Merge "drm/msm/dsi-staging: use parser APIs for custom panel data" into dev/msm-4.14-display (b8830f17) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/gpu/drm/msm/dsi-staging/dsi_display.c

+106 −18

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include "dsi_clk.h"
		#include "dsi_pwr.h"
		#include "sde_dbg.h"
		#include "dsi_parser.h"

		#define to_dsi_display(x) container_of(x, struct dsi_display, host)
		#define INT_BASE_10 10
		@@ -1143,6 +1144,8 @@ static int dsi_display_debugfs_init(struct dsi_display *display)
		}

		display->root = dir;
		dsi_parser_dbg_init(display->parser, dir);

		return rc;
		error_remove_dir:
		debugfs_remove(dir);
		@@ -2457,6 +2460,27 @@ static bool dsi_display_check_prefix(const char *clk_prefix,
		return !!strnstr(clk_name, clk_prefix, strlen(clk_name));
		}

		static int dsi_display_get_clocks_count(struct dsi_display *display)
		{
		if (display->fw)
		return dsi_parser_count_strings(display->parser_node,
		"qcom,dsi-select-clocks");
		else
		return of_property_count_strings(display->disp_node,
		"qcom,dsi-select-clocks");
		}

		static void dsi_display_get_clock_name(struct dsi_display *display,
		int index, const char **clk_name)
		{
		if (display->fw)
		dsi_parser_read_string_index(display->parser_node,
		"qcom,dsi-select-clocks", index, clk_name);
		else
		of_property_read_string_index(display->disp_node,
		"qcom,dsi-select-clocks", index, clk_name);
		}

		static int dsi_display_clocks_init(struct dsi_display *display)
		{
		int i, rc = 0, num_clk = 0;
		@@ -2469,12 +2493,12 @@ static int dsi_display_clocks_init(struct dsi_display *display)
		struct dsi_clk_link_set *mux = &display->clock_info.mux_clks;
		struct dsi_clk_link_set *shadow = &display->clock_info.shadow_clks;

		num_clk = of_property_count_strings(display->disp_node,
		"qcom,dsi-select-clocks");
		num_clk = dsi_display_get_clocks_count(display);

		pr_debug("clk count=%d\n", num_clk);

		for (i = 0; i < num_clk; i++) {
		of_property_read_string_index(display->disp_node,
		"qcom,dsi-select-clocks", i, &clk_name);
		dsi_display_get_clock_name(display, i, &clk_name);

		pr_debug("clock name:%s\n", clk_name);

		@@ -2917,7 +2941,12 @@ static int dsi_display_get_phandle_index(
		if (index >= count)
		goto end;

		rc = of_property_read_u32_array(disp_node, propname, val, count);
		if (display->fw)
		rc = dsi_parser_read_u32_array(display->parser_node,
		propname, val, count);
		else
		rc = of_property_read_u32_array(disp_node, propname,
		val, count);
		if (rc)
		goto end;

		@@ -2929,18 +2958,31 @@ static int dsi_display_get_phandle_index(
		return rc;
		}

		static int dsi_display_get_phandle_count(struct dsi_display *display,
		const char *propname)
		{
		if (display->fw)
		return dsi_parser_count_u32_elems(display->parser_node,
		propname);
		else
		return of_property_count_u32_elems(display->disp_node,
		propname);
		}

		static int dsi_display_parse_dt(struct dsi_display *display)
		{
		int rc = 0;
		int i;
		int i, rc = 0;
		u32 phy_count = 0;
		struct device_node *of_node = display->pdev->dev.of_node;
		struct device_node *disp_node = display->disp_node;

		display->ctrl_count = of_property_count_u32_elems(disp_node,
		display->ctrl_count = dsi_display_get_phandle_count(display,
		"qcom,dsi-ctrl-num");
		phy_count = dsi_display_get_phandle_count(display,
		"qcom,dsi-ctrl-num");
		phy_count = of_property_count_u32_elems(disp_node,
		"qcom,dsi-phy-num");

		pr_debug("ctrl count=%d, phy count=%d\n",
		display->ctrl_count, phy_count);

		if (!phy_count \|\| !display->ctrl_count) {
		pr_err("no ctrl/phys found\n");
		@@ -2977,6 +3019,8 @@ static int dsi_display_parse_dt(struct dsi_display *display)
		rc = -ENODEV;
		goto error;
		}

		pr_debug("success\n");
		error:
		return rc;
		}
		@@ -3007,7 +3051,10 @@ static int dsi_display_res_init(struct dsi_display *display)
		}
		}

		display->panel = dsi_panel_get(&display->pdev->dev, display->panel_of,
		display->panel = dsi_panel_get(&display->pdev->dev,
		display->panel_of,
		display->parser_node,
		display->root,
		display->cmdline_topology);
		if (IS_ERR_OR_NULL(display->panel)) {
		rc = PTR_ERR(display->panel);
		@@ -3494,6 +3541,12 @@ static int _dsi_display_dev_init(struct dsi_display *display)

		mutex_lock(&display->display_lock);

		display->parser = dsi_parser_get(&display->pdev->dev);
		if (display->fw && display->parser)
		display->parser_node = dsi_parser_get_head_node(
		display->parser, display->fw->data,
		display->fw->size);

		rc = dsi_display_parse_dt(display);
		if (rc) {
		pr_err("[%s] failed to parse dt, rc=%d\n", display->name, rc);
		@@ -3973,6 +4026,28 @@ static int dsi_display_init(struct dsi_display *display,
		return rc;
		}

		static void dsi_display_firmware_display(const struct firmware *fw,
		void *context)
		{
		struct dsi_display *display = context;
		struct platform_device *pdev = display->pdev;

		if (fw) {
		pr_debug("reading data from firmware, size=%zd\n",
		fw->size);

		display->fw = fw;
		display->name = "dsi_firmware_display";
		}

		dsi_display_setup(display);

		if (dsi_display_init(display, pdev))
		return;

		pr_debug("success\n");
		}

		int dsi_display_dev_probe(struct platform_device *pdev)
		{
		struct dsi_display *display = NULL;
		@@ -3981,6 +4056,7 @@ int dsi_display_dev_probe(struct platform_device *pdev)
		const char *disp_list = "qcom,dsi-display-list";
		const char *disp_active = "qcom,dsi-display-active";
		int i, count, rc = 0;
		bool firm_req = false;

		if (!pdev \|\| !pdev->dev.of_node) {
		pr_err("pdev not found\n");
		@@ -3989,8 +4065,10 @@ int dsi_display_dev_probe(struct platform_device *pdev)
		}

		display = devm_kzalloc(&pdev->dev, sizeof(*display), GFP_KERNEL);
		if (!display)
		return -ENOMEM;
		if (!display) {
		rc = -ENOMEM;
		goto end;
		}

		if (boot_displays[DSI_PRIMARY].boot_disp_en)
		display_from_cmdline = true;
		@@ -4012,6 +4090,12 @@ int dsi_display_dev_probe(struct platform_device *pdev)
		} else {
		if (of_property_read_bool(np, disp_active)) {
		disp_node = np;

		if (IS_ENABLED(CONFIG_DSI_PARSER))
		firm_req = !request_firmware_nowait(
		THIS_MODULE, 1, "dsi_prop",
		&pdev->dev, GFP_KERNEL, display,
		dsi_display_firmware_display);
		break;
		}
		}
		@@ -4035,10 +4119,14 @@ int dsi_display_dev_probe(struct platform_device *pdev)
		platform_set_drvdata(pdev, display);
		default_display = display;

		/* initialize display in firmware callback */
		if (!firm_req) {
		dsi_display_setup(display);

		rc = dsi_display_init(display, pdev);
		if (rc)
		goto end;
		}

		return 0;
		end:

drivers/gpu/drm/msm/dsi-staging/dsi_display.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@
		#include <linux/bitops.h>
		#include <linux/debugfs.h>
		#include <linux/of_device.h>
		#include <linux/firmware.h>
		#include <drm/drmP.h>
		#include <drm/drm_crtc.h>

		@@ -183,6 +184,7 @@ struct dsi_display {
		struct dsi_panel *panel;
		struct device_node *disp_node;
		struct device_node *panel_of;
		struct device_node *parser_node;

		struct dsi_display_mode *modes;

		@@ -228,6 +230,10 @@ struct dsi_display {
		struct work_struct fifo_underflow_work;
		struct work_struct fifo_overflow_work;
		struct work_struct lp_rx_timeout_work;

		/* firmware panel data */
		const struct firmware *fw;
		void *parser;
		};

		int dsi_display_dev_probe(struct platform_device *pdev);

drivers/gpu/drm/msm/dsi-staging/dsi_panel.c

+271 −212

File changed.

Preview size limit exceeded, changes collapsed.

drivers/gpu/drm/msm/dsi-staging/dsi_panel.h

+7 −2

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include "dsi_ctrl_hw.h"
		#include "dsi_clk.h"
		#include "dsi_pwr.h"
		#include "dsi_parser.h"
		#include "msm_drv.h"

		#define MAX_BL_LEVEL 4096
		@@ -149,6 +150,7 @@ struct dsi_panel {
		struct drm_panel drm_panel;
		struct mipi_dsi_host *host;
		struct device *parent;
		struct dentry *root;

		struct dsi_host_common_cfg host_config;
		struct dsi_video_engine_cfg video_config;
		@@ -168,6 +170,8 @@ struct dsi_panel {
		struct drm_panel_hdr_properties hdr_props;
		struct drm_panel_esd_config esd_config;

		struct dsi_parser_utils utils;

		bool lp11_init;
		bool ulps_enabled;
		bool ulps_suspend_enabled;
		@@ -204,6 +208,8 @@ static inline void dsi_panel_release_panel_lock(struct dsi_panel *panel)

		struct dsi_panel dsi_panel_get(struct device parent,
		struct device_node *of_node,
		struct device_node *parser_node,
		struct dentry *root,
		int topology_override);

		int dsi_panel_trigger_esd_attack(struct dsi_panel *panel);
		@@ -214,8 +220,7 @@ int dsi_panel_drv_init(struct dsi_panel panel, struct mipi_dsi_host host);

		int dsi_panel_drv_deinit(struct dsi_panel *panel);

		int dsi_panel_get_mode_count(struct dsi_panel *panel,
		struct device_node *of_node);
		int dsi_panel_get_mode_count(struct dsi_panel *panel);

		void dsi_panel_put_mode(struct dsi_display_mode *mode);

drivers/gpu/drm/msm/dsi-staging/dsi_pwr.c

+25 −26

Original line number	Diff line number	Diff line
		@@ -17,11 +17,13 @@
		#include <linux/slab.h>

		#include "dsi_pwr.h"
		#include "dsi_parser.h"

		/*
		* dsi_pwr_parse_supply_node() - parse power supply node from root device node
		*/
		static int dsi_pwr_parse_supply_node(struct device_node *root,
		static int dsi_pwr_parse_supply_node(struct dsi_parser_utils *utils,
		struct device_node *root,
		struct dsi_regulator_info *regs)
		{
		int rc = 0;
		@@ -29,10 +31,10 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		u32 tmp = 0;
		struct device_node *node = NULL;

		for_each_child_of_node(root, node) {
		dsi_for_each_child_node(root, node) {
		const char *st = NULL;

		rc = of_property_read_string(node, "qcom,supply-name", &st);
		rc = utils->read_string(node, "qcom,supply-name", &st);
		if (rc) {
		pr_err("failed to read name, rc = %d\n", rc);
		goto error;
		@@ -42,32 +44,28 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		ARRAY_SIZE(regs->vregs[i].vreg_name),
		"%s", st);

		rc = of_property_read_u32(node, "qcom,supply-min-voltage",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-min-voltage", &tmp);
		if (rc) {
		pr_err("failed to read min voltage, rc = %d\n", rc);
		goto error;
		}
		regs->vregs[i].min_voltage = tmp;

		rc = of_property_read_u32(node, "qcom,supply-max-voltage",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-max-voltage", &tmp);
		if (rc) {
		pr_err("failed to read max voltage, rc = %d\n", rc);
		goto error;
		}
		regs->vregs[i].max_voltage = tmp;

		rc = of_property_read_u32(node, "qcom,supply-enable-load",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-enable-load", &tmp);
		if (rc) {
		pr_err("failed to read enable load, rc = %d\n", rc);
		goto error;
		}
		regs->vregs[i].enable_load = tmp;

		rc = of_property_read_u32(node, "qcom,supply-disable-load",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-disable-load", &tmp);
		if (rc) {
		pr_err("failed to read disable load, rc = %d\n", rc);
		goto error;
		@@ -75,8 +73,7 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		regs->vregs[i].disable_load = tmp;

		/* Optional values */
		rc = of_property_read_u32(node, "qcom,supply-pre-on-sleep",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-pre-on-sleep", &tmp);
		if (rc) {
		pr_debug("pre-on-sleep not specified\n");
		rc = 0;
		@@ -84,8 +81,7 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		regs->vregs[i].pre_on_sleep = tmp;
		}

		rc = of_property_read_u32(node, "qcom,supply-pre-off-sleep",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-pre-off-sleep", &tmp);
		if (rc) {
		pr_debug("pre-off-sleep not specified\n");
		rc = 0;
		@@ -93,8 +89,7 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		regs->vregs[i].pre_off_sleep = tmp;
		}

		rc = of_property_read_u32(node, "qcom,supply-post-on-sleep",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-post-on-sleep", &tmp);
		if (rc) {
		pr_debug("post-on-sleep not specified\n");
		rc = 0;
		@@ -102,8 +97,7 @@ static int dsi_pwr_parse_supply_node(struct device_node *root,
		regs->vregs[i].post_on_sleep = tmp;
		}

		rc = of_property_read_u32(node, "qcom,supply-post-off-sleep",
		&tmp);
		rc = utils->read_u32(node, "qcom,supply-post-off-sleep", &tmp);
		if (rc) {
		pr_debug("post-off-sleep not specified\n");
		rc = 0;
		@@ -221,22 +215,23 @@ static int dsi_pwr_enable_vregs(struct dsi_regulator_info *regs, bool enable)
		*
		* return: error code in case of failure or 0 for success.
		*/
		int dsi_pwr_of_get_vreg_data(struct device_node *of_node,
		int dsi_pwr_of_get_vreg_data(struct dsi_parser_utils *utils,
		struct dsi_regulator_info *regs,
		char *supply_name)
		{
		int rc = 0;
		struct device_node *supply_root_node = NULL;

		if (!of_node \|\| !regs) {
		if (!utils \|\| !regs) {
		pr_err("Bad params\n");
		return -EINVAL;
		}

		regs->count = 0;
		supply_root_node = of_get_child_by_name(of_node, supply_name);
		supply_root_node = utils->get_child_by_name(utils->data, supply_name);
		if (!supply_root_node) {
		supply_root_node = of_parse_phandle(of_node, supply_name, 0);
		supply_root_node = of_parse_phandle(utils->node,
		supply_name, 0);
		if (!supply_root_node) {
		pr_debug("No supply entry present for %s\n",
		supply_name);
		@@ -244,7 +239,7 @@ int dsi_pwr_of_get_vreg_data(struct device_node *of_node,
		}
		}

		regs->count = of_get_available_child_count(supply_root_node);
		regs->count = utils->get_available_child_count(supply_root_node);
		if (regs->count == 0) {
		pr_err("No vregs defined for %s\n", supply_name);
		return -EINVAL;
		@@ -256,7 +251,7 @@ int dsi_pwr_of_get_vreg_data(struct device_node *of_node,
		return -ENOMEM;
		}

		rc = dsi_pwr_parse_supply_node(supply_root_node, regs);
		rc = dsi_pwr_parse_supply_node(utils, supply_root_node, regs);
		if (rc) {
		pr_err("failed to parse supply node for %s, rc = %d\n",
		supply_name, rc);
		@@ -285,6 +280,7 @@ int dsi_pwr_get_dt_vreg_data(struct device *dev,
		struct device_node *of_node = NULL;
		struct device_node *supply_node = NULL;
		struct device_node *supply_root_node = NULL;
		struct dsi_parser_utils utils = *dsi_parser_get_of_utils();

		if (!dev \|\| !regs) {
		pr_err("Bad params\n");
		@@ -318,7 +314,10 @@ int dsi_pwr_get_dt_vreg_data(struct device *dev,
		return -ENOMEM;
		}

		rc = dsi_pwr_parse_supply_node(supply_root_node, regs);
		utils.data = of_node;
		utils.node = of_node;

		rc = dsi_pwr_parse_supply_node(&utils, supply_root_node, regs);
		if (rc) {
		pr_err("failed to parse supply node for %s, rc = %d\n",
		supply_name, rc);