2019-06-01 08:08:42 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2012-10-04 13:32:52 +00:00
|
|
|
/*
|
|
|
|
* OF helpers for parsing display timings
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
|
|
|
|
*
|
|
|
|
* based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de>
|
|
|
|
*/
|
|
|
|
#include <linux/export.h>
|
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <video/display_timing.h>
|
|
|
|
#include <video/of_display_timing.h>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* parse_timing_property - parse timing_entry from device_node
|
|
|
|
* @np: device_node with the property
|
|
|
|
* @name: name of the property
|
|
|
|
* @result: will be set to the return value
|
|
|
|
*
|
|
|
|
* DESCRIPTION:
|
|
|
|
* Every display_timing can be specified with either just the typical value or
|
|
|
|
* a range consisting of min/typ/max. This function helps handling this
|
|
|
|
**/
|
2013-05-27 12:33:05 +00:00
|
|
|
static int parse_timing_property(const struct device_node *np, const char *name,
|
2012-10-04 13:32:52 +00:00
|
|
|
struct timing_entry *result)
|
|
|
|
{
|
|
|
|
struct property *prop;
|
|
|
|
int length, cells, ret;
|
|
|
|
|
|
|
|
prop = of_find_property(np, name, &length);
|
|
|
|
if (!prop) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: could not find property %s\n", np, name);
|
2012-10-04 13:32:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cells = length / sizeof(u32);
|
|
|
|
if (cells == 1) {
|
|
|
|
ret = of_property_read_u32(np, name, &result->typ);
|
|
|
|
result->min = result->typ;
|
|
|
|
result->max = result->typ;
|
|
|
|
} else if (cells == 3) {
|
|
|
|
ret = of_property_read_u32_array(np, name, &result->min, cells);
|
|
|
|
} else {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: illegal timing specification in %s\n", np, name);
|
2012-10-04 13:32:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-05-16 12:36:38 +00:00
|
|
|
* of_parse_display_timing - parse display_timing entry from device_node
|
2012-10-04 13:32:52 +00:00
|
|
|
* @np: device_node with the properties
|
|
|
|
**/
|
Merge branch 'drm-next' of git://people.freedesktop.org/~airlied/linux
Pull drm updates from Dave Airlie:
"Okay this is the big one, I was stalled on the fbdev pull req as I
stupidly let fbdev guys merge a patch I required to fix a warning with
some patches I had, they ended up merging the patch from the wrong
place, but the warning should be fixed. In future I'll just take the
patch myself!
Outside drm:
There are some snd changes for the HDMI audio interactions on haswell,
they've been acked for inclusion via my tree. This relies on the
wound/wait tree from Ingo which is already merged.
Major changes:
AMD finally released the dynamic power management code for all their
GPUs from r600->present day, this is great, off by default for now but
also a huge amount of code, in fact it is most of this pull request.
Since it landed there has been a lot of community testing and Alex has
sent a lot of fixes for any bugs found so far. I suspect radeon might
now be the biggest kernel driver ever :-P p.s. radeon.dpm=1 to enable
dynamic powermanagement for anyone.
New drivers:
Renesas r-car display unit.
Other highlights:
- core: GEM CMA prime support, use new w/w mutexs for TTM
reservations, cursor hotspot, doc updates
- dvo chips: chrontel 7010B support
- i915: Haswell (fbc, ips, vecs, watermarks, audio powerwell),
Valleyview (enabled by default, rc6), lots of pll reworking, 30bpp
support (this time for sure)
- nouveau: async buffer object deletion, context/register init
updates, kernel vp2 engine support, GF117 support, GK110 accel
support (with external nvidia ucode), context cleanups.
- exynos: memory leak fixes, Add S3C64XX SoC series support, device
tree updates, common clock framework support,
- qxl: cursor hotspot support, multi-monitor support, suspend/resume
support
- mgag200: hw cursor support, g200 mode limiting
- shmobile: prime support
- tegra: fixes mostly
I've been banging on this quite a lot due to the size of it, and it
seems to okay on everything I've tested it on."
* 'drm-next' of git://people.freedesktop.org/~airlied/linux: (811 commits)
drm/radeon/dpm: implement vblank_too_short callback for si
drm/radeon/dpm: implement vblank_too_short callback for cayman
drm/radeon/dpm: implement vblank_too_short callback for btc
drm/radeon/dpm: implement vblank_too_short callback for evergreen
drm/radeon/dpm: implement vblank_too_short callback for 7xx
drm/radeon/dpm: add checks against vblank time
drm/radeon/dpm: add helper to calculate vblank time
drm/radeon: remove stray line in old pm code
drm/radeon/dpm: fix display_gap programming on rv7xx
drm/nvc0/gr: fix gpc firmware regression
drm/nouveau: fix minor thinko causing bo moves to not be async on kepler
drm/radeon/dpm: implement force performance level for TN
drm/radeon/dpm: implement force performance level for ON/LN
drm/radeon/dpm: implement force performance level for SI
drm/radeon/dpm: implement force performance level for cayman
drm/radeon/dpm: implement force performance levels for 7xx/eg/btc
drm/radeon/dpm: add infrastructure to force performance levels
drm/radeon: fix surface setup on r1xx
drm/radeon: add support for 3d perf states on older asics
drm/radeon: set default clocks for SI when DPM is disabled
...
2013-07-09 23:04:31 +00:00
|
|
|
static int of_parse_display_timing(const struct device_node *np,
|
2013-05-16 12:29:06 +00:00
|
|
|
struct display_timing *dt)
|
2012-10-04 13:32:52 +00:00
|
|
|
{
|
|
|
|
u32 val = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
2013-05-16 12:29:06 +00:00
|
|
|
memset(dt, 0, sizeof(*dt));
|
2012-10-04 13:32:52 +00:00
|
|
|
|
|
|
|
ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
|
|
|
|
ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
|
|
|
|
ret |= parse_timing_property(np, "hactive", &dt->hactive);
|
|
|
|
ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
|
|
|
|
ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
|
|
|
|
ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
|
|
|
|
ret |= parse_timing_property(np, "vactive", &dt->vactive);
|
|
|
|
ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
|
|
|
|
ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
|
|
|
|
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags = 0;
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!of_property_read_u32(np, "vsync-active", &val))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
|
|
|
|
DISPLAY_FLAGS_VSYNC_LOW;
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!of_property_read_u32(np, "hsync-active", &val))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
|
|
|
|
DISPLAY_FLAGS_HSYNC_LOW;
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!of_property_read_u32(np, "de-active", &val))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
|
2012-10-04 13:32:52 +00:00
|
|
|
DISPLAY_FLAGS_DE_LOW;
|
|
|
|
if (!of_property_read_u32(np, "pixelclk-active", &val))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
|
2012-10-04 13:32:52 +00:00
|
|
|
DISPLAY_FLAGS_PIXDATA_NEGEDGE;
|
|
|
|
|
2016-09-22 10:35:26 +00:00
|
|
|
if (!of_property_read_u32(np, "syncclk-active", &val))
|
|
|
|
dt->flags |= val ? DISPLAY_FLAGS_SYNC_POSEDGE :
|
|
|
|
DISPLAY_FLAGS_SYNC_NEGEDGE;
|
|
|
|
else if (dt->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE |
|
|
|
|
DISPLAY_FLAGS_PIXDATA_NEGEDGE))
|
|
|
|
dt->flags |= dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ?
|
|
|
|
DISPLAY_FLAGS_SYNC_POSEDGE :
|
|
|
|
DISPLAY_FLAGS_SYNC_NEGEDGE;
|
|
|
|
|
2012-10-04 13:32:52 +00:00
|
|
|
if (of_property_read_bool(np, "interlaced"))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= DISPLAY_FLAGS_INTERLACED;
|
2012-10-04 13:32:52 +00:00
|
|
|
if (of_property_read_bool(np, "doublescan"))
|
2013-03-12 08:26:45 +00:00
|
|
|
dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
|
2013-05-27 12:33:34 +00:00
|
|
|
if (of_property_read_bool(np, "doubleclk"))
|
|
|
|
dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
|
2012-10-04 13:32:52 +00:00
|
|
|
|
|
|
|
if (ret) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: error reading timing properties\n", np);
|
2013-05-16 12:29:06 +00:00
|
|
|
return -EINVAL;
|
2012-10-04 13:32:52 +00:00
|
|
|
}
|
|
|
|
|
2013-05-16 12:29:06 +00:00
|
|
|
return 0;
|
2012-10-04 13:32:52 +00:00
|
|
|
}
|
|
|
|
|
2013-05-16 12:36:38 +00:00
|
|
|
/**
|
|
|
|
* of_get_display_timing - parse a display_timing entry
|
|
|
|
* @np: device_node with the timing subnode
|
|
|
|
* @name: name of the timing node
|
|
|
|
* @dt: display_timing struct to fill
|
|
|
|
**/
|
2016-10-03 13:55:48 +00:00
|
|
|
int of_get_display_timing(const struct device_node *np, const char *name,
|
2013-05-16 12:36:38 +00:00
|
|
|
struct display_timing *dt)
|
|
|
|
{
|
|
|
|
struct device_node *timing_np;
|
2019-07-22 18:24:36 +00:00
|
|
|
int ret;
|
2013-05-16 12:36:38 +00:00
|
|
|
|
2014-05-13 12:58:21 +00:00
|
|
|
if (!np)
|
2013-05-16 12:36:38 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-09-25 11:51:31 +00:00
|
|
|
timing_np = of_get_child_by_name(np, name);
|
2019-07-22 18:24:37 +00:00
|
|
|
if (!timing_np)
|
2013-05-16 12:36:38 +00:00
|
|
|
return -ENOENT;
|
|
|
|
|
2019-07-22 18:24:36 +00:00
|
|
|
ret = of_parse_display_timing(timing_np, dt);
|
|
|
|
|
|
|
|
of_node_put(timing_np);
|
|
|
|
|
|
|
|
return ret;
|
2013-05-16 12:36:38 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_get_display_timing);
|
|
|
|
|
2012-10-04 13:32:52 +00:00
|
|
|
/**
|
|
|
|
* of_get_display_timings - parse all display_timing entries from a device_node
|
|
|
|
* @np: device_node with the subnodes
|
|
|
|
**/
|
2016-10-03 13:55:48 +00:00
|
|
|
struct display_timings *of_get_display_timings(const struct device_node *np)
|
2012-10-04 13:32:52 +00:00
|
|
|
{
|
|
|
|
struct device_node *timings_np;
|
|
|
|
struct device_node *entry;
|
|
|
|
struct device_node *native_mode;
|
|
|
|
struct display_timings *disp;
|
|
|
|
|
2014-05-13 12:58:21 +00:00
|
|
|
if (!np)
|
2012-10-04 13:32:52 +00:00
|
|
|
return NULL;
|
|
|
|
|
2013-09-25 11:51:31 +00:00
|
|
|
timings_np = of_get_child_by_name(np, "display-timings");
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!timings_np) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: could not find display-timings node\n", np);
|
2012-10-04 13:32:52 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
disp = kzalloc(sizeof(*disp), GFP_KERNEL);
|
|
|
|
if (!disp) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: could not allocate struct disp'\n", np);
|
2012-10-04 13:32:52 +00:00
|
|
|
goto dispfail;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry = of_parse_phandle(timings_np, "native-mode", 0);
|
|
|
|
/* assume first child as native mode if none provided */
|
|
|
|
if (!entry)
|
2014-05-09 13:53:12 +00:00
|
|
|
entry = of_get_next_child(timings_np, NULL);
|
2012-10-04 13:32:52 +00:00
|
|
|
/* if there is no child, it is useless to go on */
|
|
|
|
if (!entry) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: no timing specifications given\n", np);
|
2012-10-04 13:32:52 +00:00
|
|
|
goto entryfail;
|
|
|
|
}
|
|
|
|
|
2018-10-08 10:57:36 +00:00
|
|
|
pr_debug("%pOF: using %pOFn as default timing\n", np, entry);
|
2012-10-04 13:32:52 +00:00
|
|
|
|
|
|
|
native_mode = entry;
|
|
|
|
|
|
|
|
disp->num_timings = of_get_child_count(timings_np);
|
|
|
|
if (disp->num_timings == 0) {
|
|
|
|
/* should never happen, as entry was already found above */
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: no timings specified\n", np);
|
2012-10-04 13:32:52 +00:00
|
|
|
goto entryfail;
|
|
|
|
}
|
|
|
|
|
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-12 21:03:40 +00:00
|
|
|
disp->timings = kcalloc(disp->num_timings,
|
|
|
|
sizeof(struct display_timing *),
|
|
|
|
GFP_KERNEL);
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!disp->timings) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: could not allocate timings array\n", np);
|
2012-10-04 13:32:52 +00:00
|
|
|
goto entryfail;
|
|
|
|
}
|
|
|
|
|
|
|
|
disp->num_timings = 0;
|
|
|
|
disp->native_mode = 0;
|
|
|
|
|
|
|
|
for_each_child_of_node(timings_np, entry) {
|
|
|
|
struct display_timing *dt;
|
2013-05-16 12:29:06 +00:00
|
|
|
int r;
|
2012-10-04 13:32:52 +00:00
|
|
|
|
2013-05-16 12:29:06 +00:00
|
|
|
dt = kzalloc(sizeof(*dt), GFP_KERNEL);
|
2012-10-04 13:32:52 +00:00
|
|
|
if (!dt) {
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: could not allocate display_timing struct\n",
|
|
|
|
np);
|
2013-05-16 12:29:06 +00:00
|
|
|
goto timingfail;
|
|
|
|
}
|
|
|
|
|
2013-05-16 12:36:38 +00:00
|
|
|
r = of_parse_display_timing(entry, dt);
|
2013-05-16 12:29:06 +00:00
|
|
|
if (r) {
|
2012-10-04 13:32:52 +00:00
|
|
|
/*
|
|
|
|
* to not encourage wrong devicetrees, fail in case of
|
|
|
|
* an error
|
|
|
|
*/
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_err("%pOF: error in timing %d\n",
|
|
|
|
np, disp->num_timings + 1);
|
2015-09-30 09:54:08 +00:00
|
|
|
kfree(dt);
|
2012-10-04 13:32:52 +00:00
|
|
|
goto timingfail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (native_mode == entry)
|
|
|
|
disp->native_mode = disp->num_timings;
|
|
|
|
|
|
|
|
disp->timings[disp->num_timings] = dt;
|
|
|
|
disp->num_timings++;
|
|
|
|
}
|
|
|
|
of_node_put(timings_np);
|
|
|
|
/*
|
|
|
|
* native_mode points to the device_node returned by of_parse_phandle
|
|
|
|
* therefore call of_node_put on it
|
|
|
|
*/
|
|
|
|
of_node_put(native_mode);
|
|
|
|
|
2017-08-07 15:22:13 +00:00
|
|
|
pr_debug("%pOF: got %d timings. Using timing #%d as default\n",
|
|
|
|
np, disp->num_timings,
|
2012-10-04 13:32:52 +00:00
|
|
|
disp->native_mode + 1);
|
|
|
|
|
|
|
|
return disp;
|
|
|
|
|
|
|
|
timingfail:
|
2014-08-08 10:07:55 +00:00
|
|
|
of_node_put(native_mode);
|
2012-10-04 13:32:52 +00:00
|
|
|
display_timings_release(disp);
|
2014-07-11 09:21:36 +00:00
|
|
|
disp = NULL;
|
2012-10-04 13:32:52 +00:00
|
|
|
entryfail:
|
|
|
|
kfree(disp);
|
|
|
|
dispfail:
|
|
|
|
of_node_put(timings_np);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_get_display_timings);
|