License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2011-12-12 20:25:57 +04:00
|
|
|
/*
|
|
|
|
* Self tests for device tree subsystem
|
|
|
|
*/
|
|
|
|
|
2013-02-13 01:19:37 +04:00
|
|
|
#define pr_fmt(fmt) "### dt-test ### " fmt
|
2011-12-12 20:25:57 +04:00
|
|
|
|
2018-10-31 01:09:49 +03:00
|
|
|
#include <linux/memblock.h>
|
2011-12-12 20:25:57 +04:00
|
|
|
#include <linux/clk.h>
|
2020-09-17 19:43:40 +03:00
|
|
|
#include <linux/dma-direct.h> /* to test phys_to_dma/dma_to_phys */
|
2011-12-12 20:25:57 +04:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/errno.h>
|
2014-10-02 16:09:15 +04:00
|
|
|
#include <linux/hashtable.h>
|
2017-04-26 03:09:54 +03:00
|
|
|
#include <linux/libfdt.h>
|
2011-12-12 20:25:57 +04:00
|
|
|
#include <linux/of.h>
|
2019-09-20 21:28:53 +03:00
|
|
|
#include <linux/of_address.h>
|
2014-07-17 10:09:39 +04:00
|
|
|
#include <linux/of_fdt.h>
|
2013-10-12 01:04:23 +04:00
|
|
|
#include <linux/of_irq.h>
|
2014-04-24 02:57:40 +04:00
|
|
|
#include <linux/of_platform.h>
|
2011-12-12 20:25:57 +04:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/device.h>
|
2014-10-28 23:35:59 +03:00
|
|
|
#include <linux/platform_device.h>
|
2021-04-08 23:45:08 +03:00
|
|
|
#include <linux/kernel.h>
|
2011-12-12 20:25:57 +04:00
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/i2c-mux.h>
|
2020-02-20 21:40:20 +03:00
|
|
|
#include <linux/gpio/driver.h>
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2015-04-07 22:23:49 +03:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
|
2014-07-04 20:58:47 +04:00
|
|
|
#include "of_private.h"
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static struct unittest_results {
|
2013-10-12 01:04:23 +04:00
|
|
|
int passed;
|
|
|
|
int failed;
|
2015-03-11 11:36:54 +03:00
|
|
|
} unittest_results;
|
2013-10-12 01:04:23 +04:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
#define unittest(result, fmt, ...) ({ \
|
2014-11-04 16:14:13 +03:00
|
|
|
bool failed = !(result); \
|
|
|
|
if (failed) { \
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_results.failed++; \
|
2013-10-12 01:04:23 +04:00
|
|
|
pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
|
2013-02-13 01:19:37 +04:00
|
|
|
} else { \
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_results.passed++; \
|
2013-10-12 01:04:23 +04:00
|
|
|
pr_debug("pass %s():%i\n", __func__, __LINE__); \
|
2013-02-13 01:19:37 +04:00
|
|
|
} \
|
2014-11-04 16:14:13 +03:00
|
|
|
failed; \
|
|
|
|
})
|
2011-12-12 20:25:57 +04:00
|
|
|
|
2020-02-20 21:40:20 +03:00
|
|
|
/*
|
|
|
|
* Expected message may have a message level other than KERN_INFO.
|
|
|
|
* Print the expected message only if the current loglevel will allow
|
|
|
|
* the actual message to print.
|
2020-02-20 21:40:21 +03:00
|
|
|
*
|
|
|
|
* Do not use EXPECT_BEGIN() or EXPECT_END() for messages generated by
|
|
|
|
* pr_debug().
|
2020-02-20 21:40:20 +03:00
|
|
|
*/
|
|
|
|
#define EXPECT_BEGIN(level, fmt, ...) \
|
|
|
|
printk(level pr_fmt("EXPECT \\ : ") fmt, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
#define EXPECT_END(level, fmt, ...) \
|
|
|
|
printk(level pr_fmt("EXPECT / : ") fmt, ##__VA_ARGS__)
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_find_node_by_name(void)
|
2014-03-14 17:53:10 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
2017-06-01 23:50:55 +03:00
|
|
|
const char *options, *name;
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data");
|
2017-06-01 23:50:55 +03:00
|
|
|
name = kasprintf(GFP_KERNEL, "%pOF", np);
|
|
|
|
unittest(np && !strcmp("/testcase-data", name),
|
2014-03-14 17:53:10 +04:00
|
|
|
"find /testcase-data failed\n");
|
|
|
|
of_node_put(np);
|
2017-06-01 23:50:55 +03:00
|
|
|
kfree(name);
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
/* Test if trailing '/' works */
|
|
|
|
np = of_find_node_by_path("/testcase-data/");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
|
2017-06-01 23:50:55 +03:00
|
|
|
name = kasprintf(GFP_KERNEL, "%pOF", np);
|
|
|
|
unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
|
2014-03-14 17:53:10 +04:00
|
|
|
"find /testcase-data/phandle-tests/consumer-a failed\n");
|
|
|
|
of_node_put(np);
|
2017-06-01 23:50:55 +03:00
|
|
|
kfree(name);
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("testcase-alias");
|
2017-06-01 23:50:55 +03:00
|
|
|
name = kasprintf(GFP_KERNEL, "%pOF", np);
|
|
|
|
unittest(np && !strcmp("/testcase-data", name),
|
2014-03-14 17:53:10 +04:00
|
|
|
"find testcase-alias failed\n");
|
|
|
|
of_node_put(np);
|
2017-06-01 23:50:55 +03:00
|
|
|
kfree(name);
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
/* Test if trailing '/' works on aliases */
|
|
|
|
np = of_find_node_by_path("testcase-alias/");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
|
2017-06-01 23:50:55 +03:00
|
|
|
name = kasprintf(GFP_KERNEL, "%pOF", np);
|
|
|
|
unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
|
2014-03-14 17:53:10 +04:00
|
|
|
"find testcase-alias/phandle-tests/consumer-a failed\n");
|
|
|
|
of_node_put(np);
|
2017-06-01 23:50:55 +03:00
|
|
|
kfree(name);
|
2014-03-14 17:53:10 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/missing-path");
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(!np, "non-existent path returned node %pOF\n", np);
|
2014-03-14 17:53:10 +04:00
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
np = of_find_node_by_path("missing-alias");
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(!np, "non-existent alias returned node %pOF\n", np);
|
2014-03-14 17:53:10 +04:00
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
np = of_find_node_by_path("testcase-alias/missing-path");
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
|
2014-03-14 17:53:10 +04:00
|
|
|
of_node_put(np);
|
2014-11-28 14:34:28 +03:00
|
|
|
|
|
|
|
np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !strcmp("testoption", options),
|
2014-11-28 14:34:28 +03:00
|
|
|
"option path test failed\n");
|
|
|
|
of_node_put(np);
|
|
|
|
|
2015-03-06 21:59:59 +03:00
|
|
|
np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !strcmp("test/option", options),
|
2015-03-06 21:59:59 +03:00
|
|
|
"option path test, subcase #1 failed\n");
|
|
|
|
of_node_put(np);
|
|
|
|
|
2015-03-17 22:30:32 +03:00
|
|
|
np = of_find_node_opts_by_path("/testcase-data/testcase-device1:test/option", &options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !strcmp("test/option", options),
|
2015-03-17 22:30:32 +03:00
|
|
|
"option path test, subcase #2 failed\n");
|
|
|
|
of_node_put(np);
|
|
|
|
|
2014-11-28 14:34:28 +03:00
|
|
|
np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np, "NULL option path test failed\n");
|
2014-11-28 14:34:28 +03:00
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
|
|
|
|
&options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !strcmp("testaliasoption", options),
|
2014-11-28 14:34:28 +03:00
|
|
|
"option alias path test failed\n");
|
|
|
|
of_node_put(np);
|
|
|
|
|
2015-03-06 21:59:59 +03:00
|
|
|
np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
|
|
|
|
&options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !strcmp("test/alias/option", options),
|
2015-03-06 21:59:59 +03:00
|
|
|
"option alias path test, subcase #1 failed\n");
|
|
|
|
of_node_put(np);
|
|
|
|
|
2014-11-28 14:34:28 +03:00
|
|
|
np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np, "NULL option alias path test failed\n");
|
2014-11-28 14:34:28 +03:00
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
options = "testoption";
|
|
|
|
np = of_find_node_opts_by_path("testcase-alias", &options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !options, "option clearing test failed\n");
|
2014-11-28 14:34:28 +03:00
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
options = "testoption";
|
|
|
|
np = of_find_node_opts_by_path("/", &options);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(np && !options, "option clearing root node test failed\n");
|
2014-11-28 14:34:28 +03:00
|
|
|
of_node_put(np);
|
2014-03-14 17:53:10 +04:00
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_dynamic(void)
|
2013-11-15 21:19:09 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct property *prop;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Array of 4 properties for the purpose of testing */
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 00:03:40 +03:00
|
|
|
prop = kcalloc(4, sizeof(*prop), GFP_KERNEL);
|
2013-11-15 21:19:09 +04:00
|
|
|
if (!prop) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "kzalloc() failed\n");
|
2013-11-15 21:19:09 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a new property - should pass*/
|
|
|
|
prop->name = "new-property";
|
|
|
|
prop->value = "new-property-data";
|
2018-05-22 02:26:14 +03:00
|
|
|
prop->length = strlen(prop->value) + 1;
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
|
2013-11-15 21:19:09 +04:00
|
|
|
|
|
|
|
/* Try to add an existing property - should fail */
|
|
|
|
prop++;
|
|
|
|
prop->name = "new-property";
|
|
|
|
prop->value = "new-property-data-should-fail";
|
2018-05-22 02:26:14 +03:00
|
|
|
prop->length = strlen(prop->value) + 1;
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_add_property(np, prop) != 0,
|
2013-11-15 21:19:09 +04:00
|
|
|
"Adding an existing property should have failed\n");
|
|
|
|
|
|
|
|
/* Try to modify an existing property - should pass */
|
|
|
|
prop->value = "modify-property-data-should-pass";
|
2018-05-22 02:26:14 +03:00
|
|
|
prop->length = strlen(prop->value) + 1;
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_update_property(np, prop) == 0,
|
2013-11-15 21:19:09 +04:00
|
|
|
"Updating an existing property should have passed\n");
|
|
|
|
|
|
|
|
/* Try to modify non-existent property - should pass*/
|
|
|
|
prop++;
|
|
|
|
prop->name = "modify-property";
|
|
|
|
prop->value = "modify-missing-property-data-should-pass";
|
2018-05-22 02:26:14 +03:00
|
|
|
prop->length = strlen(prop->value) + 1;
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_update_property(np, prop) == 0,
|
2013-11-15 21:19:09 +04:00
|
|
|
"Updating a missing property should have passed\n");
|
|
|
|
|
|
|
|
/* Remove property - should pass */
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_remove_property(np, prop) == 0,
|
2013-11-15 21:19:09 +04:00
|
|
|
"Removing a property should have passed\n");
|
|
|
|
|
|
|
|
/* Adding very large property - should pass */
|
|
|
|
prop++;
|
|
|
|
prop->name = "large-property-PAGE_SIZEx8";
|
|
|
|
prop->length = PAGE_SIZE * 8;
|
|
|
|
prop->value = kzalloc(prop->length, GFP_KERNEL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(prop->value != NULL, "Unable to allocate large buffer\n");
|
2013-11-15 21:19:09 +04:00
|
|
|
if (prop->value)
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(of_add_property(np, prop) == 0,
|
2013-11-15 21:19:09 +04:00
|
|
|
"Adding a large property should have passed\n");
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int __init of_unittest_check_node_linkage(struct device_node *np)
|
2014-10-01 20:40:22 +04:00
|
|
|
{
|
2014-10-03 19:28:27 +04:00
|
|
|
struct device_node *child;
|
2014-10-01 20:40:22 +04:00
|
|
|
int count = 0, rc;
|
|
|
|
|
|
|
|
for_each_child_of_node(np, child) {
|
|
|
|
if (child->parent != np) {
|
2018-08-28 04:00:19 +03:00
|
|
|
pr_err("Child node %pOFn links to wrong parent %pOFn\n",
|
|
|
|
child, np);
|
2015-10-22 12:02:50 +03:00
|
|
|
rc = -EINVAL;
|
|
|
|
goto put_child;
|
2014-10-01 20:40:22 +04:00
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
rc = of_unittest_check_node_linkage(child);
|
2014-10-01 20:40:22 +04:00
|
|
|
if (rc < 0)
|
2015-10-22 12:02:50 +03:00
|
|
|
goto put_child;
|
2014-10-01 20:40:22 +04:00
|
|
|
count += rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count + 1;
|
2015-10-22 12:02:50 +03:00
|
|
|
put_child:
|
|
|
|
of_node_put(child);
|
|
|
|
return rc;
|
2014-10-01 20:40:22 +04:00
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_check_tree_linkage(void)
|
2014-10-01 20:40:22 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
int allnode_count = 0, child_count;
|
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
if (!of_root)
|
2014-10-01 20:40:22 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
for_each_of_allnodes(np)
|
|
|
|
allnode_count++;
|
2015-03-11 11:36:54 +03:00
|
|
|
child_count = of_unittest_check_node_linkage(of_root);
|
2014-10-01 20:40:22 +04:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(child_count > 0, "Device node data structure is corrupted\n");
|
2015-03-29 10:59:58 +03:00
|
|
|
unittest(child_count == allnode_count,
|
2015-03-14 09:59:01 +03:00
|
|
|
"allnodes list size (%i) doesn't match sibling lists size (%i)\n",
|
|
|
|
allnode_count, child_count);
|
2014-10-01 20:40:22 +04:00
|
|
|
pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
|
|
|
|
}
|
|
|
|
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
|
|
|
|
const char *expected)
|
|
|
|
{
|
2018-03-12 07:27:23 +03:00
|
|
|
unsigned char *buf;
|
|
|
|
int buf_size;
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
int size, i;
|
|
|
|
|
2018-03-12 07:27:23 +03:00
|
|
|
buf_size = strlen(expected) + 10;
|
|
|
|
buf = kmalloc(buf_size, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
/* Baseline; check conversion with a large size limit */
|
2018-03-12 07:27:23 +03:00
|
|
|
memset(buf, 0xff, buf_size);
|
|
|
|
size = snprintf(buf, buf_size - 2, fmt, np);
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
|
|
|
|
/* use strcmp() instead of strncmp() here to be absolutely sure strings match */
|
|
|
|
unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
|
|
|
|
"sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
|
|
|
|
fmt, expected, buf);
|
|
|
|
|
|
|
|
/* Make sure length limits work */
|
|
|
|
size++;
|
|
|
|
for (i = 0; i < 2; i++, size--) {
|
|
|
|
/* Clear the buffer, and make sure it works correctly still */
|
2018-03-12 07:27:23 +03:00
|
|
|
memset(buf, 0xff, buf_size);
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
snprintf(buf, size+1, fmt, np);
|
|
|
|
unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
|
|
|
|
"snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
|
|
|
|
size, fmt, expected, buf);
|
|
|
|
}
|
2018-03-12 07:27:23 +03:00
|
|
|
kfree(buf);
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init of_unittest_printf(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
|
|
|
|
char phandle_str[16] = "";
|
|
|
|
|
|
|
|
np = of_find_node_by_path(full_name);
|
|
|
|
if (!np) {
|
|
|
|
unittest(np, "testcase data missing\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-04-11 02:31:16 +03:00
|
|
|
num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
|
|
|
|
of_unittest_printf_one(np, "%pOF", full_name);
|
|
|
|
of_unittest_printf_one(np, "%pOFf", full_name);
|
2018-08-27 17:05:06 +03:00
|
|
|
of_unittest_printf_one(np, "%pOFn", "dev");
|
|
|
|
of_unittest_printf_one(np, "%2pOFn", "dev");
|
|
|
|
of_unittest_printf_one(np, "%5pOFn", " dev");
|
|
|
|
of_unittest_printf_one(np, "%pOFnc", "dev:test-sub-device");
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
of_unittest_printf_one(np, "%pOFp", phandle_str);
|
|
|
|
of_unittest_printf_one(np, "%pOFP", "dev@100");
|
|
|
|
of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
|
|
|
|
of_unittest_printf_one(np, "%10pOFP", " dev@100");
|
|
|
|
of_unittest_printf_one(np, "%-10pOFP", "dev@100 ");
|
|
|
|
of_unittest_printf_one(of_root, "%pOFP", "/");
|
|
|
|
of_unittest_printf_one(np, "%pOFF", "----");
|
|
|
|
of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
|
|
|
|
of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
|
|
|
|
of_unittest_printf_one(np, "%pOFc", "test-sub-device");
|
|
|
|
of_unittest_printf_one(np, "%pOFC",
|
|
|
|
"\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
|
|
|
|
}
|
|
|
|
|
2014-10-02 16:09:15 +04:00
|
|
|
struct node_hash {
|
|
|
|
struct hlist_node node;
|
|
|
|
struct device_node *np;
|
|
|
|
};
|
|
|
|
|
2014-10-07 14:30:31 +04:00
|
|
|
static DEFINE_HASHTABLE(phandle_ht, 8);
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_check_phandles(void)
|
2014-10-02 16:09:15 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct node_hash *nh;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
int i, dup_count = 0, phandle_count = 0;
|
|
|
|
|
|
|
|
for_each_of_allnodes(np) {
|
|
|
|
if (!np->phandle)
|
|
|
|
continue;
|
|
|
|
|
2014-10-07 14:30:31 +04:00
|
|
|
hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
|
2014-10-02 16:09:15 +04:00
|
|
|
if (nh->np->phandle == np->phandle) {
|
2017-06-01 23:50:55 +03:00
|
|
|
pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
|
|
|
|
np->phandle, nh->np, np);
|
2014-10-02 16:09:15 +04:00
|
|
|
dup_count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nh = kzalloc(sizeof(*nh), GFP_KERNEL);
|
2019-05-02 15:45:35 +03:00
|
|
|
if (!nh)
|
2014-10-02 16:09:15 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
nh->np = np;
|
2014-10-07 14:30:31 +04:00
|
|
|
hash_add(phandle_ht, &nh->node, np->phandle);
|
2014-10-02 16:09:15 +04:00
|
|
|
phandle_count++;
|
|
|
|
}
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
|
2014-10-02 16:09:15 +04:00
|
|
|
dup_count, phandle_count);
|
|
|
|
|
|
|
|
/* Clean up */
|
2014-10-07 14:30:31 +04:00
|
|
|
hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
|
2014-10-02 16:09:15 +04:00
|
|
|
hash_del(&nh->node);
|
|
|
|
kfree(nh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_parse_phandle_with_args(void)
|
2011-12-12 20:25:57 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct of_phandle_args args;
|
2013-02-13 01:19:37 +04:00
|
|
|
int i, rc;
|
2011-12-12 20:25:57 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-02-11 02:57:21 +04:00
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
|
2013-02-11 02:57:21 +04:00
|
|
|
|
2013-02-12 21:41:22 +04:00
|
|
|
for (i = 0; i < 8; i++) {
|
2011-12-12 20:25:57 +04:00
|
|
|
bool passed = true;
|
2015-03-14 10:02:31 +03:00
|
|
|
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2011-12-12 20:25:57 +04:00
|
|
|
rc = of_parse_phandle_with_args(np, "phandle-list",
|
|
|
|
"#phandle-cells", i, &args);
|
|
|
|
|
|
|
|
/* Test the values from tests-phandle.dtsi */
|
|
|
|
switch (i) {
|
|
|
|
case 0:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 1);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 2);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
passed &= (args.args[1] == 0);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
passed &= (rc == -ENOENT);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 3);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
passed &= (args.args[1] == 4);
|
|
|
|
passed &= (args.args[2] == 3);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 2);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
passed &= (args.args[1] == 100);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 0);
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 1);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
break;
|
|
|
|
case 7:
|
2013-02-13 01:19:37 +04:00
|
|
|
passed &= (rc == -ENOENT);
|
2011-12-12 20:25:57 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
passed = false;
|
|
|
|
}
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(passed, "index %i - data error on node %pOF rc=%i\n",
|
|
|
|
i, args.np, rc);
|
2011-12-12 20:25:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for missing list property */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2011-12-12 20:25:57 +04:00
|
|
|
rc = of_parse_phandle_with_args(np, "phandle-list-missing",
|
|
|
|
"#phandle-cells", 0, &args);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
|
2013-02-11 02:57:21 +04:00
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list-missing",
|
|
|
|
"#phandle-cells");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
|
2011-12-12 20:25:57 +04:00
|
|
|
|
|
|
|
/* Check for missing cells property */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2011-12-12 20:25:57 +04:00
|
|
|
rc = of_parse_phandle_with_args(np, "phandle-list",
|
|
|
|
"#phandle-cells-missing", 0, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2013-02-11 02:57:21 +04:00
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list",
|
|
|
|
"#phandle-cells-missing");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not get #phandle-cells-missing for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2011-12-12 20:25:57 +04:00
|
|
|
|
|
|
|
/* Check for bad phandle in list */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
|
|
|
|
|
2011-12-12 20:25:57 +04:00
|
|
|
rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
|
|
|
|
"#phandle-cells", 0, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
|
|
|
|
|
2013-02-11 02:57:21 +04:00
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
|
|
|
|
"#phandle-cells");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: could not find phandle");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2011-12-12 20:25:57 +04:00
|
|
|
|
|
|
|
/* Check for incorrectly formed argument list */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
|
|
|
|
|
2011-12-12 20:25:57 +04:00
|
|
|
rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
|
|
|
|
"#phandle-cells", 1, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
|
|
|
|
|
2013-02-11 02:57:21 +04:00
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
|
|
|
|
"#phandle-cells");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-a: #phandle-cells = 3 found -1");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
2011-12-12 20:25:57 +04:00
|
|
|
}
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
static void __init of_unittest_parse_phandle_with_args_map(void)
|
|
|
|
{
|
|
|
|
struct device_node *np, *p0, *p1, *p2, *p3;
|
|
|
|
struct of_phandle_args args;
|
|
|
|
int i, rc;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-b");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
p0 = of_find_node_by_path("/testcase-data/phandle-tests/provider0");
|
|
|
|
if (!p0) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
p1 = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
|
|
|
|
if (!p1) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
p2 = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
|
|
|
|
if (!p2) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
p3 = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
|
|
|
|
if (!p3) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
|
|
|
|
unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
|
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
bool passed = true;
|
|
|
|
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2018-01-31 05:36:17 +03:00
|
|
|
rc = of_parse_phandle_with_args_map(np, "phandle-list",
|
|
|
|
"phandle", i, &args);
|
|
|
|
|
|
|
|
/* Test the values from tests-phandle.dtsi */
|
|
|
|
switch (i) {
|
|
|
|
case 0:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p1);
|
|
|
|
passed &= (args.args_count == 1);
|
|
|
|
passed &= (args.args[0] == 1);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p3);
|
|
|
|
passed &= (args.args_count == 3);
|
|
|
|
passed &= (args.args[0] == 2);
|
|
|
|
passed &= (args.args[1] == 5);
|
|
|
|
passed &= (args.args[2] == 3);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
passed &= (rc == -ENOENT);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p0);
|
|
|
|
passed &= (args.args_count == 0);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p1);
|
|
|
|
passed &= (args.args_count == 1);
|
|
|
|
passed &= (args.args[0] == 3);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p0);
|
|
|
|
passed &= (args.args_count == 0);
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.np == p2);
|
|
|
|
passed &= (args.args_count == 2);
|
|
|
|
passed &= (args.args[0] == 15);
|
|
|
|
passed &= (args.args[1] == 0x20);
|
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
passed &= (rc == -ENOENT);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
passed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
unittest(passed, "index %i - data error on node %s rc=%i\n",
|
|
|
|
i, args.np->full_name, rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for missing list property */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2018-01-31 05:36:17 +03:00
|
|
|
rc = of_parse_phandle_with_args_map(np, "phandle-list-missing",
|
|
|
|
"phandle", 0, &args);
|
|
|
|
unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
|
|
|
|
|
|
|
|
/* Check for missing cells,map,mask property */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
rc = of_parse_phandle_with_args_map(np, "phandle-list",
|
|
|
|
"phandle-missing", 0, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: could not get #phandle-missing-cells for /testcase-data/phandle-tests/provider1");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
|
|
|
|
|
|
|
/* Check for bad phandle in list */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: could not find phandle");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-phandle",
|
|
|
|
"phandle", 0, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: could not find phandle");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
|
|
|
|
|
|
|
/* Check for incorrectly formed argument list */
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
|
|
|
|
"phandle", 1, &args);
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: /testcase-data/phandle-tests/consumer-b: #phandle-cells = 2 found -1");
|
|
|
|
|
2018-01-31 05:36:17 +03:00
|
|
|
unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_property_string(void)
|
2011-12-12 20:25:58 +04:00
|
|
|
{
|
2014-11-03 18:15:35 +03:00
|
|
|
const char *strings[4];
|
2011-12-12 20:25:58 +04:00
|
|
|
struct device_node *np;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("No testcase data in device tree\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = of_property_match_string(np, "phandle-list-names", "first");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0, "first expected:0 got:%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "phandle-list-names", "second");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 1, "second expected:1 got:%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "phandle-list-names", "third");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 2, "third expected:2 got:%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "phandle-list-names", "fourth");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "missing-property", "blah");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "empty-property", "blah");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
|
2011-12-12 20:25:58 +04:00
|
|
|
rc = of_property_match_string(np, "unterminated-string", "blah");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
|
|
|
|
/* of_property_count_strings() tests */
|
|
|
|
rc = of_property_count_strings(np, "string-property");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_count_strings(np, "phandle-list-names");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_count_strings(np, "unterminated-string");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_count_strings(np, "unterminated-string-list");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
|
|
|
|
/* of_property_read_string_index() tests */
|
|
|
|
rc = of_property_read_string_index(np, "string-property", 0, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[0] = NULL;
|
|
|
|
rc = of_property_read_string_index(np, "string-property", 1, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[0] = NULL;
|
|
|
|
rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[0] = NULL;
|
|
|
|
rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[0] = NULL;
|
|
|
|
rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[1] = NULL;
|
|
|
|
|
|
|
|
/* of_property_read_string_array() tests */
|
|
|
|
rc = of_property_read_string_array(np, "string-property", strings, 4);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
/* -- An incorrectly formed string should cause a failure */
|
|
|
|
rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
/* -- parsing the correctly formed strings should still work: */
|
|
|
|
strings[2] = NULL;
|
|
|
|
rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
|
2014-11-03 18:15:35 +03:00
|
|
|
strings[1] = NULL;
|
|
|
|
rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
|
2011-12-12 20:25:58 +04:00
|
|
|
}
|
|
|
|
|
2014-07-04 20:58:47 +04:00
|
|
|
#define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
|
|
|
|
(p1)->value && (p2)->value && \
|
|
|
|
!memcmp((p1)->value, (p2)->value, (p1)->length) && \
|
|
|
|
!strcmp((p1)->name, (p2)->name))
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_property_copy(void)
|
2014-07-04 20:58:47 +04:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_OF_DYNAMIC
|
|
|
|
struct property p1 = { .name = "p1", .length = 0, .value = "" };
|
|
|
|
struct property p2 = { .name = "p2", .length = 5, .value = "abcd" };
|
|
|
|
struct property *new;
|
|
|
|
|
|
|
|
new = __of_prop_dup(&p1, GFP_KERNEL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
|
2014-07-04 20:58:47 +04:00
|
|
|
kfree(new->value);
|
|
|
|
kfree(new->name);
|
|
|
|
kfree(new);
|
|
|
|
|
|
|
|
new = __of_prop_dup(&p2, GFP_KERNEL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
|
2014-07-04 20:58:47 +04:00
|
|
|
kfree(new->value);
|
|
|
|
kfree(new->name);
|
|
|
|
kfree(new);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_changeset(void)
|
2014-07-04 20:58:49 +04:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_OF_DYNAMIC
|
2018-02-27 01:01:22 +03:00
|
|
|
struct property *ppadd, padd = { .name = "prop-add", .length = 1, .value = "" };
|
|
|
|
struct property *ppname_n1, pname_n1 = { .name = "name", .length = 3, .value = "n1" };
|
|
|
|
struct property *ppname_n2, pname_n2 = { .name = "name", .length = 3, .value = "n2" };
|
|
|
|
struct property *ppname_n21, pname_n21 = { .name = "name", .length = 3, .value = "n21" };
|
2014-07-04 20:58:49 +04:00
|
|
|
struct property *ppupdate, pupdate = { .name = "prop-update", .length = 5, .value = "abcd" };
|
|
|
|
struct property *ppremove;
|
2018-02-27 01:01:22 +03:00
|
|
|
struct device_node *n1, *n2, *n21, *nchangeset, *nremove, *parent, *np;
|
2014-07-04 20:58:49 +04:00
|
|
|
struct of_changeset chgset;
|
|
|
|
|
2018-02-27 01:01:23 +03:00
|
|
|
n1 = __of_node_dup(NULL, "n1");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(n1, "testcase setup failure\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2018-02-27 01:01:23 +03:00
|
|
|
n2 = __of_node_dup(NULL, "n2");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(n2, "testcase setup failure\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2018-02-27 01:01:23 +03:00
|
|
|
n21 = __of_node_dup(NULL, "n21");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(n21, "testcase setup failure %p\n", n21);
|
2018-02-27 01:01:22 +03:00
|
|
|
|
|
|
|
nchangeset = of_find_node_by_path("/testcase-data/changeset");
|
|
|
|
nremove = of_get_child_by_name(nchangeset, "node-remove");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(nremove, "testcase setup failure\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2014-07-04 20:58:49 +04:00
|
|
|
ppadd = __of_prop_dup(&padd, GFP_KERNEL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(ppadd, "testcase setup failure\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
|
|
|
ppname_n1 = __of_prop_dup(&pname_n1, GFP_KERNEL);
|
|
|
|
unittest(ppname_n1, "testcase setup failure\n");
|
|
|
|
|
|
|
|
ppname_n2 = __of_prop_dup(&pname_n2, GFP_KERNEL);
|
|
|
|
unittest(ppname_n2, "testcase setup failure\n");
|
|
|
|
|
|
|
|
ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
|
|
|
|
unittest(ppname_n21, "testcase setup failure\n");
|
|
|
|
|
2014-07-04 20:58:49 +04:00
|
|
|
ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(ppupdate, "testcase setup failure\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
|
|
|
parent = nchangeset;
|
2014-07-04 20:58:49 +04:00
|
|
|
n1->parent = parent;
|
|
|
|
n2->parent = parent;
|
|
|
|
n21->parent = n2;
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2014-07-04 20:58:49 +04:00
|
|
|
ppremove = of_find_property(parent, "prop-remove", NULL);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(ppremove, "failed to find removal prop");
|
2014-07-04 20:58:49 +04:00
|
|
|
|
|
|
|
of_changeset_init(&chgset);
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
unittest(!of_changeset_add_property(&chgset, n1, ppname_n1), "fail add prop name\n");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
unittest(!of_changeset_add_property(&chgset, n2, ppname_n2), "fail add prop name\n");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
unittest(!of_changeset_add_property(&chgset, n21, ppname_n21), "fail add prop name\n");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
|
|
|
unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop prop-add\n");
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
|
|
|
|
unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
|
2018-02-27 01:01:22 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_apply(&chgset), "apply failed\n");
|
2014-07-04 20:58:49 +04:00
|
|
|
|
2018-02-27 01:01:22 +03:00
|
|
|
of_node_put(nchangeset);
|
|
|
|
|
2014-11-18 01:31:32 +03:00
|
|
|
/* Make sure node names are constructed correctly */
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
|
2017-06-01 23:50:55 +03:00
|
|
|
"'%pOF' not added\n", n21);
|
2014-12-02 15:54:00 +03:00
|
|
|
of_node_put(np);
|
2014-11-18 01:31:32 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_changeset_revert(&chgset), "revert failed\n");
|
2014-07-04 20:58:49 +04:00
|
|
|
|
|
|
|
of_changeset_destroy(&chgset);
|
2020-04-17 00:42:46 +03:00
|
|
|
|
|
|
|
of_node_put(n1);
|
|
|
|
of_node_put(n2);
|
|
|
|
of_node_put(n21);
|
2014-07-04 20:58:49 +04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2020-11-19 20:53:56 +03:00
|
|
|
static void __init of_unittest_dma_get_max_cpu_address(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
phys_addr_t cpu_addr;
|
|
|
|
|
2020-12-01 15:47:25 +03:00
|
|
|
if (!IS_ENABLED(CONFIG_OF_ADDRESS))
|
|
|
|
return;
|
|
|
|
|
2020-11-19 20:53:56 +03:00
|
|
|
np = of_find_node_by_path("/testcase-data/address-tests");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu_addr = of_dma_get_max_cpu_address(np);
|
|
|
|
unittest(cpu_addr == 0x4fffffff,
|
|
|
|
"of_dma_get_max_cpu_address: wrong CPU addr %pad (expecting %x)\n",
|
|
|
|
&cpu_addr, 0x4fffffff);
|
|
|
|
}
|
|
|
|
|
2019-09-20 21:28:53 +03:00
|
|
|
static void __init of_unittest_dma_ranges_one(const char *path,
|
2020-09-17 19:43:40 +03:00
|
|
|
u64 expect_dma_addr, u64 expect_paddr)
|
2019-09-20 21:28:53 +03:00
|
|
|
{
|
2020-09-17 19:43:40 +03:00
|
|
|
#ifdef CONFIG_HAS_DMA
|
2019-09-20 21:28:53 +03:00
|
|
|
struct device_node *np;
|
2020-09-17 19:43:40 +03:00
|
|
|
const struct bus_dma_region *map = NULL;
|
2019-09-20 21:28:53 +03:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
np = of_find_node_by_path(path);
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-17 19:43:40 +03:00
|
|
|
rc = of_dma_get_range(np, &map);
|
2019-09-20 21:28:53 +03:00
|
|
|
|
|
|
|
unittest(!rc, "of_dma_get_range failed on node %pOF rc=%i\n", np, rc);
|
2020-09-17 19:43:40 +03:00
|
|
|
|
2019-09-20 21:28:53 +03:00
|
|
|
if (!rc) {
|
2020-09-17 19:43:40 +03:00
|
|
|
phys_addr_t paddr;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
struct device dev_bogus;
|
|
|
|
|
|
|
|
dev_bogus.dma_range_map = map;
|
|
|
|
paddr = dma_to_phys(&dev_bogus, expect_dma_addr);
|
|
|
|
dma_addr = phys_to_dma(&dev_bogus, expect_paddr);
|
|
|
|
|
2019-09-20 21:28:53 +03:00
|
|
|
unittest(paddr == expect_paddr,
|
2020-09-17 19:43:40 +03:00
|
|
|
"of_dma_get_range: wrong phys addr %pap (expecting %llx) on node %pOF\n",
|
|
|
|
&paddr, expect_paddr, np);
|
2019-09-20 21:28:53 +03:00
|
|
|
unittest(dma_addr == expect_dma_addr,
|
2020-09-17 19:43:40 +03:00
|
|
|
"of_dma_get_range: wrong DMA addr %pad (expecting %llx) on node %pOF\n",
|
|
|
|
&dma_addr, expect_dma_addr, np);
|
|
|
|
|
|
|
|
kfree(map);
|
2019-09-20 21:28:53 +03:00
|
|
|
}
|
|
|
|
of_node_put(np);
|
2020-09-17 19:43:40 +03:00
|
|
|
#endif
|
2019-09-20 21:28:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init of_unittest_parse_dma_ranges(void)
|
|
|
|
{
|
|
|
|
of_unittest_dma_ranges_one("/testcase-data/address-tests/device@70000000",
|
2020-09-17 19:43:40 +03:00
|
|
|
0x0, 0x20000000);
|
2019-09-20 21:28:53 +03:00
|
|
|
of_unittest_dma_ranges_one("/testcase-data/address-tests/bus@80000000/device@1000",
|
2020-09-17 19:43:40 +03:00
|
|
|
0x100000000, 0x20000000);
|
2019-09-20 21:28:53 +03:00
|
|
|
of_unittest_dma_ranges_one("/testcase-data/address-tests/pci@90000000",
|
2020-09-17 19:43:40 +03:00
|
|
|
0x80000000, 0x20000000);
|
2019-09-20 21:28:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init of_unittest_pci_dma_ranges(void)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct of_pci_range range;
|
|
|
|
struct of_pci_range_parser parser;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_PCI))
|
|
|
|
return;
|
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/address-tests/pci@90000000");
|
|
|
|
if (!np) {
|
|
|
|
pr_err("missing testcase data\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (of_pci_dma_range_parser_init(&parser, np)) {
|
|
|
|
pr_err("missing dma-ranges property\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the dma-ranges from the device tree
|
|
|
|
*/
|
|
|
|
for_each_of_pci_range(&parser, &range) {
|
|
|
|
if (!i) {
|
|
|
|
unittest(range.size == 0x10000000,
|
|
|
|
"for_each_of_pci_range wrong size on node %pOF size=%llx\n",
|
|
|
|
np, range.size);
|
|
|
|
unittest(range.cpu_addr == 0x20000000,
|
|
|
|
"for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
|
|
|
|
range.cpu_addr, np);
|
|
|
|
unittest(range.pci_addr == 0x80000000,
|
|
|
|
"for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
|
|
|
|
range.pci_addr, np);
|
|
|
|
} else {
|
|
|
|
unittest(range.size == 0x10000000,
|
|
|
|
"for_each_of_pci_range wrong size on node %pOF size=%llx\n",
|
|
|
|
np, range.size);
|
|
|
|
unittest(range.cpu_addr == 0x40000000,
|
|
|
|
"for_each_of_pci_range wrong CPU addr (%llx) on node %pOF",
|
|
|
|
range.cpu_addr, np);
|
|
|
|
unittest(range.pci_addr == 0xc0000000,
|
|
|
|
"for_each_of_pci_range wrong DMA addr (%llx) on node %pOF",
|
|
|
|
range.pci_addr, np);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_parse_interrupts(void)
|
2013-10-12 01:04:23 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct of_phandle_args args;
|
|
|
|
int i, rc;
|
|
|
|
|
of: unittest: Disable interrupt node tests for old world MAC systems
On systems with OF_IMAP_OLDWORLD_MAC set in of_irq_workarounds, the
devicetree interrupt parsing code is different, causing unit tests of
devicetree interrupt nodes to fail. Due to a bug in unittest code, which
tries to dereference an uninitialized pointer, this results in a crash.
OF: /testcase-data/phandle-tests/consumer-a: arguments longer than property
Unable to handle kernel paging request for data at address 0x00bc616e
Faulting instruction address: 0xc08e9468
Oops: Kernel access of bad area, sig: 11 [#1]
BE PREEMPT PowerMac
Modules linked in:
CPU: 0 PID: 1 Comm: swapper Not tainted 4.14.72-rc1-yocto-standard+ #1
task: cf8e0000 task.stack: cf8da000
NIP: c08e9468 LR: c08ea5bc CTR: c08ea5ac
REGS: cf8dbb50 TRAP: 0300 Not tainted (4.14.72-rc1-yocto-standard+)
MSR: 00001032 <ME,IR,DR,RI> CR: 82004044 XER: 00000000
DAR: 00bc616e DSISR: 40000000
GPR00: c08ea5bc cf8dbc00 cf8e0000 c13ca517 c13ca517 c13ca8a0 00000066 00000002
GPR08: 00000063 00bc614e c0b05865 000affff 82004048 00000000 c00047f0 00000000
GPR16: c0a80000 c0a9cc34 c13ca517 c0ad1134 05ffffff 000affff c0b05860 c0abeef8
GPR24: cecec278 cecec278 c0a8c4d0 c0a885e0 c13ca8a0 05ffffff c13ca8a0 c13ca517
NIP [c08e9468] device_node_gen_full_name+0x30/0x15c
LR [c08ea5bc] device_node_string+0x190/0x3c8
Call Trace:
[cf8dbc00] [c007f670] trace_hardirqs_on_caller+0x118/0x1fc (unreliable)
[cf8dbc40] [c08ea5bc] device_node_string+0x190/0x3c8
[cf8dbcb0] [c08eb794] pointer+0x25c/0x4d0
[cf8dbd00] [c08ebcbc] vsnprintf+0x2b4/0x5ec
[cf8dbd60] [c08ec00c] vscnprintf+0x18/0x48
[cf8dbd70] [c008e268] vprintk_store+0x4c/0x22c
[cf8dbda0] [c008ecac] vprintk_emit+0x94/0x130
[cf8dbdd0] [c008ff54] printk+0x5c/0x6c
[cf8dbe10] [c0b8ddd4] of_unittest+0x2220/0x26f8
[cf8dbea0] [c0004434] do_one_initcall+0x4c/0x184
[cf8dbf00] [c0b4534c] kernel_init_freeable+0x13c/0x1d8
[cf8dbf30] [c0004814] kernel_init+0x24/0x118
[cf8dbf40] [c0013398] ret_from_kernel_thread+0x5c/0x64
The problem was observed when running a qemu test for the g3beige machine
with devicetree unittests enabled.
Disable interrupt node tests on affected systems to avoid both false
unittest failures and the crash.
With this patch in place, unittest on the affected system passes with
the following message.
dt-test ### end of unittest - 144 passed, 0 failed
Fixes: 53a42093d96ef ("of: Add device tree selftests")
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2018-09-26 07:06:24 +03:00
|
|
|
if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
|
|
|
|
return;
|
|
|
|
|
2013-10-12 01:04:23 +04:00
|
|
|
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;
|
2015-03-14 10:02:31 +03:00
|
|
|
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2013-10-12 01:04:23 +04:00
|
|
|
rc = of_irq_parse_one(np, i, &args);
|
|
|
|
|
|
|
|
passed &= !rc;
|
|
|
|
passed &= (args.args_count == 1);
|
|
|
|
passed &= (args.args[0] == (i + 1));
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(passed, "index %i - data error on node %pOF rc=%i\n",
|
|
|
|
i, args.np, rc);
|
2013-10-12 01:04:23 +04:00
|
|
|
}
|
|
|
|
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;
|
2015-03-14 10:02:31 +03:00
|
|
|
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2013-10-12 01:04:23 +04:00
|
|
|
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;
|
|
|
|
}
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(passed, "index %i - data error on node %pOF rc=%i\n",
|
|
|
|
i, args.np, rc);
|
2013-10-12 01:04:23 +04:00
|
|
|
}
|
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_parse_interrupts_extended(void)
|
2013-09-20 01:47:37 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct of_phandle_args args;
|
|
|
|
int i, rc;
|
|
|
|
|
of: unittest: Disable interrupt node tests for old world MAC systems
On systems with OF_IMAP_OLDWORLD_MAC set in of_irq_workarounds, the
devicetree interrupt parsing code is different, causing unit tests of
devicetree interrupt nodes to fail. Due to a bug in unittest code, which
tries to dereference an uninitialized pointer, this results in a crash.
OF: /testcase-data/phandle-tests/consumer-a: arguments longer than property
Unable to handle kernel paging request for data at address 0x00bc616e
Faulting instruction address: 0xc08e9468
Oops: Kernel access of bad area, sig: 11 [#1]
BE PREEMPT PowerMac
Modules linked in:
CPU: 0 PID: 1 Comm: swapper Not tainted 4.14.72-rc1-yocto-standard+ #1
task: cf8e0000 task.stack: cf8da000
NIP: c08e9468 LR: c08ea5bc CTR: c08ea5ac
REGS: cf8dbb50 TRAP: 0300 Not tainted (4.14.72-rc1-yocto-standard+)
MSR: 00001032 <ME,IR,DR,RI> CR: 82004044 XER: 00000000
DAR: 00bc616e DSISR: 40000000
GPR00: c08ea5bc cf8dbc00 cf8e0000 c13ca517 c13ca517 c13ca8a0 00000066 00000002
GPR08: 00000063 00bc614e c0b05865 000affff 82004048 00000000 c00047f0 00000000
GPR16: c0a80000 c0a9cc34 c13ca517 c0ad1134 05ffffff 000affff c0b05860 c0abeef8
GPR24: cecec278 cecec278 c0a8c4d0 c0a885e0 c13ca8a0 05ffffff c13ca8a0 c13ca517
NIP [c08e9468] device_node_gen_full_name+0x30/0x15c
LR [c08ea5bc] device_node_string+0x190/0x3c8
Call Trace:
[cf8dbc00] [c007f670] trace_hardirqs_on_caller+0x118/0x1fc (unreliable)
[cf8dbc40] [c08ea5bc] device_node_string+0x190/0x3c8
[cf8dbcb0] [c08eb794] pointer+0x25c/0x4d0
[cf8dbd00] [c08ebcbc] vsnprintf+0x2b4/0x5ec
[cf8dbd60] [c08ec00c] vscnprintf+0x18/0x48
[cf8dbd70] [c008e268] vprintk_store+0x4c/0x22c
[cf8dbda0] [c008ecac] vprintk_emit+0x94/0x130
[cf8dbdd0] [c008ff54] printk+0x5c/0x6c
[cf8dbe10] [c0b8ddd4] of_unittest+0x2220/0x26f8
[cf8dbea0] [c0004434] do_one_initcall+0x4c/0x184
[cf8dbf00] [c0b4534c] kernel_init_freeable+0x13c/0x1d8
[cf8dbf30] [c0004814] kernel_init+0x24/0x118
[cf8dbf40] [c0013398] ret_from_kernel_thread+0x5c/0x64
The problem was observed when running a qemu test for the g3beige machine
with devicetree unittests enabled.
Disable interrupt node tests on affected systems to avoid both false
unittest failures and the crash.
With this patch in place, unittest on the affected system passes with
the following message.
dt-test ### end of unittest - 144 passed, 0 failed
Fixes: 53a42093d96ef ("of: Add device tree selftests")
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2018-09-26 07:06:24 +03:00
|
|
|
if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
|
|
|
|
return;
|
|
|
|
|
2013-09-20 01:47:37 +04:00
|
|
|
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;
|
2015-03-14 10:02:31 +03:00
|
|
|
|
2018-10-05 06:40:21 +03:00
|
|
|
memset(&args, 0, sizeof(args));
|
2013-09-20 01:47:37 +04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
unittest(passed, "index %i - data error on node %pOF rc=%i\n",
|
|
|
|
i, args.np, rc);
|
2013-09-20 01:47:37 +04:00
|
|
|
}
|
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
2015-03-14 10:00:36 +03:00
|
|
|
static const struct of_device_id match_node_table[] = {
|
2014-02-19 01:38:55 +04:00
|
|
|
{ .data = "A", .name = "name0", }, /* Name alone is lowest priority */
|
|
|
|
{ .data = "B", .type = "type1", }, /* followed by type alone */
|
|
|
|
|
|
|
|
{ .data = "Ca", .name = "name2", .type = "type1", }, /* followed by both together */
|
|
|
|
{ .data = "Cb", .name = "name2", }, /* Only match when type doesn't match */
|
|
|
|
{ .data = "Cc", .name = "name2", .type = "type2", },
|
|
|
|
|
|
|
|
{ .data = "E", .compatible = "compat3" },
|
|
|
|
{ .data = "G", .compatible = "compat2", },
|
|
|
|
{ .data = "H", .compatible = "compat2", .name = "name5", },
|
|
|
|
{ .data = "I", .compatible = "compat2", .type = "type1", },
|
|
|
|
{ .data = "J", .compatible = "compat2", .type = "type1", .name = "name8", },
|
|
|
|
{ .data = "K", .compatible = "compat2", .name = "name9", },
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
const char *path;
|
|
|
|
const char *data;
|
|
|
|
} match_node_tests[] = {
|
|
|
|
{ .path = "/testcase-data/match-node/name0", .data = "A", },
|
|
|
|
{ .path = "/testcase-data/match-node/name1", .data = "B", },
|
|
|
|
{ .path = "/testcase-data/match-node/a/name2", .data = "Ca", },
|
|
|
|
{ .path = "/testcase-data/match-node/b/name2", .data = "Cb", },
|
|
|
|
{ .path = "/testcase-data/match-node/c/name2", .data = "Cc", },
|
|
|
|
{ .path = "/testcase-data/match-node/name3", .data = "E", },
|
|
|
|
{ .path = "/testcase-data/match-node/name4", .data = "G", },
|
|
|
|
{ .path = "/testcase-data/match-node/name5", .data = "H", },
|
|
|
|
{ .path = "/testcase-data/match-node/name6", .data = "G", },
|
|
|
|
{ .path = "/testcase-data/match-node/name7", .data = "I", },
|
|
|
|
{ .path = "/testcase-data/match-node/name8", .data = "J", },
|
|
|
|
{ .path = "/testcase-data/match-node/name9", .data = "K", },
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_match_node(void)
|
2014-02-19 01:38:55 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
const struct of_device_id *match;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
|
|
|
|
np = of_find_node_by_path(match_node_tests[i].path);
|
|
|
|
if (!np) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "missing testcase node %s\n",
|
2014-02-19 01:38:55 +04:00
|
|
|
match_node_tests[i].path);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
match = of_match_node(match_node_table, np);
|
|
|
|
if (!match) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "%s didn't match anything\n",
|
2014-02-19 01:38:55 +04:00
|
|
|
match_node_tests[i].path);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(match->data, match_node_tests[i].data) != 0) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "%s got wrong match. expected %s, got %s\n",
|
2014-02-19 01:38:55 +04:00
|
|
|
match_node_tests[i].path, match_node_tests[i].data,
|
|
|
|
(const char *)match->data);
|
|
|
|
continue;
|
|
|
|
}
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "passed");
|
2014-02-19 01:38:55 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-01 09:22:23 +03:00
|
|
|
static struct resource test_bus_res = DEFINE_RES_MEM(0xfffffff8, 2);
|
2015-03-28 06:30:04 +03:00
|
|
|
static const struct platform_device_info test_bus_info = {
|
|
|
|
.name = "unittest-bus",
|
2014-11-04 16:14:13 +03:00
|
|
|
};
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_platform_populate(void)
|
2014-04-24 02:57:40 +04:00
|
|
|
{
|
2014-11-04 16:14:13 +03:00
|
|
|
int irq, rc;
|
|
|
|
struct device_node *np, *child, *grandchild;
|
2015-03-28 06:30:04 +03:00
|
|
|
struct platform_device *pdev, *test_bus;
|
2015-03-14 10:00:36 +03:00
|
|
|
const struct of_device_id match[] = {
|
2014-05-13 19:07:54 +04:00
|
|
|
{ .compatible = "test-device", },
|
|
|
|
{}
|
|
|
|
};
|
2014-04-24 02:57:40 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data");
|
2016-06-01 09:53:10 +03:00
|
|
|
of_platform_default_populate(np, NULL, NULL);
|
2014-04-24 02:57:40 +04:00
|
|
|
|
|
|
|
/* Test that a missing irq domain returns -EPROBE_DEFER */
|
|
|
|
np = of_find_node_by_path("/testcase-data/testcase-device1");
|
|
|
|
pdev = of_find_device_by_node(np);
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(pdev, "device 1 creation failed\n");
|
2014-05-13 19:07:29 +04:00
|
|
|
|
of: unittest: Disable interrupt node tests for old world MAC systems
On systems with OF_IMAP_OLDWORLD_MAC set in of_irq_workarounds, the
devicetree interrupt parsing code is different, causing unit tests of
devicetree interrupt nodes to fail. Due to a bug in unittest code, which
tries to dereference an uninitialized pointer, this results in a crash.
OF: /testcase-data/phandle-tests/consumer-a: arguments longer than property
Unable to handle kernel paging request for data at address 0x00bc616e
Faulting instruction address: 0xc08e9468
Oops: Kernel access of bad area, sig: 11 [#1]
BE PREEMPT PowerMac
Modules linked in:
CPU: 0 PID: 1 Comm: swapper Not tainted 4.14.72-rc1-yocto-standard+ #1
task: cf8e0000 task.stack: cf8da000
NIP: c08e9468 LR: c08ea5bc CTR: c08ea5ac
REGS: cf8dbb50 TRAP: 0300 Not tainted (4.14.72-rc1-yocto-standard+)
MSR: 00001032 <ME,IR,DR,RI> CR: 82004044 XER: 00000000
DAR: 00bc616e DSISR: 40000000
GPR00: c08ea5bc cf8dbc00 cf8e0000 c13ca517 c13ca517 c13ca8a0 00000066 00000002
GPR08: 00000063 00bc614e c0b05865 000affff 82004048 00000000 c00047f0 00000000
GPR16: c0a80000 c0a9cc34 c13ca517 c0ad1134 05ffffff 000affff c0b05860 c0abeef8
GPR24: cecec278 cecec278 c0a8c4d0 c0a885e0 c13ca8a0 05ffffff c13ca8a0 c13ca517
NIP [c08e9468] device_node_gen_full_name+0x30/0x15c
LR [c08ea5bc] device_node_string+0x190/0x3c8
Call Trace:
[cf8dbc00] [c007f670] trace_hardirqs_on_caller+0x118/0x1fc (unreliable)
[cf8dbc40] [c08ea5bc] device_node_string+0x190/0x3c8
[cf8dbcb0] [c08eb794] pointer+0x25c/0x4d0
[cf8dbd00] [c08ebcbc] vsnprintf+0x2b4/0x5ec
[cf8dbd60] [c08ec00c] vscnprintf+0x18/0x48
[cf8dbd70] [c008e268] vprintk_store+0x4c/0x22c
[cf8dbda0] [c008ecac] vprintk_emit+0x94/0x130
[cf8dbdd0] [c008ff54] printk+0x5c/0x6c
[cf8dbe10] [c0b8ddd4] of_unittest+0x2220/0x26f8
[cf8dbea0] [c0004434] do_one_initcall+0x4c/0x184
[cf8dbf00] [c0b4534c] kernel_init_freeable+0x13c/0x1d8
[cf8dbf30] [c0004814] kernel_init+0x24/0x118
[cf8dbf40] [c0013398] ret_from_kernel_thread+0x5c/0x64
The problem was observed when running a qemu test for the g3beige machine
with devicetree unittests enabled.
Disable interrupt node tests on affected systems to avoid both false
unittest failures and the crash.
With this patch in place, unittest on the affected system passes with
the following message.
dt-test ### end of unittest - 144 passed, 0 failed
Fixes: 53a42093d96ef ("of: Add device tree selftests")
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2018-09-26 07:06:24 +03:00
|
|
|
if (!(of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)) {
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
unittest(irq == -EPROBE_DEFER,
|
|
|
|
"device deferred probe failed - %d\n", irq);
|
|
|
|
|
|
|
|
/* Test that a parsing failure does not return -EPROBE_DEFER */
|
|
|
|
np = of_find_node_by_path("/testcase-data/testcase-device2");
|
|
|
|
pdev = of_find_device_by_node(np);
|
|
|
|
unittest(pdev, "device 2 creation failed\n");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"platform testcase-data:testcase-device2: IRQ index 0 not found");
|
|
|
|
|
of: unittest: Disable interrupt node tests for old world MAC systems
On systems with OF_IMAP_OLDWORLD_MAC set in of_irq_workarounds, the
devicetree interrupt parsing code is different, causing unit tests of
devicetree interrupt nodes to fail. Due to a bug in unittest code, which
tries to dereference an uninitialized pointer, this results in a crash.
OF: /testcase-data/phandle-tests/consumer-a: arguments longer than property
Unable to handle kernel paging request for data at address 0x00bc616e
Faulting instruction address: 0xc08e9468
Oops: Kernel access of bad area, sig: 11 [#1]
BE PREEMPT PowerMac
Modules linked in:
CPU: 0 PID: 1 Comm: swapper Not tainted 4.14.72-rc1-yocto-standard+ #1
task: cf8e0000 task.stack: cf8da000
NIP: c08e9468 LR: c08ea5bc CTR: c08ea5ac
REGS: cf8dbb50 TRAP: 0300 Not tainted (4.14.72-rc1-yocto-standard+)
MSR: 00001032 <ME,IR,DR,RI> CR: 82004044 XER: 00000000
DAR: 00bc616e DSISR: 40000000
GPR00: c08ea5bc cf8dbc00 cf8e0000 c13ca517 c13ca517 c13ca8a0 00000066 00000002
GPR08: 00000063 00bc614e c0b05865 000affff 82004048 00000000 c00047f0 00000000
GPR16: c0a80000 c0a9cc34 c13ca517 c0ad1134 05ffffff 000affff c0b05860 c0abeef8
GPR24: cecec278 cecec278 c0a8c4d0 c0a885e0 c13ca8a0 05ffffff c13ca8a0 c13ca517
NIP [c08e9468] device_node_gen_full_name+0x30/0x15c
LR [c08ea5bc] device_node_string+0x190/0x3c8
Call Trace:
[cf8dbc00] [c007f670] trace_hardirqs_on_caller+0x118/0x1fc (unreliable)
[cf8dbc40] [c08ea5bc] device_node_string+0x190/0x3c8
[cf8dbcb0] [c08eb794] pointer+0x25c/0x4d0
[cf8dbd00] [c08ebcbc] vsnprintf+0x2b4/0x5ec
[cf8dbd60] [c08ec00c] vscnprintf+0x18/0x48
[cf8dbd70] [c008e268] vprintk_store+0x4c/0x22c
[cf8dbda0] [c008ecac] vprintk_emit+0x94/0x130
[cf8dbdd0] [c008ff54] printk+0x5c/0x6c
[cf8dbe10] [c0b8ddd4] of_unittest+0x2220/0x26f8
[cf8dbea0] [c0004434] do_one_initcall+0x4c/0x184
[cf8dbf00] [c0b4534c] kernel_init_freeable+0x13c/0x1d8
[cf8dbf30] [c0004814] kernel_init+0x24/0x118
[cf8dbf40] [c0013398] ret_from_kernel_thread+0x5c/0x64
The problem was observed when running a qemu test for the g3beige machine
with devicetree unittests enabled.
Disable interrupt node tests on affected systems to avoid both false
unittest failures and the crash.
With this patch in place, unittest on the affected system passes with
the following message.
dt-test ### end of unittest - 144 passed, 0 failed
Fixes: 53a42093d96ef ("of: Add device tree selftests")
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2018-09-26 07:06:24 +03:00
|
|
|
irq = platform_get_irq(pdev, 0);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"platform testcase-data:testcase-device2: IRQ index 0 not found");
|
|
|
|
|
of: unittest: Disable interrupt node tests for old world MAC systems
On systems with OF_IMAP_OLDWORLD_MAC set in of_irq_workarounds, the
devicetree interrupt parsing code is different, causing unit tests of
devicetree interrupt nodes to fail. Due to a bug in unittest code, which
tries to dereference an uninitialized pointer, this results in a crash.
OF: /testcase-data/phandle-tests/consumer-a: arguments longer than property
Unable to handle kernel paging request for data at address 0x00bc616e
Faulting instruction address: 0xc08e9468
Oops: Kernel access of bad area, sig: 11 [#1]
BE PREEMPT PowerMac
Modules linked in:
CPU: 0 PID: 1 Comm: swapper Not tainted 4.14.72-rc1-yocto-standard+ #1
task: cf8e0000 task.stack: cf8da000
NIP: c08e9468 LR: c08ea5bc CTR: c08ea5ac
REGS: cf8dbb50 TRAP: 0300 Not tainted (4.14.72-rc1-yocto-standard+)
MSR: 00001032 <ME,IR,DR,RI> CR: 82004044 XER: 00000000
DAR: 00bc616e DSISR: 40000000
GPR00: c08ea5bc cf8dbc00 cf8e0000 c13ca517 c13ca517 c13ca8a0 00000066 00000002
GPR08: 00000063 00bc614e c0b05865 000affff 82004048 00000000 c00047f0 00000000
GPR16: c0a80000 c0a9cc34 c13ca517 c0ad1134 05ffffff 000affff c0b05860 c0abeef8
GPR24: cecec278 cecec278 c0a8c4d0 c0a885e0 c13ca8a0 05ffffff c13ca8a0 c13ca517
NIP [c08e9468] device_node_gen_full_name+0x30/0x15c
LR [c08ea5bc] device_node_string+0x190/0x3c8
Call Trace:
[cf8dbc00] [c007f670] trace_hardirqs_on_caller+0x118/0x1fc (unreliable)
[cf8dbc40] [c08ea5bc] device_node_string+0x190/0x3c8
[cf8dbcb0] [c08eb794] pointer+0x25c/0x4d0
[cf8dbd00] [c08ebcbc] vsnprintf+0x2b4/0x5ec
[cf8dbd60] [c08ec00c] vscnprintf+0x18/0x48
[cf8dbd70] [c008e268] vprintk_store+0x4c/0x22c
[cf8dbda0] [c008ecac] vprintk_emit+0x94/0x130
[cf8dbdd0] [c008ff54] printk+0x5c/0x6c
[cf8dbe10] [c0b8ddd4] of_unittest+0x2220/0x26f8
[cf8dbea0] [c0004434] do_one_initcall+0x4c/0x184
[cf8dbf00] [c0b4534c] kernel_init_freeable+0x13c/0x1d8
[cf8dbf30] [c0004814] kernel_init+0x24/0x118
[cf8dbf40] [c0013398] ret_from_kernel_thread+0x5c/0x64
The problem was observed when running a qemu test for the g3beige machine
with devicetree unittests enabled.
Disable interrupt node tests on affected systems to avoid both false
unittest failures and the crash.
With this patch in place, unittest on the affected system passes with
the following message.
dt-test ### end of unittest - 144 passed, 0 failed
Fixes: 53a42093d96ef ("of: Add device tree selftests")
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Frank Rowand <frank.rowand@sony.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2018-09-26 07:06:24 +03:00
|
|
|
unittest(irq < 0 && irq != -EPROBE_DEFER,
|
|
|
|
"device parsing error failed - %d\n", irq);
|
|
|
|
}
|
2014-04-24 02:57:40 +04:00
|
|
|
|
2015-03-14 09:57:40 +03:00
|
|
|
np = of_find_node_by_path("/testcase-data/platform-tests");
|
2015-03-29 10:59:58 +03:00
|
|
|
unittest(np, "No testcase data in device tree\n");
|
2015-03-14 09:57:40 +03:00
|
|
|
if (!np)
|
2014-11-04 16:14:13 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-28 06:30:04 +03:00
|
|
|
test_bus = platform_device_register_full(&test_bus_info);
|
|
|
|
rc = PTR_ERR_OR_ZERO(test_bus);
|
2015-03-29 10:59:58 +03:00
|
|
|
unittest(!rc, "testbus registration failed; rc=%i\n", rc);
|
2019-08-15 09:22:18 +03:00
|
|
|
if (rc) {
|
|
|
|
of_node_put(np);
|
2014-05-13 19:07:54 +04:00
|
|
|
return;
|
2019-08-15 09:22:18 +03:00
|
|
|
}
|
2015-03-28 06:30:04 +03:00
|
|
|
test_bus->dev.of_node = np;
|
2014-05-13 19:07:54 +04:00
|
|
|
|
2016-01-04 15:13:21 +03:00
|
|
|
/*
|
|
|
|
* Add a dummy resource to the test bus node after it is
|
|
|
|
* registered to catch problems with un-inserted resources. The
|
|
|
|
* DT code doesn't insert the resources, and it has caused the
|
|
|
|
* kernel to oops in the past. This makes sure the same bug
|
|
|
|
* doesn't crop up again.
|
|
|
|
*/
|
|
|
|
platform_device_add_resources(test_bus, &test_bus_res, 1);
|
|
|
|
|
2015-03-28 06:30:04 +03:00
|
|
|
of_platform_populate(np, match, NULL, &test_bus->dev);
|
2014-05-13 19:07:54 +04:00
|
|
|
for_each_child_of_node(np, child) {
|
2020-04-17 00:42:47 +03:00
|
|
|
for_each_child_of_node(child, grandchild) {
|
|
|
|
pdev = of_find_device_by_node(grandchild);
|
|
|
|
unittest(pdev,
|
2018-08-28 04:00:19 +03:00
|
|
|
"Could not create device for node '%pOFn'\n",
|
|
|
|
grandchild);
|
2021-02-12 02:27:44 +03:00
|
|
|
platform_device_put(pdev);
|
2020-04-17 00:42:47 +03:00
|
|
|
}
|
2014-05-13 19:07:54 +04:00
|
|
|
}
|
2014-11-04 16:14:13 +03:00
|
|
|
|
2015-03-28 06:30:04 +03:00
|
|
|
of_platform_depopulate(&test_bus->dev);
|
2014-11-04 16:14:13 +03:00
|
|
|
for_each_child_of_node(np, child) {
|
|
|
|
for_each_child_of_node(child, grandchild)
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(!of_find_device_by_node(grandchild),
|
2018-08-28 04:00:19 +03:00
|
|
|
"device didn't get destroyed '%pOFn'\n",
|
|
|
|
grandchild);
|
2014-11-04 16:14:13 +03:00
|
|
|
}
|
|
|
|
|
2015-03-28 06:30:04 +03:00
|
|
|
platform_device_unregister(test_bus);
|
2014-11-04 16:14:13 +03:00
|
|
|
of_node_put(np);
|
2014-04-24 02:57:40 +04:00
|
|
|
}
|
|
|
|
|
2014-07-17 10:09:39 +04:00
|
|
|
/**
|
|
|
|
* update_node_properties - adds the properties
|
|
|
|
* of np into dup node (present in live tree) and
|
|
|
|
* updates parent of children of np to dup.
|
|
|
|
*
|
2018-10-13 05:38:26 +03:00
|
|
|
* @np: node whose properties are being added to the live tree
|
2014-07-17 10:09:39 +04:00
|
|
|
* @dup: node present in live tree to be updated
|
|
|
|
*/
|
|
|
|
static void update_node_properties(struct device_node *np,
|
|
|
|
struct device_node *dup)
|
|
|
|
{
|
|
|
|
struct property *prop;
|
2018-10-13 05:38:26 +03:00
|
|
|
struct property *save_next;
|
2014-07-17 10:09:39 +04:00
|
|
|
struct device_node *child;
|
2018-10-13 05:38:26 +03:00
|
|
|
int ret;
|
2014-07-17 10:09:39 +04:00
|
|
|
|
|
|
|
for_each_child_of_node(np, child)
|
|
|
|
child->parent = dup;
|
2018-10-13 05:38:26 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* "unittest internal error: unable to add testdata property"
|
|
|
|
*
|
|
|
|
* If this message reports a property in node '/__symbols__' then
|
|
|
|
* the respective unittest overlay contains a label that has the
|
|
|
|
* same name as a label in the live devicetree. The label will
|
|
|
|
* be in the live devicetree only if the devicetree source was
|
|
|
|
* compiled with the '-@' option. If you encounter this error,
|
|
|
|
* please consider renaming __all__ of the labels in the unittest
|
|
|
|
* overlay dts files with an odd prefix that is unlikely to be
|
|
|
|
* used in a real devicetree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* open code for_each_property_of_node() because of_add_property()
|
|
|
|
* sets prop->next to NULL
|
|
|
|
*/
|
|
|
|
for (prop = np->properties; prop != NULL; prop = save_next) {
|
|
|
|
save_next = prop->next;
|
|
|
|
ret = of_add_property(dup, prop);
|
2019-01-25 02:22:13 +03:00
|
|
|
if (ret) {
|
|
|
|
if (ret == -EEXIST && !strcmp(prop->name, "name"))
|
|
|
|
continue;
|
2018-10-13 05:38:26 +03:00
|
|
|
pr_err("unittest internal error: unable to add testdata property %pOF/%s",
|
|
|
|
np, prop->name);
|
2019-01-25 02:22:13 +03:00
|
|
|
}
|
2018-10-13 05:38:26 +03:00
|
|
|
}
|
2014-07-17 10:09:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* attach_node_and_children - attaches nodes
|
2019-01-25 02:22:14 +03:00
|
|
|
* and its children to live tree.
|
|
|
|
* CAUTION: misleading function name - if node @np already exists in
|
|
|
|
* the live tree then children of @np are *not* attached to the live
|
|
|
|
* tree. This works for the current test devicetree nodes because such
|
|
|
|
* nodes do not have child nodes.
|
2014-07-17 10:09:39 +04:00
|
|
|
*
|
|
|
|
* @np: Node to attach to live tree
|
|
|
|
*/
|
2018-10-13 05:38:26 +03:00
|
|
|
static void attach_node_and_children(struct device_node *np)
|
2014-07-17 10:09:39 +04:00
|
|
|
{
|
2014-10-03 19:28:27 +04:00
|
|
|
struct device_node *next, *dup, *child;
|
2015-01-11 10:19:51 +03:00
|
|
|
unsigned long flags;
|
2017-06-01 23:50:55 +03:00
|
|
|
const char *full_name;
|
2014-07-17 10:09:39 +04:00
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
full_name = kasprintf(GFP_KERNEL, "%pOF", np);
|
2018-10-13 05:38:26 +03:00
|
|
|
|
|
|
|
if (!strcmp(full_name, "/__local_fixups__") ||
|
2019-11-26 04:48:04 +03:00
|
|
|
!strcmp(full_name, "/__fixups__")) {
|
|
|
|
kfree(full_name);
|
2018-10-13 05:38:26 +03:00
|
|
|
return;
|
2019-11-26 04:48:04 +03:00
|
|
|
}
|
2018-10-13 05:38:26 +03:00
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dup = of_find_node_by_path(full_name);
|
|
|
|
kfree(full_name);
|
2014-10-03 19:28:27 +04:00
|
|
|
if (dup) {
|
|
|
|
update_node_properties(np, dup);
|
2018-10-13 05:38:26 +03:00
|
|
|
return;
|
2014-10-03 19:28:27 +04:00
|
|
|
}
|
2014-07-17 10:09:39 +04:00
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
child = np->child;
|
|
|
|
np->child = NULL;
|
2015-01-11 10:19:51 +03:00
|
|
|
|
|
|
|
mutex_lock(&of_mutex);
|
|
|
|
raw_spin_lock_irqsave(&devtree_lock, flags);
|
|
|
|
np->sibling = np->parent->child;
|
|
|
|
np->parent->child = np;
|
|
|
|
of_node_clear_flag(np, OF_DETACHED);
|
|
|
|
raw_spin_unlock_irqrestore(&devtree_lock, flags);
|
|
|
|
|
|
|
|
__of_attach_node_sysfs(np);
|
|
|
|
mutex_unlock(&of_mutex);
|
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
while (child) {
|
|
|
|
next = child->sibling;
|
|
|
|
attach_node_and_children(child);
|
|
|
|
child = next;
|
2014-07-17 10:09:39 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-03-11 11:36:54 +03:00
|
|
|
* unittest_data_add - Reads, copies data from
|
2014-07-17 10:09:39 +04:00
|
|
|
* linked tree and attaches it to the live tree
|
|
|
|
*/
|
2015-03-11 11:36:54 +03:00
|
|
|
static int __init unittest_data_add(void)
|
2014-07-17 10:09:39 +04:00
|
|
|
{
|
2015-03-11 11:36:54 +03:00
|
|
|
void *unittest_data;
|
2021-04-08 23:45:08 +03:00
|
|
|
void *unittest_data_align;
|
2021-04-05 06:28:45 +03:00
|
|
|
struct device_node *unittest_data_node = NULL, *np;
|
2015-03-14 10:04:24 +03:00
|
|
|
/*
|
|
|
|
* __dtb_testcases_begin[] and __dtb_testcases_end[] are magically
|
|
|
|
* created by cmd_dt_S_dtb in scripts/Makefile.lib
|
|
|
|
*/
|
2014-07-17 10:09:39 +04:00
|
|
|
extern uint8_t __dtb_testcases_begin[];
|
|
|
|
extern uint8_t __dtb_testcases_end[];
|
|
|
|
const int size = __dtb_testcases_end - __dtb_testcases_begin;
|
2014-10-02 17:36:46 +04:00
|
|
|
int rc;
|
2021-04-05 06:28:45 +03:00
|
|
|
void *ret;
|
2014-07-17 10:09:39 +04:00
|
|
|
|
2014-07-26 23:48:50 +04:00
|
|
|
if (!size) {
|
2021-04-05 06:28:45 +03:00
|
|
|
pr_warn("%s: testcases is empty\n", __func__);
|
2014-07-17 10:09:39 +04:00
|
|
|
return -ENODATA;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* creating copy */
|
2021-04-08 23:45:08 +03:00
|
|
|
unittest_data = kmalloc(size + FDT_ALIGN_SIZE, GFP_KERNEL);
|
2019-05-02 15:45:35 +03:00
|
|
|
if (!unittest_data)
|
2014-07-17 10:09:39 +04:00
|
|
|
return -ENOMEM;
|
2019-05-02 15:45:35 +03:00
|
|
|
|
2021-04-08 23:45:08 +03:00
|
|
|
unittest_data_align = PTR_ALIGN(unittest_data, FDT_ALIGN_SIZE);
|
|
|
|
memcpy(unittest_data_align, __dtb_testcases_begin, size);
|
|
|
|
|
|
|
|
ret = of_fdt_unflatten_tree(unittest_data_align, NULL, &unittest_data_node);
|
2021-04-05 06:28:45 +03:00
|
|
|
if (!ret) {
|
|
|
|
pr_warn("%s: unflatten testcases tree failed\n", __func__);
|
|
|
|
kfree(unittest_data);
|
|
|
|
return -ENODATA;
|
|
|
|
}
|
2015-03-11 11:36:54 +03:00
|
|
|
if (!unittest_data_node) {
|
2021-04-05 06:28:45 +03:00
|
|
|
pr_warn("%s: testcases tree is empty\n", __func__);
|
2019-10-04 21:58:43 +03:00
|
|
|
kfree(unittest_data);
|
2014-07-26 23:48:50 +04:00
|
|
|
return -ENODATA;
|
|
|
|
}
|
2017-10-18 02:36:29 +03:00
|
|
|
|
|
|
|
/*
|
2018-02-12 11:19:42 +03:00
|
|
|
* This lock normally encloses of_resolve_phandles()
|
2017-10-18 02:36:29 +03:00
|
|
|
*/
|
|
|
|
of_overlay_mutex_lock();
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
rc = of_resolve_phandles(unittest_data_node);
|
2014-10-02 17:36:46 +04:00
|
|
|
if (rc) {
|
|
|
|
pr_err("%s: Failed to resolve phandles (rc=%i)\n", __func__, rc);
|
2017-10-18 02:36:29 +03:00
|
|
|
of_overlay_mutex_unlock();
|
2014-10-02 17:36:46 +04:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2014-07-26 23:48:50 +04:00
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
if (!of_root) {
|
2015-03-11 11:36:54 +03:00
|
|
|
of_root = unittest_data_node;
|
2014-07-26 23:48:50 +04:00
|
|
|
for_each_of_allnodes(np)
|
|
|
|
__of_attach_node_sysfs(np);
|
|
|
|
of_aliases = of_find_node_by_path("/aliases");
|
|
|
|
of_chosen = of_find_node_by_path("/chosen");
|
2017-10-18 02:36:29 +03:00
|
|
|
of_overlay_mutex_unlock();
|
2014-07-26 23:48:50 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2014-07-17 10:09:39 +04:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
|
|
|
|
|
2014-07-17 10:09:39 +04:00
|
|
|
/* attach the sub-tree to live tree */
|
2015-03-11 11:36:54 +03:00
|
|
|
np = unittest_data_node->child;
|
2014-10-03 19:28:27 +04:00
|
|
|
while (np) {
|
|
|
|
struct device_node *next = np->sibling;
|
2015-03-14 10:02:31 +03:00
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
np->parent = of_root;
|
|
|
|
attach_node_and_children(np);
|
|
|
|
np = next;
|
|
|
|
}
|
2017-10-18 02:36:29 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"Duplicate name in testcase-data, renamed to \"duplicate-name#1\"");
|
|
|
|
|
2017-10-18 02:36:29 +03:00
|
|
|
of_overlay_mutex_unlock();
|
|
|
|
|
2014-10-03 19:28:27 +04:00
|
|
|
return 0;
|
2014-07-17 10:09:39 +04:00
|
|
|
}
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
#ifdef CONFIG_OF_OVERLAY
|
2018-03-13 16:15:42 +03:00
|
|
|
static int __init overlay_data_apply(const char *overlay_name, int *overlay_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_probe(struct platform_device *pdev)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *np = dev->of_node;
|
|
|
|
|
|
|
|
if (np == NULL) {
|
|
|
|
dev_err(dev, "No OF data for device\n");
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2014-12-19 15:34:34 +03:00
|
|
|
|
|
|
|
of_platform_populate(np, NULL, NULL, &pdev->dev);
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_remove(struct platform_device *pdev)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *np = dev->of_node;
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2014-10-28 23:35:59 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-29 10:59:58 +03:00
|
|
|
static const struct of_device_id unittest_match[] = {
|
2015-03-11 11:36:54 +03:00
|
|
|
{ .compatible = "unittest", },
|
2014-10-28 23:35:59 +03:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static struct platform_driver unittest_driver = {
|
|
|
|
.probe = unittest_probe,
|
|
|
|
.remove = unittest_remove,
|
2014-10-28 23:35:59 +03:00
|
|
|
.driver = {
|
2015-03-11 11:36:54 +03:00
|
|
|
.name = "unittest",
|
|
|
|
.of_match_table = of_match_ptr(unittest_match),
|
2014-10-28 23:35:59 +03:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
/* get the platform device instantiated at the path */
|
|
|
|
static struct platform_device *of_path_to_platform_device(const char *path)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct platform_device *pdev;
|
|
|
|
|
|
|
|
np = of_find_node_by_path(path);
|
|
|
|
if (np == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pdev = of_find_device_by_node(np);
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
return pdev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find out if a platform device exists at that path */
|
|
|
|
static int of_path_platform_device_exists(const char *path)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev;
|
|
|
|
|
|
|
|
pdev = of_path_to_platform_device(path);
|
|
|
|
platform_device_put(pdev);
|
|
|
|
return pdev != NULL;
|
|
|
|
}
|
|
|
|
|
2020-02-28 07:16:29 +03:00
|
|
|
#ifdef CONFIG_OF_GPIO
|
|
|
|
|
|
|
|
struct unittest_gpio_dev {
|
|
|
|
struct gpio_chip chip;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int unittest_gpio_chip_request_count;
|
|
|
|
static int unittest_gpio_probe_count;
|
|
|
|
static int unittest_gpio_probe_pass_count;
|
|
|
|
|
|
|
|
static int unittest_gpio_chip_request(struct gpio_chip *chip, unsigned int offset)
|
|
|
|
{
|
|
|
|
unittest_gpio_chip_request_count++;
|
|
|
|
|
|
|
|
pr_debug("%s(): %s %d %d\n", __func__, chip->label, offset,
|
|
|
|
unittest_gpio_chip_request_count);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unittest_gpio_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct unittest_gpio_dev *devptr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
unittest_gpio_probe_count++;
|
|
|
|
|
|
|
|
devptr = kzalloc(sizeof(*devptr), GFP_KERNEL);
|
|
|
|
if (!devptr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, devptr);
|
|
|
|
|
|
|
|
devptr->chip.of_node = pdev->dev.of_node;
|
|
|
|
devptr->chip.label = "of-unittest-gpio";
|
|
|
|
devptr->chip.base = -1; /* dynamic allocation */
|
|
|
|
devptr->chip.ngpio = 5;
|
|
|
|
devptr->chip.request = unittest_gpio_chip_request;
|
|
|
|
|
|
|
|
ret = gpiochip_add_data(&devptr->chip, NULL);
|
|
|
|
|
|
|
|
unittest(!ret,
|
|
|
|
"gpiochip_add_data() for node @%pOF failed, ret = %d\n", devptr->chip.of_node, ret);
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
unittest_gpio_probe_pass_count++;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unittest_gpio_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct unittest_gpio_dev *gdev = platform_get_drvdata(pdev);
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *np = pdev->dev.of_node;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
|
|
|
|
|
|
|
if (!gdev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (gdev->chip.base != -1)
|
|
|
|
gpiochip_remove(&gdev->chip);
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
2020-03-26 04:45:30 +03:00
|
|
|
kfree(gdev);
|
2020-02-28 07:16:29 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct of_device_id unittest_gpio_id[] = {
|
|
|
|
{ .compatible = "unittest-gpio", },
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_driver unittest_gpio_driver = {
|
|
|
|
.probe = unittest_gpio_probe,
|
|
|
|
.remove = unittest_gpio_remove,
|
|
|
|
.driver = {
|
|
|
|
.name = "unittest-gpio",
|
|
|
|
.of_match_table = of_match_ptr(unittest_gpio_id),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init of_unittest_overlay_gpio(void)
|
|
|
|
{
|
|
|
|
int chip_request_count;
|
|
|
|
int probe_pass_count;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* tests: apply overlays before registering driver
|
|
|
|
* Similar to installing a driver as a module, the
|
|
|
|
* driver is registered after applying the overlays.
|
|
|
|
*
|
2020-03-26 04:45:31 +03:00
|
|
|
* The overlays are applied by overlay_data_apply()
|
|
|
|
* instead of of_unittest_apply_overlay() so that they
|
|
|
|
* will not be tracked. Thus they will not be removed
|
|
|
|
* by of_unittest_destroy_tracked_overlays().
|
|
|
|
*
|
2020-02-28 07:16:29 +03:00
|
|
|
* - apply overlay_gpio_01
|
|
|
|
* - apply overlay_gpio_02a
|
|
|
|
* - apply overlay_gpio_02b
|
|
|
|
* - register driver
|
|
|
|
*
|
|
|
|
* register driver will result in
|
|
|
|
* - probe and processing gpio hog for overlay_gpio_01
|
|
|
|
* - probe for overlay_gpio_02a
|
|
|
|
* - processing gpio for overlay_gpio_02b
|
|
|
|
*/
|
|
|
|
|
|
|
|
probe_pass_count = unittest_gpio_probe_pass_count;
|
|
|
|
chip_request_count = unittest_gpio_chip_request_count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* overlay_gpio_01 contains gpio node and child gpio hog node
|
|
|
|
* overlay_gpio_02a contains gpio node
|
|
|
|
* overlay_gpio_02b contains child gpio hog node
|
|
|
|
*/
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_01", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_01' failed\n");
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_02a", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_02a' failed\n");
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_02b", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_02b' failed\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* messages are the result of the probes, after the
|
|
|
|
* driver is registered
|
|
|
|
*/
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-B-input) hogged as input\n");
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-A-input) hogged as input\n");
|
|
|
|
|
|
|
|
ret = platform_driver_register(&unittest_gpio_driver);
|
|
|
|
if (unittest(ret == 0, "could not register unittest gpio driver\n"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-A-input) hogged as input\n");
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-B-input) hogged as input\n");
|
|
|
|
|
|
|
|
unittest(probe_pass_count + 2 == unittest_gpio_probe_pass_count,
|
|
|
|
"unittest_gpio_probe() failed or not called\n");
|
|
|
|
|
|
|
|
unittest(chip_request_count + 2 == unittest_gpio_chip_request_count,
|
|
|
|
"unittest_gpio_chip_request() called %d times (expected 1 time)\n",
|
|
|
|
unittest_gpio_chip_request_count - chip_request_count);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* tests: apply overlays after registering driver
|
|
|
|
*
|
|
|
|
* Similar to a driver built-in to the kernel, the
|
|
|
|
* driver is registered before applying the overlays.
|
|
|
|
*
|
|
|
|
* overlay_gpio_03 contains gpio node and child gpio hog node
|
|
|
|
*
|
|
|
|
* - apply overlay_gpio_03
|
|
|
|
*
|
|
|
|
* apply overlay will result in
|
|
|
|
* - probe and processing gpio hog.
|
|
|
|
*/
|
|
|
|
|
|
|
|
probe_pass_count = unittest_gpio_probe_pass_count;
|
|
|
|
chip_request_count = unittest_gpio_chip_request_count;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-D-input) hogged as input\n");
|
|
|
|
|
|
|
|
/* overlay_gpio_03 contains gpio node and child gpio hog node */
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_03", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_03' failed\n");
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-D-input) hogged as input\n");
|
|
|
|
|
|
|
|
unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
|
|
|
|
"unittest_gpio_probe() failed or not called\n");
|
|
|
|
|
|
|
|
unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
|
|
|
|
"unittest_gpio_chip_request() called %d times (expected 1 time)\n",
|
|
|
|
unittest_gpio_chip_request_count - chip_request_count);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* overlay_gpio_04a contains gpio node
|
|
|
|
*
|
|
|
|
* - apply overlay_gpio_04a
|
|
|
|
*
|
|
|
|
* apply the overlay will result in
|
|
|
|
* - probe for overlay_gpio_04a
|
|
|
|
*/
|
|
|
|
|
|
|
|
probe_pass_count = unittest_gpio_probe_pass_count;
|
|
|
|
chip_request_count = unittest_gpio_chip_request_count;
|
|
|
|
|
|
|
|
/* overlay_gpio_04a contains gpio node */
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_04a", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_04a' failed\n");
|
|
|
|
|
|
|
|
unittest(probe_pass_count + 1 == unittest_gpio_probe_pass_count,
|
|
|
|
"unittest_gpio_probe() failed or not called\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* overlay_gpio_04b contains child gpio hog node
|
|
|
|
*
|
|
|
|
* - apply overlay_gpio_04b
|
|
|
|
*
|
|
|
|
* apply the overlay will result in
|
|
|
|
* - processing gpio for overlay_gpio_04b
|
|
|
|
*/
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-C-input) hogged as input\n");
|
|
|
|
|
|
|
|
/* overlay_gpio_04b contains child gpio hog node */
|
|
|
|
|
|
|
|
unittest(overlay_data_apply("overlay_gpio_04b", NULL),
|
|
|
|
"Adding overlay 'overlay_gpio_04b' failed\n");
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"GPIO line <<int>> (line-C-input) hogged as input\n");
|
|
|
|
|
|
|
|
unittest(chip_request_count + 1 == unittest_gpio_chip_request_count,
|
|
|
|
"unittest_gpio_chip_request() called %d times (expected 1 time)\n",
|
|
|
|
unittest_gpio_chip_request_count - chip_request_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static void __init of_unittest_overlay_gpio(void)
|
|
|
|
{
|
|
|
|
/* skip tests */
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C)
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
/* get the i2c client device instantiated at the path */
|
|
|
|
static struct i2c_client *of_path_to_i2c_client(const char *path)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
np = of_find_node_by_path(path);
|
|
|
|
if (np == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
client = of_find_i2c_device_by_node(np);
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
return client;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* find out if a i2c client device exists at that path */
|
|
|
|
static int of_path_i2c_client_exists(const char *path)
|
|
|
|
{
|
|
|
|
struct i2c_client *client;
|
|
|
|
|
|
|
|
client = of_path_to_i2c_client(path);
|
|
|
|
if (client)
|
|
|
|
put_device(&client->dev);
|
|
|
|
return client != NULL;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int of_path_i2c_client_exists(const char *path)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
enum overlay_type {
|
|
|
|
PDEV_OVERLAY,
|
|
|
|
I2C_OVERLAY
|
|
|
|
};
|
|
|
|
|
|
|
|
static int of_path_device_type_exists(const char *path,
|
|
|
|
enum overlay_type ovtype)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2015-01-12 20:02:49 +03:00
|
|
|
switch (ovtype) {
|
|
|
|
case PDEV_OVERLAY:
|
|
|
|
return of_path_platform_device_exists(path);
|
|
|
|
case I2C_OVERLAY:
|
|
|
|
return of_path_i2c_client_exists(path);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static const char *unittest_path(int nr, enum overlay_type ovtype)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
const char *base;
|
2014-10-28 23:35:59 +03:00
|
|
|
static char buf[256];
|
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
switch (ovtype) {
|
|
|
|
case PDEV_OVERLAY:
|
|
|
|
base = "/testcase-data/overlay-node/test-bus";
|
|
|
|
break;
|
|
|
|
case I2C_OVERLAY:
|
|
|
|
base = "/testcase-data/overlay-node/test-bus/i2c-test-bus";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
buf[0] = '\0';
|
|
|
|
return buf;
|
|
|
|
}
|
2015-03-11 11:36:54 +03:00
|
|
|
snprintf(buf, sizeof(buf) - 1, "%s/test-unittest%d", base, nr);
|
2014-10-28 23:35:59 +03:00
|
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int of_unittest_device_exists(int unittest_nr, enum overlay_type ovtype)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
const char *path;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
path = unittest_path(unittest_nr, ovtype);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
switch (ovtype) {
|
|
|
|
case PDEV_OVERLAY:
|
|
|
|
return of_path_platform_device_exists(path);
|
|
|
|
case I2C_OVERLAY:
|
|
|
|
return of_path_i2c_client_exists(path);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
static const char *overlay_name_from_nr(int nr)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
|
|
|
static char buf[256];
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf) - 1,
|
2018-02-12 11:19:42 +03:00
|
|
|
"overlay_%d", nr);
|
2014-10-28 23:35:59 +03:00
|
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *bus_path = "/testcase-data/overlay-node/test-bus";
|
|
|
|
|
2020-03-26 04:45:31 +03:00
|
|
|
/* FIXME: it is NOT guaranteed that overlay ids are assigned in sequence */
|
|
|
|
|
2015-04-07 22:23:49 +03:00
|
|
|
#define MAX_UNITTEST_OVERLAYS 256
|
|
|
|
static unsigned long overlay_id_bits[BITS_TO_LONGS(MAX_UNITTEST_OVERLAYS)];
|
|
|
|
static int overlay_first_id = -1;
|
|
|
|
|
2020-03-26 04:45:31 +03:00
|
|
|
static long of_unittest_overlay_tracked(int id)
|
|
|
|
{
|
|
|
|
if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
|
|
|
|
return 0;
|
|
|
|
return overlay_id_bits[BIT_WORD(id)] & BIT_MASK(id);
|
|
|
|
}
|
|
|
|
|
2015-04-07 22:23:49 +03:00
|
|
|
static void of_unittest_track_overlay(int id)
|
|
|
|
{
|
|
|
|
if (overlay_first_id < 0)
|
|
|
|
overlay_first_id = id;
|
|
|
|
id -= overlay_first_id;
|
|
|
|
|
2020-03-26 04:45:31 +03:00
|
|
|
if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
|
|
|
|
return;
|
2015-04-07 22:23:49 +03:00
|
|
|
overlay_id_bits[BIT_WORD(id)] |= BIT_MASK(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void of_unittest_untrack_overlay(int id)
|
|
|
|
{
|
|
|
|
if (overlay_first_id < 0)
|
|
|
|
return;
|
|
|
|
id -= overlay_first_id;
|
2020-03-26 04:45:31 +03:00
|
|
|
if (WARN_ON(id >= MAX_UNITTEST_OVERLAYS))
|
|
|
|
return;
|
2015-04-07 22:23:49 +03:00
|
|
|
overlay_id_bits[BIT_WORD(id)] &= ~BIT_MASK(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void of_unittest_destroy_tracked_overlays(void)
|
|
|
|
{
|
2017-10-18 02:36:26 +03:00
|
|
|
int id, ret, defers, ovcs_id;
|
2015-04-07 22:23:49 +03:00
|
|
|
|
|
|
|
if (overlay_first_id < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* try until no defers */
|
|
|
|
do {
|
|
|
|
defers = 0;
|
|
|
|
/* remove in reverse order */
|
|
|
|
for (id = MAX_UNITTEST_OVERLAYS - 1; id >= 0; id--) {
|
2020-03-26 04:45:31 +03:00
|
|
|
if (!of_unittest_overlay_tracked(id))
|
2015-04-07 22:23:49 +03:00
|
|
|
continue;
|
|
|
|
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = id + overlay_first_id;
|
|
|
|
ret = of_overlay_remove(&ovcs_id);
|
2016-03-02 14:24:49 +03:00
|
|
|
if (ret == -ENODEV) {
|
|
|
|
pr_warn("%s: no overlay to destroy for #%d\n",
|
|
|
|
__func__, id + overlay_first_id);
|
|
|
|
continue;
|
|
|
|
}
|
2015-04-07 22:23:49 +03:00
|
|
|
if (ret != 0) {
|
|
|
|
defers++;
|
|
|
|
pr_warn("%s: overlay destroy failed for #%d\n",
|
|
|
|
__func__, id + overlay_first_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-03-26 04:45:31 +03:00
|
|
|
of_unittest_untrack_overlay(id);
|
2015-04-07 22:23:49 +03:00
|
|
|
}
|
|
|
|
} while (defers > 0);
|
|
|
|
}
|
|
|
|
|
2018-10-05 06:39:24 +03:00
|
|
|
static int __init of_unittest_apply_overlay(int overlay_nr, int *overlay_id)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2018-02-12 11:19:42 +03:00
|
|
|
const char *overlay_name;
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
overlay_name = overlay_name_from_nr(overlay_nr);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2018-03-14 23:08:28 +03:00
|
|
|
if (!overlay_data_apply(overlay_name, overlay_id)) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "could not apply overlay \"%s\"\n",
|
|
|
|
overlay_name);
|
2018-03-14 23:08:28 +03:00
|
|
|
return -EFAULT;
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
2017-10-18 02:36:26 +03:00
|
|
|
of_unittest_track_overlay(*overlay_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2018-03-09 01:39:05 +03:00
|
|
|
return 0;
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* apply an overlay while checking before and after states */
|
2018-02-12 11:19:42 +03:00
|
|
|
static int __init of_unittest_apply_overlay_check(int overlay_nr,
|
|
|
|
int unittest_nr, int before, int after,
|
|
|
|
enum overlay_type ovtype)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2017-10-18 02:36:26 +03:00
|
|
|
int ret, ovcs_id;
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must not be in before state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s with device @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype),
|
2014-10-28 23:35:59 +03:00
|
|
|
!before ? "enabled" : "disabled");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = 0;
|
2018-10-05 06:39:24 +03:00
|
|
|
ret = of_unittest_apply_overlay(overlay_nr, &ovcs_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
if (ret != 0) {
|
2015-03-11 11:36:54 +03:00
|
|
|
/* of_unittest_apply_overlay already called unittest() */
|
2014-10-28 23:35:59 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be to set to after state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s failed to create @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype),
|
2014-10-28 23:35:59 +03:00
|
|
|
!after ? "enabled" : "disabled");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply an overlay and then revert it while checking before, after states */
|
2018-02-12 11:19:42 +03:00
|
|
|
static int __init of_unittest_apply_revert_overlay_check(int overlay_nr,
|
2015-03-11 11:36:54 +03:00
|
|
|
int unittest_nr, int before, int after,
|
2015-01-12 20:02:49 +03:00
|
|
|
enum overlay_type ovtype)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-03-26 04:45:31 +03:00
|
|
|
int ret, ovcs_id, save_id;
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be in before state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s with device @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype),
|
2014-10-28 23:35:59 +03:00
|
|
|
!before ? "enabled" : "disabled");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply the overlay */
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = 0;
|
2018-10-05 06:39:24 +03:00
|
|
|
ret = of_unittest_apply_overlay(overlay_nr, &ovcs_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
if (ret != 0) {
|
2015-03-11 11:36:54 +03:00
|
|
|
/* of_unittest_apply_overlay already called unittest() */
|
2014-10-28 23:35:59 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be in after state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s failed to create @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype),
|
2014-10-28 23:35:59 +03:00
|
|
|
!after ? "enabled" : "disabled");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2020-03-26 04:45:31 +03:00
|
|
|
save_id = ovcs_id;
|
2017-10-18 02:36:26 +03:00
|
|
|
ret = of_overlay_remove(&ovcs_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
if (ret != 0) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s failed to be destroyed @\"%s\"\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype));
|
2014-10-28 23:35:59 +03:00
|
|
|
return ret;
|
|
|
|
}
|
2020-03-26 04:45:31 +03:00
|
|
|
of_unittest_untrack_overlay(save_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be again in before state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr, PDEV_OVERLAY) != before) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s with device @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr, ovtype),
|
2014-10-28 23:35:59 +03:00
|
|
|
!before ? "enabled" : "disabled");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test activation of device */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_0(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* device should enable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest0/status");
|
|
|
|
|
|
|
|
if (ret)
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 0);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test deactivation of device */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_1(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* device should disable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest1/status");
|
|
|
|
|
|
|
|
if (ret)
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 1);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test activation of device */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_2(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* device should enable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest2/status");
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
if (ret)
|
|
|
|
return;
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 2);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test deactivation of device */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_3(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* device should disable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest3/status");
|
|
|
|
|
|
|
|
if (ret)
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 3);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test activation of a full device node */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_4(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
|
|
|
/* device should disable */
|
2018-03-09 01:39:04 +03:00
|
|
|
if (of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY))
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 4);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test overlay apply/revert sequence */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_5(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* device should disable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest5/status");
|
|
|
|
|
|
|
|
if (ret)
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 5);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test overlay application in sequence */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_6(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2018-03-09 01:39:04 +03:00
|
|
|
int i, ov_id[2], ovcs_id;
|
2015-03-11 11:36:54 +03:00
|
|
|
int overlay_nr = 6, unittest_nr = 6;
|
2014-10-28 23:35:59 +03:00
|
|
|
int before = 0, after = 1;
|
2018-02-12 11:19:42 +03:00
|
|
|
const char *overlay_name;
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be in before state */
|
2014-10-28 23:35:59 +03:00
|
|
|
for (i = 0; i < 2; i++) {
|
2015-03-11 11:36:54 +03:00
|
|
|
if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
|
2014-10-28 23:35:59 +03:00
|
|
|
!= before) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s with device @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr + i),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr + i,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY),
|
2014-10-28 23:35:59 +03:00
|
|
|
!before ? "enabled" : "disabled");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply the overlays */
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
|
|
|
|
|
|
|
|
overlay_name = overlay_name_from_nr(overlay_nr + 0);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = overlay_data_apply(overlay_name, &ovcs_id);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ov_id[0] = ovcs_id;
|
|
|
|
of_unittest_track_overlay(ov_id[0]);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest6/status");
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
|
|
|
|
|
|
|
|
overlay_name = overlay_name_from_nr(overlay_nr + 1);
|
|
|
|
|
|
|
|
ret = overlay_data_apply(overlay_name, &ovcs_id);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
}
|
2020-02-20 21:40:21 +03:00
|
|
|
ov_id[1] = ovcs_id;
|
|
|
|
of_unittest_track_overlay(ov_id[1]);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest7/status");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
|
|
|
|
for (i = 0; i < 2; i++) {
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be in after state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
|
2014-10-28 23:35:59 +03:00
|
|
|
!= after) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
|
2018-02-12 11:19:42 +03:00
|
|
|
overlay_name_from_nr(overlay_nr + i),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr + i,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY),
|
2014-10-28 23:35:59 +03:00
|
|
|
!after ? "enabled" : "disabled");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 1; i >= 0; i--) {
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = ov_id[i];
|
2018-03-09 01:39:04 +03:00
|
|
|
if (of_overlay_remove(&ovcs_id)) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s failed destroy @\"%s\"\n",
|
|
|
|
overlay_name_from_nr(overlay_nr + i),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr + i,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY));
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
}
|
2015-04-07 22:23:49 +03:00
|
|
|
of_unittest_untrack_overlay(ov_id[i]);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 2; i++) {
|
2015-03-11 11:36:54 +03:00
|
|
|
/* unittest device must be again in before state */
|
|
|
|
if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
|
2014-10-28 23:35:59 +03:00
|
|
|
!= before) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s with device @\"%s\" %s\n",
|
|
|
|
overlay_name_from_nr(overlay_nr + i),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr + i,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY),
|
2014-10-28 23:35:59 +03:00
|
|
|
!before ? "enabled" : "disabled");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 6);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test overlay application in sequence */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_8(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
2018-03-09 01:39:04 +03:00
|
|
|
int i, ov_id[2], ovcs_id;
|
2015-03-11 11:36:54 +03:00
|
|
|
int overlay_nr = 8, unittest_nr = 8;
|
2018-02-12 11:19:42 +03:00
|
|
|
const char *overlay_name;
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
2014-10-28 23:35:59 +03:00
|
|
|
|
|
|
|
/* we don't care about device state in this test */
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
|
|
|
|
|
|
|
|
overlay_name = overlay_name_from_nr(overlay_nr + 0);
|
|
|
|
|
|
|
|
ret = overlay_data_apply(overlay_name, &ovcs_id);
|
|
|
|
if (!ret)
|
|
|
|
unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/status");
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ov_id[0] = ovcs_id;
|
|
|
|
of_unittest_track_overlay(ov_id[0]);
|
|
|
|
|
|
|
|
overlay_name = overlay_name_from_nr(overlay_nr + 1);
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* apply the overlays */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = overlay_data_apply(overlay_name, &ovcs_id);
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/test-unittest8/property-foo");
|
2014-10-28 23:35:59 +03:00
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
if (!ret) {
|
|
|
|
unittest(0, "could not apply overlay \"%s\"\n", overlay_name);
|
|
|
|
return;
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
ov_id[1] = ovcs_id;
|
|
|
|
of_unittest_track_overlay(ov_id[1]);
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
/* now try to remove first overlay (it should fail) */
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = ov_id[0];
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: overlay #6 is not topmost");
|
|
|
|
|
|
|
|
ret = of_overlay_remove(&ovcs_id);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: overlay #6 is not topmost");
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: node_overlaps_later_cs: #6 overlaps with #7 @/testcase-data/overlay-node/test-bus/test-unittest8");
|
|
|
|
|
|
|
|
if (!ret) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s was destroyed @\"%s\"\n",
|
|
|
|
overlay_name_from_nr(overlay_nr + 0),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY));
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* removing them in order should work */
|
|
|
|
for (i = 1; i >= 0; i--) {
|
2017-10-18 02:36:26 +03:00
|
|
|
ovcs_id = ov_id[i];
|
2018-03-09 01:39:04 +03:00
|
|
|
if (of_overlay_remove(&ovcs_id)) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "%s not destroyed @\"%s\"\n",
|
|
|
|
overlay_name_from_nr(overlay_nr + i),
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest_path(unittest_nr,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY));
|
2014-10-28 23:35:59 +03:00
|
|
|
return;
|
|
|
|
}
|
2015-04-07 22:23:49 +03:00
|
|
|
of_unittest_untrack_overlay(ov_id[i]);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 8);
|
2014-10-28 23:35:59 +03:00
|
|
|
}
|
|
|
|
|
2014-12-19 15:34:34 +03:00
|
|
|
/* test insertion of a bus with parent devices */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_10(void)
|
2014-12-19 15:34:34 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char *child_path;
|
|
|
|
|
|
|
|
/* device should disable */
|
2015-03-11 11:36:54 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
if (unittest(ret == 0,
|
2015-01-12 20:02:49 +03:00
|
|
|
"overlay test %d failed; overlay application\n", 10))
|
2014-12-19 15:34:34 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
|
|
|
|
unittest_path(10, PDEV_OVERLAY));
|
|
|
|
if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
|
2014-12-19 15:34:34 +03:00
|
|
|
return;
|
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
|
2014-12-19 15:34:34 +03:00
|
|
|
kfree(child_path);
|
2018-03-09 01:39:05 +03:00
|
|
|
|
|
|
|
unittest(ret, "overlay test %d failed; no child device\n", 10);
|
2014-12-19 15:34:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test insertion of a bus with parent devices (and revert) */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_11(void)
|
2014-12-19 15:34:34 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* device should disable */
|
2015-03-11 11:36:54 +03:00
|
|
|
ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
|
2015-01-12 20:02:49 +03:00
|
|
|
PDEV_OVERLAY);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2018-03-09 01:39:05 +03:00
|
|
|
unittest(ret == 0, "overlay test %d failed; overlay apply\n", 11);
|
2015-01-12 20:02:49 +03:00
|
|
|
}
|
|
|
|
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
struct unittest_i2c_bus_data {
|
2015-01-12 20:02:49 +03:00
|
|
|
struct platform_device *pdev;
|
|
|
|
struct i2c_adapter adap;
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_master_xfer(struct i2c_adapter *adap,
|
2015-01-12 20:02:49 +03:00
|
|
|
struct i2c_msg *msgs, int num)
|
|
|
|
{
|
2015-03-11 11:36:54 +03:00
|
|
|
struct unittest_i2c_bus_data *std = i2c_get_adapdata(adap);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
(void)std;
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static u32 unittest_i2c_functionality(struct i2c_adapter *adap)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static const struct i2c_algorithm unittest_i2c_algo = {
|
|
|
|
.master_xfer = unittest_i2c_master_xfer,
|
|
|
|
.functionality = unittest_i2c_functionality,
|
2015-01-12 20:02:49 +03:00
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_bus_probe(struct platform_device *pdev)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *np = dev->of_node;
|
2015-03-11 11:36:54 +03:00
|
|
|
struct unittest_i2c_bus_data *std;
|
2015-01-12 20:02:49 +03:00
|
|
|
struct i2c_adapter *adap;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (np == NULL) {
|
|
|
|
dev_err(dev, "No OF data for device\n");
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
std = devm_kzalloc(dev, sizeof(*std), GFP_KERNEL);
|
2019-05-02 15:45:35 +03:00
|
|
|
if (!std)
|
2015-01-12 20:02:49 +03:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* link them together */
|
|
|
|
std->pdev = pdev;
|
|
|
|
platform_set_drvdata(pdev, std);
|
|
|
|
|
|
|
|
adap = &std->adap;
|
|
|
|
i2c_set_adapdata(adap, std);
|
|
|
|
adap->nr = -1;
|
|
|
|
strlcpy(adap->name, pdev->name, sizeof(adap->name));
|
|
|
|
adap->class = I2C_CLASS_DEPRECATED;
|
2015-03-11 11:36:54 +03:00
|
|
|
adap->algo = &unittest_i2c_algo;
|
2015-01-12 20:02:49 +03:00
|
|
|
adap->dev.parent = dev;
|
|
|
|
adap->dev.of_node = dev->of_node;
|
|
|
|
adap->timeout = 5 * HZ;
|
|
|
|
adap->retries = 3;
|
|
|
|
|
|
|
|
ret = i2c_add_numbered_adapter(adap);
|
|
|
|
if (ret != 0) {
|
|
|
|
dev_err(dev, "Failed to add I2C adapter\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_bus_remove(struct platform_device *pdev)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *np = dev->of_node;
|
2015-03-11 11:36:54 +03:00
|
|
|
struct unittest_i2c_bus_data *std = platform_get_drvdata(pdev);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2015-01-12 20:02:49 +03:00
|
|
|
i2c_del_adapter(&std->adap);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-29 10:59:58 +03:00
|
|
|
static const struct of_device_id unittest_i2c_bus_match[] = {
|
2015-03-11 11:36:54 +03:00
|
|
|
{ .compatible = "unittest-i2c-bus", },
|
2015-01-12 20:02:49 +03:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static struct platform_driver unittest_i2c_bus_driver = {
|
|
|
|
.probe = unittest_i2c_bus_probe,
|
|
|
|
.remove = unittest_i2c_bus_remove,
|
2015-01-12 20:02:49 +03:00
|
|
|
.driver = {
|
2015-03-11 11:36:54 +03:00
|
|
|
.name = "unittest-i2c-bus",
|
|
|
|
.of_match_table = of_match_ptr(unittest_i2c_bus_match),
|
2015-01-12 20:02:49 +03:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_dev_probe(struct i2c_client *client,
|
2015-01-12 20:02:49 +03:00
|
|
|
const struct i2c_device_id *id)
|
|
|
|
{
|
|
|
|
struct device *dev = &client->dev;
|
|
|
|
struct device_node *np = client->dev.of_node;
|
|
|
|
|
|
|
|
if (!np) {
|
|
|
|
dev_err(dev, "No OF node\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_dev_remove(struct i2c_client *client)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &client->dev;
|
|
|
|
struct device_node *np = client->dev.of_node;
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2015-01-12 20:02:49 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static const struct i2c_device_id unittest_i2c_dev_id[] = {
|
|
|
|
{ .name = "unittest-i2c-dev" },
|
2015-01-12 20:02:49 +03:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static struct i2c_driver unittest_i2c_dev_driver = {
|
2015-01-12 20:02:49 +03:00
|
|
|
.driver = {
|
2015-03-11 11:36:54 +03:00
|
|
|
.name = "unittest-i2c-dev",
|
2015-01-12 20:02:49 +03:00
|
|
|
},
|
2015-03-11 11:36:54 +03:00
|
|
|
.probe = unittest_i2c_dev_probe,
|
|
|
|
.remove = unittest_i2c_dev_remove,
|
|
|
|
.id_table = unittest_i2c_dev_id,
|
2015-01-12 20:02:49 +03:00
|
|
|
};
|
|
|
|
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C_MUX)
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2016-04-20 09:42:47 +03:00
|
|
|
static int unittest_i2c_mux_select_chan(struct i2c_mux_core *muxc, u32 chan)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_mux_probe(struct i2c_client *client,
|
2015-01-12 20:02:49 +03:00
|
|
|
const struct i2c_device_id *id)
|
|
|
|
{
|
2018-03-09 01:39:04 +03:00
|
|
|
int i, nchans;
|
2015-01-12 20:02:49 +03:00
|
|
|
struct device *dev = &client->dev;
|
2019-06-10 12:51:56 +03:00
|
|
|
struct i2c_adapter *adap = client->adapter;
|
2015-01-12 20:02:49 +03:00
|
|
|
struct device_node *np = client->dev.of_node, *child;
|
2016-04-20 09:42:47 +03:00
|
|
|
struct i2c_mux_core *muxc;
|
2015-01-12 20:02:49 +03:00
|
|
|
u32 reg, max_reg;
|
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
if (!np) {
|
|
|
|
dev_err(dev, "No OF node\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
max_reg = (u32)-1;
|
|
|
|
for_each_child_of_node(np, child) {
|
2018-03-09 01:39:04 +03:00
|
|
|
if (of_property_read_u32(child, "reg", ®))
|
2015-01-12 20:02:49 +03:00
|
|
|
continue;
|
|
|
|
if (max_reg == (u32)-1 || reg > max_reg)
|
|
|
|
max_reg = reg;
|
|
|
|
}
|
|
|
|
nchans = max_reg == (u32)-1 ? 0 : max_reg + 1;
|
|
|
|
if (nchans == 0) {
|
|
|
|
dev_err(dev, "No channels\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-20 09:42:47 +03:00
|
|
|
muxc = i2c_mux_alloc(adap, dev, nchans, 0, 0,
|
|
|
|
unittest_i2c_mux_select_chan, NULL);
|
|
|
|
if (!muxc)
|
2015-01-12 20:02:49 +03:00
|
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < nchans; i++) {
|
2018-03-09 01:39:04 +03:00
|
|
|
if (i2c_mux_add_adapter(muxc, 0, i, 0)) {
|
2015-01-12 20:02:49 +03:00
|
|
|
dev_err(dev, "Failed to register mux #%d\n", i);
|
2016-04-20 09:42:47 +03:00
|
|
|
i2c_mux_del_adapters(muxc);
|
2015-01-12 20:02:49 +03:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-20 09:42:47 +03:00
|
|
|
i2c_set_clientdata(client, muxc);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int unittest_i2c_mux_remove(struct i2c_client *client)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
struct device *dev = &client->dev;
|
|
|
|
struct device_node *np = client->dev.of_node;
|
2016-04-20 09:42:47 +03:00
|
|
|
struct i2c_mux_core *muxc = i2c_get_clientdata(client);
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2017-06-01 23:50:55 +03:00
|
|
|
dev_dbg(dev, "%s for node @%pOF\n", __func__, np);
|
2016-04-20 09:42:47 +03:00
|
|
|
i2c_mux_del_adapters(muxc);
|
2015-01-12 20:02:49 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static const struct i2c_device_id unittest_i2c_mux_id[] = {
|
|
|
|
{ .name = "unittest-i2c-mux" },
|
2015-01-12 20:02:49 +03:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static struct i2c_driver unittest_i2c_mux_driver = {
|
2015-01-12 20:02:49 +03:00
|
|
|
.driver = {
|
2015-03-11 11:36:54 +03:00
|
|
|
.name = "unittest-i2c-mux",
|
2015-01-12 20:02:49 +03:00
|
|
|
},
|
2015-03-11 11:36:54 +03:00
|
|
|
.probe = unittest_i2c_mux_probe,
|
|
|
|
.remove = unittest_i2c_mux_remove,
|
|
|
|
.id_table = unittest_i2c_mux_id,
|
2015-01-12 20:02:49 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int of_unittest_overlay_i2c_init(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
ret = i2c_add_driver(&unittest_i2c_dev_driver);
|
|
|
|
if (unittest(ret == 0,
|
|
|
|
"could not register unittest i2c device driver\n"))
|
2015-01-12 20:02:49 +03:00
|
|
|
return ret;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
ret = platform_driver_register(&unittest_i2c_bus_driver);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
if (unittest(ret == 0,
|
|
|
|
"could not register unittest i2c bus driver\n"))
|
2015-01-12 20:02:49 +03:00
|
|
|
return ret;
|
|
|
|
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C_MUX)
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"i2c i2c-1: Added multiplexed i2c bus 2");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
ret = i2c_add_driver(&unittest_i2c_mux_driver);
|
2020-02-20 21:40:21 +03:00
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"i2c i2c-1: Added multiplexed i2c bus 2");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
if (unittest(ret == 0,
|
|
|
|
"could not register unittest i2c mux driver\n"))
|
2015-01-12 20:02:49 +03:00
|
|
|
return ret;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void of_unittest_overlay_i2c_cleanup(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C_MUX)
|
2015-03-11 11:36:54 +03:00
|
|
|
i2c_del_driver(&unittest_i2c_mux_driver);
|
2015-01-12 20:02:49 +03:00
|
|
|
#endif
|
2015-03-11 11:36:54 +03:00
|
|
|
platform_driver_unregister(&unittest_i2c_bus_driver);
|
|
|
|
i2c_del_driver(&unittest_i2c_dev_driver);
|
2015-01-12 20:02:49 +03:00
|
|
|
}
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_i2c_12(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
/* device should enable */
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
|
|
|
|
|
|
|
|
ret = of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest12/status");
|
|
|
|
|
|
|
|
if (ret)
|
2015-01-12 20:02:49 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 12);
|
2015-01-12 20:02:49 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* test deactivation of device */
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_i2c_13(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
|
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
/* device should disable */
|
2020-02-20 21:40:21 +03:00
|
|
|
ret = of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data/overlay-node/test-bus/i2c-test-bus/test-unittest13/status");
|
|
|
|
|
|
|
|
if (ret)
|
2014-12-19 15:34:34 +03:00
|
|
|
return;
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 13);
|
2015-01-12 20:02:49 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* just check for i2c mux existence */
|
2015-03-11 11:36:54 +03:00
|
|
|
static void of_unittest_overlay_i2c_14(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
2014-12-19 15:34:34 +03:00
|
|
|
}
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
static void __init of_unittest_overlay_i2c_15(void)
|
2015-01-12 20:02:49 +03:00
|
|
|
{
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
|
|
|
|
2015-01-12 20:02:49 +03:00
|
|
|
/* device should enable */
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_INFO,
|
|
|
|
"i2c i2c-1: Added multiplexed i2c bus 3");
|
|
|
|
|
|
|
|
ret = of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_INFO,
|
|
|
|
"i2c i2c-1: Added multiplexed i2c bus 3");
|
|
|
|
|
|
|
|
if (ret)
|
2015-01-12 20:02:49 +03:00
|
|
|
return;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "overlay test %d passed\n", 15);
|
2015-01-12 20:02:49 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static inline void of_unittest_overlay_i2c_14(void) { }
|
|
|
|
static inline void of_unittest_overlay_i2c_15(void) { }
|
2015-01-12 20:02:49 +03:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static void __init of_unittest_overlay(void)
|
2014-10-28 23:35:59 +03:00
|
|
|
{
|
|
|
|
struct device_node *bus_np = NULL;
|
|
|
|
|
2018-03-09 01:39:04 +03:00
|
|
|
if (platform_driver_register(&unittest_driver)) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "could not register unittest driver\n");
|
2014-10-28 23:35:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
bus_np = of_find_node_by_path(bus_path);
|
|
|
|
if (bus_np == NULL) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "could not find bus_path \"%s\"\n", bus_path);
|
2014-10-28 23:35:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-03-09 01:39:04 +03:00
|
|
|
if (of_platform_default_populate(bus_np, NULL, NULL)) {
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
|
2014-10-28 23:35:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
|
|
|
|
unittest(0, "could not find unittest0 @ \"%s\"\n",
|
|
|
|
unittest_path(100, PDEV_OVERLAY));
|
2014-10-28 23:35:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
|
|
|
|
unittest(0, "unittest1 @ \"%s\" should not exist\n",
|
|
|
|
unittest_path(101, PDEV_OVERLAY));
|
2014-10-28 23:35:59 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
unittest(1, "basic infrastructure of overlays passed");
|
2014-10-28 23:35:59 +03:00
|
|
|
|
|
|
|
/* tests in sequence */
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_overlay_0();
|
|
|
|
of_unittest_overlay_1();
|
|
|
|
of_unittest_overlay_2();
|
|
|
|
of_unittest_overlay_3();
|
|
|
|
of_unittest_overlay_4();
|
|
|
|
of_unittest_overlay_5();
|
|
|
|
of_unittest_overlay_6();
|
|
|
|
of_unittest_overlay_8();
|
|
|
|
|
|
|
|
of_unittest_overlay_10();
|
|
|
|
of_unittest_overlay_11();
|
2014-12-19 15:34:34 +03:00
|
|
|
|
2015-03-04 22:49:47 +03:00
|
|
|
#if IS_BUILTIN(CONFIG_I2C)
|
2015-03-11 11:36:54 +03:00
|
|
|
if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
|
2015-01-12 20:02:49 +03:00
|
|
|
goto out;
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_overlay_i2c_12();
|
|
|
|
of_unittest_overlay_i2c_13();
|
|
|
|
of_unittest_overlay_i2c_14();
|
|
|
|
of_unittest_overlay_i2c_15();
|
2015-01-12 20:02:49 +03:00
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_overlay_i2c_cleanup();
|
2015-01-12 20:02:49 +03:00
|
|
|
#endif
|
|
|
|
|
2020-02-20 21:40:20 +03:00
|
|
|
of_unittest_overlay_gpio();
|
|
|
|
|
2015-04-07 22:23:49 +03:00
|
|
|
of_unittest_destroy_tracked_overlays();
|
|
|
|
|
2014-10-28 23:35:59 +03:00
|
|
|
out:
|
|
|
|
of_node_put(bus_np);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2015-03-11 11:36:54 +03:00
|
|
|
static inline void __init of_unittest_overlay(void) { }
|
2014-10-28 23:35:59 +03:00
|
|
|
#endif
|
|
|
|
|
2017-07-19 19:25:20 +03:00
|
|
|
#ifdef CONFIG_OF_OVERLAY
|
|
|
|
|
2017-04-26 03:09:54 +03:00
|
|
|
/*
|
|
|
|
* __dtb_ot_begin[] and __dtb_ot_end[] are created by cmd_dt_S_dtb
|
|
|
|
* in scripts/Makefile.lib
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define OVERLAY_INFO_EXTERN(name) \
|
|
|
|
extern uint8_t __dtb_##name##_begin[]; \
|
|
|
|
extern uint8_t __dtb_##name##_end[]
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
#define OVERLAY_INFO(overlay_name, expected) \
|
|
|
|
{ .dtb_begin = __dtb_##overlay_name##_begin, \
|
|
|
|
.dtb_end = __dtb_##overlay_name##_end, \
|
|
|
|
.expected_result = expected, \
|
|
|
|
.name = #overlay_name, \
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
struct overlay_info {
|
2018-02-12 11:19:42 +03:00
|
|
|
uint8_t *dtb_begin;
|
|
|
|
uint8_t *dtb_end;
|
|
|
|
int expected_result;
|
|
|
|
int overlay_id;
|
|
|
|
char *name;
|
2017-04-26 03:09:54 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_base);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay);
|
2018-02-12 11:19:42 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_0);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_1);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_2);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_3);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_4);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_5);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_6);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_7);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_8);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_9);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_10);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_11);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_12);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_13);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_15);
|
2020-02-20 21:40:20 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_01);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_02a);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_02b);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_03);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_04a);
|
|
|
|
OVERLAY_INFO_EXTERN(overlay_gpio_04b);
|
2018-10-05 06:34:33 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_bad_add_dup_node);
|
of: overlay: check prevents multiple fragments touching same property
Add test case of two fragments updating the same property. After
adding the test case, the system hangs at end of boot, after
after slub stack dumps from kfree() in crypto modprobe code.
Multiple overlay fragments adding, modifying, or deleting the same
property is not supported. Add check to detect the attempt and fail
the overlay apply.
Before this patch, the first fragment error would terminate
processing. Allow fragment checking to proceed and report all
of the fragment errors before terminating the overlay apply. This
is not a hot path, thus not a performance issue (the error is not
transient and requires fixing the overlay before attempting to
apply it again).
After applying this patch, the devicetree unittest messages will
include:
OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/rpm_avail
...
### dt-test ### end of unittest - 212 passed, 0 failed
The check to detect two fragments updating the same property is
folded into the patch that created the test case to maintain
bisectability.
Tested-by: Alan Tull <atull@kernel.org>
Signed-off-by: Frank Rowand <frank.rowand@sony.com>
2018-10-05 06:36:18 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_bad_add_dup_prop);
|
2017-04-26 03:09:54 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_bad_phandle);
|
2017-07-19 19:25:20 +03:00
|
|
|
OVERLAY_INFO_EXTERN(overlay_bad_symbol);
|
2017-04-26 03:09:54 +03:00
|
|
|
|
2018-10-05 06:41:03 +03:00
|
|
|
/* entries found by name */
|
2017-04-26 03:09:54 +03:00
|
|
|
static struct overlay_info overlays[] = {
|
|
|
|
OVERLAY_INFO(overlay_base, -9999),
|
|
|
|
OVERLAY_INFO(overlay, 0),
|
2018-02-12 11:19:42 +03:00
|
|
|
OVERLAY_INFO(overlay_0, 0),
|
|
|
|
OVERLAY_INFO(overlay_1, 0),
|
|
|
|
OVERLAY_INFO(overlay_2, 0),
|
|
|
|
OVERLAY_INFO(overlay_3, 0),
|
|
|
|
OVERLAY_INFO(overlay_4, 0),
|
|
|
|
OVERLAY_INFO(overlay_5, 0),
|
|
|
|
OVERLAY_INFO(overlay_6, 0),
|
|
|
|
OVERLAY_INFO(overlay_7, 0),
|
|
|
|
OVERLAY_INFO(overlay_8, 0),
|
|
|
|
OVERLAY_INFO(overlay_9, 0),
|
|
|
|
OVERLAY_INFO(overlay_10, 0),
|
|
|
|
OVERLAY_INFO(overlay_11, 0),
|
|
|
|
OVERLAY_INFO(overlay_12, 0),
|
|
|
|
OVERLAY_INFO(overlay_13, 0),
|
|
|
|
OVERLAY_INFO(overlay_15, 0),
|
2020-02-20 21:40:20 +03:00
|
|
|
OVERLAY_INFO(overlay_gpio_01, 0),
|
|
|
|
OVERLAY_INFO(overlay_gpio_02a, 0),
|
|
|
|
OVERLAY_INFO(overlay_gpio_02b, 0),
|
|
|
|
OVERLAY_INFO(overlay_gpio_03, 0),
|
|
|
|
OVERLAY_INFO(overlay_gpio_04a, 0),
|
|
|
|
OVERLAY_INFO(overlay_gpio_04b, 0),
|
2018-10-05 06:34:33 +03:00
|
|
|
OVERLAY_INFO(overlay_bad_add_dup_node, -EINVAL),
|
of: overlay: check prevents multiple fragments touching same property
Add test case of two fragments updating the same property. After
adding the test case, the system hangs at end of boot, after
after slub stack dumps from kfree() in crypto modprobe code.
Multiple overlay fragments adding, modifying, or deleting the same
property is not supported. Add check to detect the attempt and fail
the overlay apply.
Before this patch, the first fragment error would terminate
processing. Allow fragment checking to proceed and report all
of the fragment errors before terminating the overlay apply. This
is not a hot path, thus not a performance issue (the error is not
transient and requires fixing the overlay before attempting to
apply it again).
After applying this patch, the devicetree unittest messages will
include:
OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/rpm_avail
...
### dt-test ### end of unittest - 212 passed, 0 failed
The check to detect two fragments updating the same property is
folded into the patch that created the test case to maintain
bisectability.
Tested-by: Alan Tull <atull@kernel.org>
Signed-off-by: Frank Rowand <frank.rowand@sony.com>
2018-10-05 06:36:18 +03:00
|
|
|
OVERLAY_INFO(overlay_bad_add_dup_prop, -EINVAL),
|
2017-04-26 03:09:54 +03:00
|
|
|
OVERLAY_INFO(overlay_bad_phandle, -EINVAL),
|
2017-07-19 19:25:20 +03:00
|
|
|
OVERLAY_INFO(overlay_bad_symbol, -EINVAL),
|
2018-10-05 06:41:03 +03:00
|
|
|
/* end marker */
|
|
|
|
{.dtb_begin = NULL, .dtb_end = NULL, .expected_result = 0, .name = NULL}
|
2017-04-26 03:09:54 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct device_node *overlay_base_root;
|
|
|
|
|
2018-01-06 00:32:33 +03:00
|
|
|
static void * __init dt_alloc_memory(u64 size, u64 align)
|
|
|
|
{
|
2019-03-12 09:30:31 +03:00
|
|
|
void *ptr = memblock_alloc(size, align);
|
|
|
|
|
|
|
|
if (!ptr)
|
|
|
|
panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
|
|
|
|
__func__, size, align);
|
|
|
|
|
|
|
|
return ptr;
|
2018-01-06 00:32:33 +03:00
|
|
|
}
|
|
|
|
|
2017-04-26 03:09:54 +03:00
|
|
|
/*
|
|
|
|
* Create base device tree for the overlay unittest.
|
|
|
|
*
|
|
|
|
* This is called from very early boot code.
|
|
|
|
*
|
|
|
|
* Do as much as possible the same way as done in __unflatten_device_tree
|
|
|
|
* and other early boot steps for the normal FDT so that the overlay base
|
|
|
|
* unflattened tree will have the same characteristics as the real tree
|
|
|
|
* (such as having memory allocated by the early allocator). The goal
|
|
|
|
* is to test "the real thing" as much as possible, and test "test setup
|
|
|
|
* code" as little as possible.
|
|
|
|
*
|
|
|
|
* Have to stop before resolving phandles, because that uses kmalloc.
|
|
|
|
*/
|
|
|
|
void __init unittest_unflatten_overlay_base(void)
|
|
|
|
{
|
|
|
|
struct overlay_info *info;
|
|
|
|
u32 data_size;
|
2018-02-12 11:19:42 +03:00
|
|
|
void *new_fdt;
|
2017-04-26 03:09:54 +03:00
|
|
|
u32 size;
|
2018-10-05 06:41:03 +03:00
|
|
|
int found = 0;
|
|
|
|
const char *overlay_name = "overlay_base";
|
|
|
|
|
|
|
|
for (info = overlays; info && info->name; info++) {
|
|
|
|
if (!strcmp(overlay_name, info->name)) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) {
|
|
|
|
pr_err("no overlay data for %s\n", overlay_name);
|
|
|
|
return;
|
|
|
|
}
|
2017-04-26 03:09:54 +03:00
|
|
|
|
|
|
|
info = &overlays[0];
|
|
|
|
|
|
|
|
if (info->expected_result != -9999) {
|
|
|
|
pr_err("No dtb 'overlay_base' to attach\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data_size = info->dtb_end - info->dtb_begin;
|
|
|
|
if (!data_size) {
|
|
|
|
pr_err("No dtb 'overlay_base' to attach\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = fdt_totalsize(info->dtb_begin);
|
|
|
|
if (size != data_size) {
|
|
|
|
pr_err("dtb 'overlay_base' header totalsize != actual size");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
new_fdt = dt_alloc_memory(size, roundup_pow_of_two(FDT_V17_SIZE));
|
|
|
|
if (!new_fdt) {
|
2017-04-26 03:09:54 +03:00
|
|
|
pr_err("alloc for dtb 'overlay_base' failed");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
memcpy(new_fdt, info->dtb_begin, size);
|
2017-04-26 03:09:54 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
__unflatten_device_tree(new_fdt, NULL, &overlay_base_root,
|
2018-01-06 00:32:33 +03:00
|
|
|
dt_alloc_memory, true);
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The purpose of of_unittest_overlay_data_add is to add an
|
|
|
|
* overlay in the normal fashion. This is a test of the whole
|
|
|
|
* picture, instead of testing individual elements.
|
|
|
|
*
|
|
|
|
* A secondary purpose is to be able to verify that the contents of
|
|
|
|
* /proc/device-tree/ contains the updated structure and values from
|
|
|
|
* the overlay. That must be verified separately in user space.
|
|
|
|
*
|
|
|
|
* Return 0 on unexpected error.
|
|
|
|
*/
|
2018-02-12 11:19:42 +03:00
|
|
|
static int __init overlay_data_apply(const char *overlay_name, int *overlay_id)
|
2017-04-26 03:09:54 +03:00
|
|
|
{
|
|
|
|
struct overlay_info *info;
|
2018-02-12 11:19:42 +03:00
|
|
|
int found = 0;
|
2017-04-26 03:09:54 +03:00
|
|
|
int ret;
|
|
|
|
u32 size;
|
|
|
|
|
2018-10-05 06:41:03 +03:00
|
|
|
for (info = overlays; info && info->name; info++) {
|
2018-02-12 11:19:42 +03:00
|
|
|
if (!strcmp(overlay_name, info->name)) {
|
|
|
|
found = 1;
|
2017-04-26 03:09:54 +03:00
|
|
|
break;
|
2018-02-12 11:19:42 +03:00
|
|
|
}
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
2018-02-12 11:19:42 +03:00
|
|
|
if (!found) {
|
|
|
|
pr_err("no overlay data for %s\n", overlay_name);
|
2017-04-26 03:09:54 +03:00
|
|
|
return 0;
|
2018-02-12 11:19:42 +03:00
|
|
|
}
|
2017-04-26 03:09:54 +03:00
|
|
|
|
|
|
|
size = info->dtb_end - info->dtb_begin;
|
2018-03-09 01:39:05 +03:00
|
|
|
if (!size)
|
2018-02-12 11:19:42 +03:00
|
|
|
pr_err("no overlay data for %s\n", overlay_name);
|
2017-04-26 03:09:54 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
ret = of_overlay_fdt_apply(info->dtb_begin, size, &info->overlay_id);
|
|
|
|
if (overlay_id)
|
|
|
|
*overlay_id = info->overlay_id;
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2017-04-26 03:09:54 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
pr_debug("%s applied\n", overlay_name);
|
2017-04-26 03:09:54 +03:00
|
|
|
|
|
|
|
out:
|
2018-02-12 11:19:42 +03:00
|
|
|
if (ret != info->expected_result)
|
|
|
|
pr_err("of_overlay_fdt_apply() expected %d, ret=%d, %s\n",
|
|
|
|
info->expected_result, ret, overlay_name);
|
|
|
|
|
2017-04-26 03:09:54 +03:00
|
|
|
return (ret == info->expected_result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The purpose of of_unittest_overlay_high_level is to add an overlay
|
|
|
|
* in the normal fashion. This is a test of the whole picture,
|
|
|
|
* instead of individual elements.
|
|
|
|
*
|
|
|
|
* The first part of the function is _not_ normal overlay usage; it is
|
|
|
|
* finishing splicing the base overlay device tree into the live tree.
|
|
|
|
*/
|
|
|
|
static __init void of_unittest_overlay_high_level(void)
|
|
|
|
{
|
|
|
|
struct device_node *last_sibling;
|
|
|
|
struct device_node *np;
|
|
|
|
struct device_node *of_symbols;
|
|
|
|
struct device_node *overlay_base_symbols;
|
|
|
|
struct device_node **pprev;
|
|
|
|
struct property *prop;
|
2020-02-20 21:40:21 +03:00
|
|
|
int ret;
|
2017-04-26 03:09:54 +03:00
|
|
|
|
|
|
|
if (!overlay_base_root) {
|
|
|
|
unittest(0, "overlay_base_root not initialized\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Could not fixup phandles in unittest_unflatten_overlay_base()
|
|
|
|
* because kmalloc() was not yet available.
|
|
|
|
*/
|
2017-10-18 02:36:29 +03:00
|
|
|
of_overlay_mutex_lock();
|
2017-04-26 03:09:54 +03:00
|
|
|
of_resolve_phandles(overlay_base_root);
|
2017-10-18 02:36:29 +03:00
|
|
|
of_overlay_mutex_unlock();
|
|
|
|
|
2017-04-26 03:09:54 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* do not allow overlay_base to duplicate any node already in
|
|
|
|
* tree, this greatly simplifies the code
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove overlay_base_root node "__local_fixups", after
|
|
|
|
* being used by of_resolve_phandles()
|
|
|
|
*/
|
|
|
|
pprev = &overlay_base_root->child;
|
|
|
|
for (np = overlay_base_root->child; np; np = np->sibling) {
|
2018-08-27 16:37:06 +03:00
|
|
|
if (of_node_name_eq(np, "__local_fixups__")) {
|
2017-04-26 03:09:54 +03:00
|
|
|
*pprev = np->sibling;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pprev = &np->sibling;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove overlay_base_root node "__symbols__" if in live tree */
|
|
|
|
of_symbols = of_get_child_by_name(of_root, "__symbols__");
|
|
|
|
if (of_symbols) {
|
|
|
|
/* will have to graft properties from node into live tree */
|
|
|
|
pprev = &overlay_base_root->child;
|
|
|
|
for (np = overlay_base_root->child; np; np = np->sibling) {
|
2018-08-27 16:37:06 +03:00
|
|
|
if (of_node_name_eq(np, "__symbols__")) {
|
2017-04-26 03:09:54 +03:00
|
|
|
overlay_base_symbols = np;
|
|
|
|
*pprev = np->sibling;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pprev = &np->sibling;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-27 16:38:08 +03:00
|
|
|
for_each_child_of_node(overlay_base_root, np) {
|
|
|
|
struct device_node *base_child;
|
|
|
|
for_each_child_of_node(of_root, base_child) {
|
|
|
|
if (!strcmp(np->full_name, base_child->full_name)) {
|
|
|
|
unittest(0, "illegal node name in overlay_base %pOFn",
|
|
|
|
np);
|
|
|
|
return;
|
|
|
|
}
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* overlay 'overlay_base' is not allowed to have root
|
|
|
|
* properties, so only need to splice nodes into main device tree.
|
|
|
|
*
|
|
|
|
* root node of *overlay_base_root will not be freed, it is lost
|
|
|
|
* memory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
for (np = overlay_base_root->child; np; np = np->sibling)
|
|
|
|
np->parent = of_root;
|
|
|
|
|
|
|
|
mutex_lock(&of_mutex);
|
|
|
|
|
2017-04-28 12:44:11 +03:00
|
|
|
for (last_sibling = np = of_root->child; np; np = np->sibling)
|
2017-04-26 03:09:54 +03:00
|
|
|
last_sibling = np;
|
|
|
|
|
|
|
|
if (last_sibling)
|
|
|
|
last_sibling->sibling = overlay_base_root->child;
|
|
|
|
else
|
|
|
|
of_root->child = overlay_base_root->child;
|
|
|
|
|
|
|
|
for_each_of_allnodes_from(overlay_base_root, np)
|
|
|
|
__of_attach_node_sysfs(np);
|
|
|
|
|
|
|
|
if (of_symbols) {
|
2018-02-12 11:19:42 +03:00
|
|
|
struct property *new_prop;
|
2017-04-26 03:09:54 +03:00
|
|
|
for_each_property_of_node(overlay_base_symbols, prop) {
|
2018-02-12 11:19:42 +03:00
|
|
|
|
|
|
|
new_prop = __of_prop_dup(prop, GFP_KERNEL);
|
|
|
|
if (!new_prop) {
|
|
|
|
unittest(0, "__of_prop_dup() of '%s' from overlay_base node __symbols__",
|
|
|
|
prop->name);
|
|
|
|
goto err_unlock;
|
|
|
|
}
|
2018-03-09 01:39:04 +03:00
|
|
|
if (__of_add_property(of_symbols, new_prop)) {
|
2020-04-17 00:42:48 +03:00
|
|
|
kfree(new_prop->name);
|
|
|
|
kfree(new_prop->value);
|
|
|
|
kfree(new_prop);
|
2018-03-09 01:39:04 +03:00
|
|
|
/* "name" auto-generated by unflatten */
|
2020-04-17 00:42:48 +03:00
|
|
|
if (!strcmp(prop->name, "name"))
|
2018-02-12 11:19:42 +03:00
|
|
|
continue;
|
|
|
|
unittest(0, "duplicate property '%s' in overlay_base node __symbols__",
|
2017-04-26 03:09:54 +03:00
|
|
|
prop->name);
|
2017-05-03 22:49:50 +03:00
|
|
|
goto err_unlock;
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
2018-03-09 01:39:04 +03:00
|
|
|
if (__of_add_property_sysfs(of_symbols, new_prop)) {
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(0, "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
|
2017-04-26 03:09:54 +03:00
|
|
|
prop->name);
|
2017-05-03 22:49:50 +03:00
|
|
|
goto err_unlock;
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&of_mutex);
|
|
|
|
|
|
|
|
|
|
|
|
/* now do the normal overlay usage test */
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
|
|
|
|
|
|
|
|
ret = overlay_data_apply("overlay", NULL);
|
|
|
|
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_right");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200_left");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/ride_200");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /__symbols__/hvac_2");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/rate");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/color");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/lights@40000/status");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@40/incline-up");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/ride@100/track@30/incline-up");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/fairway-1/status");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: WARNING: memory leak will occur if overlay removed, property: /testcase-data-2/substation@100/status");
|
|
|
|
|
|
|
|
unittest(ret, "Adding overlay 'overlay' failed\n");
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
|
2017-04-26 03:09:54 +03:00
|
|
|
|
2018-10-05 06:34:33 +03:00
|
|
|
unittest(overlay_data_apply("overlay_bad_add_dup_node", NULL),
|
|
|
|
"Adding overlay 'overlay_bad_add_dup_node' failed\n");
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/controller/name");
|
|
|
|
EXPECT_END(KERN_ERR,
|
|
|
|
"OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/controller");
|
|
|
|
|
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_BEGIN(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
of: overlay: check prevents multiple fragments touching same property
Add test case of two fragments updating the same property. After
adding the test case, the system hangs at end of boot, after
after slub stack dumps from kfree() in crypto modprobe code.
Multiple overlay fragments adding, modifying, or deleting the same
property is not supported. Add check to detect the attempt and fail
the overlay apply.
Before this patch, the first fragment error would terminate
processing. Allow fragment checking to proceed and report all
of the fragment errors before terminating the overlay apply. This
is not a hot path, thus not a performance issue (the error is not
transient and requires fixing the overlay before attempting to
apply it again).
After applying this patch, the devicetree unittest messages will
include:
OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/rpm_avail
...
### dt-test ### end of unittest - 212 passed, 0 failed
The check to detect two fragments updating the same property is
folded into the patch that created the test case to maintain
bisectability.
Tested-by: Alan Tull <atull@kernel.org>
Signed-off-by: Frank Rowand <frank.rowand@sony.com>
2018-10-05 06:36:18 +03:00
|
|
|
unittest(overlay_data_apply("overlay_bad_add_dup_prop", NULL),
|
|
|
|
"Adding overlay 'overlay_bad_add_dup_prop' failed\n");
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/name");
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add, update, and/or delete property /testcase-data-2/substation@100/motor-1/electric/rpm_avail");
|
2020-02-20 21:40:21 +03:00
|
|
|
EXPECT_END(KERN_ERR,
|
2020-04-17 00:42:50 +03:00
|
|
|
"OF: overlay: ERROR: multiple fragments add and/or delete node /testcase-data-2/substation@100/motor-1/electric");
|
2020-02-20 21:40:21 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(overlay_data_apply("overlay_bad_phandle", NULL),
|
2017-04-26 03:09:54 +03:00
|
|
|
"Adding overlay 'overlay_bad_phandle' failed\n");
|
2017-07-19 19:25:20 +03:00
|
|
|
|
2018-02-12 11:19:42 +03:00
|
|
|
unittest(overlay_data_apply("overlay_bad_symbol", NULL),
|
2017-07-19 19:25:20 +03:00
|
|
|
"Adding overlay 'overlay_bad_symbol' failed\n");
|
|
|
|
|
2017-05-03 22:49:50 +03:00
|
|
|
return;
|
|
|
|
|
|
|
|
err_unlock:
|
|
|
|
mutex_unlock(&of_mutex);
|
2017-04-26 03:09:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static inline __init void of_unittest_overlay_high_level(void) {}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
static int __init of_unittest(void)
|
2011-12-12 20:25:57 +04:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
2014-07-17 10:09:39 +04:00
|
|
|
int res;
|
|
|
|
|
2020-02-20 21:40:21 +03:00
|
|
|
pr_info("start of unittest - you will see error messages\n");
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
/* adding data for unittest */
|
2019-02-20 02:54:22 +03:00
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_UML))
|
|
|
|
unittest_unflatten_overlay_base();
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
res = unittest_data_add();
|
2014-07-17 10:09:39 +04:00
|
|
|
if (res)
|
|
|
|
return res;
|
2014-11-19 20:13:44 +03:00
|
|
|
if (!of_aliases)
|
|
|
|
of_aliases = of_find_node_by_path("/aliases");
|
2011-12-12 20:25:57 +04:00
|
|
|
|
|
|
|
np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
|
|
|
|
if (!np) {
|
|
|
|
pr_info("No testcase data in device tree; not running tests\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
of_node_put(np);
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_check_tree_linkage();
|
|
|
|
of_unittest_check_phandles();
|
|
|
|
of_unittest_find_node_by_name();
|
|
|
|
of_unittest_dynamic();
|
|
|
|
of_unittest_parse_phandle_with_args();
|
2018-01-31 05:36:17 +03:00
|
|
|
of_unittest_parse_phandle_with_args_map();
|
vsprintf: Add %p extension "%pOF" for device tree
90% of the usage of device node's full_name is printing it out in a
kernel message. However, storing the full path for every node is
wasteful and redundant. With a custom format specifier, we can generate
the full path at run-time and eventually remove the full path from every
node.
For instance typical use is:
pr_info("Frobbing node %s\n", node->full_name);
Which can be written now as:
pr_info("Frobbing node %pOF\n", node);
'%pO' is the base specifier to represent kobjects with '%pOF'
representing struct device_node. Currently, struct device_node is the
only supported type of kobject.
More fine-grained control of formatting includes printing the name,
flags, path-spec name and others, explained in the documentation entry.
Originally written by Pantelis, but pretty much rewrote the core
function using existing string/number functions. The 2 passes were
unnecessary and have been removed. Also, updated the checkpatch.pl
check. The unittest code was written by Grant Likely.
Signed-off-by: Pantelis Antoniou <pantelis.antoniou@konsulko.com>
Acked-by: Joe Perches <joe@perches.com>
Signed-off-by: Rob Herring <robh@kernel.org>
2015-01-21 20:06:14 +03:00
|
|
|
of_unittest_printf();
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_property_string();
|
|
|
|
of_unittest_property_copy();
|
|
|
|
of_unittest_changeset();
|
|
|
|
of_unittest_parse_interrupts();
|
|
|
|
of_unittest_parse_interrupts_extended();
|
2020-11-19 20:53:56 +03:00
|
|
|
of_unittest_dma_get_max_cpu_address();
|
2019-09-20 21:28:53 +03:00
|
|
|
of_unittest_parse_dma_ranges();
|
|
|
|
of_unittest_pci_dma_ranges();
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_match_node();
|
|
|
|
of_unittest_platform_populate();
|
|
|
|
of_unittest_overlay();
|
2014-07-17 10:09:39 +04:00
|
|
|
|
2014-10-01 20:40:22 +04:00
|
|
|
/* Double check linkage after removing testcase data */
|
2015-03-11 11:36:54 +03:00
|
|
|
of_unittest_check_tree_linkage();
|
2014-10-01 20:40:22 +04:00
|
|
|
|
2017-04-26 03:09:54 +03:00
|
|
|
of_unittest_overlay_high_level();
|
|
|
|
|
2015-03-11 11:36:54 +03:00
|
|
|
pr_info("end of unittest - %i passed, %i failed\n",
|
|
|
|
unittest_results.passed, unittest_results.failed);
|
2014-10-01 20:40:22 +04:00
|
|
|
|
2011-12-12 20:25:57 +04:00
|
|
|
return 0;
|
|
|
|
}
|
2015-03-11 11:36:54 +03:00
|
|
|
late_initcall(of_unittest);
|