Various parameters of SM501 can be set using platform_data,
so parameters cannot be passed in the DeviceTree target.
Expands the parameters set in platform_data so that they can be
specified using DeviceTree properties.
Signed-off-by: Yoshinori Sato <ysato@xxxxxxxxxxxxxxxxxxxx>
---
drivers/mfd/sm501.c | 238 ++++++++++++++++++++++++++++++++++
drivers/video/fbdev/sm501fb.c | 87 +++++++++++++
2 files changed, 325 insertions(+)
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index b3592982a83b..d373aded0c3b 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -20,6 +20,7 @@
#include <linux/gpio/driver.h>
#include <linux/gpio/machine.h>
#include <linux/slab.h>
+#include <linux/clk.h>
#include <linux/sm501.h>
#include <linux/sm501-regs.h>
@@ -82,6 +83,16 @@ struct sm501_devdata {
unsigned int rev;
};
+struct sm501_config_props_uint {
+ char *name;
+ u32 shift;
+};
+
+struct sm501_config_props_flag {
+ char *clr_name;
+ char *set_name;
+ u32 bit;
+};
#define MHZ (1000 * 1000)
@@ -1370,6 +1381,227 @@ static int sm501_init_dev(struct sm501_devdata *sm)
return 0;
}
+#define FIELD_WIDTH 4
+struct dt_values {
+ char *name;
+ unsigned int offset;
+ unsigned int width;
+ char *val[(1 << FIELD_WIDTH) + 1];
+};
+
+#define fld(_name, _offset, _width, ...) \
+ { \
+ .name = _name, \
+ .offset = _offset, \
+ .width = _width, \
+ .val = { __VA_ARGS__, NULL}, \
+ }
+
+static const struct dt_values misc_timing[] = {
+ fld("ex", 28, 4,
+ "none", "16", "32", "48", "64", "80", "96", "112",
+ "128", "144", "160", "176", "192", "208", "224", "240"),
+ fld("xc", 24, 2, "internal-pll", "hclk", "gpio30"),
+ fld("us", 23, 1, "disable", "enable"),
+ fld("ssm1", 20, 1, "288", "divider"),
+ fld("sm1", 16, 4,
+ "1", "2", "4", "8", "16", "32", "64", "128",
+ "3", "6", "12", "24", "48", "96", "192", "384"),
+ fld("ssm0", 12, 1, "288", "divider"),
+ fld("sm0", 8, 4,
+ "1", "2", "4", "8", "16", "32", "64", "128",
+ "3", "6", "12", "24", "48", "96", "192", "384"),
+ fld("deb", 7, 1, "input-reference", "output"),
+ fld("a", 6, 1, "no-acpi", "acpi"),
+ fld("divider", 4, 2, "336", "288", "240", "192"),
+ fld("u", 3, 1, "normal", "simulation"),
+ fld("delay", 0, 3, "none", "0.5", "1.0", "1.5", "2.0", "2.5"),
+ { .name = NULL },
+};
+
+static const struct dt_values misc_control[] = {
+ fld("pad", 30, 2, "24", "12", "8"),
+ fld("usbclk", 28, 2, "xtal", "96", "48"),
+ fld("ssp", 27, 1, "uart1", "ssp1"),
+ fld("lat", 26, 1, "disable", "enable"),
+ fld("fp", 25, 1, "18", "24"),
+ fld("freq", 24, 1, "24", "12"),
+ fld("refresh", 21, 2, "8", "16", "32", "64"),
+ fld("hold", 18, 3, "fifo-empty", "8", "16", "24", "32"),
+ fld("sh", 17, 1, "active-low", "active-high"),
+ fld("ii", 16, 1, "normal", "inverted"),
+ fld("pll", 15, 1, "disable", "enable"),
+ fld("gap", 13, 2, "0"),
+ fld("dac", 12, 1, "enable", "disable"),
+ fld("mc", 11, 1, "cpu", "8051"),
+ fld("bl", 10, 8, "1"),
+ fld("usb", 9, 1, "master", "slave"),
+ fld("vr", 4, 1, "0x1e00000", "0x3e00000"),
+ { .name = NULL },
+};
+
+/* Read configuration values */
+static void sm501_of_read_config(struct device *dev, struct device_node *np,
+ const char *prefix,
+ const struct dt_values *values,
+ struct sm501_reg_init *ret)
+{
+ const char *name;
+ const char *val;
+ unsigned int i;
+ char key[64];
+ u32 shift;
+ u32 width;
+ u32 mask;
+
+ ret->mask = ~0;
+ ret->set = 0;
+
+ while (values->name) {
+ snprintf(key, sizeof(key), "%s-%s", prefix, values->name);
+ name = values->name;
+ shift = values->offset;
+ width = values->width;
+
+ if (of_property_read_string(np, key, &val) == 0) {
+ mask = (1 << width) - 1;
+ mask = ~(mask << shift);
+ ret->mask &= mask;
+ i = 0;
+ while (values->val[i]) {
+ if (strcmp(val, values->val[i]) == 0) {
+ ret->set |= i << shift;
+ break;
+ }
+ i++;
+ }
+ }
+ values++;
+ }
+}
+
+static void sm501_of_read_gpio(struct device *dev, struct device_node *np,
+ struct sm501_reg_init *hi, struct sm501_reg_init *low)
+{
+ struct device_node *gpio_node;
+ struct property *prop;
+ unsigned int pin_no;
+ const char *s;
+ int mode;
+ u64 mask;
+ u64 set;
+
+ mask = ~0;
+ set = 0;
+ gpio_node = of_get_child_by_name(np, "gpio");
+ if (gpio_node) {
+ for (prop = gpio_node->properties; prop; prop = prop->next) {
+ mode = -1;
+ if (sscanf(prop->name, "pin-%u", &pin_no) == 1) {
+ of_property_read_string(gpio_node, prop->name, &s);
+ if (strcmp(s, "ioport")) {
+ mode = 0;
+ } else if (strcmp(s, "function")) {
+ mode = 1;
+ }
+ }
+ if (mode >= 0) {
+ mask &= ~(1 << pin_no);
+ set |= mode << pin_no;
+ }
+ }
+ }
+ /* Bit48 - 54 is reserved */
+ mask &= ~0x007f000000000000UL;
+ set &= ~0x007f000000000000UL;
+
+ hi->set = set >> 32;
+ low->set = set & 0xffffffff;
+ hi->mask = mask >> 32;
+ low->mask = mask & 0xffffffff;
+}
+
+/* Read device functions */
+static u32 sm501_read_devices(struct device *dev, struct device_node *np)
+{
+ static const char * const funcname[] = {
+ "usb-host", "usb-slave", "ssp0", "ssp1",
+ "uart0", "uart1", "fbaccel", "ac97",
+ "i2s",
+ };
+ struct property *prop;
+ unsigned int i;
+ const char *s;
+ u32 ret = 0;
+
+ of_property_for_each_string(np, "smi,devices", prop, s) {
+ for (i = 0; i < ARRAY_SIZE(funcname); i++) {
+ if (strcmp(s, funcname[i]) == 0) {
+ ret |= 1 << i;
+ goto next;
+ }
+ }
+ dev_warn(dev, "Unknown device function '%s'", s);
+next:
+ }
+ if (!ret)
+ dev_warn(dev, "devices not defined. disable all functions.");
+ return ret;
+}
+
+/* Build platform_data from OF property */
+struct plat_dt {
+ struct sm501_platdata plat;
+ struct sm501_initdata init;
+};
+
+static int mclk_get(struct device_node *np, int index, unsigned long *out)
+{
+ struct clk *clk;
+
+ clk = of_clk_get(np, 0);
+ if (IS_ERR(clk))
+ return PTR_ERR(clk);
+ *out = clk_get_rate(clk);
+ clk_put(clk);
+ return 0;
+}
+
+static int sm501_parse_dt(struct sm501_devdata *sm, struct device_node *np)
+{
+ struct sm501_platdata *plat;
+ struct plat_dt *dt_p;
+ int ret;
+
+ dt_p = devm_kzalloc(sm->dev, sizeof(*dt_p), GFP_KERNEL);
+ if (!dt_p)
+ return -ENOMEM;
+
+ plat = &dt_p->plat;
+ plat->init = &dt_p->init;
+
+ plat->init->devices = sm501_read_devices(sm->dev, np);
+
+ ret = mclk_get(np, 0, &plat->init->mclk);
+ if (ret && ret != -ENOENT)
+ return ret;
+ ret = mclk_get(np, 0, &plat->init->m1xclk);
+ if (ret && ret != -ENOENT)
+ return ret;
+
+ sm501_of_read_config(sm->dev, np, "misc-timing",
+ misc_timing, &plat->init->misc_timing);
+ sm501_of_read_config(sm->dev, np, "misc-control",
+ misc_control, &plat->init->misc_control);
+ if (IS_ENABLED(CONFIG_MFD_SM501_GPIO)) {
+ sm501_of_read_gpio(sm->dev, np,
+ &plat->init->gpio_high,
+ &plat->init->gpio_low);
+ }
+ sm->platdata = plat;
+ return 0;
+}
+
static int sm501_plat_probe(struct platform_device *dev)
{
struct sm501_devdata *sm;
@@ -1406,6 +1638,12 @@ static int sm501_plat_probe(struct platform_device *dev)
goto err_res;
}
+ if (IS_ENABLED(CONFIG_OF) && dev->dev.of_node) {
+ ret = sm501_parse_dt(sm, dev->dev.of_node);
+ if (ret)
+ goto err_res;
+ }
+
platform_set_drvdata(dev, sm);
sm->regs = ioremap(sm->io_res->start, resource_size(sm->io_res));
diff --git a/drivers/video/fbdev/sm501fb.c b/drivers/video/fbdev/sm501fb.c
index d6fdc1737cd2..4162e1322dd4 100644
--- a/drivers/video/fbdev/sm501fb.c
+++ b/drivers/video/fbdev/sm501fb.c
@@ -1932,6 +1932,87 @@ static int sm501fb_start_one(struct sm501fb_info *info,
return 0;
}
+#if defined(CONFIG_OF)
+static u32 read_display_flags(struct device_node *np)
+{
+ static const char * const name[] = {
+ "use-init-done", "disable-at-exit", "use-hwcursor", "use-hwaccel",
+ "panel-no-fpen", "panel-no-vbiasen", "panel-inv-fpen", "panel-inv-vbiasen",
+ };
+
+ struct property *prop;
+ unsigned int i;
+ const char *s;
+ u32 ret = 0;
+
+ of_property_for_each_string(np, "smi,flags", prop, s) {
+ for (i = 0; i < ARRAY_SIZE(name); i++) {
+ if (strcmp(s, name[i]) == 0) {
+ ret |= 1 << i;
+ break;
+ }
+ }
+ }
+ return ret;
+}
+
+/* parse CRT / panel configuration */
+static struct sm501_platdata_fbsub *dt_fbsub(struct device *dev,
+ struct device_node *np,
+ const char *name)
+{
+ struct sm501_platdata_fbsub *fbsub = NULL;
+ struct device_node *child;
+ u32 flags = 0;
+ u32 bpp = 0;
+ int len;
+
+ child = of_get_child_by_name(np, name);
+ if (child == NULL)
+ return NULL;
+
+ of_property_read_u32(child, "bpp", &bpp);
+
+ /* If flags property is obtained, fbsub is returned. */
+ flags = read_display_flags(child);
+ if (flags) {
+ fbsub = devm_kzalloc(dev, sizeof(*fbsub), GFP_KERNEL);
+ if (fbsub) {
+ fbsub->def_bpp = bpp;
+ fbsub->flags = flags;
+ }
+ }
+ return fbsub;
+}
+
+/* Build platform_data from OF property */
+static struct sm501_platdata_fb *pdata_from_dt(struct device *dev, struct device_node *np)
+{
+ enum sm501_fb_routing fb_route = SM501_FB_OWN;
+ struct sm501_platdata_fb *pdata = NULL;
+ struct sm501_platdata_fbsub *fb_crt;
+ struct sm501_platdata_fbsub *fb_pnl;
+ unsigned int flags = 0;
+
+ if (of_property_read_bool(np, "route-crt-panel"))
+ fb_route = SM501_FB_CRT_PANEL;
+ if (of_property_read_bool(np, "swap-fb-endian"))
+ flags = SM501_FBPD_SWAP_FB_ENDIAN;
+ fb_crt = dt_fbsub(dev, np, "crt");
+ fb_pnl = dt_fbsub(dev, np, "panel");
+ if (fb_crt || fb_pnl) {
+ pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+ if (pdata) {
+ pdata->fb_route = fb_route;
+ pdata->flags = flags;
+ pdata->fb_crt = fb_crt;
+ pdata->fb_pnl = fb_pnl;
+ }
+ }
+ return pdata;
+}
+#endif
+
static int sm501fb_probe(struct platform_device *pdev)
{
struct sm501fb_info *info;
@@ -1974,6 +2055,12 @@ static int sm501fb_probe(struct platform_device *pdev)
if (info->edid_data)
found = 1;
}
+ /* Get platform data compatible configuration */
+ if (!found) {
+ info->pdata = pdata_from_dt(dev, np);
+ if (info->pdata)
+ found = 1;
+ }
}
#endif
if (!found) {
--
2.39.2
