[DPU PATCH 0/3] Add support for DisplayPort driver on SnapDragon 845

[DPU PATCH 0/3] Add support for DisplayPort driver on SnapDragon 845

[Chandan Uddaraju]

These patches add support for Display-Port driver on SnapDragon 845 hardware. It adds
DP driver and DP PLL driver files along with the needed device-tree bindings.

The block diagram of DP driver is shown below:


                 +-------------+
                 |DRM FRAMEWORK|
                 +------+------+
                        |
                   +----v----+
                   | DP DRM  |
                   +----+----+
                        |
                   +----v----+
     +------------+|   DP    +----------++------+
     +        +---+| DISPLAY |+---+      |      |
     |        +    +-+-----+-+    |      |      |
     |        |      |     |      |      |      |
     |        |      |     |      |      |      |
     |        |      |     |      |      |      |
     v        v      v     v      v      v      v
 +------+ +------+ +---+ +----+ +----+ +---+ +-----+
 |  DP  | |  DP  | |DP | | DP | | DP | |DP | | DP  |
 |PARSER| |EXTCON| |AUX| |LINK| |CTRL| |PHY| |POWER|
 +--+---+ +---+--+ +---+ +----+ +--+-+ +-+-+ +-----+
    |         |                    |     |
 +--v---+ +---v-----+             +v-----v+
 |DEVICE| |EXTCON   |             |  DP   |
 | TREE | |INTERFACE|             |CATALOG|
 +------+ +---------+             +---+---+
                                      |
                                  +---v----+
                                  |CTRL/PHY|
                                  |   HW   |
                                  +--------+


These patches have dependency on clock driver changes mentioned below:
https://patchwork.kernel.org/patch/10632753/ 
https://patchwork.kernel.org/patch/10632757/



Chandan Uddaraju (3):
  dt-bindings: msm/dp: add bindings of DP/DP-PLL driver for Snapdragon
    845
  drm/msm/dp: add displayPort driver support
  drm/msm/dp: add support for DP PLL driver

 .../devicetree/bindings/display/msm/dp.txt         |  249 ++++
 .../devicetree/bindings/display/msm/dpu.txt        |   16 +-
 drivers/gpu/drm/msm/Kconfig                        |   25 +
 drivers/gpu/drm/msm/Makefile                       |   21 +-
 drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c        |  206 +++
 drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h        |   44 +
 drivers/gpu/drm/msm/dp/dp_aux.c                    |  570 +++++++
 drivers/gpu/drm/msm/dp/dp_aux.h                    |   44 +
 drivers/gpu/drm/msm/dp/dp_catalog.c                | 1188 +++++++++++++++
 drivers/gpu/drm/msm/dp/dp_catalog.h                |  144 ++
 drivers/gpu/drm/msm/dp/dp_ctrl.c                   | 1476 +++++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_ctrl.h                   |   50 +
 drivers/gpu/drm/msm/dp/dp_debug.c                  |  507 +++++++
 drivers/gpu/drm/msm/dp/dp_debug.h                  |   81 +
 drivers/gpu/drm/msm/dp/dp_display.c                | 1027 +++++++++++++
 drivers/gpu/drm/msm/dp/dp_display.h                |   58 +
 drivers/gpu/drm/msm/dp/dp_drm.c                    |  542 +++++++
 drivers/gpu/drm/msm/dp/dp_drm.h                    |   52 +
 drivers/gpu/drm/msm/dp/dp_extcon.c                 |  400 +++++
 drivers/gpu/drm/msm/dp/dp_extcon.h                 |  111 ++
 drivers/gpu/drm/msm/dp/dp_link.c                   | 1549 ++++++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_link.h                   |  184 +++
 drivers/gpu/drm/msm/dp/dp_panel.c                  |  624 ++++++++
 drivers/gpu/drm/msm/dp/dp_panel.h                  |  121 ++
 drivers/gpu/drm/msm/dp/dp_parser.c                 |  679 +++++++++
 drivers/gpu/drm/msm/dp/dp_parser.h                 |  208 +++
 drivers/gpu/drm/msm/dp/dp_power.c                  |  652 ++++++++
 drivers/gpu/drm/msm/dp/dp_power.h                  |   59 +
 drivers/gpu/drm/msm/dp/dp_reg.h                    |  357 +++++
 drivers/gpu/drm/msm/dp/pll/dp_pll.c                |  153 ++
 drivers/gpu/drm/msm/dp/pll/dp_pll.h                |   64 +
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c           |  401 +++++
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h           |   94 ++
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c      |  531 +++++++
 drivers/gpu/drm/msm/msm_drv.c                      |    2 +
 drivers/gpu/drm/msm/msm_drv.h                      |   22 +
 include/drm/drm_dp_helper.h                        |   19 +
 37 files changed, 12525 insertions(+), 5 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/display/msm/dp.txt
 create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.c
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.h
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c

-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project

_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

[DPU PATCH 1/3] dt-bindings: msm/dp: add bindings of DP/DP-PLL driver for Snapdragon 845

[Chandan Uddaraju]

Add bindings for Snapdragon 845 DisplayPort and
display-port PLL driver.

Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
---
 .../devicetree/bindings/display/msm/dp.txt         | 249 +++++++++++++++++++++
 .../devicetree/bindings/display/msm/dpu.txt        |  16 +-
 2 files changed, 261 insertions(+), 4 deletions(-)
 create mode 100644 Documentation/devicetree/bindings/display/msm/dp.txt

diff --git a/Documentation/devicetree/bindings/display/msm/dp.txt b/Documentation/devicetree/bindings/display/msm/dp.txt
new file mode 100644
index 0000000..0155266
--- /dev/null
+++ b/Documentation/devicetree/bindings/display/msm/dp.txt
@@ -0,0 +1,249 @@
+Qualcomm Technologies, Inc.
+DP is the master Display Port device which supports DP host controllers that are compatible with VESA Display Port interface specification.
+DP Controller: Required properties:
+- compatible:           Should be "qcom,dp-display".
+- reg:                  Base address and length of DP hardware's memory mapped regions.
+- cell-index:           Specifies the controller instance.
+- reg-names:            A list of strings that name the list of regs.
+			"dp_ahb" - DP controller memory region.
+			"dp_aux" - DP AUX memory region.
+			"dp_link" - DP link layer memory region.
+			"dp_p0" - DP pixel clock domain memory region.
+			"dp_phy" - DP PHY memory region.
+			"dp_ln_tx0" - USB3 DP PHY combo TX-0 lane memory region.
+			"dp_ln_tx1" - USB3 DP PHY combo TX-1 lane memory region.
+			"dp_mmss_cc" - Display Clock Control memory region.
+			"qfprom_physical" - QFPROM Phys memory region.
+			"dp_pll" - USB3 DP combo PLL memory region.
+			"usb3_dp_com" - USB3 DP PHY combo memory region.
+			"hdcp_physical" - DP HDCP memory region.
+- interrupt-parent	phandle to the interrupt parent device node.
+- interrupts:		The interrupt signal from the DP block.
+- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
+- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
+			"core_aux_clk", "core_usb_ref_clk_src","core_usb_ref_clk", "core_usb_cfg_ahb_clk",
+			"core_usb_pipe_clk", "ctrl_link_clk", "ctrl_link_iface_clk", "ctrl_crypto_clk",
+			"ctrl_pixel_clk", "pixel_clk_rcg", "pixel_parent".
+- pll-node:		phandle to DP PLL node.
+- vdda-1p2-supply:		phandle to vdda 1.2V regulator node.
+- vdda-0p9-supply:		phandle to vdda 0.9V regulator node.
+- qcom,aux-cfg0-settings:		Specifies the DP AUX configuration 0 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg1-settings:		Specifies the DP AUX configuration 1 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg2-settings:		Specifies the DP AUX configuration 2 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg3-settings:		Specifies the DP AUX configuration 3 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg4-settings:		Specifies the DP AUX configuration 4 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg5-settings:		Specifies the DP AUX configuration 5 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg6-settings:		Specifies the DP AUX configuration 6 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg7-settings:		Specifies the DP AUX configuration 7 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg8-settings:		Specifies the DP AUX configuration 8 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,aux-cfg9-settings:		Specifies the DP AUX configuration 9 settings. The first
+					entry in this array corresponds to the register offset
+					within DP AUX, while the remaining entries indicate the
+					programmable values.
+- qcom,max-pclk-frequency-khz:	An integer specifying the maximum. pixel clock in KHz supported by Display Port.
+- extcon:				Phandle for the external connector class interface.
+- qcom,<type>-supply-entries:		A node that lists the elements of the supply used by the a particular "type" of DP module. The module "types"
+					can be "core", "ctrl", and "phy". Within the same type,
+					there can be more than one instance of this binding,
+					in which case the entry would be appended with the
+					supply entry index.
+					e.g. qcom,ctrl-supply-entry@0
+					-- qcom,supply-name: name of the supply (vdd/vdda/vddio)
+					-- qcom,supply-min-voltage: minimum voltage level (uV)
+					-- qcom,supply-max-voltage: maximum voltage level (uV)
+					-- qcom,supply-enable-load: load drawn (uA) from enabled supply
+					-- qcom,supply-disable-load: load drawn (uA) from disabled supply
+					-- qcom,supply-pre-on-sleep: time to sleep (ms) before turning on
+					-- qcom,supply-post-on-sleep: time to sleep (ms) after turning on
+					-- qcom,supply-pre-off-sleep: time to sleep (ms) before turning off
+					-- qcom,supply-post-off-sleep: time to sleep (ms) after turning off
+- pinctrl-names:	List of names to assign mdss pin states defined in pinctrl device node
+					Refer to pinctrl-bindings.txt
+- pinctrl-<0..n>:	Lists phandles each pointing to the pin configuration node within a pin
+					controller. These pin configurations are installed in the pinctrl
+					device node. Refer to pinctrl-bindings.txt
+DP Endpoint properties:
+  - remote-endpoint: For port@0, set to phandle of the connected panel/bridge's
+    input endpoint. For port@1, set to the DPU interface output. See [2] for
+    device graph info.
+
+Optional properties:
+- qcom,aux-en-gpio:		Specifies the aux-channel enable gpio.
+- qcom,aux-sel-gpio:		Specifies the aux-channel select gpio.
+
+
+DP PLL: Required properties:
+- compatible:           Should be "qcom,dp-pll-10nm".
+- reg:                  Base address and length of DP hardware's memory mapped regions.
+- cell-index:           Specifies the PLL instance.
+- reg-names:            A list of strings that name the list of regs.
+			"pll_base" - DP PLL memory region.
+			"phy_base" - DP PHY memory region.
+			"ln_tx0_base" - USB3 DP PHY combo TX-0 lane memory region.
+			"ln_tx1_base" - USB3 DP PHY combo TX-1 lane memory region.
+			"gdsc_base" - gdsc memory region.
+- interrupt-parent	phandle to the interrupt parent device node.
+- interrupts:		The interrupt signal from the DP block.
+- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
+- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
+			"iface_clk", "ref_clk", cfg_ahb_clk", "pipe_clk".
+- clock-rate:           Initial clock rate to be configured. For the shared clocks, the default value			     is set to zero so that minimum clock value is configured. Non-zero clock
+			value can be used to configure DP pixel clock.
+
+
+[1] Documentation/devicetree/bindings/clock/clock-bindings.txt
+[2] Documentation/devicetree/bindings/graph.txt
+
+Example:
+	msm_dp: dp_display@ae90000{
+		cell-index = <0>;
+		compatible = "qcom,dp-display";
+
+		reg =   <0 0x90000 0x0dc>,
+			<0 0x90200 0x0c0>,
+			<0 0x90400 0x508>,
+			<0 0x90a00 0x094>,
+			<1 0xeaa00 0x200>,
+			<1 0xea200 0x200>,
+			<1 0xea600 0x200>,
+			<2 0x02000 0x1a0>,
+			<3 0x00000 0x621c>,
+			<1 0xea000 0x180>,
+			<1 0xe8000 0x20>,
+			<4 0xe1000 0x034>;
+		reg-names = "dp_ahb", "dp_aux", "dp_link",
+			"dp_p0", "dp_phy", "dp_ln_tx0", "dp_ln_tx1",
+			"dp_mmss_cc", "qfprom_physical", "dp_pll",
+			"usb3_dp_com", "hdcp_physical";
+
+		interrupt-parent = <&mdss>;
+		interrupts = <12 0>;
+
+		extcon = <&usb_1_ssphy>;
+		clocks =  <&dispcc DISP_CC_MDSS_DP_AUX_CLK>,
+			<&rpmhcc RPMH_CXO_CLK>,
+			<&gcc GCC_USB3_PRIM_CLKREF_CLK>,
+			<&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
+			<&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>,
+			<&dispcc DISP_CC_MDSS_DP_LINK_CLK>,
+			<&dispcc DISP_CC_MDSS_DP_LINK_INTF_CLK>,
+			<&dispcc DISP_CC_MDSS_DP_PIXEL_CLK>,
+			<&dispcc DISP_CC_MDSS_DP_CRYPTO_CLK>,
+			<&dispcc DISP_CC_MDSS_DP_PIXEL_CLK_SRC>;
+		clock-names = "core_aux_clk", "core_ref_clk_src",
+			"core_usb_ref_clk", "core_usb_cfg_ahb_clk",
+			"core_usb_pipe_clk", "ctrl_link_clk",
+			"ctrl_link_iface_clk", "ctrl_pixel_clk",
+			"crypto_clk", "pixel_clk_rcg";
+
+		pll-node = <&dp_pll>;
+		qcom,aux-cfg0-settings = [20 00];
+		qcom,aux-cfg1-settings = [24 13 23 1d];
+		qcom,aux-cfg2-settings = [28 24];
+		qcom,aux-cfg3-settings = [2c 00];
+		qcom,aux-cfg4-settings = [30 0a];
+		qcom,aux-cfg5-settings = [34 26];
+		qcom,aux-cfg6-settings = [38 0a];
+		qcom,aux-cfg7-settings = [3c 03];
+		qcom,aux-cfg8-settings = [40 bb];
+		qcom,aux-cfg9-settings = [44 03];
+
+		qcom,max-pclk-frequency-khz = <675000>;
+
+		qcom,ctrl-supply-entries {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			qcom,ctrl-supply-entry@0 {
+				reg = <0>;
+				qcom,supply-name = "vdda-1p2";
+				qcom,supply-min-voltage = <1200000>;
+				qcom,supply-max-voltage = <1200000>;
+				qcom,supply-enable-load = <21800>;
+				qcom,supply-disable-load = <4>;
+			};
+		};
+
+		qcom,phy-supply-entries {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			qcom,phy-supply-entry@0 {
+				reg = <0>;
+				qcom,supply-name = "vdda-0p9";
+				qcom,supply-min-voltage = <880000>;
+				qcom,supply-max-voltage = <880000>;
+				qcom,supply-enable-load = <36000>;
+				qcom,supply-disable-load = <32>;
+			};
+		};
+
+		ports {
+			#address-cells = <1>;
+			#size-cells = <0>;
+
+			port@0 {
+				reg = <0>;
+				dp_in: endpoint {
+					remote-endpoint = <&dpu_intf0_out>;
+				};
+			};
+
+			port@1 {
+				reg = <1>;
+				dp_out: endpoint {
+				};
+			};
+		};
+	};
+
+	dp_pll: dp-pll@c011000 {
+		compatible = "qcom,dp-pll-10nm";
+		label = "DP PLL";
+		cell-index = <0>;
+		#clock-cells = <1>;
+
+		reg = <1 0xea000 0x200>,
+		      <1 0xeaa00 0x200>,
+		      <1 0xea200 0x200>,
+		      <1 0xea600 0x200>,
+		      <2 0x03000 0x8>;
+		reg-names = "pll_base", "phy_base", "ln_tx0_base",
+			"ln_tx1_base", "gdsc_base";
+
+		clocks = <&dispcc DISP_CC_MDSS_AHB_CLK>,
+			 <&gcc GCC_USB3_PRIM_CLKREF_CLK>,
+			 <&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
+			 <&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>;
+		clock-names = "iface_clk", "ref_clk",
+			"cfg_ahb_clk", "pipe_clk";
+		clock-rate = <0>;
+
+	};
diff --git a/Documentation/devicetree/bindings/display/msm/dpu.txt b/Documentation/devicetree/bindings/display/msm/dpu.txt
index ad2e883..ab2d1f6 100644
--- a/Documentation/devicetree/bindings/display/msm/dpu.txt
+++ b/Documentation/devicetree/bindings/display/msm/dpu.txt
@@ -58,8 +58,9 @@ Required properties:
 	Documentation/devicetree/bindings/graph.txt
 	Documentation/devicetree/bindings/media/video-interfaces.txt
 
-	Port 0 -> DPU_INTF1 (DSI1)
-	Port 1 -> DPU_INTF2 (DSI2)
+	Port 0 -> DPU_INTF0 (DP)
+	Port 1 -> DPU_INTF1 (DSI1)
+	Port 2 -> DPU_INTF2 (DSI2)
 
 Optional properties:
 - assigned-clocks: list of clock specifiers for clocks needing rate assignment
@@ -115,13 +116,20 @@ Example:
 
 				port@0 {
 					reg = <0>;
-					dpu_intf1_out: endpoint {
-						remote-endpoint = <&dsi0_in>;
+					dpu_intf0_out: endpoint {
+						remote-endpoint = <&dp_in>;
 					};
 				};
 
 				port@1 {
 					reg = <1>;
+					dpu_intf1_out: endpoint {
+						remote-endpoint = <&dsi0_in>;
+					};
+				};
+
+				port@2 {
+					reg = <2>;
 					dpu_intf2_out: endpoint {
 						remote-endpoint = <&dsi1_in>;
 					};
-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project

_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 1/3] dt-bindings: msm/dp: add bindings of DP/DP-PLL driver for Snapdragon 845

[Sean Paul]

On Wed, Oct 10, 2018 at 10:15:57AM -0700, Chandan Uddaraju wrote:
> Add bindings for Snapdragon 845 DisplayPort and
> display-port PLL driver.
> 

This won't get Rob Herring's review unless it's sent to the devicetree list.

> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  .../devicetree/bindings/display/msm/dp.txt         | 249 +++++++++++++++++++++
>  .../devicetree/bindings/display/msm/dpu.txt        |  16 +-
>  2 files changed, 261 insertions(+), 4 deletions(-)
>  create mode 100644 Documentation/devicetree/bindings/display/msm/dp.txt
> 
> diff --git a/Documentation/devicetree/bindings/display/msm/dp.txt b/Documentation/devicetree/bindings/display/msm/dp.txt
> new file mode 100644
> index 0000000..0155266
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/display/msm/dp.txt
> @@ -0,0 +1,249 @@
> +Qualcomm Technologies, Inc.
> +DP is the master Display Port device which supports DP host controllers that are compatible with VESA Display Port interface specification.
> +DP Controller: Required properties:
> +- compatible:           Should be "qcom,dp-display".
> +- reg:                  Base address and length of DP hardware's memory mapped regions.
> +- cell-index:           Specifies the controller instance.
> +- reg-names:            A list of strings that name the list of regs.
> +			"dp_ahb" - DP controller memory region.
> +			"dp_aux" - DP AUX memory region.
> +			"dp_link" - DP link layer memory region.
> +			"dp_p0" - DP pixel clock domain memory region.
> +			"dp_phy" - DP PHY memory region.
> +			"dp_ln_tx0" - USB3 DP PHY combo TX-0 lane memory region.
> +			"dp_ln_tx1" - USB3 DP PHY combo TX-1 lane memory region.
> +			"dp_mmss_cc" - Display Clock Control memory region.
> +			"qfprom_physical" - QFPROM Phys memory region.
> +			"dp_pll" - USB3 DP combo PLL memory region.
> +			"usb3_dp_com" - USB3 DP PHY combo memory region.
> +			"hdcp_physical" - DP HDCP memory region.
> +- interrupt-parent	phandle to the interrupt parent device node.
> +- interrupts:		The interrupt signal from the DP block.
> +- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
> +- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
> +			"core_aux_clk", "core_usb_ref_clk_src","core_usb_ref_clk", "core_usb_cfg_ahb_clk",
> +			"core_usb_pipe_clk", "ctrl_link_clk", "ctrl_link_iface_clk", "ctrl_crypto_clk",
> +			"ctrl_pixel_clk", "pixel_clk_rcg", "pixel_parent".
> +- pll-node:		phandle to DP PLL node.
> +- vdda-1p2-supply:		phandle to vdda 1.2V regulator node.
> +- vdda-0p9-supply:		phandle to vdda 0.9V regulator node.
> +- qcom,aux-cfg0-settings:		Specifies the DP AUX configuration 0 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg1-settings:		Specifies the DP AUX configuration 1 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg2-settings:		Specifies the DP AUX configuration 2 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg3-settings:		Specifies the DP AUX configuration 3 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg4-settings:		Specifies the DP AUX configuration 4 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg5-settings:		Specifies the DP AUX configuration 5 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg6-settings:		Specifies the DP AUX configuration 6 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg7-settings:		Specifies the DP AUX configuration 7 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg8-settings:		Specifies the DP AUX configuration 8 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.
> +- qcom,aux-cfg9-settings:		Specifies the DP AUX configuration 9 settings. The first
> +					entry in this array corresponds to the register offset
> +					within DP AUX, while the remaining entries indicate the
> +					programmable values.


What about the AUX configuration are these configuring? What are the permissible
values? If they're not describing the hardware, they probably don't belong
here.

> +- qcom,max-pclk-frequency-khz:	An integer specifying the maximum. pixel clock in KHz supported by Display Port.
> +- extcon:				Phandle for the external connector class interface.
> +- qcom,<type>-supply-entries:		A node that lists the elements of the supply used by the a particular "type" of DP module. The module "types"
> +					can be "core", "ctrl", and "phy". Within the same type,
> +					there can be more than one instance of this binding,
> +					in which case the entry would be appended with the
> +					supply entry index.
> +					e.g. qcom,ctrl-supply-entry@0
> +					-- qcom,supply-name: name of the supply (vdd/vdda/vddio)
> +					-- qcom,supply-min-voltage: minimum voltage level (uV)
> +					-- qcom,supply-max-voltage: maximum voltage level (uV)
> +					-- qcom,supply-enable-load: load drawn (uA) from enabled supply
> +					-- qcom,supply-disable-load: load drawn (uA) from disabled supply
> +					-- qcom,supply-pre-on-sleep: time to sleep (ms) before turning on
> +					-- qcom,supply-post-on-sleep: time to sleep (ms) after turning on
> +					-- qcom,supply-pre-off-sleep: time to sleep (ms) before turning off
> +					-- qcom,supply-post-off-sleep: time to sleep (ms) after turning off
> +- pinctrl-names:	List of names to assign mdss pin states defined in pinctrl device node
> +					Refer to pinctrl-bindings.txt
> +- pinctrl-<0..n>:	Lists phandles each pointing to the pin configuration node within a pin
> +					controller. These pin configurations are installed in the pinctrl
> +					device node. Refer to pinctrl-bindings.txt
> +DP Endpoint properties:
> +  - remote-endpoint: For port@0, set to phandle of the connected panel/bridge's
> +    input endpoint. For port@1, set to the DPU interface output. See [2] for
> +    device graph info.
> +
> +Optional properties:
> +- qcom,aux-en-gpio:		Specifies the aux-channel enable gpio.
> +- qcom,aux-sel-gpio:		Specifies the aux-channel select gpio.

What does the select gpio do? Could you please describe it?

> +
> +
> +DP PLL: Required properties:
> +- compatible:           Should be "qcom,dp-pll-10nm".
> +- reg:                  Base address and length of DP hardware's memory mapped regions.
> +- cell-index:           Specifies the PLL instance.
> +- reg-names:            A list of strings that name the list of regs.
> +			"pll_base" - DP PLL memory region.
> +			"phy_base" - DP PHY memory region.
> +			"ln_tx0_base" - USB3 DP PHY combo TX-0 lane memory region.
> +			"ln_tx1_base" - USB3 DP PHY combo TX-1 lane memory region.
> +			"gdsc_base" - gdsc memory region.
> +- interrupt-parent	phandle to the interrupt parent device node.
> +- interrupts:		The interrupt signal from the DP block.
> +- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
> +- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
> +			"iface_clk", "ref_clk", cfg_ahb_clk", "pipe_clk".
> +- clock-rate:           Initial clock rate to be configured. For the shared clocks, the default value			     is set to zero so that minimum clock value is configured. Non-zero clock
> +			value can be used to configure DP pixel clock.
> +
> +
> +[1] Documentation/devicetree/bindings/clock/clock-bindings.txt
> +[2] Documentation/devicetree/bindings/graph.txt
> +
> +Example:
> +	msm_dp: dp_display@ae90000{
> +		cell-index = <0>;
> +		compatible = "qcom,dp-display";
> +
> +		reg =   <0 0x90000 0x0dc>,
> +			<0 0x90200 0x0c0>,
> +			<0 0x90400 0x508>,
> +			<0 0x90a00 0x094>,
> +			<1 0xeaa00 0x200>,
> +			<1 0xea200 0x200>,
> +			<1 0xea600 0x200>,
> +			<2 0x02000 0x1a0>,
> +			<3 0x00000 0x621c>,
> +			<1 0xea000 0x180>,
> +			<1 0xe8000 0x20>,
> +			<4 0xe1000 0x034>;
> +		reg-names = "dp_ahb", "dp_aux", "dp_link",
> +			"dp_p0", "dp_phy", "dp_ln_tx0", "dp_ln_tx1",
> +			"dp_mmss_cc", "qfprom_physical", "dp_pll",
> +			"usb3_dp_com", "hdcp_physical";
> +
> +		interrupt-parent = <&mdss>;
> +		interrupts = <12 0>;
> +
> +		extcon = <&usb_1_ssphy>;
> +		clocks =  <&dispcc DISP_CC_MDSS_DP_AUX_CLK>,
> +			<&rpmhcc RPMH_CXO_CLK>,
> +			<&gcc GCC_USB3_PRIM_CLKREF_CLK>,
> +			<&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
> +			<&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>,
> +			<&dispcc DISP_CC_MDSS_DP_LINK_CLK>,
> +			<&dispcc DISP_CC_MDSS_DP_LINK_INTF_CLK>,
> +			<&dispcc DISP_CC_MDSS_DP_PIXEL_CLK>,
> +			<&dispcc DISP_CC_MDSS_DP_CRYPTO_CLK>,
> +			<&dispcc DISP_CC_MDSS_DP_PIXEL_CLK_SRC>;
> +		clock-names = "core_aux_clk", "core_ref_clk_src",
> +			"core_usb_ref_clk", "core_usb_cfg_ahb_clk",
> +			"core_usb_pipe_clk", "ctrl_link_clk",
> +			"ctrl_link_iface_clk", "ctrl_pixel_clk",
> +			"crypto_clk", "pixel_clk_rcg";
> +
> +		pll-node = <&dp_pll>;
> +		qcom,aux-cfg0-settings = [20 00];
> +		qcom,aux-cfg1-settings = [24 13 23 1d];
> +		qcom,aux-cfg2-settings = [28 24];
> +		qcom,aux-cfg3-settings = [2c 00];
> +		qcom,aux-cfg4-settings = [30 0a];
> +		qcom,aux-cfg5-settings = [34 26];
> +		qcom,aux-cfg6-settings = [38 0a];
> +		qcom,aux-cfg7-settings = [3c 03];
> +		qcom,aux-cfg8-settings = [40 bb];
> +		qcom,aux-cfg9-settings = [44 03];
> +
> +		qcom,max-pclk-frequency-khz = <675000>;
> +
> +		qcom,ctrl-supply-entries {
> +			#address-cells = <1>;
> +			#size-cells = <0>;
> +
> +			qcom,ctrl-supply-entry@0 {
> +				reg = <0>;
> +				qcom,supply-name = "vdda-1p2";
> +				qcom,supply-min-voltage = <1200000>;
> +				qcom,supply-max-voltage = <1200000>;
> +				qcom,supply-enable-load = <21800>;
> +				qcom,supply-disable-load = <4>;
> +			};
> +		};
> +
> +		qcom,phy-supply-entries {
> +			#address-cells = <1>;
> +			#size-cells = <0>;
> +
> +			qcom,phy-supply-entry@0 {
> +				reg = <0>;
> +				qcom,supply-name = "vdda-0p9";
> +				qcom,supply-min-voltage = <880000>;
> +				qcom,supply-max-voltage = <880000>;
> +				qcom,supply-enable-load = <36000>;
> +				qcom,supply-disable-load = <32>;
> +			};
> +		};
> +
> +		ports {
> +			#address-cells = <1>;
> +			#size-cells = <0>;
> +
> +			port@0 {
> +				reg = <0>;
> +				dp_in: endpoint {
> +					remote-endpoint = <&dpu_intf0_out>;
> +				};
> +			};
> +
> +			port@1 {
> +				reg = <1>;
> +				dp_out: endpoint {
> +				};
> +			};
> +		};
> +	};
> +
> +	dp_pll: dp-pll@c011000 {
> +		compatible = "qcom,dp-pll-10nm";
> +		label = "DP PLL";
> +		cell-index = <0>;
> +		#clock-cells = <1>;
> +
> +		reg = <1 0xea000 0x200>,
> +		      <1 0xeaa00 0x200>,
> +		      <1 0xea200 0x200>,
> +		      <1 0xea600 0x200>,
> +		      <2 0x03000 0x8>;
> +		reg-names = "pll_base", "phy_base", "ln_tx0_base",
> +			"ln_tx1_base", "gdsc_base";
> +
> +		clocks = <&dispcc DISP_CC_MDSS_AHB_CLK>,
> +			 <&gcc GCC_USB3_PRIM_CLKREF_CLK>,
> +			 <&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
> +			 <&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>;
> +		clock-names = "iface_clk", "ref_clk",
> +			"cfg_ahb_clk", "pipe_clk";
> +		clock-rate = <0>;
> +
> +	};
> diff --git a/Documentation/devicetree/bindings/display/msm/dpu.txt b/Documentation/devicetree/bindings/display/msm/dpu.txt
> index ad2e883..ab2d1f6 100644
> --- a/Documentation/devicetree/bindings/display/msm/dpu.txt
> +++ b/Documentation/devicetree/bindings/display/msm/dpu.txt
> @@ -58,8 +58,9 @@ Required properties:
>  	Documentation/devicetree/bindings/graph.txt
>  	Documentation/devicetree/bindings/media/video-interfaces.txt
>  
> -	Port 0 -> DPU_INTF1 (DSI1)
> -	Port 1 -> DPU_INTF2 (DSI2)
> +	Port 0 -> DPU_INTF0 (DP)
> +	Port 1 -> DPU_INTF1 (DSI1)
> +	Port 2 -> DPU_INTF2 (DSI2)
>  
>  Optional properties:
>  - assigned-clocks: list of clock specifiers for clocks needing rate assignment
> @@ -115,13 +116,20 @@ Example:
>  
>  				port@0 {
>  					reg = <0>;
> -					dpu_intf1_out: endpoint {
> -						remote-endpoint = <&dsi0_in>;
> +					dpu_intf0_out: endpoint {
> +						remote-endpoint = <&dp_in>;
>  					};
>  				};
>  
>  				port@1 {
>  					reg = <1>;
> +					dpu_intf1_out: endpoint {
> +						remote-endpoint = <&dsi0_in>;
> +					};
> +				};
> +
> +				port@2 {
> +					reg = <2>;
>  					dpu_intf2_out: endpoint {
>  						remote-endpoint = <&dsi1_in>;
>  					};
> -- 
> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
> a Linux Foundation Collaborative Project
> 

-- 
Sean Paul, Software Engineer, Google / Chromium OS
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 1/3] dt-bindings: msm/dp: add bindings of DP/DP-PLL driver for Snapdragon 845

[Stephen Boyd]

Quoting Chandan Uddaraju (2018-10-10 10:15:57)
> diff --git a/Documentation/devicetree/bindings/display/msm/dp.txt b/Documentation/devicetree/bindings/display/msm/dp.txt
> new file mode 100644
> index 0000000..0155266
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/display/msm/dp.txt
> @@ -0,0 +1,249 @@
> +Qualcomm Technologies, Inc.
> +DP is the master Display Port device which supports DP host controllers that are compatible with VESA Display Port interface specification.
> +DP Controller: Required properties:
> +- compatible:           Should be "qcom,dp-display".
> +- reg:                  Base address and length of DP hardware's memory mapped regions.
> +- cell-index:           Specifies the controller instance.
> +- reg-names:            A list of strings that name the list of regs.

This is a lot of register regions! There are probably multiple devices
in here.

> +                       "dp_ahb" - DP controller memory region.
> +                       "dp_aux" - DP AUX memory region.
> +                       "dp_link" - DP link layer memory region.
> +                       "dp_p0" - DP pixel clock domain memory region.
> +                       "dp_phy" - DP PHY memory region.

So a phy driver? Should be different binding and device than the DP
controller?

> +                       "dp_ln_tx0" - USB3 DP PHY combo TX-0 lane memory region.
> +                       "dp_ln_tx1" - USB3 DP PHY combo TX-1 lane memory region.

Presumably part of the phy device. Again, different binding?

> +                       "dp_mmss_cc" - Display Clock Control memory region.

No. This shouldn't be reaching into the display clock controller region.
That should be it's own node and device driver.

> +                       "qfprom_physical" - QFPROM Phys memory region.

qfprom is accessed through nvmem framework, please use it instead of
remapping it and reading random bits directly from your driver.

> +                       "dp_pll" - USB3 DP combo PLL memory region.
> +                       "usb3_dp_com" - USB3 DP PHY combo memory region.

I guess this would go with the DP phy node?

> +                       "hdcp_physical" - DP HDCP memory region.

Goes with the main DP device?

Please drop the full stop from all of these lines.

> +- interrupt-parent     phandle to the interrupt parent device node.

We don't need this sort of duplicate information. If it's part of
standard spec and not specific to this binding it can be left out.

> +- interrupts:          The interrupt signal from the DP block.
> +- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
> +- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
> +                       "core_aux_clk", "core_usb_ref_clk_src","core_usb_ref_clk", "core_usb_cfg_ahb_clk",
> +                       "core_usb_pipe_clk", "ctrl_link_clk", "ctrl_link_iface_clk", "ctrl_crypto_clk",
> +                       "ctrl_pixel_clk", "pixel_clk_rcg", "pixel_parent".

Please remove "_clk" from all your clock-names. It's redundant and makes
things harder to read.

> +- pll-node:            phandle to DP PLL node.

Huh?

> +- vdda-1p2-supply:             phandle to vdda 1.2V regulator node.
> +- vdda-0p9-supply:             phandle to vdda 0.9V regulator node.

Perhaps these have other names besides vdda? Maybe vdda-pll and vdda?
I'd also drop the 1p2 and 0p9 from them and just describe that in
freeform in the binding.

> +- qcom,aux-cfg0-settings:              Specifies the DP AUX configuration 0 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg1-settings:              Specifies the DP AUX configuration 1 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg2-settings:              Specifies the DP AUX configuration 2 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg3-settings:              Specifies the DP AUX configuration 3 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg4-settings:              Specifies the DP AUX configuration 4 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg5-settings:              Specifies the DP AUX configuration 5 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg6-settings:              Specifies the DP AUX configuration 6 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg7-settings:              Specifies the DP AUX configuration 7 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg8-settings:              Specifies the DP AUX configuration 8 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.
> +- qcom,aux-cfg9-settings:              Specifies the DP AUX configuration 9 settings. The first
> +                                       entry in this array corresponds to the register offset
> +                                       within DP AUX, while the remaining entries indicate the
> +                                       programmable values.

Look like magic bits. Can they just be thrown into the driver? Or
specified in some way that us mere mortals know what to put into these
bits.

> +- qcom,max-pclk-frequency-khz: An integer specifying the maximum. pixel clock in KHz supported by Display Port.

Why is this in the binding? It isn't known based on the device
compatible string?

> +- extcon:                              Phandle for the external connector class interface.

Is this for typec? Would be good to say what it's for.

> +- qcom,<type>-supply-entries:          A node that lists the elements of the supply used by the a particular "type" of DP module. The module "types"
> +                                       can be "core", "ctrl", and "phy". Within the same type,
> +                                       there can be more than one instance of this binding,
> +                                       in which case the entry would be appended with the
> +                                       supply entry index.
> +                                       e.g. qcom,ctrl-supply-entry@0
> +                                       -- qcom,supply-name: name of the supply (vdd/vdda/vddio)
> +                                       -- qcom,supply-min-voltage: minimum voltage level (uV)
> +                                       -- qcom,supply-max-voltage: maximum voltage level (uV)
> +                                       -- qcom,supply-enable-load: load drawn (uA) from enabled supply
> +                                       -- qcom,supply-disable-load: load drawn (uA) from disabled supply
> +                                       -- qcom,supply-pre-on-sleep: time to sleep (ms) before turning on
> +                                       -- qcom,supply-post-on-sleep: time to sleep (ms) after turning on
> +                                       -- qcom,supply-pre-off-sleep: time to sleep (ms) before turning off
> +                                       -- qcom,supply-post-off-sleep: time to sleep (ms) after turning off

All these properties should go away. min/max should be handled by board
constraints. Sleep times should be handled by regulator framework for
those particular regulators. Maybe the load would be important, but I'm
still sort of lost how that wouldn't be expressed through some SoC
compatible string for the device and then hardcoded into the driver.

> +- pinctrl-names:       List of names to assign mdss pin states defined in pinctrl device node
> +                                       Refer to pinctrl-bindings.txt
> +- pinctrl-<0..n>:      Lists phandles each pointing to the pin configuration node within a pin
> +                                       controller. These pin configurations are installed in the pinctrl
> +                                       device node. Refer to pinctrl-bindings.txt

This isn't needed in the binding. Or at least, I don't see where it's
expressed in the example, so probably just noise?

> +DP Endpoint properties:
> +  - remote-endpoint: For port@0, set to phandle of the connected panel/bridge's
> +    input endpoint. For port@1, set to the DPU interface output. See [2] for
> +    device graph info.
> +
> +Optional properties:
> +- qcom,aux-en-gpio:            Specifies the aux-channel enable gpio.
> +- qcom,aux-sel-gpio:           Specifies the aux-channel select gpio.

These should follow standard 'gpios' properties, like aux-enable-gpios
and aux-select-gpios. I guess these would need pinctrl muxing too.

> +
> +
> +DP PLL: Required properties:
> +- compatible:           Should be "qcom,dp-pll-10nm".
> +- reg:                  Base address and length of DP hardware's memory mapped regions.
> +- cell-index:           Specifies the PLL instance.
> +- reg-names:            A list of strings that name the list of regs.
> +                       "pll_base" - DP PLL memory region.
> +                       "phy_base" - DP PHY memory region.
> +                       "ln_tx0_base" - USB3 DP PHY combo TX-0 lane memory region.
> +                       "ln_tx1_base" - USB3 DP PHY combo TX-1 lane memory region.
> +                       "gdsc_base" - gdsc memory region.

Why a gdsc_base? GDSCs should be handled by power domains?

> +- interrupt-parent     phandle to the interrupt parent device node.

Again, drop this one.

> +- interrupts:          The interrupt signal from the DP block.
> +- clocks:               Clocks required for Display Port operation. See [1] for details on clock bindings.
> +- clock-names:          Names of the clocks corresponding to handles. Following clocks are required:
> +                       "iface_clk", "ref_clk", cfg_ahb_clk", "pipe_clk".

Again, drop "_clk" please.

> +- clock-rate:           Initial clock rate to be configured. For the shared clocks, the default value                       is set to zero so that minimum clock value is configured. Non-zero clock
> +                       value can be used to configure DP pixel clock.

We have assigned-clock-rates for this. Can you use that?

> +
> +
> +[1] Documentation/devicetree/bindings/clock/clock-bindings.txt
> +[2] Documentation/devicetree/bindings/graph.txt
> +
> +Example:
> +       msm_dp: dp_display@ae90000{
> +               cell-index = <0>;

Is this needed?

> +               compatible = "qcom,dp-display";
> +
> +               reg =   <0 0x90000 0x0dc>,
> +                       <0 0x90200 0x0c0>,
> +                       <0 0x90400 0x508>,
> +                       <0 0x90a00 0x094>,

Looks like one device with one reg property:

		<0x90000 0x1000>

> +                       <1 0xeaa00 0x200>,
> +                       <1 0xea200 0x200>,
> +                       <1 0xea600 0x200>,

Looks like another device with one reg property:

		<0xea000 0x1000>;

> +                       <2 0x02000 0x1a0>,
> +                       <3 0x00000 0x621c>,
> +                       <1 0xea000 0x180>,

This is part of the one above.

> +                       <1 0xe8000 0x20>,

Well maybe this is also part of the DP phy? Then it would start
somewhere a little earlier I supposed.

> +                       <4 0xe1000 0x034>;
> +               reg-names = "dp_ahb", "dp_aux", "dp_link",
> +                       "dp_p0", "dp_phy", "dp_ln_tx0", "dp_ln_tx1",
> +                       "dp_mmss_cc", "qfprom_physical", "dp_pll",
> +                       "usb3_dp_com", "hdcp_physical";
> +
> +               interrupt-parent = <&mdss>;
> +               interrupts = <12 0>;

Why is this interrupt-parent stuff being done?

> +
> +               extcon = <&usb_1_ssphy>;
> +               clocks =  <&dispcc DISP_CC_MDSS_DP_AUX_CLK>,
> +                       <&rpmhcc RPMH_CXO_CLK>,
> +                       <&gcc GCC_USB3_PRIM_CLKREF_CLK>,
> +                       <&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
> +                       <&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>,

It's really odd that this device needs USB phy clocks. Is it really
necessary to do this?

> +                       <&dispcc DISP_CC_MDSS_DP_LINK_CLK>,
> +                       <&dispcc DISP_CC_MDSS_DP_LINK_INTF_CLK>,
> +                       <&dispcc DISP_CC_MDSS_DP_PIXEL_CLK>,
> +                       <&dispcc DISP_CC_MDSS_DP_CRYPTO_CLK>,
> +                       <&dispcc DISP_CC_MDSS_DP_PIXEL_CLK_SRC>;
> +               clock-names = "core_aux_clk", "core_ref_clk_src",
> +                       "core_usb_ref_clk", "core_usb_cfg_ahb_clk",
> +                       "core_usb_pipe_clk", "ctrl_link_clk",
> +                       "ctrl_link_iface_clk", "ctrl_pixel_clk",
> +                       "crypto_clk", "pixel_clk_rcg";
> +
> +               pll-node = <&dp_pll>;
> +               qcom,aux-cfg0-settings = [20 00];
> +               qcom,aux-cfg1-settings = [24 13 23 1d];
> +               qcom,aux-cfg2-settings = [28 24];
> +               qcom,aux-cfg3-settings = [2c 00];
> +               qcom,aux-cfg4-settings = [30 0a];
> +               qcom,aux-cfg5-settings = [34 26];
> +               qcom,aux-cfg6-settings = [38 0a];
> +               qcom,aux-cfg7-settings = [3c 03];
> +               qcom,aux-cfg8-settings = [40 bb];
> +               qcom,aux-cfg9-settings = [44 03];
> +
> +               qcom,max-pclk-frequency-khz = <675000>;
> +
> +               qcom,ctrl-supply-entries {
> +                       #address-cells = <1>;
> +                       #size-cells = <0>;
> +
> +                       qcom,ctrl-supply-entry@0 {
> +                               reg = <0>;
> +                               qcom,supply-name = "vdda-1p2";
> +                               qcom,supply-min-voltage = <1200000>;
> +                               qcom,supply-max-voltage = <1200000>;
> +                               qcom,supply-enable-load = <21800>;
> +                               qcom,supply-disable-load = <4>;
> +                       };
> +               };
> +
> +               qcom,phy-supply-entries {
> +                       #address-cells = <1>;
> +                       #size-cells = <0>;
> +
> +                       qcom,phy-supply-entry@0 {
> +                               reg = <0>;
> +                               qcom,supply-name = "vdda-0p9";
> +                               qcom,supply-min-voltage = <880000>;
> +                               qcom,supply-max-voltage = <880000>;
> +                               qcom,supply-enable-load = <36000>;
> +                               qcom,supply-disable-load = <32>;
> +                       };
> +               };

NAK on the above two nodes.

> +
> +               ports {
> +                       #address-cells = <1>;
> +                       #size-cells = <0>;
> +
> +                       port@0 {
> +                               reg = <0>;
> +                               dp_in: endpoint {
> +                                       remote-endpoint = <&dpu_intf0_out>;
> +                               };
> +                       };
> +
> +                       port@1 {
> +                               reg = <1>;
> +                               dp_out: endpoint {
> +                               };
> +                       };
> +               };
> +       };
> +
> +       dp_pll: dp-pll@c011000 {

This doesn't even match reg property.

> +               compatible = "qcom,dp-pll-10nm";
> +               label = "DP PLL";
> +               cell-index = <0>;
> +               #clock-cells = <1>;
> +
> +               reg = <1 0xea000 0x200>,
> +                     <1 0xeaa00 0x200>,
> +                     <1 0xea200 0x200>,
> +                     <1 0xea600 0x200>,
> +                     <2 0x03000 0x8>;

Why 1 and 2? What's going on in this example.

> +               reg-names = "pll_base", "phy_base", "ln_tx0_base",
> +                       "ln_tx1_base", "gdsc_base";

Don't think we really need "_base" on these reg-names either. Seems
redundant.

> +
> +               clocks = <&dispcc DISP_CC_MDSS_AHB_CLK>,
> +                        <&gcc GCC_USB3_PRIM_CLKREF_CLK>,
> +                        <&gcc GCC_USB_PHY_CFG_AHB2PHY_CLK>,
> +                        <&gcc GCC_USB3_PRIM_PHY_PIPE_CLK>;
> +               clock-names = "iface_clk", "ref_clk",
> +                       "cfg_ahb_clk", "pipe_clk";
> +               clock-rate = <0>;
> +
> +       };
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

[DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Chandan Uddaraju]

Add the needed displayPort files to enable DP driver
on msm target.

"dp_display" module is the main module that calls into
other sub-modules. "dp_drm" file represents the interface
between DRM framework and DP driver.

Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
---
 drivers/gpu/drm/msm/Kconfig                 |    9 +
 drivers/gpu/drm/msm/Makefile                |   15 +-
 drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
 drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
 drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
 drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
 drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 ++++++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
 drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 +++++++++++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
 drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
 drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
 drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
 drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
 drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
 drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
 drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
 drivers/gpu/drm/msm/dp/dp_link.c            | 1549 +++++++++++++++++++++++++++
 drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
 drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
 drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
 drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
 drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
 drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
 drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
 drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
 drivers/gpu/drm/msm/msm_drv.c               |    2 +
 drivers/gpu/drm/msm/msm_drv.h               |   22 +
 include/drm/drm_dp_helper.h                 |   19 +
 30 files changed, 10887 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
 create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
 create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h

diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
index 843a9d4..c363f24 100644
--- a/drivers/gpu/drm/msm/Kconfig
+++ b/drivers/gpu/drm/msm/Kconfig
@@ -49,6 +49,15 @@ config DRM_MSM_HDMI_HDCP
 	help
 	  Choose this option to enable HDCP state machine
 
+config DRM_MSM_DP
+	bool "Enable DP support in MSM DRM driver"
+	depends on DRM_MSM
+	default n
+	help
+	  Compile in support for DP driver in msm drm
+	  driver. DP external display support is enabled
+	  through this config option. It can be primary or
+	  secondary display on device.
 config DRM_MSM_DSI
 	bool "Enable DSI support in MSM DRM driver"
 	depends on DRM_MSM
diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
index 19ab521..765a8d8 100644
--- a/drivers/gpu/drm/msm/Makefile
+++ b/drivers/gpu/drm/msm/Makefile
@@ -2,6 +2,7 @@
 ccflags-y := -Idrivers/gpu/drm/msm
 ccflags-y += -Idrivers/gpu/drm/msm/disp/dpu1
 ccflags-$(CONFIG_DRM_MSM_DSI) += -Idrivers/gpu/drm/msm/dsi
+ccflags-$(CONFIG_DRM_MSM_DP) += -Idrivers/gpu/drm/msm/dp
 
 msm-y := \
 	adreno/adreno_device.o \
@@ -93,7 +94,19 @@ msm-y := \
 	msm_submitqueue.o
 
 msm-$(CONFIG_DEBUG_FS) += adreno/a5xx_debugfs.o \
-			  disp/dpu1/dpu_dbg.o
+			  disp/dpu1/dpu_dbg.o \
+			  dp/dp_debug.o
+
+msm-$(CONFIG_DRM_MSM_DP)+= dp/dp_extcon.o \
+	dp/dp_parser.o \
+	dp/dp_power.o \
+	dp/dp_catalog.o \
+	dp/dp_aux.o \
+	dp/dp_panel.o \
+	dp/dp_link.o \
+	dp/dp_ctrl.o \
+	dp/dp_display.o \
+	dp/dp_drm.o
 
 msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
 msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
index 790d39f..0f53a15 100644
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
@@ -14,10 +14,216 @@
 #include <linux/clk.h>
 #include <linux/clk/clk-conf.h>
 #include <linux/err.h>
+#include <linux/io.h>
+#include <linux/regulator/consumer.h>
 #include <linux/delay.h>
 
 #include "dpu_io_util.h"
 
+static struct resource *msm_dss_get_res_byname(struct platform_device *pdev,
+					       unsigned int type,
+					       const char *name)
+{
+	struct resource *res = NULL;
+
+	res = platform_get_resource_byname(pdev, type, name);
+	if (!res)
+		DEV_ERR("%s: '%s' resource not found\n", __func__, name);
+
+	return res;
+} /* msm_dss_get_res_byname */
+
+int msm_dss_ioremap_byname(struct platform_device *pdev,
+			   struct dss_io_data *io_data, const char *name)
+{
+	struct resource *res = NULL;
+
+	if (!pdev || !io_data) {
+		DEV_ERR("%pS->%s: invalid input\n",
+			__builtin_return_address(0), __func__);
+		return -EINVAL;
+	}
+
+	res = msm_dss_get_res_byname(pdev, IORESOURCE_MEM, name);
+	if (!res) {
+		DEV_ERR("%pS->%s: '%s' msm_dss_get_res_byname failed\n",
+			__builtin_return_address(0), __func__, name);
+		return -ENODEV;
+	}
+
+	io_data->len = (u32)resource_size(res);
+	io_data->base = ioremap(res->start, io_data->len);
+	if (!io_data->base) {
+		DEV_ERR("%pS->%s: '%s' ioremap failed\n",
+			__builtin_return_address(0), __func__, name);
+		return -EIO;
+	}
+
+	return 0;
+} /* msm_dss_ioremap_byname */
+
+void msm_dss_iounmap(struct dss_io_data *io_data)
+{
+	if (!io_data) {
+		DEV_ERR("%pS->%s: invalid input\n",
+			__builtin_return_address(0), __func__);
+		return;
+	}
+
+	if (io_data->base) {
+		iounmap(io_data->base);
+		io_data->base = NULL;
+	}
+	io_data->len = 0;
+} /* msm_dss_iounmap */
+
+int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
+			int num_vreg, int config)
+{
+	int i = 0, rc = 0;
+	struct dss_vreg *curr_vreg = NULL;
+	enum dss_vreg_type type;
+
+	if (!in_vreg || !num_vreg)
+		return rc;
+
+	if (config) {
+		for (i = 0; i < num_vreg; i++) {
+			curr_vreg = &in_vreg[i];
+			curr_vreg->vreg = regulator_get(dev,
+				curr_vreg->vreg_name);
+			rc = PTR_RET(curr_vreg->vreg);
+			if (rc) {
+				DEV_ERR("%pS->%s: %s get failed. rc=%d\n",
+					 __builtin_return_address(0), __func__,
+					 curr_vreg->vreg_name, rc);
+				curr_vreg->vreg = NULL;
+				goto vreg_get_fail;
+			}
+			type = (regulator_count_voltages(curr_vreg->vreg) > 0)
+					? DSS_REG_LDO : DSS_REG_VS;
+			if (type == DSS_REG_LDO) {
+				rc = regulator_set_voltage(
+					curr_vreg->vreg,
+					curr_vreg->min_voltage,
+					curr_vreg->max_voltage);
+				if (rc < 0) {
+					DEV_ERR("%pS->%s: %s set vltg fail\n",
+						__builtin_return_address(0),
+						__func__,
+						curr_vreg->vreg_name);
+					goto vreg_set_voltage_fail;
+				}
+			}
+		}
+	} else {
+		for (i = num_vreg-1; i >= 0; i--) {
+			curr_vreg = &in_vreg[i];
+			if (curr_vreg->vreg) {
+				type = (regulator_count_voltages(
+					curr_vreg->vreg) > 0)
+					? DSS_REG_LDO : DSS_REG_VS;
+				if (type == DSS_REG_LDO) {
+					regulator_set_voltage(curr_vreg->vreg,
+						0, curr_vreg->max_voltage);
+				}
+				regulator_put(curr_vreg->vreg);
+				curr_vreg->vreg = NULL;
+			}
+		}
+	}
+	return 0;
+
+vreg_unconfig:
+if (type == DSS_REG_LDO)
+	regulator_set_load(curr_vreg->vreg, 0);
+
+vreg_set_voltage_fail:
+	regulator_put(curr_vreg->vreg);
+	curr_vreg->vreg = NULL;
+
+vreg_get_fail:
+	for (i--; i >= 0; i--) {
+		curr_vreg = &in_vreg[i];
+		type = (regulator_count_voltages(curr_vreg->vreg) > 0)
+			? DSS_REG_LDO : DSS_REG_VS;
+		goto vreg_unconfig;
+	}
+	return rc;
+} /* msm_dss_config_vreg */
+
+int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg, int enable)
+{
+	int i = 0, rc = 0;
+	bool need_sleep;
+
+	if (enable) {
+		for (i = 0; i < num_vreg; i++) {
+			rc = PTR_RET(in_vreg[i].vreg);
+			if (rc) {
+				DEV_ERR("%pS->%s: %s regulator error. rc=%d\n",
+					__builtin_return_address(0), __func__,
+					in_vreg[i].vreg_name, rc);
+				goto vreg_set_opt_mode_fail;
+			}
+			need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
+			if (in_vreg[i].pre_on_sleep && need_sleep)
+				usleep_range(in_vreg[i].pre_on_sleep * 1000,
+					in_vreg[i].pre_on_sleep * 1000);
+			rc = regulator_set_load(in_vreg[i].vreg,
+				in_vreg[i].enable_load);
+			if (rc < 0) {
+				DEV_ERR("%pS->%s: %s set opt m fail\n",
+					__builtin_return_address(0), __func__,
+					in_vreg[i].vreg_name);
+				goto vreg_set_opt_mode_fail;
+			}
+			rc = regulator_enable(in_vreg[i].vreg);
+			if (in_vreg[i].post_on_sleep && need_sleep)
+				usleep_range(in_vreg[i].post_on_sleep * 1000,
+					in_vreg[i].post_on_sleep * 1000);
+			if (rc < 0) {
+				DEV_ERR("%pS->%s: %s enable failed\n",
+					__builtin_return_address(0), __func__,
+					in_vreg[i].vreg_name);
+				goto disable_vreg;
+			}
+		}
+	} else {
+		for (i = num_vreg-1; i >= 0; i--) {
+			if (in_vreg[i].pre_off_sleep)
+				usleep_range(in_vreg[i].pre_off_sleep * 1000,
+					in_vreg[i].pre_off_sleep * 1000);
+			regulator_set_load(in_vreg[i].vreg,
+				in_vreg[i].disable_load);
+			regulator_disable(in_vreg[i].vreg);
+			if (in_vreg[i].post_off_sleep)
+				usleep_range(in_vreg[i].post_off_sleep * 1000,
+					in_vreg[i].post_off_sleep * 1000);
+		}
+	}
+	return rc;
+
+disable_vreg:
+	regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
+
+vreg_set_opt_mode_fail:
+	for (i--; i >= 0; i--) {
+		if (in_vreg[i].pre_off_sleep)
+			usleep_range(in_vreg[i].pre_off_sleep * 1000,
+				in_vreg[i].pre_off_sleep * 1000);
+		regulator_set_load(in_vreg[i].vreg,
+			in_vreg[i].disable_load);
+		regulator_disable(in_vreg[i].vreg);
+		if (in_vreg[i].post_off_sleep)
+			usleep_range(in_vreg[i].post_off_sleep * 1000,
+				in_vreg[i].post_off_sleep * 1000);
+	}
+
+	return rc;
+} /* msm_dss_enable_vreg */
+
+
 void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk)
 {
 	int i;
diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
index bc07381..524b394 100644
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
@@ -15,6 +15,7 @@
 
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
 #include <linux/types.h>
 
 #define DEV_DBG(fmt, args...)   pr_debug(fmt, ##args)
@@ -22,6 +23,39 @@
 #define DEV_WARN(fmt, args...)  pr_warn(fmt, ##args)
 #define DEV_ERR(fmt, args...)   pr_err(fmt, ##args)
 
+struct dss_io_data {
+	u32 len;
+	void __iomem *base;
+};
+
+/*
+void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 debug);
+u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug);
+void dss_reg_dump(void __iomem *base, u32 len, const char *prefix, u32 debug);
+
+#define DSS_REG_W_ND(io, offset, val)  dss_reg_w(io, offset, val, false)
+#define DSS_REG_W(io, offset, val)     dss_reg_w(io, offset, val, true)
+#define DSS_REG_R_ND(io, offset)       dss_reg_r(io, offset, false)
+#define DSS_REG_R(io, offset)          dss_reg_r(io, offset, true)
+*/
+enum dss_vreg_type {
+	DSS_REG_LDO,
+	DSS_REG_VS,
+};
+
+struct dss_vreg {
+	struct regulator *vreg; /* vreg handle */
+	char vreg_name[32];
+	int min_voltage;
+	int max_voltage;
+	int enable_load;
+	int disable_load;
+	int pre_on_sleep;
+	int post_on_sleep;
+	int pre_off_sleep;
+	int post_off_sleep;
+};
+
 struct dss_gpio {
 	unsigned int gpio;
 	unsigned int value;
@@ -42,12 +76,22 @@ struct dss_clk {
 };
 
 struct dss_module_power {
+	unsigned int num_vreg;
+	struct dss_vreg *vreg_config;
 	unsigned int num_gpio;
 	struct dss_gpio *gpio_config;
 	unsigned int num_clk;
 	struct dss_clk *clk_config;
 };
 
+int msm_dss_ioremap_byname(struct platform_device *pdev,
+			   struct dss_io_data *io_data, const char *name);
+void msm_dss_iounmap(struct dss_io_data *io_data);
+
+int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
+			int num_vreg, int config);
+int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg,	int enable);
+
 int msm_dss_get_clk(struct device *dev, struct dss_clk *clk_arry, int num_clk);
 void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk);
 int msm_dss_clk_set_rate(struct dss_clk *clk_arry, int num_clk);
diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c b/drivers/gpu/drm/msm/dp/dp_aux.c
new file mode 100644
index 0000000..00b82c2
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_aux.c
@@ -0,0 +1,570 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/delay.h>
+
+#include "dp_aux.h"
+
+#define DP_AUX_ENUM_STR(x)		#x
+
+enum {
+	DP_AUX_DATA_INDEX_WRITE = BIT(31),
+};
+
+struct dp_aux_private {
+	struct device *dev;
+	struct dp_aux dp_aux;
+	struct dp_catalog_aux *catalog;
+	struct dp_aux_cfg *cfg;
+
+	struct mutex mutex;
+	struct completion comp;
+
+	u32 aux_error_num;
+	u32 retry_cnt;
+	bool cmd_busy;
+	bool native;
+	bool read;
+	bool no_send_addr;
+	bool no_send_stop;
+	u32 offset;
+	u32 segment;
+
+	struct drm_dp_aux drm_aux;
+};
+
+static char *dp_aux_get_error(u32 aux_error)
+{
+	switch (aux_error) {
+	case DP_AUX_ERR_NONE:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_NONE);
+	case DP_AUX_ERR_ADDR:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_ADDR);
+	case DP_AUX_ERR_TOUT:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_TOUT);
+	case DP_AUX_ERR_NACK:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_NACK);
+	case DP_AUX_ERR_DEFER:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_DEFER);
+	case DP_AUX_ERR_NACK_DEFER:
+		return DP_AUX_ENUM_STR(DP_AUX_ERR_NACK_DEFER);
+	default:
+		return "unknown";
+	}
+}
+
+static u32 dp_aux_write(struct dp_aux_private *aux,
+			struct drm_dp_aux_msg *msg)
+{
+	u32 data[4], reg, len;
+	u8 *msgdata = msg->buffer;
+	int const aux_cmd_fifo_len = 128;
+	int i = 0;
+
+	if (aux->read)
+		len = 4;
+	else
+		len = msg->size + 4;
+
+	/*
+	 * cmd fifo only has depth of 144 bytes
+	 * limit buf length to 128 bytes here
+	 */
+	if (len > aux_cmd_fifo_len) {
+		pr_err("buf len error\n");
+		return 0;
+	}
+
+	/* Pack cmd and write to HW */
+	data[0] = (msg->address >> 16) & 0xf; /* addr[19:16] */
+	if (aux->read)
+		data[0] |=  BIT(4); /* R/W */
+
+	data[1] = (msg->address >> 8) & 0xff;	/* addr[15:8] */
+	data[2] = msg->address & 0xff;		/* addr[7:0] */
+	data[3] = (msg->size - 1) & 0xff;	/* len[7:0] */
+
+	for (i = 0; i < len; i++) {
+		reg = (i < 4) ? data[i] : msgdata[i - 4];
+		reg = ((reg) << 8) & 0x0000ff00; /* index = 0, write */
+		if (i == 0)
+			reg |= DP_AUX_DATA_INDEX_WRITE;
+		aux->catalog->data = reg;
+		aux->catalog->write_data(aux->catalog);
+	}
+
+	aux->catalog->clear_trans(aux->catalog, false);
+
+	reg = 0; /* Transaction number == 1 */
+	if (!aux->native) { /* i2c */
+		reg |= BIT(8);
+
+		if (aux->no_send_addr)
+			reg |= BIT(10);
+
+		if (aux->no_send_stop)
+			reg |= BIT(11);
+	}
+
+	reg |= BIT(9);
+	aux->catalog->data = reg;
+	aux->catalog->write_trans(aux->catalog);
+
+	return len;
+}
+
+static int dp_aux_cmd_fifo_tx(struct dp_aux_private *aux,
+			      struct drm_dp_aux_msg *msg)
+{
+	u32 ret = 0, len = 0, timeout;
+	int const aux_timeout_ms = HZ/4;
+
+	reinit_completion(&aux->comp);
+
+	len = dp_aux_write(aux, msg);
+	if (len == 0) {
+		pr_err("DP AUX write failed\n");
+		return -EINVAL;
+	}
+
+	timeout = wait_for_completion_timeout(&aux->comp, aux_timeout_ms);
+	if (!timeout) {
+		pr_err("aux %s timeout\n", (aux->read ? "read" : "write"));
+		return -ETIMEDOUT;
+	}
+
+	if (aux->aux_error_num == DP_AUX_ERR_NONE) {
+		ret = len;
+	} else {
+		pr_err_ratelimited("aux err: %s\n",
+			dp_aux_get_error(aux->aux_error_num));
+
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+static void dp_aux_cmd_fifo_rx(struct dp_aux_private *aux,
+		struct drm_dp_aux_msg *msg)
+{
+	u32 data;
+	u8 *dp;
+	u32 i, actual_i;
+	u32 len = msg->size;
+
+	aux->catalog->clear_trans(aux->catalog, true);
+
+	data = 0;
+	data |= DP_AUX_DATA_INDEX_WRITE; /* INDEX_WRITE */
+	data |= BIT(0);  /* read */
+
+	aux->catalog->data = data;
+	aux->catalog->write_data(aux->catalog);
+
+	dp = msg->buffer;
+
+	/* discard first byte */
+	data = aux->catalog->read_data(aux->catalog);
+
+	for (i = 0; i < len; i++) {
+		data = aux->catalog->read_data(aux->catalog);
+		*dp++ = (u8)((data >> 8) & 0xff);
+
+		actual_i = (data >> 16) & 0xFF;
+		if (i != actual_i)
+			pr_warn("Index mismatch: expected %d, found %d\n",
+				i, actual_i);
+	}
+}
+
+static void dp_aux_native_handler(struct dp_aux_private *aux)
+{
+	u32 isr = aux->catalog->isr;
+
+	if (isr & DP_INTR_AUX_I2C_DONE)
+		aux->aux_error_num = DP_AUX_ERR_NONE;
+	else if (isr & DP_INTR_WRONG_ADDR)
+		aux->aux_error_num = DP_AUX_ERR_ADDR;
+	else if (isr & DP_INTR_TIMEOUT)
+		aux->aux_error_num = DP_AUX_ERR_TOUT;
+	if (isr & DP_INTR_NACK_DEFER)
+		aux->aux_error_num = DP_AUX_ERR_NACK;
+
+	complete(&aux->comp);
+}
+
+static void dp_aux_i2c_handler(struct dp_aux_private *aux)
+{
+	u32 isr = aux->catalog->isr;
+
+	if (isr & DP_INTR_AUX_I2C_DONE) {
+		if (isr & (DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER))
+			aux->aux_error_num = DP_AUX_ERR_NACK;
+		else
+			aux->aux_error_num = DP_AUX_ERR_NONE;
+	} else {
+		if (isr & DP_INTR_WRONG_ADDR)
+			aux->aux_error_num = DP_AUX_ERR_ADDR;
+		else if (isr & DP_INTR_TIMEOUT)
+			aux->aux_error_num = DP_AUX_ERR_TOUT;
+		if (isr & DP_INTR_NACK_DEFER)
+			aux->aux_error_num = DP_AUX_ERR_NACK_DEFER;
+		if (isr & DP_INTR_I2C_NACK)
+			aux->aux_error_num = DP_AUX_ERR_NACK;
+		if (isr & DP_INTR_I2C_DEFER)
+			aux->aux_error_num = DP_AUX_ERR_DEFER;
+	}
+
+	complete(&aux->comp);
+}
+
+static void dp_aux_isr(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	aux->catalog->get_irq(aux->catalog, aux->cmd_busy);
+
+	if (!aux->cmd_busy)
+		return;
+
+	if (aux->native)
+		dp_aux_native_handler(aux);
+	else
+		dp_aux_i2c_handler(aux);
+}
+
+static void dp_aux_reconfig(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	aux->catalog->update_aux_cfg(aux->catalog,
+			aux->cfg, PHY_AUX_CFG1);
+	aux->catalog->reset(aux->catalog);
+}
+
+static void dp_aux_update_offset_and_segment(struct dp_aux_private *aux,
+					     struct drm_dp_aux_msg *input_msg)
+{
+	u32 const edid_address = 0x50;
+	u32 const segment_address = 0x30;
+	bool i2c_read = input_msg->request &
+		(DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
+	u8 *data = NULL;
+
+	if (aux->native || i2c_read || ((input_msg->address != edid_address) &&
+		(input_msg->address != segment_address)))
+		return;
+
+
+	data = input_msg->buffer;
+	if (input_msg->address == segment_address)
+		aux->segment = *data;
+	else
+		aux->offset = *data;
+}
+
+/**
+ * dp_aux_transfer_helper() - helper function for EDID read transactions
+ *
+ * @aux: DP AUX private structure
+ * @input_msg: input message from DRM upstream APIs
+ *
+ * return: void
+ *
+ * This helper function is used to fix EDID reads for non-compliant
+ * sinks that do not handle the i2c middle-of-transaction flag correctly.
+ */
+static void dp_aux_transfer_helper(struct dp_aux_private *aux,
+				   struct drm_dp_aux_msg *input_msg)
+{
+	struct drm_dp_aux_msg helper_msg;
+	u32 const message_size = 0x10;
+	u32 const segment_address = 0x30;
+	bool i2c_mot = input_msg->request & DP_AUX_I2C_MOT;
+	bool i2c_read = input_msg->request &
+		(DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
+
+	if (!i2c_mot || !i2c_read || (input_msg->size == 0))
+		return;
+
+	aux->read = false;
+	aux->cmd_busy = true;
+	aux->no_send_addr = true;
+	aux->no_send_stop = true;
+
+	/*
+	 * Send the segment address for every i2c read in which the
+	 * middle-of-tranaction flag is set. This is required to support EDID
+	 * reads of more than 2 blocks as the segment address is reset to 0
+	 * since we are overriding the middle-of-transaction flag for read
+	 * transactions.
+	 */
+	memset(&helper_msg, 0, sizeof(helper_msg));
+	helper_msg.address = segment_address;
+	helper_msg.buffer = &aux->segment;
+	helper_msg.size = 1;
+	dp_aux_cmd_fifo_tx(aux, &helper_msg);
+
+	/*
+	 * Send the offset address for every i2c read in which the
+	 * middle-of-transaction flag is set. This will ensure that the sink
+	 * will update its read pointer and return the correct portion of the
+	 * EDID buffer in the subsequent i2c read trasntion triggered in the
+	 * native AUX transfer function.
+	 */
+	memset(&helper_msg, 0, sizeof(helper_msg));
+	helper_msg.address = input_msg->address;
+	helper_msg.buffer = &aux->offset;
+	helper_msg.size = 1;
+	dp_aux_cmd_fifo_tx(aux, &helper_msg);
+	aux->offset += message_size;
+
+	if (aux->offset == 0x80 || aux->offset == 0x100)
+		aux->segment = 0x0; /* reset segment at end of block */
+}
+
+/*
+ * This function does the real job to process an AUX transaction.
+ * It will call aux_reset() function to reset the AUX channel,
+ * if the waiting is timeout.
+ */
+static ssize_t dp_aux_transfer(struct drm_dp_aux *drm_aux,
+			       struct drm_dp_aux_msg *msg)
+{
+	ssize_t ret;
+	int const aux_cmd_native_max = 16;
+	int const aux_cmd_i2c_max = 128;
+	int const retry_count = 5;
+	struct dp_aux_private *aux = container_of(drm_aux,
+		struct dp_aux_private, drm_aux);
+
+	mutex_lock(&aux->mutex);
+
+	aux->native = msg->request & (DP_AUX_NATIVE_WRITE & DP_AUX_NATIVE_READ);
+
+	/* Ignore address only message */
+	if ((msg->size == 0) || (msg->buffer == NULL)) {
+		msg->reply = aux->native ?
+			DP_AUX_NATIVE_REPLY_ACK : DP_AUX_I2C_REPLY_ACK;
+		ret = msg->size;
+		goto unlock_exit;
+	}
+
+	/* msg sanity check */
+	if ((aux->native && (msg->size > aux_cmd_native_max)) ||
+		(msg->size > aux_cmd_i2c_max)) {
+		pr_err("%s: invalid msg: size(%zu), request(%x)\n",
+			__func__, msg->size, msg->request);
+		ret = -EINVAL;
+		goto unlock_exit;
+	}
+
+	dp_aux_update_offset_and_segment(aux, msg);
+	dp_aux_transfer_helper(aux, msg);
+
+	aux->read = msg->request & (DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
+	aux->cmd_busy = true;
+
+	if (aux->read) {
+		aux->no_send_addr = true;
+		aux->no_send_stop = false;
+	} else {
+		aux->no_send_addr = true;
+		aux->no_send_stop = true;
+	}
+
+	ret = dp_aux_cmd_fifo_tx(aux, msg);
+	if ((ret < 0) && aux->native) {
+		aux->retry_cnt++;
+		if (!(aux->retry_cnt % retry_count))
+			aux->catalog->update_aux_cfg(aux->catalog,
+				aux->cfg, PHY_AUX_CFG1);
+		aux->catalog->reset(aux->catalog);
+		goto unlock_exit;
+	} else if (ret < 0) {
+		goto unlock_exit;
+	}
+
+	if (aux->aux_error_num == DP_AUX_ERR_NONE) {
+		if (aux->read)
+			dp_aux_cmd_fifo_rx(aux, msg);
+
+		msg->reply = aux->native ?
+			DP_AUX_NATIVE_REPLY_ACK : DP_AUX_I2C_REPLY_ACK;
+	} else {
+		/* Reply defer to retry */
+		msg->reply = aux->native ?
+			DP_AUX_NATIVE_REPLY_DEFER : DP_AUX_I2C_REPLY_DEFER;
+	}
+
+	/* Return requested size for success or retry */
+	ret = msg->size;
+	aux->retry_cnt = 0;
+
+unlock_exit:
+	aux->cmd_busy = false;
+	mutex_unlock(&aux->mutex);
+	return ret;
+}
+
+static void dp_aux_reset_phy_config_indices(struct dp_aux_cfg *aux_cfg)
+{
+	int i = 0;
+
+	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
+		aux_cfg[i].current_index = 0;
+}
+
+static void dp_aux_init(struct dp_aux *dp_aux, struct dp_aux_cfg *aux_cfg)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux || !aux_cfg) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	dp_aux_reset_phy_config_indices(aux_cfg);
+	aux->catalog->setup(aux->catalog, aux_cfg);
+	aux->catalog->reset(aux->catalog);
+	aux->catalog->enable(aux->catalog, true);
+	aux->retry_cnt = 0;
+}
+
+static void dp_aux_deinit(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	aux->catalog->enable(aux->catalog, false);
+}
+
+static int dp_aux_register(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+	int ret = 0;
+
+	if (!dp_aux) {
+		pr_err("invalid input\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	aux->drm_aux.name = "dpu_dp_aux";
+	aux->drm_aux.dev = aux->dev;
+	aux->drm_aux.transfer = dp_aux_transfer;
+	ret = drm_dp_aux_register(&aux->drm_aux);
+	if (ret) {
+		pr_err("%s: failed to register drm aux: %d\n", __func__, ret);
+		goto exit;
+	}
+	dp_aux->drm_aux = &aux->drm_aux;
+exit:
+	return ret;
+}
+
+static void dp_aux_deregister(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+	drm_dp_aux_unregister(&aux->drm_aux);
+}
+
+struct dp_aux *dp_aux_get(struct device *dev, struct dp_catalog_aux *catalog,
+			  struct dp_aux_cfg *aux_cfg)
+{
+	int rc = 0;
+	struct dp_aux_private *aux;
+	struct dp_aux *dp_aux;
+
+	if (!catalog || !aux_cfg) {
+		pr_err("invalid input\n");
+		rc = -ENODEV;
+		goto error;
+	}
+
+	aux = devm_kzalloc(dev, sizeof(*aux), GFP_KERNEL);
+	if (!aux) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	init_completion(&aux->comp);
+	aux->cmd_busy = false;
+	mutex_init(&aux->mutex);
+
+	aux->dev = dev;
+	aux->catalog = catalog;
+	aux->cfg = aux_cfg;
+	dp_aux = &aux->dp_aux;
+	aux->retry_cnt = 0;
+
+	dp_aux->isr     = dp_aux_isr;
+	dp_aux->init    = dp_aux_init;
+	dp_aux->deinit  = dp_aux_deinit;
+	dp_aux->drm_aux_register = dp_aux_register;
+	dp_aux->drm_aux_deregister = dp_aux_deregister;
+	dp_aux->reconfig = dp_aux_reconfig;
+
+	return dp_aux;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_aux_put(struct dp_aux *dp_aux)
+{
+	struct dp_aux_private *aux;
+
+	if (!dp_aux)
+		return;
+
+	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+
+	mutex_destroy(&aux->mutex);
+
+	devm_kfree(aux->dev, aux);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h b/drivers/gpu/drm/msm/dp/dp_aux.h
new file mode 100644
index 0000000..0c300ed
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_aux.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_AUX_H_
+#define _DP_AUX_H_
+
+#include "dp_catalog.h"
+#include <drm/drm_dp_helper.h>
+
+enum dp_aux_error {
+	DP_AUX_ERR_NONE	= 0,
+	DP_AUX_ERR_ADDR	= -1,
+	DP_AUX_ERR_TOUT	= -2,
+	DP_AUX_ERR_NACK	= -3,
+	DP_AUX_ERR_DEFER	= -4,
+	DP_AUX_ERR_NACK_DEFER	= -5,
+};
+
+struct dp_aux {
+	struct drm_dp_aux *drm_aux;
+	int (*drm_aux_register)(struct dp_aux *aux);
+	void (*drm_aux_deregister)(struct dp_aux *aux);
+	void (*isr)(struct dp_aux *aux);
+	void (*init)(struct dp_aux *aux, struct dp_aux_cfg *aux_cfg);
+	void (*deinit)(struct dp_aux *aux);
+	void (*reconfig)(struct dp_aux *aux);
+};
+
+struct dp_aux *dp_aux_get(struct device *dev, struct dp_catalog_aux *catalog,
+			  struct dp_aux_cfg *aux_cfg);
+void dp_aux_put(struct dp_aux *aux);
+
+#endif /*__DP_AUX_H_*/
diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c b/drivers/gpu/drm/msm/dp/dp_catalog.c
new file mode 100644
index 0000000..5818612
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
@@ -0,0 +1,1188 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/delay.h>
+#include <drm/drm_dp_helper.h>
+
+#include "dp_catalog.h"
+#include "dp_reg.h"
+
+#define DP_GET_MSB(x)	(x >> 8)
+#define DP_GET_LSB(x)	(x & 0xff)
+
+#define dp_read(offset) readl_relaxed((offset))
+#define dp_write(offset, data) writel_relaxed((data), (offset))
+
+#define dp_catalog_get_priv(x) { \
+	struct dp_catalog *dp_catalog; \
+	dp_catalog = container_of(x, struct dp_catalog, x); \
+	catalog = container_of(dp_catalog, struct dp_catalog_private, \
+				dp_catalog); \
+}
+
+#define DP_INTERRUPT_STATUS1 \
+	(DP_INTR_AUX_I2C_DONE| \
+	DP_INTR_WRONG_ADDR | DP_INTR_TIMEOUT | \
+	DP_INTR_NACK_DEFER | DP_INTR_WRONG_DATA_CNT | \
+	DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER | \
+	DP_INTR_PLL_UNLOCKED | DP_INTR_AUX_ERROR)
+
+#define DP_INTR_MASK1		(DP_INTERRUPT_STATUS1 << 2)
+
+#define DP_INTERRUPT_STATUS2 \
+	(DP_INTR_READY_FOR_VIDEO | DP_INTR_IDLE_PATTERN_SENT | \
+	DP_INTR_FRAME_END | DP_INTR_CRC_UPDATED)
+
+#define DP_INTR_MASK2		(DP_INTERRUPT_STATUS2 << 2)
+
+static u8 const vm_pre_emphasis[4][4] = {
+	{0x00, 0x0B, 0x12, 0xFF},       /* pe0, 0 db */
+	{0x00, 0x0A, 0x12, 0xFF},       /* pe1, 3.5 db */
+	{0x00, 0x0C, 0xFF, 0xFF},       /* pe2, 6.0 db */
+	{0xFF, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
+};
+
+/* voltage swing, 0.2v and 1.0v are not support */
+static u8 const vm_voltage_swing[4][4] = {
+	{0x07, 0x0F, 0x14, 0xFF}, /* sw0, 0.4v  */
+	{0x11, 0x1D, 0x1F, 0xFF}, /* sw1, 0.6 v */
+	{0x18, 0x1F, 0xFF, 0xFF}, /* sw1, 0.8 v */
+	{0xFF, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
+};
+
+/* audio related catalog functions */
+struct dp_catalog_private {
+	struct device *dev;
+	struct dp_io *io;
+
+	u32 (*audio_map)[DP_AUDIO_SDP_HEADER_MAX];
+	struct dp_catalog dp_catalog;
+};
+
+/* aux related catalog functions */
+static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	return dp_read(base + DP_AUX_DATA);
+end:
+	return 0;
+}
+
+static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
+{
+	int rc = 0;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	dp_write(base + DP_AUX_DATA, aux->data);
+end:
+	return rc;
+}
+
+static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
+{
+	int rc = 0;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	dp_write(base + DP_AUX_TRANS_CTRL, aux->data);
+end:
+	return rc;
+}
+
+static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, bool read)
+{
+	int rc = 0;
+	u32 data = 0;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	if (read) {
+		data = dp_read(base + DP_AUX_TRANS_CTRL);
+		data &= ~BIT(9);
+		dp_write(base + DP_AUX_TRANS_CTRL, data);
+	} else {
+		dp_write(base + DP_AUX_TRANS_CTRL, 0);
+	}
+end:
+	return rc;
+}
+
+static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
+{
+	u32 aux_ctrl;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	aux_ctrl = dp_read(base + DP_AUX_CTRL);
+
+	aux_ctrl |= BIT(1);
+	dp_write(base + DP_AUX_CTRL, aux_ctrl);
+	usleep_range(1000, 1010); /* h/w recommended delay */
+
+	aux_ctrl &= ~BIT(1);
+	dp_write(base + DP_AUX_CTRL, aux_ctrl);
+	wmb();
+}
+
+static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool enable)
+{
+	u32 aux_ctrl;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(aux);
+	base = catalog->io->dp_aux.base;
+
+	aux_ctrl = dp_read(base + DP_AUX_CTRL);
+
+	if (enable) {
+		dp_write(base + DP_TIMEOUT_COUNT, 0xffff);
+		dp_write(base + DP_AUX_LIMITS, 0xffff);
+		aux_ctrl |= BIT(0);
+	} else {
+		aux_ctrl &= ~BIT(0);
+	}
+
+	dp_write(base + DP_AUX_CTRL, aux_ctrl);
+}
+
+static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
+		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type)
+{
+	struct dp_catalog_private *catalog;
+	u32 new_index = 0, current_index = 0;
+
+	if (!aux || !cfg || (type >= PHY_AUX_CFG_MAX)) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(aux);
+
+	current_index = cfg[type].current_index;
+	new_index = (current_index + 1) % cfg[type].cfg_cnt;
+	pr_debug("Updating %s from 0x%08x to 0x%08x\n",
+		dp_phy_aux_config_type_to_string(type),
+	cfg[type].lut[current_index], cfg[type].lut[new_index]);
+
+	dp_write(catalog->io->phy_io.base + cfg[type].offset,
+			cfg[type].lut[new_index]);
+	cfg[type].current_index = new_index;
+}
+
+static void dp_catalog_aux_setup(struct dp_catalog_aux *aux,
+		struct dp_aux_cfg *cfg)
+{
+	struct dp_catalog_private *catalog;
+	int i = 0;
+
+	if (!aux || !cfg) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(aux);
+
+	dp_write(catalog->io->phy_io.base + DP_PHY_PD_CTL, 0x65);
+	wmb(); /* make sure PD programming happened */
+
+	/* Turn on BIAS current for PHY/PLL */
+	dp_write(catalog->io->dp_pll_io.base +
+		QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x1b);
+
+	/* DP AUX CFG register programming */
+	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
+		pr_debug("%s: offset=0x%08x, value=0x%08x\n",
+			dp_phy_aux_config_type_to_string(i),
+			cfg[i].offset, cfg[i].lut[cfg[i].current_index]);
+		dp_write(catalog->io->phy_io.base + cfg[i].offset,
+			cfg[i].lut[cfg[i].current_index]);
+	}
+
+	dp_write(catalog->io->phy_io.base + DP_PHY_AUX_INTERRUPT_MASK, 0x1F);
+}
+
+static void dp_catalog_aux_get_irq(struct dp_catalog_aux *aux, bool cmd_busy)
+{
+	u32 ack;
+	struct dp_catalog_private *catalog;
+	void __iomem *ahb_base;
+
+	if (!aux) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(aux);
+	ahb_base = catalog->io->dp_ahb.base;
+
+	aux->isr = dp_read(ahb_base + DP_INTR_STATUS);
+	aux->isr &= ~DP_INTR_MASK1;
+	ack = aux->isr & DP_INTERRUPT_STATUS1;
+	ack <<= 1;
+	ack |= DP_INTR_MASK1;
+	dp_write(ahb_base + DP_INTR_STATUS, ack);
+}
+
+/* controller related catalog functions */
+static void dp_catalog_ctrl_update_transfer_unit(struct dp_catalog_ctrl *ctrl)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	dp_write(base + DP_VALID_BOUNDARY, ctrl->valid_boundary);
+	dp_write(base + DP_TU, ctrl->dp_tu);
+	dp_write(base + DP_VALID_BOUNDARY_2, ctrl->valid_boundary2);
+}
+
+static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, u32 state)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	dp_write(base + DP_STATE_CTRL, state);
+}
+
+static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, u32 cfg)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *link_base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	link_base = catalog->io->dp_link.base;
+
+	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
+
+	dp_write(link_base + DP_CONFIGURATION_CTRL, cfg);
+}
+
+static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl *ctrl)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	dp_write(base + DP_LOGICAL2PHYSICAL_LANE_MAPPING, 0xe4);
+}
+
+static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl *ctrl,
+						bool enable)
+{
+	u32 mainlink_ctrl;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	if (enable) {
+		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
+		wmb(); /* make sure mainlink is turned off before reset */
+		dp_write(base + DP_MAINLINK_CTRL, 0x02000002);
+		wmb(); /* make sure mainlink entered reset */
+		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
+		wmb(); /* make sure mainlink reset done */
+		dp_write(base + DP_MAINLINK_CTRL, 0x02000001);
+		wmb(); /* make sure mainlink turned on */
+	} else {
+		mainlink_ctrl = dp_read(base + DP_MAINLINK_CTRL);
+		mainlink_ctrl &= ~BIT(0);
+		dp_write(base + DP_MAINLINK_CTRL, mainlink_ctrl);
+	}
+}
+
+static void dp_catalog_ctrl_config_misc(struct dp_catalog_ctrl *ctrl,
+					u32 cc, u32 tb)
+{
+	u32 misc_val;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	misc_val = dp_read(base + DP_MISC1_MISC0);
+	misc_val |= cc;
+	misc_val |= (tb << 5);
+	misc_val |= BIT(0); /* Configure clock to synchronous mode */
+
+	pr_debug("misc settings = 0x%x\n", misc_val);
+	dp_write(base + DP_MISC1_MISC0, misc_val);
+}
+
+static void dp_catalog_ctrl_config_msa(struct dp_catalog_ctrl *ctrl,
+					u32 rate, u32 stream_rate_khz,
+					bool fixed_nvid)
+{
+	u32 pixel_m, pixel_n;
+	u32 mvid, nvid;
+	u64 mvid_calc;
+	u32 const nvid_fixed = 0x8000;
+	u32 const link_rate_hbr2 = 540000;
+	u32 const link_rate_hbr3 = 810000;
+	struct dp_catalog_private *catalog;
+	void __iomem *base_cc, *base_ctrl;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	if (fixed_nvid) {
+		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
+		nvid = nvid_fixed;
+
+		pr_debug("link rate=%dkbps, stream_rate_khz=%uKhz",
+			rate, stream_rate_khz);
+
+		/*
+		 * For intermediate results, use 64 bit arithmetic to avoid
+		 * loss of precision.
+		 */
+		mvid_calc = (u64) stream_rate_khz * nvid;
+		mvid_calc = div_u64(mvid_calc, rate);
+
+		/*
+		 * truncate back to 32 bits as this final divided value will
+		 * always be within the range of a 32 bit unsigned int.
+		 */
+		mvid = (u32) mvid_calc;
+	} else {
+		base_cc = catalog->io->dp_cc_io.base;
+
+		pixel_m = dp_read(base_cc + MMSS_DP_PIXEL_M);
+		pixel_n = dp_read(base_cc + MMSS_DP_PIXEL_N);
+		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
+
+		mvid = (pixel_m & 0xFFFF) * 5;
+		nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
+
+		pr_debug("rate = %d\n", rate);
+
+		if (link_rate_hbr2 == rate)
+			nvid *= 2;
+
+		if (link_rate_hbr3 == rate)
+			nvid *= 3;
+	}
+
+	base_ctrl = catalog->io->dp_link.base;
+	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
+	dp_write(base_ctrl + DP_SOFTWARE_MVID, mvid);
+	dp_write(base_ctrl + DP_SOFTWARE_NVID, nvid);
+}
+
+static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
+					u32 pattern)
+{
+	int bit, cnt = 10;
+	u32 data;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	bit = 1;
+	bit <<= (pattern - 1);
+	pr_debug("hw: bit=%d train=%d\n", bit, pattern);
+	dp_write(base + DP_STATE_CTRL, bit);
+
+	bit = 8;
+	bit <<= (pattern - 1);
+
+	while (cnt--) {
+		data = dp_read(base + DP_MAINLINK_READY);
+		if (data & bit)
+			break;
+	}
+
+	if (cnt == 0)
+		pr_err("set link_train=%d failed\n", pattern);
+}
+
+static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, bool flip)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+
+	base = catalog->io->usb3_dp_com.base;
+
+	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x0a);
+	dp_write(base + USB3_DP_COM_PHY_MODE_CTRL, 0x02);
+	dp_write(base + USB3_DP_COM_SW_RESET, 0x01);
+	/* make sure usb3 com phy software reset is done */
+	wmb();
+
+	if (!flip) /* CC1 */
+		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x02);
+	else /* CC2 */
+		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x03);
+
+	dp_write(base + USB3_DP_COM_SWI_CTRL, 0x00);
+	dp_write(base + USB3_DP_COM_SW_RESET, 0x00);
+	/* make sure the software reset is done */
+	wmb();
+
+	dp_write(base + USB3_DP_COM_POWER_DOWN_CTRL, 0x01);
+	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x00);
+	/* make sure phy is brought out of reset */
+	wmb();
+
+}
+
+static void dp_catalog_panel_tpg_cfg(struct dp_catalog_panel *panel,
+	bool enable)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!panel) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(panel);
+	base = catalog->io->dp_p0.base;
+
+	if (!enable) {
+		dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x0);
+		dp_write(base + MMSS_DP_BIST_ENABLE, 0x0);
+		dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x0);
+		wmb(); /* ensure Timing generator is turned off */
+		return;
+	}
+
+	dp_write(base + MMSS_DP_INTF_CONFIG, 0x0);
+	dp_write(base + MMSS_DP_INTF_HSYNC_CTL, panel->hsync_ctl);
+	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F0, panel->vsync_period *
+			panel->hsync_period);
+	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0, panel->v_sync_width *
+			panel->hsync_period);
+	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F1, 0);
+	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1, 0);
+	dp_write(base + MMSS_DP_INTF_DISPLAY_HCTL, panel->display_hctl);
+	dp_write(base + MMSS_DP_INTF_ACTIVE_HCTL, 0);
+	dp_write(base + MMSS_INTF_DISPLAY_V_START_F0, panel->display_v_start);
+	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F0, panel->display_v_end);
+	dp_write(base + MMSS_INTF_DISPLAY_V_START_F1, 0);
+	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F1, 0);
+	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F0, 0);
+	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F0, 0);
+	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F1, 0);
+	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F1, 0);
+	dp_write(base + MMSS_DP_INTF_POLARITY_CTL, 0);
+	wmb(); /* ensure TPG registers are programmed */
+
+	dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x100);
+	dp_write(base + MMSS_DP_TPG_VIDEO_CONFIG, 0x5);
+	wmb(); /* ensure TPG config is programmed */
+	dp_write(base + MMSS_DP_BIST_ENABLE, 0x1);
+	dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x1);
+	wmb(); /* ensure Timing generator is turned on */
+	pr_debug("%s: enabled tpg\n", __func__);
+}
+
+static void dp_catalog_ctrl_reset(struct dp_catalog_ctrl *ctrl)
+{
+	u32 sw_reset;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_ahb.base;
+
+	sw_reset = dp_read(base + DP_SW_RESET);
+
+	sw_reset |= BIT(0);
+	dp_write(base + DP_SW_RESET, sw_reset);
+	usleep_range(1000, 1010); /* h/w recommended delay */
+
+	sw_reset &= ~BIT(0);
+	dp_write(base + DP_SW_RESET, sw_reset);
+}
+
+static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl *ctrl)
+{
+	u32 data;
+	int cnt = 10;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_link.base;
+
+	while (--cnt) {
+		/* DP_MAINLINK_READY */
+		data = dp_read(base + DP_MAINLINK_READY);
+		if (data & BIT(0))
+			return true;
+
+		usleep_range(1000, 1010); /* 1ms wait before next reg read */
+	}
+	pr_err("mainlink not ready\n");
+end:
+	return false;
+}
+
+static void dp_catalog_ctrl_enable_irq(struct dp_catalog_ctrl *ctrl,
+						bool enable)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_ahb.base;
+
+	if (enable) {
+		dp_write(base + DP_INTR_STATUS, DP_INTR_MASK1);
+		dp_write(base + DP_INTR_STATUS2, DP_INTR_MASK2);
+	} else {
+		dp_write(base + DP_INTR_STATUS, 0x00);
+		dp_write(base + DP_INTR_STATUS2, 0x00);
+	}
+}
+
+static void dp_catalog_ctrl_hpd_config(struct dp_catalog_ctrl *ctrl, bool en)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_aux.base;
+
+	if (en) {
+		u32 reftimer = dp_read(base + DP_DP_HPD_REFTIMER);
+
+		dp_write(base + DP_DP_HPD_INT_ACK, 0xF);
+		dp_write(base + DP_DP_HPD_INT_MASK, 0xF);
+
+		/* Enabling REFTIMER */
+		reftimer |= BIT(16);
+		dp_write(base + DP_DP_HPD_REFTIMER, 0xF);
+		/* Enable HPD */
+		dp_write(base + DP_DP_HPD_CTRL, 0x1);
+	} else {
+		/*Disable HPD */
+		dp_write(base + DP_DP_HPD_CTRL, 0x0);
+	}
+}
+
+static void dp_catalog_ctrl_get_interrupt(struct dp_catalog_ctrl *ctrl)
+{
+	u32 ack = 0;
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_ahb.base;
+
+	ctrl->isr = dp_read(base + DP_INTR_STATUS2);
+	ctrl->isr &= ~DP_INTR_MASK2;
+	ack = ctrl->isr & DP_INTERRUPT_STATUS2;
+	ack <<= 1;
+	ack |= DP_INTR_MASK2;
+	dp_write(base + DP_INTR_STATUS2, ack);
+}
+
+static void dp_catalog_ctrl_phy_reset(struct dp_catalog_ctrl *ctrl)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base = catalog->io->dp_ahb.base;
+
+	dp_write(base + DP_PHY_CTRL, 0x5); /* bit 0 & 2 */
+	usleep_range(1000, 1010); /* h/w recommended delay */
+	dp_write(base + DP_PHY_CTRL, 0x0);
+	wmb(); /* make sure PHY reset done */
+}
+
+static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl *ctrl,
+		bool flipped, u8 ln_cnt)
+{
+	u32 info = 0x0;
+	struct dp_catalog_private *catalog;
+	u8 orientation = BIT(!!flipped);
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+
+	info |= (ln_cnt & 0x0F);
+	info |= ((orientation & 0x0F) << 4);
+	pr_debug("Shared Info = 0x%x\n", info);
+
+	dp_write(catalog->io->phy_io.base + DP_PHY_SPARE0, info);
+}
+
+static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl *ctrl,
+		u8 v_level, u8 p_level)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base0, *base1;
+	u8 value0, value1;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+	base0 = catalog->io->ln_tx0_io.base;
+	base1 = catalog->io->ln_tx1_io.base;
+
+	pr_debug("hw: v=%d p=%d\n", v_level, p_level);
+
+	value0 = vm_voltage_swing[v_level][p_level];
+	value1 = vm_pre_emphasis[v_level][p_level];
+
+	/* program default setting first */
+	dp_write(base0 + TXn_TX_DRV_LVL, 0x2A);
+	dp_write(base1 + TXn_TX_DRV_LVL, 0x2A);
+	dp_write(base0 + TXn_TX_EMP_POST1_LVL, 0x20);
+	dp_write(base1 + TXn_TX_EMP_POST1_LVL, 0x20);
+
+	/* Enable MUX to use Cursor values from these registers */
+	value0 |= BIT(5);
+	value1 |= BIT(5);
+
+	/* Configure host and panel only if both values are allowed */
+	if (value0 != 0xFF && value1 != 0xFF) {
+		dp_write(base0 + TXn_TX_DRV_LVL, value0);
+		dp_write(base1 + TXn_TX_DRV_LVL, value0);
+		dp_write(base0 + TXn_TX_EMP_POST1_LVL, value1);
+		dp_write(base1 + TXn_TX_EMP_POST1_LVL, value1);
+
+		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
+			value0, value1);
+	} else {
+		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
+			v_level, value0, p_level, value1);
+	}
+}
+
+static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl *ctrl,
+			u32 pattern)
+{
+	struct dp_catalog_private *catalog;
+	u32 value = 0x0;
+	void __iomem *base = NULL;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp_catalog_get_priv(ctrl);
+
+	base = catalog->io->dp_link.base;
+
+	dp_write(base + DP_STATE_CTRL, 0x0);
+
+	switch (pattern) {
+	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
+		dp_write(base + DP_STATE_CTRL, 0x1);
+		break;
+	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
+		value &= ~(1 << 16);
+		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
+		value |= 0xFC;
+		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
+		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
+		dp_write(base + DP_STATE_CTRL, 0x10);
+		break;
+	case DP_TEST_PHY_PATTERN_PRBS7:
+		dp_write(base + DP_STATE_CTRL, 0x20);
+		break;
+	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
+		dp_write(base + DP_STATE_CTRL, 0x40);
+		/* 00111110000011111000001111100000 */
+		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG0, 0x3E0F83E0);
+		/* 00001111100000111110000011111000 */
+		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG1, 0x0F83E0F8);
+		/* 1111100000111110 */
+		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG2, 0x0000F83E);
+		break;
+	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
+		value = BIT(16);
+		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
+		value |= 0xFC;
+		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
+		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
+		dp_write(base + DP_STATE_CTRL, 0x10);
+		break;
+	default:
+		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
+		return;
+	}
+
+	/* Make sure the test pattern is programmed in the hardware */
+	wmb();
+}
+
+static u32 dp_catalog_ctrl_read_phy_pattern(struct dp_catalog_ctrl *ctrl)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base = NULL;
+
+	if (!ctrl) {
+		pr_err("invalid input\n");
+		return 0;
+	}
+
+	dp_catalog_get_priv(ctrl);
+
+	base = catalog->io->dp_link.base;
+
+	return dp_read(base + DP_MAINLINK_READY);
+}
+
+/* panel related catalog functions */
+static int dp_catalog_panel_timing_cfg(struct dp_catalog_panel *panel)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+
+	if (!panel) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	dp_catalog_get_priv(panel);
+	base = catalog->io->dp_link.base;
+
+	dp_write(base + DP_TOTAL_HOR_VER, panel->total);
+	dp_write(base + DP_START_HOR_VER_FROM_SYNC, panel->sync_start);
+	dp_write(base + DP_HSYNC_VSYNC_WIDTH_POLARITY, panel->width_blanking);
+	dp_write(base + DP_ACTIVE_HOR_VER, panel->dp_active);
+end:
+	return 0;
+}
+
+static void dp_catalog_audio_init(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	static u32 sdp_map[][DP_AUDIO_SDP_HEADER_MAX] = {
+		{
+			MMSS_DP_AUDIO_STREAM_0,
+			MMSS_DP_AUDIO_STREAM_1,
+			MMSS_DP_AUDIO_STREAM_1,
+		},
+		{
+			MMSS_DP_AUDIO_TIMESTAMP_0,
+			MMSS_DP_AUDIO_TIMESTAMP_1,
+			MMSS_DP_AUDIO_TIMESTAMP_1,
+		},
+		{
+			MMSS_DP_AUDIO_INFOFRAME_0,
+			MMSS_DP_AUDIO_INFOFRAME_1,
+			MMSS_DP_AUDIO_INFOFRAME_1,
+		},
+		{
+			MMSS_DP_AUDIO_COPYMANAGEMENT_0,
+			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
+			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
+		},
+		{
+			MMSS_DP_AUDIO_ISRC_0,
+			MMSS_DP_AUDIO_ISRC_1,
+			MMSS_DP_AUDIO_ISRC_1,
+		},
+	};
+
+	if (!audio)
+		return;
+
+	dp_catalog_get_priv(audio);
+
+	catalog->audio_map = sdp_map;
+}
+
+static void dp_catalog_audio_config_sdp(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+	u32 sdp_cfg = 0;
+	u32 sdp_cfg2 = 0;
+
+	if (!audio)
+		return;
+
+	dp_catalog_get_priv(audio);
+	base = catalog->io->dp_link.base;
+
+	sdp_cfg = dp_read(base + MMSS_DP_SDP_CFG);
+
+	/* AUDIO_TIMESTAMP_SDP_EN */
+	sdp_cfg |= BIT(1);
+	/* AUDIO_STREAM_SDP_EN */
+	sdp_cfg |= BIT(2);
+	/* AUDIO_COPY_MANAGEMENT_SDP_EN */
+	sdp_cfg |= BIT(5);
+	/* AUDIO_ISRC_SDP_EN  */
+	sdp_cfg |= BIT(6);
+	/* AUDIO_INFOFRAME_SDP_EN  */
+	sdp_cfg |= BIT(20);
+
+	pr_debug("sdp_cfg = 0x%x\n", sdp_cfg);
+	dp_write(base + MMSS_DP_SDP_CFG, sdp_cfg);
+
+	sdp_cfg2 = dp_read(base + MMSS_DP_SDP_CFG2);
+	/* IFRM_REGSRC -> Do not use reg values */
+	sdp_cfg2 &= ~BIT(0);
+	/* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
+	sdp_cfg2 &= ~BIT(1);
+
+	pr_debug("sdp_cfg2 = 0x%x\n", sdp_cfg2);
+	dp_write(base + MMSS_DP_SDP_CFG2, sdp_cfg2);
+}
+
+static void dp_catalog_audio_get_header(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
+	void __iomem *base;
+	enum dp_catalog_audio_sdp_type sdp;
+	enum dp_catalog_audio_header_type header;
+
+	if (!audio)
+		return;
+
+	dp_catalog_get_priv(audio);
+
+	base    = catalog->io->dp_link.base;
+	sdp_map = catalog->audio_map;
+	sdp     = audio->sdp_type;
+	header  = audio->sdp_header;
+
+	audio->data = dp_read(base + sdp_map[sdp][header]);
+}
+
+static void dp_catalog_audio_set_header(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
+	void __iomem *base;
+	enum dp_catalog_audio_sdp_type sdp;
+	enum dp_catalog_audio_header_type header;
+	u32 data;
+
+	if (!audio)
+		return;
+
+	dp_catalog_get_priv(audio);
+
+	base    = catalog->io->dp_link.base;
+	sdp_map = catalog->audio_map;
+	sdp     = audio->sdp_type;
+	header  = audio->sdp_header;
+	data    = audio->data;
+
+	dp_write(base + sdp_map[sdp][header], data);
+}
+
+static void dp_catalog_audio_config_acr(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+	u32 acr_ctrl, select;
+
+	dp_catalog_get_priv(audio);
+
+	select = audio->data;
+	base   = catalog->io->dp_link.base;
+
+	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
+
+	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
+
+	dp_write(base + MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
+}
+
+static void dp_catalog_audio_safe_to_exit_level(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+	u32 mainlink_levels, safe_to_exit_level;
+
+	dp_catalog_get_priv(audio);
+
+	base   = catalog->io->dp_link.base;
+	safe_to_exit_level = audio->data;
+
+	mainlink_levels = dp_read(base + DP_MAINLINK_LEVELS);
+	mainlink_levels &= 0xFE0;
+	mainlink_levels |= safe_to_exit_level;
+
+	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
+			mainlink_levels, safe_to_exit_level);
+
+	dp_write(base + DP_MAINLINK_LEVELS, mainlink_levels);
+}
+
+static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
+{
+	struct dp_catalog_private *catalog;
+	void __iomem *base;
+	bool enable;
+	u32 audio_ctrl;
+
+	dp_catalog_get_priv(audio);
+
+	base   = catalog->io->dp_link.base;
+	enable = !!audio->data;
+
+	audio_ctrl = dp_read(base + MMSS_DP_AUDIO_CFG);
+
+	if (enable)
+		audio_ctrl |= BIT(0);
+	else
+		audio_ctrl &= ~BIT(0);
+
+	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
+	dp_write(base + MMSS_DP_AUDIO_CFG, audio_ctrl);
+
+	/* make sure audio engine is disabled */
+	wmb();
+}
+
+struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io)
+{
+	int rc = 0;
+	struct dp_catalog *dp_catalog;
+	struct dp_catalog_private *catalog;
+	struct dp_catalog_aux aux = {
+		.read_data     = dp_catalog_aux_read_data,
+		.write_data    = dp_catalog_aux_write_data,
+		.write_trans   = dp_catalog_aux_write_trans,
+		.clear_trans   = dp_catalog_aux_clear_trans,
+		.reset         = dp_catalog_aux_reset,
+		.update_aux_cfg = dp_catalog_aux_update_cfg,
+		.enable        = dp_catalog_aux_enable,
+		.setup         = dp_catalog_aux_setup,
+		.get_irq       = dp_catalog_aux_get_irq,
+	};
+	struct dp_catalog_ctrl ctrl = {
+		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
+		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
+		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
+		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
+		.config_misc    = dp_catalog_ctrl_config_misc,
+		.config_msa     = dp_catalog_ctrl_config_msa,
+		.set_pattern    = dp_catalog_ctrl_set_pattern,
+		.reset          = dp_catalog_ctrl_reset,
+		.usb_reset      = dp_catalog_ctrl_usb_reset,
+		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
+		.enable_irq     = dp_catalog_ctrl_enable_irq,
+		.hpd_config     = dp_catalog_ctrl_hpd_config,
+		.phy_reset      = dp_catalog_ctrl_phy_reset,
+		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
+		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
+		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
+		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
+		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
+		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,
+	};
+	struct dp_catalog_audio audio = {
+		.init       = dp_catalog_audio_init,
+		.config_acr = dp_catalog_audio_config_acr,
+		.enable     = dp_catalog_audio_enable,
+		.config_sdp = dp_catalog_audio_config_sdp,
+		.set_header = dp_catalog_audio_set_header,
+		.get_header = dp_catalog_audio_get_header,
+		.safe_to_exit_level = dp_catalog_audio_safe_to_exit_level,
+	};
+	struct dp_catalog_panel panel = {
+		.timing_cfg = dp_catalog_panel_timing_cfg,
+		.tpg_config = dp_catalog_panel_tpg_cfg,
+	};
+
+	if (!io) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	catalog  = devm_kzalloc(dev, sizeof(*catalog), GFP_KERNEL);
+	if (!catalog) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	catalog->dev = dev;
+	catalog->io = io;
+
+	dp_catalog = &catalog->dp_catalog;
+
+	dp_catalog->aux   = aux;
+	dp_catalog->ctrl  = ctrl;
+	dp_catalog->audio = audio;
+	dp_catalog->panel = panel;
+
+	return dp_catalog;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_catalog_put(struct dp_catalog *dp_catalog)
+{
+	struct dp_catalog_private *catalog;
+
+	if (!dp_catalog)
+		return;
+
+	catalog = container_of(dp_catalog, struct dp_catalog_private,
+				dp_catalog);
+
+	devm_kfree(catalog->dev, catalog);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h b/drivers/gpu/drm/msm/dp/dp_catalog.h
new file mode 100644
index 0000000..58951df
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_CATALOG_H_
+#define _DP_CATALOG_H_
+
+#include "dp_parser.h"
+
+/* interrupts */
+#define DP_INTR_HPD		BIT(0)
+#define DP_INTR_AUX_I2C_DONE	BIT(3)
+#define DP_INTR_WRONG_ADDR	BIT(6)
+#define DP_INTR_TIMEOUT		BIT(9)
+#define DP_INTR_NACK_DEFER	BIT(12)
+#define DP_INTR_WRONG_DATA_CNT	BIT(15)
+#define DP_INTR_I2C_NACK	BIT(18)
+#define DP_INTR_I2C_DEFER	BIT(21)
+#define DP_INTR_PLL_UNLOCKED	BIT(24)
+#define DP_INTR_AUX_ERROR	BIT(27)
+
+#define DP_INTR_READY_FOR_VIDEO		BIT(0)
+#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
+#define DP_INTR_FRAME_END		BIT(6)
+#define DP_INTR_CRC_UPDATED		BIT(9)
+
+struct dp_catalog_aux {
+	u32 data;
+	u32 isr;
+
+	u32 (*read_data)(struct dp_catalog_aux *aux);
+	int (*write_data)(struct dp_catalog_aux *aux);
+	int (*write_trans)(struct dp_catalog_aux *aux);
+	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
+	void (*reset)(struct dp_catalog_aux *aux);
+	void (*enable)(struct dp_catalog_aux *aux, bool enable);
+	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
+		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
+	void (*setup)(struct dp_catalog_aux *aux,
+			struct dp_aux_cfg *aux_cfg);
+	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
+};
+
+struct dp_catalog_ctrl {
+	u32 dp_tu;
+	u32 valid_boundary;
+	u32 valid_boundary2;
+	u32 isr;
+
+	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
+	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
+	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
+	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
+	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
+	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
+				u32 stream_rate_khz, bool fixed_nvid);
+	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
+	void (*reset)(struct dp_catalog_ctrl *ctrl);
+	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
+	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
+	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
+	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
+	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
+	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
+				u8 lane_cnt);
+	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
+				u8 p_level);
+	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
+	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
+	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
+			u32 pattern);
+	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
+};
+
+enum dp_catalog_audio_sdp_type {
+	DP_AUDIO_SDP_STREAM,
+	DP_AUDIO_SDP_TIMESTAMP,
+	DP_AUDIO_SDP_INFOFRAME,
+	DP_AUDIO_SDP_COPYMANAGEMENT,
+	DP_AUDIO_SDP_ISRC,
+	DP_AUDIO_SDP_MAX,
+};
+
+enum dp_catalog_audio_header_type {
+	DP_AUDIO_SDP_HEADER_1,
+	DP_AUDIO_SDP_HEADER_2,
+	DP_AUDIO_SDP_HEADER_3,
+	DP_AUDIO_SDP_HEADER_MAX,
+};
+
+struct dp_catalog_audio {
+	enum dp_catalog_audio_sdp_type sdp_type;
+	enum dp_catalog_audio_header_type sdp_header;
+	u32 data;
+
+	void (*init)(struct dp_catalog_audio *audio);
+	void (*enable)(struct dp_catalog_audio *audio);
+	void (*config_acr)(struct dp_catalog_audio *audio);
+	void (*config_sdp)(struct dp_catalog_audio *audio);
+	void (*set_header)(struct dp_catalog_audio *audio);
+	void (*get_header)(struct dp_catalog_audio *audio);
+	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);
+};
+
+struct dp_catalog_panel {
+	u32 total;
+	u32 sync_start;
+	u32 width_blanking;
+	u32 dp_active;
+
+	/* TPG */
+	u32 hsync_period;
+	u32 vsync_period;
+	u32 display_v_start;
+	u32 display_v_end;
+	u32 v_sync_width;
+	u32 hsync_ctl;
+	u32 display_hctl;
+
+	int (*timing_cfg)(struct dp_catalog_panel *panel);
+	void (*tpg_config)(struct dp_catalog_panel *panel, bool enable);
+};
+
+struct dp_catalog {
+	struct dp_catalog_aux aux;
+	struct dp_catalog_ctrl ctrl;
+	struct dp_catalog_audio audio;
+	struct dp_catalog_panel panel;
+};
+
+struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io);
+void dp_catalog_put(struct dp_catalog *catalog);
+
+#endif /* _DP_CATALOG_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
new file mode 100644
index 0000000..08a52f5
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
@@ -0,0 +1,1475 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/types.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+
+#include "dp_ctrl.h"
+
+#define DP_KHZ_TO_HZ 1000
+
+#define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
+#define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
+
+/* dp state ctrl */
+#define ST_TRAIN_PATTERN_1		BIT(0)
+#define ST_TRAIN_PATTERN_2		BIT(1)
+#define ST_TRAIN_PATTERN_3		BIT(2)
+#define ST_TRAIN_PATTERN_4		BIT(3)
+#define ST_SYMBOL_ERR_RATE_MEASUREMENT	BIT(4)
+#define ST_PRBS7			BIT(5)
+#define ST_CUSTOM_80_BIT_PATTERN	BIT(6)
+#define ST_SEND_VIDEO			BIT(7)
+#define ST_PUSH_IDLE			BIT(8)
+
+#define MR_LINK_TRAINING1  0x8
+#define MR_LINK_SYMBOL_ERM 0x80
+#define MR_LINK_PRBS7 0x100
+#define MR_LINK_CUSTOM80 0x200
+
+struct dp_vc_tu_mapping_table {
+	u32 vic;
+	u8 lanes;
+	u8 lrate; /* DP_LINK_RATE -> 162(6), 270(10), 540(20), 810 (30) */
+	u8 bpp;
+	u8 valid_boundary_link;
+	u16 delay_start_link;
+	bool boundary_moderation_en;
+	u8 valid_lower_boundary_link;
+	u8 upper_boundary_count;
+	u8 lower_boundary_count;
+	u8 tu_size_minus1;
+};
+
+struct dp_ctrl_private {
+	struct dp_ctrl dp_ctrl;
+
+	struct device *dev;
+	struct dp_aux *aux;
+	struct dp_panel *panel;
+	struct dp_link *link;
+	struct dp_power *power;
+	struct dp_parser *parser;
+	struct dp_catalog_ctrl *catalog;
+
+	struct completion idle_comp;
+	struct completion video_comp;
+
+	bool orientation;
+	atomic_t aborted;
+
+	u32 pixel_rate;
+	u32 vic;
+};
+
+enum notification_status {
+	NOTIFY_UNKNOWN,
+	NOTIFY_CONNECT,
+	NOTIFY_DISCONNECT,
+	NOTIFY_CONNECT_IRQ_HPD,
+	NOTIFY_DISCONNECT_IRQ_HPD,
+};
+
+static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
+{
+	pr_debug("idle_patterns_sent\n");
+	complete(&ctrl->idle_comp);
+}
+
+static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
+{
+	pr_debug("dp_video_ready\n");
+	complete(&ctrl->video_comp);
+}
+
+static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl) {
+		pr_err("Invalid input data\n");
+		return;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	atomic_set(&ctrl->aborted, 1);
+}
+
+static void dp_ctrl_state_ctrl(struct dp_ctrl_private *ctrl, u32 state)
+{
+	ctrl->catalog->state_ctrl(ctrl->catalog, state);
+}
+
+static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
+{
+	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl) {
+		pr_err("Invalid input data\n");
+		return;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	reinit_completion(&ctrl->idle_comp);
+	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
+
+	if (!wait_for_completion_timeout(&ctrl->idle_comp,
+			idle_pattern_completion_timeout_ms))
+		pr_warn("PUSH_IDLE pattern timedout\n");
+
+	pr_debug("mainlink off done\n");
+}
+
+static void dp_ctrl_config_ctrl(struct dp_ctrl_private *ctrl)
+{
+	u32 config = 0, tbd;
+	u8 *dpcd = ctrl->panel->dpcd;
+
+	config |= (2 << 13); /* Default-> LSCLK DIV: 1/4 LCLK  */
+	config |= (0 << 11); /* RGB */
+
+	/* Scrambler reset enable */
+	if (dpcd[DP_EDP_CONFIGURATION_CAP] & DP_ALTERNATE_SCRAMBLER_RESET_CAP)
+		config |= (1 << 10);
+
+	tbd = ctrl->link->get_test_bits_depth(ctrl->link,
+			ctrl->panel->pinfo.bpp);
+
+	if (tbd == DP_TEST_BIT_DEPTH_UNKNOWN)
+		tbd = DP_TEST_BIT_DEPTH_8;
+
+	config |= tbd << 8;
+
+	/* Num of Lanes */
+	config |= ((ctrl->link->link_params.lane_count - 1) << 4);
+
+	if (drm_dp_enhanced_frame_cap(dpcd))
+		config |= 0x40;
+
+	config |= 0x04; /* progressive video */
+
+	config |= 0x03;	/* sycn clock & static Mvid */
+
+	ctrl->catalog->config_ctrl(ctrl->catalog, config);
+}
+
+/**
+ * dp_ctrl_configure_source_params() - configures DP transmitter source params
+ * @ctrl: Display Port Driver data
+ *
+ * Configures the DP transmitter source params including details such as lane
+ * configuration, output format and sink/panel timing information.
+ */
+static void dp_ctrl_configure_source_params(struct dp_ctrl_private *ctrl)
+{
+	u32 cc, tb;
+
+	ctrl->catalog->lane_mapping(ctrl->catalog);
+	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
+
+	dp_ctrl_config_ctrl(ctrl);
+
+	tb = ctrl->link->get_test_bits_depth(ctrl->link,
+		ctrl->panel->pinfo.bpp);
+	cc = ctrl->link->get_colorimetry_config(ctrl->link);
+	ctrl->catalog->config_misc(ctrl->catalog, cc, tb);
+	ctrl->panel->timing_cfg(ctrl->panel);
+}
+
+static void dp_ctrl_get_extra_req_bytes(u64 result_valid,
+					int valid_bdary_link,
+					u64 value1, u64 value2,
+					bool *negative, u64 *result,
+					u64 compare)
+{
+	*negative = false;
+	if (result_valid >= compare) {
+		if (valid_bdary_link
+				>= compare)
+			*result = value1 + value2;
+		else {
+			if (value1 < value2)
+				*negative = true;
+			*result = (value1 >= value2) ?
+				(value1 - value2) : (value2 - value1);
+		}
+	} else {
+		if (valid_bdary_link
+				>= compare) {
+			if (value1 >= value2)
+				*negative = true;
+			*result = (value1 >= value2) ?
+				(value1 - value2) : (value2 - value1);
+		} else {
+			*result = value1 + value2;
+			*negative = true;
+		}
+	}
+}
+
+static u64 roundup_u64(u64 x, u64 y)
+{
+	x += (y - 1);
+	return (div64_ul(x, y) * y);
+}
+
+static u64 rounddown_u64(u64 x, u64 y)
+{
+	u64 rem;
+
+	div64_u64_rem(x, y, &rem);
+	return (x - rem);
+}
+
+static void dp_ctrl_calc_tu_parameters(struct dp_ctrl_private *ctrl,
+				       struct dp_vc_tu_mapping_table *tu_table)
+{
+	u32 multiplier = 1000000;
+	u64 pclk, lclk;
+	u8 bpp, ln_cnt;
+	int run_idx = 0;
+	u32 lwidth, h_blank;
+	u32 fifo_empty = 0;
+	u32 ratio_scale = 1001;
+	u64 temp, ratio, original_ratio;
+	u64 temp2, reminder;
+	u64 temp3, temp4, result = 0;
+
+	u64 err = multiplier;
+	u64 n_err = 0, n_n_err = 0;
+	bool n_err_neg, nn_err_neg;
+	u8 hblank_margin = 16;
+
+	u8 tu_size, tu_size_desired = 0, tu_size_minus1;
+	int valid_boundary_link;
+	u64 resulting_valid;
+	u64 total_valid;
+	u64 effective_valid;
+	u64 effective_valid_recorded;
+	int n_tus;
+	int n_tus_per_lane;
+	int paired_tus;
+	int remainder_tus;
+	int remainder_tus_upper, remainder_tus_lower;
+	int extra_bytes;
+	int filler_size;
+	int delay_start_link;
+	int boundary_moderation_en = 0;
+	int upper_bdry_cnt = 0;
+	int lower_bdry_cnt = 0;
+	int i_upper_bdry_cnt = 0;
+	int i_lower_bdry_cnt = 0;
+	int valid_lower_boundary_link = 0;
+	int even_distribution_bf = 0;
+	int even_distribution_legacy = 0;
+	int even_distribution = 0;
+	int min_hblank = 0;
+	int extra_pclk_cycles;
+	u8 extra_pclk_cycle_delay = 4;
+	int extra_pclk_cycles_in_link_clk;
+	u64 ratio_by_tu;
+	u64 average_valid2;
+	u64 extra_buffer_margin;
+	int new_valid_boundary_link;
+
+	u64 resulting_valid_tmp;
+	u64 ratio_by_tu_tmp;
+	int n_tus_tmp;
+	int extra_pclk_cycles_tmp;
+	int extra_pclk_cycles_in_lclk_tmp;
+	int extra_req_bytes_new_tmp;
+	int filler_size_tmp;
+	int lower_filler_size_tmp;
+	int delay_start_link_tmp;
+	int min_hblank_tmp = 0;
+	bool extra_req_bytes_is_neg = false;
+	struct dp_panel_info *pinfo = &ctrl->panel->pinfo;
+
+	u8 dp_brute_force = 1;
+	u64 brute_force_threshold = 10;
+	u64 diff_abs;
+
+	ln_cnt =  ctrl->link->link_params.lane_count;
+
+	bpp = pinfo->bpp;
+	lwidth = pinfo->h_active;
+	h_blank = pinfo->h_back_porch + pinfo->h_front_porch +
+				pinfo->h_sync_width;
+	pclk = pinfo->pixel_clk_khz * 1000;
+
+	boundary_moderation_en = 0;
+	upper_bdry_cnt = 0;
+	lower_bdry_cnt = 0;
+	i_upper_bdry_cnt = 0;
+	i_lower_bdry_cnt = 0;
+	valid_lower_boundary_link = 0;
+	even_distribution_bf = 0;
+	even_distribution_legacy = 0;
+	even_distribution = 0;
+	min_hblank = 0;
+
+	lclk = drm_dp_bw_code_to_link_rate(
+		ctrl->link->link_params.bw_code) * DP_KHZ_TO_HZ;
+
+	pr_debug("pclk=%lld, active_width=%d, h_blank=%d\n",
+						pclk, lwidth, h_blank);
+	pr_debug("lclk = %lld, ln_cnt = %d\n", lclk, ln_cnt);
+	ratio = div64_u64_rem(pclk * bpp * multiplier,
+				8 * ln_cnt * lclk, &reminder);
+	ratio = div64_u64((pclk * bpp * multiplier), (8 * ln_cnt * lclk));
+	original_ratio = ratio;
+
+	extra_buffer_margin = roundup_u64(div64_u64(extra_pclk_cycle_delay
+				* lclk * multiplier, pclk), multiplier);
+	extra_buffer_margin = div64_u64(extra_buffer_margin, multiplier);
+
+	/* To deal with cases where lines are not distributable */
+	if (((lwidth % ln_cnt) != 0) && ratio < multiplier) {
+		ratio = ratio * ratio_scale;
+		ratio = ratio < (1000 * multiplier)
+				? ratio : (1000 * multiplier);
+	}
+	pr_debug("ratio = %lld\n", ratio);
+
+	for (tu_size = 32; tu_size <= 64; tu_size++) {
+		temp = ratio * tu_size;
+		temp2 = ((temp / multiplier) + 1) * multiplier;
+		n_err = roundup_u64(temp, multiplier) - temp;
+
+		if (n_err < err) {
+			err = n_err;
+			tu_size_desired = tu_size;
+		}
+	}
+	pr_debug("Info: tu_size_desired = %d\n", tu_size_desired);
+
+	tu_size_minus1 = tu_size_desired - 1;
+
+	valid_boundary_link = roundup_u64(ratio * tu_size_desired, multiplier);
+	valid_boundary_link /= multiplier;
+	n_tus = rounddown((lwidth * bpp * multiplier)
+			/ (8 * valid_boundary_link), multiplier) / multiplier;
+	even_distribution_legacy = n_tus % ln_cnt == 0 ? 1 : 0;
+	pr_debug("Info: n_symbol_per_tu=%d, number_of_tus=%d\n",
+					valid_boundary_link, n_tus);
+
+	extra_bytes = roundup_u64((n_tus + 1)
+			* ((valid_boundary_link * multiplier)
+			- (original_ratio * tu_size_desired)), multiplier);
+	extra_bytes /= multiplier;
+	extra_pclk_cycles = roundup(extra_bytes * 8 * multiplier / bpp,
+			multiplier);
+	extra_pclk_cycles /= multiplier;
+	extra_pclk_cycles_in_link_clk = roundup_u64(div64_u64(extra_pclk_cycles
+				* lclk * multiplier, pclk), multiplier);
+	extra_pclk_cycles_in_link_clk /= multiplier;
+	filler_size = roundup_u64((tu_size_desired - valid_boundary_link)
+						* multiplier, multiplier);
+	filler_size /= multiplier;
+	ratio_by_tu = div64_u64(ratio * tu_size_desired, multiplier);
+
+	pr_debug("extra_pclk_cycles_in_link_clk=%d, extra_bytes=%d\n",
+				extra_pclk_cycles_in_link_clk, extra_bytes);
+	pr_debug("extra_pclk_cycles_in_link_clk=%d\n",
+				extra_pclk_cycles_in_link_clk);
+	pr_debug("filler_size=%d, extra_buffer_margin=%lld\n",
+				filler_size, extra_buffer_margin);
+
+	delay_start_link = ((extra_bytes > extra_pclk_cycles_in_link_clk)
+			? extra_bytes
+			: extra_pclk_cycles_in_link_clk)
+				+ filler_size + extra_buffer_margin;
+	resulting_valid = valid_boundary_link;
+	pr_debug("Info: delay_start_link=%d, filler_size=%d\n",
+				delay_start_link, filler_size);
+	pr_debug("valid_boundary_link=%d ratio_by_tu=%lld\n",
+				valid_boundary_link, ratio_by_tu);
+
+	diff_abs = (resulting_valid >= ratio_by_tu)
+				? (resulting_valid - ratio_by_tu)
+				: (ratio_by_tu - resulting_valid);
+
+	if (err != 0 && ((diff_abs > brute_force_threshold)
+			|| (even_distribution_legacy == 0)
+			|| (dp_brute_force == 1))) {
+		err = multiplier;
+		for (tu_size = 32; tu_size <= 64; tu_size++) {
+			for (i_upper_bdry_cnt = 1; i_upper_bdry_cnt <= 15;
+						i_upper_bdry_cnt++) {
+				for (i_lower_bdry_cnt = 1;
+					i_lower_bdry_cnt <= 15;
+					i_lower_bdry_cnt++) {
+					new_valid_boundary_link =
+						roundup_u64(ratio
+						* tu_size, multiplier);
+					average_valid2 = (i_upper_bdry_cnt
+						* new_valid_boundary_link
+						+ i_lower_bdry_cnt
+						* (new_valid_boundary_link
+							- multiplier))
+						/ (i_upper_bdry_cnt
+							+ i_lower_bdry_cnt);
+					n_tus = rounddown_u64(div64_u64(lwidth
+						* multiplier * multiplier
+						* (bpp / 8), average_valid2),
+							multiplier);
+					n_tus /= multiplier;
+					n_tus_per_lane
+						= rounddown(n_tus
+							* multiplier
+							/ ln_cnt, multiplier);
+					n_tus_per_lane /= multiplier;
+					paired_tus =
+						rounddown((n_tus_per_lane)
+							* multiplier
+							/ (i_upper_bdry_cnt
+							+ i_lower_bdry_cnt),
+							multiplier);
+					paired_tus /= multiplier;
+					remainder_tus = n_tus_per_lane
+							- paired_tus
+						* (i_upper_bdry_cnt
+							+ i_lower_bdry_cnt);
+					if ((remainder_tus
+						- i_upper_bdry_cnt) > 0) {
+						remainder_tus_upper
+							= i_upper_bdry_cnt;
+						remainder_tus_lower =
+							remainder_tus
+							- i_upper_bdry_cnt;
+					} else {
+						remainder_tus_upper
+							= remainder_tus;
+						remainder_tus_lower = 0;
+					}
+					total_valid = paired_tus
+						* (i_upper_bdry_cnt
+						* new_valid_boundary_link
+							+ i_lower_bdry_cnt
+						* (new_valid_boundary_link
+							- multiplier))
+						+ (remainder_tus_upper
+						* new_valid_boundary_link)
+						+ (remainder_tus_lower
+						* (new_valid_boundary_link
+							- multiplier));
+					n_err_neg = nn_err_neg = false;
+					effective_valid
+						= div_u64(total_valid,
+							n_tus_per_lane);
+					n_n_err = (effective_valid
+							>= (ratio * tu_size))
+						? (effective_valid
+							- (ratio * tu_size))
+						: ((ratio * tu_size)
+							- effective_valid);
+					if (effective_valid < (ratio * tu_size))
+						nn_err_neg = true;
+					n_err = (average_valid2
+						>= (ratio * tu_size))
+						? (average_valid2
+							- (ratio * tu_size))
+						: ((ratio * tu_size)
+							- average_valid2);
+					if (average_valid2 < (ratio * tu_size))
+						n_err_neg = true;
+					even_distribution =
+						n_tus % ln_cnt == 0 ? 1 : 0;
+					diff_abs =
+						resulting_valid >= ratio_by_tu
+						? (resulting_valid
+							- ratio_by_tu)
+						: (ratio_by_tu
+							- resulting_valid);
+
+					resulting_valid_tmp = div64_u64(
+						(i_upper_bdry_cnt
+						* new_valid_boundary_link
+						+ i_lower_bdry_cnt
+						* (new_valid_boundary_link
+							- multiplier)),
+						(i_upper_bdry_cnt
+							+ i_lower_bdry_cnt));
+					ratio_by_tu_tmp =
+						original_ratio * tu_size;
+					ratio_by_tu_tmp /= multiplier;
+					n_tus_tmp = rounddown_u64(
+						div64_u64(lwidth
+						* multiplier * multiplier
+						* bpp / 8,
+						resulting_valid_tmp),
+						multiplier);
+					n_tus_tmp /= multiplier;
+
+					temp3 = (resulting_valid_tmp
+						>= (original_ratio * tu_size))
+						? (resulting_valid_tmp
+						- original_ratio * tu_size)
+						: (original_ratio * tu_size)
+						- resulting_valid_tmp;
+					temp3 = (n_tus_tmp + 1) * temp3;
+					temp4 = (new_valid_boundary_link
+						>= (original_ratio * tu_size))
+						? (new_valid_boundary_link
+							- original_ratio
+							* tu_size)
+						: (original_ratio * tu_size)
+						- new_valid_boundary_link;
+					temp4 = (i_upper_bdry_cnt
+							* ln_cnt * temp4);
+
+					temp3 = roundup_u64(temp3, multiplier);
+					temp4 = roundup_u64(temp4, multiplier);
+					dp_ctrl_get_extra_req_bytes
+						(resulting_valid_tmp,
+						new_valid_boundary_link,
+						temp3, temp4,
+						&extra_req_bytes_is_neg,
+						&result,
+						(original_ratio * tu_size));
+					extra_req_bytes_new_tmp
+						= div64_ul(result, multiplier);
+					if ((extra_req_bytes_is_neg)
+						&& (extra_req_bytes_new_tmp
+							> 1))
+						extra_req_bytes_new_tmp
+						= extra_req_bytes_new_tmp - 1;
+					if (extra_req_bytes_new_tmp == 0)
+						extra_req_bytes_new_tmp = 1;
+					extra_pclk_cycles_tmp =
+						(u64)(extra_req_bytes_new_tmp
+						      * 8 * multiplier) / bpp;
+					extra_pclk_cycles_tmp /= multiplier;
+
+					if (extra_pclk_cycles_tmp <= 0)
+						extra_pclk_cycles_tmp = 1;
+					extra_pclk_cycles_in_lclk_tmp =
+						roundup_u64(div64_u64(
+							extra_pclk_cycles_tmp
+							* lclk * multiplier,
+							pclk), multiplier);
+					extra_pclk_cycles_in_lclk_tmp
+						/= multiplier;
+					filler_size_tmp = roundup_u64(
+						(tu_size * multiplier *
+						new_valid_boundary_link),
+						multiplier);
+					filler_size_tmp /= multiplier;
+					lower_filler_size_tmp =
+						filler_size_tmp + 1;
+					if (extra_req_bytes_is_neg)
+						temp3 = (extra_req_bytes_new_tmp
+						> extra_pclk_cycles_in_lclk_tmp
+						? extra_pclk_cycles_in_lclk_tmp
+						: extra_req_bytes_new_tmp);
+					else
+						temp3 = (extra_req_bytes_new_tmp
+						> extra_pclk_cycles_in_lclk_tmp
+						? extra_req_bytes_new_tmp :
+						extra_pclk_cycles_in_lclk_tmp);
+
+					temp4 = lower_filler_size_tmp
+						+ extra_buffer_margin;
+					if (extra_req_bytes_is_neg)
+						delay_start_link_tmp
+							= (temp3 >= temp4)
+							? (temp3 - temp4)
+							: (temp4 - temp3);
+					else
+						delay_start_link_tmp
+							= temp3 + temp4;
+
+					min_hblank_tmp = (int)div64_u64(
+						roundup_u64(
+						div64_u64(delay_start_link_tmp
+						* pclk * multiplier, lclk),
+						multiplier), multiplier)
+						+ hblank_margin;
+
+					if (((even_distribution == 1)
+						|| ((even_distribution_bf == 0)
+						&& (even_distribution_legacy
+								== 0)))
+						&& !n_err_neg && !nn_err_neg
+						&& n_n_err < err
+						&& (n_n_err < diff_abs
+						|| (dp_brute_force == 1))
+						&& (new_valid_boundary_link
+									- 1) > 0
+						&& (h_blank >=
+							(u32)min_hblank_tmp)) {
+						upper_bdry_cnt =
+							i_upper_bdry_cnt;
+						lower_bdry_cnt =
+							i_lower_bdry_cnt;
+						err = n_n_err;
+						boundary_moderation_en = 1;
+						tu_size_desired = tu_size;
+						valid_boundary_link =
+							new_valid_boundary_link;
+						effective_valid_recorded
+							= effective_valid;
+						delay_start_link
+							= delay_start_link_tmp;
+						filler_size = filler_size_tmp;
+						min_hblank = min_hblank_tmp;
+						n_tus = n_tus_tmp;
+						even_distribution_bf = 1;
+
+						pr_debug("upper_bdry_cnt=%d, lower_boundary_cnt=%d, err=%lld, tu_size_desired=%d, valid_boundary_link=%d, effective_valid=%lld\n",
+							upper_bdry_cnt,
+							lower_bdry_cnt, err,
+							tu_size_desired,
+							valid_boundary_link,
+							effective_valid);
+					}
+				}
+			}
+		}
+
+		if (boundary_moderation_en == 1) {
+			resulting_valid = (u64)(upper_bdry_cnt
+					*valid_boundary_link + lower_bdry_cnt
+					* (valid_boundary_link - 1))
+					/ (upper_bdry_cnt + lower_bdry_cnt);
+			ratio_by_tu = original_ratio * tu_size_desired;
+			valid_lower_boundary_link =
+				(valid_boundary_link / multiplier) - 1;
+
+			tu_size_minus1 = tu_size_desired - 1;
+			even_distribution_bf = 1;
+			valid_boundary_link /= multiplier;
+			pr_debug("Info: Boundary_moderation enabled\n");
+		}
+	}
+
+	min_hblank = ((int) roundup_u64(div64_u64(delay_start_link * pclk
+			* multiplier, lclk), multiplier))
+			/ multiplier + hblank_margin;
+	if (h_blank < (u32)min_hblank) {
+		pr_debug(" WARNING: run_idx=%d Programmed h_blank %d is smaller than the min_hblank %d supported.\n",
+					run_idx, h_blank, min_hblank);
+	}
+
+	if (fifo_empty)	{
+		tu_size_minus1 = 31;
+		valid_boundary_link = 32;
+		delay_start_link = 0;
+		boundary_moderation_en = 0;
+	}
+
+	pr_debug("tu_size_minus1=%d valid_boundary_link=%d delay_start_link=%d boundary_moderation_en=%d\n upper_boundary_cnt=%d lower_boundary_cnt=%d valid_lower_boundary_link=%d min_hblank=%d\n",
+		tu_size_minus1, valid_boundary_link, delay_start_link,
+		boundary_moderation_en, upper_bdry_cnt, lower_bdry_cnt,
+		valid_lower_boundary_link, min_hblank);
+
+	tu_table->valid_boundary_link = valid_boundary_link;
+	tu_table->delay_start_link = delay_start_link;
+	tu_table->boundary_moderation_en = boundary_moderation_en;
+	tu_table->valid_lower_boundary_link = valid_lower_boundary_link;
+	tu_table->upper_boundary_count = upper_bdry_cnt;
+	tu_table->lower_boundary_count = lower_bdry_cnt;
+	tu_table->tu_size_minus1 = tu_size_minus1;
+}
+
+static void dp_ctrl_setup_tr_unit(struct dp_ctrl_private *ctrl)
+{
+	u32 dp_tu = 0x0;
+	u32 valid_boundary = 0x0;
+	u32 valid_boundary2 = 0x0;
+	struct dp_vc_tu_mapping_table tu_calc_table;
+
+	dp_ctrl_calc_tu_parameters(ctrl, &tu_calc_table);
+
+	dp_tu |= tu_calc_table.tu_size_minus1;
+	valid_boundary |= tu_calc_table.valid_boundary_link;
+	valid_boundary |= (tu_calc_table.delay_start_link << 16);
+
+	valid_boundary2 |= (tu_calc_table.valid_lower_boundary_link << 1);
+	valid_boundary2 |= (tu_calc_table.upper_boundary_count << 16);
+	valid_boundary2 |= (tu_calc_table.lower_boundary_count << 20);
+
+	if (tu_calc_table.boundary_moderation_en)
+		valid_boundary2 |= BIT(0);
+
+	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
+			dp_tu, valid_boundary, valid_boundary2);
+
+	ctrl->catalog->dp_tu = dp_tu;
+	ctrl->catalog->valid_boundary = valid_boundary;
+	ctrl->catalog->valid_boundary2 = valid_boundary2;
+
+	ctrl->catalog->update_transfer_unit(ctrl->catalog);
+}
+
+static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+
+	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);
+	if (ret <= 0) {
+		pr_err("Link Train timedout\n");
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl,
+				     u32 voltage_level, u32 pre_emphasis_level)
+{
+	int i;
+	u8 buf[4];
+	u32 max_level_reached = 0;
+
+	if (voltage_level == DP_LINK_VOLTAGE_MAX) {
+		pr_debug("max. voltage swing level reached %d\n",
+				voltage_level);
+		max_level_reached |= BIT(2);
+	}
+
+	if (pre_emphasis_level == DP_LINK_PRE_EMPHASIS_MAX) {
+		pr_debug("max. pre-emphasis level reached %d\n",
+				pre_emphasis_level);
+		max_level_reached  |= BIT(5);
+	}
+
+	pre_emphasis_level <<= 3;
+
+	for (i = 0; i < 4; i++)
+		buf[i] = voltage_level | pre_emphasis_level | max_level_reached;
+
+	pr_debug("sink: p|v=0x%x\n", voltage_level | pre_emphasis_level);
+	return drm_dp_dpcd_write(ctrl->aux->drm_aux, 0x103, buf, 4);
+}
+
+static void dp_ctrl_update_vx_px(struct dp_ctrl_private *ctrl)
+{
+	struct dp_link *link = ctrl->link;
+
+	ctrl->catalog->update_vx_px(ctrl->catalog,
+		link->phy_params.v_level, link->phy_params.p_level);
+
+	dp_ctrl_update_sink_vx_px(ctrl, link->phy_params.v_level,
+		link->phy_params.p_level);
+}
+
+static void dp_ctrl_train_pattern_set(struct dp_ctrl_private *ctrl,
+		u8 pattern)
+{
+	u8 buf[4];
+
+	pr_debug("sink: pattern=%x\n", pattern);
+
+	buf[0] = pattern;
+	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_TRAINING_PATTERN_SET, buf, 1);
+}
+
+static int dp_ctrl_read_link_status(struct dp_ctrl_private *ctrl,
+				    u8 *link_status)
+{
+	int ret = 0, len;
+	u32 const offset = DP_LANE_ALIGN_STATUS_UPDATED - DP_LANE0_1_STATUS;
+	u32 link_status_read_max_retries = 100;
+
+	while (--link_status_read_max_retries) {
+		len = drm_dp_dpcd_read_link_status(ctrl->aux->drm_aux,
+			link_status);
+		if (len != DP_LINK_STATUS_SIZE) {
+			pr_err("DP link status read failed, err: %d\n", len);
+			ret = len;
+			break;
+		}
+
+		if (!(link_status[offset] & DP_LINK_STATUS_UPDATED))
+			break;
+	}
+
+	return ret;
+}
+
+static int dp_ctrl_link_train_1(struct dp_ctrl_private *ctrl)
+{
+	int tries, old_v_level, ret = 0;
+	u8 link_status[DP_LINK_STATUS_SIZE];
+	int const maximum_retries = 5;
+
+	dp_ctrl_state_ctrl(ctrl, 0);
+	/* Make sure to clear the current pattern before starting a new one */
+	wmb();
+
+	ctrl->catalog->set_pattern(ctrl->catalog, 0x01);
+	dp_ctrl_train_pattern_set(ctrl, DP_TRAINING_PATTERN_1 |
+		DP_LINK_SCRAMBLING_DISABLE); /* train_1 */
+	dp_ctrl_update_vx_px(ctrl);
+
+	tries = 0;
+	old_v_level = ctrl->link->phy_params.v_level;
+	while (1) {
+		drm_dp_link_train_clock_recovery_delay(ctrl->panel->dpcd);
+
+		ret = dp_ctrl_read_link_status(ctrl, link_status);
+		if (ret)
+			break;
+
+		if (drm_dp_clock_recovery_ok(link_status,
+			ctrl->link->link_params.lane_count)) {
+			break;
+		}
+
+		if (ctrl->link->phy_params.v_level == DP_LINK_VOLTAGE_MAX) {
+			pr_err_ratelimited("max v_level reached\n");
+			ret = -EAGAIN;
+			break;
+		}
+
+		if (old_v_level == ctrl->link->phy_params.v_level) {
+			tries++;
+			if (tries >= maximum_retries) {
+				pr_err("max tries reached\n");
+				ret = -ETIMEDOUT;
+				break;
+			}
+		} else {
+			tries = 0;
+			old_v_level = ctrl->link->phy_params.v_level;
+		}
+
+		pr_debug("clock recovery not done, adjusting vx px\n");
+
+		ctrl->link->adjust_levels(ctrl->link, link_status);
+		dp_ctrl_update_vx_px(ctrl);
+	}
+
+	return ret;
+}
+
+static int dp_ctrl_link_rate_down_shift(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+
+	if (!ctrl)
+		return -EINVAL;
+
+	switch (ctrl->link->link_params.bw_code) {
+	case DP_LINK_BW_8_1:
+		ctrl->link->link_params.bw_code = DP_LINK_BW_5_4;
+		break;
+	case DP_LINK_BW_5_4:
+		ctrl->link->link_params.bw_code = DP_LINK_BW_2_7;
+		break;
+	case DP_LINK_BW_2_7:
+	case DP_LINK_BW_1_62:
+	default:
+		ctrl->link->link_params.bw_code = DP_LINK_BW_1_62;
+		break;
+	};
+
+	pr_debug("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
+
+	return ret;
+}
+
+static void dp_ctrl_clear_training_pattern(struct dp_ctrl_private *ctrl)
+{
+	dp_ctrl_train_pattern_set(ctrl, 0);
+	drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
+}
+
+static int dp_ctrl_link_training_2(struct dp_ctrl_private *ctrl)
+{
+	int tries = 0, ret = 0;
+	char pattern;
+	int const maximum_retries = 5;
+	u8 link_status[DP_LINK_STATUS_SIZE];
+
+	dp_ctrl_state_ctrl(ctrl, 0);
+	/* Make sure to clear the current pattern before starting a new one */
+	wmb();
+
+	if (drm_dp_tps3_supported(ctrl->panel->dpcd))
+		pattern = DP_TRAINING_PATTERN_3;
+	else
+		pattern = DP_TRAINING_PATTERN_2;
+
+	dp_ctrl_update_vx_px(ctrl);
+	ctrl->catalog->set_pattern(ctrl->catalog, pattern);
+	dp_ctrl_train_pattern_set(ctrl, pattern | DP_RECOVERED_CLOCK_OUT_EN);
+
+	do  {
+		drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
+
+		ret = dp_ctrl_read_link_status(ctrl, link_status);
+		if (ret)
+			break;
+
+		if (drm_dp_channel_eq_ok(link_status,
+			ctrl->link->link_params.lane_count))
+			break;
+
+		if (tries > maximum_retries) {
+			ret = -ETIMEDOUT;
+			break;
+		}
+		tries++;
+
+		ctrl->link->adjust_levels(ctrl->link, link_status);
+		dp_ctrl_update_vx_px(ctrl);
+	} while (1);
+
+	return ret;
+}
+
+static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+	u8 encoding = 0x1;
+	struct drm_dp_link link_info = {0};
+
+	ctrl->link->phy_params.p_level = 0;
+	ctrl->link->phy_params.v_level = 0;
+
+	dp_ctrl_config_ctrl(ctrl);
+
+	link_info.num_lanes = ctrl->link->link_params.lane_count;
+	link_info.rate = drm_dp_bw_code_to_link_rate(
+		ctrl->link->link_params.bw_code);
+	link_info.capabilities = ctrl->panel->link_info.capabilities;
+
+	drm_dp_link_configure(ctrl->aux->drm_aux, &link_info);
+	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
+				&encoding, 1);
+
+	ret = dp_ctrl_link_train_1(ctrl);
+	if (ret) {
+		pr_err("link training #1 failed\n");
+		goto end;
+	}
+
+	/* print success info as this is a result of user initiated action */
+	pr_info("link training #1 successful\n");
+
+	ret = dp_ctrl_link_training_2(ctrl);
+	if (ret) {
+		pr_err("link training #2 failed\n");
+		goto end;
+	}
+
+	/* print success info as this is a result of user initiated action */
+	pr_info("link training #2 successful\n");
+
+end:
+	dp_ctrl_state_ctrl(ctrl, 0);
+	/* Make sure to clear the current pattern before starting a new one */
+	wmb();
+
+	dp_ctrl_clear_training_pattern(ctrl);
+	return ret;
+}
+
+static int dp_ctrl_setup_main_link(struct dp_ctrl_private *ctrl, bool train)
+{
+	bool mainlink_ready = false;
+	int ret = 0;
+
+	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
+
+	ret = ctrl->link->psm_config(ctrl->link,
+		&ctrl->panel->link_info, false);
+	if (ret)
+		goto end;
+
+	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
+		goto end;
+
+	if (!train)
+		goto send_video;
+
+	/*
+	 * As part of previous calls, DP controller state might have
+	 * transitioned to PUSH_IDLE. In order to start transmitting a link
+	 * training pattern, we have to first to a DP software reset.
+	 */
+	ctrl->catalog->reset(ctrl->catalog);
+
+	ret = dp_ctrl_link_train(ctrl);
+	if (ret)
+		goto end;
+
+send_video:
+	/*
+	 * Set up transfer unit values and set controller state to send
+	 * video.
+	 */
+	dp_ctrl_setup_tr_unit(ctrl);
+	ctrl->catalog->state_ctrl(ctrl->catalog, ST_SEND_VIDEO);
+
+	dp_ctrl_wait4video_ready(ctrl);
+	mainlink_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
+	pr_debug("mainlink %s\n", mainlink_ready ? "READY" : "NOT READY");
+end:
+	return ret;
+}
+
+static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
+				   char *name, u32 rate)
+{
+	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
+	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
+
+	while (num && strcmp(cfg->clk_name, name)) {
+		num--;
+		cfg++;
+	}
+
+	pr_debug("setting rate=%d on clk=%s\n", rate, name);
+
+	if (num)
+		cfg->rate = rate;
+	else
+		pr_err("%s clock could not be set with rate %d\n", name, rate);
+}
+
+static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+
+	ctrl->power->set_pixel_clk_parent(ctrl->power);
+
+	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
+		drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code));
+
+	dp_ctrl_set_clock_rate(ctrl, "ctrl_pixel_clk", ctrl->pixel_rate);
+
+	ret = ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, true);
+	if (ret) {
+		pr_err("Unabled to start link clocks\n");
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+static int dp_ctrl_disable_mainlink_clocks(struct dp_ctrl_private *ctrl)
+{
+	return ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, false);
+}
+
+static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip)
+{
+	struct dp_ctrl_private *ctrl;
+	struct dp_catalog_ctrl *catalog;
+
+	if (!dp_ctrl) {
+		pr_err("Invalid input data\n");
+		return -EINVAL;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	ctrl->orientation = flip;
+	catalog = ctrl->catalog;
+
+	catalog->usb_reset(ctrl->catalog, flip);
+	catalog->phy_reset(ctrl->catalog);
+	catalog->enable_irq(ctrl->catalog, true);
+
+	return 0;
+}
+
+/**
+ * dp_ctrl_host_deinit() - Uninitialize DP controller
+ * @ctrl: Display Port Driver data
+ *
+ * Perform required steps to uninitialize DP controller
+ * and its resources.
+ */
+static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl) {
+		pr_err("Invalid input data\n");
+		return;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	ctrl->catalog->enable_irq(ctrl->catalog, false);
+
+	pr_debug("Host deinitialized successfully\n");
+}
+
+static bool dp_ctrl_use_fixed_nvid(struct dp_ctrl_private *ctrl)
+{
+	u8 *dpcd = ctrl->panel->dpcd;
+
+	/*
+	 * For better interop experience, used a fixed NVID=0x8000
+	 * whenever connected to a VGA dongle downstream.
+	 */
+	if (dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) {
+		u8 type = dpcd[DP_DOWNSTREAMPORT_PRESENT] &
+			DP_DWN_STRM_PORT_TYPE_MASK;
+		if (type == DP_DWN_STRM_PORT_TYPE_ANALOG)
+			return true;
+	}
+
+	return false;
+}
+
+static int dp_ctrl_link_maintenance(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+
+	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
+	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
+
+	ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
+
+	do {
+		if (ret == -EAGAIN) {
+			/* try with lower link rate */
+			dp_ctrl_link_rate_down_shift(ctrl);
+
+			ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
+		}
+
+		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
+			ctrl->orientation, ctrl->link->link_params.lane_count);
+
+		/*
+		 * Disable and re-enable the mainlink clock since the
+		 * link clock might have been adjusted as part of the
+		 * link maintenance.
+		 */
+		dp_ctrl_disable_mainlink_clocks(ctrl);
+
+		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
+		if (ret)
+			continue;
+
+		dp_ctrl_configure_source_params(ctrl);
+
+		ctrl->catalog->config_msa(ctrl->catalog,
+			drm_dp_bw_code_to_link_rate(
+			ctrl->link->link_params.bw_code),
+			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
+
+		reinit_completion(&ctrl->idle_comp);
+
+		ret = dp_ctrl_setup_main_link(ctrl, true);
+	} while (ret == -EAGAIN);
+
+	return ret;
+}
+
+static void dp_ctrl_process_phy_test_request(struct dp_ctrl_private *ctrl)
+{
+	int ret = 0;
+
+	if (!ctrl->link->phy_params.phy_test_pattern_sel) {
+		pr_debug("no test pattern selected by sink\n");
+		return;
+	}
+
+	pr_debug("start\n");
+
+	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
+	/*
+	 * The global reset will need DP link ralated clocks to be
+	 * running. Add the global reset just before disabling the
+	 * link clocks and core clocks.
+	 */
+	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
+	ctrl->dp_ctrl.off(&ctrl->dp_ctrl);
+
+	ret = ctrl->dp_ctrl.on(&ctrl->dp_ctrl);
+	if (ret)
+		pr_err("failed to enable DP controller\n");
+
+	pr_debug("end\n");
+}
+
+static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private *ctrl)
+{
+	bool success = false;
+	u32 pattern_sent = 0x0;
+	u32 pattern_requested = ctrl->link->phy_params.phy_test_pattern_sel;
+
+	pr_debug("request: %s\n",
+			dp_link_get_phy_test_pattern(pattern_requested));
+
+	ctrl->catalog->update_vx_px(ctrl->catalog,
+			ctrl->link->phy_params.v_level,
+			ctrl->link->phy_params.p_level);
+	ctrl->catalog->send_phy_pattern(ctrl->catalog, pattern_requested);
+	ctrl->link->send_test_response(ctrl->link);
+
+	pattern_sent = ctrl->catalog->read_phy_pattern(ctrl->catalog);
+
+	switch (pattern_sent) {
+	case MR_LINK_TRAINING1:
+		if (pattern_requested ==
+				DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING)
+			success = true;
+		break;
+	case MR_LINK_SYMBOL_ERM:
+		if ((pattern_requested ==
+				DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT)
+			|| (pattern_requested ==
+				DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN))
+			success = true;
+		break;
+	case MR_LINK_PRBS7:
+		if (pattern_requested == DP_TEST_PHY_PATTERN_PRBS7)
+			success = true;
+		break;
+	case MR_LINK_CUSTOM80:
+		if (pattern_requested ==
+				DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN)
+			success = true;
+		break;
+	default:
+		success = false;
+		return;
+	}
+
+	pr_debug("%s: %s\n", success ? "success" : "failed",
+			dp_link_get_phy_test_pattern(pattern_requested));
+}
+
+static void dp_ctrl_handle_sink_request(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+	u32 sink_request = 0x0;
+
+	if (!dp_ctrl) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+	sink_request = ctrl->link->sink_request;
+
+	if (sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
+		pr_info("PHY_TEST_PATTERN request\n");
+		dp_ctrl_process_phy_test_request(ctrl);
+	}
+
+	if (sink_request & DP_LINK_STATUS_UPDATED)
+		dp_ctrl_link_maintenance(ctrl);
+
+	if (sink_request & DP_TEST_LINK_TRAINING) {
+		ctrl->link->send_test_response(ctrl->link);
+		dp_ctrl_link_maintenance(ctrl);
+	}
+}
+
+static void dp_ctrl_reset(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl) {
+		pr_err("invalid params\n");
+		return;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+	ctrl->catalog->reset(ctrl->catalog);
+}
+
+static int dp_ctrl_on(struct dp_ctrl *dp_ctrl)
+{
+	int rc = 0;
+	struct dp_ctrl_private *ctrl;
+	u32 rate = 0;
+	u32 link_train_max_retries = 100;
+	u32 const phy_cts_pixel_clk_khz = 148500;
+
+	if (!dp_ctrl) {
+		rc = -EINVAL;
+		goto end;
+	}
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	atomic_set(&ctrl->aborted, 0);
+	rate = ctrl->panel->link_info.rate;
+
+	ctrl->power->clk_enable(ctrl->power, DP_CORE_PM, true);
+	ctrl->catalog->hpd_config(ctrl->catalog, true);
+
+	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
+		pr_debug("using phy test link parameters\n");
+		if (!ctrl->panel->pinfo.pixel_clk_khz)
+			ctrl->pixel_rate = phy_cts_pixel_clk_khz;
+	} else {
+		ctrl->link->link_params.bw_code =
+			drm_dp_link_rate_to_bw_code(rate);
+		ctrl->link->link_params.lane_count =
+			ctrl->panel->link_info.num_lanes;
+		ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
+	}
+
+	pr_debug("bw_code=%d, lane_count=%d, pixel_rate=%d\n",
+		ctrl->link->link_params.bw_code,
+		ctrl->link->link_params.lane_count, ctrl->pixel_rate);
+
+	ctrl->catalog->phy_lane_cfg(ctrl->catalog,
+			ctrl->orientation, ctrl->link->link_params.lane_count);
+
+	rc = dp_ctrl_enable_mainlink_clocks(ctrl);
+	if (rc)
+		goto end;
+
+	reinit_completion(&ctrl->idle_comp);
+
+	dp_ctrl_configure_source_params(ctrl);
+
+	while (--link_train_max_retries && !atomic_read(&ctrl->aborted)) {
+		ctrl->catalog->config_msa(ctrl->catalog,
+			drm_dp_bw_code_to_link_rate(
+			ctrl->link->link_params.bw_code),
+			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
+
+		rc = dp_ctrl_setup_main_link(ctrl, true);
+		if (!rc)
+			break;
+
+		/* try with lower link rate */
+		dp_ctrl_link_rate_down_shift(ctrl);
+
+		ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
+
+		dp_ctrl_disable_mainlink_clocks(ctrl);
+		/* hw recommended delay before re-enabling clocks */
+		msleep(20);
+
+		dp_ctrl_enable_mainlink_clocks(ctrl);
+	}
+
+	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
+		dp_ctrl_send_phy_test_pattern(ctrl);
+
+	pr_debug("End-\n");
+
+end:
+	return rc;
+}
+
+static void dp_ctrl_off(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl)
+		return;
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
+	ctrl->catalog->reset(ctrl->catalog);
+
+	/* Make sure DP is disabled before clk disable */
+	wmb();
+
+	dp_ctrl_disable_mainlink_clocks(ctrl);
+
+	pr_debug("DP off done\n");
+}
+
+static void dp_ctrl_isr(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl)
+		return;
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	ctrl->catalog->get_interrupt(ctrl->catalog);
+
+	if (ctrl->catalog->isr & DP_CTRL_INTR_READY_FOR_VIDEO)
+		dp_ctrl_video_ready(ctrl);
+
+	if (ctrl->catalog->isr & DP_CTRL_INTR_IDLE_PATTERN_SENT)
+		dp_ctrl_idle_patterns_sent(ctrl);
+}
+
+struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
+{
+	int rc = 0;
+	struct dp_ctrl_private *ctrl;
+	struct dp_ctrl *dp_ctrl;
+
+	if (!in->dev || !in->panel || !in->aux ||
+	    !in->link || !in->catalog) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	ctrl = devm_kzalloc(in->dev, sizeof(*ctrl), GFP_KERNEL);
+	if (!ctrl) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	init_completion(&ctrl->idle_comp);
+	init_completion(&ctrl->video_comp);
+
+	/* in parameters */
+	ctrl->parser   = in->parser;
+	ctrl->panel    = in->panel;
+	ctrl->power    = in->power;
+	ctrl->aux      = in->aux;
+	ctrl->link     = in->link;
+	ctrl->catalog  = in->catalog;
+	ctrl->dev      = in->dev;
+
+	dp_ctrl = &ctrl->dp_ctrl;
+
+	/* out parameters */
+	dp_ctrl->init      = dp_ctrl_host_init;
+	dp_ctrl->deinit    = dp_ctrl_host_deinit;
+	dp_ctrl->on        = dp_ctrl_on;
+	dp_ctrl->off       = dp_ctrl_off;
+	dp_ctrl->push_idle = dp_ctrl_push_idle;
+	dp_ctrl->abort     = dp_ctrl_abort;
+	dp_ctrl->isr       = dp_ctrl_isr;
+	dp_ctrl->reset	   = dp_ctrl_reset;
+	dp_ctrl->handle_sink_request = dp_ctrl_handle_sink_request;
+
+	return dp_ctrl;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_ctrl_put(struct dp_ctrl *dp_ctrl)
+{
+	struct dp_ctrl_private *ctrl;
+
+	if (!dp_ctrl)
+		return;
+
+	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
+
+	devm_kfree(ctrl->dev, ctrl);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.h b/drivers/gpu/drm/msm/dp/dp_ctrl.h
new file mode 100644
index 0000000..6ab221a
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_ctrl.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_CTRL_H_
+#define _DP_CTRL_H_
+
+#include "dp_aux.h"
+#include "dp_panel.h"
+#include "dp_link.h"
+#include "dp_parser.h"
+#include "dp_power.h"
+#include "dp_catalog.h"
+
+struct dp_ctrl {
+	int (*init)(struct dp_ctrl *dp_ctrl, bool flip);
+	void (*deinit)(struct dp_ctrl *dp_ctrl);
+	int (*on)(struct dp_ctrl *dp_ctrl);
+	void (*off)(struct dp_ctrl *dp_ctrl);
+	void (*reset)(struct dp_ctrl *dp_ctrl);
+	void (*push_idle)(struct dp_ctrl *dp_ctrl);
+	void (*abort)(struct dp_ctrl *dp_ctrl);
+	void (*isr)(struct dp_ctrl *dp_ctrl);
+	void (*handle_sink_request)(struct dp_ctrl *dp_ctrl);
+};
+
+struct dp_ctrl_in {
+	struct device *dev;
+	struct dp_panel *panel;
+	struct dp_aux *aux;
+	struct dp_link *link;
+	struct dp_parser *parser;
+	struct dp_power *power;
+	struct dp_catalog_ctrl *catalog;
+};
+
+struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in);
+void dp_ctrl_put(struct dp_ctrl *dp_ctrl);
+
+#endif /* _DP_CTRL_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_debug.c b/drivers/gpu/drm/msm/dp/dp_debug.c
new file mode 100644
index 0000000..5c0a8ce
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_debug.c
@@ -0,0 +1,507 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/debugfs.h>
+#include <drm/drm_connector.h>
+
+#include "dp_parser.h"
+#include "dp_power.h"
+#include "dp_catalog.h"
+#include "dp_aux.h"
+#include "dp_ctrl.h"
+#include "dp_debug.h"
+#include "dp_display.h"
+
+#define DEBUG_NAME "drm_dp"
+
+struct dp_debug_private {
+	struct dentry *root;
+
+	struct dp_usbpd *usbpd;
+	struct dp_link *link;
+	struct dp_panel *panel;
+	struct drm_connector **connector;
+	struct device *dev;
+
+	struct dp_debug dp_debug;
+};
+
+static ssize_t dp_debug_write_hpd(struct file *file,
+		const char __user *user_buff, size_t count, loff_t *ppos)
+{
+	struct dp_debug_private *debug = file->private_data;
+	char buf[SZ_8];
+	size_t len = 0;
+	int hpd;
+
+	if (!debug)
+		return -ENODEV;
+
+	if (*ppos)
+		return 0;
+
+	/* Leave room for termination char */
+	len = min_t(size_t, count, SZ_8 - 1);
+	if (copy_from_user(buf, user_buff, len))
+		goto end;
+
+	buf[len] = '\0';
+
+	if (kstrtoint(buf, 10, &hpd) != 0)
+		goto end;
+
+	if (debug->usbpd && debug->usbpd->connect)
+		debug->usbpd->connect(debug->usbpd, hpd);
+
+end:
+	return -len;
+}
+
+static ssize_t dp_debug_write_edid_modes(struct file *file,
+		const char __user *user_buff, size_t count, loff_t *ppos)
+{
+	struct dp_debug_private *debug = file->private_data;
+	char buf[SZ_32];
+	size_t len = 0;
+	int hdisplay = 0, vdisplay = 0, vrefresh = 0;
+
+	if (!debug)
+		return -ENODEV;
+
+	if (*ppos)
+		goto end;
+
+	/* Leave room for termination char */
+	len = min_t(size_t, count, SZ_32 - 1);
+	if (copy_from_user(buf, user_buff, len))
+		goto clear;
+
+	buf[len] = '\0';
+
+	if (sscanf(buf, "%d %d %d", &hdisplay, &vdisplay, &vrefresh) != 3)
+		goto clear;
+
+	if (!hdisplay || !vdisplay || !vrefresh)
+		goto clear;
+
+	debug->dp_debug.debug_en = true;
+	debug->dp_debug.hdisplay = hdisplay;
+	debug->dp_debug.vdisplay = vdisplay;
+	debug->dp_debug.vrefresh = vrefresh;
+	goto end;
+clear:
+	pr_debug("clearing debug modes\n");
+	debug->dp_debug.debug_en = false;
+end:
+	return len;
+}
+
+static ssize_t dp_debug_read_connected(struct file *file,
+		char __user *user_buff, size_t count, loff_t *ppos)
+{
+	struct dp_debug_private *debug = file->private_data;
+	char buf[SZ_8];
+	u32 len = 0;
+
+	if (!debug)
+		return -ENODEV;
+
+	if (*ppos)
+		return 0;
+
+	if (!debug->usbpd)
+		return -ENODEV;
+
+	len += snprintf(buf, SZ_8, "%d\n", debug->usbpd->hpd_high);
+
+	if (copy_to_user(user_buff, buf, len))
+		return -EFAULT;
+
+	*ppos += len;
+	return len;
+}
+
+static ssize_t dp_debug_read_edid_modes(struct file *file,
+		char __user *user_buff, size_t count, loff_t *ppos)
+{
+	struct dp_debug_private *debug = file->private_data;
+	char *buf;
+	u32 len = 0;
+	int rc = 0;
+	struct drm_connector *connector;
+	struct drm_display_mode *mode;
+
+	if (!debug) {
+		pr_err("invalid data\n");
+		rc = -ENODEV;
+		goto error;
+	}
+
+	connector = *debug->connector;
+
+	if (!connector) {
+		pr_err("connector is NULL\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	if (*ppos)
+		goto error;
+
+	buf = kzalloc(SZ_4K, GFP_KERNEL);
+	if (!buf) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	list_for_each_entry(mode, &connector->modes, head) {
+		len += snprintf(buf + len, SZ_4K - len,
+		"%s %d %d %d %d %d %d %d %d %d 0x%x\n",
+		mode->name, mode->vrefresh, mode->hdisplay,
+		mode->hsync_start, mode->hsync_end, mode->htotal,
+		mode->vdisplay, mode->vsync_start, mode->vsync_end,
+		mode->vtotal, mode->flags);
+	}
+
+	if (copy_to_user(user_buff, buf, len)) {
+		kfree(buf);
+		rc = -EFAULT;
+		goto error;
+	}
+
+	*ppos += len;
+	kfree(buf);
+
+	return len;
+error:
+	return rc;
+}
+
+static int dp_debug_check_buffer_overflow(int rc, int *max_size, int *len)
+{
+	if (rc >= *max_size) {
+		pr_err("buffer overflow\n");
+		return -EINVAL;
+	}
+	*len += rc;
+	*max_size = SZ_4K - *len;
+
+	return 0;
+}
+
+static ssize_t dp_debug_read_info(struct file *file, char __user *user_buff,
+		size_t count, loff_t *ppos)
+{
+	struct dp_debug_private *debug = file->private_data;
+	char *buf;
+	u32 len = 0, rc = 0;
+	u64 lclk = 0;
+	u32 max_size = SZ_4K;
+
+	if (!debug)
+		return -ENODEV;
+
+	if (*ppos)
+		return 0;
+
+	buf = kzalloc(SZ_4K, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	rc = snprintf(buf + len, max_size, "\tname = %s\n", DEBUG_NAME);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\tdp_panel\n\t\tmax_pclk_khz = %d\n",
+		debug->panel->max_pclk_khz);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\tdrm_dp_link\n\t\trate = %u\n",
+		debug->panel->link_info.rate);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tnum_lanes = %u\n",
+		debug->panel->link_info.num_lanes);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tcapabilities = %lu\n",
+		debug->panel->link_info.capabilities);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\tdp_panel_info:\n\t\tactive = %dx%d\n",
+		debug->panel->pinfo.h_active,
+		debug->panel->pinfo.v_active);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tback_porch = %dx%d\n",
+		debug->panel->pinfo.h_back_porch,
+		debug->panel->pinfo.v_back_porch);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tfront_porch = %dx%d\n",
+		debug->panel->pinfo.h_front_porch,
+		debug->panel->pinfo.v_front_porch);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tsync_width = %dx%d\n",
+		debug->panel->pinfo.h_sync_width,
+		debug->panel->pinfo.v_sync_width);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tactive_low = %dx%d\n",
+		debug->panel->pinfo.h_active_low,
+		debug->panel->pinfo.v_active_low);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\th_skew = %d\n",
+		debug->panel->pinfo.h_skew);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\trefresh rate = %d\n",
+		debug->panel->pinfo.refresh_rate);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tpixel clock khz = %d\n",
+		debug->panel->pinfo.pixel_clk_khz);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tbpp = %d\n",
+		debug->panel->pinfo.bpp);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	/* Link Information */
+	rc = snprintf(buf + len, max_size,
+		"\tdp_link:\n\t\ttest_requested = %d\n",
+		debug->link->sink_request);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tlane_count = %d\n", debug->link->link_params.lane_count);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tbw_code = %d\n", debug->link->link_params.bw_code);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	lclk = drm_dp_bw_code_to_link_rate(
+			debug->link->link_params.bw_code) * 1000;
+	rc = snprintf(buf + len, max_size,
+		"\t\tlclk = %lld\n", lclk);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tv_level = %d\n", debug->link->phy_params.v_level);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	rc = snprintf(buf + len, max_size,
+		"\t\tp_level = %d\n", debug->link->phy_params.p_level);
+	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
+		goto error;
+
+	if (copy_to_user(user_buff, buf, len))
+		goto error;
+
+	*ppos += len;
+
+	kfree(buf);
+	return len;
+error:
+	kfree(buf);
+	return -EINVAL;
+}
+
+static const struct file_operations dp_debug_fops = {
+	.open = simple_open,
+	.read = dp_debug_read_info,
+};
+
+static const struct file_operations edid_modes_fops = {
+	.open = simple_open,
+	.read = dp_debug_read_edid_modes,
+	.write = dp_debug_write_edid_modes,
+};
+
+static const struct file_operations hpd_fops = {
+	.open = simple_open,
+	.write = dp_debug_write_hpd,
+};
+
+static const struct file_operations connected_fops = {
+	.open = simple_open,
+	.read = dp_debug_read_connected,
+};
+
+static int dp_debug_init(struct dp_debug *dp_debug)
+{
+	int rc = 0;
+	struct dp_debug_private *debug = container_of(dp_debug,
+		struct dp_debug_private, dp_debug);
+	struct dentry *dir, *file, *edid_modes;
+	struct dentry *hpd, *connected;
+
+	dir = debugfs_create_dir(DEBUG_NAME, NULL);
+	if (IS_ERR_OR_NULL(dir)) {
+		rc = PTR_ERR(dir);
+		pr_err("[%s] debugfs create dir failed, rc = %d\n",
+		       DEBUG_NAME, rc);
+		goto error;
+	}
+
+	file = debugfs_create_file("dp_debug", 0444, dir,
+				debug, &dp_debug_fops);
+	if (IS_ERR_OR_NULL(file)) {
+		rc = PTR_ERR(file);
+		pr_err("[%s] debugfs create file failed, rc=%d\n",
+		       DEBUG_NAME, rc);
+		goto error_remove_dir;
+	}
+
+	edid_modes = debugfs_create_file("edid_modes", 0644, dir,
+					debug, &edid_modes_fops);
+	if (IS_ERR_OR_NULL(edid_modes)) {
+		rc = PTR_ERR(edid_modes);
+		pr_err("[%s] debugfs create edid_modes failed, rc=%d\n",
+		       DEBUG_NAME, rc);
+		goto error_remove_dir;
+	}
+
+	hpd = debugfs_create_file("hpd", 0644, dir,
+					debug, &hpd_fops);
+	if (IS_ERR_OR_NULL(hpd)) {
+		rc = PTR_ERR(hpd);
+		pr_err("[%s] debugfs hpd failed, rc=%d\n",
+			DEBUG_NAME, rc);
+		goto error_remove_dir;
+	}
+
+	connected = debugfs_create_file("connected", 0444, dir,
+					debug, &connected_fops);
+	if (IS_ERR_OR_NULL(connected)) {
+		rc = PTR_ERR(connected);
+		pr_err("[%s] debugfs connected failed, rc=%d\n",
+			DEBUG_NAME, rc);
+		goto error_remove_dir;
+	}
+
+	debug->root = dir;
+	return rc;
+error_remove_dir:
+	debugfs_remove(dir);
+error:
+	return rc;
+}
+
+struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
+			struct dp_usbpd *usbpd, struct dp_link *link,
+			struct drm_connector **connector)
+{
+	int rc = 0;
+	struct dp_debug_private *debug;
+	struct dp_debug *dp_debug;
+
+	if (!dev || !panel || !usbpd || !link) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
+	if (!debug) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	debug->dp_debug.debug_en = false;
+	debug->usbpd = usbpd;
+	debug->link = link;
+	debug->panel = panel;
+	debug->dev = dev;
+	debug->connector = connector;
+
+	dp_debug = &debug->dp_debug;
+	dp_debug->vdisplay = 0;
+	dp_debug->hdisplay = 0;
+	dp_debug->vrefresh = 0;
+
+	rc = dp_debug_init(dp_debug);
+	if (rc) {
+		devm_kfree(dev, debug);
+		goto error;
+	}
+
+	return dp_debug;
+error:
+	return ERR_PTR(rc);
+}
+
+static int dp_debug_deinit(struct dp_debug *dp_debug)
+{
+	struct dp_debug_private *debug;
+
+	if (!dp_debug)
+		return -EINVAL;
+
+	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
+
+	debugfs_remove_recursive(debug->root);
+
+	return 0;
+}
+
+void dp_debug_put(struct dp_debug *dp_debug)
+{
+	struct dp_debug_private *debug;
+
+	if (!dp_debug)
+		return;
+
+	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
+
+	dp_debug_deinit(dp_debug);
+
+	devm_kfree(debug->dev, debug);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_debug.h b/drivers/gpu/drm/msm/dp/dp_debug.h
new file mode 100644
index 0000000..a6480e1
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_debug.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_DEBUG_H_
+#define _DP_DEBUG_H_
+
+#include "dp_panel.h"
+#include "dp_link.h"
+#include "dp_extcon.h"
+
+/**
+ * struct dp_debug
+ * @debug_en: specifies whether debug mode enabled
+ * @vdisplay: used to filter out vdisplay value
+ * @hdisplay: used to filter out hdisplay value
+ * @vrefresh: used to filter out vrefresh value
+ * @tpg_state: specifies whether tpg feature is enabled
+ */
+struct dp_debug {
+	bool debug_en;
+	int aspect_ratio;
+	int vdisplay;
+	int hdisplay;
+	int vrefresh;
+};
+
+#if defined(CONFIG_DEBUG_FS)
+
+/**
+ * dp_debug_get() - configure and get the DisplayPlot debug module data
+ *
+ * @dev: device instance of the caller
+ * @panel: instance of panel module
+ * @usbpd: instance of usbpd module
+ * @link: instance of link module
+ * @connector: double pointer to display connector
+ * return: pointer to allocated debug module data
+ *
+ * This function sets up the debug module and provides a way
+ * for debugfs input to be communicated with existing modules
+ */
+struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
+			struct dp_usbpd *usbpd, struct dp_link *link,
+			struct drm_connector **connector);
+/**
+ * dp_debug_put()
+ *
+ * Cleans up dp_debug instance
+ *
+ * @dp_debug: instance of dp_debug
+ */
+void dp_debug_put(struct dp_debug *dp_debug);
+
+#else
+
+static inline
+struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
+			struct dp_usbpd *usbpd, struct dp_link *link,
+			struct drm_connector **connector)
+{
+	return ERR_PTR(-EINVAL);
+}
+
+static inline void dp_debug_put(struct dp_debug *dp_debug)
+{
+}
+
+#endif /* defined(CONFIG_DEBUG_FS) */
+
+#endif /* _DP_DEBUG_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
new file mode 100644
index 0000000..8c98399
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_display.c
@@ -0,0 +1,977 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <linux/component.h>
+#include <linux/of_irq.h>
+
+#include "msm_drv.h"
+#include "dp_extcon.h"
+#include "dp_parser.h"
+#include "dp_power.h"
+#include "dp_catalog.h"
+#include "dp_aux.h"
+#include "dp_link.h"
+#include "dp_panel.h"
+#include "dp_ctrl.h"
+#include "dp_display.h"
+#include "dp_drm.h"
+#include "dp_debug.h"
+
+static struct msm_dp *g_dp_display;
+#define HPD_STRING_SIZE 30
+
+struct dp_display_private {
+	char *name;
+	int irq;
+
+	/* state variables */
+	bool core_initialized;
+	bool power_on;
+	bool hpd_irq_on;
+	bool audio_supported;
+
+	struct platform_device *pdev;
+	struct dentry *root;
+	struct completion notification_comp;
+
+	struct dp_usbpd   *usbpd;
+	struct dp_parser  *parser;
+	struct dp_power   *power;
+	struct dp_catalog *catalog;
+	struct dp_aux     *aux;
+	struct dp_link    *link;
+	struct dp_panel   *panel;
+	struct dp_ctrl    *ctrl;
+	struct dp_debug   *debug;
+
+	struct dp_usbpd_cb usbpd_cb;
+	struct dp_display_mode mode;
+	struct msm_dp dp_display;
+
+};
+
+static const struct of_device_id dp_dt_match[] = {
+	{.compatible = "qcom,dp-display"},
+	{}
+};
+
+static irqreturn_t dp_display_irq(int irq, void *dev_id)
+{
+	struct dp_display_private *dp = dev_id;
+
+	if (!dp) {
+		pr_err("invalid data\n");
+		return IRQ_NONE;
+	}
+
+	/* DP controller isr */
+	dp->ctrl->isr(dp->ctrl);
+
+	/* DP aux isr */
+	dp->aux->isr(dp->aux);
+
+	return IRQ_HANDLED;
+}
+
+static int dp_display_bind(struct device *dev, struct device *master,
+			   void *data)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+	struct drm_device *drm;
+	struct msm_drm_private *priv;
+	struct platform_device *pdev = to_platform_device(dev);
+
+	if (!dev || !pdev || !master) {
+		pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
+				dev, pdev, master);
+		rc = -EINVAL;
+		goto end;
+	}
+
+	drm = dev_get_drvdata(master);
+	dp = platform_get_drvdata(pdev);
+	if (!drm || !dp) {
+		pr_err("invalid param(s), drm %pK, dp %pK\n",
+				drm, dp);
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp->dp_display.drm_dev = drm;
+	priv = drm->dev_private;
+	priv->dp = &(dp->dp_display);
+
+	rc = dp->parser->parse(dp->parser);
+	if (rc) {
+		pr_err("device tree parsing failed\n");
+		goto end;
+	}
+
+	rc = dp->aux->drm_aux_register(dp->aux);
+	if (rc) {
+		pr_err("DRM DP AUX register failed\n");
+		goto end;
+	}
+
+	rc = dp->power->power_client_init(dp->power);
+	if (rc) {
+		pr_err("Power client create failed\n");
+		goto end;
+	}
+
+end:
+	return rc;
+}
+
+static void dp_display_unbind(struct device *dev, struct device *master,
+			      void *data)
+{
+	struct dp_display_private *dp;
+	struct platform_device *pdev = to_platform_device(dev);
+	struct drm_device *drm = dev_get_drvdata(master);
+	struct msm_drm_private *priv = drm->dev_private;
+
+	if (!dev || !pdev) {
+		pr_err("invalid param(s)\n");
+		return;
+	}
+
+	dp = platform_get_drvdata(pdev);
+	if (!dp) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	(void)dp->power->power_client_deinit(dp->power);
+	(void)dp->aux->drm_aux_deregister(dp->aux);
+	priv->dp = NULL;
+}
+
+static const struct component_ops dp_display_comp_ops = {
+	.bind = dp_display_bind,
+	.unbind = dp_display_unbind,
+};
+
+static bool dp_display_is_ds_bridge(struct dp_panel *panel)
+{
+	return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
+		DP_DWN_STRM_PORT_PRESENT);
+}
+
+static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
+{
+	return dp_display_is_ds_bridge(dp->panel) &&
+		(dp->link->sink_count.count == 0);
+}
+
+static void dp_display_send_hpd_event(struct msm_dp *dp_display)
+{
+	struct dp_display_private *dp;
+	struct drm_connector *connector;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+	if (!dp) {
+		pr_err("invalid params\n");
+		return;
+	}
+
+	connector = dp->dp_display.connector;
+	drm_helper_hpd_irq_event(connector->dev);
+}
+
+static int dp_display_send_hpd_notification(struct dp_display_private *dp,
+					    bool hpd)
+{
+	if ((hpd && dp->dp_display.is_connected) ||
+			(!hpd && !dp->dp_display.is_connected)) {
+		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
+		return 0;
+	}
+
+	/* reset video pattern flag on disconnect */
+	if (!hpd)
+		dp->panel->video_test = false;
+
+	dp->dp_display.is_connected = hpd;
+	reinit_completion(&dp->notification_comp);
+	dp_display_send_hpd_event(&dp->dp_display);
+
+	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
+		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int dp_display_process_hpd_high(struct dp_display_private *dp)
+{
+	int rc = 0;
+	struct edid *edid;
+
+	dp->aux->init(dp->aux, dp->parser->aux_cfg);
+
+	if (dp->link->psm_enabled)
+		goto notify;
+
+	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);
+	if (rc)
+		goto notify;
+
+	dp->link->process_request(dp->link);
+
+	if (dp_display_is_sink_count_zero(dp)) {
+		pr_debug("no downstream devices connected\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	edid = dp->panel->edid;
+
+	dp->audio_supported = drm_detect_monitor_audio(edid);
+
+	dp->panel->handle_sink_request(dp->panel);
+
+	dp->dp_display.max_pclk_khz = dp->parser->max_pclk_khz;
+notify:
+	dp_display_send_hpd_notification(dp, true);
+
+end:
+	return rc;
+}
+
+static void dp_display_host_init(struct dp_display_private *dp)
+{
+	bool flip = false;
+
+	if (dp->core_initialized) {
+		pr_debug("DP core already initialized\n");
+		return;
+	}
+
+	if (dp->usbpd->orientation == ORIENTATION_CC2)
+		flip = true;
+
+	dp->power->init(dp->power, flip);
+	dp->ctrl->init(dp->ctrl, flip);
+	enable_irq(dp->irq);
+	dp->core_initialized = true;
+}
+
+static void dp_display_host_deinit(struct dp_display_private *dp)
+{
+	if (!dp->core_initialized) {
+		pr_debug("DP core already off\n");
+		return;
+	}
+
+	dp->ctrl->deinit(dp->ctrl);
+	dp->power->deinit(dp->power);
+	disable_irq(dp->irq);
+	dp->core_initialized = false;
+}
+
+static void dp_display_process_hpd_low(struct dp_display_private *dp)
+{
+	/* cancel any pending request */
+	dp->ctrl->abort(dp->ctrl);
+
+	dp_display_send_hpd_notification(dp, false);
+
+	dp->aux->deinit(dp->aux);
+}
+
+static int dp_display_usbpd_configure_cb(struct device *dev)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dev) {
+		pr_err("invalid dev\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp = dev_get_drvdata(dev);
+	if (!dp) {
+		pr_err("no driver data found\n");
+		rc = -ENODEV;
+		goto end;
+	}
+
+	dp_display_host_init(dp);
+
+	if (dp->usbpd->hpd_high)
+		dp_display_process_hpd_high(dp);
+end:
+	return rc;
+}
+
+static void dp_display_clean(struct dp_display_private *dp)
+{
+	dp->ctrl->push_idle(dp->ctrl);
+	dp->ctrl->off(dp->ctrl);
+}
+
+static int dp_display_usbpd_disconnect_cb(struct device *dev)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dev) {
+		pr_err("invalid dev\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp = dev_get_drvdata(dev);
+	if (!dp) {
+		pr_err("no driver data found\n");
+		rc = -ENODEV;
+		goto end;
+	}
+
+	/* cancel any pending request */
+	dp->ctrl->abort(dp->ctrl);
+
+	rc = dp_display_send_hpd_notification(dp, false);
+
+	/* if cable is disconnected, reset psm_enabled flag */
+	if (!dp->usbpd->alt_mode_cfg_done)
+		dp->link->psm_enabled = false;
+
+	if ((rc < 0) && dp->power_on)
+		dp_display_clean(dp);
+
+	dp_display_host_deinit(dp);
+end:
+	return rc;
+}
+
+static void dp_display_handle_video_request(struct dp_display_private *dp)
+{
+	if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
+		/* force disconnect followed by connect */
+		dp->usbpd->connect(dp->usbpd, false);
+		dp->panel->video_test = true;
+		dp->usbpd->connect(dp->usbpd, true);
+		dp->link->send_test_response(dp->link);
+	}
+}
+
+static int dp_display_handle_hpd_irq(struct dp_display_private *dp)
+{
+	if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) {
+		dp_display_send_hpd_notification(dp, false);
+
+		if (dp_display_is_sink_count_zero(dp)) {
+			pr_debug("sink count is zero, nothing to do\n");
+			return 0;
+		}
+
+		return dp_display_process_hpd_high(dp);
+	}
+
+	dp->ctrl->handle_sink_request(dp->ctrl);
+
+	dp_display_handle_video_request(dp);
+
+	return 0;
+}
+
+static int dp_display_usbpd_attention_cb(struct device *dev)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dev) {
+		pr_err("invalid dev\n");
+		return -EINVAL;
+	}
+
+	dp = dev_get_drvdata(dev);
+	if (!dp) {
+		pr_err("no driver data found\n");
+		return -ENODEV;
+	}
+
+	if (dp->usbpd->hpd_irq) {
+		dp->hpd_irq_on = true;
+
+		rc = dp->link->process_request(dp->link);
+		/* check for any test request issued by sink */
+		if (!rc)
+			dp_display_handle_hpd_irq(dp);
+
+		dp->hpd_irq_on = false;
+		goto end;
+	}
+
+	if (!dp->usbpd->hpd_high) {
+		dp_display_process_hpd_low(dp);
+		goto end;
+	}
+
+	if (dp->usbpd->alt_mode_cfg_done)
+		dp_display_process_hpd_high(dp);
+end:
+	return rc;
+}
+
+static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
+{
+	dp_ctrl_put(dp->ctrl);
+	dp_link_put(dp->link);
+	dp_panel_put(dp->panel);
+	dp_aux_put(dp->aux);
+	dp_power_put(dp->power);
+	dp_catalog_put(dp->catalog);
+	dp_parser_put(dp->parser);
+	dp_debug_put(dp->debug);
+}
+
+static int dp_init_sub_modules(struct dp_display_private *dp)
+{
+	int rc = 0;
+	struct device *dev = &dp->pdev->dev;
+	struct dp_usbpd_cb *cb = &dp->usbpd_cb;
+	struct dp_ctrl_in ctrl_in = {
+		.dev = dev,
+	};
+	struct dp_panel_in panel_in = {
+		.dev = dev,
+	};
+
+	/* Callback APIs used for cable status change event */
+	cb->configure  = dp_display_usbpd_configure_cb;
+	cb->disconnect = dp_display_usbpd_disconnect_cb;
+	cb->attention  = dp_display_usbpd_attention_cb;
+
+	dp->parser = dp_parser_get(dp->pdev);
+	if (IS_ERR(dp->parser)) {
+		rc = PTR_ERR(dp->parser);
+		pr_err("failed to initialize parser, rc = %d\n", rc);
+		dp->parser = NULL;
+		goto error_parser;
+	}
+
+	dp->catalog = dp_catalog_get(dev, &dp->parser->io);
+	if (IS_ERR(dp->catalog)) {
+		rc = PTR_ERR(dp->catalog);
+		pr_err("failed to initialize catalog, rc = %d\n", rc);
+		dp->catalog = NULL;
+		goto error_catalog;
+	}
+
+	dp->power = dp_power_get(dp->parser);
+	if (IS_ERR(dp->power)) {
+		rc = PTR_ERR(dp->power);
+		pr_err("failed to initialize power, rc = %d\n", rc);
+		dp->power = NULL;
+		goto error_power;
+	}
+
+	dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser->aux_cfg);
+	if (IS_ERR(dp->aux)) {
+		rc = PTR_ERR(dp->aux);
+		pr_err("failed to initialize aux, rc = %d\n", rc);
+		dp->aux = NULL;
+		goto error_aux;
+	}
+
+	dp->link = dp_link_get(dev, dp->aux);
+	if (IS_ERR(dp->link)) {
+		rc = PTR_ERR(dp->link);
+		pr_err("failed to initialize link, rc = %d\n", rc);
+		dp->link = NULL;
+		goto error_link;
+	}
+
+	panel_in.aux = dp->aux;
+	panel_in.catalog = &dp->catalog->panel;
+	panel_in.link = dp->link;
+
+	dp->panel = dp_panel_get(&panel_in);
+	if (IS_ERR(dp->panel)) {
+		rc = PTR_ERR(dp->panel);
+		pr_err("failed to initialize panel, rc = %d\n", rc);
+		dp->panel = NULL;
+		goto error_panel;
+	}
+
+	ctrl_in.link = dp->link;
+	ctrl_in.panel = dp->panel;
+	ctrl_in.aux = dp->aux;
+	ctrl_in.power = dp->power;
+	ctrl_in.catalog = &dp->catalog->ctrl;
+	ctrl_in.parser = dp->parser;
+
+	dp->ctrl = dp_ctrl_get(&ctrl_in);
+	if (IS_ERR(dp->ctrl)) {
+		rc = PTR_ERR(dp->ctrl);
+		pr_err("failed to initialize ctrl, rc = %d\n", rc);
+		dp->ctrl = NULL;
+		goto error_ctrl;
+	}
+
+	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
+				dp->link, &dp->dp_display.connector);
+	if (IS_ERR(dp->debug)) {
+		rc = PTR_ERR(dp->debug);
+		pr_err("failed to initialize debug, rc = %d\n", rc);
+		dp->debug = NULL;
+		goto error_debug;
+	}
+
+	return rc;
+error_debug:
+	dp_ctrl_put(dp->ctrl);
+error_ctrl:
+	dp_panel_put(dp->panel);
+error_panel:
+	dp_link_put(dp->link);
+error_link:
+	dp_aux_put(dp->aux);
+error_aux:
+	dp_power_put(dp->power);
+error_power:
+	dp_catalog_put(dp->catalog);
+error_catalog:
+	dp_parser_put(dp->parser);
+error_parser:
+	return rc;
+}
+
+static int dp_display_set_mode(struct msm_dp *dp_display,
+			       struct dp_display_mode *mode)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	dp->panel->pinfo = mode->timing;
+	dp->panel->init_info(dp->panel);
+error:
+	return rc;
+}
+
+static int dp_display_prepare(struct msm_dp *dp)
+{
+	return 0;
+}
+
+static int dp_display_enable(struct msm_dp *dp_display)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	if (dp->power_on) {
+		pr_debug("Link already setup, return\n");
+		return 0;
+	}
+
+	dp->aux->init(dp->aux, dp->parser->aux_cfg);
+
+	rc = dp->ctrl->on(dp->ctrl);
+	if (!rc)
+		dp->power_on = true;
+error:
+	return rc;
+}
+
+static int dp_display_post_enable(struct msm_dp *dp_display)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	complete_all(&dp->notification_comp);
+
+end:
+	return rc;
+}
+
+static int dp_display_pre_disable(struct msm_dp *dp_display)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	if (dp->usbpd->alt_mode_cfg_done && (dp->usbpd->hpd_high ||
+		dp->usbpd->forced_disconnect))
+		dp->link->psm_config(dp->link, &dp->panel->link_info, true);
+
+	dp->ctrl->push_idle(dp->ctrl);
+error:
+	return rc;
+}
+
+static int dp_display_disable(struct msm_dp *dp_display)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	if (!dp->power_on || !dp->core_initialized)
+		goto error;
+
+	dp->ctrl->off(dp->ctrl);
+
+	dp->power_on = false;
+
+	complete_all(&dp->notification_comp);
+error:
+	return rc;
+}
+
+static int dp_request_irq(struct msm_dp *dp_display)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
+	if (dp->irq < 0) {
+		rc = dp->irq;
+		pr_err("failed to get irq: %d\n", rc);
+		return rc;
+	}
+
+	rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq,
+		IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
+	if (rc < 0) {
+		pr_err("failed to request IRQ%u: %d\n",
+				dp->irq, rc);
+		return rc;
+	}
+	disable_irq(dp->irq);
+
+	return 0;
+}
+
+static struct dp_debug *dp_get_debug(struct msm_dp *dp_display)
+{
+	struct dp_display_private *dp;
+
+	if (!dp_display) {
+		pr_err("invalid input\n");
+		return ERR_PTR(-EINVAL);
+	}
+
+	dp = container_of(dp_display, struct dp_display_private, dp_display);
+
+	return dp->debug;
+}
+
+static int dp_display_unprepare(struct msm_dp *dp)
+{
+	return 0;
+}
+
+static int dp_display_validate_mode(struct msm_dp *dp, u32 mode_pclk_khz)
+{
+	const u32 num_components = 3, default_bpp = 24;
+	struct dp_display_private *dp_display;
+	struct drm_dp_link *link_info;
+	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
+
+	if (!dp || !mode_pclk_khz || !dp->connector) {
+		pr_err("invalid params\n");
+		return -EINVAL;
+	}
+
+	dp_display = container_of(dp, struct dp_display_private, dp_display);
+	link_info = &dp_display->panel->link_info;
+
+	mode_bpp = dp->connector->display_info.bpc * num_components;
+	if (!mode_bpp)
+		mode_bpp = default_bpp;
+
+	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,
+			mode_bpp, mode_pclk_khz);
+
+	mode_rate_khz = mode_pclk_khz * mode_bpp;
+	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
+
+	if (mode_rate_khz > supported_rate_khz)
+		return MODE_BAD;
+
+	return MODE_OK;
+}
+
+static int dp_display_get_modes(struct msm_dp *dp,
+				struct dp_display_mode *dp_mode)
+{
+	struct dp_display_private *dp_display;
+	int ret = 0;
+
+	if (!dp) {
+		pr_err("invalid params\n");
+		return 0;
+	}
+
+	dp_display = container_of(dp, struct dp_display_private, dp_display);
+
+	ret = dp_display->panel->get_modes(dp_display->panel,
+		dp->connector, dp_mode);
+	if (dp_mode->timing.pixel_clk_khz)
+		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;
+	return ret;
+}
+
+static bool dp_display_check_video_test(struct msm_dp *dp)
+{
+	struct dp_display_private *dp_display;
+
+	if (!dp) {
+		pr_err("invalid params\n");
+		return false;
+	}
+
+	dp_display = container_of(dp, struct dp_display_private, dp_display);
+
+	if (dp_display->panel->video_test)
+		return true;
+
+	return false;
+}
+
+static int dp_display_get_test_bpp(struct msm_dp *dp)
+{
+	struct dp_display_private *dp_display;
+
+	if (!dp) {
+		pr_err("invalid params\n");
+		return 0;
+	}
+
+	dp_display = container_of(dp, struct dp_display_private, dp_display);
+
+	return dp_link_bit_depth_to_bpp(
+		dp_display->link->test_video.test_bit_depth);
+}
+
+static int dp_display_probe(struct platform_device *pdev)
+{
+	int rc = 0;
+	struct dp_display_private *dp;
+
+	if (!pdev || !pdev->dev.of_node) {
+		pr_err("pdev not found\n");
+		return -ENODEV;
+	}
+
+	dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
+	if (!dp)
+		return -ENOMEM;
+
+	init_completion(&dp->notification_comp);
+
+	dp->pdev = pdev;
+	dp->name = "drm_dp";
+
+	rc = dp_init_sub_modules(dp);
+	if (rc) {
+		pr_err("init sub module failed\n");
+		devm_kfree(&pdev->dev, dp);
+		return -EPROBE_DEFER;
+	}
+
+	platform_set_drvdata(pdev, dp);
+
+	g_dp_display = &dp->dp_display;
+
+	g_dp_display->enable        = dp_display_enable;
+	g_dp_display->post_enable   = dp_display_post_enable;
+	g_dp_display->pre_disable   = dp_display_pre_disable;
+	g_dp_display->disable       = dp_display_disable;
+	g_dp_display->set_mode      = dp_display_set_mode;
+	g_dp_display->validate_mode = dp_display_validate_mode;
+	g_dp_display->get_modes     = dp_display_get_modes;
+	g_dp_display->prepare       = dp_display_prepare;
+	g_dp_display->unprepare     = dp_display_unprepare;
+	g_dp_display->request_irq   = dp_request_irq;
+	g_dp_display->get_debug     = dp_get_debug;
+	g_dp_display->send_hpd_event    = dp_display_send_hpd_event;
+	g_dp_display->is_video_test = dp_display_check_video_test;
+	g_dp_display->get_test_bpp = dp_display_get_test_bpp;
+
+	rc = component_add(&pdev->dev, &dp_display_comp_ops);
+	if (rc) {
+		pr_err("component add failed, rc=%d\n", rc);
+		dp_display_deinit_sub_modules(dp);
+		devm_kfree(&pdev->dev, dp);
+	}
+
+	return rc;
+}
+
+int dp_display_get_displays(void **displays, int count)
+{
+	if (!displays) {
+		pr_err("invalid data\n");
+		return -EINVAL;
+	}
+
+	if (count != 1) {
+		pr_err("invalid number of displays\n");
+		return -EINVAL;
+	}
+
+	displays[0] = g_dp_display;
+	return count;
+}
+
+int dp_display_get_num_of_displays(void)
+{
+	return 1;
+}
+
+static int dp_display_remove(struct platform_device *pdev)
+{
+	struct dp_display_private *dp;
+
+	if (!pdev)
+		return -EINVAL;
+
+	dp = platform_get_drvdata(pdev);
+
+	dp_display_deinit_sub_modules(dp);
+
+	platform_set_drvdata(pdev, NULL);
+	devm_kfree(&pdev->dev, dp);
+
+	return 0;
+}
+
+static struct platform_driver dp_display_driver = {
+	.probe  = dp_display_probe,
+	.remove = dp_display_remove,
+	.driver = {
+		.name = "msm-dp-display",
+		.of_match_table = dp_dt_match,
+	},
+};
+
+int __init msm_dp_register(void)
+{
+	int ret;
+
+	ret = platform_driver_register(&dp_display_driver);
+	if (ret) {
+		pr_err("driver register failed");
+		return ret;
+	}
+
+	return ret;
+}
+
+void __exit msm_dp_unregister(void)
+{
+	platform_driver_unregister(&dp_display_driver);
+}
+
+int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
+			struct drm_encoder *encoder)
+{
+	struct msm_drm_private *priv;
+	int ret;
+
+	if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
+		return -EINVAL;
+
+	priv = dev->dev_private;
+	dp_display->drm_dev = dev;
+
+	ret = dp_drm_bridge_init(dp_display, encoder);
+	if (ret) {
+		dev_err(dev->dev, "failed to create dp bridge: %d\n", ret);
+		dp_display->bridge = NULL;
+		return ret;
+	}
+	dp_display->encoder = encoder;
+
+	dp_display->connector = dp_drm_connector_init(dp_display);
+	if (IS_ERR(dp_display->connector)) {
+		ret = PTR_ERR(dp_display->connector);
+		dev_err(dev->dev,
+			"failed to create dp connector: %d\n", ret);
+		dp_display->connector = NULL;
+		goto conn_fail;
+	}
+
+	priv->bridges[priv->num_bridges++] = dp_display->bridge;
+	priv->connectors[priv->num_connectors++] = dp_display->connector;
+	return 0;
+
+conn_fail:
+	if (dp_display->bridge) {
+		dp_drm_bridge_deinit(dp_display);
+		dp_display->bridge = NULL;
+	}
+	return ret;
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
new file mode 100644
index 0000000..ca5eae5
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_display.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_DISPLAY_H_
+#define _DP_DISPLAY_H_
+
+#include <drm/drmP.h>
+
+#include "dp_panel.h"
+
+struct msm_dp {
+	struct drm_device *drm_dev;
+	struct dp_bridge *dp_bridge;
+	struct drm_connector *connector;
+	struct drm_bridge *bridge;
+
+	/* the encoder we are hooked to (outside of dsi block) */
+	struct drm_encoder *encoder;
+	bool is_connected;
+	u32 max_pclk_khz;
+
+	int (*enable)(struct msm_dp *dp_display);
+	int (*post_enable)(struct msm_dp *dp_display);
+
+	int (*pre_disable)(struct msm_dp *dp_display);
+	int (*disable)(struct msm_dp *dp_display);
+
+	int (*set_mode)(struct msm_dp *dp_display,
+			struct dp_display_mode *mode);
+	int (*validate_mode)(struct msm_dp *dp_display, u32 mode_pclk_khz);
+	int (*get_modes)(struct msm_dp *dp_display,
+		struct dp_display_mode *dp_mode);
+	int (*prepare)(struct msm_dp *dp_display);
+	int (*unprepare)(struct msm_dp *dp_display);
+	int (*request_irq)(struct msm_dp *dp_display);
+	struct dp_debug *(*get_debug)(struct msm_dp *dp_display);
+	void (*send_hpd_event)(struct msm_dp *dp_display);
+	bool (*is_video_test)(struct msm_dp *dp_display);
+	int (*get_test_bpp)(struct msm_dp *dp_display);
+};
+
+int dp_display_get_num_of_displays(void);
+int dp_display_get_displays(void **displays, int count);
+#endif /* _DP_DISPLAY_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_drm.c b/drivers/gpu/drm/msm/dp/dp_drm.c
new file mode 100644
index 0000000..64d6449
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_drm.c
@@ -0,0 +1,542 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
+
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_crtc.h>
+
+#include "msm_drv.h"
+#include "msm_kms.h"
+//#include "dpu_connector.h"
+#include "dp_drm.h"
+#include "dp_debug.h"
+
+struct dp_connector {
+	struct drm_connector base;
+	struct msm_dp *dp_display;
+};
+#define to_dp_connector(x) container_of(x, struct dp_connector, base)
+#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
+
+static void convert_to_dp_mode(const struct drm_display_mode *drm_mode,
+			struct dp_display_mode *dp_mode, struct msm_dp *dp)
+{
+	const u32 num_components = 3;
+
+	memset(dp_mode, 0, sizeof(*dp_mode));
+
+	dp_mode->timing.h_active = drm_mode->hdisplay;
+	dp_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;
+	dp_mode->timing.h_sync_width = drm_mode->htotal -
+			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);
+	dp_mode->timing.h_front_porch = drm_mode->hsync_start -
+					 drm_mode->hdisplay;
+	dp_mode->timing.h_skew = drm_mode->hskew;
+
+	dp_mode->timing.v_active = drm_mode->vdisplay;
+	dp_mode->timing.v_back_porch = drm_mode->vtotal - drm_mode->vsync_end;
+	dp_mode->timing.v_sync_width = drm_mode->vtotal -
+		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);
+
+	dp_mode->timing.v_front_porch = drm_mode->vsync_start -
+					 drm_mode->vdisplay;
+
+	if (dp->is_video_test(dp))
+		dp_mode->timing.bpp = dp->get_test_bpp(dp);
+	else
+		dp_mode->timing.bpp = dp->connector->display_info.bpc *
+		num_components;
+
+	if (!dp_mode->timing.bpp)
+		dp_mode->timing.bpp = 24;
+
+	dp_mode->timing.refresh_rate = drm_mode->vrefresh;
+
+	dp_mode->timing.pixel_clk_khz = drm_mode->clock;
+
+	dp_mode->timing.v_active_low =
+		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);
+
+	dp_mode->timing.h_active_low =
+		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);
+}
+
+static void convert_to_drm_mode(const struct dp_display_mode *dp_mode,
+				struct drm_display_mode *drm_mode)
+{
+	u32 flags = 0;
+
+	memset(drm_mode, 0, sizeof(*drm_mode));
+
+	drm_mode->hdisplay = dp_mode->timing.h_active;
+	drm_mode->hsync_start = drm_mode->hdisplay +
+				dp_mode->timing.h_front_porch;
+	drm_mode->hsync_end = drm_mode->hsync_start +
+			      dp_mode->timing.h_sync_width;
+	drm_mode->htotal = drm_mode->hsync_end + dp_mode->timing.h_back_porch;
+	drm_mode->hskew = dp_mode->timing.h_skew;
+
+	drm_mode->vdisplay = dp_mode->timing.v_active;
+	drm_mode->vsync_start = drm_mode->vdisplay +
+				dp_mode->timing.v_front_porch;
+	drm_mode->vsync_end = drm_mode->vsync_start +
+			      dp_mode->timing.v_sync_width;
+	drm_mode->vtotal = drm_mode->vsync_end + dp_mode->timing.v_back_porch;
+
+	drm_mode->vrefresh = dp_mode->timing.refresh_rate;
+	drm_mode->clock = dp_mode->timing.pixel_clk_khz;
+
+	if (dp_mode->timing.h_active_low)
+		flags |= DRM_MODE_FLAG_NHSYNC;
+	else
+		flags |= DRM_MODE_FLAG_PHSYNC;
+
+	if (dp_mode->timing.v_active_low)
+		flags |= DRM_MODE_FLAG_NVSYNC;
+	else
+		flags |= DRM_MODE_FLAG_PVSYNC;
+
+	drm_mode->flags = flags;
+
+	drm_mode->type = 0x48;
+	drm_mode_set_name(drm_mode);
+}
+
+static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
+{
+	int rc = 0;
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	/* By this point mode should have been validated through mode_fixup */
+	rc = dp->set_mode(dp, &bridge->dp_mode);
+	if (rc) {
+		pr_err("[%d] failed to perform a mode set, rc=%d\n",
+		       bridge->id, rc);
+		return;
+	}
+
+	rc = dp->prepare(dp);
+	if (rc) {
+		pr_err("[%d] DP display prepare failed, rc=%d\n",
+		       bridge->id, rc);
+		return;
+	}
+
+	rc = dp->enable(dp);
+	if (rc) {
+		pr_err("[%d] DP display enable failed, rc=%d\n",
+		       bridge->id, rc);
+		dp->unprepare(dp);
+	}
+}
+
+static void dp_bridge_enable(struct drm_bridge *drm_bridge)
+{
+	int rc = 0;
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	rc = dp->post_enable(dp);
+	if (rc)
+		pr_err("[%d] DP display post enable failed, rc=%d\n",
+		       bridge->id, rc);
+}
+
+static void dp_bridge_disable(struct drm_bridge *drm_bridge)
+{
+	int rc = 0;
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	rc = dp->pre_disable(dp);
+	if (rc) {
+		pr_err("[%d] DP display pre disable failed, rc=%d\n",
+		       bridge->id, rc);
+	}
+}
+
+static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
+{
+	int rc = 0;
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	rc = dp->disable(dp);
+	if (rc) {
+		pr_err("[%d] DP display disable failed, rc=%d\n",
+		       bridge->id, rc);
+		return;
+	}
+
+	rc = dp->unprepare(dp);
+	if (rc) {
+		pr_err("[%d] DP display unprepare failed, rc=%d\n",
+		       bridge->id, rc);
+		return;
+	}
+}
+
+static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
+				struct drm_display_mode *mode,
+				struct drm_display_mode *adjusted_mode)
+{
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge || !mode || !adjusted_mode) {
+		pr_err("Invalid params\n");
+		return;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
+	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode, dp);
+}
+
+static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
+				  const struct drm_display_mode *mode,
+				  struct drm_display_mode *adjusted_mode)
+{
+	bool ret = true;
+	struct dp_display_mode dp_mode;
+	struct dp_bridge *bridge;
+	struct msm_dp *dp;
+
+	if (!drm_bridge || !mode || !adjusted_mode) {
+		pr_err("Invalid params\n");
+		ret = false;
+		goto end;
+	}
+
+	bridge = to_dp_bridge(drm_bridge);
+	dp = bridge->display;
+
+	convert_to_dp_mode(mode, &dp_mode, dp);
+	convert_to_drm_mode(&dp_mode, adjusted_mode);
+end:
+	return ret;
+}
+
+static const struct drm_bridge_funcs dp_bridge_ops = {
+	.mode_fixup   = dp_bridge_mode_fixup,
+	.pre_enable   = dp_bridge_pre_enable,
+	.enable       = dp_bridge_enable,
+	.disable      = dp_bridge_disable,
+	.post_disable = dp_bridge_post_disable,
+	.mode_set     = dp_bridge_mode_set,
+};
+
+int dp_connector_post_init(struct drm_connector *connector, void *display)
+{
+	struct msm_dp *dp_display = display;
+
+	if (!dp_display)
+		return -EINVAL;
+
+	dp_display->connector = connector;
+	return 0;
+}
+
+/**
+ * dp_connector_detect - callback to determine if connector is connected
+ * @connector: Pointer to drm connector structure
+ * @force: Force detect setting from drm framework
+ * Returns: Connector 'is connected' status
+ */
+static enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
+		bool force)
+{
+	enum drm_connector_status status = connector_status_unknown;
+	static enum drm_connector_status current_status = connector_status_unknown;
+	struct msm_dp *dp;
+	struct dp_connector *dp_conn;
+	struct msm_drm_private *priv = conn->dev->dev_private;
+	struct msm_kms *kms = priv->kms;
+
+	dp_conn = to_dp_connector(conn);
+	dp = dp_conn->dp_display;
+
+	pr_err("is_connected = %s\n",
+		(dp->is_connected) ? "true" : "false");
+
+	status = (dp->is_connected) ? connector_status_connected :
+					connector_status_disconnected;
+
+	if (dp->is_connected && dp->bridge->encoder
+				&& (current_status != status)
+				&& kms->funcs->set_encoder_mode) {
+		kms->funcs->set_encoder_mode(kms,
+				dp->bridge->encoder, false);
+		pr_err("call set_encoder_mode\n");
+	}
+	current_status = status;
+	return status;
+}
+
+static void dp_connector_destroy(struct drm_connector *connector)
+{
+	struct dp_connector *dp_conn = to_dp_connector(connector);
+
+	DBG("");
+
+	drm_connector_cleanup(connector);
+
+	kfree(dp_conn);
+}
+
+void dp_connector_send_hpd_event(void *display)
+{
+	struct msm_dp *dp;
+
+	if (!display) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	dp = display;
+
+	if (dp->send_hpd_event)
+		dp->send_hpd_event(dp);
+}
+
+/**
+ * dp_connector_get_modes - callback to add drm modes via drm_mode_probed_add()
+ * @connector: Pointer to drm connector structure
+ * Returns: Number of modes added
+ */
+static int dp_connector_get_modes(struct drm_connector *connector)
+{
+	int rc = 0;
+	struct msm_dp *dp;
+	struct dp_display_mode *dp_mode = NULL;
+	struct drm_display_mode *m, drm_mode;
+	struct dp_connector *dp_conn;
+
+	if (!connector)
+		return 0;
+
+	dp_conn = to_dp_connector(connector);
+	dp = dp_conn->dp_display;
+
+	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
+	if (!dp_mode)
+		return 0;
+
+	/* pluggable case assumes EDID is read when HPD */
+	if (dp->is_connected) {
+		rc = dp->get_modes(dp, dp_mode);
+		if (!rc)
+			pr_err("failed to get DP sink modes, rc=%d\n", rc);
+
+		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
+			memset(&drm_mode, 0x0, sizeof(drm_mode));
+			convert_to_drm_mode(dp_mode, &drm_mode);
+			m = drm_mode_duplicate(connector->dev, &drm_mode);
+			if (!m) {
+				pr_err("failed to add mode %ux%u\n",
+				       drm_mode.hdisplay,
+				       drm_mode.vdisplay);
+				kfree(dp_mode);
+				return 0;
+			}
+			m->width_mm = connector->display_info.width_mm;
+			m->height_mm = connector->display_info.height_mm;
+			drm_mode_probed_add(connector, m);
+		}
+	} else {
+		pr_err("No sink connected\n");
+	}
+	kfree(dp_mode);
+
+	return rc;
+}
+
+int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
+{
+	int rc = 0;
+	struct dp_bridge *dp_bridge;
+	struct drm_device *dev;
+	struct msm_dp *dp_display = data;
+	struct msm_drm_private *priv = NULL;
+
+	dp_bridge = kzalloc(sizeof(*dp_bridge), GFP_KERNEL);
+	if (!dp_bridge) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	dev = dp_display->drm_dev;
+	dp_bridge->display = dp_display;
+	dp_bridge->base.funcs = &dp_bridge_ops;
+	dp_bridge->base.encoder = encoder;
+
+	priv = dev->dev_private;
+
+	rc = drm_bridge_attach(encoder, &dp_bridge->base, NULL);
+	if (rc) {
+		pr_err("failed to attach bridge, rc=%d\n", rc);
+		goto error_free_bridge;
+	}
+
+	rc = dp_display->request_irq(dp_display);
+	if (rc) {
+		pr_err("request_irq failed, rc=%d\n", rc);
+		goto error_free_bridge;
+	}
+
+	encoder->bridge = &dp_bridge->base;
+	dp_display->dp_bridge = dp_bridge;
+	dp_display->bridge = &dp_bridge->base;
+
+	return 0;
+error_free_bridge:
+	kfree(dp_bridge);
+error:
+	return rc;
+}
+
+void dp_drm_bridge_deinit(void *data)
+{
+	struct msm_dp *display = data;
+	struct dp_bridge *bridge = display->dp_bridge;
+
+	if (bridge && bridge->base.encoder)
+		bridge->base.encoder->bridge = NULL;
+
+	kfree(bridge);
+}
+
+/**
+ * dp_connector_mode_valid - callback to determine if specified mode is valid
+ * @connector: Pointer to drm connector structure
+ * @mode: Pointer to drm mode structure
+ * Returns: Validity status for specified mode
+ */
+static enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,
+		struct drm_display_mode *mode)
+{
+	struct msm_dp *dp_disp;
+	struct dp_debug *debug;
+	struct dp_connector *dp_conn;
+
+	if (!mode || !connector) {
+		pr_err("invalid params\n");
+		return MODE_ERROR;
+	}
+
+	dp_conn = to_dp_connector(connector);
+	dp_disp = dp_conn->dp_display;
+	debug = dp_disp->get_debug(dp_disp);
+
+	mode->vrefresh = drm_mode_vrefresh(mode);
+
+	if (mode->clock > dp_disp->max_pclk_khz)
+		return MODE_BAD;
+
+	if (debug->debug_en && (mode->hdisplay != debug->hdisplay ||
+			mode->vdisplay != debug->vdisplay ||
+			mode->vrefresh != debug->vrefresh ||
+			mode->picture_aspect_ratio != debug->aspect_ratio))
+		return MODE_BAD;
+
+	return dp_disp->validate_mode(dp_disp, mode->clock);
+}
+
+static const struct drm_connector_funcs dp_connector_funcs = {
+	.detect = dp_connector_detect,
+	.fill_modes = drm_helper_probe_single_connector_modes,
+	.destroy = dp_connector_destroy,
+	.reset = drm_atomic_helper_connector_reset,
+	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
+	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
+};
+
+static const struct drm_connector_helper_funcs dp_connector_helper_funcs = {
+	.get_modes = dp_connector_get_modes,
+	.mode_valid = dp_connector_mode_valid,
+};
+
+/* connector initialization */
+struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display)
+{
+	struct drm_connector *connector = NULL;
+	struct dp_connector *dp_connector;
+	int ret;
+
+	dp_connector = kzalloc(sizeof(*dp_connector), GFP_KERNEL);
+	if (!dp_connector)
+		return ERR_PTR(-ENOMEM);
+
+	dp_connector->dp_display = dp_display;
+
+	connector = &dp_connector->base;
+
+	ret = drm_connector_init(dp_display->drm_dev, connector, &dp_connector_funcs,
+			DRM_MODE_CONNECTOR_DisplayPort);
+	if (ret)
+		return ERR_PTR(ret);
+
+	drm_connector_helper_add(connector, &dp_connector_helper_funcs);
+
+	/*
+	 * Enable HPD to let hpd event is handled
+	 * when cable is attached to the host.
+	 */
+	connector->polled = DRM_CONNECTOR_POLL_HPD;
+
+	/* Display driver doesn't support interlace now. */
+	connector->interlace_allowed = false;
+	connector->doublescan_allowed = false;
+
+	drm_connector_attach_encoder(connector, dp_display->encoder);
+
+	return connector;
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_drm.h b/drivers/gpu/drm/msm/dp/dp_drm.h
new file mode 100644
index 0000000..efbc1be
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_drm.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_DRM_H_
+#define _DP_DRM_H_
+
+#include <linux/types.h>
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_crtc_helper.h>
+
+#include "msm_drv.h"
+#include "dp_display.h"
+
+struct dp_bridge {
+	struct drm_bridge base;
+	u32 id;
+
+	struct msm_dp *display;
+	struct dp_display_mode dp_mode;
+};
+
+/**
+ * dp_connector_post_init - callback to perform additional initialization steps
+ * @connector: Pointer to drm connector structure
+ * @display: Pointer to private display handle
+ * Returns: Zero on success
+ */
+int dp_connector_post_init(struct drm_connector *connector, void *display);
+
+void dp_connector_send_hpd_event(void *display);
+
+int dp_drm_bridge_init(void *display,
+	struct drm_encoder *encoder);
+
+void dp_drm_bridge_deinit(void *display);
+
+struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display);
+
+#endif /* _DP_DRM_H_ */
+
diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.c b/drivers/gpu/drm/msm/dp/dp_extcon.c
new file mode 100644
index 0000000..635c13b
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_extcon.c
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/extcon.h>
+
+#include "dp_extcon.h"
+
+/* DP specific VDM commands */
+#define DP_USBPD_VDM_STATUS	0x10
+#define DP_USBPD_VDM_CONFIGURE	0x11
+
+/* USBPD-TypeC specific Macros */
+#define VDM_VERSION		0x0
+#define USB_C_DP_SID		0xFF01
+
+enum dp_usbpd_pin_assignment {
+	DP_USBPD_PIN_A,
+	DP_USBPD_PIN_B,
+	DP_USBPD_PIN_C,
+	DP_USBPD_PIN_D,
+	DP_USBPD_PIN_E,
+	DP_USBPD_PIN_F,
+	DP_USBPD_PIN_MAX,
+};
+
+struct dp_usbpd_capabilities {
+	enum dp_usbpd_port port;
+	bool receptacle_state;
+	u8 ulink_pin_config;
+	u8 dlink_pin_config;
+};
+
+struct dp_extcon_private {
+	u32 vdo;
+	struct device *dev;
+	struct notifier_block extcon_nb;
+	struct extcon_dev *extcon;
+	struct workqueue_struct *extcon_wq;
+	struct work_struct event_work;
+	struct usbpd *pd;
+	struct dp_usbpd_cb *dp_cb;
+	struct dp_usbpd_capabilities cap;
+	struct dp_usbpd dp_usbpd;
+};
+
+static const char *dp_usbpd_pin_name(u8 pin)
+{
+	switch (pin) {
+	case DP_USBPD_PIN_A: return "DP_USBPD_PIN_ASSIGNMENT_A";
+	case DP_USBPD_PIN_B: return "DP_USBPD_PIN_ASSIGNMENT_B";
+	case DP_USBPD_PIN_C: return "DP_USBPD_PIN_ASSIGNMENT_C";
+	case DP_USBPD_PIN_D: return "DP_USBPD_PIN_ASSIGNMENT_D";
+	case DP_USBPD_PIN_E: return "DP_USBPD_PIN_ASSIGNMENT_E";
+	case DP_USBPD_PIN_F: return "DP_USBPD_PIN_ASSIGNMENT_F";
+	default: return "UNKNOWN";
+	}
+}
+
+static const char *dp_usbpd_port_name(enum dp_usbpd_port port)
+{
+	switch (port) {
+	case DP_USBPD_PORT_NONE: return "DP_USBPD_PORT_NONE";
+	case DP_USBPD_PORT_UFP_D: return "DP_USBPD_PORT_UFP_D";
+	case DP_USBPD_PORT_DFP_D: return "DP_USBPD_PORT_DFP_D";
+	case DP_USBPD_PORT_D_UFP_D: return "DP_USBPD_PORT_D_UFP_D";
+	default: return "DP_USBPD_PORT_NONE";
+	}
+}
+
+static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
+{
+	switch (in_port) {
+	case 0:
+		*port = DP_USBPD_PORT_NONE;
+		break;
+	case 1:
+		*port = DP_USBPD_PORT_UFP_D;
+		break;
+	case 2:
+		*port = DP_USBPD_PORT_DFP_D;
+		break;
+	case 3:
+		*port = DP_USBPD_PORT_D_UFP_D;
+		break;
+	default:
+		*port = DP_USBPD_PORT_NONE;
+	}
+	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
+}
+
+void dp_usbpd_get_capabilities(struct dp_extcon_private *pd)
+{
+	struct dp_usbpd_capabilities *cap = &pd->cap;
+	u32 buf = pd->vdo;
+	int port = buf & 0x3;
+
+	cap->receptacle_state = (buf & BIT(6)) ? true : false;
+	cap->dlink_pin_config = (buf >> 8) & 0xff;
+	cap->ulink_pin_config = (buf >> 16) & 0xff;
+
+	dp_usbpd_init_port(&cap->port, port);
+}
+
+void dp_usbpd_get_status(struct dp_extcon_private *pd)
+{
+	struct dp_usbpd *status = &pd->dp_usbpd;
+	u32 buf = pd->vdo;
+	int port = buf & 0x3;
+
+	status->low_pow_st     = (buf & BIT(2)) ? true : false;
+	status->adaptor_dp_en  = (buf & BIT(3)) ? true : false;
+	status->multi_func     = (buf & BIT(4)) ? true : false;
+	status->usb_config_req = (buf & BIT(5)) ? true : false;
+	status->exit_dp_mode   = (buf & BIT(6)) ? true : false;
+	status->hpd_high       = (buf & BIT(7)) ? true : false;
+	status->hpd_irq        = (buf & BIT(8)) ? true : false;
+
+	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
+			status->low_pow_st, status->adaptor_dp_en,
+			status->multi_func);
+	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
+			status->usb_config_req,
+			status->exit_dp_mode, status->hpd_high);
+	pr_debug("hpd_irq = %d\n", status->hpd_irq);
+
+	dp_usbpd_init_port(&status->port, port);
+}
+
+u32 dp_usbpd_gen_config_pkt(struct dp_extcon_private *pd)
+{
+	u8 pin_cfg, pin;
+	u32 config = 0;
+	const u32 ufp_d_config = 0x2, dp_ver = 0x1;
+
+	if (pd->cap.receptacle_state)
+		pin_cfg = pd->cap.ulink_pin_config;
+	else
+		pin_cfg = pd->cap.dlink_pin_config;
+
+	for (pin = DP_USBPD_PIN_A; pin < DP_USBPD_PIN_MAX; pin++) {
+		if (pin_cfg & BIT(pin)) {
+			if (pd->dp_usbpd.multi_func) {
+				if (pin == DP_USBPD_PIN_D)
+					break;
+			} else {
+				break;
+			}
+		}
+	}
+
+	if (pin == DP_USBPD_PIN_MAX)
+		pin = DP_USBPD_PIN_C;
+
+	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
+
+	config |= BIT(pin) << 8;
+
+	config |= (dp_ver << 2);
+	config |= ufp_d_config;
+
+	pr_debug("config = 0x%x\n", config);
+	return config;
+}
+
+static int dp_extcon_connect(struct dp_usbpd *dp_usbpd, bool hpd)
+{
+	int rc = 0;
+	struct dp_extcon_private *extcon;
+
+	if (!dp_usbpd) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
+
+	dp_usbpd->hpd_high = hpd;
+	dp_usbpd->forced_disconnect = !hpd;
+
+	if (hpd)
+		extcon->dp_cb->configure(extcon->dev);
+	else
+		extcon->dp_cb->disconnect(extcon->dev);
+
+error:
+	return rc;
+}
+
+static int dp_extcon_get_lanes(struct dp_extcon_private *extcon_priv)
+{
+	union extcon_property_value property;
+	u8 lanes;
+
+	if (!extcon_priv || !extcon_priv->extcon) {
+		pr_err("Invalid input arguments\n");
+		return 0;
+	}
+
+	extcon_get_property(extcon_priv->extcon,
+					EXTCON_DISP_DP,
+					EXTCON_PROP_USB_SS,
+					&property);
+	lanes = ((property.intval) ? 2 : 4);
+
+	return lanes;
+}
+
+
+static void dp_extcon_event_work(struct work_struct *work)
+{
+	struct dp_extcon_private *extcon_priv;
+	int dp_state, ret;
+	int lanes;
+	union extcon_property_value property;
+
+	extcon_priv = container_of(work,
+			struct dp_extcon_private, event_work);
+
+	if (!extcon_priv || !extcon_priv->extcon) {
+		pr_err("Invalid extcon device handler\n");
+		return;
+	}
+
+	dp_state = extcon_get_state(extcon_priv->extcon,
+						EXTCON_DISP_DP);
+
+	if (dp_state > 0) {
+		ret = extcon_get_property(extcon_priv->extcon,
+					EXTCON_DISP_DP,
+					EXTCON_PROP_USB_TYPEC_POLARITY,
+					&property);
+		if (ret) {
+			pr_err("Get Polarity property failed\n");
+			return;
+		}
+		extcon_priv->dp_usbpd.orientation =
+			((property.intval) ?
+				ORIENTATION_CC2 : ORIENTATION_CC1);
+
+		lanes = dp_extcon_get_lanes(extcon_priv);
+		if (!lanes)
+			return;
+		extcon_priv->dp_usbpd.multi_func =
+					((lanes == 2) ? false : true);
+
+		if (extcon_priv->dp_cb && extcon_priv->dp_cb->configure)
+			dp_extcon_connect(&extcon_priv->dp_usbpd, true);
+	} else {
+		if (extcon_priv->dp_cb && extcon_priv->dp_cb->disconnect)
+			dp_extcon_connect(&extcon_priv->dp_usbpd, false);
+	}
+}
+
+static int dp_extcon_create_workqueue(struct dp_extcon_private *extcon_priv)
+{
+	extcon_priv->extcon_wq = create_singlethread_workqueue("drm_dp_extcon");
+	if (IS_ERR_OR_NULL(extcon_priv->extcon_wq)) {
+		pr_err("Error creating extcon wq\n");
+		return -EPERM;
+	}
+
+	INIT_WORK(&extcon_priv->event_work, dp_extcon_event_work);
+
+	return 0;
+}
+
+static int dp_extcon_event_notify(struct notifier_block *nb,
+				  unsigned long event, void *priv)
+{
+	struct dp_extcon_private *extcon_priv;
+
+	extcon_priv = container_of(nb, struct dp_extcon_private,
+						extcon_nb);
+
+	queue_work(extcon_priv->extcon_wq, &extcon_priv->event_work);
+	return NOTIFY_DONE;
+}
+
+int dp_extcon_register(struct dp_usbpd *dp_usbpd)
+{
+	struct dp_extcon_private *extcon_priv;
+	int ret = 0;
+
+	if (!dp_usbpd)
+		return -EINVAL;
+
+	pr_err("Start++++");
+	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
+
+	extcon_priv->extcon_nb.notifier_call = dp_extcon_event_notify;
+	ret = devm_extcon_register_notifier(extcon_priv->dev, extcon_priv->extcon,
+					    EXTCON_DISP_DP,
+					    &extcon_priv->extcon_nb);
+	if (ret) {
+		dev_err(extcon_priv->dev,
+			"register EXTCON_DISP_DP notifier err\n");
+		ret = -EINVAL;
+	}
+
+	ret = dp_extcon_create_workqueue(extcon_priv);
+	if (ret) {
+		pr_err("Failed to create workqueue\n");
+		dp_extcon_unregister(dp_usbpd);
+	}
+
+	pr_err("End----");
+	return ret;
+}
+
+void dp_extcon_unregister(struct dp_usbpd *dp_usbpd)
+{
+	struct dp_extcon_private *extcon_priv;
+
+	if (!dp_usbpd) {
+		pr_err("Invalid input\n");
+		return;
+	}
+
+	pr_err("Start++++");
+	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
+
+	devm_extcon_unregister_notifier(extcon_priv->dev, extcon_priv->extcon,
+					    EXTCON_DISP_DP,
+					    &extcon_priv->extcon_nb);
+
+	if (extcon_priv->extcon_wq)
+		destroy_workqueue(extcon_priv->extcon_wq);
+
+	pr_err("End----");
+	return;
+}
+
+struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb)
+{
+	int rc = 0;
+	struct dp_extcon_private *dp_extcon;
+	struct dp_usbpd *dp_usbpd;
+
+	if (!cb) {
+		pr_err("invalid cb data\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	pr_err("%s: Start", __func__);
+	dp_extcon = devm_kzalloc(dev, sizeof(*dp_extcon), GFP_KERNEL);
+	if (!dp_extcon) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	dp_extcon->extcon = extcon_get_edev_by_phandle(dev, 0);
+	if (!dp_extcon->extcon) {
+		pr_err("invalid extcon data\n");
+		rc = -EINVAL;
+		devm_kfree(dev, dp_extcon);
+		goto error;
+        }
+
+	dp_extcon->dev = dev;
+	dp_extcon->dp_cb = cb;
+
+	dp_extcon->dp_usbpd.connect = dp_extcon_connect;
+	dp_usbpd = &dp_extcon->dp_usbpd;
+
+	pr_err("%s: end", __func__);
+	return dp_usbpd;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_extcon_put(struct dp_usbpd *dp_usbpd)
+{
+	struct dp_extcon_private *extcon;
+
+	if (!dp_usbpd)
+		return;
+
+	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
+
+	devm_kfree(extcon->dev, extcon);
+
+	pr_err("%s: end", __func__);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.h b/drivers/gpu/drm/msm/dp/dp_extcon.h
new file mode 100644
index 0000000..1f83a18
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_extcon.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_EXTCON_H_
+#define _DP_EXTCON_H_
+
+//#include <linux/usb/usbpd.h>
+
+#include <linux/types.h>
+#include <linux/device.h>
+
+/**
+ * enum dp_usbpd_port - usb/dp port type
+ * @DP_USBPD_PORT_NONE: port not configured
+ * @DP_USBPD_PORT_UFP_D: Upstream Facing Port - DisplayPort
+ * @DP_USBPD_PORT_DFP_D: Downstream Facing Port - DisplayPort
+ * @DP_USBPD_PORT_D_UFP_D: Both UFP & DFP - DisplayPort
+ */
+
+enum dp_usbpd_port {
+	DP_USBPD_PORT_NONE,
+	DP_USBPD_PORT_UFP_D,
+	DP_USBPD_PORT_DFP_D,
+	DP_USBPD_PORT_D_UFP_D,
+};
+
+enum plug_orientation {
+	ORIENTATION_NONE,
+	ORIENTATION_CC1,
+	ORIENTATION_CC2,
+};
+
+/**
+ * struct dp_usbpd - DisplayPort status
+ *
+ * @port: port configured
+ * orientation: plug orientation configuration
+ * @low_pow_st: low power state
+ * @adaptor_dp_en: adaptor functionality enabled
+ * @multi_func: multi-function preferred
+ * @usb_config_req: request to switch to usb
+ * @exit_dp_mode: request exit from displayport mode
+ * @hpd_high: Hot Plug Detect signal is high.
+ * @hpd_irq: Change in the status since last message
+ * @alt_mode_cfg_done: bool to specify alt mode status
+ * @debug_en: bool to specify debug mode
+ * @connect: simulate disconnect or connect for debug mode
+ */
+struct dp_usbpd {
+	enum dp_usbpd_port port;
+	enum plug_orientation orientation;
+	bool low_pow_st;
+	bool adaptor_dp_en;
+	bool multi_func;
+	bool usb_config_req;
+	bool exit_dp_mode;
+	bool hpd_high;
+	bool hpd_irq;
+	bool alt_mode_cfg_done;
+	bool debug_en;
+	bool forced_disconnect;
+
+	int (*connect)(struct dp_usbpd *dp_usbpd, bool hpd);
+};
+
+/**
+ * struct dp_usbpd_cb - callback functions provided by the client
+ *
+ * @configure: called by usbpd module when PD communication has
+ * been completed and the usb peripheral has been configured on
+ * dp mode.
+ * @disconnect: notify the cable disconnect issued by usb.
+ * @attention: notify any attention message issued by usb.
+ */
+struct dp_usbpd_cb {
+	int (*configure)(struct device *dev);
+	int (*disconnect)(struct device *dev);
+	int (*attention)(struct device *dev);
+};
+
+/**
+ * dp_extcon_get() - setup usbpd module
+ *
+ * @dev: device instance of the caller
+ * @cb: struct containing callback function pointers.
+ *
+ * This function allows the client to initialize the usbpd
+ * module. The module will communicate with usb driver and
+ * handles the power delivery (PD) communication with the
+ * sink/usb device. This module will notify the client using
+ * the callback functions about the connection and status.
+ */
+struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb);
+
+void dp_extcon_put(struct dp_usbpd *pd);
+
+int dp_extcon_register(struct dp_usbpd *dp_usbpd);
+void dp_extcon_unregister(struct dp_usbpd *dp_usbpd);
+
+#endif /* _DP_EXTCON_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_link.c b/drivers/gpu/drm/msm/dp/dp_link.c
new file mode 100644
index 0000000..5ab1efc
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_link.c
@@ -0,0 +1,1549 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include "dp_link.h"
+#include "dp_panel.h"
+
+enum dynamic_range {
+	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
+	DP_DYNAMIC_RANGE_RGB_CEA = 0x01,
+	DP_DYNAMIC_RANGE_UNKNOWN = 0xFFFFFFFF,
+};
+
+enum audio_sample_rate {
+	AUDIO_SAMPLE_RATE_32_KHZ	= 0x00,
+	AUDIO_SAMPLE_RATE_44_1_KHZ	= 0x01,
+	AUDIO_SAMPLE_RATE_48_KHZ	= 0x02,
+	AUDIO_SAMPLE_RATE_88_2_KHZ	= 0x03,
+	AUDIO_SAMPLE_RATE_96_KHZ	= 0x04,
+	AUDIO_SAMPLE_RATE_176_4_KHZ	= 0x05,
+	AUDIO_SAMPLE_RATE_192_KHZ	= 0x06,
+};
+
+enum audio_pattern_type {
+	AUDIO_TEST_PATTERN_OPERATOR_DEFINED	= 0x00,
+	AUDIO_TEST_PATTERN_SAWTOOTH		= 0x01,
+};
+
+struct dp_link_request {
+	u32 test_requested;
+	u32 test_link_rate;
+	u32 test_lane_count;
+};
+
+struct dp_link_private {
+	u32 prev_sink_count;
+	struct device *dev;
+	struct dp_aux *aux;
+	struct dp_link dp_link;
+
+	struct dp_link_request request;
+	u8 link_status[DP_LINK_STATUS_SIZE];
+};
+
+static char *dp_link_get_audio_test_pattern(u32 pattern)
+{
+	switch (pattern) {
+	case AUDIO_TEST_PATTERN_OPERATOR_DEFINED:
+		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_OPERATOR_DEFINED);
+	case AUDIO_TEST_PATTERN_SAWTOOTH:
+		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_SAWTOOTH);
+	default:
+		return "unknown";
+	}
+}
+
+static char *dp_link_get_audio_sample_rate(u32 rate)
+{
+	switch (rate) {
+	case AUDIO_SAMPLE_RATE_32_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_32_KHZ);
+	case AUDIO_SAMPLE_RATE_44_1_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_44_1_KHZ);
+	case AUDIO_SAMPLE_RATE_48_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_48_KHZ);
+	case AUDIO_SAMPLE_RATE_88_2_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_88_2_KHZ);
+	case AUDIO_SAMPLE_RATE_96_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_96_KHZ);
+	case AUDIO_SAMPLE_RATE_176_4_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_176_4_KHZ);
+	case AUDIO_SAMPLE_RATE_192_KHZ:
+		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_192_KHZ);
+	default:
+		return "unknown";
+	}
+}
+
+static int dp_link_get_period(struct dp_link_private *link, int const addr)
+{
+	int ret = 0;
+	u8 bp;
+	u8 data;
+	u32 const param_len = 0x1;
+	u32 const max_audio_period = 0xA;
+
+	/* TEST_AUDIO_PERIOD_CH_XX */
+	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
+		param_len) < param_len) {
+		pr_err("failed to read test_audio_period (0x%x)\n", addr);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	data = bp;
+
+	/* Period - Bits 3:0 */
+	data = data & 0xF;
+	if ((int)data > max_audio_period) {
+		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	ret = data;
+exit:
+	return ret;
+}
+
+static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
+{
+	int ret = 0;
+	struct dp_link_test_audio *req = &link->dp_link.test_audio;
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_1 = ret;
+	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_2 = ret;
+	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
+
+	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_3 = ret;
+	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_4 = ret;
+	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_5 = ret;
+	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_6 = ret;
+	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_7 = ret;
+	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
+
+	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
+	if (ret == -EINVAL)
+		goto exit;
+
+	req->test_audio_period_ch_8 = ret;
+	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
+exit:
+	return ret;
+}
+
+static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
+{
+	int ret = 0;
+	u8 bp;
+	u8 data;
+	int rlen;
+	int const param_len = 0x1;
+	int const max_audio_pattern_type = 0x1;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
+		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read link audio mode data\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+
+	/* Audio Pattern Type - Bits 7:0 */
+	if ((int)data > max_audio_pattern_type) {
+		pr_err("invalid audio pattern type = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->dp_link.test_audio.test_audio_pattern_type = data;
+	pr_debug("audio pattern type = %s\n",
+			dp_link_get_audio_test_pattern(data));
+exit:
+	return ret;
+}
+
+static int dp_link_parse_audio_mode(struct dp_link_private *link)
+{
+	int ret = 0;
+	u8 bp;
+	u8 data;
+	int rlen;
+	int const param_len = 0x1;
+	int const max_audio_sampling_rate = 0x6;
+	int const max_audio_channel_count = 0x8;
+	int sampling_rate = 0x0;
+	int channel_count = 0x0;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read link audio mode data\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+
+	/* Sampling Rate - Bits 3:0 */
+	sampling_rate = data & 0xF;
+	if (sampling_rate > max_audio_sampling_rate) {
+		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
+				sampling_rate, max_audio_sampling_rate);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	/* Channel Count - Bits 7:4 */
+	channel_count = ((data & 0xF0) >> 4) + 1;
+	if (channel_count > max_audio_channel_count) {
+		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
+				channel_count, max_audio_channel_count);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
+	link->dp_link.test_audio.test_audio_channel_count = channel_count;
+	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
+		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
+exit:
+	return ret;
+}
+
+/**
+ * dp_parse_audio_pattern_params() - parses audio pattern parameters from DPCD
+ * @link: Display Port Driver data
+ *
+ * Returns 0 if it successfully parses the audio link pattern parameters.
+ */
+static int dp_link_parse_audio_pattern_params(struct dp_link_private *link)
+{
+	int ret = 0;
+
+	ret = dp_link_parse_audio_mode(link);
+	if (ret)
+		goto exit;
+
+	ret = dp_link_parse_audio_pattern_type(link);
+	if (ret)
+		goto exit;
+
+	ret = dp_link_parse_audio_channel_period(link);
+
+exit:
+	return ret;
+}
+
+/**
+ * dp_link_is_video_pattern_valid() - validates the video pattern
+ * @pattern: video pattern requested by the sink
+ *
+ * Returns true if the requested video pattern is supported.
+ */
+static bool dp_link_is_video_pattern_valid(u32 pattern)
+{
+	switch (pattern) {
+	case DP_NO_TEST_PATTERN:
+	case DP_COLOR_RAMP:
+	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
+	case DP_COLOR_SQUARE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static char *dp_link_video_pattern_to_string(u32 test_video_pattern)
+{
+	switch (test_video_pattern) {
+	case DP_NO_TEST_PATTERN:
+		return DP_LINK_ENUM_STR(DP_NO_TEST_PATTERN);
+	case DP_COLOR_RAMP:
+		return DP_LINK_ENUM_STR(DP_COLOR_RAMP);
+	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
+		return DP_LINK_ENUM_STR(DP_BLACK_AND_WHITE_VERTICAL_LINES);
+	case DP_COLOR_SQUARE:
+		return DP_LINK_ENUM_STR(DP_COLOR_SQUARE);
+	default:
+		return "unknown";
+	}
+}
+
+/**
+ * dp_link_is_dynamic_range_valid() - validates the dynamic range
+ * @bit_depth: the dynamic range value to be checked
+ *
+ * Returns true if the dynamic range value is supported.
+ */
+static bool dp_link_is_dynamic_range_valid(u32 dr)
+{
+	switch (dr) {
+	case DP_DYNAMIC_RANGE_RGB_VESA:
+	case DP_DYNAMIC_RANGE_RGB_CEA:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static char *dp_link_dynamic_range_to_string(u32 dr)
+{
+	switch (dr) {
+	case DP_DYNAMIC_RANGE_RGB_VESA:
+		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_VESA);
+	case DP_DYNAMIC_RANGE_RGB_CEA:
+		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_CEA);
+	case DP_DYNAMIC_RANGE_UNKNOWN:
+	default:
+		return "unknown";
+	}
+}
+
+/**
+ * dp_link_is_bit_depth_valid() - validates the bit depth requested
+ * @bit_depth: bit depth requested by the sink
+ *
+ * Returns true if the requested bit depth is supported.
+ */
+static bool dp_link_is_bit_depth_valid(u32 tbd)
+{
+	/* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */
+	switch (tbd) {
+	case DP_TEST_BIT_DEPTH_6:
+	case DP_TEST_BIT_DEPTH_8:
+	case DP_TEST_BIT_DEPTH_10:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static char *dp_link_bit_depth_to_string(u32 tbd)
+{
+	switch (tbd) {
+	case DP_TEST_BIT_DEPTH_6:
+		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_6);
+	case DP_TEST_BIT_DEPTH_8:
+		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_8);
+	case DP_TEST_BIT_DEPTH_10:
+		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_10);
+	case DP_TEST_BIT_DEPTH_UNKNOWN:
+	default:
+		return "unknown";
+	}
+}
+
+static int dp_link_parse_timing_params1(struct dp_link_private *link,
+					int const addr, int const len, u32 *val)
+{
+	u8 bp[2];
+	int rlen;
+
+	if (len < 2)
+		return -EINVAL;
+
+	/* Read the requested video link pattern (Byte 0x221). */
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
+	if (rlen < len) {
+		pr_err("failed to read 0x%x\n", addr);
+		return -EINVAL;
+	}
+
+	*val = bp[1] | (bp[0] << 8);
+
+	return 0;
+}
+
+static int dp_link_parse_timing_params2(struct dp_link_private *link,
+					int const addr, int const len,
+					u32 *val1, u32 *val2)
+{
+	u8 bp[2];
+	int rlen;
+
+	if (len < 2)
+		return -EINVAL;
+
+	/* Read the requested video link pattern (Byte 0x221). */
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
+	if (rlen < len) {
+		pr_err("failed to read 0x%x\n", addr);
+		return -EINVAL;
+	}
+
+	*val1 = (bp[0] & BIT(7)) >> 7;
+	*val2 = bp[1] | ((bp[0] & 0x7F) << 8);
+
+	return 0;
+}
+
+static int dp_link_parse_timing_params3(struct dp_link_private *link,
+					int const addr, u32 *val)
+{
+	u8 bp;
+	u32 len = 1;
+	int rlen;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp, len);
+	if (rlen < 1) {
+		pr_err("failed to read 0x%x\n", addr);
+		return -EINVAL;
+	}
+	*val = bp;
+
+	return 0;
+}
+
+/**
+ * dp_parse_video_pattern_params() - parses video pattern parameters from DPCD
+ * @link: Display Port Driver data
+ *
+ * Returns 0 if it successfully parses the video link pattern and the link
+ * bit depth requested by the sink and, and if the values parsed are valid.
+ */
+static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
+{
+	int ret = 0;
+	int rlen;
+	u8 bp;
+	u8 data;
+	u32 dyn_range;
+	int const param_len = 0x1;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PATTERN,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read link video pattern\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+
+	if (!dp_link_is_video_pattern_valid(data)) {
+		pr_err("invalid link video pattern = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->dp_link.test_video.test_video_pattern = data;
+	pr_debug("link video pattern = 0x%x (%s)\n",
+		link->dp_link.test_video.test_video_pattern,
+		dp_link_video_pattern_to_string(
+			link->dp_link.test_video.test_video_pattern));
+
+	/* Read the requested color bit depth and dynamic range (Byte 0x232) */
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_MISC0,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read link bit depth\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+
+	/* Dynamic Range */
+	dyn_range = (data & DP_TEST_DYNAMIC_RANGE_CEA) >> 3;
+	if (!dp_link_is_dynamic_range_valid(dyn_range)) {
+		pr_err("invalid link dynamic range = 0x%x", dyn_range);
+		ret = -EINVAL;
+		goto exit;
+	}
+	link->dp_link.test_video.test_dyn_range = dyn_range;
+	pr_debug("link dynamic range = 0x%x (%s)\n",
+		link->dp_link.test_video.test_dyn_range,
+		dp_link_dynamic_range_to_string(
+			link->dp_link.test_video.test_dyn_range));
+
+	/* Color bit depth */
+	data &= DP_TEST_BIT_DEPTH_MASK;
+	if (!dp_link_is_bit_depth_valid(data)) {
+		pr_err("invalid link bit depth = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->dp_link.test_video.test_bit_depth = data;
+	pr_debug("link bit depth = 0x%x (%s)\n",
+		link->dp_link.test_video.test_bit_depth,
+		dp_link_bit_depth_to_string(
+		link->dp_link.test_video.test_bit_depth));
+
+	/* resolution timing params */
+	ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
+			&link->dp_link.test_video.test_h_total);
+	if (ret) {
+		pr_err("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_H_TOTAL = %d\n", link->dp_link.test_video.test_h_total);
+
+	ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
+			&link->dp_link.test_video.test_v_total);
+	if (ret) {
+		pr_err("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_V_TOTAL = %d\n", link->dp_link.test_video.test_v_total);
+
+	ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
+			&link->dp_link.test_video.test_h_start);
+	if (ret) {
+		pr_err("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_H_START = %d\n", link->dp_link.test_video.test_h_start);
+
+	ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
+			&link->dp_link.test_video.test_v_start);
+	if (ret) {
+		pr_err("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_V_START = %d\n", link->dp_link.test_video.test_v_start);
+
+	ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
+			&link->dp_link.test_video.test_hsync_pol,
+			&link->dp_link.test_video.test_hsync_width);
+	if (ret) {
+		pr_err("failed to parse (DP_TEST_HSYNC_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_HSYNC_POL = %d\n",
+		link->dp_link.test_video.test_hsync_pol);
+	pr_debug("TEST_HSYNC_WIDTH = %d\n",
+		link->dp_link.test_video.test_hsync_width);
+
+	ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
+			&link->dp_link.test_video.test_vsync_pol,
+			&link->dp_link.test_video.test_vsync_width);
+	if (ret) {
+		pr_err("failed to parse (DP_TEST_VSYNC_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_VSYNC_POL = %d\n",
+		link->dp_link.test_video.test_vsync_pol);
+	pr_debug("TEST_VSYNC_WIDTH = %d\n",
+		link->dp_link.test_video.test_vsync_width);
+
+	ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
+			&link->dp_link.test_video.test_h_width);
+	if (ret) {
+		pr_err("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_H_WIDTH = %d\n", link->dp_link.test_video.test_h_width);
+
+	ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
+			&link->dp_link.test_video.test_v_height);
+	if (ret) {
+		pr_err("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
+		goto exit;
+	}
+	pr_debug("TEST_V_HEIGHT = %d\n",
+		link->dp_link.test_video.test_v_height);
+
+	ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
+		&link->dp_link.test_video.test_rr_d);
+	link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
+	if (ret) {
+		pr_err("failed to parse test_rr_d (DP_TEST_MISC1)\n");
+		goto exit;
+	}
+	pr_debug("TEST_REFRESH_DENOMINATOR = %d\n",
+		link->dp_link.test_video.test_rr_d);
+
+	ret = dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR,
+		&link->dp_link.test_video.test_rr_n);
+	if (ret) {
+		pr_err("failed to parse test_rr_n (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
+		goto exit;
+	}
+	pr_debug("TEST_REFRESH_NUMERATOR = %d\n",
+		link->dp_link.test_video.test_rr_n);
+exit:
+	return ret;
+}
+
+/**
+ * dp_link_parse_link_training_params() - parses link training parameters from
+ * DPCD
+ * @link: Display Port Driver data
+ *
+ * Returns 0 if it successfully parses the link rate (Byte 0x219) and lane
+ * count (Byte 0x220), and if these values parse are valid.
+ */
+static int dp_link_parse_link_training_params(struct dp_link_private *link)
+{
+	u8 bp;
+	u8 data;
+	int ret = 0;
+	int rlen;
+	int const param_len = 0x1;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LINK_RATE,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read link rate\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+
+	if (!is_link_rate_valid(data)) {
+		pr_err("invalid link rate = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->request.test_link_rate = data;
+	pr_debug("link rate = 0x%x\n", link->request.test_link_rate);
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LANE_COUNT,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read lane count\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+	data = bp;
+	data &= 0x1F;
+
+	if (!is_lane_count_valid(data)) {
+		pr_err("invalid lane count = 0x%x\n", data);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	link->request.test_lane_count = data;
+	pr_debug("lane count = 0x%x\n", link->request.test_lane_count);
+exit:
+	return ret;
+}
+
+static bool dp_link_is_phy_test_pattern_supported(u32 phy_test_pattern_sel)
+{
+	switch (phy_test_pattern_sel) {
+	case DP_TEST_PHY_PATTERN_NONE:
+	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
+	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
+	case DP_TEST_PHY_PATTERN_PRBS7:
+	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
+	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
+		return true;
+	default:
+		return false;
+	}
+}
+
+/**
+ * dp_parse_phy_test_params() - parses the phy link parameters
+ * @link: Display Port Driver data
+ *
+ * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is being
+ * requested.
+ */
+static int dp_link_parse_phy_test_params(struct dp_link_private *link)
+{
+	u8 bp;
+	u8 data;
+	int rlen;
+	int const param_len = 0x1;
+	int ret = 0;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PHY_PATTERN,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read phy link pattern\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	data = bp;
+
+	link->dp_link.phy_params.phy_test_pattern_sel = data;
+
+	pr_debug("phy_test_pattern_sel = %s\n",
+			dp_link_get_phy_test_pattern(data));
+
+	if (!dp_link_is_phy_test_pattern_supported(data))
+		ret = -EINVAL;
+end:
+	return ret;
+}
+
+static char *dp_link_get_test_name(u32 test_requested)
+{
+	switch (test_requested) {
+	case DP_TEST_LINK_TRAINING:
+		return DP_LINK_ENUM_STR(DP_TEST_LINK_TRAINING);
+	case DP_TEST_LINK_VIDEO_PATTERN:
+		return DP_LINK_ENUM_STR(DP_TEST_LINK_VIDEO_PATTERN);
+	case DP_TEST_LINK_EDID_READ:
+		return DP_LINK_ENUM_STR(DP_TEST_LINK_EDID_READ);
+	case DP_TEST_LINK_PHY_TEST_PATTERN:
+		return DP_LINK_ENUM_STR(DP_TEST_LINK_PHY_TEST_PATTERN);
+	case DP_TEST_LINK_AUDIO_PATTERN:
+		return DP_LINK_ENUM_STR(DP_TEST_LINK_AUDIO_PATTERN);
+	default:
+		return "unknown";
+	}
+}
+
+/**
+ * dp_link_is_video_audio_test_requested() - checks for audio/video link request
+ * @link: link requested by the sink
+ *
+ * Returns true if the requested link is a permitted audio/video link.
+ */
+static bool dp_link_is_video_audio_test_requested(u32 link)
+{
+	return (link == DP_TEST_LINK_VIDEO_PATTERN) ||
+		(link == (DP_TEST_LINK_AUDIO_PATTERN |
+		DP_TEST_LINK_VIDEO_PATTERN)) ||
+		(link == DP_TEST_LINK_AUDIO_PATTERN) ||
+		(link == (DP_TEST_LINK_AUDIO_PATTERN |
+		DP_TEST_LINK_AUDIO_DISABLED_VIDEO));
+}
+
+/**
+ * dp_link_supported() - checks if link requested by sink is supported
+ * @test_requested: link requested by the sink
+ *
+ * Returns true if the requested link is supported.
+ */
+static bool dp_link_is_test_supported(u32 test_requested)
+{
+	return (test_requested == DP_TEST_LINK_TRAINING) ||
+		(test_requested == DP_TEST_LINK_EDID_READ) ||
+		(test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) ||
+		dp_link_is_video_audio_test_requested(test_requested);
+}
+
+static bool dp_link_is_test_edid_read(struct dp_link_private *link)
+{
+	return (link->request.test_requested == DP_TEST_LINK_EDID_READ);
+}
+
+/**
+ * dp_sink_parse_test_request() - parses link request parameters from sink
+ * @link: Display Port Driver data
+ *
+ * Parses the DPCD to check if an automated link is requested (Byte 0x201),
+ * and what type of link automation is being requested (Byte 0x218).
+ */
+static int dp_link_parse_request(struct dp_link_private *link)
+{
+	int ret = 0;
+	u8 bp;
+	u8 data;
+	int rlen;
+	u32 const param_len = 0x1;
+
+	/**
+	 * Read the device service IRQ vector (Byte 0x201) to determine
+	 * whether an automated link has been requested by the sink.
+	 */
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
+		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
+	if (rlen < param_len) {
+		pr_err("aux read failed\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	data = bp;
+
+	pr_debug("device service irq vector = 0x%x\n", data);
+
+	if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
+		pr_debug("no test requested\n");
+		return 0;
+	}
+
+	/**
+	 * Read the link request byte (Byte 0x218) to determine what type
+	 * of automated link has been requested by the sink.
+	 */
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("aux read failed\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	data = bp;
+
+	if (!dp_link_is_test_supported(data)) {
+		pr_debug("link 0x%x not supported\n", data);
+		goto end;
+	}
+
+	pr_debug("%s (0x%x) requested\n", dp_link_get_test_name(data), data);
+	link->request.test_requested = data;
+
+	if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) {
+		ret = dp_link_parse_phy_test_params(link);
+		if (ret)
+			goto end;
+		ret = dp_link_parse_link_training_params(link);
+	}
+
+	if (link->request.test_requested == DP_TEST_LINK_TRAINING)
+		ret = dp_link_parse_link_training_params(link);
+
+	if (dp_link_is_video_audio_test_requested(
+			link->request.test_requested)) {
+		ret = dp_link_parse_video_pattern_params(link);
+		if (ret)
+			goto end;
+
+		ret = dp_link_parse_audio_pattern_params(link);
+	}
+end:
+	/**
+	 * Send a DP_TEST_ACK if all link parameters are valid, otherwise send
+	 * a DP_TEST_NAK.
+	 */
+	if (ret) {
+		link->dp_link.test_response = DP_TEST_NAK;
+	} else {
+		if (!dp_link_is_test_edid_read(link))
+			link->dp_link.test_response = DP_TEST_ACK;
+		else
+			link->dp_link.test_response =
+				DP_TEST_EDID_CHECKSUM_WRITE;
+	}
+
+	return ret;
+}
+
+/**
+ * dp_link_parse_sink_count() - parses the sink count
+ *
+ * Parses the DPCD to check if there is an update to the sink count
+ * (Byte 0x200), and whether all the sink devices connected have Content
+ * Protection enabled.
+ */
+static int dp_link_parse_sink_count(struct dp_link *dp_link)
+{
+	int rlen;
+	int const param_len = 0x1;
+	struct dp_link_private *link = container_of(dp_link,
+			struct dp_link_private, dp_link);
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_SINK_COUNT,
+			&link->dp_link.sink_count.count, param_len);
+	if (rlen < param_len) {
+		pr_err("failed to read sink count\n");
+		return -EINVAL;
+	}
+
+	link->dp_link.sink_count.cp_ready =
+		link->dp_link.sink_count.count & DP_SINK_CP_READY;
+	/* BIT 7, BIT 5:0 */
+	link->dp_link.sink_count.count =
+		DP_GET_SINK_COUNT(link->dp_link.sink_count.count);
+
+	pr_debug("sink_count = 0x%x, cp_ready = 0x%x\n",
+		link->dp_link.sink_count.count,
+		link->dp_link.sink_count.cp_ready);
+	return 0;
+}
+
+static void dp_link_parse_sink_status_field(struct dp_link_private *link)
+{
+	int len = 0;
+
+	link->prev_sink_count = link->dp_link.sink_count.count;
+	dp_link_parse_sink_count(&link->dp_link);
+
+	len = drm_dp_dpcd_read_link_status(link->aux->drm_aux,
+		link->link_status);
+	if (len < DP_LINK_STATUS_SIZE)
+		pr_err("DP link status read failed\n");
+	dp_link_parse_request(link);
+}
+
+static bool dp_link_is_link_training_requested(struct dp_link_private *link)
+{
+	return (link->request.test_requested == DP_TEST_LINK_TRAINING);
+}
+
+/**
+ * dp_link_process_link_training_request() - processes new training requests
+ * @link: Display Port link data
+ *
+ * This function will handle new link training requests that are initiated by
+ * the sink. In particular, it will update the requested lane count and link
+ * link rate, and then trigger the link retraining procedure.
+ *
+ * The function will return 0 if a link training request has been processed,
+ * otherwise it will return -EINVAL.
+ */
+static int dp_link_process_link_training_request(struct dp_link_private *link)
+{
+	if (!dp_link_is_link_training_requested(link))
+		return -EINVAL;
+
+	pr_debug("%s link rate = 0x%x, lane count = 0x%x\n",
+			dp_link_get_test_name(DP_TEST_LINK_TRAINING),
+			link->request.test_link_rate,
+			link->request.test_lane_count);
+
+	link->dp_link.link_params.lane_count = link->request.test_lane_count;
+	link->dp_link.link_params.bw_code = link->request.test_link_rate;
+
+	return 0;
+}
+
+static void dp_link_send_test_response(struct dp_link *dp_link)
+{
+	struct dp_link_private *link = NULL;
+	u32 const response_len = 0x1;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
+			&dp_link->test_response, response_len);
+}
+
+static int dp_link_psm_config(struct dp_link *dp_link,
+			      struct drm_dp_link *link_info, bool enable)
+{
+	struct dp_link_private *link = NULL;
+	int ret = 0;
+
+	if (!dp_link) {
+		pr_err("invalid params\n");
+		return -EINVAL;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	if (enable)
+		ret = drm_dp_link_power_down(link->aux->drm_aux, link_info);
+	else
+		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
+
+	if (ret)
+		pr_err("Failed to %s low power mode\n",
+			(enable ? "enter" : "exit"));
+	else
+		dp_link->psm_enabled = enable;
+
+	return ret;
+}
+
+static void dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum)
+{
+	struct dp_link_private *link = NULL;
+	u32 const response_len = 0x1;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_EDID_CHECKSUM,
+			&checksum, response_len);
+}
+
+static int dp_link_parse_vx_px(struct dp_link_private *link)
+{
+	u8 bp;
+	u8 data;
+	int const param_len = 0x1;
+	int ret = 0;
+	u32 v0, p0, v1, p1, v2, p2, v3, p3;
+	int rlen;
+
+	pr_debug("\n");
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE0_1,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed reading lanes 0/1\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	data = bp;
+
+	pr_debug("lanes 0/1 (Byte 0x206): 0x%x\n", data);
+
+	v0 = data & 0x3;
+	data = data >> 2;
+	p0 = data & 0x3;
+	data = data >> 2;
+
+	v1 = data & 0x3;
+	data = data >> 2;
+	p1 = data & 0x3;
+	data = data >> 2;
+
+	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE2_3,
+			&bp, param_len);
+	if (rlen < param_len) {
+		pr_err("failed reading lanes 2/3\n");
+		ret = -EINVAL;
+		goto end;
+	}
+
+	data = bp;
+
+	pr_debug("lanes 2/3 (Byte 0x207): 0x%x\n", data);
+
+	v2 = data & 0x3;
+	data = data >> 2;
+	p2 = data & 0x3;
+	data = data >> 2;
+
+	v3 = data & 0x3;
+	data = data >> 2;
+	p3 = data & 0x3;
+	data = data >> 2;
+
+	pr_debug("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
+	pr_debug("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
+
+	/**
+	 * Update the voltage and pre-emphasis levels as per DPCD request
+	 * vector.
+	 */
+	pr_debug("Current: v_level = 0x%x, p_level = 0x%x\n",
+			link->dp_link.phy_params.v_level,
+			link->dp_link.phy_params.p_level);
+	pr_debug("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
+	link->dp_link.phy_params.v_level = v0;
+	link->dp_link.phy_params.p_level = p0;
+
+	pr_debug("Success\n");
+end:
+	return ret;
+}
+
+/**
+ * dp_link_process_phy_test_pattern_request() - process new phy link requests
+ * @link: Display Port Driver data
+ *
+ * This function will handle new phy link pattern requests that are initiated
+ * by the sink. The function will return 0 if a phy link pattern has been
+ * processed, otherwise it will return -EINVAL.
+ */
+static int dp_link_process_phy_test_pattern_request(
+		struct dp_link_private *link)
+{
+	u32 test_link_rate = 0, test_lane_count = 0;
+
+	if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) {
+		pr_debug("no phy test\n");
+		return -EINVAL;
+	}
+
+	test_link_rate = link->request.test_link_rate;
+	test_lane_count = link->request.test_lane_count;
+
+	if (!is_link_rate_valid(test_link_rate) ||
+		!is_lane_count_valid(test_lane_count)) {
+		pr_err("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
+				test_link_rate, test_lane_count);
+		return -EINVAL;
+	}
+
+	pr_debug("start\n");
+
+	pr_info("Current: bw_code = 0x%x, lane count = 0x%x\n",
+			link->dp_link.link_params.bw_code,
+			link->dp_link.link_params.lane_count);
+
+	pr_info("Requested: bw_code = 0x%x, lane count = 0x%x\n",
+			test_link_rate, test_lane_count);
+
+	link->dp_link.link_params.lane_count = link->request.test_lane_count;
+	link->dp_link.link_params.bw_code = link->request.test_link_rate;
+
+	dp_link_parse_vx_px(link);
+
+	pr_debug("end\n");
+
+	return 0;
+}
+
+static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r)
+{
+	return link_status[r - DP_LANE0_1_STATUS];
+}
+
+/**
+ * dp_link_process_link_status_update() - processes link status updates
+ * @link: Display Port link module data
+ *
+ * This function will check for changes in the link status, e.g. clock
+ * recovery done on all lanes, and trigger link training if there is a
+ * failure/error on the link.
+ *
+ * The function will return 0 if the a link status update has been processed,
+ * otherwise it will return -EINVAL.
+ */
+static int dp_link_process_link_status_update(struct dp_link_private *link)
+{
+	if (!(get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) &
+		DP_LINK_STATUS_UPDATED) || /* link status updated */
+		(drm_dp_clock_recovery_ok(link->link_status,
+			link->dp_link.link_params.lane_count) &&
+	     drm_dp_channel_eq_ok(link->link_status,
+			link->dp_link.link_params.lane_count)))
+		return -EINVAL;
+
+	pr_debug("channel_eq_done = %d, clock_recovery_done = %d\n",
+			drm_dp_clock_recovery_ok(link->link_status,
+			link->dp_link.link_params.lane_count),
+			drm_dp_clock_recovery_ok(link->link_status,
+			link->dp_link.link_params.lane_count));
+
+	return 0;
+}
+
+static bool dp_link_is_ds_port_status_changed(struct dp_link_private *link)
+{
+	if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) &
+		DP_DOWNSTREAM_PORT_STATUS_CHANGED) /* port status changed */
+		return true;
+
+	if (link->prev_sink_count != link->dp_link.sink_count.count)
+		return true;
+
+	return false;
+}
+
+/**
+ * dp_link_process_downstream_port_status_change() - process port status changes
+ * @link: Display Port Driver data
+ *
+ * This function will handle downstream port updates that are initiated by
+ * the sink. If the downstream port status has changed, the EDID is read via
+ * AUX.
+ *
+ * The function will return 0 if a downstream port update has been
+ * processed, otherwise it will return -EINVAL.
+ */
+static int dp_link_process_ds_port_status_change(struct dp_link_private *link)
+{
+	if (!dp_link_is_ds_port_status_changed(link))
+		return -EINVAL;
+
+	/* reset prev_sink_count */
+	link->prev_sink_count = link->dp_link.sink_count.count;
+
+	return 0;
+}
+
+static bool dp_link_is_video_pattern_requested(struct dp_link_private *link)
+{
+	return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN)
+		&& !(link->request.test_requested &
+		DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
+}
+
+static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link)
+{
+	return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN);
+}
+
+/**
+ * dp_link_process_video_pattern_request() - process new video pattern request
+ * @link: Display Port link module's data
+ *
+ * This function will handle a new video pattern request that are initiated by
+ * the sink. This is acheieved by first sending a disconnect notification to
+ * the sink followed by a subsequent connect notification to the user modules,
+ * where it is expected that the user modules would draw the required link
+ * pattern.
+ */
+static int dp_link_process_video_pattern_request(struct dp_link_private *link)
+{
+	if (!dp_link_is_video_pattern_requested(link))
+		goto end;
+
+	pr_debug("%s: bit depth=%d(%d bpp) pattern=%s\n",
+		dp_link_get_test_name(DP_TEST_LINK_VIDEO_PATTERN),
+		link->dp_link.test_video.test_bit_depth,
+		dp_link_bit_depth_to_bpp(
+		link->dp_link.test_video.test_bit_depth),
+		dp_link_video_pattern_to_string(
+			link->dp_link.test_video.test_video_pattern));
+
+	return 0;
+end:
+	return -EINVAL;
+}
+
+/**
+ * dp_link_process_audio_pattern_request() - process new audio pattern request
+ * @link: Display Port link module data
+ *
+ * This function will handle a new audio pattern request that is initiated by
+ * the sink. This is acheieved by sending the necessary secondary data packets
+ * to the sink. It is expected that any simulatenous requests for video
+ * patterns will be handled before the audio pattern is sent to the sink.
+ */
+static int dp_link_process_audio_pattern_request(struct dp_link_private *link)
+{
+	if (!dp_link_is_audio_pattern_requested(link))
+		return -EINVAL;
+
+	pr_debug("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
+		dp_link_get_audio_sample_rate(
+			link->dp_link.test_audio.test_audio_sampling_rate),
+		link->dp_link.test_audio.test_audio_channel_count,
+		dp_link_get_audio_test_pattern(
+			link->dp_link.test_audio.test_audio_pattern_type));
+
+	pr_debug("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
+		link->dp_link.test_audio.test_audio_period_ch_1,
+		link->dp_link.test_audio.test_audio_period_ch_2,
+		link->dp_link.test_audio.test_audio_period_ch_3,
+		link->dp_link.test_audio.test_audio_period_ch_4);
+
+	pr_debug("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
+		link->dp_link.test_audio.test_audio_period_ch_5,
+		link->dp_link.test_audio.test_audio_period_ch_6,
+		link->dp_link.test_audio.test_audio_period_ch_7,
+		link->dp_link.test_audio.test_audio_period_ch_8);
+
+	return 0;
+}
+
+static void dp_link_reset_data(struct dp_link_private *link)
+{
+	link->request = (const struct dp_link_request){ 0 };
+	link->dp_link.test_video = (const struct dp_link_test_video){ 0 };
+	link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN;
+	link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 };
+	link->dp_link.phy_params.phy_test_pattern_sel = 0;
+	link->dp_link.sink_request = 0;
+	link->dp_link.test_response = 0;
+}
+
+/**
+ * dp_link_process_request() - handle HPD IRQ transition to HIGH
+ * @link: pointer to link module data
+ *
+ * This function will handle the HPD IRQ state transitions from LOW to HIGH
+ * (including cases when there are back to back HPD IRQ HIGH) indicating
+ * the start of a new link training request or sink status update.
+ */
+static int dp_link_process_request(struct dp_link *dp_link)
+{
+	int ret = 0;
+	struct dp_link_private *link;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	pr_debug("start\n");
+
+	dp_link_reset_data(link);
+
+	dp_link_parse_sink_status_field(link);
+
+	if (dp_link_is_test_edid_read(link)) {
+		dp_link->sink_request |= DP_TEST_LINK_EDID_READ;
+		goto exit;
+	}
+
+	ret = dp_link_process_ds_port_status_change(link);
+	if (!ret) {
+		dp_link->sink_request |= DS_PORT_STATUS_CHANGED;
+		goto exit;
+	}
+
+	ret = dp_link_process_link_training_request(link);
+	if (!ret) {
+		dp_link->sink_request |= DP_TEST_LINK_TRAINING;
+		goto exit;
+	}
+
+	ret = dp_link_process_phy_test_pattern_request(link);
+	if (!ret) {
+		dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN;
+		goto exit;
+	}
+
+	ret = dp_link_process_link_status_update(link);
+	if (!ret) {
+		dp_link->sink_request |= DP_LINK_STATUS_UPDATED;
+		goto exit;
+	}
+
+	ret = dp_link_process_video_pattern_request(link);
+	if (!ret) {
+		dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN;
+		goto exit;
+	}
+
+	ret = dp_link_process_audio_pattern_request(link);
+	if (!ret) {
+		dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN;
+		goto exit;
+	}
+
+	pr_debug("done\n");
+exit:
+	return ret;
+}
+
+static int dp_link_get_colorimetry_config(struct dp_link *dp_link)
+{
+	u32 cc;
+	enum dynamic_range dr;
+	struct dp_link_private *link;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	/* unless a video pattern CTS test is ongoing, use CEA_VESA */
+	if (dp_link_is_video_pattern_requested(link))
+		dr = link->dp_link.test_video.test_dyn_range;
+	else
+		dr = DP_DYNAMIC_RANGE_RGB_VESA;
+
+	/* Only RGB_VESA nd RGB_CEA supported for now */
+	switch (dr) {
+	case DP_DYNAMIC_RANGE_RGB_CEA:
+		cc = BIT(3);
+		break;
+	case DP_DYNAMIC_RANGE_RGB_VESA:
+	default:
+		cc = 0;
+	}
+
+	return cc;
+}
+
+static int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status)
+{
+	int i;
+	int max = 0;
+	u8 data;
+	struct dp_link_private *link;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	/* use the max level across lanes */
+	for (i = 0; i < dp_link->link_params.lane_count; i++) {
+		data = drm_dp_get_adjust_request_voltage(link_status, i);
+		pr_debug("lane=%d req_voltage_swing=%d\n", i, data);
+		if (max < data)
+			max = data;
+	}
+
+	dp_link->phy_params.v_level = max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
+
+	/* use the max level across lanes */
+	max = 0;
+	for (i = 0; i < dp_link->link_params.lane_count; i++) {
+		data = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
+		pr_debug("lane=%d req_pre_emphasis=%d\n", i, data);
+		if (max < data)
+			max = data;
+	}
+
+	dp_link->phy_params.p_level = max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
+
+	/**
+	 * Adjust the voltage swing and pre-emphasis level combination to within
+	 * the allowable range.
+	 */
+	if (dp_link->phy_params.v_level > DP_LINK_VOLTAGE_MAX) {
+		pr_debug("Requested vSwingLevel=%d, change to %d\n",
+			dp_link->phy_params.v_level, DP_LINK_VOLTAGE_MAX);
+		dp_link->phy_params.v_level = DP_LINK_VOLTAGE_MAX;
+	}
+
+	if (dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_MAX) {
+		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
+			dp_link->phy_params.p_level, DP_LINK_PRE_EMPHASIS_MAX);
+		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_MAX;
+	}
+
+	if ((dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_LEVEL_1)
+		&& (dp_link->phy_params.v_level == DP_LINK_VOLTAGE_LEVEL_2)) {
+		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
+			dp_link->phy_params.p_level,
+			DP_LINK_PRE_EMPHASIS_LEVEL_1);
+		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_LEVEL_1;
+	}
+
+	pr_debug("adjusted: v_level=%d, p_level=%d\n",
+		dp_link->phy_params.v_level, dp_link->phy_params.p_level);
+
+	return 0;
+}
+
+static int dp_link_send_psm_request(struct dp_link *dp_link, bool req)
+{
+	struct dp_link_private *link;
+
+	if (!dp_link) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	return 0;
+}
+
+static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp)
+{
+	u32 tbd;
+
+	/*
+	 * Few simplistic rules and assumptions made here:
+	 *    1. Test bit depth is bit depth per color component
+	 *    2. Assume 3 color components
+	 */
+	switch (bpp) {
+	case 18:
+		tbd = DP_TEST_BIT_DEPTH_6;
+		break;
+	case 24:
+		tbd = DP_TEST_BIT_DEPTH_8;
+		break;
+	case 30:
+		tbd = DP_TEST_BIT_DEPTH_10;
+		break;
+	default:
+		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
+		break;
+	}
+
+	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
+		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
+
+	return tbd;
+}
+
+struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
+{
+	int rc = 0;
+	struct dp_link_private *link;
+	struct dp_link *dp_link;
+
+	if (!dev || !aux) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
+	if (!link) {
+		rc = -EINVAL;
+		goto error;
+	}
+
+	link->dev   = dev;
+	link->aux   = aux;
+
+	dp_link = &link->dp_link;
+
+	dp_link->process_request        = dp_link_process_request;
+	dp_link->get_test_bits_depth    = dp_link_get_test_bits_depth;
+	dp_link->get_colorimetry_config = dp_link_get_colorimetry_config;
+	dp_link->adjust_levels          = dp_link_adjust_levels;
+	dp_link->send_psm_request       = dp_link_send_psm_request;
+	dp_link->send_test_response     = dp_link_send_test_response;
+	dp_link->psm_config             = dp_link_psm_config;
+	dp_link->send_edid_checksum     = dp_link_send_edid_checksum;
+
+	return dp_link;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_link_put(struct dp_link *dp_link)
+{
+	struct dp_link_private *link;
+
+	if (!dp_link)
+		return;
+
+	link = container_of(dp_link, struct dp_link_private, dp_link);
+
+	devm_kfree(link->dev, link);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_link.h b/drivers/gpu/drm/msm/dp/dp_link.h
new file mode 100644
index 0000000..6d6ef43
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_link.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_LINK_H_
+#define _DP_LINK_H_
+
+#include "dp_aux.h"
+
+#define DS_PORT_STATUS_CHANGED 0x200
+#define DP_TEST_BIT_DEPTH_UNKNOWN 0xFFFFFFFF
+#define DP_LINK_ENUM_STR(x)		#x
+
+enum dp_link_voltage_level {
+	DP_LINK_VOLTAGE_LEVEL_0	= 0,
+	DP_LINK_VOLTAGE_LEVEL_1	= 1,
+	DP_LINK_VOLTAGE_LEVEL_2	= 2,
+	DP_LINK_VOLTAGE_MAX	= DP_LINK_VOLTAGE_LEVEL_2,
+};
+
+enum dp_link_preemaphasis_level {
+	DP_LINK_PRE_EMPHASIS_LEVEL_0	= 0,
+	DP_LINK_PRE_EMPHASIS_LEVEL_1	= 1,
+	DP_LINK_PRE_EMPHASIS_LEVEL_2	= 2,
+	DP_LINK_PRE_EMPHASIS_MAX	= DP_LINK_PRE_EMPHASIS_LEVEL_2,
+};
+
+struct dp_link_sink_count {
+	u32 count;
+	bool cp_ready;
+};
+
+struct dp_link_test_video {
+	u32 test_video_pattern;
+	u32 test_bit_depth;
+	u32 test_dyn_range;
+	u32 test_h_total;
+	u32 test_v_total;
+	u32 test_h_start;
+	u32 test_v_start;
+	u32 test_hsync_pol;
+	u32 test_hsync_width;
+	u32 test_vsync_pol;
+	u32 test_vsync_width;
+	u32 test_h_width;
+	u32 test_v_height;
+	u32 test_rr_d;
+	u32 test_rr_n;
+};
+
+struct dp_link_test_audio {
+	u32 test_audio_sampling_rate;
+	u32 test_audio_channel_count;
+	u32 test_audio_pattern_type;
+	u32 test_audio_period_ch_1;
+	u32 test_audio_period_ch_2;
+	u32 test_audio_period_ch_3;
+	u32 test_audio_period_ch_4;
+	u32 test_audio_period_ch_5;
+	u32 test_audio_period_ch_6;
+	u32 test_audio_period_ch_7;
+	u32 test_audio_period_ch_8;
+};
+
+struct dp_link_phy_params {
+	u32 phy_test_pattern_sel;
+	u8 v_level;
+	u8 p_level;
+};
+
+struct dp_link_params {
+	u32 lane_count;
+	u32 bw_code;
+};
+
+struct dp_link {
+	u32 sink_request;
+	u32 test_response;
+	bool psm_enabled;
+
+	struct dp_link_sink_count sink_count;
+	struct dp_link_test_video test_video;
+	struct dp_link_test_audio test_audio;
+	struct dp_link_phy_params phy_params;
+	struct dp_link_params link_params;
+
+	u32 (*get_test_bits_depth)(struct dp_link *dp_link, u32 bpp);
+	int (*process_request)(struct dp_link *dp_link);
+	int (*get_colorimetry_config)(struct dp_link *dp_link);
+	int (*adjust_levels)(struct dp_link *dp_link, u8 *link_status);
+	int (*send_psm_request)(struct dp_link *dp_link, bool req);
+	void (*send_test_response)(struct dp_link *dp_link);
+	int (*psm_config)(struct dp_link *dp_link,
+		struct drm_dp_link *link_info, bool enable);
+	void (*send_edid_checksum)(struct dp_link *dp_link, u8 checksum);
+};
+
+static inline char *dp_link_get_phy_test_pattern(u32 phy_test_pattern_sel)
+{
+	switch (phy_test_pattern_sel) {
+	case DP_TEST_PHY_PATTERN_NONE:
+		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_NONE);
+	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
+		return DP_LINK_ENUM_STR(
+			DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING);
+	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
+		return DP_LINK_ENUM_STR(
+			DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT);
+	case DP_TEST_PHY_PATTERN_PRBS7:
+		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_PRBS7);
+	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
+		return DP_LINK_ENUM_STR(
+			DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN);
+	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
+		return DP_LINK_ENUM_STR(
+			DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN);
+	default:
+		return "unknown";
+	}
+}
+
+/**
+ * mdss_dp_test_bit_depth_to_bpp() - convert test bit depth to bpp
+ * @tbd: test bit depth
+ *
+ * Returns the bits per pixel (bpp) to be used corresponding to the
+ * git bit depth value. This function assumes that bit depth has
+ * already been validated.
+ */
+static inline u32 dp_link_bit_depth_to_bpp(u32 tbd)
+{
+	u32 bpp;
+
+	/*
+	 * Few simplistic rules and assumptions made here:
+	 *    1. Bit depth is per color component
+	 *    2. If bit depth is unknown return 0
+	 *    3. Assume 3 color components
+	 */
+	switch (tbd) {
+	case DP_TEST_BIT_DEPTH_6:
+		bpp = 18;
+		break;
+	case DP_TEST_BIT_DEPTH_8:
+		bpp = 24;
+		break;
+	case DP_TEST_BIT_DEPTH_10:
+		bpp = 30;
+		break;
+	case DP_TEST_BIT_DEPTH_UNKNOWN:
+	default:
+		bpp = 0;
+	}
+
+	return bpp;
+}
+
+/**
+ * dp_link_get() - get the functionalities of dp test module
+ *
+ *
+ * return: a pointer to dp_link struct
+ */
+struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux);
+
+/**
+ * dp_link_put() - releases the dp test module's resources
+ *
+ * @dp_link: an instance of dp_link module
+ *
+ */
+void dp_link_put(struct dp_link *dp_link);
+
+#endif /* _DP_LINK_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_panel.c b/drivers/gpu/drm/msm/dp/dp_panel.c
new file mode 100644
index 0000000..e497b44
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_panel.c
@@ -0,0 +1,624 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include "dp_panel.h"
+
+#include <drm/drm_connector.h>
+#include <drm/drm_edid.h>
+
+#define DP_PANEL_DEFAULT_BPP 24
+#define DP_MAX_DS_PORT_COUNT 1
+
+enum {
+	DP_LINK_RATE_MULTIPLIER = 27000000,
+};
+
+struct dp_panel_private {
+	struct device *dev;
+	struct dp_panel dp_panel;
+	struct dp_aux *aux;
+	struct dp_link *link;
+	struct dp_catalog_panel *catalog;
+	bool panel_on;
+	bool aux_cfg_update_done;
+};
+
+static const struct dp_panel_info fail_safe = {
+	.h_active = 640,
+	.v_active = 480,
+	.h_back_porch = 48,
+	.h_front_porch = 16,
+	.h_sync_width = 96,
+	.h_active_low = 0,
+	.v_back_porch = 33,
+	.v_front_porch = 10,
+	.v_sync_width = 2,
+	.v_active_low = 0,
+	.h_skew = 0,
+	.refresh_rate = 60,
+	.pixel_clk_khz = 25200,
+	.bpp = 24,
+};
+
+static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
+{
+	int rlen, rc = 0;
+	struct dp_panel_private *panel;
+	struct drm_dp_link *link_info;
+	u8 *dpcd, major = 0, minor = 0;
+	u32 dfp_count = 0;
+	unsigned long caps = DP_LINK_CAP_ENHANCED_FRAMING;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	dpcd = dp_panel->dpcd;
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+	link_info = &dp_panel->link_info;
+
+	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DPCD_REV,
+		dpcd, (DP_RECEIVER_CAP_SIZE + 1));
+	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
+		pr_err("dpcd read failed, rlen=%d\n", rlen);
+		rc = -EINVAL;
+		goto end;
+	}
+
+	link_info->revision = dp_panel->dpcd[DP_DPCD_REV];
+
+	major = (link_info->revision >> 4) & 0x0f;
+	minor = link_info->revision & 0x0f;
+	pr_debug("version: %d.%d\n", major, minor);
+
+	link_info->rate =
+		drm_dp_bw_code_to_link_rate(dp_panel->dpcd[DP_MAX_LINK_RATE]);
+	pr_debug("link_rate=%d\n", link_info->rate);
+
+	link_info->num_lanes = dp_panel->dpcd[DP_MAX_LANE_COUNT] &
+				DP_MAX_LANE_COUNT_MASK;
+
+	pr_debug("lane_count=%d\n", link_info->num_lanes);
+
+	if (drm_dp_enhanced_frame_cap(dpcd))
+		link_info->capabilities |= caps;
+
+	dfp_count = dpcd[DP_DOWN_STREAM_PORT_COUNT] &
+						DP_DOWN_STREAM_PORT_COUNT;
+
+	if ((dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)
+		&& (dpcd[DP_DPCD_REV] > 0x10)) {
+		rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
+			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
+			DP_MAX_DOWNSTREAM_PORTS);
+		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
+			pr_err("ds port status failed, rlen=%d\n", rlen);
+			rc = -EINVAL;
+			goto end;
+		}
+	}
+
+	if (dfp_count > DP_MAX_DS_PORT_COUNT)
+		pr_debug("DS port count %d greater that max (%d) supported\n",
+			dfp_count, DP_MAX_DS_PORT_COUNT);
+
+end:
+	return rc;
+}
+
+static int dp_panel_set_default_link_params(struct dp_panel *dp_panel)
+{
+	struct drm_dp_link *link_info;
+	const int default_bw_code = 162000;
+	const int default_num_lanes = 1;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+	link_info = &dp_panel->link_info;
+	link_info->rate = default_bw_code;
+	link_info->num_lanes = default_num_lanes;
+	pr_debug("link_rate=%d num_lanes=%d\n",
+		link_info->rate, link_info->num_lanes);
+	return 0;
+}
+
+static int dp_panel_read_edid(struct dp_panel *dp_panel,
+	struct drm_connector *connector)
+{
+	int retry_cnt = 0;
+	const int max_retry = 10;
+	struct dp_panel_private *panel;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	do {
+		kfree(dp_panel->edid);
+		dp_panel->edid = drm_get_edid(connector,
+					      &panel->aux->drm_aux->ddc);
+		if (!dp_panel->edid) {
+			pr_err("EDID read failed\n");
+			retry_cnt++;
+			panel->aux->reconfig(panel->aux);
+			panel->aux_cfg_update_done = true;
+		} else {
+			return 0;
+		}
+	} while (retry_cnt < max_retry);
+
+	return -EINVAL;
+}
+
+static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
+	struct drm_connector *connector)
+{
+	int rc = 0;
+	struct dp_panel_private *panel;
+
+	if (!dp_panel || !connector) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	rc = dp_panel_read_dpcd(dp_panel);
+	if (rc || !is_link_rate_valid(drm_dp_link_rate_to_bw_code(
+		dp_panel->link_info.rate)) || !is_lane_count_valid(
+		dp_panel->link_info.num_lanes) ||
+		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
+		dp_panel->max_bw_code)) {
+		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
+			pr_err("DPCD read failed, return early\n");
+			return rc;
+		}
+		pr_err("panel dpcd read failed/incorrect, set default params\n");
+		dp_panel_set_default_link_params(dp_panel);
+	}
+
+	rc = dp_panel_read_edid(dp_panel, connector);
+	if (rc) {
+		pr_err("panel edid read failed, set failsafe mode\n");
+		return rc;
+	}
+
+	if (panel->aux_cfg_update_done) {
+		pr_debug("read DPCD with updated AUX config\n");
+		dp_panel_read_dpcd(dp_panel);
+		panel->aux_cfg_update_done = false;
+	}
+
+	return 0;
+}
+
+static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
+		u32 mode_edid_bpp, u32 mode_pclk_khz)
+{
+	struct drm_dp_link *link_info;
+	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
+	u32 bpp = 0, data_rate_khz = 0;
+
+	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
+
+	link_info = &dp_panel->link_info;
+	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
+
+	while (bpp > min_supported_bpp) {
+		if (mode_pclk_khz * bpp <= data_rate_khz)
+			break;
+		bpp -= 6;
+	}
+
+	return bpp;
+}
+
+static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
+		u32 mode_edid_bpp, u32 mode_pclk_khz)
+{
+	struct dp_panel_private *panel;
+	u32 bpp = mode_edid_bpp;
+
+	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
+		pr_err("invalid input\n");
+		return 0;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	if (dp_panel->video_test)
+		bpp = dp_link_bit_depth_to_bpp(
+				panel->link->test_video.test_bit_depth);
+	else
+		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
+				mode_pclk_khz);
+
+	return bpp;
+}
+
+static void dp_panel_set_test_mode(struct dp_panel_private *panel,
+		struct dp_display_mode *mode)
+{
+	struct dp_panel_info *pinfo = NULL;
+	struct dp_link_test_video *test_info = NULL;
+
+	if (!panel) {
+		pr_err("invalid params\n");
+		return;
+	}
+
+	pinfo = &mode->timing;
+	test_info = &panel->link->test_video;
+
+	pinfo->h_active = test_info->test_h_width;
+	pinfo->h_sync_width = test_info->test_hsync_width;
+	pinfo->h_back_porch = test_info->test_h_start -
+		test_info->test_hsync_width;
+	pinfo->h_front_porch = test_info->test_h_total -
+		(test_info->test_h_start + test_info->test_h_width);
+
+	pinfo->v_active = test_info->test_v_height;
+	pinfo->v_sync_width = test_info->test_vsync_width;
+	pinfo->v_back_porch = test_info->test_v_start -
+		test_info->test_vsync_width;
+	pinfo->v_front_porch = test_info->test_v_total -
+		(test_info->test_v_start + test_info->test_v_height);
+
+	pinfo->bpp = dp_link_bit_depth_to_bpp(test_info->test_bit_depth);
+	pinfo->h_active_low = test_info->test_hsync_pol;
+	pinfo->v_active_low = test_info->test_vsync_pol;
+
+	pinfo->refresh_rate = test_info->test_rr_n;
+	pinfo->pixel_clk_khz = test_info->test_h_total *
+		test_info->test_v_total * pinfo->refresh_rate;
+
+	if (test_info->test_rr_d == 0)
+		pinfo->pixel_clk_khz /= 1000;
+	else
+		pinfo->pixel_clk_khz /= 1001;
+
+	if (test_info->test_h_width == 640)
+		pinfo->pixel_clk_khz = 25170;
+}
+
+static int dp_panel_update_modes(struct drm_connector *connector,
+	struct edid *edid)
+{
+	int rc = 0;
+
+	pr_debug("%s +", __func__);
+	if (edid) {
+		drm_connector_update_edid_property(connector,
+			edid);
+		rc = drm_add_edid_modes(connector, edid);
+		pr_debug("%s -", __func__);
+		return rc;
+	}
+
+	drm_connector_update_edid_property(connector, NULL);
+	pr_debug("%s null edid -", __func__);
+	return rc;
+}
+
+static int dp_panel_get_modes(struct dp_panel *dp_panel,
+	struct drm_connector *connector, struct dp_display_mode *mode)
+{
+	struct dp_panel_private *panel;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		return -EINVAL;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	if (dp_panel->video_test) {
+		dp_panel_set_test_mode(panel, mode);
+		return 1;
+	} else if (dp_panel->edid) {
+	  return dp_panel_update_modes(connector, dp_panel->edid);
+	}
+
+	/* fail-safe mode */
+	memcpy(&mode->timing, &fail_safe,
+		sizeof(fail_safe));
+	return 1;
+}
+
+static u8 dp_panel_get_edid_checksum(struct edid *edid)
+{
+	struct edid *last_block = NULL;
+	u8 *raw_edid = NULL;
+
+	if (!edid) {
+		pr_err("invalid edid input\n");
+		return 0;
+	}
+
+	raw_edid = (u8 *)edid;
+	raw_edid += (edid->extensions * EDID_LENGTH);
+	last_block = (struct edid *)raw_edid;
+
+	if (last_block)
+		return last_block->checksum;
+
+	pr_err("Invalid block, no checksum\n");
+	return 0;
+}
+
+static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
+{
+	struct dp_panel_private *panel;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
+		u8 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
+
+		panel->link->send_edid_checksum(panel->link, checksum);
+		panel->link->send_test_response(panel->link);
+	}
+}
+
+static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
+{
+	u32 hsync_start_x, hsync_end_x;
+	struct dp_catalog_panel *catalog;
+	struct dp_panel_private *panel;
+	struct dp_panel_info *pinfo;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		return;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+	catalog = panel->catalog;
+	pinfo = &panel->dp_panel.pinfo;
+
+	if (!panel->panel_on) {
+		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
+		return;
+	}
+
+	if (!enable) {
+		panel->catalog->tpg_config(catalog, false);
+		return;
+	}
+
+	/* TPG config */
+	catalog->hsync_period = pinfo->h_sync_width + pinfo->h_back_porch +
+			pinfo->h_active + pinfo->h_front_porch;
+	catalog->vsync_period = pinfo->v_sync_width + pinfo->v_back_porch +
+			pinfo->v_active + pinfo->v_front_porch;
+
+	catalog->display_v_start = ((pinfo->v_sync_width +
+			pinfo->v_back_porch) * catalog->hsync_period);
+	catalog->display_v_end = ((catalog->vsync_period -
+			pinfo->v_front_porch) * catalog->hsync_period) - 1;
+
+	catalog->display_v_start += pinfo->h_sync_width + pinfo->h_back_porch;
+	catalog->display_v_end -= pinfo->h_front_porch;
+
+	hsync_start_x = pinfo->h_back_porch + pinfo->h_sync_width;
+	hsync_end_x = catalog->hsync_period - pinfo->h_front_porch - 1;
+
+	catalog->v_sync_width = pinfo->v_sync_width;
+
+	catalog->hsync_ctl = (catalog->hsync_period << 16) |
+			pinfo->h_sync_width;
+	catalog->display_hctl = (hsync_end_x << 16) | hsync_start_x;
+
+	pr_err("%s: calling catalog tpg_config\n", __func__);
+	panel->catalog->tpg_config(catalog, true);
+}
+
+static int dp_panel_timing_cfg(struct dp_panel *dp_panel)
+{
+	int rc = 0;
+	u32 data, total_ver, total_hor;
+	struct dp_catalog_panel *catalog;
+	struct dp_panel_private *panel;
+	struct dp_panel_info *pinfo;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+	catalog = panel->catalog;
+	pinfo = &panel->dp_panel.pinfo;
+
+	pr_debug("width=%d hporch= %d %d %d\n",
+		pinfo->h_active, pinfo->h_back_porch,
+		pinfo->h_front_porch, pinfo->h_sync_width);
+
+	pr_debug("height=%d vporch= %d %d %d\n",
+		pinfo->v_active, pinfo->v_back_porch,
+		pinfo->v_front_porch, pinfo->v_sync_width);
+
+	total_hor = pinfo->h_active + pinfo->h_back_porch +
+		pinfo->h_front_porch + pinfo->h_sync_width;
+
+	total_ver = pinfo->v_active + pinfo->v_back_porch +
+			pinfo->v_front_porch + pinfo->v_sync_width;
+
+	data = total_ver;
+	data <<= 16;
+	data |= total_hor;
+
+	catalog->total = data;
+
+	data = (pinfo->v_back_porch + pinfo->v_sync_width);
+	data <<= 16;
+	data |= (pinfo->h_back_porch + pinfo->h_sync_width);
+
+	catalog->sync_start = data;
+
+	data = pinfo->v_sync_width;
+	data <<= 16;
+	data |= (pinfo->v_active_low << 31);
+	data |= pinfo->h_sync_width;
+	data |= (pinfo->h_active_low << 15);
+
+	catalog->width_blanking = data;
+
+	data = pinfo->v_active;
+	data <<= 16;
+	data |= pinfo->h_active;
+
+	catalog->dp_active = data;
+
+	panel->catalog->timing_cfg(catalog);
+	panel->panel_on = true;
+end:
+	return rc;
+}
+
+static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
+{
+	int rc = 0;
+	struct dp_panel_info *pinfo;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	pinfo = &dp_panel->pinfo;
+
+	/*
+	 * print resolution info as this is a result
+	 * of user initiated action of cable connection
+	 */
+	pr_info("SET NEW RESOLUTION:\n");
+	pr_info("%dx%d@%dfps\n", pinfo->h_active,
+		pinfo->v_active, pinfo->refresh_rate);
+	pr_info("h_porches(back|front|width) = (%d|%d|%d)\n",
+			pinfo->h_back_porch,
+			pinfo->h_front_porch,
+			pinfo->h_sync_width);
+	pr_info("v_porches(back|front|width) = (%d|%d|%d)\n",
+			pinfo->v_back_porch,
+			pinfo->v_front_porch,
+			pinfo->v_sync_width);
+	pr_info("pixel clock (KHz)=(%d)\n", pinfo->pixel_clk_khz);
+	pr_info("bpp = %d\n", pinfo->bpp);
+	pr_info("active low (h|v)=(%d|%d)\n", pinfo->h_active_low,
+		pinfo->v_active_low);
+
+	pinfo->bpp = max_t(u32, 18, min_t(u32, pinfo->bpp, 30));
+	pr_info("updated bpp = %d\n", pinfo->bpp);
+end:
+	return rc;
+}
+
+static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
+{
+	const u32 encoding_factx10 = 8;
+	u32 min_link_rate_khz = 0, lane_cnt;
+	struct dp_panel_info *pinfo;
+
+	if (!dp_panel) {
+		pr_err("invalid input\n");
+		goto end;
+	}
+
+	lane_cnt = dp_panel->link_info.num_lanes;
+	pinfo = &dp_panel->pinfo;
+
+	/* num_lanes * lane_count * 8 >= pclk * bpp * 10 */
+	min_link_rate_khz = pinfo->pixel_clk_khz /
+				(lane_cnt * encoding_factx10);
+	min_link_rate_khz *= pinfo->bpp;
+
+	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
+		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
+		pinfo->bpp);
+end:
+	return min_link_rate_khz;
+}
+
+struct dp_panel *dp_panel_get(struct dp_panel_in *in)
+{
+	int rc = 0;
+	struct dp_panel_private *panel;
+	struct dp_panel *dp_panel;
+
+	if (!in->dev || !in->catalog || !in->aux || !in->link) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
+	if (!panel) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	panel->dev = in->dev;
+	panel->aux = in->aux;
+	panel->catalog = in->catalog;
+	panel->link = in->link;
+
+	dp_panel = &panel->dp_panel;
+	dp_panel->max_bw_code = DP_LINK_BW_8_1;
+	panel->aux_cfg_update_done = false;
+
+	dp_panel->init_info = dp_panel_init_panel_info;
+	dp_panel->timing_cfg = dp_panel_timing_cfg;
+	dp_panel->read_sink_caps = dp_panel_read_sink_caps;
+	dp_panel->get_min_req_link_rate = dp_panel_get_min_req_link_rate;
+	dp_panel->get_mode_bpp = dp_panel_get_mode_bpp;
+	dp_panel->get_modes = dp_panel_get_modes;
+	dp_panel->handle_sink_request = dp_panel_handle_sink_request;
+	dp_panel->tpg_config = dp_panel_tpg_config;
+
+	return dp_panel;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_panel_put(struct dp_panel *dp_panel)
+{
+	struct dp_panel_private *panel;
+
+	if (!dp_panel)
+		return;
+
+	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
+
+	kfree(dp_panel->edid);
+	dp_panel->edid = NULL;
+	devm_kfree(panel->dev, panel);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_panel.h b/drivers/gpu/drm/msm/dp/dp_panel.h
new file mode 100644
index 0000000..bf802df
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_panel.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_PANEL_H_
+#define _DP_PANEL_H_
+
+#include <drm/msm_drm.h>
+
+#include "dp_aux.h"
+#include "dp_link.h"
+#include "dp_extcon.h"
+
+struct edid;
+
+enum dp_lane_count {
+	DP_LANE_COUNT_1	= 1,
+	DP_LANE_COUNT_2	= 2,
+	DP_LANE_COUNT_4	= 4,
+};
+
+#define DP_MAX_DOWNSTREAM_PORTS 0x10
+
+struct dp_panel_info {
+	u32 h_active;
+	u32 v_active;
+	u32 h_back_porch;
+	u32 h_front_porch;
+	u32 h_sync_width;
+	u32 h_active_low;
+	u32 v_back_porch;
+	u32 v_front_porch;
+	u32 v_sync_width;
+	u32 v_active_low;
+	u32 h_skew;
+	u32 refresh_rate;
+	u32 pixel_clk_khz;
+	u32 bpp;
+};
+
+struct dp_display_mode {
+	struct dp_panel_info timing;
+	u32 capabilities;
+};
+
+struct dp_panel_in {
+	struct device *dev;
+	struct dp_aux *aux;
+	struct dp_link *link;
+	struct dp_catalog_panel *catalog;
+};
+
+struct dp_panel {
+	/* dpcd raw data */
+	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];
+	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
+
+	struct drm_dp_link link_info;
+	struct edid *edid;
+	struct drm_connector *connector;
+	struct dp_panel_info pinfo;
+	bool video_test;
+
+	u32 vic;
+	u32 max_pclk_khz;
+
+	u32 max_bw_code;
+	int (*init_info)(struct dp_panel *dp_panel);
+	int (*deinit)(struct dp_panel *dp_panel);
+	int (*timing_cfg)(struct dp_panel *dp_panel);
+	int (*read_sink_caps)(struct dp_panel *dp_panel,
+		struct drm_connector *connector);
+	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);
+	u32 (*get_mode_bpp)(struct dp_panel *dp_panel, u32 mode_max_bpp,
+			u32 mode_pclk_khz);
+	int (*get_modes)(struct dp_panel *dp_panel,
+		struct drm_connector *connector, struct dp_display_mode *mode);
+	void (*handle_sink_request)(struct dp_panel *dp_panel);
+	void (*tpg_config)(struct dp_panel *dp_panel, bool enable);
+};
+
+/**
+ * is_link_rate_valid() - validates the link rate
+ * @lane_rate: link rate requested by the sink
+ *
+ * Returns true if the requested link rate is supported.
+ */
+static inline bool is_link_rate_valid(u32 bw_code)
+{
+	return ((bw_code == DP_LINK_BW_1_62) ||
+		(bw_code == DP_LINK_BW_2_7) ||
+		(bw_code == DP_LINK_BW_5_4) ||
+		(bw_code == DP_LINK_BW_8_1));
+}
+
+/**
+ * dp_link_is_lane_count_valid() - validates the lane count
+ * @lane_count: lane count requested by the sink
+ *
+ * Returns true if the requested lane count is supported.
+ */
+static inline bool is_lane_count_valid(u32 lane_count)
+{
+	return (lane_count == DP_LANE_COUNT_1) ||
+		(lane_count == DP_LANE_COUNT_2) ||
+		(lane_count == DP_LANE_COUNT_4);
+}
+
+struct dp_panel *dp_panel_get(struct dp_panel_in *in);
+void dp_panel_put(struct dp_panel *dp_panel);
+#endif /* _DP_PANEL_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_parser.c b/drivers/gpu/drm/msm/dp/dp_parser.c
new file mode 100644
index 0000000..a366dc5
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_parser.c
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/of_gpio.h>
+
+#include "dp_parser.h"
+
+static void dp_parser_unmap_io_resources(struct dp_parser *parser)
+{
+	struct dp_io *io = &parser->io;
+
+	msm_dss_iounmap(&io->dp_ahb);
+	msm_dss_iounmap(&io->dp_aux);
+	msm_dss_iounmap(&io->dp_link);
+	msm_dss_iounmap(&io->dp_p0);
+	msm_dss_iounmap(&io->phy_io);
+	msm_dss_iounmap(&io->ln_tx0_io);
+	msm_dss_iounmap(&io->ln_tx0_io);
+	msm_dss_iounmap(&io->dp_pll_io);
+	msm_dss_iounmap(&io->dp_cc_io);
+	msm_dss_iounmap(&io->usb3_dp_com);
+	msm_dss_iounmap(&io->qfprom_io);
+}
+
+static int dp_parser_ctrl_res(struct dp_parser *parser)
+{
+	int rc = 0;
+	u32 index;
+	struct platform_device *pdev = parser->pdev;
+	struct device_node *of_node = parser->pdev->dev.of_node;
+	struct dp_io *io = &parser->io;
+
+	rc = of_property_read_u32(of_node, "cell-index", &index);
+	if (rc) {
+		pr_err("cell-index not specified, rc=%d\n", rc);
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->dp_ahb, "dp_ahb");
+	if (rc) {
+		pr_err("unable to remap dp io resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->dp_aux, "dp_aux");
+	if (rc) {
+		pr_err("unable to remap dp io resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->dp_link, "dp_link");
+	if (rc) {
+		pr_err("unable to remap dp io resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->dp_p0, "dp_p0");
+	if (rc) {
+		pr_err("unable to remap dp io resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->phy_io, "dp_phy");
+	if (rc) {
+		pr_err("unable to remap dp PHY resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx0_io, "dp_ln_tx0");
+	if (rc) {
+		pr_err("unable to remap dp TX0 resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx1_io, "dp_ln_tx1");
+	if (rc) {
+		pr_err("unable to remap dp TX1 resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->dp_pll_io, "dp_pll");
+	if (rc) {
+		pr_err("unable to remap DP PLL resources\n");
+		goto err;
+	}
+
+	rc = msm_dss_ioremap_byname(pdev, &io->usb3_dp_com, "usb3_dp_com");
+	if (rc) {
+		pr_err("unable to remap USB3 DP com resources\n");
+		goto err;
+	}
+
+	if (msm_dss_ioremap_byname(pdev, &io->dp_cc_io, "dp_mmss_cc")) {
+		pr_err("unable to remap dp MMSS_CC resources\n");
+		goto err;
+	}
+
+	if (msm_dss_ioremap_byname(pdev, &io->qfprom_io, "qfprom_physical"))
+		pr_warn("unable to remap dp qfprom resources\n");
+
+	return 0;
+err:
+	dp_parser_unmap_io_resources(parser);
+	return rc;
+}
+
+static const char *dp_get_phy_aux_config_property(u32 cfg_type)
+{
+	switch (cfg_type) {
+	case PHY_AUX_CFG0:
+		return "qcom,aux-cfg0-settings";
+	case PHY_AUX_CFG1:
+		return "qcom,aux-cfg1-settings";
+	case PHY_AUX_CFG2:
+		return "qcom,aux-cfg2-settings";
+	case PHY_AUX_CFG3:
+		return "qcom,aux-cfg3-settings";
+	case PHY_AUX_CFG4:
+		return "qcom,aux-cfg4-settings";
+	case PHY_AUX_CFG5:
+		return "qcom,aux-cfg5-settings";
+	case PHY_AUX_CFG6:
+		return "qcom,aux-cfg6-settings";
+	case PHY_AUX_CFG7:
+		return "qcom,aux-cfg7-settings";
+	case PHY_AUX_CFG8:
+		return "qcom,aux-cfg8-settings";
+	case PHY_AUX_CFG9:
+		return "qcom,aux-cfg9-settings";
+	default:
+		return "unknown";
+	}
+}
+
+static void dp_parser_phy_aux_cfg_reset(struct dp_parser *parser)
+{
+	int i = 0;
+
+	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
+		parser->aux_cfg[i] = (const struct dp_aux_cfg){ 0 };
+}
+
+static int dp_parser_aux(struct dp_parser *parser)
+{
+	struct device_node *of_node = parser->pdev->dev.of_node;
+	int len = 0, i = 0, j = 0, config_count = 0;
+	const char *data;
+	int const minimum_config_count = 1;
+
+	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
+		const char *property = dp_get_phy_aux_config_property(i);
+
+		data = of_get_property(of_node, property, &len);
+		if (!data) {
+			pr_err("Unable to read %s\n", property);
+			goto error;
+		}
+
+		config_count = len - 1;
+		if ((config_count < minimum_config_count) ||
+			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {
+			pr_err("Invalid config count (%d) configs for %s\n",
+					config_count, property);
+			goto error;
+		}
+
+		parser->aux_cfg[i].offset = data[0];
+		parser->aux_cfg[i].cfg_cnt = config_count;
+		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
+				property,
+				parser->aux_cfg[i].offset,
+				parser->aux_cfg[i].cfg_cnt);
+		for (j = 1; j < len; j++) {
+			parser->aux_cfg[i].lut[j - 1] = data[j];
+			pr_debug("%s lut[%d]=0x%x\n",
+					property,
+					i,
+					parser->aux_cfg[i].lut[j - 1]);
+		}
+	}
+		return 0;
+
+error:
+	dp_parser_phy_aux_cfg_reset(parser);
+	return -EINVAL;
+}
+
+static int dp_parser_misc(struct dp_parser *parser)
+{
+	int rc = 0;
+	struct device_node *of_node = parser->pdev->dev.of_node;
+
+	rc = of_property_read_u32(of_node,
+		"qcom,max-pclk-frequency-khz", &parser->max_pclk_khz);
+	if (rc)
+		parser->max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;
+
+	return 0;
+}
+
+static int dp_parser_pinctrl(struct dp_parser *parser)
+{
+	int rc = 0;
+	struct dp_pinctrl *pinctrl = &parser->pinctrl;
+
+	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
+
+	if (IS_ERR_OR_NULL(pinctrl->pin)) {
+		rc = PTR_ERR(pinctrl->pin);
+		pr_err("failed to get pinctrl, rc=%d\n", rc);
+		goto error;
+	}
+
+	pinctrl->state_active = pinctrl_lookup_state(pinctrl->pin,
+					"mdss_dp_active");
+	if (IS_ERR_OR_NULL(pinctrl->state_active)) {
+		rc = PTR_ERR(pinctrl->state_active);
+		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
+		goto error;
+	}
+
+	pinctrl->state_suspend = pinctrl_lookup_state(pinctrl->pin,
+					"mdss_dp_sleep");
+	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
+		rc = PTR_ERR(pinctrl->state_suspend);
+		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
+		goto error;
+	}
+error:
+	return rc;
+}
+
+static int dp_parser_gpio(struct dp_parser *parser)
+{
+	int i = 0;
+	struct device *dev = &parser->pdev->dev;
+	struct device_node *of_node = dev->of_node;
+	struct dss_module_power *mp = &parser->mp[DP_CORE_PM];
+	static const char * const dp_gpios[] = {
+		"qcom,aux-en-gpio",
+		"qcom,aux-sel-gpio",
+		"qcom,usbplug-cc-gpio",
+	};
+
+	mp->gpio_config = devm_kzalloc(dev,
+		sizeof(struct dss_gpio) * ARRAY_SIZE(dp_gpios), GFP_KERNEL);
+	if (!mp->gpio_config)
+		return -ENOMEM;
+
+	mp->num_gpio = ARRAY_SIZE(dp_gpios);
+
+	for (i = 0; i < ARRAY_SIZE(dp_gpios); i++) {
+		mp->gpio_config[i].gpio = of_get_named_gpio(of_node,
+			dp_gpios[i], 0);
+
+		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
+			pr_err("%s gpio not specified\n", dp_gpios[i]);
+			return -EINVAL;
+		}
+
+		strlcpy(mp->gpio_config[i].gpio_name, dp_gpios[i],
+			sizeof(mp->gpio_config[i].gpio_name));
+
+		mp->gpio_config[i].value = 0;
+	}
+
+	return 0;
+}
+
+static const char *dp_parser_supply_node_name(enum dp_pm_type module)
+{
+	switch (module) {
+	case DP_CORE_PM:	return "qcom,core-supply-entries";
+	case DP_CTRL_PM:	return "qcom,ctrl-supply-entries";
+	case DP_PHY_PM:		return "qcom,phy-supply-entries";
+	default:		return "???";
+	}
+}
+
+static int dp_parser_get_vreg(struct dp_parser *parser,
+		enum dp_pm_type module)
+{
+	int i = 0, rc = 0;
+	u32 tmp = 0;
+	const char *pm_supply_name = NULL;
+	struct device_node *supply_node = NULL;
+	struct device_node *of_node = parser->pdev->dev.of_node;
+	struct device_node *supply_root_node = NULL;
+	struct dss_module_power *mp = &parser->mp[module];
+
+	mp->num_vreg = 0;
+	pm_supply_name = dp_parser_supply_node_name(module);
+	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
+	if (!supply_root_node) {
+		pr_err("no supply entry present: %s\n", pm_supply_name);
+		goto novreg;
+	}
+
+	mp->num_vreg = of_get_available_child_count(supply_root_node);
+
+	if (mp->num_vreg == 0) {
+		pr_debug("no vreg\n");
+		goto novreg;
+	} else {
+		pr_debug("vreg found. count=%d\n", mp->num_vreg);
+	}
+
+	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
+		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
+	if (!mp->vreg_config) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	for_each_child_of_node(supply_root_node, supply_node) {
+		const char *st = NULL;
+		/* vreg-name */
+		rc = of_property_read_string(supply_node,
+			"qcom,supply-name", &st);
+		if (rc) {
+			pr_err("error reading name. rc=%d\n",
+				 rc);
+			goto error;
+		}
+		snprintf(mp->vreg_config[i].vreg_name,
+			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);
+		/* vreg-min-voltage */
+		rc = of_property_read_u32(supply_node,
+			"qcom,supply-min-voltage", &tmp);
+		if (rc) {
+			pr_err("error reading min volt. rc=%d\n",
+				rc);
+			goto error;
+		}
+		mp->vreg_config[i].min_voltage = tmp;
+
+		/* vreg-max-voltage */
+		rc = of_property_read_u32(supply_node,
+			"qcom,supply-max-voltage", &tmp);
+		if (rc) {
+			pr_err("error reading max volt. rc=%d\n",
+				rc);
+			goto error;
+		}
+		mp->vreg_config[i].max_voltage = tmp;
+
+		/* enable-load */
+		rc = of_property_read_u32(supply_node,
+			"qcom,supply-enable-load", &tmp);
+		if (rc) {
+			pr_err("error reading enable load. rc=%d\n",
+				rc);
+			goto error;
+		}
+		mp->vreg_config[i].enable_load = tmp;
+
+		/* disable-load */
+		rc = of_property_read_u32(supply_node,
+			"qcom,supply-disable-load", &tmp);
+		if (rc) {
+			pr_err("error reading disable load. rc=%d\n",
+				rc);
+			goto error;
+		}
+		mp->vreg_config[i].disable_load = tmp;
+
+		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
+			mp->vreg_config[i].vreg_name,
+			mp->vreg_config[i].min_voltage,
+			mp->vreg_config[i].max_voltage,
+			mp->vreg_config[i].enable_load,
+			mp->vreg_config[i].disable_load
+			);
+		++i;
+	}
+
+	return rc;
+
+error:
+	if (mp->vreg_config) {
+		devm_kfree(&parser->pdev->dev, mp->vreg_config);
+		mp->vreg_config = NULL;
+	}
+novreg:
+	mp->num_vreg = 0;
+
+	return rc;
+}
+
+static void dp_parser_put_vreg_data(struct device *dev,
+	struct dss_module_power *mp)
+{
+	if (!mp) {
+		DEV_ERR("invalid input\n");
+		return;
+	}
+
+	if (mp->vreg_config) {
+		devm_kfree(dev, mp->vreg_config);
+		mp->vreg_config = NULL;
+	}
+	mp->num_vreg = 0;
+}
+
+static int dp_parser_regulator(struct dp_parser *parser)
+{
+	int i, rc = 0;
+	struct platform_device *pdev = parser->pdev;
+
+	/* Parse the regulator information */
+	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
+		rc = dp_parser_get_vreg(parser, i);
+		if (rc) {
+			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
+				dp_parser_pm_name(i), rc);
+			i--;
+			for (; i >= DP_CORE_PM; i--)
+				dp_parser_put_vreg_data(&pdev->dev,
+					&parser->mp[i]);
+			break;
+		}
+	}
+
+	return rc;
+}
+
+static bool dp_parser_check_prefix(const char *clk_prefix, const char *clk_name)
+{
+	return !!strnstr(clk_name, clk_prefix, strlen(clk_name));
+}
+
+static void dp_parser_put_clk_data(struct device *dev,
+	struct dss_module_power *mp)
+{
+	if (!mp) {
+		DEV_ERR("%s: invalid input\n", __func__);
+		return;
+	}
+
+	if (mp->clk_config) {
+		devm_kfree(dev, mp->clk_config);
+		mp->clk_config = NULL;
+	}
+
+	mp->num_clk = 0;
+}
+
+static void dp_parser_put_gpio_data(struct device *dev,
+	struct dss_module_power *mp)
+{
+	if (!mp) {
+		DEV_ERR("%s: invalid input\n", __func__);
+		return;
+	}
+
+	if (mp->gpio_config) {
+		devm_kfree(dev, mp->gpio_config);
+		mp->gpio_config = NULL;
+	}
+
+	mp->num_gpio = 0;
+}
+
+static int dp_parser_init_clk_data(struct dp_parser *parser)
+{
+	int num_clk = 0, i = 0, rc = 0;
+	int core_clk_count = 0, ctrl_clk_count = 0;
+	const char *core_clk = "core";
+	const char *ctrl_clk = "ctrl";
+	const char *clk_name;
+	struct device *dev = &parser->pdev->dev;
+	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
+	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
+
+	num_clk = of_property_count_strings(dev->of_node, "clock-names");
+	if (num_clk <= 0) {
+		pr_err("no clocks are defined\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	for (i = 0; i < num_clk; i++) {
+		of_property_read_string_index(dev->of_node,
+				"clock-names", i, &clk_name);
+
+		if (dp_parser_check_prefix(core_clk, clk_name))
+			core_clk_count++;
+
+		if (dp_parser_check_prefix(ctrl_clk, clk_name))
+			ctrl_clk_count++;
+	}
+
+	/* Initialize the CORE power module */
+	if (core_clk_count <= 0) {
+		pr_err("no core clocks are defined\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	core_power->num_clk = core_clk_count;
+	core_power->clk_config = devm_kzalloc(dev,
+			sizeof(struct dss_clk) * core_power->num_clk,
+			GFP_KERNEL);
+	if (!core_power->clk_config) {
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	/* Initialize the CTRL power module */
+	if (ctrl_clk_count <= 0) {
+		pr_err("no ctrl clocks are defined\n");
+		rc = -EINVAL;
+		goto ctrl_clock_error;
+	}
+
+	ctrl_power->num_clk = ctrl_clk_count;
+	ctrl_power->clk_config = devm_kzalloc(dev,
+			sizeof(struct dss_clk) * ctrl_power->num_clk,
+			GFP_KERNEL);
+	if (!ctrl_power->clk_config) {
+		ctrl_power->num_clk = 0;
+		rc = -EINVAL;
+		goto ctrl_clock_error;
+	}
+
+	return rc;
+
+ctrl_clock_error:
+	dp_parser_put_clk_data(dev, core_power);
+exit:
+	return rc;
+}
+
+static int dp_parser_clock(struct dp_parser *parser)
+{
+	int rc = 0, i = 0;
+	int num_clk = 0;
+	int core_clk_index = 0, ctrl_clk_index = 0;
+	int core_clk_count = 0, ctrl_clk_count = 0;
+	const char *clk_name;
+	const char *core_clk = "core";
+	const char *ctrl_clk = "ctrl";
+	struct device *dev = &parser->pdev->dev;
+	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
+	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
+
+	core_power = &parser->mp[DP_CORE_PM];
+	ctrl_power = &parser->mp[DP_CTRL_PM];
+
+	rc =  dp_parser_init_clk_data(parser);
+	if (rc) {
+		pr_err("failed to initialize power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	core_clk_count = core_power->num_clk;
+	ctrl_clk_count = ctrl_power->num_clk;
+
+	num_clk = core_clk_count + ctrl_clk_count;
+
+	for (i = 0; i < num_clk; i++) {
+		of_property_read_string_index(dev->of_node, "clock-names",
+				i, &clk_name);
+
+		if (dp_parser_check_prefix(core_clk, clk_name) &&
+				core_clk_index < core_clk_count) {
+			struct dss_clk *clk =
+				&core_power->clk_config[core_clk_index];
+			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
+			clk->type = DSS_CLK_AHB;
+			core_clk_index++;
+		} else if (dp_parser_check_prefix(ctrl_clk, clk_name) &&
+			   ctrl_clk_index < ctrl_clk_count) {
+			struct dss_clk *clk =
+				&ctrl_power->clk_config[ctrl_clk_index];
+			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
+			ctrl_clk_index++;
+
+			if (!strcmp(clk_name, "ctrl_link_clk") ||
+			    !strcmp(clk_name, "ctrl_pixel_clk"))
+				clk->type = DSS_CLK_PCLK;
+			else
+				clk->type = DSS_CLK_AHB;
+		}
+	}
+
+	pr_debug("clock parsing successful\n");
+
+exit:
+	return rc;
+}
+
+static int dp_parser_parse(struct dp_parser *parser)
+{
+	int rc = 0;
+
+	if (!parser) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto err;
+	}
+
+	rc = dp_parser_ctrl_res(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_aux(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_misc(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_clock(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_regulator(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_gpio(parser);
+	if (rc)
+		goto err;
+
+	rc = dp_parser_pinctrl(parser);
+err:
+	return rc;
+}
+
+struct dp_parser *dp_parser_get(struct platform_device *pdev)
+{
+	struct dp_parser *parser;
+
+	parser = devm_kzalloc(&pdev->dev, sizeof(*parser), GFP_KERNEL);
+	if (!parser)
+		return ERR_PTR(-ENOMEM);
+
+	parser->parse = dp_parser_parse;
+	parser->pdev = pdev;
+
+	return parser;
+}
+
+void dp_parser_put(struct dp_parser *parser)
+{
+	int i = 0;
+	struct dss_module_power *power = NULL;
+
+	if (!parser) {
+		pr_err("invalid parser module\n");
+		return;
+	}
+
+	power = parser->mp;
+
+	for (i = 0; i < DP_MAX_PM; i++) {
+		dp_parser_put_clk_data(&parser->pdev->dev, &power[i]);
+		dp_parser_put_vreg_data(&parser->pdev->dev, &power[i]);
+		dp_parser_put_gpio_data(&parser->pdev->dev, &power[i]);
+	}
+
+	devm_kfree(&parser->pdev->dev, parser);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h b/drivers/gpu/drm/msm/dp/dp_parser.h
new file mode 100644
index 0000000..b39ea02
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_parser.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_PARSER_H_
+#define _DP_PARSER_H_
+
+#include "dpu_io_util.h"
+
+#define DP_LABEL "MDSS DP DISPLAY"
+#define AUX_CFG_LEN	10
+#define DP_MAX_PIXEL_CLK_KHZ	675000
+
+enum dp_pm_type {
+	DP_CORE_PM,
+	DP_CTRL_PM,
+	DP_PHY_PM,
+	DP_MAX_PM
+};
+
+static inline const char *dp_parser_pm_name(enum dp_pm_type module)
+{
+	switch (module) {
+	case DP_CORE_PM:	return "DP_CORE_PM";
+	case DP_CTRL_PM:	return "DP_CTRL_PM";
+	case DP_PHY_PM:		return "DP_PHY_PM";
+	default:		return "???";
+	}
+}
+
+/**
+ * struct dp_display_data  - display related device tree data.
+ *
+ * @ctrl_node: referece to controller device
+ * @phy_node:  reference to phy device
+ * @is_active: is the controller currently active
+ * @name: name of the display
+ * @display_type: type of the display
+ */
+struct dp_display_data {
+	struct device_node *ctrl_node;
+	struct device_node *phy_node;
+	bool is_active;
+	const char *name;
+	const char *display_type;
+};
+
+/**
+ * struct dp_ctrl_resource - controller's IO related data
+ *
+ * @dp_ahb: controller's ahb mapped memory address
+ * @dp_aux: controller's aux mapped memory address
+ * @dp_link: controller's link mapped memory address
+ * @dp_p0: controller's p0 mapped memory address
+ * @phy_io: phy's mapped memory address
+ * @ln_tx0_io: USB-DP lane TX0's mapped memory address
+ * @ln_tx1_io: USB-DP lane TX1's mapped memory address
+ * @dp_cc_io: DP cc's mapped memory address
+ * @qfprom_io: qfprom's mapped memory address
+ * @dp_pll_io: DP PLL mapped memory address
+ * @usb3_dp_com: USB3 DP PHY combo mapped memory address
+ */
+struct dp_io {
+	struct dss_io_data ctrl_io;
+	struct dss_io_data dp_ahb;
+	struct dss_io_data dp_aux;
+	struct dss_io_data dp_link;
+	struct dss_io_data dp_p0;
+	struct dss_io_data phy_io;
+	struct dss_io_data ln_tx0_io;
+	struct dss_io_data ln_tx1_io;
+	struct dss_io_data dp_cc_io;
+	struct dss_io_data qfprom_io;
+	struct dss_io_data dp_pll_io;
+	struct dss_io_data usb3_dp_com;
+};
+
+/**
+ * struct dp_pinctrl - DP's pin control
+ *
+ * @pin: pin-controller's instance
+ * @state_active: active state pin control
+ * @state_hpd_active: hpd active state pin control
+ * @state_suspend: suspend state pin control
+ */
+struct dp_pinctrl {
+	struct pinctrl *pin;
+	struct pinctrl_state *state_active;
+	struct pinctrl_state *state_hpd_active;
+	struct pinctrl_state *state_suspend;
+};
+
+#define DP_ENUM_STR(x)	#x
+#define DP_AUX_CFG_MAX_VALUE_CNT 3
+/**
+ * struct dp_aux_cfg - DP's AUX configuration settings
+ *
+ * @cfg_cnt: count of the configurable settings for the AUX register
+ * @current_index: current index of the AUX config lut
+ * @offset: register offset of the AUX config register
+ * @lut: look up table for the AUX config values for this register
+ */
+struct dp_aux_cfg {
+	u32 cfg_cnt;
+	u32 current_index;
+	u32 offset;
+	u32 lut[DP_AUX_CFG_MAX_VALUE_CNT];
+};
+
+/* PHY AUX config registers */
+enum dp_phy_aux_config_type {
+	PHY_AUX_CFG0,
+	PHY_AUX_CFG1,
+	PHY_AUX_CFG2,
+	PHY_AUX_CFG3,
+	PHY_AUX_CFG4,
+	PHY_AUX_CFG5,
+	PHY_AUX_CFG6,
+	PHY_AUX_CFG7,
+	PHY_AUX_CFG8,
+	PHY_AUX_CFG9,
+	PHY_AUX_CFG_MAX,
+};
+
+static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type)
+{
+	switch (cfg_type) {
+	case PHY_AUX_CFG0:
+		return DP_ENUM_STR(PHY_AUX_CFG0);
+	case PHY_AUX_CFG1:
+		return DP_ENUM_STR(PHY_AUX_CFG1);
+	case PHY_AUX_CFG2:
+		return DP_ENUM_STR(PHY_AUX_CFG2);
+	case PHY_AUX_CFG3:
+		return DP_ENUM_STR(PHY_AUX_CFG3);
+	case PHY_AUX_CFG4:
+		return DP_ENUM_STR(PHY_AUX_CFG4);
+	case PHY_AUX_CFG5:
+		return DP_ENUM_STR(PHY_AUX_CFG5);
+	case PHY_AUX_CFG6:
+		return DP_ENUM_STR(PHY_AUX_CFG6);
+	case PHY_AUX_CFG7:
+		return DP_ENUM_STR(PHY_AUX_CFG7);
+	case PHY_AUX_CFG8:
+		return DP_ENUM_STR(PHY_AUX_CFG8);
+	case PHY_AUX_CFG9:
+		return DP_ENUM_STR(PHY_AUX_CFG9);
+	default:
+		return "unknown";
+	}
+}
+
+/**
+ * struct dp_parser - DP parser's data exposed to clients
+ *
+ * @pdev: platform data of the client
+ * @mp: gpio, regulator and clock related data
+ * @pinctrl: pin-control related data
+ * @disp_data: controller's display related data
+ * @parse: function to be called by client to parse device tree.
+ */
+struct dp_parser {
+	struct platform_device *pdev;
+	struct dss_module_power mp[DP_MAX_PM];
+	struct dp_pinctrl pinctrl;
+	struct dp_io io;
+	struct dp_display_data disp_data;
+
+	u8 l_map[4];
+	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
+	u32 max_pclk_khz;
+
+	int (*parse)(struct dp_parser *parser);
+};
+
+/**
+ * dp_parser_get() - get the DP's device tree parser module
+ *
+ * @pdev: platform data of the client
+ * return: pointer to dp_parser structure.
+ *
+ * This function provides client capability to parse the
+ * device tree and populate the data structures. The data
+ * related to clock, regulators, pin-control and other
+ * can be parsed using this module.
+ */
+struct dp_parser *dp_parser_get(struct platform_device *pdev);
+
+/**
+ * dp_parser_put() - cleans the dp_parser module
+ *
+ * @parser: pointer to the parser's data.
+ */
+void dp_parser_put(struct dp_parser *parser);
+#endif
diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
new file mode 100644
index 0000000..1d58480
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_power.c
@@ -0,0 +1,599 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
+
+#include <linux/clk.h>
+#include "dp_power.h"
+
+#define DP_CLIENT_NAME_SIZE	20
+
+struct dp_power_private {
+	struct dp_parser *parser;
+	struct platform_device *pdev;
+	struct clk *pixel_clk_rcg;
+	struct clk *pixel_parent;
+
+	struct dp_power dp_power;
+
+	bool core_clks_on;
+	bool link_clks_on;
+};
+
+static int dp_power_regulator_init(struct dp_power_private *power)
+{
+	int rc = 0, i = 0, j = 0;
+	struct platform_device *pdev;
+	struct dp_parser *parser;
+
+	parser = power->parser;
+	pdev = power->pdev;
+
+	for (i = DP_CORE_PM; !rc && (i < DP_MAX_PM); i++) {
+		rc = msm_dss_config_vreg(&pdev->dev,
+			parser->mp[i].vreg_config,
+			parser->mp[i].num_vreg, 1);
+		if (rc) {
+			pr_err("failed to init vregs for %s\n",
+				dp_parser_pm_name(i));
+			for (j = i - 1; j >= DP_CORE_PM; j--) {
+				msm_dss_config_vreg(&pdev->dev,
+				parser->mp[j].vreg_config,
+				parser->mp[j].num_vreg, 0);
+			}
+
+			goto error;
+		}
+	}
+error:
+	return rc;
+}
+
+static void dp_power_regulator_deinit(struct dp_power_private *power)
+{
+	int rc = 0, i = 0;
+	struct platform_device *pdev;
+	struct dp_parser *parser;
+
+	parser = power->parser;
+	pdev = power->pdev;
+
+	for (i = DP_CORE_PM; (i < DP_MAX_PM); i++) {
+		rc = msm_dss_config_vreg(&pdev->dev,
+			parser->mp[i].vreg_config,
+			parser->mp[i].num_vreg, 0);
+		if (rc)
+			pr_err("failed to deinit vregs for %s\n",
+				dp_parser_pm_name(i));
+	}
+}
+
+static int dp_power_regulator_ctrl(struct dp_power_private *power, bool enable)
+{
+	int rc = 0, i = 0, j = 0;
+	struct dp_parser *parser;
+
+	parser = power->parser;
+
+	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
+		rc = msm_dss_enable_vreg(
+			parser->mp[i].vreg_config,
+			parser->mp[i].num_vreg, enable);
+		if (rc) {
+			pr_err("failed to '%s' vregs for %s\n",
+					enable ? "enable" : "disable",
+					dp_parser_pm_name(i));
+			if (enable) {
+				for (j = i-1; j >= DP_CORE_PM; j--) {
+					msm_dss_enable_vreg(
+					parser->mp[j].vreg_config,
+					parser->mp[j].num_vreg, 0);
+				}
+			}
+			goto error;
+		}
+	}
+error:
+	return rc;
+}
+
+static int dp_power_pinctrl_set(struct dp_power_private *power, bool active)
+{
+	int rc = -EFAULT;
+	struct pinctrl_state *pin_state;
+	struct dp_parser *parser;
+
+	parser = power->parser;
+
+	if (IS_ERR_OR_NULL(parser->pinctrl.pin))
+		return PTR_ERR(parser->pinctrl.pin);
+
+	pin_state = active ? parser->pinctrl.state_active
+				: parser->pinctrl.state_suspend;
+	if (!IS_ERR_OR_NULL(pin_state)) {
+		rc = pinctrl_select_state(parser->pinctrl.pin,
+				pin_state);
+		if (rc)
+			pr_err("can not set %s pins\n",
+			       active ? "dp_active"
+			       : "dp_sleep");
+	} else {
+		pr_err("invalid '%s' pinstate\n",
+		       active ? "dp_active"
+		       : "dp_sleep");
+	}
+
+	return rc;
+}
+
+static int dp_power_clk_init(struct dp_power_private *power, bool enable)
+{
+	int rc = 0;
+	struct dss_module_power *core, *ctrl;
+	struct device *dev;
+
+	core = &power->parser->mp[DP_CORE_PM];
+	ctrl = &power->parser->mp[DP_CTRL_PM];
+
+	dev = &power->pdev->dev;
+
+	if (!core || !ctrl) {
+		pr_err("invalid power_data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	if (enable) {
+		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
+		if (rc) {
+			pr_err("failed to get %s clk. err=%d\n",
+				dp_parser_pm_name(DP_CORE_PM), rc);
+			goto exit;
+		}
+
+		rc = msm_dss_get_clk(dev, ctrl->clk_config, ctrl->num_clk);
+		if (rc) {
+			pr_err("failed to get %s clk. err=%d\n",
+				dp_parser_pm_name(DP_CTRL_PM), rc);
+			goto ctrl_get_error;
+		}
+
+		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
+		if (IS_ERR(power->pixel_clk_rcg)) {
+			pr_debug("Unable to get DP pixel clk RCG\n");
+			power->pixel_clk_rcg = NULL;
+		}
+
+		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
+		if (IS_ERR(power->pixel_parent)) {
+			pr_debug("Unable to get DP pixel RCG parent\n");
+			power->pixel_parent = NULL;
+		}
+	} else {
+		if (power->pixel_parent)
+			devm_clk_put(dev, power->pixel_parent);
+
+		if (power->pixel_clk_rcg)
+			devm_clk_put(dev, power->pixel_clk_rcg);
+
+		msm_dss_put_clk(ctrl->clk_config, ctrl->num_clk);
+		msm_dss_put_clk(core->clk_config, core->num_clk);
+	}
+
+	return rc;
+
+ctrl_get_error:
+	msm_dss_put_clk(core->clk_config, core->num_clk);
+exit:
+	return rc;
+}
+
+static int dp_power_clk_set_rate(struct dp_power_private *power,
+		enum dp_pm_type module, bool enable)
+{
+	int rc = 0;
+	struct dss_module_power *mp;
+
+	if (!power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	mp = &power->parser->mp[module];
+
+	if (enable) {
+		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
+		if (rc) {
+			pr_err("failed to set clks rate.\n");
+			goto exit;
+		}
+
+		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
+		if (rc) {
+			pr_err("failed to enable clks\n");
+			goto exit;
+		}
+	} else {
+		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
+		if (rc) {
+			pr_err("failed to disable clks\n");
+				goto exit;
+		}
+	}
+exit:
+	return rc;
+}
+
+static int dp_power_clk_enable(struct dp_power *dp_power,
+		enum dp_pm_type pm_type, bool enable)
+{
+	int rc = 0;
+	struct dss_module_power *mp;
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	mp = &power->parser->mp[pm_type];
+
+	if ((pm_type != DP_CORE_PM) && (pm_type != DP_CTRL_PM)) {
+		pr_err("unsupported power module: %s\n",
+				dp_parser_pm_name(pm_type));
+		return -EINVAL;
+	}
+
+	if (enable) {
+		if ((pm_type == DP_CORE_PM)
+			&& (power->core_clks_on)) {
+			pr_debug("core clks already enabled\n");
+			return 0;
+		}
+
+		if ((pm_type == DP_CTRL_PM)
+			&& (power->link_clks_on)) {
+			pr_debug("links clks already enabled\n");
+			return 0;
+		}
+
+		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {
+			pr_debug("Need to enable core clks before link clks\n");
+
+			rc = dp_power_clk_set_rate(power, DP_CORE_PM, enable);
+			if (rc) {
+				pr_err("failed to enable clks: %s. err=%d\n",
+					dp_parser_pm_name(DP_CORE_PM), rc);
+				goto error;
+			} else {
+				power->core_clks_on = true;
+			}
+		}
+	}
+
+	rc = dp_power_clk_set_rate(power, pm_type, enable);
+	if (rc) {
+		pr_err("failed to '%s' clks for: %s. err=%d\n",
+			enable ? "enable" : "disable",
+			dp_parser_pm_name(pm_type), rc);
+			goto error;
+	}
+
+	if (pm_type == DP_CORE_PM)
+		power->core_clks_on = enable;
+	else
+		power->link_clks_on = enable;
+
+	pr_debug("%s clocks for %s\n",
+			enable ? "enable" : "disable",
+			dp_parser_pm_name(pm_type));
+	pr_debug("link_clks:%s core_clks:%s\n",
+		power->link_clks_on ? "on" : "off",
+		power->core_clks_on ? "on" : "off");
+error:
+	return rc;
+}
+
+static int dp_power_request_gpios(struct dp_power_private *power)
+{
+	int rc = 0, i;
+	struct device *dev;
+	struct dss_module_power *mp;
+	static const char * const gpio_names[] = {
+		"aux_enable", "aux_sel", "usbplug_cc",
+	};
+
+	if (!power) {
+		pr_err("invalid power data\n");
+		return -EINVAL;
+	}
+
+	dev = &power->pdev->dev;
+	mp = &power->parser->mp[DP_CORE_PM];
+
+	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
+		unsigned int gpio = mp->gpio_config[i].gpio;
+
+		if (gpio_is_valid(gpio)) {
+			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
+			if (rc) {
+				pr_err("request %s gpio failed, rc=%d\n",
+					       gpio_names[i], rc);
+				goto error;
+			}
+		}
+	}
+	return 0;
+error:
+	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
+		unsigned int gpio = mp->gpio_config[i].gpio;
+
+		if (gpio_is_valid(gpio))
+			gpio_free(gpio);
+	}
+	return rc;
+}
+
+static bool dp_power_find_gpio(const char *gpio1, const char *gpio2)
+{
+	return !!strnstr(gpio1, gpio2, strlen(gpio1));
+}
+
+static void dp_power_set_gpio(struct dp_power_private *power, bool flip)
+{
+	int i;
+	struct dss_module_power *mp = &power->parser->mp[DP_CORE_PM];
+	struct dss_gpio *config = mp->gpio_config;
+
+	for (i = 0; i < mp->num_gpio; i++) {
+		if (dp_power_find_gpio(config->gpio_name, "aux-sel"))
+			config->value = flip;
+
+		if (gpio_is_valid(config->gpio)) {
+			pr_debug("gpio %s, value %d\n", config->gpio_name,
+				config->value);
+
+			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
+			    dp_power_find_gpio(config->gpio_name, "aux-sel"))
+				gpio_direction_output(config->gpio,
+					config->value);
+			else
+				gpio_set_value(config->gpio, config->value);
+
+		}
+		config++;
+	}
+}
+
+static int dp_power_config_gpios(struct dp_power_private *power, bool flip,
+					bool enable)
+{
+	int rc = 0, i;
+	struct dss_module_power *mp;
+	struct dss_gpio *config;
+
+	mp = &power->parser->mp[DP_CORE_PM];
+	config = mp->gpio_config;
+
+	if (enable) {
+		rc = dp_power_request_gpios(power);
+		if (rc) {
+			pr_err("gpio request failed\n");
+			return rc;
+		}
+
+		dp_power_set_gpio(power, flip);
+	} else {
+		for (i = 0; i < mp->num_gpio; i++) {
+			gpio_set_value(config[i].gpio, 0);
+			gpio_free(config[i].gpio);
+		}
+	}
+
+	return 0;
+}
+
+static int dp_power_client_init(struct dp_power *dp_power)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		return -EINVAL;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	pm_runtime_enable(&power->pdev->dev);
+
+	rc = dp_power_regulator_init(power);
+	if (rc) {
+		pr_err("failed to init regulators\n");
+		goto error_power;
+	}
+
+	rc = dp_power_clk_init(power, true);
+	if (rc) {
+		pr_err("failed to init clocks\n");
+		goto error_clk;
+	}
+	return 0;
+
+error_clk:
+	dp_power_regulator_deinit(power);
+error_power:
+	pm_runtime_disable(&power->pdev->dev);
+	return rc;
+}
+
+static void dp_power_client_deinit(struct dp_power *dp_power)
+{
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		return;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	dp_power_clk_init(power, false);
+	dp_power_regulator_deinit(power);
+	pm_runtime_disable(&power->pdev->dev);
+
+}
+
+static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	if (power->pixel_clk_rcg && power->pixel_parent)
+		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
+exit:
+	return rc;
+}
+
+static int dp_power_init(struct dp_power *dp_power, bool flip)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	pm_runtime_get_sync(&power->pdev->dev);
+	rc = dp_power_regulator_ctrl(power, true);
+	if (rc) {
+		pr_err("failed to enable regulators\n");
+		goto exit;
+	}
+
+	rc = dp_power_pinctrl_set(power, true);
+	if (rc) {
+		pr_err("failed to set pinctrl state\n");
+		goto err_pinctrl;
+	}
+
+	rc = dp_power_config_gpios(power, flip, true);
+	if (rc) {
+		pr_err("failed to enable gpios\n");
+		goto err_gpio;
+	}
+
+	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
+	if (rc) {
+		pr_err("failed to enable DP core clocks\n");
+		goto err_clk;
+	}
+
+	return 0;
+
+err_clk:
+	dp_power_config_gpios(power, flip, false);
+err_gpio:
+	dp_power_pinctrl_set(power, false);
+err_pinctrl:
+	dp_power_regulator_ctrl(power, false);
+exit:
+	pm_runtime_put_sync(&power->pdev->dev);
+	return rc;
+}
+
+static int dp_power_deinit(struct dp_power *dp_power)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	dp_power_clk_enable(dp_power, DP_CORE_PM, false);
+	dp_power_config_gpios(power, false, false);
+	dp_power_pinctrl_set(power, false);
+	dp_power_regulator_ctrl(power, false);
+	pm_runtime_put_sync(&power->pdev->dev);
+exit:
+	return rc;
+}
+
+struct dp_power *dp_power_get(struct dp_parser *parser)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+	struct dp_power *dp_power;
+
+	if (!parser) {
+		pr_err("invalid input\n");
+		rc = -EINVAL;
+		goto error;
+	}
+
+	power = devm_kzalloc(&parser->pdev->dev, sizeof(*power), GFP_KERNEL);
+	if (!power) {
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	power->parser = parser;
+	power->pdev = parser->pdev;
+
+	dp_power = &power->dp_power;
+
+	dp_power->init = dp_power_init;
+	dp_power->deinit = dp_power_deinit;
+	dp_power->clk_enable = dp_power_clk_enable;
+	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
+	dp_power->power_client_init = dp_power_client_init;
+	dp_power->power_client_deinit = dp_power_client_deinit;
+
+	return dp_power;
+error:
+	return ERR_PTR(rc);
+}
+
+void dp_power_put(struct dp_power *dp_power)
+{
+	struct dp_power_private *power = NULL;
+
+	if (!dp_power)
+		return;
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	devm_kfree(&power->pdev->dev, power);
+}
diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
new file mode 100644
index 0000000..d1adaaf
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_power.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_POWER_H_
+#define _DP_POWER_H_
+
+#include "dp_parser.h"
+#include "dpu_power_handle.h"
+
+/**
+ * sruct dp_power - DisplayPort's power related data
+ *
+ * @init: initializes the regulators/core clocks/GPIOs/pinctrl
+ * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
+ * @clk_enable: enable/disable the DP clocks
+ * @set_pixel_clk_parent: set the parent of DP pixel clock
+ */
+struct dp_power {
+	int (*init)(struct dp_power *power, bool flip);
+	int (*deinit)(struct dp_power *power);
+	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
+				bool enable);
+	int (*set_pixel_clk_parent)(struct dp_power *power);
+	int (*power_client_init)(struct dp_power *power);
+	void (*power_client_deinit)(struct dp_power *power);
+};
+
+/**
+ * dp_power_get() - configure and get the DisplayPort power module data
+ *
+ * @parser: instance of parser module
+ * return: pointer to allocated power module data
+ *
+ * This API will configure the DisplayPort's power module and provides
+ * methods to be called by the client to configure the power related
+ * modueles.
+ */
+struct dp_power *dp_power_get(struct dp_parser *parser);
+
+/**
+ * dp_power_put() - release the power related resources
+ *
+ * @power: pointer to the power module's data
+ */
+void dp_power_put(struct dp_power *power);
+#endif /* _DP_POWER_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_reg.h b/drivers/gpu/drm/msm/dp/dp_reg.h
new file mode 100644
index 0000000..77b5c0e
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/dp_reg.h
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _DP_REG_H_
+#define _DP_REG_H_
+
+/* DP_TX Registers */
+#define DP_HW_VERSION				(0x00000000)
+#define DP_SW_RESET				(0x00000010)
+#define DP_PHY_CTRL				(0x00000014)
+#define DP_CLK_CTRL				(0x00000018)
+#define DP_CLK_ACTIVE				(0x0000001C)
+#define DP_INTR_STATUS				(0x00000020)
+#define DP_INTR_STATUS2				(0x00000024)
+#define DP_INTR_STATUS3				(0x00000028)
+
+#define DP_DP_HPD_CTRL				(0x00000000)
+#define DP_DP_HPD_INT_STATUS			(0x00000004)
+#define DP_DP_HPD_INT_ACK			(0x00000008)
+#define DP_DP_HPD_INT_MASK			(0x0000000C)
+#define DP_DP_HPD_REFTIMER			(0x00000018)
+#define DP_DP_HPD_EVENT_TIME_0			(0x0000001C)
+#define DP_DP_HPD_EVENT_TIME_1			(0x00000020)
+#define DP_AUX_CTRL				(0x00000030)
+#define DP_AUX_DATA				(0x00000034)
+#define DP_AUX_TRANS_CTRL			(0x00000038)
+#define DP_TIMEOUT_COUNT			(0x0000003C)
+#define DP_AUX_LIMITS				(0x00000040)
+#define DP_AUX_STATUS				(0x00000044)
+
+#define DP_DPCD_CP_IRQ				(0x201)
+#define DP_DPCD_RXSTATUS			(0x69493)
+
+#define DP_INTERRUPT_TRANS_NUM			(0x000000A0)
+
+#define DP_MAINLINK_CTRL			(0x00000000)
+#define DP_STATE_CTRL				(0x00000004)
+#define DP_CONFIGURATION_CTRL			(0x00000008)
+#define DP_SOFTWARE_MVID			(0x00000010)
+#define DP_SOFTWARE_NVID			(0x00000018)
+#define DP_TOTAL_HOR_VER			(0x0000001C)
+#define DP_START_HOR_VER_FROM_SYNC		(0x00000020)
+#define DP_HSYNC_VSYNC_WIDTH_POLARITY		(0x00000024)
+#define DP_ACTIVE_HOR_VER			(0x00000028)
+#define DP_MISC1_MISC0				(0x0000002C)
+#define DP_VALID_BOUNDARY			(0x00000030)
+#define DP_VALID_BOUNDARY_2			(0x00000034)
+#define DP_LOGICAL2PHYSICAL_LANE_MAPPING	(0x00000038)
+
+#define DP_MAINLINK_READY			(0x00000040)
+#define DP_MAINLINK_LEVELS			(0x00000044)
+#define DP_TU					(0x0000004C)
+
+#define DP_HBR2_COMPLIANCE_SCRAMBLER_RESET	(0x00000054)
+#define DP_TEST_80BIT_CUSTOM_PATTERN_REG0	(0x000000C0)
+#define DP_TEST_80BIT_CUSTOM_PATTERN_REG1	(0x000000C4)
+#define DP_TEST_80BIT_CUSTOM_PATTERN_REG2	(0x000000C8)
+
+#define MMSS_DP_MISC1_MISC0			(0x0000002C)
+#define MMSS_DP_AUDIO_TIMING_GEN		(0x00000080)
+#define MMSS_DP_AUDIO_TIMING_RBR_32		(0x00000084)
+#define MMSS_DP_AUDIO_TIMING_HBR_32		(0x00000088)
+#define MMSS_DP_AUDIO_TIMING_RBR_44		(0x0000008C)
+#define MMSS_DP_AUDIO_TIMING_HBR_44		(0x00000090)
+#define MMSS_DP_AUDIO_TIMING_RBR_48		(0x00000094)
+#define MMSS_DP_AUDIO_TIMING_HBR_48		(0x00000098)
+
+#define MMSS_DP_PSR_CRC_RG			(0x00000154)
+#define MMSS_DP_PSR_CRC_B			(0x00000158)
+
+#define DP_COMPRESSION_MODE_CTRL		(0x00000180)
+
+#define MMSS_DP_AUDIO_CFG			(0x00000200)
+#define MMSS_DP_AUDIO_STATUS			(0x00000204)
+#define MMSS_DP_AUDIO_PKT_CTRL			(0x00000208)
+#define MMSS_DP_AUDIO_PKT_CTRL2			(0x0000020C)
+#define MMSS_DP_AUDIO_ACR_CTRL			(0x00000210)
+#define MMSS_DP_AUDIO_CTRL_RESET		(0x00000214)
+
+#define MMSS_DP_SDP_CFG				(0x00000228)
+#define MMSS_DP_SDP_CFG2			(0x0000022C)
+#define MMSS_DP_AUDIO_TIMESTAMP_0		(0x00000230)
+#define MMSS_DP_AUDIO_TIMESTAMP_1		(0x00000234)
+
+#define MMSS_DP_AUDIO_STREAM_0			(0x00000240)
+#define MMSS_DP_AUDIO_STREAM_1			(0x00000244)
+
+#define MMSS_DP_EXTENSION_0			(0x00000250)
+#define MMSS_DP_EXTENSION_1			(0x00000254)
+#define MMSS_DP_EXTENSION_2			(0x00000258)
+#define MMSS_DP_EXTENSION_3			(0x0000025C)
+#define MMSS_DP_EXTENSION_4			(0x00000260)
+#define MMSS_DP_EXTENSION_5			(0x00000264)
+#define MMSS_DP_EXTENSION_6			(0x00000268)
+#define MMSS_DP_EXTENSION_7			(0x0000026C)
+#define MMSS_DP_EXTENSION_8			(0x00000270)
+#define MMSS_DP_EXTENSION_9			(0x00000274)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_0		(0x00000278)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_1		(0x0000027C)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_2		(0x00000280)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_3		(0x00000284)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_4		(0x00000288)
+#define MMSS_DP_AUDIO_COPYMANAGEMENT_5		(0x0000028C)
+#define MMSS_DP_AUDIO_ISRC_0			(0x00000290)
+#define MMSS_DP_AUDIO_ISRC_1			(0x00000294)
+#define MMSS_DP_AUDIO_ISRC_2			(0x00000298)
+#define MMSS_DP_AUDIO_ISRC_3			(0x0000029C)
+#define MMSS_DP_AUDIO_ISRC_4			(0x000002A0)
+#define MMSS_DP_AUDIO_ISRC_5			(0x000002A4)
+#define MMSS_DP_AUDIO_INFOFRAME_0		(0x000002A8)
+#define MMSS_DP_AUDIO_INFOFRAME_1		(0x000002AC)
+#define MMSS_DP_AUDIO_INFOFRAME_2		(0x000002B0)
+
+#define MMSS_DP_GENERIC0_0			(0x00000300)
+#define MMSS_DP_GENERIC0_1			(0x00000304)
+#define MMSS_DP_GENERIC0_2			(0x00000308)
+#define MMSS_DP_GENERIC0_3			(0x0000030C)
+#define MMSS_DP_GENERIC0_4			(0x00000310)
+#define MMSS_DP_GENERIC0_5			(0x00000314)
+#define MMSS_DP_GENERIC0_6			(0x00000318)
+#define MMSS_DP_GENERIC0_7			(0x0000031C)
+#define MMSS_DP_GENERIC0_8			(0x00000320)
+#define MMSS_DP_GENERIC0_9			(0x00000324)
+#define MMSS_DP_GENERIC1_0			(0x00000328)
+#define MMSS_DP_GENERIC1_1			(0x0000032C)
+#define MMSS_DP_GENERIC1_2			(0x00000330)
+#define MMSS_DP_GENERIC1_3			(0x00000334)
+#define MMSS_DP_GENERIC1_4			(0x00000338)
+#define MMSS_DP_GENERIC1_5			(0x0000033C)
+#define MMSS_DP_GENERIC1_6			(0x00000340)
+#define MMSS_DP_GENERIC1_7			(0x00000344)
+#define MMSS_DP_GENERIC1_8			(0x00000348)
+#define MMSS_DP_GENERIC1_9			(0x0000034C)
+
+#define MMSS_DP_VSCEXT_0			(0x000002D0)
+#define MMSS_DP_VSCEXT_1			(0x000002D4)
+#define MMSS_DP_VSCEXT_2			(0x000002D8)
+#define MMSS_DP_VSCEXT_3			(0x000002DC)
+#define MMSS_DP_VSCEXT_4			(0x000002E0)
+#define MMSS_DP_VSCEXT_5			(0x000002E4)
+#define MMSS_DP_VSCEXT_6			(0x000002E8)
+#define MMSS_DP_VSCEXT_7			(0x000002EC)
+#define MMSS_DP_VSCEXT_8			(0x000002F0)
+#define MMSS_DP_VSCEXT_9			(0x000002F4)
+
+#define MMSS_DP_BIST_ENABLE			(0x00000000)
+#define MMSS_DP_TIMING_ENGINE_EN		(0x00000010)
+#define MMSS_DP_INTF_CONFIG			(0x00000014)
+#define MMSS_DP_INTF_HSYNC_CTL			(0x00000018)
+#define MMSS_DP_INTF_VSYNC_PERIOD_F0		(0x0000001C)
+#define MMSS_DP_INTF_VSYNC_PERIOD_F1		(0x00000020)
+#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0	(0x00000024)
+#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1	(0x00000028)
+#define MMSS_INTF_DISPLAY_V_START_F0		(0x0000002C)
+#define MMSS_INTF_DISPLAY_V_START_F1		(0x00000030)
+#define MMSS_DP_INTF_DISPLAY_V_END_F0		(0x00000034)
+#define MMSS_DP_INTF_DISPLAY_V_END_F1		(0x00000038)
+#define MMSS_DP_INTF_ACTIVE_V_START_F0		(0x0000003C)
+#define MMSS_DP_INTF_ACTIVE_V_START_F1		(0x00000040)
+#define MMSS_DP_INTF_ACTIVE_V_END_F0		(0x00000044)
+#define MMSS_DP_INTF_ACTIVE_V_END_F1		(0x00000048)
+#define MMSS_DP_INTF_DISPLAY_HCTL		(0x0000004C)
+#define MMSS_DP_INTF_ACTIVE_HCTL		(0x00000050)
+#define MMSS_DP_INTF_POLARITY_CTL		(0x00000058)
+#define MMSS_DP_TPG_MAIN_CONTROL		(0x00000060)
+#define MMSS_DP_TPG_VIDEO_CONFIG		(0x00000064)
+#define MMSS_DP_ASYNC_FIFO_CONFIG		(0x00000088)
+
+/*DP PHY Register offsets */
+#define DP_PHY_REVISION_ID0                     (0x00000000)
+#define DP_PHY_REVISION_ID1                     (0x00000004)
+#define DP_PHY_REVISION_ID2                     (0x00000008)
+#define DP_PHY_REVISION_ID3                     (0x0000000C)
+
+#define DP_PHY_CFG                              (0x00000010)
+#define DP_PHY_PD_CTL                           (0x00000018)
+#define DP_PHY_MODE                             (0x0000001C)
+
+#define DP_PHY_AUX_CFG0                         (0x00000020)
+#define DP_PHY_AUX_CFG1                         (0x00000024)
+#define DP_PHY_AUX_CFG2                         (0x00000028)
+#define DP_PHY_AUX_CFG3                         (0x0000002C)
+#define DP_PHY_AUX_CFG4                         (0x00000030)
+#define DP_PHY_AUX_CFG5                         (0x00000034)
+#define DP_PHY_AUX_CFG6                         (0x00000038)
+#define DP_PHY_AUX_CFG7                         (0x0000003C)
+#define DP_PHY_AUX_CFG8                         (0x00000040)
+#define DP_PHY_AUX_CFG9                         (0x00000044)
+#define DP_PHY_AUX_INTERRUPT_MASK               (0x00000048)
+#define DP_PHY_AUX_INTERRUPT_CLEAR              (0x0000004C)
+#define DP_PHY_AUX_BIST_CFG			(0x00000050)
+
+#define DP_PHY_VCO_DIV				0x0064
+#define DP_PHY_TX0_TX1_LANE_CTL			0x006C
+#define DP_PHY_TX2_TX3_LANE_CTL			0x0088
+
+#define DP_PHY_SPARE0				(0x00AC)
+#define DP_PHY_STATUS				(0x00C0)
+
+/* Tx registers */
+#define TXn_BIST_MODE_LANENO			0x0000
+#define TXn_CLKBUF_ENABLE			0x0008
+#define TXn_TX_EMP_POST1_LVL			0x000C
+
+#define TXn_TX_DRV_LVL				0x001C
+
+#define TXn_RESET_TSYNC_EN			0x0024
+#define TXn_PRE_STALL_LDO_BOOST_EN		0x0028
+#define TXn_TX_BAND				0x002C
+#define TXn_SLEW_CNTL				0x0030
+#define TXn_INTERFACE_SELECT			0x0034
+
+#define TXn_RES_CODE_LANE_TX			0x003C
+#define TXn_RES_CODE_LANE_RX			0x0040
+#define TXn_RES_CODE_LANE_OFFSET_TX		0x0044
+#define TXn_RES_CODE_LANE_OFFSET_RX		0x0048
+
+#define TXn_DEBUG_BUS_SEL			0x0058
+#define TXn_TRANSCEIVER_BIAS_EN			0x005C
+#define TXn_HIGHZ_DRVR_EN			0x0060
+#define TXn_TX_POL_INV				0x0064
+#define TXn_PARRATE_REC_DETECT_IDLE_EN		0x0068
+
+#define TXn_LANE_MODE_1				0x008C
+
+#define TXn_TRAN_DRVR_EMP_EN			0x00C0
+#define TXn_TX_INTERFACE_MODE			0x00C4
+
+#define TXn_VMODE_CTRL1				0x00F0
+
+/* PLL register offset */
+#define QSERDES_COM_ATB_SEL1			0x0000
+#define QSERDES_COM_ATB_SEL2			0x0004
+#define QSERDES_COM_FREQ_UPDATE			0x0008
+#define QSERDES_COM_BG_TIMER			0x000C
+#define QSERDES_COM_SSC_EN_CENTER		0x0010
+#define QSERDES_COM_SSC_ADJ_PER1		0x0014
+#define QSERDES_COM_SSC_ADJ_PER2		0x0018
+#define QSERDES_COM_SSC_PER1			0x001C
+#define QSERDES_COM_SSC_PER2			0x0020
+#define QSERDES_COM_SSC_STEP_SIZE1		0x0024
+#define QSERDES_COM_SSC_STEP_SIZE2		0x0028
+#define QSERDES_COM_POST_DIV			0x002C
+#define QSERDES_COM_POST_DIV_MUX		0x0030
+#define QSERDES_COM_BIAS_EN_CLKBUFLR_EN		0x0034
+#define QSERDES_COM_CLK_ENABLE1			0x0038
+#define QSERDES_COM_SYS_CLK_CTRL		0x003C
+#define QSERDES_COM_SYSCLK_BUF_ENABLE		0x0040
+#define QSERDES_COM_PLL_EN			0x0044
+#define QSERDES_COM_PLL_IVCO			0x0048
+#define QSERDES_COM_CMN_IETRIM			0x004C
+#define QSERDES_COM_CMN_IPTRIM			0x0050
+
+#define QSERDES_COM_CP_CTRL_MODE0		0x0060
+#define QSERDES_COM_CP_CTRL_MODE1		0x0064
+#define QSERDES_COM_PLL_RCTRL_MODE0		0x0068
+#define QSERDES_COM_PLL_RCTRL_MODE1		0x006C
+#define QSERDES_COM_PLL_CCTRL_MODE0		0x0070
+#define QSERDES_COM_PLL_CCTRL_MODE1		0x0074
+#define QSERDES_COM_PLL_CNTRL			0x0078
+#define QSERDES_COM_BIAS_EN_CTRL_BY_PSM		0x007C
+#define QSERDES_COM_SYSCLK_EN_SEL		0x0080
+#define QSERDES_COM_CML_SYSCLK_SEL		0x0084
+#define QSERDES_COM_RESETSM_CNTRL		0x0088
+#define QSERDES_COM_RESETSM_CNTRL2		0x008C
+#define QSERDES_COM_LOCK_CMP_EN			0x0090
+#define QSERDES_COM_LOCK_CMP_CFG		0x0094
+#define QSERDES_COM_LOCK_CMP1_MODE0		0x0098
+#define QSERDES_COM_LOCK_CMP2_MODE0		0x009C
+#define QSERDES_COM_LOCK_CMP3_MODE0		0x00A0
+
+#define QSERDES_COM_DEC_START_MODE0		0x00B0
+#define QSERDES_COM_DEC_START_MODE1		0x00B4
+#define QSERDES_COM_DIV_FRAC_START1_MODE0	0x00B8
+#define QSERDES_COM_DIV_FRAC_START2_MODE0	0x00BC
+#define QSERDES_COM_DIV_FRAC_START3_MODE0	0x00C0
+#define QSERDES_COM_DIV_FRAC_START1_MODE1	0x00C4
+#define QSERDES_COM_DIV_FRAC_START2_MODE1	0x00C8
+#define QSERDES_COM_DIV_FRAC_START3_MODE1	0x00CC
+#define QSERDES_COM_INTEGLOOP_INITVAL		0x00D0
+#define QSERDES_COM_INTEGLOOP_EN		0x00D4
+#define QSERDES_COM_INTEGLOOP_GAIN0_MODE0	0x00D8
+#define QSERDES_COM_INTEGLOOP_GAIN1_MODE0	0x00DC
+#define QSERDES_COM_INTEGLOOP_GAIN0_MODE1	0x00E0
+#define QSERDES_COM_INTEGLOOP_GAIN1_MODE1	0x00E4
+#define QSERDES_COM_VCOCAL_DEADMAN_CTRL		0x00E8
+#define QSERDES_COM_VCO_TUNE_CTRL		0x00EC
+#define QSERDES_COM_VCO_TUNE_MAP		0x00F0
+
+#define QSERDES_COM_CMN_STATUS			0x0124
+#define QSERDES_COM_RESET_SM_STATUS		0x0128
+
+#define QSERDES_COM_CLK_SEL			0x0138
+#define QSERDES_COM_HSCLK_SEL			0x013C
+
+#define QSERDES_COM_CORECLK_DIV_MODE0		0x0148
+
+#define QSERDES_COM_SW_RESET			0x0150
+#define QSERDES_COM_CORE_CLK_EN			0x0154
+#define QSERDES_COM_C_READY_STATUS		0x0158
+#define QSERDES_COM_CMN_CONFIG			0x015C
+
+#define QSERDES_COM_SVS_MODE_CLK_SEL		0x0164
+
+/* DP MMSS_CC registers */
+#define MMSS_DP_LINK_CMD_RCGR			(0x0138)
+#define MMSS_DP_LINK_CFG_RCGR			(0x013C)
+#define MMSS_DP_PIXEL_M				(0x0174)
+#define MMSS_DP_PIXEL_N				(0x0178)
+
+/* DP HDCP 1.3 registers */
+#define DP_HDCP_CTRL                                   (0x0A0)
+#define DP_HDCP_STATUS                                 (0x0A4)
+#define DP_HDCP_SW_UPPER_AKSV                          (0x098)
+#define DP_HDCP_SW_LOWER_AKSV                          (0x09C)
+#define DP_HDCP_ENTROPY_CTRL0                          (0x350)
+#define DP_HDCP_ENTROPY_CTRL1                          (0x35C)
+#define DP_HDCP_SHA_STATUS                             (0x0C8)
+#define DP_HDCP_RCVPORT_DATA2_0                        (0x0B0)
+#define DP_HDCP_RCVPORT_DATA3                          (0x0A4)
+#define DP_HDCP_RCVPORT_DATA4                          (0x0A8)
+#define DP_HDCP_RCVPORT_DATA5                          (0x0C0)
+#define DP_HDCP_RCVPORT_DATA6                          (0x0C4)
+
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_CTRL           (0x024)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_DATA           (0x028)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA0      (0x004)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA1      (0x008)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA7      (0x00C)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA8      (0x010)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA9      (0x014)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA10     (0x018)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA11     (0x01C)
+#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA12     (0x020)
+
+/* USB3 DP COM registers */
+#define USB3_DP_COM_RESET_OVRD_CTRL (0x1C)
+#define USB3_DP_COM_PHY_MODE_CTRL   (0x00)
+#define USB3_DP_COM_SW_RESET        (0x04)
+#define USB3_DP_COM_TYPEC_CTRL      (0x10)
+#define USB3_DP_COM_SWI_CTRL        (0x0c)
+#define USB3_DP_COM_POWER_DOWN_CTRL (0x08)
+
+
+
+#endif /* _DP_REG_H_ */
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index f5cd7f6..be801be 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -1367,6 +1367,7 @@ static int __init msm_drm_register(void)
 	msm_dsi_register();
 	msm_edp_register();
 	msm_hdmi_register();
+	msm_dp_register();
 	adreno_register();
 	return platform_driver_register(&msm_platform_driver);
 }
@@ -1375,6 +1376,7 @@ static void __exit msm_drm_unregister(void)
 {
 	DBG("fini");
 	platform_driver_unregister(&msm_platform_driver);
+	msm_dp_unregister();
 	msm_hdmi_unregister();
 	adreno_unregister();
 	msm_edp_unregister();
diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
index 9d11f32..fb1e6f4 100644
--- a/drivers/gpu/drm/msm/msm_drv.h
+++ b/drivers/gpu/drm/msm/msm_drv.h
@@ -176,6 +176,7 @@ struct msm_drm_private {
 	/* DSI is shared by mdp4 and mdp5 */
 	struct msm_dsi *dsi[2];
 
+	struct msm_dp *dp;
 	/* when we have more than one 'msm_gpu' these need to be an array: */
 	struct msm_gpu *gpu;
 	struct msm_file_private *lastctx;
@@ -364,6 +365,27 @@ static inline int msm_dsi_modeset_init(struct msm_dsi *msm_dsi,
 }
 #endif
 
+#ifdef CONFIG_DRM_MSM_DP
+int __init msm_dp_register(void);
+void __exit msm_dp_unregister(void);
+int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
+			 struct drm_encoder *encoder);
+#else
+static inline int __init msm_dp_register(void)
+{
+	return -EINVAL;
+}
+static inline void __exit msm_dp_unregister(void)
+{
+}
+static inline int msm_dp_modeset_init(struct msm_dp *dp_display,
+				       struct drm_device *dev,
+				       struct drm_encoder *encoder)
+{
+	return -EINVAL;
+}
+#endif
+
 void __init msm_mdp_register(void);
 void __exit msm_mdp_unregister(void);
 void __init msm_dpu_register(void);
diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
index 2a3843f..b0816f5 100644
--- a/include/drm/drm_dp_helper.h
+++ b/include/drm/drm_dp_helper.h
@@ -551,6 +551,8 @@
 # define DP_TEST_LINK_EDID_READ		    (1 << 2)
 # define DP_TEST_LINK_PHY_TEST_PATTERN	    (1 << 3) /* DPCD >= 1.1 */
 # define DP_TEST_LINK_FAUX_PATTERN	    (1 << 4) /* DPCD >= 1.2 */
+# define DP_TEST_LINK_AUDIO_PATTERN     (1 << 5)
+# define DP_TEST_LINK_AUDIO_DISABLED_VIDEO (1 << 6)
 
 #define DP_TEST_LINK_RATE		    0x219
 # define DP_LINK_RATE_162		    (0x6)
@@ -639,6 +641,13 @@
 #define	DP_TEST_80BIT_CUSTOM_PATTERN_71_64  0x258
 #define	DP_TEST_80BIT_CUSTOM_PATTERN_79_72  0x259
 
+#define DP_TEST_PHY_PATTERN_NONE			0x0
+#define DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING	0x1
+#define DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT 0x2
+#define DP_TEST_PHY_PATTERN_PRBS7			0x3
+#define DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN	0x4
+#define DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN	0x5
+
 #define DP_TEST_RESPONSE		    0x260
 # define DP_TEST_ACK			    (1 << 0)
 # define DP_TEST_NAK			    (1 << 1)
@@ -648,6 +657,16 @@
 
 #define DP_TEST_SINK			    0x270
 # define DP_TEST_SINK_START		    (1 << 0)
+#define DP_TEST_AUDIO_MODE		    0x271
+#define DP_TEST_AUDIO_PATTERN_TYPE	    0x272
+#define DP_TEST_AUDIO_PERIOD_CH1	    0x273
+#define DP_TEST_AUDIO_PERIOD_CH2	    0x274
+#define DP_TEST_AUDIO_PERIOD_CH3	    0x275
+#define DP_TEST_AUDIO_PERIOD_CH4	    0x276
+#define DP_TEST_AUDIO_PERIOD_CH5	    0x277
+#define DP_TEST_AUDIO_PERIOD_CH6	    0x278
+#define DP_TEST_AUDIO_PERIOD_CH7	    0x279
+#define DP_TEST_AUDIO_PERIOD_CH8	    0x27A
 
 #define DP_FEC_STATUS			    0x280    /* 1.4 */
 # define DP_FEC_DECODE_EN_DETECTED	    (1 << 0)
-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project

_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Jordan Crouse]

On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> Add the needed displayPort files to enable DP driver
> on msm target.
> 
> "dp_display" module is the main module that calls into
> other sub-modules. "dp_drm" file represents the interface
> between DRM framework and DP driver.
> 
> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>  drivers/gpu/drm/msm/Makefile                |   15 +-
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 ++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 +++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 +++++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>  include/drm/drm_dp_helper.h                 |   19 +
>  30 files changed, 10887 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
> 
> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
> index 843a9d4..c363f24 100644
> --- a/drivers/gpu/drm/msm/Kconfig
> +++ b/drivers/gpu/drm/msm/Kconfig
> @@ -49,6 +49,15 @@ config DRM_MSM_HDMI_HDCP
>  	help
>  	  Choose this option to enable HDCP state machine
>  
> +config DRM_MSM_DP
> +	bool "Enable DP support in MSM DRM driver"
> +	depends on DRM_MSM
> +	default n

default n should be implied so you don't need to add it.

> +	help
> +	  Compile in support for DP driver in msm drm
> +	  driver. DP external display support is enabled
> +	  through this config option. It can be primary or
> +	  secondary display on device.
>  config DRM_MSM_DSI
>  	bool "Enable DSI support in MSM DRM driver"
>  	depends on DRM_MSM
> diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
> index 19ab521..765a8d8 100644
> --- a/drivers/gpu/drm/msm/Makefile
> +++ b/drivers/gpu/drm/msm/Makefile
> @@ -2,6 +2,7 @@
>  ccflags-y := -Idrivers/gpu/drm/msm
>  ccflags-y += -Idrivers/gpu/drm/msm/disp/dpu1
>  ccflags-$(CONFIG_DRM_MSM_DSI) += -Idrivers/gpu/drm/msm/dsi
> +ccflags-$(CONFIG_DRM_MSM_DP) += -Idrivers/gpu/drm/msm/dp
>  
>  msm-y := \
>  	adreno/adreno_device.o \
> @@ -93,7 +94,19 @@ msm-y := \
>  	msm_submitqueue.o
>  
>  msm-$(CONFIG_DEBUG_FS) += adreno/a5xx_debugfs.o \
> -			  disp/dpu1/dpu_dbg.o
> +			  disp/dpu1/dpu_dbg.o \
> +			  dp/dp_debug.o
> +
> +msm-$(CONFIG_DRM_MSM_DP)+= dp/dp_extcon.o \
> +	dp/dp_parser.o \
> +	dp/dp_power.o \
> +	dp/dp_catalog.o \
> +	dp/dp_aux.o \
> +	dp/dp_panel.o \
> +	dp/dp_link.o \
> +	dp/dp_ctrl.o \
> +	dp/dp_display.o \
> +	dp/dp_drm.o
>  
>  msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
>  msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> index 790d39f..0f53a15 100644
> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> @@ -14,10 +14,216 @@
>  #include <linux/clk.h>
>  #include <linux/clk/clk-conf.h>
>  #include <linux/err.h>
> +#include <linux/io.h>
> +#include <linux/regulator/consumer.h>
>  #include <linux/delay.h>
>  
>  #include "dpu_io_util.h"
>  
> +static struct resource *msm_dss_get_res_byname(struct platform_device *pdev,
> +					       unsigned int type,
> +					       const char *name)
> +{
> +	struct resource *res = NULL;
> +
> +	res = platform_get_resource_byname(pdev, type, name);
> +	if (!res)
> +		DEV_ERR("%s: '%s' resource not found\n", __func__, name);
> +
> +	return res;
> +} /* msm_dss_get_res_byname */
> +
> +int msm_dss_ioremap_byname(struct platform_device *pdev,
> +			   struct dss_io_data *io_data, const char *name)
> +{
> +	struct resource *res = NULL;
> +
> +	if (!pdev || !io_data) {
> +		DEV_ERR("%pS->%s: invalid input\n",
> +			__builtin_return_address(0), __func__);
> +		return -EINVAL;
> +	}
> +
> +	res = msm_dss_get_res_byname(pdev, IORESOURCE_MEM, name);
> +	if (!res) {
> +		DEV_ERR("%pS->%s: '%s' msm_dss_get_res_byname failed\n",
> +			__builtin_return_address(0), __func__, name);
> +		return -ENODEV;
> +	}
> +
> +	io_data->len = (u32)resource_size(res);
> +	io_data->base = ioremap(res->start, io_data->len);
> +	if (!io_data->base) {
> +		DEV_ERR("%pS->%s: '%s' ioremap failed\n",
> +			__builtin_return_address(0), __func__, name);
> +		return -EIO;
> +	}
> +
> +	return 0;
> +} /* msm_dss_ioremap_byname */

We already have a function called msm_ioremap() that you can use instead of
this. Bonus, it uses devm_ so you don't need to worry about unmap.
> +
> +void msm_dss_iounmap(struct dss_io_data *io_data)
> +{
> +	if (!io_data) {
> +		DEV_ERR("%pS->%s: invalid input\n",
> +			__builtin_return_address(0), __func__);
> +		return;
> +	}
> +
> +	if (io_data->base) {
> +		iounmap(io_data->base);
> +		io_data->base = NULL;
> +	}
> +	io_data->len = 0;
> +} /* msm_dss_iounmap */
>
if you use the function above you shouldn't need this one anymore.

> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
> +			int num_vreg, int config)
> +{
> +	int i = 0, rc = 0;
> +	struct dss_vreg *curr_vreg = NULL;
> +	enum dss_vreg_type type;
> +
> +	if (!in_vreg || !num_vreg)
> +		return rc;
> +
> +	if (config) {
> +		for (i = 0; i < num_vreg; i++) {
> +			curr_vreg = &in_vreg[i];
> +			curr_vreg->vreg = regulator_get(dev,
> +				curr_vreg->vreg_name);
> +			rc = PTR_RET(curr_vreg->vreg);
> +			if (rc) {

This should be IS_ERR(rc)) and then use PTR_ERR() to take it apart if you need
it for your return value or error message.  PTR_RET() has been deprecated.

> +				DEV_ERR("%pS->%s: %s get failed. rc=%d\n",
> +					 __builtin_return_address(0), __func__,
> +					 curr_vreg->vreg_name, rc);

If you care about the stack here then consider using WARN instead of
__builtin_return_address(0) and __func__.  It will give you what you need in a
standard way.

> +				curr_vreg->vreg = NULL;
> +				goto vreg_get_fail;
> +			}
> +			type = (regulator_count_voltages(curr_vreg->vreg) > 0)
> +					? DSS_REG_LDO : DSS_REG_VS;
> +			if (type == DSS_REG_LDO) {
> +				rc = regulator_set_voltage(
> +					curr_vreg->vreg,
> +					curr_vreg->min_voltage,
> +					curr_vreg->max_voltage);
> +				if (rc < 0) {
> +					DEV_ERR("%pS->%s: %s set vltg fail\n",

Same as above - use WARN if you can.  Try not to use abbreviations in log
messages - 'voltage' isn't much bigger and it is a lot more understandable
especially for non native speakers.

> +						__builtin_return_address(0),
> +						__func__,
> +						curr_vreg->vreg_name);
> +					goto vreg_set_voltage_fail;
> +				}
> +			}
> +		}
> +	} else {

This clause shares nothing with the rest of the function and proves there is no
reason to not have separate functions for setting up and taking down instead of
using the boolean flag.

> +		for (i = num_vreg-1; i >= 0; i--) {
> +			curr_vreg = &in_vreg[i];
> +			if (curr_vreg->vreg) {
> +				type = (regulator_count_voltages(
> +					curr_vreg->vreg) > 0)
> +					? DSS_REG_LDO : DSS_REG_VS;
> +				if (type == DSS_REG_LDO) {
> +					regulator_set_voltage(curr_vreg->vreg,
> +						0, curr_vreg->max_voltage);
> +				}
> +				regulator_put(curr_vreg->vreg);
> +				curr_vreg->vreg = NULL;
> +			}
> +		}
> +	}
> +	return 0;
> +
> +vreg_unconfig:
> +if (type == DSS_REG_LDO)
> +	regulator_set_load(curr_vreg->vreg, 0);

Both paths above use regulator_set_voltage(), so I'm not sure if
regulator_set_load() is what you intend here.

> +
> +vreg_set_voltage_fail:
> +	regulator_put(curr_vreg->vreg);
> +	curr_vreg->vreg = NULL;
> +
> +vreg_get_fail:
> +	for (i--; i >= 0; i--) {
> +		curr_vreg = &in_vreg[i];
> +		type = (regulator_count_voltages(curr_vreg->vreg) > 0)
> +			? DSS_REG_LDO : DSS_REG_VS;
> +		goto vreg_unconfig;

Oh my - jumping back out of a loop with goto is not okay. This entire block is
basically just trying to take the place of the takedown clause above so if you
use a separate function to put away the regulators you can just call that
instead.

> +	}
> +	return rc;
> +} /* msm_dss_config_vreg */

Maybe a nit, but we all know how to read C code. We don't need a comment to
let us know when a bracket closes out a function.

> +
> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg, int enable)
> +{
> +	int i = 0, rc = 0;
> +	bool need_sleep;
> +
> +	if (enable) {
> +		for (i = 0; i < num_vreg; i++) {
> +			rc = PTR_RET(in_vreg[i].vreg);
> +			if (rc) {
> +				DEV_ERR("%pS->%s: %s regulator error. rc=%d\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name, rc);

As above - use WARN if you can.

> +				goto vreg_set_opt_mode_fail;
> +			}
> +			need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
> +			if (in_vreg[i].pre_on_sleep && need_sleep)
> +				usleep_range(in_vreg[i].pre_on_sleep * 1000,
> +					in_vreg[i].pre_on_sleep * 1000);
> +			rc = regulator_set_load(in_vreg[i].vreg,
> +				in_vreg[i].enable_load);
> +			if (rc < 0) {
> +				DEV_ERR("%pS->%s: %s set opt m fail\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name);
> +				goto vreg_set_opt_mode_fail;
> +			}
> +			rc = regulator_enable(in_vreg[i].vreg);
> +			if (in_vreg[i].post_on_sleep && need_sleep)
> +				usleep_range(in_vreg[i].post_on_sleep * 1000,
> +					in_vreg[i].post_on_sleep * 1000);
> +			if (rc < 0) {
> +				DEV_ERR("%pS->%s: %s enable failed\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name);
> +				goto disable_vreg;
> +			}
> +		}
> +	} else {

Also as above - this entire clause can stand alone in its own function. 
> +		for (i = num_vreg-1; i >= 0; i--) {
> +			if (in_vreg[i].pre_off_sleep)
> +				usleep_range(in_vreg[i].pre_off_sleep * 1000,
> +					in_vreg[i].pre_off_sleep * 1000);
> +			regulator_set_load(in_vreg[i].vreg,
> +				in_vreg[i].disable_load);
> +			regulator_disable(in_vreg[i].vreg);
> +			if (in_vreg[i].post_off_sleep)
> +				usleep_range(in_vreg[i].post_off_sleep * 1000,
> +					in_vreg[i].post_off_sleep * 1000);
> +		}
> +	}
> +	return rc;
> +
> +disable_vreg:
> +	regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
> +
> +vreg_set_opt_mode_fail:
> +	for (i--; i >= 0; i--) {
> +		if (in_vreg[i].pre_off_sleep)
> +			usleep_range(in_vreg[i].pre_off_sleep * 1000,
> +				in_vreg[i].pre_off_sleep * 1000);
> +		regulator_set_load(in_vreg[i].vreg,
> +			in_vreg[i].disable_load);
> +		regulator_disable(in_vreg[i].vreg);
> +		if (in_vreg[i].post_off_sleep)
> +			usleep_range(in_vreg[i].post_off_sleep * 1000,
> +				in_vreg[i].post_off_sleep * 1000);
> +	}
> 
This is essentially a recreation of the code above - you can just use the
standalone function for teardown.

> +	return rc;
> +} /* msm_dss_enable_vreg */
> +
> +
>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk)
>  {
>  	int i;
> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> index bc07381..524b394 100644
> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> @@ -15,6 +15,7 @@
>  
>  #include <linux/gpio.h>
>  #include <linux/platform_device.h>
> +#include <linux/regulator/consumer.h>
>  #include <linux/types.h>
>  
>  #define DEV_DBG(fmt, args...)   pr_debug(fmt, ##args)
> @@ -22,6 +23,39 @@
>  #define DEV_WARN(fmt, args...)  pr_warn(fmt, ##args)
>  #define DEV_ERR(fmt, args...)   pr_err(fmt, ##args)

This isn't part of this patch but I would love to see these guys turn
into standard functions.

> +struct dss_io_data {
> +	u32 len;
> +	void __iomem *base;
> +};
> +
> +/*
> +void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 debug);
> +u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug);
> +void dss_reg_dump(void __iomem *base, u32 len, const char *prefix, u32 debug);
> +
> +#define DSS_REG_W_ND(io, offset, val)  dss_reg_w(io, offset, val, false)
> +#define DSS_REG_W(io, offset, val)     dss_reg_w(io, offset, val, true)
> +#define DSS_REG_R_ND(io, offset)       dss_reg_r(io, offset, false)
> +#define DSS_REG_R(io, offset)          dss_reg_r(io, offset, true)
> +*/
> +enum dss_vreg_type {
> +	DSS_REG_LDO,
> +	DSS_REG_VS,
> +};
> +
> +struct dss_vreg {
> +	struct regulator *vreg; /* vreg handle */
> +	char vreg_name[32];
> +	int min_voltage;
> +	int max_voltage;
> +	int enable_load;
> +	int disable_load;
> +	int pre_on_sleep;
> +	int post_on_sleep;
> +	int pre_off_sleep;
> +	int post_off_sleep;
> +};
> +
>  struct dss_gpio {
>  	unsigned int gpio;
>  	unsigned int value;
> @@ -42,12 +76,22 @@ struct dss_clk {
>  };
>  
>  struct dss_module_power {
> +	unsigned int num_vreg;
> +	struct dss_vreg *vreg_config;
>  	unsigned int num_gpio;
>  	struct dss_gpio *gpio_config;
>  	unsigned int num_clk;
>  	struct dss_clk *clk_config;
>  };
>  
> +int msm_dss_ioremap_byname(struct platform_device *pdev,
> +			   struct dss_io_data *io_data, const char *name);
> +void msm_dss_iounmap(struct dss_io_data *io_data);
> +
> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
> +			int num_vreg, int config);
> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg,	int enable);
> +
>  int msm_dss_get_clk(struct device *dev, struct dss_clk *clk_arry, int num_clk);
>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk);
>  int msm_dss_clk_set_rate(struct dss_clk *clk_arry, int num_clk);
> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c b/drivers/gpu/drm/msm/dp/dp_aux.c
> new file mode 100644
> index 0000000..00b82c2
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_aux.c
> @@ -0,0 +1,570 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

Please use SPDX headers.

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/delay.h>
> +
> +#include "dp_aux.h"
> +
> +#define DP_AUX_ENUM_STR(x)		#x

You should use this #define closer to where it is used.

> +
> +enum {
> +	DP_AUX_DATA_INDEX_WRITE = BIT(31),
> +};

This enum of one is not needed - this could as easily be a #define or BIT(31)
used inline.

> +struct dp_aux_private {
> +	struct device *dev;
> +	struct dp_aux dp_aux;
> +	struct dp_catalog_aux *catalog;
> +	struct dp_aux_cfg *cfg;
> +
> +	struct mutex mutex;
> +	struct completion comp;
> +
> +	u32 aux_error_num;
> +	u32 retry_cnt;
> +	bool cmd_busy;
> +	bool native;
> +	bool read;
> +	bool no_send_addr;
> +	bool no_send_stop;
> +	u32 offset;
> +	u32 segment;
> +
> +	struct drm_dp_aux drm_aux;
> +};
> +
> +static char *dp_aux_get_error(u32 aux_error)
> +{
> +	switch (aux_error) {
> +	case DP_AUX_ERR_NONE:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_NONE);
> +	case DP_AUX_ERR_ADDR:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_ADDR);
> +	case DP_AUX_ERR_TOUT:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_TOUT);
> +	case DP_AUX_ERR_NACK:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_NACK);
> +	case DP_AUX_ERR_DEFER:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_DEFER);
> +	case DP_AUX_ERR_NACK_DEFER:
> +		return DP_AUX_ENUM_STR(DP_AUX_ERR_NACK_DEFER);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static u32 dp_aux_write(struct dp_aux_private *aux,
> +			struct drm_dp_aux_msg *msg)
> +{
> +	u32 data[4], reg, len;
> +	u8 *msgdata = msg->buffer;
> +	int const aux_cmd_fifo_len = 128;

This isn't useful since it is only used oncex, and constant values like 128 can
be safely used inline when it is needed.

> +	int i = 0;
> +
> +	if (aux->read)
> +		len = 4;
> +	else
> +		len = msg->size + 4;
> +
> +	/*
> +	 * cmd fifo only has depth of 144 bytes
> +	 * limit buf length to 128 bytes here
> +	 */
> +	if (len > aux_cmd_fifo_len) {
> +		pr_err("buf len error\n");

I'm not sure if its possible, but if we could get to dev_err for these that
would be fantastic (but don't go overboard if it is hard to get the dev pointer
all the way down here).

That said, this error message should be more informative - it should at least
say what the offending length is.

> +		return 0;
> +	}
> +
> +	/* Pack cmd and write to HW */
> +	data[0] = (msg->address >> 16) & 0xf; /* addr[19:16] */
> +	if (aux->read)
> +		data[0] |=  BIT(4); /* R/W */
> +
> +	data[1] = (msg->address >> 8) & 0xff;	/* addr[15:8] */
> +	data[2] = msg->address & 0xff;		/* addr[7:0] */
> +	data[3] = (msg->size - 1) & 0xff;	/* len[7:0] */
> +
> +	for (i = 0; i < len; i++) {
> +		reg = (i < 4) ? data[i] : msgdata[i - 4];
> +		reg = ((reg) << 8) & 0x0000ff00; /* index = 0, write */
> +		if (i == 0)
> +			reg |= DP_AUX_DATA_INDEX_WRITE;
> +		aux->catalog->data = reg;
> +		aux->catalog->write_data(aux->catalog);
> +	}
> +
> +	aux->catalog->clear_trans(aux->catalog, false);
> +
> +	reg = 0; /* Transaction number == 1 */
> +	if (!aux->native) { /* i2c */
> +		reg |= BIT(8);
> +
> +		if (aux->no_send_addr)
> +			reg |= BIT(10);
> +
> +		if (aux->no_send_stop)
> +			reg |= BIT(11);
> +	}
> +
> +	reg |= BIT(9);
> +	aux->catalog->data = reg;
> +	aux->catalog->write_trans(aux->catalog);
> +
> +	return len;
> +}
> +
> +static int dp_aux_cmd_fifo_tx(struct dp_aux_private *aux,
> +			      struct drm_dp_aux_msg *msg)
> +{
> +	u32 ret = 0, len = 0, timeout;
> +	int const aux_timeout_ms = HZ/4;

As above.  Generally I don't like const variables on the stack and especially if
they are as simple as this.  This forces the reviewer to look at the line where
it is used, and then back at the initialization to see what the value is.

> +
> +	reinit_completion(&aux->comp);
> +
> +	len = dp_aux_write(aux, msg);
> +	if (len == 0) {
> +		pr_err("DP AUX write failed\n");

There is only one way len can be zero and you already print an error message for
it.  You don't need another one.

> +		return -EINVAL;
> +	}
> +
> +	timeout = wait_for_completion_timeout(&aux->comp, aux_timeout_ms);

This can easily be HZ/4 for the timeout

> +	if (!timeout) {
> +		pr_err("aux %s timeout\n", (aux->read ? "read" : "write"));
> +		return -ETIMEDOUT;
> +	}
> +
> +	if (aux->aux_error_num == DP_AUX_ERR_NONE) {
> +		ret = len;
> +	} else {
> +		pr_err_ratelimited("aux err: %s\n",
> +			dp_aux_get_error(aux->aux_error_num));
> +
> +		ret = -EINVAL;
> +	}
> +
> +	return ret;
> +}
> +
> +static void dp_aux_cmd_fifo_rx(struct dp_aux_private *aux,
> +		struct drm_dp_aux_msg *msg)
> +{
> +	u32 data;
> +	u8 *dp;
> +	u32 i, actual_i;
> +	u32 len = msg->size;
> +
> +	aux->catalog->clear_trans(aux->catalog, true);
> +
> +	data = 0;
> +	data |= DP_AUX_DATA_INDEX_WRITE; /* INDEX_WRITE */
> +	data |= BIT(0);  /* read */
> +
> +	aux->catalog->data = data;
> +	aux->catalog->write_data(aux->catalog);
> +
> +	dp = msg->buffer;
> +
> +	/* discard first byte */
> +	data = aux->catalog->read_data(aux->catalog);
> +
> +	for (i = 0; i < len; i++) {
> +		data = aux->catalog->read_data(aux->catalog);
> +		*dp++ = (u8)((data >> 8) & 0xff);
> +
> +		actual_i = (data >> 16) & 0xFF;
> +		if (i != actual_i)
> +			pr_warn("Index mismatch: expected %d, found %d\n",
> +				i, actual_i);
> +	}
> +}
> +
> +static void dp_aux_native_handler(struct dp_aux_private *aux)
> +{
> +	u32 isr = aux->catalog->isr;
> +
> +	if (isr & DP_INTR_AUX_I2C_DONE)
> +		aux->aux_error_num = DP_AUX_ERR_NONE;
> +	else if (isr & DP_INTR_WRONG_ADDR)
> +		aux->aux_error_num = DP_AUX_ERR_ADDR;
> +	else if (isr & DP_INTR_TIMEOUT)
> +		aux->aux_error_num = DP_AUX_ERR_TOUT;
> +	if (isr & DP_INTR_NACK_DEFER)
> +		aux->aux_error_num = DP_AUX_ERR_NACK;
> +
> +	complete(&aux->comp);
> +}
> +
> +static void dp_aux_i2c_handler(struct dp_aux_private *aux)
> +{
> +	u32 isr = aux->catalog->isr;
> +
> +	if (isr & DP_INTR_AUX_I2C_DONE) {
> +		if (isr & (DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER))
> +			aux->aux_error_num = DP_AUX_ERR_NACK;
> +		else
> +			aux->aux_error_num = DP_AUX_ERR_NONE;
> +	} else {
> +		if (isr & DP_INTR_WRONG_ADDR)
> +			aux->aux_error_num = DP_AUX_ERR_ADDR;
> +		else if (isr & DP_INTR_TIMEOUT)
> +			aux->aux_error_num = DP_AUX_ERR_TOUT;
> +		if (isr & DP_INTR_NACK_DEFER)
> +			aux->aux_error_num = DP_AUX_ERR_NACK_DEFER;
> +		if (isr & DP_INTR_I2C_NACK)
> +			aux->aux_error_num = DP_AUX_ERR_NACK;
> +		if (isr & DP_INTR_I2C_DEFER)
> +			aux->aux_error_num = DP_AUX_ERR_DEFER;
> +	}
> +
> +	complete(&aux->comp);
> +}
> +
> +static void dp_aux_isr(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

I'm not 100% if this is possible or not but consider replacing this with

if (WARN_ON(!dp_aux))
   return;

To avoid the custom error message yet still handle the possibility of
a NULL pointer.  Of course, if it isn't possible then it should just be removed
entirely.

> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	aux->catalog->get_irq(aux->catalog, aux->cmd_busy);
> +
> +	if (!aux->cmd_busy)
> +		return;
> +
> +	if (aux->native)
> +		dp_aux_native_handler(aux);
> +	else
> +		dp_aux_i2c_handler(aux);
> +}
> +
> +static void dp_aux_reconfig(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

As above - WARN_ON can be useful here.

> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	aux->catalog->update_aux_cfg(aux->catalog,
> +			aux->cfg, PHY_AUX_CFG1);
> +	aux->catalog->reset(aux->catalog);
> +}
> +
> +static void dp_aux_update_offset_and_segment(struct dp_aux_private *aux,
> +					     struct drm_dp_aux_msg *input_msg)
> +{
> +	u32 const edid_address = 0x50;
> +	u32 const segment_address = 0x30;

Prefer if you didn't use const variables on the stack.  They seem to be popular
in this code so I won't point them out every time.

> +	bool i2c_read = input_msg->request &
> +		(DP_AUX_I2C_READ & DP_AUX_NATIVE_READ);
> +	u8 *data = NULL;
> +
> +	if (aux->native || i2c_read || ((input_msg->address != edid_address) &&
> +		(input_msg->address != segment_address)))
> +		return;
> +
> +
> +	data = input_msg->buffer;
> +	if (input_msg->address == segment_address)
> +		aux->segment = *data;
> +	else
> +		aux->offset = *data;
> +}

<snip>

> +static void dp_aux_init(struct dp_aux *dp_aux, struct dp_aux_cfg *aux_cfg)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux || !aux_cfg) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

Prefer to use WARN_ON here instead of a custom error message.

> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	dp_aux_reset_phy_config_indices(aux_cfg);
> +	aux->catalog->setup(aux->catalog, aux_cfg);
> +	aux->catalog->reset(aux->catalog);
> +	aux->catalog->enable(aux->catalog, true);
> +	aux->retry_cnt = 0;
> +}
> +
> +static void dp_aux_deinit(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

Pefer WARN_ON.

> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	aux->catalog->enable(aux->catalog, false);
> +}
> +
> +static int dp_aux_register(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +	int ret = 0;
> +
> +	if (!dp_aux) {
> +		pr_err("invalid input\n");

Prefer WARN_ON.

> +		ret = -EINVAL;

You can just return -EINVAL;

> +		goto exit;
> +	}
> +
> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	aux->drm_aux.name = "dpu_dp_aux";
> +	aux->drm_aux.dev = aux->dev;
> +	aux->drm_aux.transfer = dp_aux_transfer;
> +	ret = drm_dp_aux_register(&aux->drm_aux);
> +	if (ret) {
> +		pr_err("%s: failed to register drm aux: %d\n", __func__, ret);

Don't forget that your pr_fmt already prints __func__.  You don't need to dobule
it up.


> +		goto exit;

This can be return ret;

> +	}
> +	dp_aux->drm_aux = &aux->drm_aux;
> +exit:

Label not needed.

> +	return ret;

This can be return 0;

> +}
> +
> +static void dp_aux_deregister(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

Prefer WARN_ON

> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +	drm_dp_aux_unregister(&aux->drm_aux);
> +}
> +
> +struct dp_aux *dp_aux_get(struct device *dev, struct dp_catalog_aux *catalog,
> +			  struct dp_aux_cfg *aux_cfg)
> +{
> +	int rc = 0;
> +	struct dp_aux_private *aux;
> +	struct dp_aux *dp_aux;
> +
> +	if (!catalog || !aux_cfg) {
> +		pr_err("invalid input\n");
> +		rc = -ENODEV;
> +		goto error;
> +	}
> 
This appears to only be called once with a known good value for catalog and
aux_cfg, so this check does not appear to be needed.  It also implies that the
NULL checks (or WARN_ON) suggested for the functions above are not needed since
all of them are to be called with known good pointers.

In fact, even if you keep this check (with a WARN_ON instead of a custom message
of course) you can still remove the checks in dp_aux_isr, dp_aux_init,
dp_aux_deinit, dp_aux_register, dp_aux_deregister and dp_aux_reconfig because
you've already vetted the pointers.

> +	aux = devm_kzalloc(dev, sizeof(*aux), GFP_KERNEL);
> +	if (!aux) {

This can just be return ERR_PTR(-ENOMEM);

> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	init_completion(&aux->comp);
> +	aux->cmd_busy = false;
> +	mutex_init(&aux->mutex);
> +
> +	aux->dev = dev;
> +	aux->catalog = catalog;
> +	aux->cfg = aux_cfg;
> +	dp_aux = &aux->dp_aux;
> +	aux->retry_cnt = 0;
> +
> +	dp_aux->isr     = dp_aux_isr;
> +	dp_aux->init    = dp_aux_init;
> +	dp_aux->deinit  = dp_aux_deinit;
> +	dp_aux->drm_aux_register = dp_aux_register;
> +	dp_aux->drm_aux_deregister = dp_aux_deregister;
> +	dp_aux->reconfig = dp_aux_reconfig;
> +
> +	return dp_aux;
> +error:
> +	return ERR_PTR(rc);
This label should not be needed.

> +}
> +
> +void dp_aux_put(struct dp_aux *dp_aux)
> +{
> +	struct dp_aux_private *aux;
> +
> +	if (!dp_aux)
> +		return;
> +
> +	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
> +
> +	mutex_destroy(&aux->mutex);

Mutex_destroy isn't needed for memory that will no longer be used.

> +
> +	devm_kfree(aux->dev, aux);

If you are using devm_ you don't need to call devm_kfree.  If you don't expect
to use the devm_ infrastructure to your advantage then just use kzalloc() in the
init function and make sure you always free it but it seems to me you can just
get rid of dp_aux_put() and be happy.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h b/drivers/gpu/drm/msm/dp/dp_aux.h
> new file mode 100644
> index 0000000..0c300ed
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_aux.h
> @@ -0,0 +1,44 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX header please.

> +
> +#ifndef _DP_AUX_H_
> +#define _DP_AUX_H_
> +
> +#include "dp_catalog.h"
> +#include <drm/drm_dp_helper.h>
> +
> +enum dp_aux_error {
> +	DP_AUX_ERR_NONE	= 0,
> +	DP_AUX_ERR_ADDR	= -1,
> +	DP_AUX_ERR_TOUT	= -2,
> +	DP_AUX_ERR_NACK	= -3,
> +	DP_AUX_ERR_DEFER	= -4,
> +	DP_AUX_ERR_NACK_DEFER	= -5,
> +};
> +
> +struct dp_aux {
> +	struct drm_dp_aux *drm_aux;
> +	int (*drm_aux_register)(struct dp_aux *aux);
> +	void (*drm_aux_deregister)(struct dp_aux *aux);
> +	void (*isr)(struct dp_aux *aux);
> +	void (*init)(struct dp_aux *aux, struct dp_aux_cfg *aux_cfg);
> +	void (*deinit)(struct dp_aux *aux);
> +	void (*reconfig)(struct dp_aux *aux);
> +};
> +
> +struct dp_aux *dp_aux_get(struct device *dev, struct dp_catalog_aux *catalog,
> +			  struct dp_aux_cfg *aux_cfg);
> +void dp_aux_put(struct dp_aux *aux);
> +
> +#endif /*__DP_AUX_H_*/
> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c b/drivers/gpu/drm/msm/dp/dp_catalog.c
> new file mode 100644
> index 0000000..5818612
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
> @@ -0,0 +1,1188 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX header please.

> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/delay.h>
> +#include <drm/drm_dp_helper.h>
> +
> +#include "dp_catalog.h"
> +#include "dp_reg.h"
> +
> +#define DP_GET_MSB(x)	(x >> 8)
> +#define DP_GET_LSB(x)	(x & 0xff)
> +
> +#define dp_read(offset) readl_relaxed((offset))
> +#define dp_write(offset, data) writel_relaxed((data), (offset))

These macros do not serve any purpose

> +#define dp_catalog_get_priv(x) { \
> +	struct dp_catalog *dp_catalog; \
> +	dp_catalog = container_of(x, struct dp_catalog, x); \
> +	catalog = container_of(dp_catalog, struct dp_catalog_private, \
> +				dp_catalog); \
> +}

This would work better as a static inline function - it wouldn't be as ugly and
you get free typechecking.

> +#define DP_INTERRUPT_STATUS1 \
> +	(DP_INTR_AUX_I2C_DONE| \
> +	DP_INTR_WRONG_ADDR | DP_INTR_TIMEOUT | \
> +	DP_INTR_NACK_DEFER | DP_INTR_WRONG_DATA_CNT | \
> +	DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER | \
> +	DP_INTR_PLL_UNLOCKED | DP_INTR_AUX_ERROR)
> +
> +#define DP_INTR_MASK1		(DP_INTERRUPT_STATUS1 << 2)
> +
> +#define DP_INTERRUPT_STATUS2 \
> +	(DP_INTR_READY_FOR_VIDEO | DP_INTR_IDLE_PATTERN_SENT | \
> +	DP_INTR_FRAME_END | DP_INTR_CRC_UPDATED)
> +
> +#define DP_INTR_MASK2		(DP_INTERRUPT_STATUS2 << 2)
> +
> +static u8 const vm_pre_emphasis[4][4] = {
> +	{0x00, 0x0B, 0x12, 0xFF},       /* pe0, 0 db */
> +	{0x00, 0x0A, 0x12, 0xFF},       /* pe1, 3.5 db */
> +	{0x00, 0x0C, 0xFF, 0xFF},       /* pe2, 6.0 db */
> +	{0xFF, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
> +};
> +
> +/* voltage swing, 0.2v and 1.0v are not support */
> +static u8 const vm_voltage_swing[4][4] = {
> +	{0x07, 0x0F, 0x14, 0xFF}, /* sw0, 0.4v  */
> +	{0x11, 0x1D, 0x1F, 0xFF}, /* sw1, 0.6 v */
> +	{0x18, 0x1F, 0xFF, 0xFF}, /* sw1, 0.8 v */
> +	{0xFF, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
> +};
> +
> +/* audio related catalog functions */
> +struct dp_catalog_private {
> +	struct device *dev;
> +	struct dp_io *io;
> +
> +	u32 (*audio_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	struct dp_catalog dp_catalog;
> +};
> +
> +/* aux related catalog functions */
> +static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		goto end;
> +	}

Not sure if this check is needed (I'm assuming I'll figure it as we go) but as
above, replacing this with a handy

if (WARN_ON(!aux))
    return 0;

Is preferred over a custom log message

> +
> +	dp_catalog_get_priv(aux);

Function like macros that set an implicit variable are so very dangerous -
please use a static inline as I suggsted above.

> +	base = catalog->io->dp_aux.base;
> +
> +	return dp_read(base + DP_AUX_DATA);
> +end:
This shouldn't be needed if you return immediately above.
> +	return 0;
> +}
> +
> +static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}

Same as above

> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	dp_write(base + DP_AUX_DATA, aux->data);
> +end:
> +	return rc;

Same as above
> +}
> +
> +static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	dp_write(base + DP_AUX_TRANS_CTRL, aux->data);
> +end:
> +	return rc;
> +}

dp_catalog_aux_write_data and dp_catalog_aux_write_trans are basically the same
function except the register offset. There must be some conslidation that can be
done.

> +static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, bool read)
> +{
> +	int rc = 0;
> +	u32 data = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}

Use WARN_ON() here and throughout for all these dp catalog function hooks.

> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	if (read) {
> +		data = dp_read(base + DP_AUX_TRANS_CTRL);
> +		data &= ~BIT(9);
> +		dp_write(base + DP_AUX_TRANS_CTRL, data);
> +	} else {
> +		dp_write(base + DP_AUX_TRANS_CTRL, 0);
> +	}
> +end:
> +	return rc;
> +}
> +
> +static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
> +{
> +	u32 aux_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
> +
> +	aux_ctrl |= BIT(1);
> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +	usleep_range(1000, 1010); /* h/w recommended delay */
> +
> +	aux_ctrl &= ~BIT(1);
> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +	wmb();
> +}
> +
> +static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool enable)
> +{
> +	u32 aux_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;

Even at the very worse a common function to derive the base would save
lines of code given how much it gets used.

> +
> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
> +
> +	if (enable) {
> +		dp_write(base + DP_TIMEOUT_COUNT, 0xffff);
> +		dp_write(base + DP_AUX_LIMITS, 0xffff);
> +		aux_ctrl |= BIT(0);
> +	} else {
> +		aux_ctrl &= ~BIT(0);
> +	}
> +
> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +}

<snip>

> +static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, u32 state)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_STATE_CTRL, state);
> +}
> +
> +static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, u32 cfg)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *link_base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	link_base = catalog->io->dp_link.base;
> +
> +	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
> +
> +	dp_write(link_base + DP_CONFIGURATION_CTRL, cfg);
> +}
> +
> +static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl *ctrl)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_LOGICAL2PHYSICAL_LANE_MAPPING, 0xe4);
> +}
>
Consolidation of dp_link write could also be done among these three.

> +static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl *ctrl,
> +						bool enable)
> +{
> +	u32 mainlink_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	if (enable) {
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
> +		wmb(); /* make sure mainlink is turned off before reset */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000002);
> +		wmb(); /* make sure mainlink entered reset */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
> +		wmb(); /* make sure mainlink reset done */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000001);
> +		wmb(); /* make sure mainlink turned on */
> +	} else {
> +		mainlink_ctrl = dp_read(base + DP_MAINLINK_CTRL);
> +		mainlink_ctrl &= ~BIT(0);
> +		dp_write(base + DP_MAINLINK_CTRL, mainlink_ctrl);
> +	}
> +}
> +
> +static void dp_catalog_ctrl_config_misc(struct dp_catalog_ctrl *ctrl,
> +					u32 cc, u32 tb)
> +{
> +	u32 misc_val;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	misc_val = dp_read(base + DP_MISC1_MISC0);
> +	misc_val |= cc;
> +	misc_val |= (tb << 5);
> +	misc_val |= BIT(0); /* Configure clock to synchronous mode */
> +
> +	pr_debug("misc settings = 0x%x\n", misc_val);
> +	dp_write(base + DP_MISC1_MISC0, misc_val);
> +}
> +
> +static void dp_catalog_ctrl_config_msa(struct dp_catalog_ctrl *ctrl,
> +					u32 rate, u32 stream_rate_khz,
> +					bool fixed_nvid)
> +{
> +	u32 pixel_m, pixel_n;
> +	u32 mvid, nvid;
> +	u64 mvid_calc;
> +	u32 const nvid_fixed = 0x8000;
> +	u32 const link_rate_hbr2 = 540000;
> +	u32 const link_rate_hbr3 = 810000;

Put these constants inline rather than using a const on the stack.

> +	struct dp_catalog_private *catalog;
> +	void __iomem *base_cc, *base_ctrl;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	if (fixed_nvid) {
> +		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
> +		nvid = nvid_fixed;

> +
> +		pr_debug("link rate=%dkbps, stream_rate_khz=%uKhz",
> +			rate, stream_rate_khz);
> +
> +		/*
> +		 * For intermediate results, use 64 bit arithmetic to avoid
> +		 * loss of precision.
> +		 */
> +		mvid_calc = (u64) stream_rate_khz * nvid;

You set a const variable, then you ste a normal variable and you only use it
once - you could cut out all the middlemen by just hardcoding 0x8000 here.

> +		mvid_calc = div_u64(mvid_calc, rate);
> +
> +		/*
> +		 * truncate back to 32 bits as this final divided value will
> +		 * always be within the range of a 32 bit unsigned int.
> +		 */
> +		mvid = (u32) mvid_calc;
> +	} else {
> +		base_cc = catalog->io->dp_cc_io.base;
> +
> +		pixel_m = dp_read(base_cc + MMSS_DP_PIXEL_M);
> +		pixel_n = dp_read(base_cc + MMSS_DP_PIXEL_N);
> +		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
> +
> +		mvid = (pixel_m & 0xFFFF) * 5;
> +		nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
> +
> +		pr_debug("rate = %d\n", rate);
> +
> +		if (link_rate_hbr2 == rate)
> +			nvid *= 2;
> +
> +		if (link_rate_hbr3 == rate)
> +			nvid *= 3;
> +	}
> +
> +	base_ctrl = catalog->io->dp_link.base;
> +	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
> +	dp_write(base_ctrl + DP_SOFTWARE_MVID, mvid);
> +	dp_write(base_ctrl + DP_SOFTWARE_NVID, nvid);
> +}

<snip>

> +static void dp_catalog_audio_get_header(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	void __iomem *base;
> +	enum dp_catalog_audio_sdp_type sdp;
> +	enum dp_catalog_audio_header_type header;
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base    = catalog->io->dp_link.base;
> +	sdp_map = catalog->audio_map;
> +	sdp     = audio->sdp_type;
> +	header  = audio->sdp_header;

I'm assuming that whoever sets up the catalog in the first place is verifying
that sdp and header are both in bounds for the audio_map array?

> +	audio->data = dp_read(base + sdp_map[sdp][header]);
> +}
> +
> +static void dp_catalog_audio_set_header(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	void __iomem *base;
> +	enum dp_catalog_audio_sdp_type sdp;
> +	enum dp_catalog_audio_header_type header;
> +	u32 data;
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base    = catalog->io->dp_link.base;
> +	sdp_map = catalog->audio_map;
> +	sdp     = audio->sdp_type;
> +	header  = audio->sdp_header;
> +	data    = audio->data;

Same question.

> +
> +	dp_write(base + sdp_map[sdp][header], data);
> +}
> +
> +static void dp_catalog_audio_config_acr(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	u32 acr_ctrl, select;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	select = audio->data;
> +	base   = catalog->io->dp_link.base;
> +
> +	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
> +
> +	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
> +
> +	dp_write(base + MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
> +}
> +
> +static void dp_catalog_audio_safe_to_exit_level(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	u32 mainlink_levels, safe_to_exit_level;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base   = catalog->io->dp_link.base;
> +	safe_to_exit_level = audio->data;
> +
> +	mainlink_levels = dp_read(base + DP_MAINLINK_LEVELS);
> +	mainlink_levels &= 0xFE0;
> +	mainlink_levels |= safe_to_exit_level;
> +
> +	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
> +			mainlink_levels, safe_to_exit_level);
> +
> +	dp_write(base + DP_MAINLINK_LEVELS, mainlink_levels);
> +}
> +
> +static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	bool enable;
> +	u32 audio_ctrl;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base   = catalog->io->dp_link.base;
> +	enable = !!audio->data;
> +
> +	audio_ctrl = dp_read(base + MMSS_DP_AUDIO_CFG);
> +
> +	if (enable)
> +		audio_ctrl |= BIT(0);
> +	else
> +		audio_ctrl &= ~BIT(0);
> +
> +	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
> +	dp_write(base + MMSS_DP_AUDIO_CFG, audio_ctrl);
> +
> +	/* make sure audio engine is disabled */
> +	wmb();
> +}
> +
> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io)
> +{
> +	int rc = 0;
> +	struct dp_catalog *dp_catalog;
> +	struct dp_catalog_private *catalog;
> +	struct dp_catalog_aux aux = {
> +		.read_data     = dp_catalog_aux_read_data,
> +		.write_data    = dp_catalog_aux_write_data,
> +		.write_trans   = dp_catalog_aux_write_trans,
> +		.clear_trans   = dp_catalog_aux_clear_trans,
> +		.reset         = dp_catalog_aux_reset,
> +		.update_aux_cfg = dp_catalog_aux_update_cfg,
> +		.enable        = dp_catalog_aux_enable,
> +		.setup         = dp_catalog_aux_setup,
> +		.get_irq       = dp_catalog_aux_get_irq,
> +	};
> +	struct dp_catalog_ctrl ctrl = {
> +		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
> +		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
> +		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
> +		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
> +		.config_misc    = dp_catalog_ctrl_config_misc,
> +		.config_msa     = dp_catalog_ctrl_config_msa,
> +		.set_pattern    = dp_catalog_ctrl_set_pattern,
> +		.reset          = dp_catalog_ctrl_reset,
> +		.usb_reset      = dp_catalog_ctrl_usb_reset,
> +		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
> +		.enable_irq     = dp_catalog_ctrl_enable_irq,
> +		.hpd_config     = dp_catalog_ctrl_hpd_config,
> +		.phy_reset      = dp_catalog_ctrl_phy_reset,
> +		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
> +		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
> +		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
> +		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
> +		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
> +		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,
> +	};
> +	struct dp_catalog_audio audio = {
> +		.init       = dp_catalog_audio_init,
> +		.config_acr = dp_catalog_audio_config_acr,
> +		.enable     = dp_catalog_audio_enable,
> +		.config_sdp = dp_catalog_audio_config_sdp,
> +		.set_header = dp_catalog_audio_set_header,
> +		.get_header = dp_catalog_audio_get_header,
> +		.safe_to_exit_level = dp_catalog_audio_safe_to_exit_level,
> +	};
> +	struct dp_catalog_panel panel = {
> +		.timing_cfg = dp_catalog_panel_timing_cfg,
> +		.tpg_config = dp_catalog_panel_tpg_cfg,
> +	};
> +
> +	if (!io) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

It doesn't appear that io can be NULL here.

> +
> +	catalog  = devm_kzalloc(dev, sizeof(*catalog), GFP_KERNEL);
> +	if (!catalog) {

You can just return ERR_PTR(-ENOMEM) here
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	catalog->dev = dev;
> +	catalog->io = io;
> +
> +	dp_catalog = &catalog->dp_catalog;
> +
> +	dp_catalog->aux   = aux;
> +	dp_catalog->ctrl  = ctrl;
> +	dp_catalog->audio = audio;
> +	dp_catalog->panel = panel;

I'll use this as an example because it is the shortest, but it should apply to
all these members. You can set the value of dp_catalog->panel directly without
an intermediate variable:

dp_catalog->panel = {
	.timing_cfg = dp_catalog_panel_timing_cfg,
	.tpg_config = dp_catalog_panel_tpg_cfg,
};

Its a small change but it makes it easier to understand what is going on in this
function.

> +
> +	return dp_catalog;
> +error:
> +	return ERR_PTR(rc);

This shouldn't be needed anymore.

> +}
> +
> +void dp_catalog_put(struct dp_catalog *dp_catalog)
> +{
> +	struct dp_catalog_private *catalog;
> +
> +	if (!dp_catalog)
> +		return;
> +
> +	catalog = container_of(dp_catalog, struct dp_catalog_private,
> +				dp_catalog);
> +
> +	devm_kfree(catalog->dev, catalog);

You don't need to devm_kfree managed memory - just let it go.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h b/drivers/gpu/drm/msm/dp/dp_catalog.h
> new file mode 100644
> index 0000000..58951df
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
> @@ -0,0 +1,144 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_CATALOG_H_
> +#define _DP_CATALOG_H_
> +
> +#include "dp_parser.h"
> +
> +/* interrupts */
> +#define DP_INTR_HPD		BIT(0)
> +#define DP_INTR_AUX_I2C_DONE	BIT(3)
> +#define DP_INTR_WRONG_ADDR	BIT(6)
> +#define DP_INTR_TIMEOUT		BIT(9)
> +#define DP_INTR_NACK_DEFER	BIT(12)
> +#define DP_INTR_WRONG_DATA_CNT	BIT(15)
> +#define DP_INTR_I2C_NACK	BIT(18)
> +#define DP_INTR_I2C_DEFER	BIT(21)
> +#define DP_INTR_PLL_UNLOCKED	BIT(24)
> +#define DP_INTR_AUX_ERROR	BIT(27)
> +
> +#define DP_INTR_READY_FOR_VIDEO		BIT(0)
> +#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
> +#define DP_INTR_FRAME_END		BIT(6)
> +#define DP_INTR_CRC_UPDATED		BIT(9)
> +
> +struct dp_catalog_aux {
> +	u32 data;
> +	u32 isr;
> +
> +	u32 (*read_data)(struct dp_catalog_aux *aux);
> +	int (*write_data)(struct dp_catalog_aux *aux);
> +	int (*write_trans)(struct dp_catalog_aux *aux);
> +	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
> +	void (*reset)(struct dp_catalog_aux *aux);
> +	void (*enable)(struct dp_catalog_aux *aux, bool enable);
> +	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
> +	void (*setup)(struct dp_catalog_aux *aux,
> +			struct dp_aux_cfg *aux_cfg);
> +	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
> +};
> +
> +struct dp_catalog_ctrl {
> +	u32 dp_tu;
> +	u32 valid_boundary;
> +	u32 valid_boundary2;
> +	u32 isr;
> +
> +	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
> +	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
> +	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
> +	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
> +	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
> +				u32 stream_rate_khz, bool fixed_nvid);
> +	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
> +	void (*reset)(struct dp_catalog_ctrl *ctrl);
> +	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
> +	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
> +	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
> +	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
> +				u8 lane_cnt);
> +	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
> +				u8 p_level);
> +	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
> +	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
> +	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
> +			u32 pattern);
> +	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
> +};
> +
> +enum dp_catalog_audio_sdp_type {
> +	DP_AUDIO_SDP_STREAM,
> +	DP_AUDIO_SDP_TIMESTAMP,
> +	DP_AUDIO_SDP_INFOFRAME,
> +	DP_AUDIO_SDP_COPYMANAGEMENT,
> +	DP_AUDIO_SDP_ISRC,
> +	DP_AUDIO_SDP_MAX,
> +};
> +
> +enum dp_catalog_audio_header_type {
> +	DP_AUDIO_SDP_HEADER_1,
> +	DP_AUDIO_SDP_HEADER_2,
> +	DP_AUDIO_SDP_HEADER_3,
> +	DP_AUDIO_SDP_HEADER_MAX,
> +};
> +
> +struct dp_catalog_audio {
> +	enum dp_catalog_audio_sdp_type sdp_type;
> +	enum dp_catalog_audio_header_type sdp_header;
> +	u32 data;
> +
> +	void (*init)(struct dp_catalog_audio *audio);
> +	void (*enable)(struct dp_catalog_audio *audio);
> +	void (*config_acr)(struct dp_catalog_audio *audio);
> +	void (*config_sdp)(struct dp_catalog_audio *audio);
> +	void (*set_header)(struct dp_catalog_audio *audio);
> +	void (*get_header)(struct dp_catalog_audio *audio);
> +	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);
> +};
> +
> +struct dp_catalog_panel {
> +	u32 total;
> +	u32 sync_start;
> +	u32 width_blanking;
> +	u32 dp_active;
> +
> +	/* TPG */
> +	u32 hsync_period;
> +	u32 vsync_period;
> +	u32 display_v_start;
> +	u32 display_v_end;
> +	u32 v_sync_width;
> +	u32 hsync_ctl;
> +	u32 display_hctl;
> +
> +	int (*timing_cfg)(struct dp_catalog_panel *panel);
> +	void (*tpg_config)(struct dp_catalog_panel *panel, bool enable);
> +};
> +
> +struct dp_catalog {
> +	struct dp_catalog_aux aux;
> +	struct dp_catalog_ctrl ctrl;
> +	struct dp_catalog_audio audio;
> +	struct dp_catalog_panel panel;
> +};
> +
> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io);
> +void dp_catalog_put(struct dp_catalog *catalog);
> +
> +#endif /* _DP_CATALOG_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> new file mode 100644
> index 0000000..08a52f5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> @@ -0,0 +1,1475 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/types.h>
> +#include <linux/completion.h>
> +#include <linux/delay.h>
> +
> +#include "dp_ctrl.h"
> +
> +#define DP_KHZ_TO_HZ 1000
> +
> +#define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
> +#define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
> +
> +/* dp state ctrl */
> +#define ST_TRAIN_PATTERN_1		BIT(0)
> +#define ST_TRAIN_PATTERN_2		BIT(1)
> +#define ST_TRAIN_PATTERN_3		BIT(2)
> +#define ST_TRAIN_PATTERN_4		BIT(3)
> +#define ST_SYMBOL_ERR_RATE_MEASUREMENT	BIT(4)
> +#define ST_PRBS7			BIT(5)
> +#define ST_CUSTOM_80_BIT_PATTERN	BIT(6)
> +#define ST_SEND_VIDEO			BIT(7)
> +#define ST_PUSH_IDLE			BIT(8)
> +
> +#define MR_LINK_TRAINING1  0x8
> +#define MR_LINK_SYMBOL_ERM 0x80
> +#define MR_LINK_PRBS7 0x100
> +#define MR_LINK_CUSTOM80 0x200
> +
> +struct dp_vc_tu_mapping_table {
> +	u32 vic;
> +	u8 lanes;
> +	u8 lrate; /* DP_LINK_RATE -> 162(6), 270(10), 540(20), 810 (30) */
> +	u8 bpp;
> +	u8 valid_boundary_link;
> +	u16 delay_start_link;
> +	bool boundary_moderation_en;
> +	u8 valid_lower_boundary_link;
> +	u8 upper_boundary_count;
> +	u8 lower_boundary_count;
> +	u8 tu_size_minus1;
> +};
> +
> +struct dp_ctrl_private {
> +	struct dp_ctrl dp_ctrl;
> +
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_panel *panel;
> +	struct dp_link *link;
> +	struct dp_power *power;
> +	struct dp_parser *parser;
> +	struct dp_catalog_ctrl *catalog;
> +
> +	struct completion idle_comp;
> +	struct completion video_comp;
> +
> +	bool orientation;
> +	atomic_t aborted;
> +
> +	u32 pixel_rate;
> +	u32 vic;
> +};
> +
> +enum notification_status {
> +	NOTIFY_UNKNOWN,
> +	NOTIFY_CONNECT,
> +	NOTIFY_DISCONNECT,
> +	NOTIFY_CONNECT_IRQ_HPD,
> +	NOTIFY_DISCONNECT_IRQ_HPD,
> +};
> +
> +static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
> +{
> +	pr_debug("idle_patterns_sent\n");
> +	complete(&ctrl->idle_comp);
> +}
> +
> +static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
> +{
> +	pr_debug("dp_video_ready\n");
> +	complete(&ctrl->video_comp);
> +}
> +
> +static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return;
> +	}

Common theme - please try to use WARN_ON instead  of a custom error message.

> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	atomic_set(&ctrl->aborted, 1);
> +}
> +
> +static void dp_ctrl_state_ctrl(struct dp_ctrl_private *ctrl, u32 state)
> +{
> +	ctrl->catalog->state_ctrl(ctrl->catalog, state);
> +}
> +
> +static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
> +{
> +	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	reinit_completion(&ctrl->idle_comp);
> +	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
> +
> +	if (!wait_for_completion_timeout(&ctrl->idle_comp,
> +			idle_pattern_completion_timeout_ms))
> +		pr_warn("PUSH_IDLE pattern timedout\n");
> +
> +	pr_debug("mainlink off done\n");
> +}
> +
> +static void dp_ctrl_config_ctrl(struct dp_ctrl_private *ctrl)
> +{
> +	u32 config = 0, tbd;
> +	u8 *dpcd = ctrl->panel->dpcd;
> +
> +	config |= (2 << 13); /* Default-> LSCLK DIV: 1/4 LCLK  */
> +	config |= (0 << 11); /* RGB */
> +
> +	/* Scrambler reset enable */
> +	if (dpcd[DP_EDP_CONFIGURATION_CAP] & DP_ALTERNATE_SCRAMBLER_RESET_CAP)
> +		config |= (1 << 10);
> +
> +	tbd = ctrl->link->get_test_bits_depth(ctrl->link,
> +			ctrl->panel->pinfo.bpp);
> +
> +	if (tbd == DP_TEST_BIT_DEPTH_UNKNOWN)
> +		tbd = DP_TEST_BIT_DEPTH_8;
> +
> +	config |= tbd << 8;
> +
> +	/* Num of Lanes */
> +	config |= ((ctrl->link->link_params.lane_count - 1) << 4);
> +
> +	if (drm_dp_enhanced_frame_cap(dpcd))
> +		config |= 0x40;
> +
> +	config |= 0x04; /* progressive video */
> +
> +	config |= 0x03;	/* sycn clock & static Mvid */
> +
> +	ctrl->catalog->config_ctrl(ctrl->catalog, config);
> +}
> +
> +/**
> + * dp_ctrl_configure_source_params() - configures DP transmitter source params
> + * @ctrl: Display Port Driver data
> + *
> + * Configures the DP transmitter source params including details such as lane
> + * configuration, output format and sink/panel timing information.
> + */
> +static void dp_ctrl_configure_source_params(struct dp_ctrl_private *ctrl)
> +{
> +	u32 cc, tb;
> +
> +	ctrl->catalog->lane_mapping(ctrl->catalog);
> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
> +
> +	dp_ctrl_config_ctrl(ctrl);
> +
> +	tb = ctrl->link->get_test_bits_depth(ctrl->link,
> +		ctrl->panel->pinfo.bpp);
> +	cc = ctrl->link->get_colorimetry_config(ctrl->link);
> +	ctrl->catalog->config_misc(ctrl->catalog, cc, tb);
> +	ctrl->panel->timing_cfg(ctrl->panel);
> +}
> +
> +static void dp_ctrl_get_extra_req_bytes(u64 result_valid,
> +					int valid_bdary_link,
> +					u64 value1, u64 value2,
> +					bool *negative, u64 *result,
> +					u64 compare)
> +{
> +	*negative = false;
> +	if (result_valid >= compare) {
> +		if (valid_bdary_link
> +				>= compare)
> +			*result = value1 + value2;
> +		else {
> +			if (value1 < value2)
> +				*negative = true;
> +			*result = (value1 >= value2) ?
> +				(value1 - value2) : (value2 - value1);
> +		}
> +	} else {
> +		if (valid_bdary_link
> +				>= compare) {
> +			if (value1 >= value2)
> +				*negative = true;
> +			*result = (value1 >= value2) ?
> +				(value1 - value2) : (value2 - value1);
> +		} else {
> +			*result = value1 + value2;
> +			*negative = true;
> +		}
> +	}
> +}
> +
> +static u64 roundup_u64(u64 x, u64 y)
> +{
> +	x += (y - 1);
> +	return (div64_ul(x, y) * y);
> +}

Does roundup() not work for u64?

> +
> +static u64 rounddown_u64(u64 x, u64 y)
> +{
> +	u64 rem;
> +
> +	div64_u64_rem(x, y, &rem);
> +	return (x - rem);
> +}

Same question

<snip>

> +static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);
> +	if (ret <= 0) {
> +		pr_err("Link Train timedout\n");
> +		ret = -EINVAL;

On timeout it would be helpful to return -ETIMEDOUT but if ret < 0 you should
return the value that you got from wait_for_completion_timeout in case the
caller wants to know about interrupted calls.

> +	}
> +
> +	return ret;
> +}

<snip>

> +static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +	u8 encoding = 0x1;
> +	struct drm_dp_link link_info = {0};
> +
> +	ctrl->link->phy_params.p_level = 0;
> +	ctrl->link->phy_params.v_level = 0;
> +
> +	dp_ctrl_config_ctrl(ctrl);
> +
> +	link_info.num_lanes = ctrl->link->link_params.lane_count;
> +	link_info.rate = drm_dp_bw_code_to_link_rate(
> +		ctrl->link->link_params.bw_code);
> +	link_info.capabilities = ctrl->panel->link_info.capabilities;
> +
> +	drm_dp_link_configure(ctrl->aux->drm_aux, &link_info);
> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
> +				&encoding, 1);
> +
> +	ret = dp_ctrl_link_train_1(ctrl);
> +	if (ret) {
> +		pr_err("link training #1 failed\n");
> +		goto end;
> +	}
> +
> +	/* print success info as this is a result of user initiated action */
> +	pr_info("link training #1 successful\n");

These seem like maybe they belong at pr_debug() level - they are interested
while getting going but probably not in a commercial setting.

> +	ret = dp_ctrl_link_training_2(ctrl);
> +	if (ret) {
> +		pr_err("link training #2 failed\n");
> +		goto end;
> +	}
> +
> +	/* print success info as this is a result of user initiated action */
> +	pr_info("link training #2 successful\n");

Same.

> +
> +end:
> +	dp_ctrl_state_ctrl(ctrl, 0);
> +	/* Make sure to clear the current pattern before starting a new one */
> +	wmb();
> +
> +	dp_ctrl_clear_training_pattern(ctrl);
> +	return ret;
> +}
> +
> +static int dp_ctrl_setup_main_link(struct dp_ctrl_private *ctrl, bool train)
> +{
> +	bool mainlink_ready = false;
> +	int ret = 0;
> +
> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
> +
> +	ret = ctrl->link->psm_config(ctrl->link,
> +		&ctrl->panel->link_info, false);
> +	if (ret)
> +		goto end;
> +
> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> +		goto end;
> +
> +	if (!train)
> +		goto send_video;
> +
> +	/*
> +	 * As part of previous calls, DP controller state might have
> +	 * transitioned to PUSH_IDLE. In order to start transmitting a link
> +	 * training pattern, we have to first to a DP software reset.
> +	 */
> +	ctrl->catalog->reset(ctrl->catalog);
> +
> +	ret = dp_ctrl_link_train(ctrl);
> +	if (ret)
> +		goto end;
> +
> +send_video:
> +	/*
> +	 * Set up transfer unit values and set controller state to send
> +	 * video.
> +	 */
> +	dp_ctrl_setup_tr_unit(ctrl);
> +	ctrl->catalog->state_ctrl(ctrl->catalog, ST_SEND_VIDEO);
> +
> +	dp_ctrl_wait4video_ready(ctrl);
> +	mainlink_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
> +	pr_debug("mainlink %s\n", mainlink_ready ? "READY" : "NOT READY");
> +end:
> +	return ret;
> +}
> +
> +static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
> +				   char *name, u32 rate)
> +{
> +	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
> +	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
> +
> +	while (num && strcmp(cfg->clk_name, name)) {
> +		num--;
> +		cfg++;
> +	}
> +
> +	pr_debug("setting rate=%d on clk=%s\n", rate, name);
> +
> +	if (num)
> +		cfg->rate = rate;
> +	else
> +		pr_err("%s clock could not be set with rate %d\n", name, rate);

More accurately, the clock name isn't found in the list.

> +}
> +
> +static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	ctrl->power->set_pixel_clk_parent(ctrl->power);
> +
> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
> +		drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code));
> +
> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_pixel_clk", ctrl->pixel_rate);
> +
> +	ret = ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, true);
> +	if (ret) {
> +		pr_err("Unabled to start link clocks\n");
> +		ret = -EINVAL;

You should use the return value from ctrl->power->clk_enable instead of
reclassifying it.

> +	}
> +
> +	return ret;
> +}
> +
> +static int dp_ctrl_disable_mainlink_clocks(struct dp_ctrl_private *ctrl)
> +{
> +	return ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, false);
> +}
> +
> +static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip)
> +{
> +	struct dp_ctrl_private *ctrl;
> +	struct dp_catalog_ctrl *catalog;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return -EINVAL;
> +	}

Use the WARN_ON to avoid the custom error message. Throughout.

> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	ctrl->orientation = flip;
> +	catalog = ctrl->catalog;
> +
> +	catalog->usb_reset(ctrl->catalog, flip);
> +	catalog->phy_reset(ctrl->catalog);
> +	catalog->enable_irq(ctrl->catalog, true);
> +
> +	return 0;
> +}

<snip>

> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
> +{
> +	int rc = 0;
> +	struct dp_ctrl_private *ctrl;
> +	struct dp_ctrl *dp_ctrl;
> +
> +	if (!in->dev || !in->panel || !in->aux ||
> +	    !in->link || !in->catalog) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

None of these will be NULL from the single call to this function.

> +	ctrl = devm_kzalloc(in->dev, sizeof(*ctrl), GFP_KERNEL);
> +	if (!ctrl) {

You can jsut return ERR_PTR(-ENOMEM) here

> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	init_completion(&ctrl->idle_comp);
> +	init_completion(&ctrl->video_comp);
> +
> +	/* in parameters */
> +	ctrl->parser   = in->parser;
> +	ctrl->panel    = in->panel;
> +	ctrl->power    = in->power;
> +	ctrl->aux      = in->aux;
> +	ctrl->link     = in->link;
> +	ctrl->catalog  = in->catalog;
> +	ctrl->dev      = in->dev;
> +
> +	dp_ctrl = &ctrl->dp_ctrl;
> +
> +	/* out parameters */
> +	dp_ctrl->init      = dp_ctrl_host_init;
> +	dp_ctrl->deinit    = dp_ctrl_host_deinit;
> +	dp_ctrl->on        = dp_ctrl_on;
> +	dp_ctrl->off       = dp_ctrl_off;
> +	dp_ctrl->push_idle = dp_ctrl_push_idle;
> +	dp_ctrl->abort     = dp_ctrl_abort;
> +	dp_ctrl->isr       = dp_ctrl_isr;
> +	dp_ctrl->reset	   = dp_ctrl_reset;
> +	dp_ctrl->handle_sink_request = dp_ctrl_handle_sink_request;
> +
> +	return dp_ctrl;
> +error:
> +	return ERR_PTR(rc);

This shouldn't be needed.

> +}
> +
> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl)
> +		return;
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	devm_kfree(ctrl->dev, ctrl);

Not needed if you are using devm_

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.h b/drivers/gpu/drm/msm/dp/dp_ctrl.h
> new file mode 100644
> index 0000000..6ab221a
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.h
> @@ -0,0 +1,50 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_CTRL_H_
> +#define _DP_CTRL_H_
> +
> +#include "dp_aux.h"
> +#include "dp_panel.h"
> +#include "dp_link.h"
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +
> +struct dp_ctrl {
> +	int (*init)(struct dp_ctrl *dp_ctrl, bool flip);
> +	void (*deinit)(struct dp_ctrl *dp_ctrl);
> +	int (*on)(struct dp_ctrl *dp_ctrl);
> +	void (*off)(struct dp_ctrl *dp_ctrl);
> +	void (*reset)(struct dp_ctrl *dp_ctrl);
> +	void (*push_idle)(struct dp_ctrl *dp_ctrl);
> +	void (*abort)(struct dp_ctrl *dp_ctrl);
> +	void (*isr)(struct dp_ctrl *dp_ctrl);
> +	void (*handle_sink_request)(struct dp_ctrl *dp_ctrl);
> +};
> +
> +struct dp_ctrl_in {
> +	struct device *dev;
> +	struct dp_panel *panel;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_parser *parser;
> +	struct dp_power *power;
> +	struct dp_catalog_ctrl *catalog;
> +};
> +
> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in);
> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl);
> +
> +#endif /* _DP_CTRL_H_ */

This seems like a good ending spot for now.  I'll do the rest later.

Jordan

-- 
The Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Jordan Crouse]

On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> Add the needed displayPort files to enable DP driver
> on msm target.
> 
> "dp_display" module is the main module that calls into
> other sub-modules. "dp_drm" file represents the interface
> between DRM framework and DP driver.
> 
> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>  drivers/gpu/drm/msm/Makefile                |   15 +-
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 ++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 +++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 +++++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>  include/drm/drm_dp_helper.h                 |   19 +
>  30 files changed, 10887 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h

<snip to dp_debug.c>

> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.c b/drivers/gpu/drm/msm/dp/dp_debug.c
> new file mode 100644
> index 0000000..5c0a8ce
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_debug.c
> @@ -0,0 +1,507 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/debugfs.h>
> +#include <drm/drm_connector.h>
> +
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +#include "dp_aux.h"
> +#include "dp_ctrl.h"
> +#include "dp_debug.h"
> +#include "dp_display.h"
> +
> +#define DEBUG_NAME "drm_dp"
> +
> +struct dp_debug_private {
> +	struct dentry *root;
> +
> +	struct dp_usbpd *usbpd;
> +	struct dp_link *link;
> +	struct dp_panel *panel;
> +	struct drm_connector **connector;
> +	struct device *dev;
> +
> +	struct dp_debug dp_debug;
> +};
> +
> +static ssize_t dp_debug_write_hpd(struct file *file,
> +		const char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_8];
> +	size_t len = 0;
> +	int hpd;
> +
> +	if (!debug)
> +		return -ENODEV;

debug will not be NULL here.

> +
> +	if (*ppos)
> +		return 0;
> +
> +	/* Leave room for termination char */
> +	len = min_t(size_t, count, SZ_8 - 1);
> +	if (copy_from_user(buf, user_buff, len))
> +		goto end;
> +
> +	buf[len] = '\0';
> +
> +	if (kstrtoint(buf, 10, &hpd) != 0)
> +		goto end;
> +

All of this can be replaced by kstrtoint_from_user().


> +	if (debug->usbpd && debug->usbpd->connect)
> +		debug->usbpd->connect(debug->usbpd, hpd);
> +
> +end:
> +	return -len;

On error you should return a real error code or the number of bytes consumed
(count) on success.

> +}
> +
> +static ssize_t dp_debug_write_edid_modes(struct file *file,
> +		const char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_32];

Just use 32.

> +	size_t len = 0;
> +	int hdisplay = 0, vdisplay = 0, vrefresh = 0;
> +
> +	if (!debug)
> +		return -ENODEV;
> 
Debug can't be NULL here.

> +	if (*ppos)
> +		goto end;
> +
> +	/* Leave room for termination char */
> +	len = min_t(size_t, count, SZ_32 - 1);

instead of SZ_23 - 1, use sizeof(buf) - 1

> +	if (copy_from_user(buf, user_buff, len))
> +		goto clear;
> +
> +	buf[len] = '\0';
> +
> +	if (sscanf(buf, "%d %d %d", &hdisplay, &vdisplay, &vrefresh) != 3)
> +		goto clear;
> +
> +	if (!hdisplay || !vdisplay || !vrefresh)
> +		goto clear;
> +
> +	debug->dp_debug.debug_en = true;
> +	debug->dp_debug.hdisplay = hdisplay;
> +	debug->dp_debug.vdisplay = vdisplay;
> +	debug->dp_debug.vrefresh = vrefresh;
> +	goto end;
> +clear:
> +	pr_debug("clearing debug modes\n");
> +	debug->dp_debug.debug_en = false;
> +end:
> +	return len;

This should be 'count'
> +}
> +
> +static ssize_t dp_debug_read_connected(struct file *file,
> +		char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_8];
> +	u32 len = 0;
> +
> +	if (!debug)
> +		return -ENODEV;
> 
Debug can't be NULL

> +	if (*ppos)
> +		return 0;
> +
> +	if (!debug->usbpd)
> +		return -ENODEV;
> +
> +	len += snprintf(buf, SZ_8, "%d\n", debug->usbpd->hpd_high);

You should always use scnprintf instead of snprintf in these situations.

And use sizeof(buf) instead of a constant.

And you can set len = snprintf(...). you don't need to do a += and depend on the
initialization.

> +
> +	if (copy_to_user(user_buff, buf, len))
> +		return -EFAULT;
> +
> +	*ppos += len;
> +	return len;
> +}
> +
> +static ssize_t dp_debug_read_edid_modes(struct file *file,
> +		char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char *buf;
> +	u32 len = 0;
> +	int rc = 0;
> +	struct drm_connector *connector;
> +	struct drm_display_mode *mode;
> +
> +	if (!debug) {
> +		pr_err("invalid data\n");
> +		rc = -ENODEV;
> +		goto error;
> +	}

Debug cannot be NULL here.

> +
> +	connector = *debug->connector;

Why are you dereferencing debug?

> +
> +	if (!connector) {
> +		pr_err("connector is NULL\n");
> +		rc = -EINVAL;
> +		goto error;


Just return -EINVAL;
> +	}

I'm not sure if this can be an error or not, but perhaps consider skipping
the print message.

> +
> +	if (*ppos)
> +		goto error;

Just return 0;

> +
> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
> +	if (!buf) {
> +		rc = -ENOMEM;
> +		goto error;

Just return -ENOMEM;

> +	}
> +
> +	list_for_each_entry(mode, &connector->modes, head) {
> +		len += snprintf(buf + len, SZ_4K - len,

Definitely use scnprintf() - this is a disaster waiting to happen/

> +		"%s %d %d %d %d %d %d %d %d %d 0x%x\n",
> +		mode->name, mode->vrefresh, mode->hdisplay,
> +		mode->hsync_start, mode->hsync_end, mode->htotal,
> +		mode->vdisplay, mode->vsync_start, mode->vsync_end,
> +		mode->vtotal, mode->flags);
> +	}
> +
> +	if (copy_to_user(user_buff, buf, len)) {
> +		kfree(buf);

Just return -EFAULT here

> +		rc = -EFAULT;
> +		goto error;
> +	}
> +
> +	*ppos += len;
> +	kfree(buf);
> +
> +	return len;
> +error:
> +	return rc;

This label isn't needed with the above changes.

> +}
> +
> +static int dp_debug_check_buffer_overflow(int rc, int *max_size, int *len)
> +{
> +	if (rc >= *max_size) {
> +		pr_err("buffer overflow\n");
> +		return -EINVAL;
> +	}
> +	*len += rc;
> +	*max_size = SZ_4K - *len;
> +
> +	return 0;
> +}
> +
> +static ssize_t dp_debug_read_info(struct file *file, char __user *user_buff,
> +		size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char *buf;
> +	u32 len = 0, rc = 0;
> +	u64 lclk = 0;
> +	u32 max_size = SZ_4K;
> +
> +	if (!debug)
> +		return -ENODEV;

Debug cannot be 0.

> +
> +	if (*ppos)
> +		return 0;
> +
> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
> +	if (!buf)
> +		return -ENOMEM;
> +
> +	rc = snprintf(buf + len, max_size, "\tname = %s\n", DEBUG_NAME);

Use scnprintf()

> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;

This function is very odd - if you use scnprintf() you can safely just do

len = scnprintf(buf + len, SZ_4K - len, "\ttname = %s\n", DEBUG_NAME);
len += scnprintf(buf + len, SZ_4K - len, ....)

But this whole thing seems like a really good fit for seq_file and then you
don't have to worry about anything else.

> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_panel\n\t\tmax_pclk_khz = %d\n",
> +		debug->panel->max_pclk_khz);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\tdrm_dp_link\n\t\trate = %u\n",
> +		debug->panel->link_info.rate);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tnum_lanes = %u\n",
> +		debug->panel->link_info.num_lanes);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tcapabilities = %lu\n",
> +		debug->panel->link_info.capabilities);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_panel_info:\n\t\tactive = %dx%d\n",
> +		debug->panel->pinfo.h_active,
> +		debug->panel->pinfo.v_active);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tback_porch = %dx%d\n",
> +		debug->panel->pinfo.h_back_porch,
> +		debug->panel->pinfo.v_back_porch);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tfront_porch = %dx%d\n",
> +		debug->panel->pinfo.h_front_porch,
> +		debug->panel->pinfo.v_front_porch);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tsync_width = %dx%d\n",
> +		debug->panel->pinfo.h_sync_width,
> +		debug->panel->pinfo.v_sync_width);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tactive_low = %dx%d\n",
> +		debug->panel->pinfo.h_active_low,
> +		debug->panel->pinfo.v_active_low);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\th_skew = %d\n",
> +		debug->panel->pinfo.h_skew);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\trefresh rate = %d\n",
> +		debug->panel->pinfo.refresh_rate);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tpixel clock khz = %d\n",
> +		debug->panel->pinfo.pixel_clk_khz);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tbpp = %d\n",
> +		debug->panel->pinfo.bpp);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	/* Link Information */
> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_link:\n\t\ttest_requested = %d\n",
> +		debug->link->sink_request);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tlane_count = %d\n", debug->link->link_params.lane_count);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tbw_code = %d\n", debug->link->link_params.bw_code);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	lclk = drm_dp_bw_code_to_link_rate(
> +			debug->link->link_params.bw_code) * 1000;
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tlclk = %lld\n", lclk);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tv_level = %d\n", debug->link->phy_params.v_level);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tp_level = %d\n", debug->link->phy_params.p_level);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	if (copy_to_user(user_buff, buf, len))
> +		goto error;
> +
> +	*ppos += len;
> +
> +	kfree(buf);
> +	return len;
> +error:
> +	kfree(buf);
> +	return -EINVAL;
> +}
> +
> +static const struct file_operations dp_debug_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_info,
> +};
> +
> +static const struct file_operations edid_modes_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_edid_modes,
> +	.write = dp_debug_write_edid_modes,
> +};
> +
> +static const struct file_operations hpd_fops = {
> +	.open = simple_open,
> +	.write = dp_debug_write_hpd,
> +};
> +
> +static const struct file_operations connected_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_connected,
> +};
> +
> +static int dp_debug_init(struct dp_debug *dp_debug)
> +{
> +	int rc = 0;
> +	struct dp_debug_private *debug = container_of(dp_debug,
> +		struct dp_debug_private, dp_debug);
> +	struct dentry *dir, *file, *edid_modes;
> +	struct dentry *hpd, *connected;
> +
> +	dir = debugfs_create_dir(DEBUG_NAME, NULL);

You don't want to be putting the debugbfs in the root dir - you'll want it
nicely nestled in with the rest of the driver. See the GPU or DPU debugfs files
for clues on how to do that.

> +	if (IS_ERR_OR_NULL(dir)) {

debugfs_create_dir only returns NULL on error.  Getting the PTR_ERR will just
return 0 in that case.

> +		rc = PTR_ERR(dir);
> +		pr_err("[%s] debugfs create dir failed, rc = %d\n",
> +		       DEBUG_NAME, rc);

You don't need DEBUG_NAME in the string - you already have it in the pr_fmt.

> +		goto error;
> +	}
> +
> +	file = debugfs_create_file("dp_debug", 0444, dir,
> +				debug, &dp_debug_fops);
> +	if (IS_ERR_OR_NULL(file)) {

As above.

> +		rc = PTR_ERR(file);
> +		pr_err("[%s] debugfs create file failed, rc=%d\n",
> +		       DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	edid_modes = debugfs_create_file("edid_modes", 0644, dir,
> +					debug, &edid_modes_fops);
> +	if (IS_ERR_OR_NULL(edid_modes)) {

As above.

> +		rc = PTR_ERR(edid_modes);
> +		pr_err("[%s] debugfs create edid_modes failed, rc=%d\n",
> +		       DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	hpd = debugfs_create_file("hpd", 0644, dir,
> +					debug, &hpd_fops);
> +	if (IS_ERR_OR_NULL(hpd)) {

As above.

> +		rc = PTR_ERR(hpd);
> +		pr_err("[%s] debugfs hpd failed, rc=%d\n",
> +			DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	connected = debugfs_create_file("connected", 0444, dir,
> +					debug, &connected_fops);
> +	if (IS_ERR_OR_NULL(connected)) {

As above.

> +		rc = PTR_ERR(connected);
> +		pr_err("[%s] debugfs connected failed, rc=%d\n",
> +			DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	debug->root = dir;
> +	return rc;
> +error_remove_dir:
> +	debugfs_remove(dir);
> +error:
> +	return rc;

Note that rc will have to be assigned by some value by you on error because you
won't be getting it from the api functions.

> +}
> +
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector)
> +{
> +	int rc = 0;
> +	struct dp_debug_private *debug;
> +	struct dp_debug *dp_debug;
> +
> +	if (!dev || !panel || !usbpd || !link) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
>
I don't think any of these checks are needed - they should all be non-NULL from
the caller.

> +	debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
> +	if (!debug) {
just return ERR_PTR(-ENOMEM);

> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	debug->dp_debug.debug_en = false;
> +	debug->usbpd = usbpd;
> +	debug->link = link;
> +	debug->panel = panel;
> +	debug->dev = dev;
> +	debug->connector = connector;
> +
> +	dp_debug = &debug->dp_debug;
> +	dp_debug->vdisplay = 0;
> +	dp_debug->hdisplay = 0;
> +	dp_debug->vrefresh = 0;
> +
> +	rc = dp_debug_init(dp_debug);
> +	if (rc) {
> +		devm_kfree(dev, debug);
just return ERR_PTR(rc);
> +		goto error;
> +	}
> +
> +	return dp_debug;
> +error:
> +	return ERR_PTR(rc);

THis isn't needed
> +}
> +
> +static int dp_debug_deinit(struct dp_debug *dp_debug)

This function doesn't need to return anything - the "error" is uninteresting.

> +{
> +	struct dp_debug_private *debug;
> +
> +	if (!dp_debug)
> +		return -EINVAL;
> +
> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
> +
> +	debugfs_remove_recursive(debug->root);
> +
> +	return 0;
> +}
> +
> +void dp_debug_put(struct dp_debug *dp_debug)
> +{
> +	struct dp_debug_private *debug;
> +
> +	if (!dp_debug)
> +		return;
> +
> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
> +
> +	dp_debug_deinit(dp_debug);

In fact, dp_debug_deinit doesn't need to exist - you can keep it all inline
and bonus - you don't have to do an unneeded container_of for no reason.

> +	devm_kfree(debug->dev, debug);

If you are using devm_ you don't need to free here.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.h b/drivers/gpu/drm/msm/dp/dp_debug.h
> new file mode 100644
> index 0000000..a6480e1
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_debug.h
> @@ -0,0 +1,81 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_DEBUG_H_
> +#define _DP_DEBUG_H_
> +
> +#include "dp_panel.h"
> +#include "dp_link.h"
> +#include "dp_extcon.h"
> +
> +/**
> + * struct dp_debug
> + * @debug_en: specifies whether debug mode enabled
> + * @vdisplay: used to filter out vdisplay value
> + * @hdisplay: used to filter out hdisplay value
> + * @vrefresh: used to filter out vrefresh value
> + * @tpg_state: specifies whether tpg feature is enabled
> + */
> +struct dp_debug {
> +	bool debug_en;
> +	int aspect_ratio;
> +	int vdisplay;
> +	int hdisplay;
> +	int vrefresh;
> +};
> +
> +#if defined(CONFIG_DEBUG_FS)
> +
> +/**
> + * dp_debug_get() - configure and get the DisplayPlot debug module data

DisplayPlot?  DisplayPort perhaps?

> + *
> + * @dev: device instance of the caller
> + * @panel: instance of panel module
> + * @usbpd: instance of usbpd module
> + * @link: instance of link module
> + * @connector: double pointer to display connector
> + * return: pointer to allocated debug module data
> + *
> + * This function sets up the debug module and provides a way
> + * for debugfs input to be communicated with existing modules
> + */
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector);
> +/**
> + * dp_debug_put()
> + *
> + * Cleans up dp_debug instance
> + *
> + * @dp_debug: instance of dp_debug
> + */
> +void dp_debug_put(struct dp_debug *dp_debug);
> +
> +#else
> +
> +static inline
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector)
> +{
> +	return ERR_PTR(-EINVAL);
> +}
> +
> +static inline void dp_debug_put(struct dp_debug *dp_debug)
> +{
> +}
> +
> +#endif /* defined(CONFIG_DEBUG_FS) */
> +
> +#endif /* _DP_DEBUG_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
> new file mode 100644
> index 0000000..8c98399
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
> @@ -0,0 +1,977 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX of course.

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/uaccess.h>
> +#include <linux/debugfs.h>
> +#include <linux/component.h>
> +#include <linux/of_irq.h>
> +
> +#include "msm_drv.h"
> +#include "dp_extcon.h"
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +#include "dp_aux.h"
> +#include "dp_link.h"
> +#include "dp_panel.h"
> +#include "dp_ctrl.h"
> +#include "dp_display.h"
> +#include "dp_drm.h"
> +#include "dp_debug.h"
> +
> +static struct msm_dp *g_dp_display;
> +#define HPD_STRING_SIZE 30
> +
> +struct dp_display_private {
> +	char *name;
> +	int irq;
> +
> +	/* state variables */
> +	bool core_initialized;
> +	bool power_on;
> +	bool hpd_irq_on;
> +	bool audio_supported;
> +
> +	struct platform_device *pdev;
> +	struct dentry *root;
> +	struct completion notification_comp;
> +
> +	struct dp_usbpd   *usbpd;
> +	struct dp_parser  *parser;
> +	struct dp_power   *power;
> +	struct dp_catalog *catalog;
> +	struct dp_aux     *aux;
> +	struct dp_link    *link;
> +	struct dp_panel   *panel;
> +	struct dp_ctrl    *ctrl;
> +	struct dp_debug   *debug;
> +
> +	struct dp_usbpd_cb usbpd_cb;
> +	struct dp_display_mode mode;
> +	struct msm_dp dp_display;
> +
> +};
> +
> +static const struct of_device_id dp_dt_match[] = {
> +	{.compatible = "qcom,dp-display"},
> +	{}

We like to have a comma after the closing {} for consistency.

> +};
> +
> +static irqreturn_t dp_display_irq(int irq, void *dev_id)
> +{
> +	struct dp_display_private *dp = dev_id;
> +
> +	if (!dp) {
> +		pr_err("invalid data\n");
> +		return IRQ_NONE;
> +	}
>
dp will never be NULL here

> +	/* DP controller isr */
> +	dp->ctrl->isr(dp->ctrl);
> +
> +	/* DP aux isr */
> +	dp->aux->isr(dp->aux);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int dp_display_bind(struct device *dev, struct device *master,
> +			   void *data)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +	struct drm_device *drm;
> +	struct msm_drm_private *priv;
> +	struct platform_device *pdev = to_platform_device(dev);
> +
> +	if (!dev || !pdev || !master) {
> +		pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
> +				dev, pdev, master);
> +		rc = -EINVAL;
> +		goto end;
> +	}
> 
These will never be NULL coming out of a component bind.

+
> +	drm = dev_get_drvdata(master);
> +	dp = platform_get_drvdata(pdev);
> +	if (!drm || !dp) {
> +		pr_err("invalid param(s), drm %pK, dp %pK\n",
> +				drm, dp);
> +		rc = -EINVAL;
> +		goto end;
> +	}

These are also very unlikely to be NULL.
> +
> +	dp->dp_display.drm_dev = drm;
> +	priv = drm->dev_private;
> +	priv->dp = &(dp->dp_display);
> +
> +	rc = dp->parser->parse(dp->parser);
> +	if (rc) {
> +		pr_err("device tree parsing failed\n");
> +		goto end;
> +	}
> +
> +	rc = dp->aux->drm_aux_register(dp->aux);
> +	if (rc) {
> +		pr_err("DRM DP AUX register failed\n");
> +		goto end;
> +	}
> +
> +	rc = dp->power->power_client_init(dp->power);
> +	if (rc) {
> +		pr_err("Power client create failed\n");
> +		goto end;

You don't need this goto here, you can just drop out.

> +	}
> +
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_unbind(struct device *dev, struct device *master,
> +			      void *data)
> +{
> +	struct dp_display_private *dp;
> +	struct platform_device *pdev = to_platform_device(dev);
> +	struct drm_device *drm = dev_get_drvdata(master);
> +	struct msm_drm_private *priv = drm->dev_private;
> +
> +	if (!dev || !pdev) {
> +		pr_err("invalid param(s)\n");
> +		return;
> +	}
> +
> +	dp = platform_get_drvdata(pdev);
> +	if (!dp) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

Both these checks are not likely to be NULL.

> +
> +	(void)dp->power->power_client_deinit(dp->power);
> +	(void)dp->aux->drm_aux_deregister(dp->aux);

If you don't care about the value of either of these then consider changing them
so they don't return a value.

> +	priv->dp = NULL;
> +}
> +
> +static const struct component_ops dp_display_comp_ops = {
> +	.bind = dp_display_bind,
> +	.unbind = dp_display_unbind,
> +};
> +
> +static bool dp_display_is_ds_bridge(struct dp_panel *panel)
> +{
> +	return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
> +		DP_DWN_STRM_PORT_PRESENT);
> +}
> +
> +static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
> +{
> +	return dp_display_is_ds_bridge(dp->panel) &&
> +		(dp->link->sink_count.count == 0);
> +}
> +
> +static void dp_display_send_hpd_event(struct msm_dp *dp_display)
> +{
> +	struct dp_display_private *dp;
> +	struct drm_connector *connector;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

It looks unlkely this will be NULL, so you can safely remove this or use
WARN_ON.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return;
> +	}

The result of a container_of() will NEVER be NULL at least not without a lot of
trouble.

> +	connector = dp->dp_display.connector;
> +	drm_helper_hpd_irq_event(connector->dev);
> +}
> +
> +static int dp_display_send_hpd_notification(struct dp_display_private *dp,
> +					    bool hpd)
> +{
> +	if ((hpd && dp->dp_display.is_connected) ||
> +			(!hpd && !dp->dp_display.is_connected)) {
> +		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
> +		return 0;
> +	}
> +
> +	/* reset video pattern flag on disconnect */
> +	if (!hpd)
> +		dp->panel->video_test = false;
> +
> +	dp->dp_display.is_connected = hpd;
> +	reinit_completion(&dp->notification_comp);
> +	dp_display_send_hpd_event(&dp->dp_display);
> +
> +	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
> +		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
> +		return -EINVAL;

Returning -ETIMEDOUT would be more informative.

> +	}
> +
> +	return 0;
> +}
> +
> +static int dp_display_process_hpd_high(struct dp_display_private *dp)
> +{
> +	int rc = 0;
> +	struct edid *edid;
> +
> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
> +
> +	if (dp->link->psm_enabled)
> +		goto notify;
> +
> +	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);
> +	if (rc)
> +		goto notify;
> +
> +	dp->link->process_request(dp->link);
> +
> +	if (dp_display_is_sink_count_zero(dp)) {
> +		pr_debug("no downstream devices connected\n");
> +		rc = -EINVAL;

You can just return -EINVAL here.

> +		goto end;
> +	}
> +
> +	edid = dp->panel->edid;
> +
> +	dp->audio_supported = drm_detect_monitor_audio(edid);
> +
> +	dp->panel->handle_sink_request(dp->panel);
> +
> +	dp->dp_display.max_pclk_khz = dp->parser->max_pclk_khz;
> +notify:
> +	dp_display_send_hpd_notification(dp, true);
> +
> +end:
> +	return rc;

Not needed.

> +}
> +
> +static void dp_display_host_init(struct dp_display_private *dp)
> +{
> +	bool flip = false;
> +
> +	if (dp->core_initialized) {
> +		pr_debug("DP core already initialized\n");
> +		return;
> +	}
> +
> +	if (dp->usbpd->orientation == ORIENTATION_CC2)
> +		flip = true;
> +
> +	dp->power->init(dp->power, flip);
> +	dp->ctrl->init(dp->ctrl, flip);
> +	enable_irq(dp->irq);
> +	dp->core_initialized = true;
> +}
> +
> +static void dp_display_host_deinit(struct dp_display_private *dp)
> +{
> +	if (!dp->core_initialized) {
> +		pr_debug("DP core already off\n");
> +		return;
> +	}
> +
> +	dp->ctrl->deinit(dp->ctrl);
> +	dp->power->deinit(dp->power);
> +	disable_irq(dp->irq);
> +	dp->core_initialized = false;
> +}
> +
> +static void dp_display_process_hpd_low(struct dp_display_private *dp)
> +{
> +	/* cancel any pending request */
> +	dp->ctrl->abort(dp->ctrl);
> +
> +	dp_display_send_hpd_notification(dp, false);
> +
> +	dp->aux->deinit(dp->aux);
> +}
> +
> +static int dp_display_usbpd_configure_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> 
I'm not sure if this ever be true (I suspect it can't) but if so you can use the
WARN_ON method.

> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		rc = -ENODEV;
> +		goto end;
> +	}

I'm reasonably sure that if dev is valid, this will be valid.

> +	dp_display_host_init(dp);
> +
> +	if (dp->usbpd->hpd_high)
> +		dp_display_process_hpd_high(dp);
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_clean(struct dp_display_private *dp)
> +{
> +	dp->ctrl->push_idle(dp->ctrl);
> +	dp->ctrl->off(dp->ctrl);
> +}
> +
> +static int dp_display_usbpd_disconnect_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		rc = -ENODEV;
> +		goto end;
> +	}

As above

> +	/* cancel any pending request */
> +	dp->ctrl->abort(dp->ctrl);
> +
> +	rc = dp_display_send_hpd_notification(dp, false);
> +
> +	/* if cable is disconnected, reset psm_enabled flag */
> +	if (!dp->usbpd->alt_mode_cfg_done)
> +		dp->link->psm_enabled = false;
> +
> +	if ((rc < 0) && dp->power_on)
> +		dp_display_clean(dp);
> +
> +	dp_display_host_deinit(dp);
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_handle_video_request(struct dp_display_private *dp)
> +{
> +	if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
> +		/* force disconnect followed by connect */
> +		dp->usbpd->connect(dp->usbpd, false);
> +		dp->panel->video_test = true;
> +		dp->usbpd->connect(dp->usbpd, true);
> +		dp->link->send_test_response(dp->link);
> +	}
> +}
> +
> +static int dp_display_handle_hpd_irq(struct dp_display_private *dp)
> +{
> +	if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) {
> +		dp_display_send_hpd_notification(dp, false);
> +
> +		if (dp_display_is_sink_count_zero(dp)) {
> +			pr_debug("sink count is zero, nothing to do\n");
> +			return 0;
> +		}
> +
> +		return dp_display_process_hpd_high(dp);
> +	}
> +
> +	dp->ctrl->handle_sink_request(dp->ctrl);
> +
> +	dp_display_handle_video_request(dp);
> +
> +	return 0;
> +}
> +
> +static int dp_display_usbpd_attention_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		return -EINVAL;
> +	}
> +
> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		return -ENODEV;
> +	}

As above.

> +	if (dp->usbpd->hpd_irq) {
> +		dp->hpd_irq_on = true;
> +
> +		rc = dp->link->process_request(dp->link);
> +		/* check for any test request issued by sink */
> +		if (!rc)
> +			dp_display_handle_hpd_irq(dp);
> +
> +		dp->hpd_irq_on = false;

Just return rc;
> +		goto end;
> +	}
> +
> +	if (!dp->usbpd->hpd_high) {
> +		dp_display_process_hpd_low(dp);
> +		goto end;

Just return  rc;

> +	}
> +
> +	if (dp->usbpd->alt_mode_cfg_done)
> +		dp_display_process_hpd_high(dp);

> +end:
> +	return rc;

return 0;
> +}
> +
> +static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
> +{
> +	dp_ctrl_put(dp->ctrl);
> +	dp_link_put(dp->link);
> +	dp_panel_put(dp->panel);
> +	dp_aux_put(dp->aux);
> +	dp_power_put(dp->power);
> +	dp_catalog_put(dp->catalog);
> +	dp_parser_put(dp->parser);
> +	dp_debug_put(dp->debug);
> +}
> +
> +static int dp_init_sub_modules(struct dp_display_private *dp)
> +{
> +	int rc = 0;
> +	struct device *dev = &dp->pdev->dev;
> +	struct dp_usbpd_cb *cb = &dp->usbpd_cb;
> +	struct dp_ctrl_in ctrl_in = {
> +		.dev = dev,
> +	};
> +	struct dp_panel_in panel_in = {
> +		.dev = dev,
> +	};
> +
> +	/* Callback APIs used for cable status change event */
> +	cb->configure  = dp_display_usbpd_configure_cb;
> +	cb->disconnect = dp_display_usbpd_disconnect_cb;
> +	cb->attention  = dp_display_usbpd_attention_cb;
> +
> +	dp->parser = dp_parser_get(dp->pdev);
> +	if (IS_ERR(dp->parser)) {
> +		rc = PTR_ERR(dp->parser);
> +		pr_err("failed to initialize parser, rc = %d\n", rc);
> +		dp->parser = NULL;
> +		goto error_parser;
> +	}
> +
> +	dp->catalog = dp_catalog_get(dev, &dp->parser->io);
> +	if (IS_ERR(dp->catalog)) {
> +		rc = PTR_ERR(dp->catalog);
> +		pr_err("failed to initialize catalog, rc = %d\n", rc);
> +		dp->catalog = NULL;
> +		goto error_catalog;
> +	}
> +
> +	dp->power = dp_power_get(dp->parser);
> +	if (IS_ERR(dp->power)) {
> +		rc = PTR_ERR(dp->power);
> +		pr_err("failed to initialize power, rc = %d\n", rc);
> +		dp->power = NULL;
> +		goto error_power;
> +	}
> +
> +	dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser->aux_cfg);
> +	if (IS_ERR(dp->aux)) {
> +		rc = PTR_ERR(dp->aux);
> +		pr_err("failed to initialize aux, rc = %d\n", rc);
> +		dp->aux = NULL;
> +		goto error_aux;
> +	}
> +
> +	dp->link = dp_link_get(dev, dp->aux);
> +	if (IS_ERR(dp->link)) {
> +		rc = PTR_ERR(dp->link);
> +		pr_err("failed to initialize link, rc = %d\n", rc);
> +		dp->link = NULL;
> +		goto error_link;
> +	}
> +
> +	panel_in.aux = dp->aux;
> +	panel_in.catalog = &dp->catalog->panel;
> +	panel_in.link = dp->link;
> +
> +	dp->panel = dp_panel_get(&panel_in);
> +	if (IS_ERR(dp->panel)) {
> +		rc = PTR_ERR(dp->panel);
> +		pr_err("failed to initialize panel, rc = %d\n", rc);
> +		dp->panel = NULL;
> +		goto error_panel;
> +	}
> +
> +	ctrl_in.link = dp->link;
> +	ctrl_in.panel = dp->panel;
> +	ctrl_in.aux = dp->aux;
> +	ctrl_in.power = dp->power;
> +	ctrl_in.catalog = &dp->catalog->ctrl;
> +	ctrl_in.parser = dp->parser;
> +
> +	dp->ctrl = dp_ctrl_get(&ctrl_in);
> +	if (IS_ERR(dp->ctrl)) {
> +		rc = PTR_ERR(dp->ctrl);
> +		pr_err("failed to initialize ctrl, rc = %d\n", rc);
> +		dp->ctrl = NULL;
> +		goto error_ctrl;
> +	}
> +
> +	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
> +				dp->link, &dp->dp_display.connector);
> +	if (IS_ERR(dp->debug)) {
> +		rc = PTR_ERR(dp->debug);
> +		pr_err("failed to initialize debug, rc = %d\n", rc);

dp_debug_get() prints all the interesting error messsages - you don't need to
add on.

In fact, I think this is probably true for the rest of the dp_ calls above - in
general, try to keep the number of log messages per error down to 1.

> +		dp->debug = NULL;
> +		goto error_debug;
> +	}
> +
> +	return rc;
> +error_debug:
> +	dp_ctrl_put(dp->ctrl);
> +error_ctrl:
> +	dp_panel_put(dp->panel);
> +error_panel:
> +	dp_link_put(dp->link);
> +error_link:
> +	dp_aux_put(dp->aux);
> +error_aux:
> +	dp_power_put(dp->power);
> +error_power:
> +	dp_catalog_put(dp->catalog);
> +error_catalog:
> +	dp_parser_put(dp->parser);
> +error_parser:
> +	return rc;
> +}
> +
> +static int dp_display_set_mode(struct msm_dp *dp_display,
> +			       struct dp_display_mode *mode)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

I'm betting this can't be NULL;

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	dp->panel->pinfo = mode->timing;
> +	dp->panel->init_info(dp->panel);
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_prepare(struct msm_dp *dp)
> +{
> +	return 0;
> +}
> +
> +static int dp_display_enable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

I am guessing this can't be NULL.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (dp->power_on) {
> +		pr_debug("Link already setup, return\n");
> +		return 0;
> +	}
> +
> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
> +
> +	rc = dp->ctrl->on(dp->ctrl);
> +	if (!rc)
> +		dp->power_on = true;
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_post_enable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
>
As above.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	complete_all(&dp->notification_comp);
> +
> +end:
> +	return rc;
> +}
> +
> +static int dp_display_pre_disable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +

as above.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (dp->usbpd->alt_mode_cfg_done && (dp->usbpd->hpd_high ||
> +		dp->usbpd->forced_disconnect))
> +		dp->link->psm_config(dp->link, &dp->panel->link_info, true);
> +
> +	dp->ctrl->push_idle(dp->ctrl);
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_disable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
>
As above.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (!dp->power_on || !dp->core_initialized)
> +		goto error;

goto error is deceptive here.  You can just return 0.  In fact, if you get
rid of the uneeded NULL check you don't have to return anything from this
function.

> +
> +	dp->ctrl->off(dp->ctrl);
> +
> +	dp->power_on = false;
> +
> +	complete_all(&dp->notification_comp);
> +error:
> +	return rc;
> +}
> +
> +static int dp_request_irq(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}

Likely not needed.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
> +	if (dp->irq < 0) {
> +		rc = dp->irq;
> +		pr_err("failed to get irq: %d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq,
> +		IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
> +	if (rc < 0) {
> +		pr_err("failed to request IRQ%u: %d\n",
> +				dp->irq, rc);
> +		return rc;
> +	}
> +	disable_irq(dp->irq);
> +
> +	return 0;
> +}
> +
> +static struct dp_debug *dp_get_debug(struct msm_dp *dp_display)
> +{
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return ERR_PTR(-EINVAL);
> +	}

Likely not needed.

> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	return dp->debug;
> +}
> +
> +static int dp_display_unprepare(struct msm_dp *dp)
> +{
> +	return 0;
> +}
> +
> +static int dp_display_validate_mode(struct msm_dp *dp, u32 mode_pclk_khz)
> +{
> +	const u32 num_components = 3, default_bpp = 24;
> +	struct dp_display_private *dp_display;
> +	struct drm_dp_link *link_info;
> +	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
> +
> +	if (!dp || !mode_pclk_khz || !dp->connector) {
> +		pr_err("invalid params\n");
> +		return -EINVAL;
> +	}

Same as above.

> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +	link_info = &dp_display->panel->link_info;
> +
> +	mode_bpp = dp->connector->display_info.bpc * num_components;
> +	if (!mode_bpp)
> +		mode_bpp = default_bpp;
> +
> +	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,
> +			mode_bpp, mode_pclk_khz);
> +
> +	mode_rate_khz = mode_pclk_khz * mode_bpp;
> +	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
> +
> +	if (mode_rate_khz > supported_rate_khz)
> +		return MODE_BAD;
> +
> +	return MODE_OK;
> +}
> +
> +static int dp_display_get_modes(struct msm_dp *dp,
> +				struct dp_display_mode *dp_mode)
> +{
> +	struct dp_display_private *dp_display;
> +	int ret = 0;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return 0;
> +	}

Likely not needed.

> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	ret = dp_display->panel->get_modes(dp_display->panel,
> +		dp->connector, dp_mode);
> +	if (dp_mode->timing.pixel_clk_khz)
> +		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;
> +	return ret;
> +}
> +
> +static bool dp_display_check_video_test(struct msm_dp *dp)
> +{
> +	struct dp_display_private *dp_display;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return false;
> +	}

Likely not needed

> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	if (dp_display->panel->video_test)
> +		return true;
> +
> +	return false;
> +}
> +
> +static int dp_display_get_test_bpp(struct msm_dp *dp)
> +{
> +	struct dp_display_private *dp_display;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return 0;
> +	}

Likely not needed.

> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	return dp_link_bit_depth_to_bpp(
> +		dp_display->link->test_video.test_bit_depth);
> +}
> +
> +static int dp_display_probe(struct platform_device *pdev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!pdev || !pdev->dev.of_node) {
> +		pr_err("pdev not found\n");
> +		return -ENODEV;
> +	}

Both of these will always be true in a probe function that you reach from a
compatible match.

> +	dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
> +	if (!dp)
> +		return -ENOMEM;
> +
> +	init_completion(&dp->notification_comp);
> +
> +	dp->pdev = pdev;
> +	dp->name = "drm_dp";
> +
> +	rc = dp_init_sub_modules(dp);
> +	if (rc) {
> +		pr_err("init sub module failed\n");
I'm guessing that  this log message will always be superfluous.

> +		devm_kfree(&pdev->dev, dp);
> +		return -EPROBE_DEFER;

Always return -EPROBE_DEFER regardless of the error?  It seems that at a certain
point many of these errors you point out would be fatal to the device regardless
of the order of initialization.

> +	}
> +
> +	platform_set_drvdata(pdev, dp);
> +
> +	g_dp_display = &dp->dp_display;
> +
> +	g_dp_display->enable        = dp_display_enable;
> +	g_dp_display->post_enable   = dp_display_post_enable;
> +	g_dp_display->pre_disable   = dp_display_pre_disable;
> +	g_dp_display->disable       = dp_display_disable;
> +	g_dp_display->set_mode      = dp_display_set_mode;
> +	g_dp_display->validate_mode = dp_display_validate_mode;
> +	g_dp_display->get_modes     = dp_display_get_modes;
> +	g_dp_display->prepare       = dp_display_prepare;
> +	g_dp_display->unprepare     = dp_display_unprepare;
> +	g_dp_display->request_irq   = dp_request_irq;
> +	g_dp_display->get_debug     = dp_get_debug;
> +	g_dp_display->send_hpd_event    = dp_display_send_hpd_event;
> +	g_dp_display->is_video_test = dp_display_check_video_test;
> +	g_dp_display->get_test_bpp = dp_display_get_test_bpp;
> +
> +	rc = component_add(&pdev->dev, &dp_display_comp_ops);
> +	if (rc) {
> +		pr_err("component add failed, rc=%d\n", rc);
> +		dp_display_deinit_sub_modules(dp);
> +		devm_kfree(&pdev->dev, dp);
> +	}
> +
> +	return rc;
> +}
> +
> +int dp_display_get_displays(void **displays, int count)
> +{
> +	if (!displays) {
> +		pr_err("invalid data\n");
> +		return -EINVAL;
> +	}
> +
> +	if (count != 1) {
> +		pr_err("invalid number of displays\n");
> +		return -EINVAL;
> +	}
> +
> +	displays[0] = g_dp_display;
> +	return count;
> +}

This isn't used in this patch so I don't see how it is used but based on
everything it seems like you could just as easily get away with

struct msm_dp *dp_display_get_display(void)
{
	return g_dp_display;
}

Even if you are planning for the future, you can make the changes to support
multiple displays then and save yourself the effort now.

> +int dp_display_get_num_of_displays(void)
> +{
> +	return 1;
> +}
> +
> +static int dp_display_remove(struct platform_device *pdev)
> +{
> +	struct dp_display_private *dp;
> +
> +	if (!pdev)
> +		return -EINVAL;

pdev will never be NULL here.

> +
> +	dp = platform_get_drvdata(pdev);
> +
> +	dp_display_deinit_sub_modules(dp);
> +
> +	platform_set_drvdata(pdev, NULL);
> +	devm_kfree(&pdev->dev, dp);

You don't need to devm_kfree() in a remove function here.
> +
> +	return 0;
> +}
> +
> +static struct platform_driver dp_display_driver = {
> +	.probe  = dp_display_probe,
> +	.remove = dp_display_remove,
> +	.driver = {
> +		.name = "msm-dp-display",
> +		.of_match_table = dp_dt_match,
> +	},
> +};
> +
> +int __init msm_dp_register(void)
> +{
> +	int ret;
> +
> +	ret = platform_driver_register(&dp_display_driver);
> +	if (ret) {
> +		pr_err("driver register failed");
> +		return ret;

You don't need this return ret - you can just drop out to the bottom.

> +	}
> +
> +	return ret;
> +}
> +
> +void __exit msm_dp_unregister(void)
> +{
> +	platform_driver_unregister(&dp_display_driver);
> +}
> +
> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
> +			struct drm_encoder *encoder)
> +{
> +	struct msm_drm_private *priv;
> +	int ret;
> +
> +	if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
> +		return -EINVAL;

Thats what I like to see - but you could also do

if (WARN_ON(!encoder || !dp_display || !dev))

> 
> +	priv = dev->dev_private;
> +	dp_display->drm_dev = dev;
> +
> +	ret = dp_drm_bridge_init(dp_display, encoder);
> +	if (ret) {
> +		dev_err(dev->dev, "failed to create dp bridge: %d\n", ret);

Just double check to see how redundant this error message is.

> +		dp_display->bridge = NULL;
> +		return ret;
> +	}
> +	dp_display->encoder = encoder;
> +
> +	dp_display->connector = dp_drm_connector_init(dp_display);
> +	if (IS_ERR(dp_display->connector)) {
> +		ret = PTR_ERR(dp_display->connector);
> +		dev_err(dev->dev,
> +			"failed to create dp connector: %d\n", ret);

Same.

> +		dp_display->connector = NULL;
> +		goto conn_fail;
> +	}
> +
> +	priv->bridges[priv->num_bridges++] = dp_display->bridge;
> +	priv->connectors[priv->num_connectors++] = dp_display->connector;
> +	return 0;
> +
> +conn_fail:
> +	if (dp_display->bridge) {
> +		dp_drm_bridge_deinit(dp_display);
> +		dp_display->bridge = NULL;
> +	}
> +	return ret;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
> new file mode 100644
> index 0000000..ca5eae5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
> @@ -0,0 +1,55 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_DISPLAY_H_
> +#define _DP_DISPLAY_H_
> +
> +#include <drm/drmP.h>
> +
> +#include "dp_panel.h"
> +
> +struct msm_dp {
> +	struct drm_device *drm_dev;
> +	struct dp_bridge *dp_bridge;
> +	struct drm_connector *connector;
> +	struct drm_bridge *bridge;
> +
> +	/* the encoder we are hooked to (outside of dsi block) */
> +	struct drm_encoder *encoder;
> +	bool is_connected;
> +	u32 max_pclk_khz;
> +
> +	int (*enable)(struct msm_dp *dp_display);
> +	int (*post_enable)(struct msm_dp *dp_display);
> +
> +	int (*pre_disable)(struct msm_dp *dp_display);
> +	int (*disable)(struct msm_dp *dp_display);
> +
> +	int (*set_mode)(struct msm_dp *dp_display,
> +			struct dp_display_mode *mode);
> +	int (*validate_mode)(struct msm_dp *dp_display, u32 mode_pclk_khz);
> +	int (*get_modes)(struct msm_dp *dp_display,
> +		struct dp_display_mode *dp_mode);
> +	int (*prepare)(struct msm_dp *dp_display);
> +	int (*unprepare)(struct msm_dp *dp_display);
> +	int (*request_irq)(struct msm_dp *dp_display);
> +	struct dp_debug *(*get_debug)(struct msm_dp *dp_display);
> +	void (*send_hpd_event)(struct msm_dp *dp_display);
> +	bool (*is_video_test)(struct msm_dp *dp_display);
> +	int (*get_test_bpp)(struct msm_dp *dp_display);
> +};
> +
> +int dp_display_get_num_of_displays(void);
> +int dp_display_get_displays(void **displays, int count);
> +#endif /* _DP_DISPLAY_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.c b/drivers/gpu/drm/msm/dp/dp_drm.c
> new file mode 100644
> index 0000000..64d6449
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_drm.c
> @@ -0,0 +1,542 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX

> +#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
> +
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_crtc.h>
> +
> +#include "msm_drv.h"
> +#include "msm_kms.h"
> +//#include "dpu_connector.h"

If this isn't needed just get rid of it

> +#include "dp_drm.h"
> +#include "dp_debug.h"
> +
> +struct dp_connector {
> +	struct drm_connector base;
> +	struct msm_dp *dp_display;
> +};
> +#define to_dp_connector(x) container_of(x, struct dp_connector, base)
> +#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
> +
> +static void convert_to_dp_mode(const struct drm_display_mode *drm_mode,
> +			struct dp_display_mode *dp_mode, struct msm_dp *dp)
> +{
> +	const u32 num_components = 3;

I prefer to use just the constants inline, especially since you are only using
once.

> +
> +	memset(dp_mode, 0, sizeof(*dp_mode));
> +
> +	dp_mode->timing.h_active = drm_mode->hdisplay;
> +	dp_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;
> +	dp_mode->timing.h_sync_width = drm_mode->htotal -
> +			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);
> +	dp_mode->timing.h_front_porch = drm_mode->hsync_start -
> +					 drm_mode->hdisplay;
> +	dp_mode->timing.h_skew = drm_mode->hskew;
> +
> +	dp_mode->timing.v_active = drm_mode->vdisplay;
> +	dp_mode->timing.v_back_porch = drm_mode->vtotal - drm_mode->vsync_end;
> +	dp_mode->timing.v_sync_width = drm_mode->vtotal -
> +		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);
> +
> +	dp_mode->timing.v_front_porch = drm_mode->vsync_start -
> +					 drm_mode->vdisplay;
> +
> +	if (dp->is_video_test(dp))
> +		dp_mode->timing.bpp = dp->get_test_bpp(dp);
> +	else
> +		dp_mode->timing.bpp = dp->connector->display_info.bpc *
> +		num_components;
> +
> +	if (!dp_mode->timing.bpp)
> +		dp_mode->timing.bpp = 24;
> +
> +	dp_mode->timing.refresh_rate = drm_mode->vrefresh;
> +
> +	dp_mode->timing.pixel_clk_khz = drm_mode->clock;
> +
> +	dp_mode->timing.v_active_low =
> +		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);
> +
> +	dp_mode->timing.h_active_low =
> +		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);
> +}
> +
> +static void convert_to_drm_mode(const struct dp_display_mode *dp_mode,
> +				struct drm_display_mode *drm_mode)
> +{
> +	u32 flags = 0;
> +
> +	memset(drm_mode, 0, sizeof(*drm_mode));
> +
> +	drm_mode->hdisplay = dp_mode->timing.h_active;
> +	drm_mode->hsync_start = drm_mode->hdisplay +
> +				dp_mode->timing.h_front_porch;
> +	drm_mode->hsync_end = drm_mode->hsync_start +
> +			      dp_mode->timing.h_sync_width;
> +	drm_mode->htotal = drm_mode->hsync_end + dp_mode->timing.h_back_porch;
> +	drm_mode->hskew = dp_mode->timing.h_skew;
> +
> +	drm_mode->vdisplay = dp_mode->timing.v_active;
> +	drm_mode->vsync_start = drm_mode->vdisplay +
> +				dp_mode->timing.v_front_porch;
> +	drm_mode->vsync_end = drm_mode->vsync_start +
> +			      dp_mode->timing.v_sync_width;
> +	drm_mode->vtotal = drm_mode->vsync_end + dp_mode->timing.v_back_porch;
> +
> +	drm_mode->vrefresh = dp_mode->timing.refresh_rate;
> +	drm_mode->clock = dp_mode->timing.pixel_clk_khz;
> +
> +	if (dp_mode->timing.h_active_low)
> +		flags |= DRM_MODE_FLAG_NHSYNC;
> +	else
> +		flags |= DRM_MODE_FLAG_PHSYNC;
> +
> +	if (dp_mode->timing.v_active_low)
> +		flags |= DRM_MODE_FLAG_NVSYNC;
> +	else
> +		flags |= DRM_MODE_FLAG_PVSYNC;
> +
> +	drm_mode->flags = flags;
> +
> +	drm_mode->type = 0x48;
> +	drm_mode_set_name(drm_mode);
> +}
> +
> +static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

bridge will always be valid.


> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;

You can move these two up to the declaration and save yourself two more lines
per function here and throughout.

> +
> +	/* By this point mode should have been validated through mode_fixup */
> +	rc = dp->set_mode(dp, &bridge->dp_mode);
> +	if (rc) {
> +		pr_err("[%d] failed to perform a mode set, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->prepare(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display prepare failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->enable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display enable failed, rc=%d\n",
> +		       bridge->id, rc);
> +		dp->unprepare(dp);
> +	}
> +}
> +
> +static void dp_bridge_enable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

bridge will always be valid.

> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->post_enable(dp);
> +	if (rc)
> +		pr_err("[%d] DP display post enable failed, rc=%d\n",
> +		       bridge->id, rc);
> +}
> +
> +static void dp_bridge_disable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

bridge will always be valid.

> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->pre_disable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display pre disable failed, rc=%d\n",
> +		       bridge->id, rc);
> +	}
> +}
> +
> +static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

bridge will always be valid.

> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->disable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display disable failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->unprepare(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display unprepare failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +}
> +
> +static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
> +				struct drm_display_mode *mode,
> +				struct drm_display_mode *adjusted_mode)
> +{
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge || !mode || !adjusted_mode) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}

bridge will always be valid. Not sure about mode or adjusted_mode, maybe you
should use WARN_ON for those.

> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
> +	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode, dp);
> +}
> +
> +static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
> +				  const struct drm_display_mode *mode,
> +				  struct drm_display_mode *adjusted_mode)
> +{
> +	bool ret = true;
> +	struct dp_display_mode dp_mode;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge || !mode || !adjusted_mode) {
> +		pr_err("Invalid params\n");
> +		ret = false;
> +		goto end;
> +	}
>
drm_bridge will always be valid, not positive about the other two.

> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	convert_to_dp_mode(mode, &dp_mode, dp);
> +	convert_to_drm_mode(&dp_mode, adjusted_mode);
> +end:
> +	return ret;
> +}
> +
> +static const struct drm_bridge_funcs dp_bridge_ops = {
> +	.mode_fixup   = dp_bridge_mode_fixup,
> +	.pre_enable   = dp_bridge_pre_enable,
> +	.enable       = dp_bridge_enable,
> +	.disable      = dp_bridge_disable,
> +	.post_disable = dp_bridge_post_disable,
> +	.mode_set     = dp_bridge_mode_set,
> +};
> +
> +int dp_connector_post_init(struct drm_connector *connector, void *display)
> +{
> +	struct msm_dp *dp_display = display;
> +
> +	if (!dp_display)
> +		return -EINVAL;
> +
> +	dp_display->connector = connector;
> +	return 0;
> +}
> +
> +/**
> + * dp_connector_detect - callback to determine if connector is connected
> + * @connector: Pointer to drm connector structure
> + * @force: Force detect setting from drm framework
> + * Returns: Connector 'is connected' status
> + */
> +static enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
> +		bool force)
> +{
> +	enum drm_connector_status status = connector_status_unknown;
> +	static enum drm_connector_status current_status = connector_status_unknown;
> +	struct msm_dp *dp;
> +	struct dp_connector *dp_conn;
> +	struct msm_drm_private *priv = conn->dev->dev_private;
> +	struct msm_kms *kms = priv->kms;
> +
> +	dp_conn = to_dp_connector(conn);
> +	dp = dp_conn->dp_display;
> +
> +	pr_err("is_connected = %s\n",
> +		(dp->is_connected) ? "true" : "false");

Oops, this looks like a debug message.

> +
> +	status = (dp->is_connected) ? connector_status_connected :
> +					connector_status_disconnected;
> +
> +	if (dp->is_connected && dp->bridge->encoder
> +				&& (current_status != status)
> +				&& kms->funcs->set_encoder_mode) {
> +		kms->funcs->set_encoder_mode(kms,
> +				dp->bridge->encoder, false);
> +		pr_err("call set_encoder_mode\n");

This too.

> +	}
> +	current_status = status;
> +	return status;
> +}
> +
> +static void dp_connector_destroy(struct drm_connector *connector)
> +{
> +	struct dp_connector *dp_conn = to_dp_connector(connector);
> +
> +	DBG("");
> +
> +	drm_connector_cleanup(connector);
> +
> +	kfree(dp_conn);
> +}
> +
> +void dp_connector_send_hpd_event(void *display)
> +{
> +	struct msm_dp *dp;
> +
> +	if (!display) {
> +		pr_err("invalid input\n");

Even if this is invalid, you don't need a error message.  A WARN_ON if you must.

> +		return;
> +	}
> +
> +	dp = display;
> +
> +	if (dp->send_hpd_event)
> +		dp->send_hpd_event(dp);
> +}
> +
> +/**
> + * dp_connector_get_modes - callback to add drm modes via drm_mode_probed_add()
> + * @connector: Pointer to drm connector structure
> + * Returns: Number of modes added
> + */
> +static int dp_connector_get_modes(struct drm_connector *connector)
> +{
> +	int rc = 0;
> +	struct msm_dp *dp;
> +	struct dp_display_mode *dp_mode = NULL;
> +	struct drm_display_mode *m, drm_mode;
> +	struct dp_connector *dp_conn;
> +
> +	if (!connector)
> +		return 0;
> 
Connector can never be NULL here.
+
> +	dp_conn = to_dp_connector(connector);
> +	dp = dp_conn->dp_display;

You can move these to the declaration.

> +	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
> +	if (!dp_mode)
> +		return 0;

Return 0 on -ENOMEM?

> +
> +	/* pluggable case assumes EDID is read when HPD */
> +	if (dp->is_connected) {
> +		rc = dp->get_modes(dp, dp_mode);
> +		if (!rc)
> +			pr_err("failed to get DP sink modes, rc=%d\n", rc);
> +

Do you wnat to keep going here even if the get_modes failed?

> +		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
> +			memset(&drm_mode, 0x0, sizeof(drm_mode));
> +			convert_to_drm_mode(dp_mode, &drm_mode);
> +			m = drm_mode_duplicate(connector->dev, &drm_mode);
> +			if (!m) {
> +				pr_err("failed to add mode %ux%u\n",
> +				       drm_mode.hdisplay,
> +				       drm_mode.vdisplay);
> +				kfree(dp_mode);
> +				return 0;
> +			}
> +			m->width_mm = connector->display_info.width_mm;
> +			m->height_mm = connector->display_info.height_mm;
> +			drm_mode_probed_add(connector, m);
> +		}
> +	} else {
> +		pr_err("No sink connected\n");
> +	}
> +	kfree(dp_mode);

How big is dp_mode? You can't put it on the stack?
> +
> +	return rc;
> +}
> +
> +int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
> +{
> +	int rc = 0;
> +	struct dp_bridge *dp_bridge;
> +	struct drm_device *dev;
> +	struct msm_dp *dp_display = data;
> +	struct msm_drm_private *priv = NULL;
> +
> +	dp_bridge = kzalloc(sizeof(*dp_bridge), GFP_KERNEL);
> +	if (!dp_bridge) {
> +		rc = -ENOMEM;

Just return -ENOMEM;

> +		goto error;
> +	}
> +
> +	dev = dp_display->drm_dev;
> +	dp_bridge->display = dp_display;
> +	dp_bridge->base.funcs = &dp_bridge_ops;
> +	dp_bridge->base.encoder = encoder;
> +
> +	priv = dev->dev_private;
> +
> +	rc = drm_bridge_attach(encoder, &dp_bridge->base, NULL);
> +	if (rc) {
> +		pr_err("failed to attach bridge, rc=%d\n", rc);
> +		goto error_free_bridge;
> +	}
> +
> +	rc = dp_display->request_irq(dp_display);
> +	if (rc) {
> +		pr_err("request_irq failed, rc=%d\n", rc);
> +		goto error_free_bridge;
> +	}
> +
> +	encoder->bridge = &dp_bridge->base;
> +	dp_display->dp_bridge = dp_bridge;
> +	dp_display->bridge = &dp_bridge->base;
> +
> +	return 0;
> +error_free_bridge:
> +	kfree(dp_bridge);
> +error:
> +	return rc;
> +}
> +
> +void dp_drm_bridge_deinit(void *data)
> +{
> +	struct msm_dp *display = data;
> +	struct dp_bridge *bridge = display->dp_bridge;
> +
> +	if (bridge && bridge->base.encoder)
> +		bridge->base.encoder->bridge = NULL;
> +
> +	kfree(bridge);
> +}
> +
> +/**
> + * dp_connector_mode_valid - callback to determine if specified mode is valid
> + * @connector: Pointer to drm connector structure
> + * @mode: Pointer to drm mode structure
> + * Returns: Validity status for specified mode
> + */
> +static enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,
> +		struct drm_display_mode *mode)
> +{
> +	struct msm_dp *dp_disp;
> +	struct dp_debug *debug;
> +	struct dp_connector *dp_conn;
> +
> +	if (!mode || !connector) {
> +		pr_err("invalid params\n");
> +		return MODE_ERROR;
> +	}
> 
I'm sure connector will always be valid, not sure about mode.

> +	dp_conn = to_dp_connector(connector);
> +	dp_disp = dp_conn->dp_display;
> +	debug = dp_disp->get_debug(dp_disp);
> +
> +	mode->vrefresh = drm_mode_vrefresh(mode);
> +
> +	if (mode->clock > dp_disp->max_pclk_khz)
> +		return MODE_BAD;
> +
> +	if (debug->debug_en && (mode->hdisplay != debug->hdisplay ||
> +			mode->vdisplay != debug->vdisplay ||
> +			mode->vrefresh != debug->vrefresh ||
> +			mode->picture_aspect_ratio != debug->aspect_ratio))
> +		return MODE_BAD;
> +
> +	return dp_disp->validate_mode(dp_disp, mode->clock);
> +}
> +
> +static const struct drm_connector_funcs dp_connector_funcs = {
> +	.detect = dp_connector_detect,
> +	.fill_modes = drm_helper_probe_single_connector_modes,
> +	.destroy = dp_connector_destroy,
> +	.reset = drm_atomic_helper_connector_reset,
> +	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
> +};
> +
> +static const struct drm_connector_helper_funcs dp_connector_helper_funcs = {
> +	.get_modes = dp_connector_get_modes,
> +	.mode_valid = dp_connector_mode_valid,
> +};
> +
> +/* connector initialization */
> +struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display)
> +{
> +	struct drm_connector *connector = NULL;
> +	struct dp_connector *dp_connector;
> +	int ret;
> +
> +	dp_connector = kzalloc(sizeof(*dp_connector), GFP_KERNEL);
> +	if (!dp_connector)
> +		return ERR_PTR(-ENOMEM);
> +
> +	dp_connector->dp_display = dp_display;
> +
> +	connector = &dp_connector->base;
> +
> +	ret = drm_connector_init(dp_display->drm_dev, connector, &dp_connector_funcs,
> +			DRM_MODE_CONNECTOR_DisplayPort);
> +	if (ret)

You are missing a kfree here.

> +		return ERR_PTR(ret);
> +
> +	drm_connector_helper_add(connector, &dp_connector_helper_funcs);
> +
> +	/*
> +	 * Enable HPD to let hpd event is handled
> +	 * when cable is attached to the host.
> +	 */
> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
> +
> +	/* Display driver doesn't support interlace now. */
> +	connector->interlace_allowed = false;
> +	connector->doublescan_allowed = false;
> +
> +	drm_connector_attach_encoder(connector, dp_display->encoder);
> +
> +	return connector;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.h b/drivers/gpu/drm/msm/dp/dp_drm.h
> new file mode 100644
> index 0000000..efbc1be
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_drm.h
> @@ -0,0 +1,52 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_DRM_H_
> +#define _DP_DRM_H_
> +
> +#include <linux/types.h>
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_crtc_helper.h>
> +
> +#include "msm_drv.h"
> +#include "dp_display.h"
> +
> +struct dp_bridge {
> +	struct drm_bridge base;
> +	u32 id;
> +
> +	struct msm_dp *display;
> +	struct dp_display_mode dp_mode;
> +};
> +
> +/**
> + * dp_connector_post_init - callback to perform additional initialization steps
> + * @connector: Pointer to drm connector structure
> + * @display: Pointer to private display handle
> + * Returns: Zero on success
> + */
> +int dp_connector_post_init(struct drm_connector *connector, void *display);
> +
> +void dp_connector_send_hpd_event(void *display);
> +
> +int dp_drm_bridge_init(void *display,
> +	struct drm_encoder *encoder);
> +
> +void dp_drm_bridge_deinit(void *display);
> +
> +struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display);
> +
> +#endif /* _DP_DRM_H_ */
> +
> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.c b/drivers/gpu/drm/msm/dp/dp_extcon.c
> new file mode 100644
> index 0000000..635c13b
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.c
> @@ -0,0 +1,400 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/slab.h>
> +#include <linux/device.h>
> +#include <linux/extcon.h>
> +
> +#include "dp_extcon.h"
> +
> +/* DP specific VDM commands */
> +#define DP_USBPD_VDM_STATUS	0x10
> +#define DP_USBPD_VDM_CONFIGURE	0x11
> +
> +/* USBPD-TypeC specific Macros */
> +#define VDM_VERSION		0x0
> +#define USB_C_DP_SID		0xFF01
> +
> +enum dp_usbpd_pin_assignment {
> +	DP_USBPD_PIN_A,
> +	DP_USBPD_PIN_B,
> +	DP_USBPD_PIN_C,
> +	DP_USBPD_PIN_D,
> +	DP_USBPD_PIN_E,
> +	DP_USBPD_PIN_F,
> +	DP_USBPD_PIN_MAX,
> +};
> +
> +struct dp_usbpd_capabilities {
> +	enum dp_usbpd_port port;
> +	bool receptacle_state;
> +	u8 ulink_pin_config;
> +	u8 dlink_pin_config;
> +};
> +
> +struct dp_extcon_private {
> +	u32 vdo;
> +	struct device *dev;
> +	struct notifier_block extcon_nb;
> +	struct extcon_dev *extcon;
> +	struct workqueue_struct *extcon_wq;
> +	struct work_struct event_work;
> +	struct usbpd *pd;
> +	struct dp_usbpd_cb *dp_cb;
> +	struct dp_usbpd_capabilities cap;
> +	struct dp_usbpd dp_usbpd;
> +};
> +
> +static const char *dp_usbpd_pin_name(u8 pin)
> +{
> +	switch (pin) {
> +	case DP_USBPD_PIN_A: return "DP_USBPD_PIN_ASSIGNMENT_A";
> +	case DP_USBPD_PIN_B: return "DP_USBPD_PIN_ASSIGNMENT_B";
> +	case DP_USBPD_PIN_C: return "DP_USBPD_PIN_ASSIGNMENT_C";
> +	case DP_USBPD_PIN_D: return "DP_USBPD_PIN_ASSIGNMENT_D";
> +	case DP_USBPD_PIN_E: return "DP_USBPD_PIN_ASSIGNMENT_E";
> +	case DP_USBPD_PIN_F: return "DP_USBPD_PIN_ASSIGNMENT_F";
> +	default: return "UNKNOWN";
> +	}
> +}
> +
> +static const char *dp_usbpd_port_name(enum dp_usbpd_port port)
> +{
> +	switch (port) {
> +	case DP_USBPD_PORT_NONE: return "DP_USBPD_PORT_NONE";
> +	case DP_USBPD_PORT_UFP_D: return "DP_USBPD_PORT_UFP_D";
> +	case DP_USBPD_PORT_DFP_D: return "DP_USBPD_PORT_DFP_D";
> +	case DP_USBPD_PORT_D_UFP_D: return "DP_USBPD_PORT_D_UFP_D";
> +	default: return "DP_USBPD_PORT_NONE";
> +	}
> +}
> +
> +static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
> +{
> +	switch (in_port) {
> +	case 0:
> +		*port = DP_USBPD_PORT_NONE;
> +		break;
> +	case 1:
> +		*port = DP_USBPD_PORT_UFP_D;
> +		break;
> +	case 2:
> +		*port = DP_USBPD_PORT_DFP_D;
> +		break;
> +	case 3:
> +		*port = DP_USBPD_PORT_D_UFP_D;
> +		break;
> +	default:
> +		*port = DP_USBPD_PORT_NONE;
> +	}
> +	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
> +}
> +
> +void dp_usbpd_get_capabilities(struct dp_extcon_private *pd)
> +{
> +	struct dp_usbpd_capabilities *cap = &pd->cap;
> +	u32 buf = pd->vdo;
> +	int port = buf & 0x3;
> +
> +	cap->receptacle_state = (buf & BIT(6)) ? true : false;
> +	cap->dlink_pin_config = (buf >> 8) & 0xff;
> +	cap->ulink_pin_config = (buf >> 16) & 0xff;
> +
> +	dp_usbpd_init_port(&cap->port, port);
> +}
> +
> +void dp_usbpd_get_status(struct dp_extcon_private *pd)
> +{
> +	struct dp_usbpd *status = &pd->dp_usbpd;
> +	u32 buf = pd->vdo;
> +	int port = buf & 0x3;
> +
> +	status->low_pow_st     = (buf & BIT(2)) ? true : false;
> +	status->adaptor_dp_en  = (buf & BIT(3)) ? true : false;
> +	status->multi_func     = (buf & BIT(4)) ? true : false;
> +	status->usb_config_req = (buf & BIT(5)) ? true : false;
> +	status->exit_dp_mode   = (buf & BIT(6)) ? true : false;
> +	status->hpd_high       = (buf & BIT(7)) ? true : false;
> +	status->hpd_irq        = (buf & BIT(8)) ? true : false;
> +
> +	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
> +			status->low_pow_st, status->adaptor_dp_en,
> +			status->multi_func);
> +	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
> +			status->usb_config_req,
> +			status->exit_dp_mode, status->hpd_high);
> +	pr_debug("hpd_irq = %d\n", status->hpd_irq);
> +
> +	dp_usbpd_init_port(&status->port, port);
> +}
> +
> +u32 dp_usbpd_gen_config_pkt(struct dp_extcon_private *pd)
> +{
> +	u8 pin_cfg, pin;
> +	u32 config = 0;
> +	const u32 ufp_d_config = 0x2, dp_ver = 0x1;
> +
> +	if (pd->cap.receptacle_state)
> +		pin_cfg = pd->cap.ulink_pin_config;
> +	else
> +		pin_cfg = pd->cap.dlink_pin_config;
> +
> +	for (pin = DP_USBPD_PIN_A; pin < DP_USBPD_PIN_MAX; pin++) {
> +		if (pin_cfg & BIT(pin)) {
> +			if (pd->dp_usbpd.multi_func) {
> +				if (pin == DP_USBPD_PIN_D)
> +					break;
> +			} else {
> +				break;
> +			}
> +		}
> +	}
> +
> +	if (pin == DP_USBPD_PIN_MAX)
> +		pin = DP_USBPD_PIN_C;
> +
> +	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
> +
> +	config |= BIT(pin) << 8;
> +
> +	config |= (dp_ver << 2);
> +	config |= ufp_d_config;
> +
> +	pr_debug("config = 0x%x\n", config);
> +	return config;
> +}
> +
> +static int dp_extcon_connect(struct dp_usbpd *dp_usbpd, bool hpd)
> +{
> +	int rc = 0;
> +	struct dp_extcon_private *extcon;
> +
> +	if (!dp_usbpd) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	dp_usbpd->hpd_high = hpd;
> +	dp_usbpd->forced_disconnect = !hpd;
> +
> +	if (hpd)
> +		extcon->dp_cb->configure(extcon->dev);
> +	else
> +		extcon->dp_cb->disconnect(extcon->dev);
> +
> +error:
> +	return rc;
> +}
> +
> +static int dp_extcon_get_lanes(struct dp_extcon_private *extcon_priv)
> +{
> +	union extcon_property_value property;
> +	u8 lanes;
> +
> +	if (!extcon_priv || !extcon_priv->extcon) {
> +		pr_err("Invalid input arguments\n");
> +		return 0;
> +	}
> +
> +	extcon_get_property(extcon_priv->extcon,
> +					EXTCON_DISP_DP,
> +					EXTCON_PROP_USB_SS,
> +					&property);
> +	lanes = ((property.intval) ? 2 : 4);
> +
> +	return lanes;
> +}
> +
> +
> +static void dp_extcon_event_work(struct work_struct *work)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +	int dp_state, ret;
> +	int lanes;
> +	union extcon_property_value property;
> +
> +	extcon_priv = container_of(work,
> +			struct dp_extcon_private, event_work);
> +
> +	if (!extcon_priv || !extcon_priv->extcon) {

The result of container_of can never be NULL.

> +		pr_err("Invalid extcon device handler\n");
> +		return;
> +	}
> +
> +	dp_state = extcon_get_state(extcon_priv->extcon,
> +						EXTCON_DISP_DP);
> +
> +	if (dp_state > 0) {
> +		ret = extcon_get_property(extcon_priv->extcon,
> +					EXTCON_DISP_DP,
> +					EXTCON_PROP_USB_TYPEC_POLARITY,
> +					&property);
> +		if (ret) {
> +			pr_err("Get Polarity property failed\n");
> +			return;
> +		}
> +		extcon_priv->dp_usbpd.orientation =
> +			((property.intval) ?
> +				ORIENTATION_CC2 : ORIENTATION_CC1);
> +
> +		lanes = dp_extcon_get_lanes(extcon_priv);
> +		if (!lanes)
> +			return;
> +		extcon_priv->dp_usbpd.multi_func =
> +					((lanes == 2) ? false : true);
> +
> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->configure)
> +			dp_extcon_connect(&extcon_priv->dp_usbpd, true);
> +	} else {
> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->disconnect)
> +			dp_extcon_connect(&extcon_priv->dp_usbpd, false);
> +	}
> +}
> +
> +static int dp_extcon_create_workqueue(struct dp_extcon_private *extcon_priv)
> +{
> +	extcon_priv->extcon_wq = create_singlethread_workqueue("drm_dp_extcon");
> +	if (IS_ERR_OR_NULL(extcon_priv->extcon_wq)) {
> +		pr_err("Error creating extcon wq\n");
> +		return -EPERM;
> +	}
> +
> +	INIT_WORK(&extcon_priv->event_work, dp_extcon_event_work);
> +
> +	return 0;
> +}
> +
> +static int dp_extcon_event_notify(struct notifier_block *nb,
> +				  unsigned long event, void *priv)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +
> +	extcon_priv = container_of(nb, struct dp_extcon_private,
> +						extcon_nb);
> +
> +	queue_work(extcon_priv->extcon_wq, &extcon_priv->event_work);
> +	return NOTIFY_DONE;
> +}
> +
> +int dp_extcon_register(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +	int ret = 0;
> +
> +	if (!dp_usbpd)
> +		return -EINVAL;
> +
> +	pr_err("Start++++");

Debug message snuck through.

> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	extcon_priv->extcon_nb.notifier_call = dp_extcon_event_notify;
> +	ret = devm_extcon_register_notifier(extcon_priv->dev, extcon_priv->extcon,
> +					    EXTCON_DISP_DP,
> +					    &extcon_priv->extcon_nb);
> +	if (ret) {
> +		dev_err(extcon_priv->dev,
> +			"register EXTCON_DISP_DP notifier err\n");

Prefer that you don't abbreviate err here.
> +		ret = -EINVAL;

You set ret, but you don't do anything with it - you continue on.

> +	}
> +
> +	ret = dp_extcon_create_workqueue(extcon_priv);
> +	if (ret) {
> +		pr_err("Failed to create workqueue\n");
> +		dp_extcon_unregister(dp_usbpd);
> +	}
> +
> +	pr_err("End----");

Also debug message.

> +	return ret;
> +}
> +
> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +
> +	if (!dp_usbpd) {
> +		pr_err("Invalid input\n");

Doesn't seem that the error message will do you much good here.

> +		return;
> +	}
> +
> +	pr_err("Start++++");
Debug log message

> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	devm_extcon_unregister_notifier(extcon_priv->dev, extcon_priv->extcon,
> +					    EXTCON_DISP_DP,
> +					    &extcon_priv->extcon_nb);
> +
> +	if (extcon_priv->extcon_wq)
> +		destroy_workqueue(extcon_priv->extcon_wq);
> +
> +	pr_err("End----");
Debug log message

> +	return;
> +}
> +
> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb)
> +{
> +	int rc = 0;
> +	struct dp_extcon_private *dp_extcon;
> +	struct dp_usbpd *dp_usbpd;
> +
> +	if (!cb) {
> +		pr_err("invalid cb data\n");

Log message isn't useful, just return ERR_PTR(-EINVAL);

> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	pr_err("%s: Start", __func__);

Debug message.

> +	dp_extcon = devm_kzalloc(dev, sizeof(*dp_extcon), GFP_KERNEL);
> +	if (!dp_extcon) {

return ERR_PTR(-ENOMEM);

> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	dp_extcon->extcon = extcon_get_edev_by_phandle(dev, 0);
> +	if (!dp_extcon->extcon) {
> +		pr_err("invalid extcon data\n");
> +		rc = -EINVAL;
> +		devm_kfree(dev, dp_extcon);

Just return ERR_PTR(-EINVAL);
> +		goto error;
> +        }
> +
> +	dp_extcon->dev = dev;
> +	dp_extcon->dp_cb = cb;
> +
> +	dp_extcon->dp_usbpd.connect = dp_extcon_connect;
> +	dp_usbpd = &dp_extcon->dp_usbpd;
> +
> +	pr_err("%s: end", __func__);
Debug message

> +	return dp_usbpd;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_extcon_put(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon;
> +
> +	if (!dp_usbpd)
> +		return;
> +
> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	devm_kfree(extcon->dev, extcon);

You don't need to do this for managed memory.  This whole function doesn't need
to exist.

> +
> +	pr_err("%s: end", __func__);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.h b/drivers/gpu/drm/msm/dp/dp_extcon.h
> new file mode 100644
> index 0000000..1f83a18
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.h
> @@ -0,0 +1,111 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please

> +#ifndef _DP_EXTCON_H_
> +#define _DP_EXTCON_H_
> +
> +//#include <linux/usb/usbpd.h>
> +
> +#include <linux/types.h>
> +#include <linux/device.h>
> +
> +/**
> + * enum dp_usbpd_port - usb/dp port type
> + * @DP_USBPD_PORT_NONE: port not configured
> + * @DP_USBPD_PORT_UFP_D: Upstream Facing Port - DisplayPort
> + * @DP_USBPD_PORT_DFP_D: Downstream Facing Port - DisplayPort
> + * @DP_USBPD_PORT_D_UFP_D: Both UFP & DFP - DisplayPort
> + */
> +
> +enum dp_usbpd_port {
> +	DP_USBPD_PORT_NONE,
> +	DP_USBPD_PORT_UFP_D,
> +	DP_USBPD_PORT_DFP_D,
> +	DP_USBPD_PORT_D_UFP_D,
> +};
> +
> +enum plug_orientation {
> +	ORIENTATION_NONE,
> +	ORIENTATION_CC1,
> +	ORIENTATION_CC2,
> +};
> +
> +/**
> + * struct dp_usbpd - DisplayPort status
> + *
> + * @port: port configured
> + * orientation: plug orientation configuration
> + * @low_pow_st: low power state
> + * @adaptor_dp_en: adaptor functionality enabled
> + * @multi_func: multi-function preferred
> + * @usb_config_req: request to switch to usb
> + * @exit_dp_mode: request exit from displayport mode
> + * @hpd_high: Hot Plug Detect signal is high.
> + * @hpd_irq: Change in the status since last message
> + * @alt_mode_cfg_done: bool to specify alt mode status
> + * @debug_en: bool to specify debug mode
> + * @connect: simulate disconnect or connect for debug mode
> + */
> +struct dp_usbpd {
> +	enum dp_usbpd_port port;
> +	enum plug_orientation orientation;
> +	bool low_pow_st;
> +	bool adaptor_dp_en;
> +	bool multi_func;
> +	bool usb_config_req;
> +	bool exit_dp_mode;
> +	bool hpd_high;
> +	bool hpd_irq;
> +	bool alt_mode_cfg_done;
> +	bool debug_en;
> +	bool forced_disconnect;
> +
> +	int (*connect)(struct dp_usbpd *dp_usbpd, bool hpd);
> +};
> +
> +/**
> + * struct dp_usbpd_cb - callback functions provided by the client
> + *
> + * @configure: called by usbpd module when PD communication has
> + * been completed and the usb peripheral has been configured on
> + * dp mode.
> + * @disconnect: notify the cable disconnect issued by usb.
> + * @attention: notify any attention message issued by usb.
> + */
> +struct dp_usbpd_cb {
> +	int (*configure)(struct device *dev);
> +	int (*disconnect)(struct device *dev);
> +	int (*attention)(struct device *dev);
> +};
> +
> +/**
> + * dp_extcon_get() - setup usbpd module
> + *
> + * @dev: device instance of the caller
> + * @cb: struct containing callback function pointers.
> + *
> + * This function allows the client to initialize the usbpd
> + * module. The module will communicate with usb driver and
> + * handles the power delivery (PD) communication with the
> + * sink/usb device. This module will notify the client using
> + * the callback functions about the connection and status.
> + */
> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb);
> +
> +void dp_extcon_put(struct dp_usbpd *pd);
> +
> +int dp_extcon_register(struct dp_usbpd *dp_usbpd);
> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd);
> +
> +#endif /* _DP_EXTCON_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_link.c b/drivers/gpu/drm/msm/dp/dp_link.c
> new file mode 100644
> index 0000000..5ab1efc
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_link.c
> @@ -0,0 +1,1549 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include "dp_link.h"
> +#include "dp_panel.h"
> +
> +enum dynamic_range {
> +	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
> +	DP_DYNAMIC_RANGE_RGB_CEA = 0x01,
> +	DP_DYNAMIC_RANGE_UNKNOWN = 0xFFFFFFFF,
> +};
> +
> +enum audio_sample_rate {
> +	AUDIO_SAMPLE_RATE_32_KHZ	= 0x00,
> +	AUDIO_SAMPLE_RATE_44_1_KHZ	= 0x01,
> +	AUDIO_SAMPLE_RATE_48_KHZ	= 0x02,
> +	AUDIO_SAMPLE_RATE_88_2_KHZ	= 0x03,
> +	AUDIO_SAMPLE_RATE_96_KHZ	= 0x04,
> +	AUDIO_SAMPLE_RATE_176_4_KHZ	= 0x05,
> +	AUDIO_SAMPLE_RATE_192_KHZ	= 0x06,
> +};
> +
> +enum audio_pattern_type {
> +	AUDIO_TEST_PATTERN_OPERATOR_DEFINED	= 0x00,
> +	AUDIO_TEST_PATTERN_SAWTOOTH		= 0x01,
> +};
> +
> +struct dp_link_request {
> +	u32 test_requested;
> +	u32 test_link_rate;
> +	u32 test_lane_count;
> +};
> +
> +struct dp_link_private {
> +	u32 prev_sink_count;
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_link dp_link;
> +
> +	struct dp_link_request request;
> +	u8 link_status[DP_LINK_STATUS_SIZE];
> +};
> +
> +static char *dp_link_get_audio_test_pattern(u32 pattern)
> +{
> +	switch (pattern) {
> +	case AUDIO_TEST_PATTERN_OPERATOR_DEFINED:
> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_OPERATOR_DEFINED);
> +	case AUDIO_TEST_PATTERN_SAWTOOTH:
> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_SAWTOOTH);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static char *dp_link_get_audio_sample_rate(u32 rate)
> +{
> +	switch (rate) {
> +	case AUDIO_SAMPLE_RATE_32_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_32_KHZ);
> +	case AUDIO_SAMPLE_RATE_44_1_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_44_1_KHZ);
> +	case AUDIO_SAMPLE_RATE_48_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_48_KHZ);
> +	case AUDIO_SAMPLE_RATE_88_2_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_88_2_KHZ);
> +	case AUDIO_SAMPLE_RATE_96_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_96_KHZ);
> +	case AUDIO_SAMPLE_RATE_176_4_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_176_4_KHZ);
> +	case AUDIO_SAMPLE_RATE_192_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_192_KHZ);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static int dp_link_get_period(struct dp_link_private *link, int const addr)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	u32 const param_len = 0x1;
> +	u32 const max_audio_period = 0xA;
> +
> +	/* TEST_AUDIO_PERIOD_CH_XX */
> +	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
> +		param_len) < param_len) {
> +		pr_err("failed to read test_audio_period (0x%x)\n", addr);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	data = bp;
> +
> +	/* Period - Bits 3:0 */
> +	data = data & 0xF;
> +	if ((int)data > max_audio_period) {
> +		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	ret = data;
> +exit:
> +	return ret;
> +}
> +
> +static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	struct dp_link_test_audio *req = &link->dp_link.test_audio;
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
> +	if (ret == -EINVAL)

You don't need the label for any of these.

> +		goto exit;
> +
> +	req->test_audio_period_ch_1 = ret;
> +	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_2 = ret;
> +	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
> +
> +	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_3 = ret;
> +	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_4 = ret;
> +	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_5 = ret;
> +	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_6 = ret;
> +	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_7 = ret;
> +	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_8 = ret;
> +	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
> +exit:
> +	return ret;

This isn't my area of expertise but I can't shake the feeling that this code
could be consolidated - like why are there individual members for
req->test_audio_period_ch_N and not an array. Like I said, not my area, just
feel like there is code that could be saved.

> +}
> +
> +static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	int rlen;
> +	int const param_len = 0x1;
> +	int const max_audio_pattern_type = 0x1;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
> +		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link audio mode data\n");
just return -EINVAL;

> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	/* Audio Pattern Type - Bits 7:0 */
> +	if ((int)data > max_audio_pattern_type) {
> +		pr_err("invalid audio pattern type = 0x%x\n", data);
> +		ret = -EINVAL;
just return -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_audio.test_audio_pattern_type = data;
> +	pr_debug("audio pattern type = %s\n",
> +			dp_link_get_audio_test_pattern(data));
> +exit:
> +	return ret;

return 0;

> +}
> +
> +static int dp_link_parse_audio_mode(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	int rlen;
> +	int const param_len = 0x1;
> +	int const max_audio_sampling_rate = 0x6;
> +	int const max_audio_channel_count = 0x8;
> +	int sampling_rate = 0x0;
> +	int channel_count = 0x0;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link audio mode data\n");
> +		ret = -EINVAL;

Same as above - you should almost never have a just a return after a label. Same
is true for much of this file.

> +		goto exit;
> +	}
> +	data = bp;
> +
> +	/* Sampling Rate - Bits 3:0 */
> +	sampling_rate = data & 0xF;
> +	if (sampling_rate > max_audio_sampling_rate) {
> +		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
> +				sampling_rate, max_audio_sampling_rate);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	/* Channel Count - Bits 7:4 */
> +	channel_count = ((data & 0xF0) >> 4) + 1;
> +	if (channel_count > max_audio_channel_count) {
> +		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
> +				channel_count, max_audio_channel_count);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
> +	link->dp_link.test_audio.test_audio_channel_count = channel_count;
> +	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
> +		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
> +exit:
> +	return ret;
> +}

<snip>

> +static void dp_link_send_test_response(struct dp_link *dp_link)
> +{
> +	struct dp_link_private *link = NULL;
> +	u32 const response_len = 0x1;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

It doesn't look to me like dp_link can be NULL here.

> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
> +			&dp_link->test_response, response_len);
> +}
> +
> +static int dp_link_psm_config(struct dp_link *dp_link,
> +			      struct drm_dp_link *link_info, bool enable)
> +{
> +	struct dp_link_private *link = NULL;
> +	int ret = 0;
> +
> +	if (!dp_link) {
> +		pr_err("invalid params\n");
> +		return -EINVAL;
> +	}
>
Same.  It seems that all of these function pointers have a verified valid
dp_link before calling.

> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	if (enable)
> +		ret = drm_dp_link_power_down(link->aux->drm_aux, link_info);
> +	else
> +		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
> +
> +	if (ret)
> +		pr_err("Failed to %s low power mode\n",
> +			(enable ? "enter" : "exit"));
> +	else
> +		dp_link->psm_enabled = enable;
> +
> +	return ret;
> +}

<snip>

> +static int dp_link_send_psm_request(struct dp_link *dp_link, bool req)
> +{
> +	struct dp_link_private *link;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	return 0;

This function looks like it doesn't do anything of value.

> +}
> +
> +static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp)
> +{
> +	u32 tbd;
> +
> +	/*
> +	 * Few simplistic rules and assumptions made here:
> +	 *    1. Test bit depth is bit depth per color component
> +	 *    2. Assume 3 color components
> +	 */
> +	switch (bpp) {
> +	case 18:
> +		tbd = DP_TEST_BIT_DEPTH_6;
> +		break;
> +	case 24:
> +		tbd = DP_TEST_BIT_DEPTH_8;
> +		break;
> +	case 30:
> +		tbd = DP_TEST_BIT_DEPTH_10;
> +		break;
> +	default:
> +		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
> +		break;
> +	}
> +
> +	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
> +		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
> +
> +	return tbd;
> +}
> +
> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_link_private *link;
> +	struct dp_link *dp_link;
> +
> +	if (!dev || !aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

Dev and aux both appear to be non NULL from the claler.

> +	link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
> +	if (!link) {
> +		rc = -EINVAL;

This should be -ENOMEM and you should just return ERR_PTR(-ENOMEM);

> +		goto error;
> +	}
> +
> +	link->dev   = dev;
> +	link->aux   = aux;
> +
> +	dp_link = &link->dp_link;
> +
> +	dp_link->process_request        = dp_link_process_request;
> +	dp_link->get_test_bits_depth    = dp_link_get_test_bits_depth;
> +	dp_link->get_colorimetry_config = dp_link_get_colorimetry_config;
> +	dp_link->adjust_levels          = dp_link_adjust_levels;
> +	dp_link->send_psm_request       = dp_link_send_psm_request;
> +	dp_link->send_test_response     = dp_link_send_test_response;
> +	dp_link->psm_config             = dp_link_psm_config;
> +	dp_link->send_edid_checksum     = dp_link_send_edid_checksum;
> +
> +	return dp_link;
> +error:
> +	return ERR_PTR(rc);

Label should not be needed.

> +}
> +
> +void dp_link_put(struct dp_link *dp_link)
> +{
> +	struct dp_link_private *link;
> +
> +	if (!dp_link)
> +		return;
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	devm_kfree(link->dev, link);

You don't need to delete devm_ managed memory.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_link.h b/drivers/gpu/drm/msm/dp/dp_link.h
> new file mode 100644
> index 0000000..6d6ef43
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_link.h
> @@ -0,0 +1,184 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_LINK_H_
> +#define _DP_LINK_H_
> +
> +#include "dp_aux.h"
> +
> +#define DS_PORT_STATUS_CHANGED 0x200
> +#define DP_TEST_BIT_DEPTH_UNKNOWN 0xFFFFFFFF
> +#define DP_LINK_ENUM_STR(x)		#x
> +
> +enum dp_link_voltage_level {
> +	DP_LINK_VOLTAGE_LEVEL_0	= 0,
> +	DP_LINK_VOLTAGE_LEVEL_1	= 1,
> +	DP_LINK_VOLTAGE_LEVEL_2	= 2,
> +	DP_LINK_VOLTAGE_MAX	= DP_LINK_VOLTAGE_LEVEL_2,

The last item in a enum will be the value of the previous item plus 1 - which is
really the only good reason to use a enum IMO.  You don't need to assign it
which is good because if you ever added anything to this list it would take two
lines of change and not just one.

> +};
> +
> +enum dp_link_preemaphasis_level {
> +	DP_LINK_PRE_EMPHASIS_LEVEL_0	= 0,
> +	DP_LINK_PRE_EMPHASIS_LEVEL_1	= 1,
> +	DP_LINK_PRE_EMPHASIS_LEVEL_2	= 2,
> +	DP_LINK_PRE_EMPHASIS_MAX	= DP_LINK_PRE_EMPHASIS_LEVEL_2,
> +};

Same.

> +
> +struct dp_link_sink_count {
> +	u32 count;
> +	bool cp_ready;
> +};
> +
> +struct dp_link_test_video {
> +	u32 test_video_pattern;
> +	u32 test_bit_depth;
> +	u32 test_dyn_range;
> +	u32 test_h_total;
> +	u32 test_v_total;
> +	u32 test_h_start;
> +	u32 test_v_start;
> +	u32 test_hsync_pol;
> +	u32 test_hsync_width;
> +	u32 test_vsync_pol;
> +	u32 test_vsync_width;
> +	u32 test_h_width;
> +	u32 test_v_height;
> +	u32 test_rr_d;
> +	u32 test_rr_n;
> +};
> +
> +struct dp_link_test_audio {
> +	u32 test_audio_sampling_rate;
> +	u32 test_audio_channel_count;
> +	u32 test_audio_pattern_type;
> +	u32 test_audio_period_ch_1;
> +	u32 test_audio_period_ch_2;
> +	u32 test_audio_period_ch_3;
> +	u32 test_audio_period_ch_4;
> +	u32 test_audio_period_ch_5;
> +	u32 test_audio_period_ch_6;
> +	u32 test_audio_period_ch_7;
> +	u32 test_audio_period_ch_8;
> +};
> +
> +struct dp_link_phy_params {
> +	u32 phy_test_pattern_sel;
> +	u8 v_level;
> +	u8 p_level;
> +};
> +
> +struct dp_link_params {
> +	u32 lane_count;
> +	u32 bw_code;
> +};
> +
> +struct dp_link {
> +	u32 sink_request;
> +	u32 test_response;
> +	bool psm_enabled;
> +
> +	struct dp_link_sink_count sink_count;
> +	struct dp_link_test_video test_video;
> +	struct dp_link_test_audio test_audio;
> +	struct dp_link_phy_params phy_params;
> +	struct dp_link_params link_params;
> +
> +	u32 (*get_test_bits_depth)(struct dp_link *dp_link, u32 bpp);
> +	int (*process_request)(struct dp_link *dp_link);
> +	int (*get_colorimetry_config)(struct dp_link *dp_link);
> +	int (*adjust_levels)(struct dp_link *dp_link, u8 *link_status);
> +	int (*send_psm_request)(struct dp_link *dp_link, bool req);
> +	void (*send_test_response)(struct dp_link *dp_link);
> +	int (*psm_config)(struct dp_link *dp_link,
> +		struct drm_dp_link *link_info, bool enable);
> +	void (*send_edid_checksum)(struct dp_link *dp_link, u8 checksum);
> +};
> +
> +static inline char *dp_link_get_phy_test_pattern(u32 phy_test_pattern_sel)
> +{
> +	switch (phy_test_pattern_sel) {
> +	case DP_TEST_PHY_PATTERN_NONE:
> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_NONE);
> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING);
> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT);
> +	case DP_TEST_PHY_PATTERN_PRBS7:
> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_PRBS7);
> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN);
> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN);
> +	default:
> +		return "unknown";
> +	}
> +}

This is a bit beefy for a inline for my tastes.

> +
> +/**
> + * mdss_dp_test_bit_depth_to_bpp() - convert test bit depth to bpp
> + * @tbd: test bit depth
> + *
> + * Returns the bits per pixel (bpp) to be used corresponding to the
> + * git bit depth value. This function assumes that bit depth has
> + * already been validated.
> + */
> +static inline u32 dp_link_bit_depth_to_bpp(u32 tbd)
> +{
> +	u32 bpp;
> +
> +	/*
> +	 * Few simplistic rules and assumptions made here:
> +	 *    1. Bit depth is per color component
> +	 *    2. If bit depth is unknown return 0
> +	 *    3. Assume 3 color components
> +	 */
> +	switch (tbd) {
> +	case DP_TEST_BIT_DEPTH_6:
> +		bpp = 18;
> +		break;
> +	case DP_TEST_BIT_DEPTH_8:
> +		bpp = 24;
> +		break;
> +	case DP_TEST_BIT_DEPTH_10:
> +		bpp = 30;
> +		break;
> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
> +	default:
> +		bpp = 0;
> +	}
> +
> +	return bpp;
> +}
> +
> +/**
> + * dp_link_get() - get the functionalities of dp test module
> + *
> + *
> + * return: a pointer to dp_link struct
> + */
> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux);
> +
> +/**
> + * dp_link_put() - releases the dp test module's resources
> + *
> + * @dp_link: an instance of dp_link module
> + *
> + */
> +void dp_link_put(struct dp_link *dp_link);
> +
> +#endif /* _DP_LINK_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.c b/drivers/gpu/drm/msm/dp/dp_panel.c
> new file mode 100644
> index 0000000..e497b44
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_panel.c
> @@ -0,0 +1,624 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.  

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include "dp_panel.h"
> +
> +#include <drm/drm_connector.h>
> +#include <drm/drm_edid.h>
> +
> +#define DP_PANEL_DEFAULT_BPP 24
> +#define DP_MAX_DS_PORT_COUNT 1
> +
> +enum {
> +	DP_LINK_RATE_MULTIPLIER = 27000000,
> +};

An enum of 1 is never useful.

> +
> +struct dp_panel_private {
> +	struct device *dev;
> +	struct dp_panel dp_panel;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_catalog_panel *catalog;
> +	bool panel_on;
> +	bool aux_cfg_update_done;
> +};
> +
> +static const struct dp_panel_info fail_safe = {
> +	.h_active = 640,
> +	.v_active = 480,
> +	.h_back_porch = 48,
> +	.h_front_porch = 16,
> +	.h_sync_width = 96,
> +	.h_active_low = 0,
> +	.v_back_porch = 33,
> +	.v_front_porch = 10,
> +	.v_sync_width = 2,
> +	.v_active_low = 0,
> +	.h_skew = 0,
> +	.refresh_rate = 60,
> +	.pixel_clk_khz = 25200,
> +	.bpp = 24,
> +};
> +
> +static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
> +{
> +	int rlen, rc = 0;
> +	struct dp_panel_private *panel;
> +	struct drm_dp_link *link_info;
> +	u8 *dpcd, major = 0, minor = 0;
> +	u32 dfp_count = 0;
> +	unsigned long caps = DP_LINK_CAP_ENHANCED_FRAMING;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
>
It appears that dp_panel will always be valid at every call point.

> +	dpcd = dp_panel->dpcd;
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	link_info = &dp_panel->link_info;
> +
> +	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DPCD_REV,
> +		dpcd, (DP_RECEIVER_CAP_SIZE + 1));
> +	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
> +		pr_err("dpcd read failed, rlen=%d\n", rlen);

Just return -ENVAL here and everywhere else end: is used.

> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	link_info->revision = dp_panel->dpcd[DP_DPCD_REV];
> +
> +	major = (link_info->revision >> 4) & 0x0f;
> +	minor = link_info->revision & 0x0f;
> +	pr_debug("version: %d.%d\n", major, minor);
> +
> +	link_info->rate =
> +		drm_dp_bw_code_to_link_rate(dp_panel->dpcd[DP_MAX_LINK_RATE]);
> +	pr_debug("link_rate=%d\n", link_info->rate);
> +
> +	link_info->num_lanes = dp_panel->dpcd[DP_MAX_LANE_COUNT] &
> +				DP_MAX_LANE_COUNT_MASK;
> +
> +	pr_debug("lane_count=%d\n", link_info->num_lanes);
> +
> +	if (drm_dp_enhanced_frame_cap(dpcd))
> +		link_info->capabilities |= caps;
> +
> +	dfp_count = dpcd[DP_DOWN_STREAM_PORT_COUNT] &
> +						DP_DOWN_STREAM_PORT_COUNT;
> +
> +	if ((dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)
> +		&& (dpcd[DP_DPCD_REV] > 0x10)) {
> +		rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
> +			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
> +			DP_MAX_DOWNSTREAM_PORTS);
> +		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
> +			pr_err("ds port status failed, rlen=%d\n", rlen);
> +			rc = -EINVAL;
> +			goto end;
> +		}
> +	}
> +
> +	if (dfp_count > DP_MAX_DS_PORT_COUNT)
> +		pr_debug("DS port count %d greater that max (%d) supported\n",
> +			dfp_count, DP_MAX_DS_PORT_COUNT);
> +
> +end:
> +	return rc;
> +}
> +
> +static int dp_panel_set_default_link_params(struct dp_panel *dp_panel)
> +{
> +	struct drm_dp_link *link_info;
> +	const int default_bw_code = 162000;
> +	const int default_num_lanes = 1;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}

dp_panel will always be valid.

> +	link_info = &dp_panel->link_info;
> +	link_info->rate = default_bw_code;
> +	link_info->num_lanes = default_num_lanes;

Instead of usint const variables just set the variables directly.

> +	pr_debug("link_rate=%d num_lanes=%d\n",
> +		link_info->rate, link_info->num_lanes);
> +	return 0;

It doesn't look like a return value is needed here.

And maybe this function isn't needed at all?  This could all happen inline where
this function is called.

> +}
> +
> +static int dp_panel_read_edid(struct dp_panel *dp_panel,
> +	struct drm_connector *connector)
> +{
> +	int retry_cnt = 0;
> +	const int max_retry = 10;
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}

dp_panel will always be valid.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	do {
> +		kfree(dp_panel->edid);
> +		dp_panel->edid = drm_get_edid(connector,
> +					      &panel->aux->drm_aux->ddc);
> +		if (!dp_panel->edid) {
> +			pr_err("EDID read failed\n");

You don't need an error here because the error prints an error on your behalf
and you certainly don't want to print 10 errors without more details about what
the failure actually was.

> +			retry_cnt++;
> +			panel->aux->reconfig(panel->aux);
> +			panel->aux_cfg_update_done = true;
> +		} else {
> +			return 0;
> +		}
> +	} while (retry_cnt < max_retry);

My edid parsing days were over back when DVI was new and interesting but as
just a kernel developer this seems odd. I'll leave it to the experts.

But at least I would use a valid for() loop:

for(retry_cnt = 0; retry_cnt < 10; retry_cnt++) {
     ..
}


> +	return -EINVAL;
> +}
> +
> +static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
> +	struct drm_connector *connector)
> +{
> +	int rc = 0;
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel || !connector) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}

Looks like both of these are valid from the caller.


> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	rc = dp_panel_read_dpcd(dp_panel);
> +	if (rc || !is_link_rate_valid(drm_dp_link_rate_to_bw_code(
> +		dp_panel->link_info.rate)) || !is_lane_count_valid(
> +		dp_panel->link_info.num_lanes) ||
> +		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
> +		dp_panel->max_bw_code)) {
> +		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
> +			pr_err("DPCD read failed, return early\n");
> +			return rc;
> +		}
> +		pr_err("panel dpcd read failed/incorrect, set default params\n");
> +		dp_panel_set_default_link_params(dp_panel);
> +	}
> +
> +	rc = dp_panel_read_edid(dp_panel, connector);
> +	if (rc) {
> +		pr_err("panel edid read failed, set failsafe mode\n");
> +		return rc;
> +	}
> +
> +	if (panel->aux_cfg_update_done) {
> +		pr_debug("read DPCD with updated AUX config\n");
> +		dp_panel_read_dpcd(dp_panel);
> +		panel->aux_cfg_update_done = false;
> +	}
> +
> +	return 0;
> +}
> +
> +static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
> +{
> +	struct drm_dp_link *link_info;
> +	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
> +	u32 bpp = 0, data_rate_khz = 0;
> +
> +	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
> +
> +	link_info = &dp_panel->link_info;
> +	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
> +
> +	while (bpp > min_supported_bpp) {
> +		if (mode_pclk_khz * bpp <= data_rate_khz)
> +			break;
> +		bpp -= 6;
> +	}
> +
> +	return bpp;
> +}
> +
> +static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
> +{
> +	struct dp_panel_private *panel;
> +	u32 bpp = mode_edid_bpp;
> +
> +	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
> +		pr_err("invalid input\n");
> +		return 0;
> +	}
>
dp_panel and mode_edid_bpp are valid from the caller, not sure about
mode_pcklk_hz.  Might want to use a WARN_ON for that one.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (dp_panel->video_test)
> +		bpp = dp_link_bit_depth_to_bpp(
> +				panel->link->test_video.test_bit_depth);
> +	else
> +		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
> +				mode_pclk_khz);
> +
> +	return bpp;
> +}
> +
> +static void dp_panel_set_test_mode(struct dp_panel_private *panel,
> +		struct dp_display_mode *mode)
> +{
> +	struct dp_panel_info *pinfo = NULL;
> +	struct dp_link_test_video *test_info = NULL;
> +
> +	if (!panel) {
> +		pr_err("invalid params\n");
> +		return;
> +	}
>
Panel will always be valid.

> +	pinfo = &mode->timing;
> +	test_info = &panel->link->test_video;
> +
> +	pinfo->h_active = test_info->test_h_width;
> +	pinfo->h_sync_width = test_info->test_hsync_width;
> +	pinfo->h_back_porch = test_info->test_h_start -
> +		test_info->test_hsync_width;
> +	pinfo->h_front_porch = test_info->test_h_total -
> +		(test_info->test_h_start + test_info->test_h_width);
> +
> +	pinfo->v_active = test_info->test_v_height;
> +	pinfo->v_sync_width = test_info->test_vsync_width;
> +	pinfo->v_back_porch = test_info->test_v_start -
> +		test_info->test_vsync_width;
> +	pinfo->v_front_porch = test_info->test_v_total -
> +		(test_info->test_v_start + test_info->test_v_height);
> +
> +	pinfo->bpp = dp_link_bit_depth_to_bpp(test_info->test_bit_depth);
> +	pinfo->h_active_low = test_info->test_hsync_pol;
> +	pinfo->v_active_low = test_info->test_vsync_pol;
> +
> +	pinfo->refresh_rate = test_info->test_rr_n;
> +	pinfo->pixel_clk_khz = test_info->test_h_total *
> +		test_info->test_v_total * pinfo->refresh_rate;
> +
> +	if (test_info->test_rr_d == 0)
> +		pinfo->pixel_clk_khz /= 1000;
> +	else
> +		pinfo->pixel_clk_khz /= 1001;
> +
> +	if (test_info->test_h_width == 640)
> +		pinfo->pixel_clk_khz = 25170;
> +}
> +
> +static int dp_panel_update_modes(struct drm_connector *connector,
> +	struct edid *edid)
> +{
> +	int rc = 0;
> +
> +	pr_debug("%s +", __func__);
> +	if (edid) {
> +		drm_connector_update_edid_property(connector,
> +			edid);
> +		rc = drm_add_edid_modes(connector, edid);
> +		pr_debug("%s -", __func__);
> +		return rc;
> +	}
> +
> +	drm_connector_update_edid_property(connector, NULL);
> +	pr_debug("%s null edid -", __func__);
> +	return rc;
> +}
> +
> +static int dp_panel_get_modes(struct dp_panel *dp_panel,
> +	struct drm_connector *connector, struct dp_display_mode *mode)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
>
panel should always be valid.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (dp_panel->video_test) {
> +		dp_panel_set_test_mode(panel, mode);
> +		return 1;

What is the valid return of this function? Is it supposed to be boolean?

> +	} else if (dp_panel->edid) {
> +	  return dp_panel_update_modes(connector, dp_panel->edid);

Indentation is suspect here.

> +	}
> +
> +	/* fail-safe mode */
> +	memcpy(&mode->timing, &fail_safe,
> +		sizeof(fail_safe));
> +	return 1;
> +}
> +
> +static u8 dp_panel_get_edid_checksum(struct edid *edid)
> +{
> +	struct edid *last_block = NULL;
> +	u8 *raw_edid = NULL;
> +
> +	if (!edid) {
> +		pr_err("invalid edid input\n");
You don't need a log message here.  Maybe a WARN_ON.

> +		return 0;
> +	}
> +
> +	raw_edid = (u8 *)edid;
> +	raw_edid += (edid->extensions * EDID_LENGTH);
> +	last_block = (struct edid *)raw_edid;
> +
> +	if (last_block)
> +		return last_block->checksum;
> +
> +	pr_err("Invalid block, no checksum\n");
> +	return 0;
> +}
> +
> +static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
>
Panel can't be NULL here.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
> +		u8 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
> +
> +		panel->link->send_edid_checksum(panel->link, checksum);
> +		panel->link->send_test_response(panel->link);
> +	}
> +}
> +
> +static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
> +{
> +	u32 hsync_start_x, hsync_end_x;
> +	struct dp_catalog_panel *catalog;
> +	struct dp_panel_private *panel;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return;
> +	}

This likely can't be NULL.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	catalog = panel->catalog;
> +	pinfo = &panel->dp_panel.pinfo;
> +
> +	if (!panel->panel_on) {
> +		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
> +		return;
> +	}
> +
> +	if (!enable) {
> +		panel->catalog->tpg_config(catalog, false);
> +		return;
> +	}
> +
> +	/* TPG config */
> +	catalog->hsync_period = pinfo->h_sync_width + pinfo->h_back_porch +
> +			pinfo->h_active + pinfo->h_front_porch;
> +	catalog->vsync_period = pinfo->v_sync_width + pinfo->v_back_porch +
> +			pinfo->v_active + pinfo->v_front_porch;
> +
> +	catalog->display_v_start = ((pinfo->v_sync_width +
> +			pinfo->v_back_porch) * catalog->hsync_period);
> +	catalog->display_v_end = ((catalog->vsync_period -
> +			pinfo->v_front_porch) * catalog->hsync_period) - 1;
> +
> +	catalog->display_v_start += pinfo->h_sync_width + pinfo->h_back_porch;
> +	catalog->display_v_end -= pinfo->h_front_porch;
> +
> +	hsync_start_x = pinfo->h_back_porch + pinfo->h_sync_width;
> +	hsync_end_x = catalog->hsync_period - pinfo->h_front_porch - 1;
> +
> +	catalog->v_sync_width = pinfo->v_sync_width;
> +
> +	catalog->hsync_ctl = (catalog->hsync_period << 16) |
> +			pinfo->h_sync_width;
> +	catalog->display_hctl = (hsync_end_x << 16) | hsync_start_x;
> +
> +	pr_err("%s: calling catalog tpg_config\n", __func__);
> +	panel->catalog->tpg_config(catalog, true);
> +}
> +
> +static int dp_panel_timing_cfg(struct dp_panel *dp_panel)
> +{
> +	int rc = 0;
> +	u32 data, total_ver, total_hor;
> +	struct dp_catalog_panel *catalog;
> +	struct dp_panel_private *panel;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
>
This likely can't be NULL.

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	catalog = panel->catalog;
> +	pinfo = &panel->dp_panel.pinfo;
> +
> +	pr_debug("width=%d hporch= %d %d %d\n",
> +		pinfo->h_active, pinfo->h_back_porch,
> +		pinfo->h_front_porch, pinfo->h_sync_width);
> +
> +	pr_debug("height=%d vporch= %d %d %d\n",
> +		pinfo->v_active, pinfo->v_back_porch,
> +		pinfo->v_front_porch, pinfo->v_sync_width);
> +
> +	total_hor = pinfo->h_active + pinfo->h_back_porch +
> +		pinfo->h_front_porch + pinfo->h_sync_width;
> +
> +	total_ver = pinfo->v_active + pinfo->v_back_porch +
> +			pinfo->v_front_porch + pinfo->v_sync_width;
> +
> +	data = total_ver;
> +	data <<= 16;
> +	data |= total_hor;
> +
> +	catalog->total = data;
> +
> +	data = (pinfo->v_back_porch + pinfo->v_sync_width);
> +	data <<= 16;
> +	data |= (pinfo->h_back_porch + pinfo->h_sync_width);
> +
> +	catalog->sync_start = data;
> +
> +	data = pinfo->v_sync_width;
> +	data <<= 16;
> +	data |= (pinfo->v_active_low << 31);
> +	data |= pinfo->h_sync_width;
> +	data |= (pinfo->h_active_low << 15);
> +
> +	catalog->width_blanking = data;
> +
> +	data = pinfo->v_active;
> +	data <<= 16;
> +	data |= pinfo->h_active;
> +
> +	catalog->dp_active = data;
> +
> +	panel->catalog->timing_cfg(catalog);
> +	panel->panel_on = true;
> +end:
> +	return rc;
> +}
> +
> +static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
> +{
> +	int rc = 0;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
>
dp_panel can't be NULL.

> +	pinfo = &dp_panel->pinfo;
> +
> +	/*
> +	 * print resolution info as this is a result
> +	 * of user initiated action of cable connection
> +	 */
> +	pr_info("SET NEW RESOLUTION:\n");
> +	pr_info("%dx%d@%dfps\n", pinfo->h_active,
> +		pinfo->v_active, pinfo->refresh_rate);
> +	pr_info("h_porches(back|front|width) = (%d|%d|%d)\n",
> +			pinfo->h_back_porch,
> +			pinfo->h_front_porch,
> +			pinfo->h_sync_width);
> +	pr_info("v_porches(back|front|width) = (%d|%d|%d)\n",
> +			pinfo->v_back_porch,
> +			pinfo->v_front_porch,
> +			pinfo->v_sync_width);
> +	pr_info("pixel clock (KHz)=(%d)\n", pinfo->pixel_clk_khz);
> +	pr_info("bpp = %d\n", pinfo->bpp);
> +	pr_info("active low (h|v)=(%d|%d)\n", pinfo->h_active_low,
> +		pinfo->v_active_low);
> +
> +	pinfo->bpp = max_t(u32, 18, min_t(u32, pinfo->bpp, 30));
> +	pr_info("updated bpp = %d\n", pinfo->bpp);
> +end:
> +	return rc;

It doesn't seem like this function should return anything.

> +}
> +
> +static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
> +{
> +	const u32 encoding_factx10 = 8;
> +	u32 min_link_rate_khz = 0, lane_cnt;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		goto end;
> +	}

dp_panel_can't be NULL.

> +	lane_cnt = dp_panel->link_info.num_lanes;
> +	pinfo = &dp_panel->pinfo;
> +
> +	/* num_lanes * lane_count * 8 >= pclk * bpp * 10 */
> +	min_link_rate_khz = pinfo->pixel_clk_khz /
> +				(lane_cnt * encoding_factx10);
> +	min_link_rate_khz *= pinfo->bpp;
> +
> +	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
> +		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
> +		pinfo->bpp);
> +end:
> +	return min_link_rate_khz;
> +}
> +
> +struct dp_panel *dp_panel_get(struct dp_panel_in *in)
> +{
> +	int rc = 0;
> +	struct dp_panel_private *panel;
> +	struct dp_panel *dp_panel;
> +
> +	if (!in->dev || !in->catalog || !in->aux || !in->link) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

It looks like none of these are likely to be NULL;
>
> +	panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
> +	if (!panel) {

return ERR_PTR(-ENOMEM);

> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	panel->dev = in->dev;
> +	panel->aux = in->aux;
> +	panel->catalog = in->catalog;
> +	panel->link = in->link;
> +
> +	dp_panel = &panel->dp_panel;
> +	dp_panel->max_bw_code = DP_LINK_BW_8_1;
> +	panel->aux_cfg_update_done = false;
> +
> +	dp_panel->init_info = dp_panel_init_panel_info;
> +	dp_panel->timing_cfg = dp_panel_timing_cfg;
> +	dp_panel->read_sink_caps = dp_panel_read_sink_caps;
> +	dp_panel->get_min_req_link_rate = dp_panel_get_min_req_link_rate;
> +	dp_panel->get_mode_bpp = dp_panel_get_mode_bpp;
> +	dp_panel->get_modes = dp_panel_get_modes;
> +	dp_panel->handle_sink_request = dp_panel_handle_sink_request;
> +	dp_panel->tpg_config = dp_panel_tpg_config;
> +
> +	return dp_panel;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_panel_put(struct dp_panel *dp_panel)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel)
> +		return;
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	kfree(dp_panel->edid);
> +	dp_panel->edid = NULL;
> +	devm_kfree(panel->dev, panel);

You don't need to do this for devm managed memory.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.h b/drivers/gpu/drm/msm/dp/dp_panel.h
> new file mode 100644
> index 0000000..bf802df
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_panel.h
> @@ -0,0 +1,121 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +#ifndef _DP_PANEL_H_
> +#define _DP_PANEL_H_
> +
> +#include <drm/msm_drm.h>
> +
> +#include "dp_aux.h"
> +#include "dp_link.h"
> +#include "dp_extcon.h"
> +
> +struct edid;
> +
> +enum dp_lane_count {
> +	DP_LANE_COUNT_1	= 1,
> +	DP_LANE_COUNT_2	= 2,
> +	DP_LANE_COUNT_4	= 4,
> +};
> +
> +#define DP_MAX_DOWNSTREAM_PORTS 0x10
> +
> +struct dp_panel_info {
> +	u32 h_active;
> +	u32 v_active;
> +	u32 h_back_porch;
> +	u32 h_front_porch;
> +	u32 h_sync_width;
> +	u32 h_active_low;
> +	u32 v_back_porch;
> +	u32 v_front_porch;
> +	u32 v_sync_width;
> +	u32 v_active_low;
> +	u32 h_skew;
> +	u32 refresh_rate;
> +	u32 pixel_clk_khz;
> +	u32 bpp;
> +};
> +
> +struct dp_display_mode {
> +	struct dp_panel_info timing;
> +	u32 capabilities;
> +};
> +
> +struct dp_panel_in {
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_catalog_panel *catalog;
> +};
> +
> +struct dp_panel {
> +	/* dpcd raw data */
> +	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];
> +	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
> +
> +	struct drm_dp_link link_info;
> +	struct edid *edid;
> +	struct drm_connector *connector;
> +	struct dp_panel_info pinfo;
> +	bool video_test;
> +
> +	u32 vic;
> +	u32 max_pclk_khz;
> +
> +	u32 max_bw_code;
> +	int (*init_info)(struct dp_panel *dp_panel);
> +	int (*deinit)(struct dp_panel *dp_panel);
> +	int (*timing_cfg)(struct dp_panel *dp_panel);
> +	int (*read_sink_caps)(struct dp_panel *dp_panel,
> +		struct drm_connector *connector);
> +	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);
> +	u32 (*get_mode_bpp)(struct dp_panel *dp_panel, u32 mode_max_bpp,
> +			u32 mode_pclk_khz);
> +	int (*get_modes)(struct dp_panel *dp_panel,
> +		struct drm_connector *connector, struct dp_display_mode *mode);
> +	void (*handle_sink_request)(struct dp_panel *dp_panel);
> +	void (*tpg_config)(struct dp_panel *dp_panel, bool enable);
> +};
> +
> +/**
> + * is_link_rate_valid() - validates the link rate
> + * @lane_rate: link rate requested by the sink
> + *
> + * Returns true if the requested link rate is supported.
> + */
> +static inline bool is_link_rate_valid(u32 bw_code)
> +{
> +	return ((bw_code == DP_LINK_BW_1_62) ||
> +		(bw_code == DP_LINK_BW_2_7) ||
> +		(bw_code == DP_LINK_BW_5_4) ||
> +		(bw_code == DP_LINK_BW_8_1));
> +}
> +
> +/**
> + * dp_link_is_lane_count_valid() - validates the lane count
> + * @lane_count: lane count requested by the sink
> + *
> + * Returns true if the requested lane count is supported.
> + */
> +static inline bool is_lane_count_valid(u32 lane_count)
> +{
> +	return (lane_count == DP_LANE_COUNT_1) ||
> +		(lane_count == DP_LANE_COUNT_2) ||
> +		(lane_count == DP_LANE_COUNT_4);
> +}
> +
> +struct dp_panel *dp_panel_get(struct dp_panel_in *in);
> +void dp_panel_put(struct dp_panel *dp_panel);
> +#endif /* _DP_PANEL_H_ */

And I'll end here for for now.

Jordan

-- 
The Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Jordan Crouse]

On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> Add the needed displayPort files to enable DP driver
> on msm target.
> 
> "dp_display" module is the main module that calls into
> other sub-modules. "dp_drm" file represents the interface
> between DRM framework and DP driver.
> 
> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>  drivers/gpu/drm/msm/Makefile                |   15 +-
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 ++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 +++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 +++++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>  include/drm/drm_dp_helper.h                 |   19 +
>  30 files changed, 10887 insertions(+), 1 deletion(-)

This is my last go - the end is in sight.

<snip all the way to dp_parser.c>

> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.c b/drivers/gpu/drm/msm/dp/dp_parser.c
> new file mode 100644
> index 0000000..a366dc5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_parser.c
> @@ -0,0 +1,679 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please

> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/of_gpio.h>
> +
> +#include "dp_parser.h"
> +
> +static void dp_parser_unmap_io_resources(struct dp_parser *parser)
> +{
> +	struct dp_io *io = &parser->io;
> +
> +	msm_dss_iounmap(&io->dp_ahb);
> +	msm_dss_iounmap(&io->dp_aux);
> +	msm_dss_iounmap(&io->dp_link);
> +	msm_dss_iounmap(&io->dp_p0);
> +	msm_dss_iounmap(&io->phy_io);
> +	msm_dss_iounmap(&io->ln_tx0_io);
> +	msm_dss_iounmap(&io->ln_tx0_io);
> +	msm_dss_iounmap(&io->dp_pll_io);
> +	msm_dss_iounmap(&io->dp_cc_io);
> +	msm_dss_iounmap(&io->usb3_dp_com);
> +	msm_dss_iounmap(&io->qfprom_io);
> +}

If you use devm_ to ioremap as suggested previously, then this all ends up going
away.

> +static int dp_parser_ctrl_res(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	u32 index;
> +	struct platform_device *pdev = parser->pdev;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	struct dp_io *io = &parser->io;
> +
> +	rc = of_property_read_u32(of_node, "cell-index", &index);
> +	if (rc) {
> +		pr_err("cell-index not specified, rc=%d\n", rc);
> +		goto err;
> +	}

This value doesn't appear to be used anywhere in this code, so why are you
grabbing it?

> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_ahb, "dp_ahb");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");

msm_ioremap() helpfully gives an informative error message including the name of
the region that failed  so you don't need a redundant message here.

> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_aux, "dp_aux");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_link, "dp_link");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_p0, "dp_p0");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->phy_io, "dp_phy");
> +	if (rc) {
> +		pr_err("unable to remap dp PHY resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx0_io, "dp_ln_tx0");
> +	if (rc) {
> +		pr_err("unable to remap dp TX0 resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx1_io, "dp_ln_tx1");
> +	if (rc) {
> +		pr_err("unable to remap dp TX1 resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_pll_io, "dp_pll");
> +	if (rc) {
> +		pr_err("unable to remap DP PLL resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->usb3_dp_com, "usb3_dp_com");
> +	if (rc) {
> +		pr_err("unable to remap USB3 DP com resources\n");
> +		goto err;
> +	}
> +
> +	if (msm_dss_ioremap_byname(pdev, &io->dp_cc_io, "dp_mmss_cc")) {
> +		pr_err("unable to remap dp MMSS_CC resources\n");
> +		goto err;
> +	}
> +
> +	if (msm_dss_ioremap_byname(pdev, &io->qfprom_io, "qfprom_physical"))
> +		pr_warn("unable to remap dp qfprom resources\n");
> +

It doesn't look like you are using this in the current code so you can remove it
but if you did need to read fuses use nvram_cell instead.


> +	return 0;
> +err:
> +	dp_parser_unmap_io_resources(parser);
> +	return rc;
> +}

This whole function is crying out for an array:

struct {
	void __iomem **base;
	const char *name;
} regions[] = {
	{ &io->dp_aux.base, "dp_aux" },
	...
	{ &io->dp_cc_io.base, "dp_mms_cc" },
	{ NULL, NULL }
};

for(i = 0; regions[i].name; i++) {
      void __iomem *ptr = msm_ioremap(pdev, regions[i].name, NULL);
      if (IS_ERR(ptr))
        return -ENODEV;
     *(regions[i].base) = ptr;
}

return 0;


> +
> +static const char *dp_get_phy_aux_config_property(u32 cfg_type)
> +{
> +	switch (cfg_type) {
> +	case PHY_AUX_CFG0:
> +		return "qcom,aux-cfg0-settings";
> +	case PHY_AUX_CFG1:
> +		return "qcom,aux-cfg1-settings";
> +	case PHY_AUX_CFG2:
> +		return "qcom,aux-cfg2-settings";
> +	case PHY_AUX_CFG3:
> +		return "qcom,aux-cfg3-settings";
> +	case PHY_AUX_CFG4:
> +		return "qcom,aux-cfg4-settings";
> +	case PHY_AUX_CFG5:
> +		return "qcom,aux-cfg5-settings";
> +	case PHY_AUX_CFG6:
> +		return "qcom,aux-cfg6-settings";
> +	case PHY_AUX_CFG7:
> +		return "qcom,aux-cfg7-settings";
> +	case PHY_AUX_CFG8:
> +		return "qcom,aux-cfg8-settings";
> +	case PHY_AUX_CFG9:
> +		return "qcom,aux-cfg9-settings";
> +	default:
> +		return "unknown";
> +	}
> +}

Since CFG0 is 0 and CFG1 is and so on instead of calling
a function you can just construct the string inline when you need it....

> +static void dp_parser_phy_aux_cfg_reset(struct dp_parser *parser)
> +{
> +	int i = 0;
> +
> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
> +		parser->aux_cfg[i] = (const struct dp_aux_cfg){ 0 };
> +}
> +
> +static int dp_parser_aux(struct dp_parser *parser)
> +{
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	int len = 0, i = 0, j = 0, config_count = 0;
> +	const char *data;
> +	int const minimum_config_count = 1;
> +
> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
> +		const char *property = dp_get_phy_aux_config_property(i);

Here, instead of this, do

char property[24];
snprintf(property, sizeof(property), "qcom,aux-cfg%d-settings", i);

> +		data = of_get_property(of_node, property, &len);
> +		if (!data) {
> +			pr_err("Unable to read %s\n", property);
> +			goto error;
> +		}
> +
> +		config_count = len - 1;
> +		if ((config_count < minimum_config_count) ||
> +			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {
> +			pr_err("Invalid config count (%d) configs for %s\n",
> +					config_count, property);
> +			goto error;
> +		}
> +
> +		parser->aux_cfg[i].offset = data[0];
> +		parser->aux_cfg[i].cfg_cnt = config_count;
> +		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
> +				property,
> +				parser->aux_cfg[i].offset,
> +				parser->aux_cfg[i].cfg_cnt);
> +		for (j = 1; j < len; j++) {
> +			parser->aux_cfg[i].lut[j - 1] = data[j];
> +			pr_debug("%s lut[%d]=0x%x\n",
> +					property,
> +					i,
> +					parser->aux_cfg[i].lut[j - 1]);
> +		}

qcom,aux-cfgN-settings appears to be an array.  Seems like it would be easier
just to use of_property_read_u32_array()?  Seems like it would save yourself a
bit of work.

> +	}
> +		return 0;
> +
> +error:
> +	dp_parser_phy_aux_cfg_reset(parser);
> +	return -EINVAL;
> +}
> +
> +static int dp_parser_misc(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +
> +	rc = of_property_read_u32(of_node,
> +		"qcom,max-pclk-frequency-khz", &parser->max_pclk_khz);
> +	if (rc)
> +		parser->max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;

On error, of_property_read_u32 and friends will not touch the passed in pointer,
so you can safely set the pointer to a default and then not worry about checking
the value of the function - so this can just turn into:

	parser->max_pclk_hz = DP_MAX_PIXEL_CLK_KHZ;
	of_property_read_u32(of_node, "qcom,max-pclk-frequency-khz",
	&parser->max_pclk_khz);

> +
> +	return 0;

This function doesn't need to return anything.  And technically, it doesn't need
to be a function, but the place where it gets called is entirely comprised of
functions so thats probably not a huge deal.

> +}
> +
> +static int dp_parser_pinctrl(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct dp_pinctrl *pinctrl = &parser->pinctrl;
> +
> +	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
> +
> +	if (IS_ERR_OR_NULL(pinctrl->pin)) {

It looks to me like pinctrl_get only returns ERR_PTR so you can just use
IS_ERR() for your check.

> +		rc = PTR_ERR(pinctrl->pin);
> +		pr_err("failed to get pinctrl, rc=%d\n", rc);

And you can just return PTR_ERR(pinctrl->pin) here

> +		goto error;
> +	}
> +
> +	pinctrl->state_active = pinctrl_lookup_state(pinctrl->pin,
> +					"mdss_dp_active");
> +	if (IS_ERR_OR_NULL(pinctrl->state_active)) {

Same.

> +		rc = PTR_ERR(pinctrl->state_active);
> +		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
> +		goto error;
> +	}
> +
> +	pinctrl->state_suspend = pinctrl_lookup_state(pinctrl->pin,
> +					"mdss_dp_sleep");
> +	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
Same
> +		rc = PTR_ERR(pinctrl->state_suspend);
> +		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
> +		goto error;
> +	}
> +error:
> +	return rc;

You don't need this label if you return as soon as you get the error.

> +}
> +
> +static int dp_parser_gpio(struct dp_parser *parser)
> +{
> +	int i = 0;
> +	struct device *dev = &parser->pdev->dev;
> +	struct device_node *of_node = dev->of_node;
> +	struct dss_module_power *mp = &parser->mp[DP_CORE_PM];
> +	static const char * const dp_gpios[] = {
> +		"qcom,aux-en-gpio",
> +		"qcom,aux-sel-gpio",
> +		"qcom,usbplug-cc-gpio",
> +	};
> +
> +	mp->gpio_config = devm_kzalloc(dev,
> +		sizeof(struct dss_gpio) * ARRAY_SIZE(dp_gpios), GFP_KERNEL);
> +	if (!mp->gpio_config)
> +		return -ENOMEM;
> +
> +	mp->num_gpio = ARRAY_SIZE(dp_gpios);
> +
> +	for (i = 0; i < ARRAY_SIZE(dp_gpios); i++) {
> +		mp->gpio_config[i].gpio = of_get_named_gpio(of_node,
> +			dp_gpios[i], 0);
> +
> +		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
> +			pr_err("%s gpio not specified\n", dp_gpios[i]);
> +			return -EINVAL;
> +		}
> +
> +		strlcpy(mp->gpio_config[i].gpio_name, dp_gpios[i],
> +			sizeof(mp->gpio_config[i].gpio_name));
> +
> +		mp->gpio_config[i].value = 0;
> +	}
> +
> +	return 0;
> +}
> +
> +static const char *dp_parser_supply_node_name(enum dp_pm_type module)
> +{
> +	switch (module) {
> +	case DP_CORE_PM:	return "qcom,core-supply-entries";
> +	case DP_CTRL_PM:	return "qcom,ctrl-supply-entries";
> +	case DP_PHY_PM:		return "qcom,phy-supply-entries";
> +	default:		return "???";

This isn't possible.  At the very least return NULL and give you self a chance
to detect the error - otherwise you'll be returning odd error messages with ????
in it that would be harder to debug.

> +	}
> +}
> +
> +static int dp_parser_get_vreg(struct dp_parser *parser,
> +		enum dp_pm_type module)
> +{
> +	int i = 0, rc = 0;
> +	u32 tmp = 0;
> +	const char *pm_supply_name = NULL;
> +	struct device_node *supply_node = NULL;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	struct device_node *supply_root_node = NULL;
> +	struct dss_module_power *mp = &parser->mp[module];
> +
> +	mp->num_vreg = 0;
> +	pm_supply_name = dp_parser_supply_node_name(module);
> +	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
> +	if (!supply_root_node) {
> +		pr_err("no supply entry present: %s\n", pm_supply_name);
> +		goto novreg;
> +	}
> +
> +	mp->num_vreg = of_get_available_child_count(supply_root_node);
> +
> +	if (mp->num_vreg == 0) {
> +		pr_debug("no vreg\n");
> +		goto novreg;
> +	} else {
> +		pr_debug("vreg found. count=%d\n", mp->num_vreg);
> +	}
> +
> +	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
> +		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
> +	if (!mp->vreg_config) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	for_each_child_of_node(supply_root_node, supply_node) {
> +		const char *st = NULL;
> +		/* vreg-name */
> +		rc = of_property_read_string(supply_node,
> +			"qcom,supply-name", &st);
> +		if (rc) {
> +			pr_err("error reading name. rc=%d\n",
> +				 rc);
> +			goto error;
> +		}
> +		snprintf(mp->vreg_config[i].vreg_name,
> +			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);

ARRAY_SIZE works for a string, but we prefer sizeof() in most cases. If you
are just copying a string, consider using strncpy() and friends.  It will be
faster than snprintf.

> +		/* vreg-min-voltage */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-min-voltage", &tmp);

As mentioned above, on error they don't touch the value of the pointer so you
don't need to use a temporary variable.

> +		if (rc) {
> +			pr_err("error reading min volt. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].min_voltage = tmp;
> +
> +		/* vreg-max-voltage */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-max-voltage", &tmp);
> +		if (rc) {
> +			pr_err("error reading max volt. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].max_voltage = tmp;
> +
> +		/* enable-load */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-enable-load", &tmp);
> +		if (rc) {
> +			pr_err("error reading enable load. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].enable_load = tmp;
> +
> +		/* disable-load */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-disable-load", &tmp);
> +		if (rc) {
> +			pr_err("error reading disable load. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].disable_load = tmp;
> +
> +		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
> +			mp->vreg_config[i].vreg_name,
> +			mp->vreg_config[i].min_voltage,
> +			mp->vreg_config[i].max_voltage,
> +			mp->vreg_config[i].enable_load,
> +			mp->vreg_config[i].disable_load
> +			);
> +		++i;
> +	}
> +
> +	return rc;
> +
> +error:
> +	if (mp->vreg_config) {

You don't need to check for NULL here.

> +		devm_kfree(&parser->pdev->dev, mp->vreg_config);
> +		mp->vreg_config = NULL;
> +	}
> +novreg:
> +	mp->num_vreg = 0;
> +
> +	return rc;
> +}
> +
> +static void dp_parser_put_vreg_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("invalid input\n");

This error message isn't useful when you are taking down the device - just
quietly skip.

> +		return;
> +	}
> +
> +	if (mp->vreg_config) {
> +		devm_kfree(dev, mp->vreg_config);

You don't need to kfree managed memory.

> +		mp->vreg_config = NULL;
> +	}
> +	mp->num_vreg = 0;
> +}
> +
> +static int dp_parser_regulator(struct dp_parser *parser)
> +{
> +	int i, rc = 0;
> +	struct platform_device *pdev = parser->pdev;
> +
> +	/* Parse the regulator information */
> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
> +		rc = dp_parser_get_vreg(parser, i);
> +		if (rc) {
> +			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
> +				dp_parser_pm_name(i), rc);

dp_parser_get_vreg() is very loud about errors - you don't need to pile on.

> +			i--;
> +			for (; i >= DP_CORE_PM; i--)
> +				dp_parser_put_vreg_data(&pdev->dev,
> +					&parser->mp[i]);
> +			break;
> +		}
> +	}
> +
> +	return rc;
> +}
> +
> +static bool dp_parser_check_prefix(const char *clk_prefix, const char *clk_name)
> +{
> +	return !!strnstr(clk_name, clk_prefix, strlen(clk_name));

This isn't saving you any lines of code - you can do the string compare
directly in the calling functions.

> +}
> +
> +static void dp_parser_put_clk_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("%s: invalid input\n", __func__);

You are taking down the device so you don't care if anything is invalid.

> +		return;
> +	}
> +
> +	if (mp->clk_config) {
> +		devm_kfree(dev, mp->clk_config);

You don't need to free managed device memory.

> +		mp->clk_config = NULL;
> +	}
> +
> +	mp->num_clk = 0;
> +}
> +
> +static void dp_parser_put_gpio_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("%s: invalid input\n", __func__);

As above.

> +		return;
> +	}
> +
> +	if (mp->gpio_config) {
> +		devm_kfree(dev, mp->gpio_config);

Also as above.

> +		mp->gpio_config = NULL;
> +	}
> +
> +	mp->num_gpio = 0;
> +}
> +
> +static int dp_parser_init_clk_data(struct dp_parser *parser)
> +{
> +	int num_clk = 0, i = 0, rc = 0;
> +	int core_clk_count = 0, ctrl_clk_count = 0;
> +	const char *core_clk = "core";
> +	const char *ctrl_clk = "ctrl";
> +	const char *clk_name;
> +	struct device *dev = &parser->pdev->dev;
> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> +
> +	num_clk = of_property_count_strings(dev->of_node, "clock-names");
> +	if (num_clk <= 0) {
> +		pr_err("no clocks are defined\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	for (i = 0; i < num_clk; i++) {
> +		of_property_read_string_index(dev->of_node,
> +				"clock-names", i, &clk_name);
> +
> +		if (dp_parser_check_prefix(core_clk, clk_name))
> +			core_clk_count++;

According to your bindings, 'core' or 'ctrl' will be the prefix for the clock,
so why are you using strnstr?  strncmp works just as well.

!strncmp("core", clk_name, 4)


> +
> +		if (dp_parser_check_prefix(ctrl_clk, clk_name))

if (!strncmp("ctrl", clk_name, 4)

> +			ctrl_clk_count++;
> +	}
> +
> +	/* Initialize the CORE power module */
> +	if (core_clk_count <= 0) {

core_clk_count clearly can't be less than zero.

> +		pr_err("no core clocks are defined\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	core_power->num_clk = core_clk_count;
> +	core_power->clk_config = devm_kzalloc(dev,
> +			sizeof(struct dss_clk) * core_power->num_clk,
> +			GFP_KERNEL);
> +	if (!core_power->clk_config) {
> +		rc = -EINVAL;

the return value should be -ENOMEM here.

> +		goto exit;
> +	}
> +
> +	/* Initialize the CTRL power module */
> +	if (ctrl_clk_count <= 0) {

Again, this clearly can't be less than zero.

> +		pr_err("no ctrl clocks are defined\n");
> +		rc = -EINVAL;
> +		goto ctrl_clock_error;
> +	}
> +
> +	ctrl_power->num_clk = ctrl_clk_count;
> +	ctrl_power->clk_config = devm_kzalloc(dev,
> +			sizeof(struct dss_clk) * ctrl_power->num_clk,
> +			GFP_KERNEL);
> +	if (!ctrl_power->clk_config) {
> +		ctrl_power->num_clk = 0;
> +		rc = -EINVAL;

And -ENOMEM again.

> +		goto ctrl_clock_error;
> +	}
> +
> +	return rc;
> +
> +ctrl_clock_error:
> +	dp_parser_put_clk_data(dev, core_power);
> +exit:
> +	return rc;

Don't use this label - just return the error code directly instead.

> +}
> +
> +static int dp_parser_clock(struct dp_parser *parser)
> +{
> +	int rc = 0, i = 0;
> +	int num_clk = 0;
> +	int core_clk_index = 0, ctrl_clk_index = 0;
> +	int core_clk_count = 0, ctrl_clk_count = 0;
> +	const char *clk_name;
> +	const char *core_clk = "core";
> +	const char *ctrl_clk = "ctrl";
> +	struct device *dev = &parser->pdev->dev;
> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> +
> +	core_power = &parser->mp[DP_CORE_PM];
> +	ctrl_power = &parser->mp[DP_CTRL_PM];
> +
> +	rc =  dp_parser_init_clk_data(parser);
> +	if (rc) {
> +		pr_err("failed to initialize power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	core_clk_count = core_power->num_clk;
> +	ctrl_clk_count = ctrl_power->num_clk;
> +
> +	num_clk = core_clk_count + ctrl_clk_count;
> +

According to your bindings, not every clock in your list is a core or a ctrl -
are those clocks ignored?

> +	for (i = 0; i < num_clk; i++) {
> +		of_property_read_string_index(dev->of_node, "clock-names",
> +				i, &clk_name);

This implies that a core_ or ctrl_ clock are first in the list.  Your bindings
do not specify an order.

> +
> +		if (dp_parser_check_prefix(core_clk, clk_name) &&

Again, you should use strncmp() here

> +				core_clk_index < core_clk_count) {

If you already went to the trouble of counting you can be pretty sure that
you won't overrun your array.

> +			struct dss_clk *clk =
> +				&core_power->clk_config[core_clk_index];
> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
> +			clk->type = DSS_CLK_AHB;
> +			core_clk_index++;
> +		} else if (dp_parser_check_prefix(ctrl_clk, clk_name) &&
> +			   ctrl_clk_index < ctrl_clk_count) {

You aren't going to overrun your array.

> +			struct dss_clk *clk =
> +				&ctrl_power->clk_config[ctrl_clk_index];
> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
> +			ctrl_clk_index++;
> +
> +			if (!strcmp(clk_name, "ctrl_link_clk") ||
> +			    !strcmp(clk_name, "ctrl_pixel_clk"))
> +				clk->type = DSS_CLK_PCLK;
> +			else
> +				clk->type = DSS_CLK_AHB;
> +		}
> +	}

There is a lot going on in these two functions but I feel they can be combined.
The number of clocks in each array shouldn't be a mystery - you can
pre-allocate or statically allocate the arrays.  That will save you from the
initial step of walking the list to allocate the memory.  Then you can have a
single walk of the list, checking the clock type and handle it accordingly.

> +
> +	pr_debug("clock parsing successful\n");
> +
> +exit:
> +	return rc;
> +}
> +
> +static int dp_parser_parse(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +
> +	if (!parser) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto err;
> +	}
>
parser can never be null here.


> +	rc = dp_parser_ctrl_res(parser);
> +	if (rc)
> +		goto err;

You can just return rc here and throughout without the label.
> +
> +	rc = dp_parser_aux(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_misc(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_clock(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_regulator(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_gpio(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_pinctrl(parser);
> +err:
> +	return rc;
> +}
> +
> +struct dp_parser *dp_parser_get(struct platform_device *pdev)
> +{
> +	struct dp_parser *parser;
> +
> +	parser = devm_kzalloc(&pdev->dev, sizeof(*parser), GFP_KERNEL);
> +	if (!parser)
> +		return ERR_PTR(-ENOMEM);
> +
> +	parser->parse = dp_parser_parse;
> +	parser->pdev = pdev;
> +
> +	return parser;
> +}
> +
> +void dp_parser_put(struct dp_parser *parser)
> +{
> +	int i = 0;
> +	struct dss_module_power *power = NULL;
> +
> +	if (!parser) {
> +		pr_err("invalid parser module\n");

If parser is null, you don't care.  Just quietly exit.

> +		return;
> +	}
> +
> +	power = parser->mp;
> +
> +	for (i = 0; i < DP_MAX_PM; i++) {
> +		dp_parser_put_clk_data(&parser->pdev->dev, &power[i]);
> +		dp_parser_put_vreg_data(&parser->pdev->dev, &power[i]);
> +		dp_parser_put_gpio_data(&parser->pdev->dev, &power[i]);
> +	}
> +
> +	devm_kfree(&parser->pdev->dev, parser);

You don't need to free managed device memory.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h b/drivers/gpu/drm/msm/dp/dp_parser.h
> new file mode 100644
> index 0000000..b39ea02
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_parser.h
> @@ -0,0 +1,205 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please

> +#ifndef _DP_PARSER_H_
> +#define _DP_PARSER_H_
> +
> +#include "dpu_io_util.h"
> +
> +#define DP_LABEL "MDSS DP DISPLAY"
> +#define AUX_CFG_LEN	10
> +#define DP_MAX_PIXEL_CLK_KHZ	675000
> +
> +enum dp_pm_type {
> +	DP_CORE_PM,
> +	DP_CTRL_PM,
> +	DP_PHY_PM,
> +	DP_MAX_PM
> +};
> +
> +static inline const char *dp_parser_pm_name(enum dp_pm_type module)
> +{
> +	switch (module) {
> +	case DP_CORE_PM:	return "DP_CORE_PM";
> +	case DP_CTRL_PM:	return "DP_CTRL_PM";
> +	case DP_PHY_PM:		return "DP_PHY_PM";
> +	default:		return "???";

You go out of your way to make sure that the default case can't happen here.
also this function is only used once, I don't think it needs to be a static
inline in the header.

> +	}
> +}
> +
> +/**
> + * struct dp_display_data  - display related device tree data.
> + *
> + * @ctrl_node: referece to controller device
> + * @phy_node:  reference to phy device
> + * @is_active: is the controller currently active
> + * @name: name of the display
> + * @display_type: type of the display
> + */
> +struct dp_display_data {
> +	struct device_node *ctrl_node;
> +	struct device_node *phy_node;
> +	bool is_active;
> +	const char *name;
> +	const char *display_type;
> +};
> +
> +/**
> + * struct dp_ctrl_resource - controller's IO related data
> + *
> + * @dp_ahb: controller's ahb mapped memory address
> + * @dp_aux: controller's aux mapped memory address
> + * @dp_link: controller's link mapped memory address
> + * @dp_p0: controller's p0 mapped memory address
> + * @phy_io: phy's mapped memory address
> + * @ln_tx0_io: USB-DP lane TX0's mapped memory address
> + * @ln_tx1_io: USB-DP lane TX1's mapped memory address
> + * @dp_cc_io: DP cc's mapped memory address
> + * @qfprom_io: qfprom's mapped memory address
> + * @dp_pll_io: DP PLL mapped memory address
> + * @usb3_dp_com: USB3 DP PHY combo mapped memory address
> + */
> +struct dp_io {
> +	struct dss_io_data ctrl_io;
> +	struct dss_io_data dp_ahb;
> +	struct dss_io_data dp_aux;
> +	struct dss_io_data dp_link;
> +	struct dss_io_data dp_p0;
> +	struct dss_io_data phy_io;
> +	struct dss_io_data ln_tx0_io;
> +	struct dss_io_data ln_tx1_io;
> +	struct dss_io_data dp_cc_io;
> +	struct dss_io_data qfprom_io;
> +	struct dss_io_data dp_pll_io;
> +	struct dss_io_data usb3_dp_com;
> +};
> +
> +/**
> + * struct dp_pinctrl - DP's pin control
> + *
> + * @pin: pin-controller's instance
> + * @state_active: active state pin control
> + * @state_hpd_active: hpd active state pin control
> + * @state_suspend: suspend state pin control
> + */
> +struct dp_pinctrl {
> +	struct pinctrl *pin;
> +	struct pinctrl_state *state_active;
> +	struct pinctrl_state *state_hpd_active;
> +	struct pinctrl_state *state_suspend;
> +};
> +
> +#define DP_ENUM_STR(x)	#x
> +#define DP_AUX_CFG_MAX_VALUE_CNT 3
> +/**
> + * struct dp_aux_cfg - DP's AUX configuration settings
> + *
> + * @cfg_cnt: count of the configurable settings for the AUX register
> + * @current_index: current index of the AUX config lut
> + * @offset: register offset of the AUX config register
> + * @lut: look up table for the AUX config values for this register
> + */
> +struct dp_aux_cfg {
> +	u32 cfg_cnt;
> +	u32 current_index;
> +	u32 offset;
> +	u32 lut[DP_AUX_CFG_MAX_VALUE_CNT];
> +};
> +
> +/* PHY AUX config registers */
> +enum dp_phy_aux_config_type {
> +	PHY_AUX_CFG0,
> +	PHY_AUX_CFG1,
> +	PHY_AUX_CFG2,
> +	PHY_AUX_CFG3,
> +	PHY_AUX_CFG4,
> +	PHY_AUX_CFG5,
> +	PHY_AUX_CFG6,
> +	PHY_AUX_CFG7,
> +	PHY_AUX_CFG8,
> +	PHY_AUX_CFG9,
> +	PHY_AUX_CFG_MAX,
> +};
> +
> +static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type)
> +{
> +	switch (cfg_type) {
> +	case PHY_AUX_CFG0:
> +		return DP_ENUM_STR(PHY_AUX_CFG0);
> +	case PHY_AUX_CFG1:
> +		return DP_ENUM_STR(PHY_AUX_CFG1);
> +	case PHY_AUX_CFG2:
> +		return DP_ENUM_STR(PHY_AUX_CFG2);
> +	case PHY_AUX_CFG3:
> +		return DP_ENUM_STR(PHY_AUX_CFG3);
> +	case PHY_AUX_CFG4:
> +		return DP_ENUM_STR(PHY_AUX_CFG4);
> +	case PHY_AUX_CFG5:
> +		return DP_ENUM_STR(PHY_AUX_CFG5);
> +	case PHY_AUX_CFG6:
> +		return DP_ENUM_STR(PHY_AUX_CFG6);
> +	case PHY_AUX_CFG7:
> +		return DP_ENUM_STR(PHY_AUX_CFG7);
> +	case PHY_AUX_CFG8:
> +		return DP_ENUM_STR(PHY_AUX_CFG8);
> +	case PHY_AUX_CFG9:
> +		return DP_ENUM_STR(PHY_AUX_CFG9);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +/**
> + * struct dp_parser - DP parser's data exposed to clients
> + *
> + * @pdev: platform data of the client
> + * @mp: gpio, regulator and clock related data
> + * @pinctrl: pin-control related data
> + * @disp_data: controller's display related data
> + * @parse: function to be called by client to parse device tree.
> + */
> +struct dp_parser {
> +	struct platform_device *pdev;
> +	struct dss_module_power mp[DP_MAX_PM];
> +	struct dp_pinctrl pinctrl;
> +	struct dp_io io;
> +	struct dp_display_data disp_data;
> +
> +	u8 l_map[4];
> +	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
> +	u32 max_pclk_khz;
> +
> +	int (*parse)(struct dp_parser *parser);
> +};
> +
> +/**
> + * dp_parser_get() - get the DP's device tree parser module
> + *
> + * @pdev: platform data of the client
> + * return: pointer to dp_parser structure.
> + *
> + * This function provides client capability to parse the
> + * device tree and populate the data structures. The data
> + * related to clock, regulators, pin-control and other
> + * can be parsed using this module.
> + */
> +struct dp_parser *dp_parser_get(struct platform_device *pdev);
> +
> +/**
> + * dp_parser_put() - cleans the dp_parser module
> + *
> + * @parser: pointer to the parser's data.
> + */
> +void dp_parser_put(struct dp_parser *parser);
> +#endif
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
> new file mode 100644
> index 0000000..1d58480
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
> @@ -0,0 +1,599 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.


> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/clk.h>
> +#include "dp_power.h"
> +
> +#define DP_CLIENT_NAME_SIZE	20
> +
> +struct dp_power_private {
> +	struct dp_parser *parser;
> +	struct platform_device *pdev;
> +	struct clk *pixel_clk_rcg;
> +	struct clk *pixel_parent;
> +
> +	struct dp_power dp_power;
> +
> +	bool core_clks_on;
> +	bool link_clks_on;
> +};
> +
> +static int dp_power_regulator_init(struct dp_power_private *power)
> +{
> +	int rc = 0, i = 0, j = 0;
> +	struct platform_device *pdev;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +	pdev = power->pdev;
> +
> +	for (i = DP_CORE_PM; !rc && (i < DP_MAX_PM); i++) {
> +		rc = msm_dss_config_vreg(&pdev->dev,
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, 1);
> +		if (rc) {
> +			pr_err("failed to init vregs for %s\n",
> +				dp_parser_pm_name(i));

msm_dss_config_vreg() already prints lots of error messages for you.

> +			for (j = i - 1; j >= DP_CORE_PM; j--) {
> +				msm_dss_config_vreg(&pdev->dev,
> +				parser->mp[j].vreg_config,
> +				parser->mp[j].num_vreg, 0);
> +			}
> +
> +			goto error;

just return rc;

> +		}
> +	}
> +error:
> +	return rc;
> +}
> +
> +static void dp_power_regulator_deinit(struct dp_power_private *power)
> +{
> +	int rc = 0, i = 0;
> +	struct platform_device *pdev;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +	pdev = power->pdev;
> +
> +	for (i = DP_CORE_PM; (i < DP_MAX_PM); i++) {
> +		rc = msm_dss_config_vreg(&pdev->dev,
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, 0);
> +		if (rc)
> +			pr_err("failed to deinit vregs for %s\n",
> +				dp_parser_pm_name(i));

Same.

> +	}
> +}
> +
> +static int dp_power_regulator_ctrl(struct dp_power_private *power, bool enable)
> +{
> +	int rc = 0, i = 0, j = 0;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +
> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
> +		rc = msm_dss_enable_vreg(
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, enable);
> +		if (rc) {
> +			pr_err("failed to '%s' vregs for %s\n",
> +					enable ? "enable" : "disable",
> +					dp_parser_pm_name(i));

msm_dss_enable_vreg() already gives you the errors you need.

> +			if (enable) {
> +				for (j = i-1; j >= DP_CORE_PM; j--) {
> +					msm_dss_enable_vreg(
> +					parser->mp[j].vreg_config,
> +					parser->mp[j].num_vreg, 0);
> +				}
> +			}
> +			goto error;
> +		}
> +	}
> +error:
> +	return rc;

You don't need a label with a single return in it.

> +}
> +
> +static int dp_power_pinctrl_set(struct dp_power_private *power, bool active)
> +{
> +	int rc = -EFAULT;
> +	struct pinctrl_state *pin_state;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +
> +	if (IS_ERR_OR_NULL(parser->pinctrl.pin))

Recall that pinctrl.in cannot be NULL.

> +		return PTR_ERR(parser->pinctrl.pin);
> +
> +	pin_state = active ? parser->pinctrl.state_active
> +				: parser->pinctrl.state_suspend;
> +	if (!IS_ERR_OR_NULL(pin_state)) {

Same

> +		rc = pinctrl_select_state(parser->pinctrl.pin,
> +				pin_state);
> +		if (rc)
> +			pr_err("can not set %s pins\n",
> +			       active ? "dp_active"
> +			       : "dp_sleep");
> +	} else {
> +		pr_err("invalid '%s' pinstate\n",
> +		       active ? "dp_active"
> +		       : "dp_sleep");

You already let the user know during inint that the pin_state was not
correct.  You don't need to update them again every time you try to change it.

> +	}
> +
> +	return rc;
> +}
> +
> +static int dp_power_clk_init(struct dp_power_private *power, bool enable)
> +{
> +	int rc = 0;
> +	struct dss_module_power *core, *ctrl;
> +	struct device *dev;
> +
> +	core = &power->parser->mp[DP_CORE_PM];
> +	ctrl = &power->parser->mp[DP_CTRL_PM];
> +
> +	dev = &power->pdev->dev;
> +
> +	if (!core || !ctrl) {
> +		pr_err("invalid power_data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}

These are both impossible since you are deriving the pointer above.

> +
> +	if (enable) {
> +		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);

> +		if (rc) {
> +			pr_err("failed to get %s clk. err=%d\n",
> +				dp_parser_pm_name(DP_CORE_PM), rc);

msm_dss_get_clk already prints an error message for you.

> +			goto exit;
> +		}
> +
> +		rc = msm_dss_get_clk(dev, ctrl->clk_config, ctrl->num_clk);
> +		if (rc) {
> +			pr_err("failed to get %s clk. err=%d\n",
> +				dp_parser_pm_name(DP_CTRL_PM), rc);

Same
> +			goto ctrl_get_error;
> +		}
> +
> +		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
> +		if (IS_ERR(power->pixel_clk_rcg)) {
> +			pr_debug("Unable to get DP pixel clk RCG\n");

This seems like it should be an error?

> +			power->pixel_clk_rcg = NULL;
> +		}
> +
> +		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
> +		if (IS_ERR(power->pixel_parent)) {
> +			pr_debug("Unable to get DP pixel RCG parent\n");

Same?

> +			power->pixel_parent = NULL;
> +		}
> +	} else {

This is another one of those functions that shares very little with the other
side and can be easily split into a separate function that is easier to
understand.

> +		if (power->pixel_parent)
> +			devm_clk_put(dev, power->pixel_parent);
> +
> +		if (power->pixel_clk_rcg)
> +			devm_clk_put(dev, power->pixel_clk_rcg);

You don't need to put managed clocks.

> +
> +		msm_dss_put_clk(ctrl->clk_config, ctrl->num_clk);
> +		msm_dss_put_clk(core->clk_config, core->num_clk);

> +	}
> +
> +	return rc;
> +
> +ctrl_get_error:
> +	msm_dss_put_clk(core->clk_config, core->num_clk);
> +exit:
> +	return rc;
> +}
> +
> +static int dp_power_clk_set_rate(struct dp_power_private *power,
> +		enum dp_pm_type module, bool enable)
> +{
> +	int rc = 0;
> +	struct dss_module_power *mp;
> +
> +	if (!power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}

power will always be valid.

> +	mp = &power->parser->mp[module];
> +
> +	if (enable) {
> +		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
> +		if (rc) {
> +			pr_err("failed to set clks rate.\n");

msm_dss_clk_set_rate() already gives you an error message;

> +			goto exit;
> +		}
> +
> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
> +		if (rc) {
> +			pr_err("failed to enable clks\n");

Same.

> +			goto exit;
> +		}
> +	} else {
> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
> +		if (rc) {
> +			pr_err("failed to disable clks\n");

Same

> +				goto exit;

Suspect indentation, but as usual, don't use a single return in a label - just
return directly.

> +		}
> +	}
> +exit:
> +	return rc;
> +}
> +
> +static int dp_power_clk_enable(struct dp_power *dp_power,
> +		enum dp_pm_type pm_type, bool enable)
> +{
> +	int rc = 0;
> +	struct dss_module_power *mp;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

dp_power will always be valid.

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	mp = &power->parser->mp[pm_type];
> +
> +	if ((pm_type != DP_CORE_PM) && (pm_type != DP_CTRL_PM)) {
> +		pr_err("unsupported power module: %s\n",
> +				dp_parser_pm_name(pm_type));

This seems like it would be never be true outside of egregious developer
error. - I suppose you could WARN_ON here but it just doesn't seem like a thing.

> +		return -EINVAL;
> +	}
> +
> +	if (enable) {
> +		if ((pm_type == DP_CORE_PM)
> +			&& (power->core_clks_on)) {
> +			pr_debug("core clks already enabled\n");
> +			return 0;
> +		}
> +
> +		if ((pm_type == DP_CTRL_PM)
> +			&& (power->link_clks_on)) {
> +			pr_debug("links clks already enabled\n");
> +			return 0;
> +		}
> +
> +		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {
> +			pr_debug("Need to enable core clks before link clks\n");
> +
> +			rc = dp_power_clk_set_rate(power, DP_CORE_PM, enable);
> +			if (rc) {
> +				pr_err("failed to enable clks: %s. err=%d\n",
> +					dp_parser_pm_name(DP_CORE_PM), rc);
> +				goto error;
> +			} else {
> +				power->core_clks_on = true;
> +			}
> +		}
> +	}
> +
> +	rc = dp_power_clk_set_rate(power, pm_type, enable);
> +	if (rc) {
> +		pr_err("failed to '%s' clks for: %s. err=%d\n",
> +			enable ? "enable" : "disable",
> +			dp_parser_pm_name(pm_type), rc);
> +			goto error;
> +	}
> +
> +	if (pm_type == DP_CORE_PM)
> +		power->core_clks_on = enable;
> +	else
> +		power->link_clks_on = enable;

With the number of if statements in here it almost seems more logical to have a
separate function for both DP_CORE_PM and DP_CTRL_PM - yeah, it would copy a bit
of code but it would be a heck of a lot more readable.

> +	pr_debug("%s clocks for %s\n",
> +			enable ? "enable" : "disable",
> +			dp_parser_pm_name(pm_type));
> +	pr_debug("link_clks:%s core_clks:%s\n",
> +		power->link_clks_on ? "on" : "off",
> +		power->core_clks_on ? "on" : "off");
> +error:
> +	return rc;
> +}
> +
> +static int dp_power_request_gpios(struct dp_power_private *power)
> +{
> +	int rc = 0, i;
> +	struct device *dev;
> +	struct dss_module_power *mp;
> +	static const char * const gpio_names[] = {
> +		"aux_enable", "aux_sel", "usbplug_cc",
> +	};
> +
> +	if (!power) {
> +		pr_err("invalid power data\n");
> +		return -EINVAL;
> +	}
> +
> +	dev = &power->pdev->dev;
> +	mp = &power->parser->mp[DP_CORE_PM];
> +
> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
> +		unsigned int gpio = mp->gpio_config[i].gpio;
> +
> +		if (gpio_is_valid(gpio)) {
> +			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
> +			if (rc) {
> +				pr_err("request %s gpio failed, rc=%d\n",
> +					       gpio_names[i], rc);
> +				goto error;
> +			}
> +		}
> +	}
> +	return 0;
> +error:
> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
> +		unsigned int gpio = mp->gpio_config[i].gpio;
> +
> +		if (gpio_is_valid(gpio))
> +			gpio_free(gpio);

Can you call gpio_free() on a device managed resource? I think you probably want
devm_gpio_free.


> +	}
> +	return rc;
> +}
> +
> +static bool dp_power_find_gpio(const char *gpio1, const char *gpio2)
> +{
> +	return !!strnstr(gpio1, gpio2, strlen(gpio1));
> +}
> +
> +static void dp_power_set_gpio(struct dp_power_private *power, bool flip)
> +{
> +	int i;
> +	struct dss_module_power *mp = &power->parser->mp[DP_CORE_PM];
> +	struct dss_gpio *config = mp->gpio_config;
> +
> +	for (i = 0; i < mp->num_gpio; i++) {
> +		if (dp_power_find_gpio(config->gpio_name, "aux-sel"))

I think config->gpio_name is the name from the DT, basically qcom,aux-sel-gpio?
Why not just strcmp on that instead of going the much harder route

> +			config->value = flip;
> +
> +		if (gpio_is_valid(config->gpio)) {
> +			pr_debug("gpio %s, value %d\n", config->gpio_name,
> +				config->value);
> +
> +			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
> +			    dp_power_find_gpio(config->gpio_name, "aux-sel"))

Same and same

> +				gpio_direction_output(config->gpio,
> +					config->value);
> +			else
> +				gpio_set_value(config->gpio, config->value);
> +
> +		}
> +		config++;
> +	}
> +}
> +
> +static int dp_power_config_gpios(struct dp_power_private *power, bool flip,
> +					bool enable)
> +{
> +	int rc = 0, i;
> +	struct dss_module_power *mp;
> +	struct dss_gpio *config;
> +
> +	mp = &power->parser->mp[DP_CORE_PM];
> +	config = mp->gpio_config;
> +
> +	if (enable) {
> +		rc = dp_power_request_gpios(power);
> +		if (rc) {
> +			pr_err("gpio request failed\n");

dp_power_request_gpios prints an error message on every failure point.

> +			return rc;
> +		}
> +
> +		dp_power_set_gpio(power, flip);

It seems like maybe dp_power_request_gpios() and dp_power_set_gpio() can be
combined - both of them only get called here.

> +	} else {

Again, this feels like it could safely be in its own function for clarity.

> +		for (i = 0; i < mp->num_gpio; i++) {
> +			gpio_set_value(config[i].gpio, 0);
> +			gpio_free(config[i].gpio);
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int dp_power_client_init(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		return -EINVAL;
> +	}

dp_power can never be NULL here.

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	pm_runtime_enable(&power->pdev->dev);
> +
> +	rc = dp_power_regulator_init(power);
> +	if (rc) {
> +		pr_err("failed to init regulators\n");

The sub function already prints error messages.

> +		goto error_power;
> +	}
> +
> +	rc = dp_power_clk_init(power, true);
> +	if (rc) {
> +		pr_err("failed to init clocks\n");

Also this one.

> +		goto error_clk;
> +	}
> +	return 0;

You can flip this if statement and save a goto:

if (!rc)
    return 0;

dp_power_regulator_deinit(power);
...

> +
> +error_clk:
> +	dp_power_regulator_deinit(power);
> +error_power:
> +	pm_runtime_disable(&power->pdev->dev);
> +	return rc;
> +}
> +
> +static void dp_power_client_deinit(struct dp_power *dp_power)
> +{
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		return;
> +	}

dp_power is always set.

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	dp_power_clk_init(power, false);
> +	dp_power_regulator_deinit(power);
> +	pm_runtime_disable(&power->pdev->dev);
> +
> +}
> +
> +static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
>
dp_power is always set.

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	if (power->pixel_clk_rcg && power->pixel_parent)
> +		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
> +exit:
> +	return rc;
> +}
> +
> +static int dp_power_init(struct dp_power *dp_power, bool flip)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}

dp_power is always set.

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	pm_runtime_get_sync(&power->pdev->dev);
> +	rc = dp_power_regulator_ctrl(power, true);
> +	if (rc) {
> +		pr_err("failed to enable regulators\n");

This already prints the error messages you need.

> +		goto exit;
> +	}
> +
> +	rc = dp_power_pinctrl_set(power, true);
> +	if (rc) {
> +		pr_err("failed to set pinctrl state\n");

Same.

> +		goto err_pinctrl;
> +	}
> +
> +	rc = dp_power_config_gpios(power, flip, true);
> +	if (rc) {
> +		pr_err("failed to enable gpios\n");

Same.

> +		goto err_gpio;
> +	}
> +
> +	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
> +	if (rc) {
> +		pr_err("failed to enable DP core clocks\n");

Same.

> +		goto err_clk;
> +	}
> +
> +	return 0;

As above, flip the if statement and save a goto:

if (!rc)
    return 0;

dp_power_config_gpios(power, flip, false);
...

> +
> +err_clk:
> +	dp_power_config_gpios(power, flip, false);
> +err_gpio:
> +	dp_power_pinctrl_set(power, false);
> +err_pinctrl:
> +	dp_power_regulator_ctrl(power, false);
> +exit:
> +	pm_runtime_put_sync(&power->pdev->dev);
> +	return rc;
> +}
> +
> +static int dp_power_deinit(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}

dp_power can never be NULL;

> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	dp_power_clk_enable(dp_power, DP_CORE_PM, false);
> +	dp_power_config_gpios(power, false, false);
> +	dp_power_pinctrl_set(power, false);
> +	dp_power_regulator_ctrl(power, false);
> +	pm_runtime_put_sync(&power->pdev->dev);
> +exit:
> +	return rc;
> +}
> +
> +struct dp_power *dp_power_get(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +	struct dp_power *dp_power;
> +
> +	if (!parser) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}

parser can never be NULL;

> +	power = devm_kzalloc(&parser->pdev->dev, sizeof(*power), GFP_KERNEL);
> +	if (!power) {
> +		rc = -ENOMEM;

Just return ERR_PTR(-ENOMEM);

> +		goto error;
> +	}
> +
> +	power->parser = parser;
> +	power->pdev = parser->pdev;
> +
> +	dp_power = &power->dp_power;
> +
> +	dp_power->init = dp_power_init;
> +	dp_power->deinit = dp_power_deinit;
> +	dp_power->clk_enable = dp_power_clk_enable;
> +	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
> +	dp_power->power_client_init = dp_power_client_init;
> +	dp_power->power_client_deinit = dp_power_client_deinit;
> +
> +	return dp_power;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_power_put(struct dp_power *dp_power)
> +{
> +	struct dp_power_private *power = NULL;
> +
> +	if (!dp_power)
> +		return;
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	devm_kfree(&power->pdev->dev, power);

You don't need to kfree device managed mmemory.

> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
> new file mode 100644
> index 0000000..d1adaaf
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
> @@ -0,0 +1,57 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

> +
> +#ifndef _DP_POWER_H_
> +#define _DP_POWER_H_
> +
> +#include "dp_parser.h"
> +#include "dpu_power_handle.h"
> +
> +/**
> + * sruct dp_power - DisplayPort's power related data
> + *
> + * @init: initializes the regulators/core clocks/GPIOs/pinctrl
> + * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
> + * @clk_enable: enable/disable the DP clocks
> + * @set_pixel_clk_parent: set the parent of DP pixel clock
> + */
> +struct dp_power {
> +	int (*init)(struct dp_power *power, bool flip);
> +	int (*deinit)(struct dp_power *power);
> +	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
> +				bool enable);
> +	int (*set_pixel_clk_parent)(struct dp_power *power);
> +	int (*power_client_init)(struct dp_power *power);
> +	void (*power_client_deinit)(struct dp_power *power);
> +};
> +
> +/**
> + * dp_power_get() - configure and get the DisplayPort power module data
> + *
> + * @parser: instance of parser module
> + * return: pointer to allocated power module data
> + *
> + * This API will configure the DisplayPort's power module and provides
> + * methods to be called by the client to configure the power related
> + * modueles.
> + */
> +struct dp_power *dp_power_get(struct dp_parser *parser);
> +
> +/**
> + * dp_power_put() - release the power related resources
> + *
> + * @power: pointer to the power module's data
> + */
> +void dp_power_put(struct dp_power *power);
> +#endif /* _DP_POWER_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_reg.h b/drivers/gpu/drm/msm/dp/dp_reg.h
> new file mode 100644
> index 0000000..77b5c0e
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_reg.h
> @@ -0,0 +1,357 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please.

<snip the rest>

Jordan

-- 
The Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Sean Paul]

On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> Add the needed displayPort files to enable DP driver
> on msm target.
> 
> "dp_display" module is the main module that calls into
> other sub-modules. "dp_drm" file represents the interface
> between DRM framework and DP driver.
> 

Hi Chandan,
A few themes which I've pointed out below, but want to call out at the top so
it's obvious.

- Please remove all superfluous NULL checks at the beginning of functions.
  Included in this is reflowing initialization of variables and checking that
  return types still make sense (ie: if a function's only error path is the NULL
  check, make it void).
- Please remove all of the new callbacks and just call functions directly. This
  should also get rid of the _get/_put functions that allocate/set them up
- Please consolidate state structs into one struct with a few substructs,
  there's too much state right now.
- Please #define hardcoded values
- Instead of sprinkling wmb() everywhere, use readl/writel instead of *_relaxed
- There are a bunch of races that I found, please audit the code and remove
  races with locks as necessary
- I tried to catch as much dead code as possible, please audit the rest for
  unused structs/variables/functions/etc
- Use drm dp helper structs for link parameter storage


> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>  drivers/gpu/drm/msm/Makefile                |   15 +-
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 ++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 +++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 +++++++++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>  include/drm/drm_dp_helper.h                 |   19 +
>  30 files changed, 10887 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
> 
> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
> index 843a9d4..c363f24 100644
> --- a/drivers/gpu/drm/msm/Kconfig
> +++ b/drivers/gpu/drm/msm/Kconfig
> @@ -49,6 +49,15 @@ config DRM_MSM_HDMI_HDCP
>  	help
>  	  Choose this option to enable HDCP state machine
>  
> +config DRM_MSM_DP
> +	bool "Enable DP support in MSM DRM driver"
> +	depends on DRM_MSM
> +	default n
> +	help
> +	  Compile in support for DP driver in msm drm
> +	  driver. DP external display support is enabled
> +	  through this config option. It can be primary or
> +	  secondary display on device.

Why are these line lengths so short? You can go to 80 columns. Please also add
an empty line here.

>  config DRM_MSM_DSI
>  	bool "Enable DSI support in MSM DRM driver"
>  	depends on DRM_MSM
> diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
> index 19ab521..765a8d8 100644
> --- a/drivers/gpu/drm/msm/Makefile
> +++ b/drivers/gpu/drm/msm/Makefile
> @@ -2,6 +2,7 @@
>  ccflags-y := -Idrivers/gpu/drm/msm
>  ccflags-y += -Idrivers/gpu/drm/msm/disp/dpu1
>  ccflags-$(CONFIG_DRM_MSM_DSI) += -Idrivers/gpu/drm/msm/dsi
> +ccflags-$(CONFIG_DRM_MSM_DP) += -Idrivers/gpu/drm/msm/dp
>  
>  msm-y := \
>  	adreno/adreno_device.o \
> @@ -93,7 +94,19 @@ msm-y := \
>  	msm_submitqueue.o
>  
>  msm-$(CONFIG_DEBUG_FS) += adreno/a5xx_debugfs.o \
> -			  disp/dpu1/dpu_dbg.o
> +			  disp/dpu1/dpu_dbg.o \
> +			  dp/dp_debug.o

Does this compile if CONFIG_DEBUG_FS is selected, but not CONFIG_DRM_MSM_DP?

> +
> +msm-$(CONFIG_DRM_MSM_DP)+= dp/dp_extcon.o \
> +	dp/dp_parser.o \
> +	dp/dp_power.o \
> +	dp/dp_catalog.o \
> +	dp/dp_aux.o \
> +	dp/dp_panel.o \
> +	dp/dp_link.o \
> +	dp/dp_ctrl.o \
> +	dp/dp_display.o \
> +	dp/dp_drm.o

The rest of the file has files in alphabetical order, this should too.

>  
>  msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
>  msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> index 790d39f..0f53a15 100644
> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
> @@ -14,10 +14,216 @@
>  #include <linux/clk.h>
>  #include <linux/clk/clk-conf.h>
>  #include <linux/err.h>
> +#include <linux/io.h>
> +#include <linux/regulator/consumer.h>
>  #include <linux/delay.h>
>  
>  #include "dpu_io_util.h"
>  
> +static struct resource *msm_dss_get_res_byname(struct platform_device *pdev,
> +					       unsigned int type,
> +					       const char *name)
> +{
> +	struct resource *res = NULL;
> +
> +	res = platform_get_resource_byname(pdev, type, name);
> +	if (!res)
> +		DEV_ERR("%s: '%s' resource not found\n", __func__, name);
> +
> +	return res;
> +} /* msm_dss_get_res_byname */

Why don't you just call platform_get_resource_byname directly?

> +
> +int msm_dss_ioremap_byname(struct platform_device *pdev,
> +			   struct dss_io_data *io_data, const char *name)
> +{
> +	struct resource *res = NULL;
> +
> +	if (!pdev || !io_data) {

Given that we've been aggressively trying to get rid of these superfluous
checks, I'm not thrilled that they're being re-introduced. Can you please go
through the patch and remove all of the unnecessary checks?

> +		DEV_ERR("%pS->%s: invalid input\n",
> +			__builtin_return_address(0), __func__);
> +		return -EINVAL;
> +	}
> +
> +	res = msm_dss_get_res_byname(pdev, IORESOURCE_MEM, name);
> +	if (!res) {
> +		DEV_ERR("%pS->%s: '%s' msm_dss_get_res_byname failed\n",
> +			__builtin_return_address(0), __func__, name);

Yet another error format :) Could we please stick with one of DPU_ERROR,
DRM_ERROR, or DRM_DEV_ERROR?

> +		return -ENODEV;
> +	}
> +
> +	io_data->len = (u32)resource_size(res);
> +	io_data->base = ioremap(res->start, io_data->len);
> +	if (!io_data->base) {
> +		DEV_ERR("%pS->%s: '%s' ioremap failed\n",
> +			__builtin_return_address(0), __func__, name);
> +		return -EIO;
> +	}
> +
> +	return 0;
> +} /* msm_dss_ioremap_byname */
> +
> +void msm_dss_iounmap(struct dss_io_data *io_data)
> +{
> +	if (!io_data) {
> +		DEV_ERR("%pS->%s: invalid input\n",
> +			__builtin_return_address(0), __func__);
> +		return;
> +	}
> +
> +	if (io_data->base) {
> +		iounmap(io_data->base);
> +		io_data->base = NULL;
> +	}
> +	io_data->len = 0;
> +} /* msm_dss_iounmap */

These two functions are only used in dp_parser.c, why not just make them static
functions there?

> +
> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
> +			int num_vreg, int config)

This should be 2 functions, one for initialization and one for deinitializing,
the 2 paths don't share any code, so there's no need to combine them.

> +{
> +	int i = 0, rc = 0;
> +	struct dss_vreg *curr_vreg = NULL;
> +	enum dss_vreg_type type;
> +
> +	if (!in_vreg || !num_vreg)
> +		return rc;
> +
> +	if (config) {
> +		for (i = 0; i < num_vreg; i++) {
> +			curr_vreg = &in_vreg[i];
> +			curr_vreg->vreg = regulator_get(dev,

Use devm_* please

> +				curr_vreg->vreg_name);
> +			rc = PTR_RET(curr_vreg->vreg);

PTR_RET is deprecated. The pattern for this is usually:

                        ptr = some_func();
                        if (IS_ERR_OR_NULL(ptr)) {
                                ...
                                rc = PTR_ERR(ptr);
                                goto fail_label:
                        }

> +			if (rc) {
> +				DEV_ERR("%pS->%s: %s get failed. rc=%d\n",
> +					 __builtin_return_address(0), __func__,
> +					 curr_vreg->vreg_name, rc);
> +				curr_vreg->vreg = NULL;
> +				goto vreg_get_fail;
> +			}
> +			type = (regulator_count_voltages(curr_vreg->vreg) > 0)
> +					? DSS_REG_LDO : DSS_REG_VS;
> +			if (type == DSS_REG_LDO) {
> +				rc = regulator_set_voltage(
> +					curr_vreg->vreg,
> +					curr_vreg->min_voltage,
> +					curr_vreg->max_voltage);
> +				if (rc < 0) {
> +					DEV_ERR("%pS->%s: %s set vltg fail\n",
> +						__builtin_return_address(0),
> +						__func__,
> +						curr_vreg->vreg_name);
> +					goto vreg_set_voltage_fail;
> +				}
> +			}
> +		}
> +	} else {
> +		for (i = num_vreg-1; i >= 0; i--) {
> +			curr_vreg = &in_vreg[i];
> +			if (curr_vreg->vreg) {
> +				type = (regulator_count_voltages(
> +					curr_vreg->vreg) > 0)
> +					? DSS_REG_LDO : DSS_REG_VS;
> +				if (type == DSS_REG_LDO) {
> +					regulator_set_voltage(curr_vreg->vreg,
> +						0, curr_vreg->max_voltage);
> +				}
> +				regulator_put(curr_vreg->vreg);
> +				curr_vreg->vreg = NULL;
> +			}
> +		}
> +	}
> +	return 0;
> +
> +vreg_unconfig:
> +if (type == DSS_REG_LDO)
> +	regulator_set_load(curr_vreg->vreg, 0);
> +
> +vreg_set_voltage_fail:
> +	regulator_put(curr_vreg->vreg);
> +	curr_vreg->vreg = NULL;
> +
> +vreg_get_fail:
> +	for (i--; i >= 0; i--) {
> +		curr_vreg = &in_vreg[i];
> +		type = (regulator_count_voltages(curr_vreg->vreg) > 0)
> +			? DSS_REG_LDO : DSS_REG_VS;
> +		goto vreg_unconfig;
> +	}
> +	return rc;
> +} /* msm_dss_config_vreg */
> +
> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg, int enable)
> +{
> +	int i = 0, rc = 0;
> +	bool need_sleep;
> +
> +	if (enable) {
> +		for (i = 0; i < num_vreg; i++) {
> +			rc = PTR_RET(in_vreg[i].vreg);
> +			if (rc) {
> +				DEV_ERR("%pS->%s: %s regulator error. rc=%d\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name, rc);
> +				goto vreg_set_opt_mode_fail;
> +			}
> +			need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
> +			if (in_vreg[i].pre_on_sleep && need_sleep)
> +				usleep_range(in_vreg[i].pre_on_sleep * 1000,
> +					in_vreg[i].pre_on_sleep * 1000);
> +			rc = regulator_set_load(in_vreg[i].vreg,
> +				in_vreg[i].enable_load);
> +			if (rc < 0) {
> +				DEV_ERR("%pS->%s: %s set opt m fail\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name);
> +				goto vreg_set_opt_mode_fail;
> +			}
> +			rc = regulator_enable(in_vreg[i].vreg);
> +			if (in_vreg[i].post_on_sleep && need_sleep)
> +				usleep_range(in_vreg[i].post_on_sleep * 1000,
> +					in_vreg[i].post_on_sleep * 1000);
> +			if (rc < 0) {
> +				DEV_ERR("%pS->%s: %s enable failed\n",
> +					__builtin_return_address(0), __func__,
> +					in_vreg[i].vreg_name);
> +				goto disable_vreg;
> +			}
> +		}
> +	} else {
> +		for (i = num_vreg-1; i >= 0; i--) {
> +			if (in_vreg[i].pre_off_sleep)
> +				usleep_range(in_vreg[i].pre_off_sleep * 1000,
> +					in_vreg[i].pre_off_sleep * 1000);
> +			regulator_set_load(in_vreg[i].vreg,
> +				in_vreg[i].disable_load);
> +			regulator_disable(in_vreg[i].vreg);
> +			if (in_vreg[i].post_off_sleep)
> +				usleep_range(in_vreg[i].post_off_sleep * 1000,
> +					in_vreg[i].post_off_sleep * 1000);
> +		}
> +	}
> +	return rc;
> +
> +disable_vreg:
> +	regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
> +
> +vreg_set_opt_mode_fail:
> +	for (i--; i >= 0; i--) {
> +		if (in_vreg[i].pre_off_sleep)
> +			usleep_range(in_vreg[i].pre_off_sleep * 1000,
> +				in_vreg[i].pre_off_sleep * 1000);
> +		regulator_set_load(in_vreg[i].vreg,
> +			in_vreg[i].disable_load);
> +		regulator_disable(in_vreg[i].vreg);
> +		if (in_vreg[i].post_off_sleep)
> +			usleep_range(in_vreg[i].post_off_sleep * 1000,
> +				in_vreg[i].post_off_sleep * 1000);
> +	}
> +
> +	return rc;
> +} /* msm_dss_enable_vreg */
> +

Same question here, but with dp_power.

> +
>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk)
>  {
>  	int i;
> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> index bc07381..524b394 100644
> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
> @@ -15,6 +15,7 @@
>  
>  #include <linux/gpio.h>
>  #include <linux/platform_device.h>
> +#include <linux/regulator/consumer.h>
>  #include <linux/types.h>
>  
>  #define DEV_DBG(fmt, args...)   pr_debug(fmt, ##args)
> @@ -22,6 +23,39 @@
>  #define DEV_WARN(fmt, args...)  pr_warn(fmt, ##args)
>  #define DEV_ERR(fmt, args...)   pr_err(fmt, ##args)
>  
> +struct dss_io_data {
> +	u32 len;
> +	void __iomem *base;
> +};

len isn't used anywhere, so this struct can go away. If the struct goes away,
you can really simplify (or eliminate msm_dss_ioremap_byname())

> +
> +/*
> +void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 debug);
> +u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug);
> +void dss_reg_dump(void __iomem *base, u32 len, const char *prefix, u32 debug);
> +
> +#define DSS_REG_W_ND(io, offset, val)  dss_reg_w(io, offset, val, false)
> +#define DSS_REG_W(io, offset, val)     dss_reg_w(io, offset, val, true)
> +#define DSS_REG_R_ND(io, offset)       dss_reg_r(io, offset, false)
> +#define DSS_REG_R(io, offset)          dss_reg_r(io, offset, true)
> +*/

None of the dss_reg_*/DSS_REG_* functions/macros are used. Please remove.


> +enum dss_vreg_type {
> +	DSS_REG_LDO,
> +	DSS_REG_VS,
> +};

These are only used in msm_dss_config_vreg(). Please remove.

> +
> +struct dss_vreg {
> +	struct regulator *vreg; /* vreg handle */
> +	char vreg_name[32];
> +	int min_voltage;
> +	int max_voltage;

Can't we deduce these from the regulator subsystem with
regulator_list_voltage()?

> +	int enable_load;
> +	int disable_load;

These are really a function of the dp device than the regulator.

> +	int pre_on_sleep;
> +	int post_on_sleep;
> +	int pre_off_sleep;
> +	int post_off_sleep;

None of these sleep values are set? Also, shouldn't these constraints usually
expressed/acted upon in the regulator driver?

> +};

So if we can remove all of the extra goop around the regulator, then we can get
rid of dss_vreg.

> +
>  struct dss_gpio {
>  	unsigned int gpio;
>  	unsigned int value;
> @@ -42,12 +76,22 @@ struct dss_clk {
>  };
>  
>  struct dss_module_power {
> +	unsigned int num_vreg;
> +	struct dss_vreg *vreg_config;
>  	unsigned int num_gpio;
>  	struct dss_gpio *gpio_config;
>  	unsigned int num_clk;
>  	struct dss_clk *clk_config;
>  };
>  
> +int msm_dss_ioremap_byname(struct platform_device *pdev,
> +			   struct dss_io_data *io_data, const char *name);
> +void msm_dss_iounmap(struct dss_io_data *io_data);
> +
> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
> +			int num_vreg, int config);
> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg,	int enable);
> +
>  int msm_dss_get_clk(struct device *dev, struct dss_clk *clk_arry, int num_clk);
>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk);


Why are these msm_dss* functions in dpu_io_util.h?

>  int msm_dss_clk_set_rate(struct dss_clk *clk_arry, int num_clk);
> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c b/drivers/gpu/drm/msm/dp/dp_aux.c
> new file mode 100644
> index 0000000..00b82c2
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_aux.c
> @@ -0,0 +1,570 @@

/snip

> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h b/drivers/gpu/drm/msm/dp/dp_aux.h
> new file mode 100644
> index 0000000..0c300ed
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_aux.h

/snip

I didn't really review the dp_aux.* files as-is. Please convert to using
drm_dp_aux and I'll take another look.


> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c b/drivers/gpu/drm/msm/dp/dp_catalog.c
> new file mode 100644
> index 0000000..5818612
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
> @@ -0,0 +1,1188 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/delay.h>
> +#include <drm/drm_dp_helper.h>
> +
> +#include "dp_catalog.h"
> +#include "dp_reg.h"
> +
> +#define DP_GET_MSB(x)	(x >> 8)
> +#define DP_GET_LSB(x)	(x & 0xff)

These aren't used anywhere

> +
> +#define dp_read(offset) readl_relaxed((offset))
> +#define dp_write(offset, data) writel_relaxed((data), (offset))

These macros aren't useful. I think you'd be much better having a read_/write_
for the different io types, ie:

static inline u32 dp_read_audio(struct dp_catalog *catalog, u32 offset)
{
        return readl_relaxed(catalog->io->dp_link.base + offset);
}

Then you can remove a ton of boilerplate code below getting base;

> +
> +#define dp_catalog_get_priv(x) { \

static inline struct dp_catalog_private *dp_catalog_get_priv(...)
{
        ...
}

> +	struct dp_catalog *dp_catalog; \
> +	dp_catalog = container_of(x, struct dp_catalog, x); \
> +	catalog = container_of(dp_catalog, struct dp_catalog_private, \
> +				dp_catalog); \
> +}
> +
> +#define DP_INTERRUPT_STATUS1 \
> +	(DP_INTR_AUX_I2C_DONE| \
> +	DP_INTR_WRONG_ADDR | DP_INTR_TIMEOUT | \
> +	DP_INTR_NACK_DEFER | DP_INTR_WRONG_DATA_CNT | \
> +	DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER | \
> +	DP_INTR_PLL_UNLOCKED | DP_INTR_AUX_ERROR)
> +
> +#define DP_INTR_MASK1		(DP_INTERRUPT_STATUS1 << 2)
> +
> +#define DP_INTERRUPT_STATUS2 \
> +	(DP_INTR_READY_FOR_VIDEO | DP_INTR_IDLE_PATTERN_SENT | \
> +	DP_INTR_FRAME_END | DP_INTR_CRC_UPDATED)
> +
> +#define DP_INTR_MASK2		(DP_INTERRUPT_STATUS2 << 2)

Can you please rename these to be consistent with each other?
DP_INTERRUPT_STATUS2_MASK perhaps?

> +
> +static u8 const vm_pre_emphasis[4][4] = {
> +	{0x00, 0x0B, 0x12, 0xFF},       /* pe0, 0 db */
> +	{0x00, 0x0A, 0x12, 0xFF},       /* pe1, 3.5 db */
> +	{0x00, 0x0C, 0xFF, 0xFF},       /* pe2, 6.0 db */
> +	{0xFF, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
> +};
> +
> +/* voltage swing, 0.2v and 1.0v are not support */
> +static u8 const vm_voltage_swing[4][4] = {
> +	{0x07, 0x0F, 0x14, 0xFF}, /* sw0, 0.4v  */
> +	{0x11, 0x1D, 0x1F, 0xFF}, /* sw1, 0.6 v */
> +	{0x18, 0x1F, 0xFF, 0xFF}, /* sw1, 0.8 v */
> +	{0xFF, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
> +};
> +
> +/* audio related catalog functions */
> +struct dp_catalog_private {
> +	struct device *dev;
> +	struct dp_io *io;
> +
> +	u32 (*audio_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	struct dp_catalog dp_catalog;
> +};
> +
> +/* aux related catalog functions */
> +static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");

And another logging type, please remove pr_* and use a DPU_/DRM_/DRM_DEV_
variant.

> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	return dp_read(base + DP_AUX_DATA);
> +end:
> +	return 0;

... or you could just return directly in the if above and remove the label :)
Same comment applies below.

Also, probably shouldn't return 0 in an error case.

Then again, I'm guessing hitting the NULL case is likely impossible, so you can
probably remove all of the machinery around checking !aux.

> +}
> +
> +static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	dp_write(base + DP_AUX_DATA, aux->data);
> +end:
> +	return rc;
> +}
> +
> +static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	dp_write(base + DP_AUX_TRANS_CTRL, aux->data);
> +end:
> +	return rc;
> +}
> +
> +static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, bool read)
> +{
> +	int rc = 0;
> +	u32 data = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	if (read) {
> +		data = dp_read(base + DP_AUX_TRANS_CTRL);
> +		data &= ~BIT(9);
> +		dp_write(base + DP_AUX_TRANS_CTRL, data);
> +	} else {
> +		dp_write(base + DP_AUX_TRANS_CTRL, 0);
> +	}
> +end:
> +	return rc;
> +}
> +
> +static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
> +{
> +	u32 aux_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
> +
> +	aux_ctrl |= BIT(1);

What's BIT(1)? Can you please #define it?

> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +	usleep_range(1000, 1010); /* h/w recommended delay */

10us diff is right on the line of enough delay to make usleep_range worth it.
I'd recommend increasing to 100us to increase the chance of the scheduler being
able to batch this wakeup with another.

> +
> +	aux_ctrl &= ~BIT(1);
> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +	wmb();

Can you just use writel for these cases instead of using _relaxed and then
wmb()? This applies elsewhere too.

> +}
> +
> +static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool enable)
> +{
> +	u32 aux_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	base = catalog->io->dp_aux.base;
> +
> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
> +
> +	if (enable) {
> +		dp_write(base + DP_TIMEOUT_COUNT, 0xffff);
> +		dp_write(base + DP_AUX_LIMITS, 0xffff);
> +		aux_ctrl |= BIT(0);

Please #define BIT(0)

> +	} else {
> +		aux_ctrl &= ~BIT(0);
> +	}
> +
> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
> +}
> +
> +static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 new_index = 0, current_index = 0;
> +
> +	if (!aux || !cfg || (type >= PHY_AUX_CFG_MAX)) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +
> +	current_index = cfg[type].current_index;
> +	new_index = (current_index + 1) % cfg[type].cfg_cnt;
> +	pr_debug("Updating %s from 0x%08x to 0x%08x\n",
> +		dp_phy_aux_config_type_to_string(type),
> +	cfg[type].lut[current_index], cfg[type].lut[new_index]);
> +
> +	dp_write(catalog->io->phy_io.base + cfg[type].offset,
> +			cfg[type].lut[new_index]);
> +	cfg[type].current_index = new_index;
> +}
> +
> +static void dp_catalog_aux_setup(struct dp_catalog_aux *aux,
> +		struct dp_aux_cfg *cfg)
> +{
> +	struct dp_catalog_private *catalog;
> +	int i = 0;
> +
> +	if (!aux || !cfg) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +
> +	dp_write(catalog->io->phy_io.base + DP_PHY_PD_CTL, 0x65);

What's 0x65? Please #define

> +	wmb(); /* make sure PD programming happened */
> +
> +	/* Turn on BIAS current for PHY/PLL */
> +	dp_write(catalog->io->dp_pll_io.base +
> +		QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x1b);

Same here for 0x1b. I'm going to stop mentioning this, please audit the driver
for other instances of hardcoded values (like this and the one at the end of
this function) and break them out into meaningful #defines.

> +
> +	/* DP AUX CFG register programming */
> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
> +		pr_debug("%s: offset=0x%08x, value=0x%08x\n",
> +			dp_phy_aux_config_type_to_string(i),
> +			cfg[i].offset, cfg[i].lut[cfg[i].current_index]);
> +		dp_write(catalog->io->phy_io.base + cfg[i].offset,
> +			cfg[i].lut[cfg[i].current_index]);
> +	}
> +
> +	dp_write(catalog->io->phy_io.base + DP_PHY_AUX_INTERRUPT_MASK, 0x1F);
> +}
> +
> +static void dp_catalog_aux_get_irq(struct dp_catalog_aux *aux, bool cmd_busy)
> +{
> +	u32 ack;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *ahb_base;
> +
> +	if (!aux) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(aux);
> +	ahb_base = catalog->io->dp_ahb.base;
> +
> +	aux->isr = dp_read(ahb_base + DP_INTR_STATUS);
> +	aux->isr &= ~DP_INTR_MASK1;
> +	ack = aux->isr & DP_INTERRUPT_STATUS1;
> +	ack <<= 1;
> +	ack |= DP_INTR_MASK1;
> +	dp_write(ahb_base + DP_INTR_STATUS, ack);
> +}
> +
> +/* controller related catalog functions */
> +static void dp_catalog_ctrl_update_transfer_unit(struct dp_catalog_ctrl *ctrl)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_VALID_BOUNDARY, ctrl->valid_boundary);
> +	dp_write(base + DP_TU, ctrl->dp_tu);
> +	dp_write(base + DP_VALID_BOUNDARY_2, ctrl->valid_boundary2);
> +}
> +
> +static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, u32 state)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_STATE_CTRL, state);
> +}
> +
> +static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, u32 cfg)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *link_base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	link_base = catalog->io->dp_link.base;
> +
> +	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
> +
> +	dp_write(link_base + DP_CONFIGURATION_CTRL, cfg);
> +}
> +
> +static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl *ctrl)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_LOGICAL2PHYSICAL_LANE_MAPPING, 0xe4);
> +}
> +
> +static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl *ctrl,
> +						bool enable)
> +{
> +	u32 mainlink_ctrl;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	if (enable) {
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
> +		wmb(); /* make sure mainlink is turned off before reset */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000002);
> +		wmb(); /* make sure mainlink entered reset */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
> +		wmb(); /* make sure mainlink reset done */
> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000001);
> +		wmb(); /* make sure mainlink turned on */

Same comments here re: readl vs readl_relaxed + wmb

Please #define the bits you're setting.


> +	} else {
> +		mainlink_ctrl = dp_read(base + DP_MAINLINK_CTRL);
> +		mainlink_ctrl &= ~BIT(0);
> +		dp_write(base + DP_MAINLINK_CTRL, mainlink_ctrl);
> +	}
> +}
> +
> +static void dp_catalog_ctrl_config_misc(struct dp_catalog_ctrl *ctrl,
> +					u32 cc, u32 tb)
> +{
> +	u32 misc_val;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	misc_val = dp_read(base + DP_MISC1_MISC0);
> +	misc_val |= cc;

Should you mask this so it doesn't stomp areas it shouldn't?

> +	misc_val |= (tb << 5);

Parentheses are unnecessary

> +	misc_val |= BIT(0); /* Configure clock to synchronous mode */
> +
> +	pr_debug("misc settings = 0x%x\n", misc_val);
> +	dp_write(base + DP_MISC1_MISC0, misc_val);
> +}
> +
> +static void dp_catalog_ctrl_config_msa(struct dp_catalog_ctrl *ctrl,
> +					u32 rate, u32 stream_rate_khz,
> +					bool fixed_nvid)
> +{
> +	u32 pixel_m, pixel_n;
> +	u32 mvid, nvid;
> +	u64 mvid_calc;
> +	u32 const nvid_fixed = 0x8000;

You should pull this out into a #define in drm_dp_helper.h and use the new
define in the i915 driver (in a separate patch) as well as here.

> +	u32 const link_rate_hbr2 = 540000;
> +	u32 const link_rate_hbr3 = 810000;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base_cc, *base_ctrl;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	if (fixed_nvid) {
> +		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
> +		nvid = nvid_fixed;
> +
> +		pr_debug("link rate=%dkbps, stream_rate_khz=%uKhz",
> +			rate, stream_rate_khz);
> +
> +		/*
> +		 * For intermediate results, use 64 bit arithmetic to avoid
> +		 * loss of precision.
> +		 */
> +		mvid_calc = (u64) stream_rate_khz * nvid;
> +		mvid_calc = div_u64(mvid_calc, rate);
> +
> +		/*
> +		 * truncate back to 32 bits as this final divided value will
> +		 * always be within the range of a 32 bit unsigned int.
> +		 */
> +		mvid = (u32) mvid_calc;
> +	} else {
> +		base_cc = catalog->io->dp_cc_io.base;
> +
> +		pixel_m = dp_read(base_cc + MMSS_DP_PIXEL_M);
> +		pixel_n = dp_read(base_cc + MMSS_DP_PIXEL_N);
> +		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
> +
> +		mvid = (pixel_m & 0xFFFF) * 5;
> +		nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
> +
> +		pr_debug("rate = %d\n", rate);
> +
> +		if (link_rate_hbr2 == rate)
> +			nvid *= 2;
> +
> +		if (link_rate_hbr3 == rate)
> +			nvid *= 3;

                switch (drm_dp_bw_code_to_link_rate(rate)) {
                case DP_LINK_BW_5_4:
                        nvid *= 2;
                        break;
                case DP_LINK_BW_8_1:
                        nvid *= 3;
                        break;
                default:
                        break;
                }

And remove link_rate_hbr* above.


> +	}
> +
> +	base_ctrl = catalog->io->dp_link.base;
> +	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
> +	dp_write(base_ctrl + DP_SOFTWARE_MVID, mvid);
> +	dp_write(base_ctrl + DP_SOFTWARE_NVID, nvid);
> +}
> +
> +static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
> +					u32 pattern)
> +{
> +	int bit, cnt = 10;
> +	u32 data;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	bit = 1;
> +	bit <<= (pattern - 1);

        bit = BIT(pattern - 1);

> +	pr_debug("hw: bit=%d train=%d\n", bit, pattern);
> +	dp_write(base + DP_STATE_CTRL, bit);
> +
> +	bit = 8;
> +	bit <<= (pattern - 1);

        bit = BIT(pattern - 1) << 3;
> +
> +	while (cnt--) {
> +		data = dp_read(base + DP_MAINLINK_READY);
> +		if (data & bit)
> +			break;

Should there be a sleep in here? Also, consider using readx_poll_timeout instead
of rolling your own polling.

> +	}
> +
> +	if (cnt == 0)
> +		pr_err("set link_train=%d failed\n", pattern);

This function should return an int and report this failure instead of ignoring
it.

> +}
> +
> +static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, bool flip)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +
> +	base = catalog->io->usb3_dp_com.base;
> +
> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x0a);

Again, all of these magic values need to be pulled out into #defines so we know
what the values mean.

> +	dp_write(base + USB3_DP_COM_PHY_MODE_CTRL, 0x02);
> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x01);
> +	/* make sure usb3 com phy software reset is done */
> +	wmb();

Same comments here wrt wmb()

> +
> +	if (!flip) /* CC1 */
> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x02);
> +	else /* CC2 */
> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x03);


        u32 val;
        ...
        val = SOME_DEFINE_THAT_MAKES_SENSE;
        if (flip)
                val |= ANOTHER_DEFINE_THAT_MEANS_FLIP;

        dp_io_write(USB3_DP_COM_TYPEC_CTRL, val);

> +
> +	dp_write(base + USB3_DP_COM_SWI_CTRL, 0x00);
> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x00);
> +	/* make sure the software reset is done */
> +	wmb();
> +
> +	dp_write(base + USB3_DP_COM_POWER_DOWN_CTRL, 0x01);
> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x00);
> +	/* make sure phy is brought out of reset */
> +	wmb();
> +
> +}
> +
> +static void dp_catalog_panel_tpg_cfg(struct dp_catalog_panel *panel,
> +	bool enable)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!panel) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(panel);
> +	base = catalog->io->dp_p0.base;
> +
> +	if (!enable) {
> +		dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x0);
> +		dp_write(base + MMSS_DP_BIST_ENABLE, 0x0);
> +		dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x0);
> +		wmb(); /* ensure Timing generator is turned off */
> +		return;
> +	}

There's really no reason to have both the enable + disable path in the same
function, they don't share any code (aside from writing a few different values
to the same registers). Could you please split this function into a
timing_generator_disable and timing_generator_enable?

> +
> +	dp_write(base + MMSS_DP_INTF_CONFIG, 0x0);
> +	dp_write(base + MMSS_DP_INTF_HSYNC_CTL, panel->hsync_ctl);
> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F0, panel->vsync_period *
> +			panel->hsync_period);
> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0, panel->v_sync_width *
> +			panel->hsync_period);
> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_DISPLAY_HCTL, panel->display_hctl);
> +	dp_write(base + MMSS_DP_INTF_ACTIVE_HCTL, 0);
> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F0, panel->display_v_start);
> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F0, panel->display_v_end);
> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F0, 0);
> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F0, 0);
> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F1, 0);
> +	dp_write(base + MMSS_DP_INTF_POLARITY_CTL, 0);
> +	wmb(); /* ensure TPG registers are programmed */
> +
> +	dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x100);
> +	dp_write(base + MMSS_DP_TPG_VIDEO_CONFIG, 0x5);
> +	wmb(); /* ensure TPG config is programmed */
> +	dp_write(base + MMSS_DP_BIST_ENABLE, 0x1);
> +	dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x1);
> +	wmb(); /* ensure Timing generator is turned on */
> +	pr_debug("%s: enabled tpg\n", __func__);
> +}
> +
> +static void dp_catalog_ctrl_reset(struct dp_catalog_ctrl *ctrl)
> +{
> +	u32 sw_reset;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_ahb.base;
> +
> +	sw_reset = dp_read(base + DP_SW_RESET);
> +
> +	sw_reset |= BIT(0);

Should be a #define

> +	dp_write(base + DP_SW_RESET, sw_reset);
> +	usleep_range(1000, 1010); /* h/w recommended delay */

Same comment here regarding the 10us range

> +
> +	sw_reset &= ~BIT(0);
> +	dp_write(base + DP_SW_RESET, sw_reset);
> +}
> +
> +static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl *ctrl)
> +{
> +	u32 data;
> +	int cnt = 10;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_link.base;
> +
> +	while (--cnt) {
> +		/* DP_MAINLINK_READY */
> +		data = dp_read(base + DP_MAINLINK_READY);
> +		if (data & BIT(0))
> +			return true;
> +
> +		usleep_range(1000, 1010); /* 1ms wait before next reg read */

Same comment here regarding using readx_poll_timeout wrapped in a helper, also
10us comment.

> +	}
> +	pr_err("mainlink not ready\n");
> +end:
> +	return false;
> +}
> +
> +static void dp_catalog_ctrl_enable_irq(struct dp_catalog_ctrl *ctrl,
> +						bool enable)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_ahb.base;
> +
> +	if (enable) {
> +		dp_write(base + DP_INTR_STATUS, DP_INTR_MASK1);
> +		dp_write(base + DP_INTR_STATUS2, DP_INTR_MASK2);
> +	} else {
> +		dp_write(base + DP_INTR_STATUS, 0x00);
> +		dp_write(base + DP_INTR_STATUS2, 0x00);
> +	}
> +}
> +
> +static void dp_catalog_ctrl_hpd_config(struct dp_catalog_ctrl *ctrl, bool en)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_aux.base;
> +
> +	if (en) {
> +		u32 reftimer = dp_read(base + DP_DP_HPD_REFTIMER);
> +
> +		dp_write(base + DP_DP_HPD_INT_ACK, 0xF);
> +		dp_write(base + DP_DP_HPD_INT_MASK, 0xF);
> +
> +		/* Enabling REFTIMER */
> +		reftimer |= BIT(16);

You don't use this anywhere?

> +		dp_write(base + DP_DP_HPD_REFTIMER, 0xF);
> +		/* Enable HPD */
> +		dp_write(base + DP_DP_HPD_CTRL, 0x1);
> +	} else {
> +		/*Disable HPD */

Space after *

> +		dp_write(base + DP_DP_HPD_CTRL, 0x0);
> +	}
> +}
> +
> +static void dp_catalog_ctrl_get_interrupt(struct dp_catalog_ctrl *ctrl)
> +{
> +	u32 ack = 0;
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_ahb.base;
> +
> +	ctrl->isr = dp_read(base + DP_INTR_STATUS2);

This value should just get returned instead of being stored.

> +	ctrl->isr &= ~DP_INTR_MASK2;

Unmasking the interrupts should not be returned from this function, it should
be part of the ack below.

> +	ack = ctrl->isr & DP_INTERRUPT_STATUS2;

And this does the above unmask already, so you can just turf it.

> +	ack <<= 1;
> +	ack |= DP_INTR_MASK2;

Instead of rolling the ack code yourself, I'd prefer what you did with _MASK,
where you define DP_INTERRUPT_STATUS2_ACK above and just do a bitwise-OR to add
the acks here. Without the register map in front of me, it would take a while
to figure out what you're trying to accomplish.

> +	dp_write(base + DP_INTR_STATUS2, ack);
> +}
> +
> +static void dp_catalog_ctrl_phy_reset(struct dp_catalog_ctrl *ctrl)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base = catalog->io->dp_ahb.base;
> +
> +	dp_write(base + DP_PHY_CTRL, 0x5); /* bit 0 & 2 */

The comment doesn't help here, please #define these bits

> +	usleep_range(1000, 1010); /* h/w recommended delay */

Same comment re: delay range

> +	dp_write(base + DP_PHY_CTRL, 0x0);
> +	wmb(); /* make sure PHY reset done */

Same comment re: wmb

> +}
> +
> +static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl *ctrl,
> +		bool flipped, u8 ln_cnt)
> +{
> +	u32 info = 0x0;
> +	struct dp_catalog_private *catalog;
> +	u8 orientation = BIT(!!flipped);
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +
> +	info |= (ln_cnt & 0x0F);

Remove the | and just make this an assignment (and you can remove the
initialization to 0 above)

> +	info |= ((orientation & 0x0F) << 4);
> +	pr_debug("Shared Info = 0x%x\n", info);
> +
> +	dp_write(catalog->io->phy_io.base + DP_PHY_SPARE0, info);
> +}
> +
> +static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl *ctrl,
> +		u8 v_level, u8 p_level)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base0, *base1;
> +	u8 value0, value1;

Can we please pick better names for these?!

> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +	base0 = catalog->io->ln_tx0_io.base;
> +	base1 = catalog->io->ln_tx1_io.base;
> +
> +	pr_debug("hw: v=%d p=%d\n", v_level, p_level);
> +
> +	value0 = vm_voltage_swing[v_level][p_level];
> +	value1 = vm_pre_emphasis[v_level][p_level];
> +
> +	/* program default setting first */

Why do you need to do this?

> +	dp_write(base0 + TXn_TX_DRV_LVL, 0x2A);
> +	dp_write(base1 + TXn_TX_DRV_LVL, 0x2A);
> +	dp_write(base0 + TXn_TX_EMP_POST1_LVL, 0x20);
> +	dp_write(base1 + TXn_TX_EMP_POST1_LVL, 0x20);

#define these magic values

> +
> +	/* Enable MUX to use Cursor values from these registers */
> +	value0 |= BIT(5);
> +	value1 |= BIT(5);

#define these bits please

> +
> +	/* Configure host and panel only if both values are allowed */
> +	if (value0 != 0xFF && value1 != 0xFF) {

You can check this a lot earlier in the function.

> +		dp_write(base0 + TXn_TX_DRV_LVL, value0);
> +		dp_write(base1 + TXn_TX_DRV_LVL, value0);
> +		dp_write(base0 + TXn_TX_EMP_POST1_LVL, value1);
> +		dp_write(base1 + TXn_TX_EMP_POST1_LVL, value1);
> +
> +		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
> +			value0, value1);
> +	} else {
> +		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
> +			v_level, value0, p_level, value1);

Seems like returning an error in this case would be useful

> +	}
> +}
> +
> +static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl *ctrl,
> +			u32 pattern)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 value = 0x0;
> +	void __iomem *base = NULL;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_STATE_CTRL, 0x0);

Do you really need to do this?

> +
> +	switch (pattern) {
> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
> +		dp_write(base + DP_STATE_CTRL, 0x1);
> +		break;
> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
> +		value &= ~(1 << 16);
> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> +		value |= 0xFC;
> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
> +		dp_write(base + DP_STATE_CTRL, 0x10);
> +		break;
> +	case DP_TEST_PHY_PATTERN_PRBS7:
> +		dp_write(base + DP_STATE_CTRL, 0x20);
> +		break;
> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
> +		dp_write(base + DP_STATE_CTRL, 0x40);
> +		/* 00111110000011111000001111100000 */
> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG0, 0x3E0F83E0);
> +		/* 00001111100000111110000011111000 */
> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG1, 0x0F83E0F8);
> +		/* 1111100000111110 */
> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG2, 0x0000F83E);
> +		break;
> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
> +		value = BIT(16);
> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> +		value |= 0xFC;
> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
> +		dp_write(base + DP_STATE_CTRL, 0x10);

This code is the exact same as the case for DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT, aside from BIT(16) vs ~BIT(16). Can you please combine these cases
and share code?

> +		break;
> +	default:
> +		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
> +		return;
> +	}

All of the DP_STATE_CTRL values should be #defined, and you can move the write
down here instead of duplicating it everywhere (with
DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN writing a 0).

> +
> +	/* Make sure the test pattern is programmed in the hardware */
> +	wmb();
> +}
> +
> +static u32 dp_catalog_ctrl_read_phy_pattern(struct dp_catalog_ctrl *ctrl)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base = NULL;
> +
> +	if (!ctrl) {
> +		pr_err("invalid input\n");
> +		return 0;
> +	}
> +
> +	dp_catalog_get_priv(ctrl);
> +
> +	base = catalog->io->dp_link.base;
> +
> +	return dp_read(base + DP_MAINLINK_READY);
> +}
> +
> +/* panel related catalog functions */
> +static int dp_catalog_panel_timing_cfg(struct dp_catalog_panel *panel)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +
> +	if (!panel) {
> +		pr_err("invalid input\n");
> +		goto end;
> +	}
> +
> +	dp_catalog_get_priv(panel);
> +	base = catalog->io->dp_link.base;
> +
> +	dp_write(base + DP_TOTAL_HOR_VER, panel->total);
> +	dp_write(base + DP_START_HOR_VER_FROM_SYNC, panel->sync_start);
> +	dp_write(base + DP_HSYNC_VSYNC_WIDTH_POLARITY, panel->width_blanking);
> +	dp_write(base + DP_ACTIVE_HOR_VER, panel->dp_active);
> +end:

useless label, but it'll probably go away when you strip out all of the
unnecessary NULL checks from the driver.

> +	return 0;
> +}
> +
> +static void dp_catalog_audio_init(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	static u32 sdp_map[][DP_AUDIO_SDP_HEADER_MAX] = {
> +		{
> +			MMSS_DP_AUDIO_STREAM_0,
> +			MMSS_DP_AUDIO_STREAM_1,
> +			MMSS_DP_AUDIO_STREAM_1,
> +		},
> +		{
> +			MMSS_DP_AUDIO_TIMESTAMP_0,
> +			MMSS_DP_AUDIO_TIMESTAMP_1,
> +			MMSS_DP_AUDIO_TIMESTAMP_1,
> +		},
> +		{
> +			MMSS_DP_AUDIO_INFOFRAME_0,
> +			MMSS_DP_AUDIO_INFOFRAME_1,
> +			MMSS_DP_AUDIO_INFOFRAME_1,
> +		},
> +		{
> +			MMSS_DP_AUDIO_COPYMANAGEMENT_0,
> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
> +		},
> +		{
> +			MMSS_DP_AUDIO_ISRC_0,
> +			MMSS_DP_AUDIO_ISRC_1,
> +			MMSS_DP_AUDIO_ISRC_1,
> +		},
> +	};
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	catalog->audio_map = sdp_map;

Hmm, this is a bit spooky, we're storing a (non-const) pointer to a static
stack variable. Fortunately this looks like it'll be easy to fix since this
data is only accessed in this file. So move the map into a static const global
and reference it directly when needed (and drop audio_map).

> +}
> +
> +static void dp_catalog_audio_config_sdp(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	u32 sdp_cfg = 0;
> +	u32 sdp_cfg2 = 0;
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +	base = catalog->io->dp_link.base;
> +
> +	sdp_cfg = dp_read(base + MMSS_DP_SDP_CFG);
> +
> +	/* AUDIO_TIMESTAMP_SDP_EN */
> +	sdp_cfg |= BIT(1);
> +	/* AUDIO_STREAM_SDP_EN */
> +	sdp_cfg |= BIT(2);
> +	/* AUDIO_COPY_MANAGEMENT_SDP_EN */
> +	sdp_cfg |= BIT(5);
> +	/* AUDIO_ISRC_SDP_EN  */
> +	sdp_cfg |= BIT(6);
> +	/* AUDIO_INFOFRAME_SDP_EN  */
> +	sdp_cfg |= BIT(20);

#define the values and combine the assignment

> +
> +	pr_debug("sdp_cfg = 0x%x\n", sdp_cfg);
> +	dp_write(base + MMSS_DP_SDP_CFG, sdp_cfg);
> +
> +	sdp_cfg2 = dp_read(base + MMSS_DP_SDP_CFG2);
> +	/* IFRM_REGSRC -> Do not use reg values */
> +	sdp_cfg2 &= ~BIT(0);
> +	/* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
> +	sdp_cfg2 &= ~BIT(1);

The reset value of this register is 0x4, so how can the bits in position 0/1
get flipped? We shouldn't need this code, afaict.

If we do, the same comments regarding #define and combination as above.

> +
> +	pr_debug("sdp_cfg2 = 0x%x\n", sdp_cfg2);
> +	dp_write(base + MMSS_DP_SDP_CFG2, sdp_cfg2);
> +}
> +
> +static void dp_catalog_audio_get_header(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	void __iomem *base;
> +	enum dp_catalog_audio_sdp_type sdp;
> +	enum dp_catalog_audio_header_type header;
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base    = catalog->io->dp_link.base;
> +	sdp_map = catalog->audio_map;
> +	sdp     = audio->sdp_type;
> +	header  = audio->sdp_header;
> +
> +	audio->data = dp_read(base + sdp_map[sdp][header]);
> +}

This function is unused, please remove.

> +
> +static void dp_catalog_audio_set_header(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
> +	void __iomem *base;
> +	enum dp_catalog_audio_sdp_type sdp;
> +	enum dp_catalog_audio_header_type header;
> +	u32 data;
> +
> +	if (!audio)
> +		return;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base    = catalog->io->dp_link.base;
> +	sdp_map = catalog->audio_map;
> +	sdp     = audio->sdp_type;
> +	header  = audio->sdp_header;
> +	data    = audio->data;
> +
> +	dp_write(base + sdp_map[sdp][header], data);
> +}

This function is unused, please remove.

> +
> +static void dp_catalog_audio_config_acr(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	u32 acr_ctrl, select;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	select = audio->data;
> +	base   = catalog->io->dp_link.base;
> +
> +	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
> +
> +	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
> +
> +	dp_write(base + MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
> +}

This function is unused, please remove.

> +
> +static void dp_catalog_audio_safe_to_exit_level(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	u32 mainlink_levels, safe_to_exit_level;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base   = catalog->io->dp_link.base;
> +	safe_to_exit_level = audio->data;
> +
> +	mainlink_levels = dp_read(base + DP_MAINLINK_LEVELS);
> +	mainlink_levels &= 0xFE0;
> +	mainlink_levels |= safe_to_exit_level;
> +
> +	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
> +			mainlink_levels, safe_to_exit_level);
> +
> +	dp_write(base + DP_MAINLINK_LEVELS, mainlink_levels);
> +}

This function is unused, please remove.

> +
> +static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
> +{
> +	struct dp_catalog_private *catalog;
> +	void __iomem *base;
> +	bool enable;
> +	u32 audio_ctrl;
> +
> +	dp_catalog_get_priv(audio);
> +
> +	base   = catalog->io->dp_link.base;
> +	enable = !!audio->data;
> +
> +	audio_ctrl = dp_read(base + MMSS_DP_AUDIO_CFG);
> +
> +	if (enable)
> +		audio_ctrl |= BIT(0);
> +	else
> +		audio_ctrl &= ~BIT(0);
> +
> +	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
> +	dp_write(base + MMSS_DP_AUDIO_CFG, audio_ctrl);
> +
> +	/* make sure audio engine is disabled */
> +	wmb();
> +}

This function is unused, please remove.

> +
> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io)
> +{
> +	int rc = 0;
> +	struct dp_catalog *dp_catalog;
> +	struct dp_catalog_private *catalog;
> +	struct dp_catalog_aux aux = {
> +		.read_data     = dp_catalog_aux_read_data,
> +		.write_data    = dp_catalog_aux_write_data,
> +		.write_trans   = dp_catalog_aux_write_trans,
> +		.clear_trans   = dp_catalog_aux_clear_trans,
> +		.reset         = dp_catalog_aux_reset,
> +		.update_aux_cfg = dp_catalog_aux_update_cfg,
> +		.enable        = dp_catalog_aux_enable,
> +		.setup         = dp_catalog_aux_setup,
> +		.get_irq       = dp_catalog_aux_get_irq,

Out of these, it seems like write_trans, clear_trans, update_aux_cfg, setup and
get_irq are all unused. Please remove them.

Please also check the other functions to ensure they're used.

> +	};
> +	struct dp_catalog_ctrl ctrl = {
> +		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
> +		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
> +		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
> +		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
> +		.config_misc    = dp_catalog_ctrl_config_misc,
> +		.config_msa     = dp_catalog_ctrl_config_msa,
> +		.set_pattern    = dp_catalog_ctrl_set_pattern,
> +		.reset          = dp_catalog_ctrl_reset,
> +		.usb_reset      = dp_catalog_ctrl_usb_reset,
> +		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
> +		.enable_irq     = dp_catalog_ctrl_enable_irq,
> +		.hpd_config     = dp_catalog_ctrl_hpd_config,
> +		.phy_reset      = dp_catalog_ctrl_phy_reset,
> +		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
> +		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
> +		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
> +		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
> +		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
> +		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,

So, what's the benefit of adding the catalog abstractions? Do you ever have
multiple/alternate implementations of a catalog? It doesn't seem like it. You
should just remove all of the catalog overhead and call the functions directly.

> +	};
> +	struct dp_catalog_audio audio = {
> +		.init       = dp_catalog_audio_init,
> +		.config_acr = dp_catalog_audio_config_acr,
> +		.enable     = dp_catalog_audio_enable,
> +		.config_sdp = dp_catalog_audio_config_sdp,
> +		.set_header = dp_catalog_audio_set_header,
> +		.get_header = dp_catalog_audio_get_header,
> +		.safe_to_exit_level = dp_catalog_audio_safe_to_exit_level,
> +	};
> +	struct dp_catalog_panel panel = {
> +		.timing_cfg = dp_catalog_panel_timing_cfg,
> +		.tpg_config = dp_catalog_panel_tpg_cfg,
> +	};
> +
> +	if (!io) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	catalog  = devm_kzalloc(dev, sizeof(*catalog), GFP_KERNEL);
> +	if (!catalog) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	catalog->dev = dev;
> +	catalog->io = io;
> +
> +	dp_catalog = &catalog->dp_catalog;
> +
> +	dp_catalog->aux   = aux;
> +	dp_catalog->ctrl  = ctrl;
> +	dp_catalog->audio = audio;
> +	dp_catalog->panel = panel;
> +
> +	return dp_catalog;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_catalog_put(struct dp_catalog *dp_catalog)
> +{
> +	struct dp_catalog_private *catalog;
> +
> +	if (!dp_catalog)
> +		return;
> +
> +	catalog = container_of(dp_catalog, struct dp_catalog_private,
> +				dp_catalog);
> +
> +	devm_kfree(catalog->dev, catalog);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h b/drivers/gpu/drm/msm/dp/dp_catalog.h
> new file mode 100644
> index 0000000..58951df
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
> @@ -0,0 +1,144 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_CATALOG_H_
> +#define _DP_CATALOG_H_
> +
> +#include "dp_parser.h"
> +
> +/* interrupts */
> +#define DP_INTR_HPD		BIT(0)
> +#define DP_INTR_AUX_I2C_DONE	BIT(3)
> +#define DP_INTR_WRONG_ADDR	BIT(6)
> +#define DP_INTR_TIMEOUT		BIT(9)
> +#define DP_INTR_NACK_DEFER	BIT(12)
> +#define DP_INTR_WRONG_DATA_CNT	BIT(15)
> +#define DP_INTR_I2C_NACK	BIT(18)
> +#define DP_INTR_I2C_DEFER	BIT(21)
> +#define DP_INTR_PLL_UNLOCKED	BIT(24)
> +#define DP_INTR_AUX_ERROR	BIT(27)
> +
> +#define DP_INTR_READY_FOR_VIDEO		BIT(0)
> +#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
> +#define DP_INTR_FRAME_END		BIT(6)
> +#define DP_INTR_CRC_UPDATED		BIT(9)
> +
> +struct dp_catalog_aux {
> +	u32 data;
> +	u32 isr;
> +
> +	u32 (*read_data)(struct dp_catalog_aux *aux);
> +	int (*write_data)(struct dp_catalog_aux *aux);
> +	int (*write_trans)(struct dp_catalog_aux *aux);
> +	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
> +	void (*reset)(struct dp_catalog_aux *aux);
> +	void (*enable)(struct dp_catalog_aux *aux, bool enable);
> +	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
> +	void (*setup)(struct dp_catalog_aux *aux,
> +			struct dp_aux_cfg *aux_cfg);
> +	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
> +};
> +
> +struct dp_catalog_ctrl {
> +	u32 dp_tu;
> +	u32 valid_boundary;
> +	u32 valid_boundary2;
> +	u32 isr;
> +
> +	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
> +	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
> +	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
> +	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
> +	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
> +				u32 stream_rate_khz, bool fixed_nvid);
> +	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
> +	void (*reset)(struct dp_catalog_ctrl *ctrl);
> +	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
> +	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
> +	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
> +	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
> +	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
> +				u8 lane_cnt);
> +	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
> +				u8 p_level);
> +	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
> +	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
> +	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
> +			u32 pattern);
> +	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
> +};
> +
> +enum dp_catalog_audio_sdp_type {
> +	DP_AUDIO_SDP_STREAM,
> +	DP_AUDIO_SDP_TIMESTAMP,
> +	DP_AUDIO_SDP_INFOFRAME,
> +	DP_AUDIO_SDP_COPYMANAGEMENT,
> +	DP_AUDIO_SDP_ISRC,
> +	DP_AUDIO_SDP_MAX,
> +};
> +
> +enum dp_catalog_audio_header_type {
> +	DP_AUDIO_SDP_HEADER_1,
> +	DP_AUDIO_SDP_HEADER_2,
> +	DP_AUDIO_SDP_HEADER_3,
> +	DP_AUDIO_SDP_HEADER_MAX,
> +};
> +
> +struct dp_catalog_audio {
> +	enum dp_catalog_audio_sdp_type sdp_type;
> +	enum dp_catalog_audio_header_type sdp_header;
> +	u32 data;
> +
> +	void (*init)(struct dp_catalog_audio *audio);
> +	void (*enable)(struct dp_catalog_audio *audio);
> +	void (*config_acr)(struct dp_catalog_audio *audio);
> +	void (*config_sdp)(struct dp_catalog_audio *audio);
> +	void (*set_header)(struct dp_catalog_audio *audio);
> +	void (*get_header)(struct dp_catalog_audio *audio);
> +	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);

None of these are called? So get rid of this entire structure, the functions
that aren't called, and the audio enums above.

> +};
> +
> +struct dp_catalog_panel {
> +	u32 total;
> +	u32 sync_start;
> +	u32 width_blanking;
> +	u32 dp_active;
> +
> +	/* TPG */
> +	u32 hsync_period;
> +	u32 vsync_period;
> +	u32 display_v_start;
> +	u32 display_v_end;
> +	u32 v_sync_width;
> +	u32 hsync_ctl;
> +	u32 display_hctl;

All of this information is already available from drm core, so it can go.

> +
> +	int (*timing_cfg)(struct dp_catalog_panel *panel);
> +	void (*tpg_config)(struct dp_catalog_panel *panel, bool enable);

As suggested elsewhere, these functions should just be called directly wherever
applicable. So we can get rid of this struct.

> +};
> +
> +struct dp_catalog {
> +	struct dp_catalog_aux aux;
> +	struct dp_catalog_ctrl ctrl;
> +	struct dp_catalog_audio audio;
> +	struct dp_catalog_panel panel;
> +};
> +
> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io *io);
> +void dp_catalog_put(struct dp_catalog *catalog);

As mentioned above, all of this should be removed. We can just call the
functions directly.

> +
> +#endif /* _DP_CATALOG_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> new file mode 100644
> index 0000000..08a52f5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> @@ -0,0 +1,1475 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/types.h>
> +#include <linux/completion.h>
> +#include <linux/delay.h>
> +
> +#include "dp_ctrl.h"
> +
> +#define DP_KHZ_TO_HZ 1000
> +
> +#define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
> +#define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
> +
> +/* dp state ctrl */
> +#define ST_TRAIN_PATTERN_1		BIT(0)
> +#define ST_TRAIN_PATTERN_2		BIT(1)
> +#define ST_TRAIN_PATTERN_3		BIT(2)
> +#define ST_TRAIN_PATTERN_4		BIT(3)
> +#define ST_SYMBOL_ERR_RATE_MEASUREMENT	BIT(4)
> +#define ST_PRBS7			BIT(5)
> +#define ST_CUSTOM_80_BIT_PATTERN	BIT(6)
> +#define ST_SEND_VIDEO			BIT(7)
> +#define ST_PUSH_IDLE			BIT(8)

I'd like to see these defined with DP_STATE_CTRL (and s/ST/DP_STATE_CTRL/).

> +
> +#define MR_LINK_TRAINING1  0x8
> +#define MR_LINK_SYMBOL_ERM 0x80
> +#define MR_LINK_PRBS7 0x100
> +#define MR_LINK_CUSTOM80 0x200
> +
> +struct dp_vc_tu_mapping_table {
> +	u32 vic;
> +	u8 lanes;
> +	u8 lrate; /* DP_LINK_RATE -> 162(6), 270(10), 540(20), 810 (30) */
> +	u8 bpp;
> +	u8 valid_boundary_link;
> +	u16 delay_start_link;
> +	bool boundary_moderation_en;
> +	u8 valid_lower_boundary_link;
> +	u8 upper_boundary_count;
> +	u8 lower_boundary_count;
> +	u8 tu_size_minus1;

Please check this struct for unused members, there are at least a couple.

> +};
> +
> +struct dp_ctrl_private {
> +	struct dp_ctrl dp_ctrl;
> +
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_panel *panel;
> +	struct dp_link *link;
> +	struct dp_power *power;
> +	struct dp_parser *parser;
> +	struct dp_catalog_ctrl *catalog;

Once you remove struct dp_ctrl and call the functions directly, I suspect you
can get rid of all of these.

> +
> +	struct completion idle_comp;
> +	struct completion video_comp;
> +
> +	bool orientation;
> +	atomic_t aborted;
> +
> +	u32 pixel_rate;
> +	u32 vic;

'u32 vic' shows up in 3 places in this driver, but there is not one use of any
vic :) Please remove from here and elsewhere.

> +};
> +
> +enum notification_status {
> +	NOTIFY_UNKNOWN,
> +	NOTIFY_CONNECT,
> +	NOTIFY_DISCONNECT,
> +	NOTIFY_CONNECT_IRQ_HPD,
> +	NOTIFY_DISCONNECT_IRQ_HPD,
> +};

Unused, please remove.

> +
> +static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
> +{
> +	pr_debug("idle_patterns_sent\n");
> +	complete(&ctrl->idle_comp);
> +}
> +
> +static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
> +{
> +	pr_debug("dp_video_ready\n");
> +	complete(&ctrl->video_comp);
> +}

These functions don't provide value, please remove and just call complete()
directly.

> +
> +static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);

JFYI, this is sprinkled everywhere, would be a good candidate for an inline
function. Since dp_ctrl can be removed, it's kind of a moot point now.

> +
> +	atomic_set(&ctrl->aborted, 1);
> +}
> +
> +static void dp_ctrl_state_ctrl(struct dp_ctrl_private *ctrl, u32 state)
> +{
> +	ctrl->catalog->state_ctrl(ctrl->catalog, state);

No need to wrap this in a function

> +}
> +
> +static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
> +{
> +	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;

This should be #define'd outside of the functioninstead. Also, why the '_ms_'
suffix? The units are in jiffies.

I think something like

#define IDLE_PATTERN_COMPLETION_TIMEOUT_JIFFIES (30 * HZ / 1000) /* 30 ms */

would be clearer.

> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	reinit_completion(&ctrl->idle_comp);

This function is called from a bunch of places, and idle_comp is also used in a
bunch of places. Are you certain this is thread-safe if you have concurrent
callers or users of idle_comp?

> +	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
> +
> +	if (!wait_for_completion_timeout(&ctrl->idle_comp,
> +			idle_pattern_completion_timeout_ms))
> +		pr_warn("PUSH_IDLE pattern timedout\n");

Return an error?

> +
> +	pr_debug("mainlink off done\n");
> +}
> +
> +static void dp_ctrl_config_ctrl(struct dp_ctrl_private *ctrl)
> +{
> +	u32 config = 0, tbd;
> +	u8 *dpcd = ctrl->panel->dpcd;
> +
> +	config |= (2 << 13); /* Default-> LSCLK DIV: 1/4 LCLK  */

#define value

> +	config |= (0 << 11); /* RGB */

This is a no-op, can be removed

> +
> +	/* Scrambler reset enable */
> +	if (dpcd[DP_EDP_CONFIGURATION_CAP] & DP_ALTERNATE_SCRAMBLER_RESET_CAP)
> +		config |= (1 << 10);
> +
> +	tbd = ctrl->link->get_test_bits_depth(ctrl->link,
> +			ctrl->panel->pinfo.bpp);
> +
> +	if (tbd == DP_TEST_BIT_DEPTH_UNKNOWN)

Should we print a debug message here?

> +		tbd = DP_TEST_BIT_DEPTH_8;
> +
> +	config |= tbd << 8;
> +
> +	/* Num of Lanes */
> +	config |= ((ctrl->link->link_params.lane_count - 1) << 4);

These shift values should be #defined

> +
> +	if (drm_dp_enhanced_frame_cap(dpcd))
> +		config |= 0x40;

#define 0x40

> +
> +	config |= 0x04; /* progressive video */
> +
> +	config |= 0x03;	/* sycn clock & static Mvid */

And these, plus s/sycn/sync/

> +
> +	ctrl->catalog->config_ctrl(ctrl->catalog, config);
> +}
> +
> +/**
> + * dp_ctrl_configure_source_params() - configures DP transmitter source params
> + * @ctrl: Display Port Driver data
> + *
> + * Configures the DP transmitter source params including details such as lane
> + * configuration, output format and sink/panel timing information.
> + */
> +static void dp_ctrl_configure_source_params(struct dp_ctrl_private *ctrl)
> +{
> +	u32 cc, tb;
> +
> +	ctrl->catalog->lane_mapping(ctrl->catalog);
> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);

We go through ctrl->catalog->callback_hook to call a function that is specific
to ctrl and only called in this file. It could easily just be a static function
without having to go through 2 structs and a callback hook.

> +
> +	dp_ctrl_config_ctrl(ctrl);
> +
> +	tb = ctrl->link->get_test_bits_depth(ctrl->link,
> +		ctrl->panel->pinfo.bpp);
> +	cc = ctrl->link->get_colorimetry_config(ctrl->link);
> +	ctrl->catalog->config_misc(ctrl->catalog, cc, tb);

Same comments with these hooks, they're only called from this file. I'll stop
harping on this, but could we please remove the layers of indirection and just
embed and call functions as appropriate?

> +	ctrl->panel->timing_cfg(ctrl->panel);
> +}
> +
> +static void dp_ctrl_get_extra_req_bytes(u64 result_valid,
> +					int valid_bdary_link,
> +					u64 value1, u64 value2,
> +					bool *negative, u64 *result,
> +					u64 compare)
> +{
> +	*negative = false;
> +	if (result_valid >= compare) {
> +		if (valid_bdary_link
> +				>= compare)
> +			*result = value1 + value2;
> +		else {
> +			if (value1 < value2)
> +				*negative = true;
> +			*result = (value1 >= value2) ?
> +				(value1 - value2) : (value2 - value1);
> +		}
> +	} else {
> +		if (valid_bdary_link
> +				>= compare) {
> +			if (value1 >= value2)
> +				*negative = true;
> +			*result = (value1 >= value2) ?
> +				(value1 - value2) : (value2 - value1);
> +		} else {
> +			*result = value1 + value2;
> +			*negative = true;
> +		}
> +	}

I think this can be simplified to the following, it's still super hard to
follow, but I'm not sure if that can be helped.

        bool result_bigger = result_valid >= compare;
        bool valid_bdary_bigger = valid_bdary_link >= compare;

	if (result_bigger && valid_bdary_bigger ||
            !result_bigger && !valid_bdary_bigger) {
                *negative = !valid_bdary_bigger;
                return value1 + value2;
        }

        *negative = (result_bigger && !valid_bdary_bigger && value1 < value2) ||
                    (!result_bigger && valid_bdary_bigger && value1 >= value2);
        return max(value1, value2) - min(value1, value2);

I don't know. The more I stare at this the less convinced I become that it's
better. So take it or leave it. At the very least you can collapse the

if (cond)
        *negative = true;

to

*negative = cond;

and do the max(v,v) - min(v,v) trick to shave off some of the conditionals in
the original.


> +}
> +
> +static u64 roundup_u64(u64 x, u64 y)
> +{
> +	x += (y - 1);
> +	return (div64_ul(x, y) * y);
> +}

Please replace all usage with DIV_ROUND_UP_ULL

> +
> +static u64 rounddown_u64(u64 x, u64 y)
> +{
> +	u64 rem;
> +
> +	div64_u64_rem(x, y, &rem);
> +	return (x - rem);
> +}

Please replace all usage with DIV_ROUND_DOWN_ULL

> +
> +static void dp_ctrl_calc_tu_parameters(struct dp_ctrl_private *ctrl,
> +				       struct dp_vc_tu_mapping_table *tu_table)
> +{
> +	u32 multiplier = 1000000;
> +	u64 pclk, lclk;
> +	u8 bpp, ln_cnt;
> +	int run_idx = 0;
> +	u32 lwidth, h_blank;
> +	u32 fifo_empty = 0;
> +	u32 ratio_scale = 1001;
> +	u64 temp, ratio, original_ratio;
> +	u64 temp2, reminder;
> +	u64 temp3, temp4, result = 0;
> +
> +	u64 err = multiplier;
> +	u64 n_err = 0, n_n_err = 0;
> +	bool n_err_neg, nn_err_neg;
> +	u8 hblank_margin = 16;
> +
> +	u8 tu_size, tu_size_desired = 0, tu_size_minus1;
> +	int valid_boundary_link;
> +	u64 resulting_valid;
> +	u64 total_valid;
> +	u64 effective_valid;
> +	u64 effective_valid_recorded;
> +	int n_tus;
> +	int n_tus_per_lane;
> +	int paired_tus;
> +	int remainder_tus;
> +	int remainder_tus_upper, remainder_tus_lower;
> +	int extra_bytes;
> +	int filler_size;
> +	int delay_start_link;
> +	int boundary_moderation_en = 0;
> +	int upper_bdry_cnt = 0;
> +	int lower_bdry_cnt = 0;
> +	int i_upper_bdry_cnt = 0;
> +	int i_lower_bdry_cnt = 0;
> +	int valid_lower_boundary_link = 0;
> +	int even_distribution_bf = 0;
> +	int even_distribution_legacy = 0;
> +	int even_distribution = 0;
> +	int min_hblank = 0;
> +	int extra_pclk_cycles;
> +	u8 extra_pclk_cycle_delay = 4;
> +	int extra_pclk_cycles_in_link_clk;
> +	u64 ratio_by_tu;
> +	u64 average_valid2;
> +	u64 extra_buffer_margin;
> +	int new_valid_boundary_link;
> +
> +	u64 resulting_valid_tmp;
> +	u64 ratio_by_tu_tmp;
> +	int n_tus_tmp;
> +	int extra_pclk_cycles_tmp;
> +	int extra_pclk_cycles_in_lclk_tmp;
> +	int extra_req_bytes_new_tmp;
> +	int filler_size_tmp;
> +	int lower_filler_size_tmp;
> +	int delay_start_link_tmp;
> +	int min_hblank_tmp = 0;
> +	bool extra_req_bytes_is_neg = false;
> +	struct dp_panel_info *pinfo = &ctrl->panel->pinfo;
> +
> +	u8 dp_brute_force = 1;
> +	u64 brute_force_threshold = 10;
> +	u64 diff_abs;


76 stack vars and ~450 lines must be a new record somewhere :)

I'm going to skip reviewing this function and let you split/simplify/reduce it.
Please just make it more readable (comments, docs, helper functions, etc).

> +
> +	ln_cnt =  ctrl->link->link_params.lane_count;
> +
> +	bpp = pinfo->bpp;
> +	lwidth = pinfo->h_active;
> +	h_blank = pinfo->h_back_porch + pinfo->h_front_porch +
> +				pinfo->h_sync_width;
> +	pclk = pinfo->pixel_clk_khz * 1000;
> +
> +	boundary_moderation_en = 0;
> +	upper_bdry_cnt = 0;
> +	lower_bdry_cnt = 0;
> +	i_upper_bdry_cnt = 0;
> +	i_lower_bdry_cnt = 0;
> +	valid_lower_boundary_link = 0;
> +	even_distribution_bf = 0;
> +	even_distribution_legacy = 0;
> +	even_distribution = 0;
> +	min_hblank = 0;
> +
> +	lclk = drm_dp_bw_code_to_link_rate(
> +		ctrl->link->link_params.bw_code) * DP_KHZ_TO_HZ;
> +
> +	pr_debug("pclk=%lld, active_width=%d, h_blank=%d\n",
> +						pclk, lwidth, h_blank);
> +	pr_debug("lclk = %lld, ln_cnt = %d\n", lclk, ln_cnt);
> +	ratio = div64_u64_rem(pclk * bpp * multiplier,
> +				8 * ln_cnt * lclk, &reminder);
> +	ratio = div64_u64((pclk * bpp * multiplier), (8 * ln_cnt * lclk));
> +	original_ratio = ratio;
> +
> +	extra_buffer_margin = roundup_u64(div64_u64(extra_pclk_cycle_delay
> +				* lclk * multiplier, pclk), multiplier);
> +	extra_buffer_margin = div64_u64(extra_buffer_margin, multiplier);
> +
> +	/* To deal with cases where lines are not distributable */
> +	if (((lwidth % ln_cnt) != 0) && ratio < multiplier) {
> +		ratio = ratio * ratio_scale;
> +		ratio = ratio < (1000 * multiplier)
> +				? ratio : (1000 * multiplier);
> +	}
> +	pr_debug("ratio = %lld\n", ratio);
> +
> +	for (tu_size = 32; tu_size <= 64; tu_size++) {
> +		temp = ratio * tu_size;
> +		temp2 = ((temp / multiplier) + 1) * multiplier;
> +		n_err = roundup_u64(temp, multiplier) - temp;
> +
> +		if (n_err < err) {
> +			err = n_err;
> +			tu_size_desired = tu_size;
> +		}
> +	}
> +	pr_debug("Info: tu_size_desired = %d\n", tu_size_desired);
> +
> +	tu_size_minus1 = tu_size_desired - 1;
> +
> +	valid_boundary_link = roundup_u64(ratio * tu_size_desired, multiplier);
> +	valid_boundary_link /= multiplier;
> +	n_tus = rounddown((lwidth * bpp * multiplier)
> +			/ (8 * valid_boundary_link), multiplier) / multiplier;
> +	even_distribution_legacy = n_tus % ln_cnt == 0 ? 1 : 0;
> +	pr_debug("Info: n_symbol_per_tu=%d, number_of_tus=%d\n",
> +					valid_boundary_link, n_tus);
> +
> +	extra_bytes = roundup_u64((n_tus + 1)
> +			* ((valid_boundary_link * multiplier)
> +			- (original_ratio * tu_size_desired)), multiplier);
> +	extra_bytes /= multiplier;
> +	extra_pclk_cycles = roundup(extra_bytes * 8 * multiplier / bpp,
> +			multiplier);
> +	extra_pclk_cycles /= multiplier;
> +	extra_pclk_cycles_in_link_clk = roundup_u64(div64_u64(extra_pclk_cycles
> +				* lclk * multiplier, pclk), multiplier);
> +	extra_pclk_cycles_in_link_clk /= multiplier;
> +	filler_size = roundup_u64((tu_size_desired - valid_boundary_link)
> +						* multiplier, multiplier);
> +	filler_size /= multiplier;
> +	ratio_by_tu = div64_u64(ratio * tu_size_desired, multiplier);
> +
> +	pr_debug("extra_pclk_cycles_in_link_clk=%d, extra_bytes=%d\n",
> +				extra_pclk_cycles_in_link_clk, extra_bytes);
> +	pr_debug("extra_pclk_cycles_in_link_clk=%d\n",
> +				extra_pclk_cycles_in_link_clk);
> +	pr_debug("filler_size=%d, extra_buffer_margin=%lld\n",
> +				filler_size, extra_buffer_margin);
> +
> +	delay_start_link = ((extra_bytes > extra_pclk_cycles_in_link_clk)
> +			? extra_bytes
> +			: extra_pclk_cycles_in_link_clk)
> +				+ filler_size + extra_buffer_margin;
> +	resulting_valid = valid_boundary_link;
> +	pr_debug("Info: delay_start_link=%d, filler_size=%d\n",
> +				delay_start_link, filler_size);
> +	pr_debug("valid_boundary_link=%d ratio_by_tu=%lld\n",
> +				valid_boundary_link, ratio_by_tu);
> +
> +	diff_abs = (resulting_valid >= ratio_by_tu)
> +				? (resulting_valid - ratio_by_tu)
> +				: (ratio_by_tu - resulting_valid);
> +
> +	if (err != 0 && ((diff_abs > brute_force_threshold)
> +			|| (even_distribution_legacy == 0)
> +			|| (dp_brute_force == 1))) {
> +		err = multiplier;
> +		for (tu_size = 32; tu_size <= 64; tu_size++) {
> +			for (i_upper_bdry_cnt = 1; i_upper_bdry_cnt <= 15;
> +						i_upper_bdry_cnt++) {
> +				for (i_lower_bdry_cnt = 1;
> +					i_lower_bdry_cnt <= 15;
> +					i_lower_bdry_cnt++) {
> +					new_valid_boundary_link =
> +						roundup_u64(ratio
> +						* tu_size, multiplier);
> +					average_valid2 = (i_upper_bdry_cnt
> +						* new_valid_boundary_link
> +						+ i_lower_bdry_cnt
> +						* (new_valid_boundary_link
> +							- multiplier))
> +						/ (i_upper_bdry_cnt
> +							+ i_lower_bdry_cnt);
> +					n_tus = rounddown_u64(div64_u64(lwidth
> +						* multiplier * multiplier
> +						* (bpp / 8), average_valid2),
> +							multiplier);
> +					n_tus /= multiplier;
> +					n_tus_per_lane
> +						= rounddown(n_tus
> +							* multiplier
> +							/ ln_cnt, multiplier);
> +					n_tus_per_lane /= multiplier;
> +					paired_tus =
> +						rounddown((n_tus_per_lane)
> +							* multiplier
> +							/ (i_upper_bdry_cnt
> +							+ i_lower_bdry_cnt),
> +							multiplier);
> +					paired_tus /= multiplier;
> +					remainder_tus = n_tus_per_lane
> +							- paired_tus
> +						* (i_upper_bdry_cnt
> +							+ i_lower_bdry_cnt);
> +					if ((remainder_tus
> +						- i_upper_bdry_cnt) > 0) {
> +						remainder_tus_upper
> +							= i_upper_bdry_cnt;
> +						remainder_tus_lower =
> +							remainder_tus
> +							- i_upper_bdry_cnt;
> +					} else {
> +						remainder_tus_upper
> +							= remainder_tus;
> +						remainder_tus_lower = 0;
> +					}
> +					total_valid = paired_tus
> +						* (i_upper_bdry_cnt
> +						* new_valid_boundary_link
> +							+ i_lower_bdry_cnt
> +						* (new_valid_boundary_link
> +							- multiplier))
> +						+ (remainder_tus_upper
> +						* new_valid_boundary_link)
> +						+ (remainder_tus_lower
> +						* (new_valid_boundary_link
> +							- multiplier));
> +					n_err_neg = nn_err_neg = false;
> +					effective_valid
> +						= div_u64(total_valid,
> +							n_tus_per_lane);
> +					n_n_err = (effective_valid
> +							>= (ratio * tu_size))
> +						? (effective_valid
> +							- (ratio * tu_size))
> +						: ((ratio * tu_size)
> +							- effective_valid);
> +					if (effective_valid < (ratio * tu_size))
> +						nn_err_neg = true;
> +					n_err = (average_valid2
> +						>= (ratio * tu_size))
> +						? (average_valid2
> +							- (ratio * tu_size))
> +						: ((ratio * tu_size)
> +							- average_valid2);
> +					if (average_valid2 < (ratio * tu_size))
> +						n_err_neg = true;
> +					even_distribution =
> +						n_tus % ln_cnt == 0 ? 1 : 0;
> +					diff_abs =
> +						resulting_valid >= ratio_by_tu
> +						? (resulting_valid
> +							- ratio_by_tu)
> +						: (ratio_by_tu
> +							- resulting_valid);
> +
> +					resulting_valid_tmp = div64_u64(
> +						(i_upper_bdry_cnt
> +						* new_valid_boundary_link
> +						+ i_lower_bdry_cnt
> +						* (new_valid_boundary_link
> +							- multiplier)),
> +						(i_upper_bdry_cnt
> +							+ i_lower_bdry_cnt));
> +					ratio_by_tu_tmp =
> +						original_ratio * tu_size;
> +					ratio_by_tu_tmp /= multiplier;
> +					n_tus_tmp = rounddown_u64(
> +						div64_u64(lwidth
> +						* multiplier * multiplier
> +						* bpp / 8,
> +						resulting_valid_tmp),
> +						multiplier);
> +					n_tus_tmp /= multiplier;
> +
> +					temp3 = (resulting_valid_tmp
> +						>= (original_ratio * tu_size))
> +						? (resulting_valid_tmp
> +						- original_ratio * tu_size)
> +						: (original_ratio * tu_size)
> +						- resulting_valid_tmp;
> +					temp3 = (n_tus_tmp + 1) * temp3;
> +					temp4 = (new_valid_boundary_link
> +						>= (original_ratio * tu_size))
> +						? (new_valid_boundary_link
> +							- original_ratio
> +							* tu_size)
> +						: (original_ratio * tu_size)
> +						- new_valid_boundary_link;
> +					temp4 = (i_upper_bdry_cnt
> +							* ln_cnt * temp4);
> +
> +					temp3 = roundup_u64(temp3, multiplier);
> +					temp4 = roundup_u64(temp4, multiplier);
> +					dp_ctrl_get_extra_req_bytes
> +						(resulting_valid_tmp,
> +						new_valid_boundary_link,
> +						temp3, temp4,
> +						&extra_req_bytes_is_neg,
> +						&result,
> +						(original_ratio * tu_size));
> +					extra_req_bytes_new_tmp
> +						= div64_ul(result, multiplier);
> +					if ((extra_req_bytes_is_neg)
> +						&& (extra_req_bytes_new_tmp
> +							> 1))
> +						extra_req_bytes_new_tmp
> +						= extra_req_bytes_new_tmp - 1;
> +					if (extra_req_bytes_new_tmp == 0)
> +						extra_req_bytes_new_tmp = 1;
> +					extra_pclk_cycles_tmp =
> +						(u64)(extra_req_bytes_new_tmp
> +						      * 8 * multiplier) / bpp;
> +					extra_pclk_cycles_tmp /= multiplier;
> +
> +					if (extra_pclk_cycles_tmp <= 0)
> +						extra_pclk_cycles_tmp = 1;
> +					extra_pclk_cycles_in_lclk_tmp =
> +						roundup_u64(div64_u64(
> +							extra_pclk_cycles_tmp
> +							* lclk * multiplier,
> +							pclk), multiplier);
> +					extra_pclk_cycles_in_lclk_tmp
> +						/= multiplier;
> +					filler_size_tmp = roundup_u64(
> +						(tu_size * multiplier *
> +						new_valid_boundary_link),
> +						multiplier);
> +					filler_size_tmp /= multiplier;
> +					lower_filler_size_tmp =
> +						filler_size_tmp + 1;
> +					if (extra_req_bytes_is_neg)
> +						temp3 = (extra_req_bytes_new_tmp
> +						> extra_pclk_cycles_in_lclk_tmp
> +						? extra_pclk_cycles_in_lclk_tmp
> +						: extra_req_bytes_new_tmp);
> +					else
> +						temp3 = (extra_req_bytes_new_tmp
> +						> extra_pclk_cycles_in_lclk_tmp
> +						? extra_req_bytes_new_tmp :
> +						extra_pclk_cycles_in_lclk_tmp);
> +
> +					temp4 = lower_filler_size_tmp
> +						+ extra_buffer_margin;
> +					if (extra_req_bytes_is_neg)
> +						delay_start_link_tmp
> +							= (temp3 >= temp4)
> +							? (temp3 - temp4)
> +							: (temp4 - temp3);
> +					else
> +						delay_start_link_tmp
> +							= temp3 + temp4;
> +
> +					min_hblank_tmp = (int)div64_u64(
> +						roundup_u64(
> +						div64_u64(delay_start_link_tmp
> +						* pclk * multiplier, lclk),
> +						multiplier), multiplier)
> +						+ hblank_margin;
> +
> +					if (((even_distribution == 1)
> +						|| ((even_distribution_bf == 0)
> +						&& (even_distribution_legacy
> +								== 0)))
> +						&& !n_err_neg && !nn_err_neg
> +						&& n_n_err < err
> +						&& (n_n_err < diff_abs
> +						|| (dp_brute_force == 1))
> +						&& (new_valid_boundary_link
> +									- 1) > 0
> +						&& (h_blank >=
> +							(u32)min_hblank_tmp)) {
> +						upper_bdry_cnt =
> +							i_upper_bdry_cnt;
> +						lower_bdry_cnt =
> +							i_lower_bdry_cnt;
> +						err = n_n_err;
> +						boundary_moderation_en = 1;
> +						tu_size_desired = tu_size;
> +						valid_boundary_link =
> +							new_valid_boundary_link;
> +						effective_valid_recorded
> +							= effective_valid;
> +						delay_start_link
> +							= delay_start_link_tmp;
> +						filler_size = filler_size_tmp;
> +						min_hblank = min_hblank_tmp;
> +						n_tus = n_tus_tmp;
> +						even_distribution_bf = 1;
> +
> +						pr_debug("upper_bdry_cnt=%d, lower_boundary_cnt=%d, err=%lld, tu_size_desired=%d, valid_boundary_link=%d, effective_valid=%lld\n",
> +							upper_bdry_cnt,
> +							lower_bdry_cnt, err,
> +							tu_size_desired,
> +							valid_boundary_link,
> +							effective_valid);
> +					}
> +				}
> +			}
> +		}
> +
> +		if (boundary_moderation_en == 1) {
> +			resulting_valid = (u64)(upper_bdry_cnt
> +					*valid_boundary_link + lower_bdry_cnt
> +					* (valid_boundary_link - 1))
> +					/ (upper_bdry_cnt + lower_bdry_cnt);
> +			ratio_by_tu = original_ratio * tu_size_desired;
> +			valid_lower_boundary_link =
> +				(valid_boundary_link / multiplier) - 1;
> +
> +			tu_size_minus1 = tu_size_desired - 1;
> +			even_distribution_bf = 1;
> +			valid_boundary_link /= multiplier;
> +			pr_debug("Info: Boundary_moderation enabled\n");
> +		}
> +	}
> +
> +	min_hblank = ((int) roundup_u64(div64_u64(delay_start_link * pclk
> +			* multiplier, lclk), multiplier))
> +			/ multiplier + hblank_margin;
> +	if (h_blank < (u32)min_hblank) {
> +		pr_debug(" WARNING: run_idx=%d Programmed h_blank %d is smaller than the min_hblank %d supported.\n",
> +					run_idx, h_blank, min_hblank);
> +	}
> +
> +	if (fifo_empty)	{
> +		tu_size_minus1 = 31;
> +		valid_boundary_link = 32;
> +		delay_start_link = 0;
> +		boundary_moderation_en = 0;
> +	}
> +
> +	pr_debug("tu_size_minus1=%d valid_boundary_link=%d delay_start_link=%d boundary_moderation_en=%d\n upper_boundary_cnt=%d lower_boundary_cnt=%d valid_lower_boundary_link=%d min_hblank=%d\n",
> +		tu_size_minus1, valid_boundary_link, delay_start_link,
> +		boundary_moderation_en, upper_bdry_cnt, lower_bdry_cnt,
> +		valid_lower_boundary_link, min_hblank);
> +
> +	tu_table->valid_boundary_link = valid_boundary_link;
> +	tu_table->delay_start_link = delay_start_link;
> +	tu_table->boundary_moderation_en = boundary_moderation_en;
> +	tu_table->valid_lower_boundary_link = valid_lower_boundary_link;
> +	tu_table->upper_boundary_count = upper_bdry_cnt;
> +	tu_table->lower_boundary_count = lower_bdry_cnt;
> +	tu_table->tu_size_minus1 = tu_size_minus1;
> +}
> +
> +static void dp_ctrl_setup_tr_unit(struct dp_ctrl_private *ctrl)
> +{
> +	u32 dp_tu = 0x0;
> +	u32 valid_boundary = 0x0;
> +	u32 valid_boundary2 = 0x0;
> +	struct dp_vc_tu_mapping_table tu_calc_table;
> +
> +	dp_ctrl_calc_tu_parameters(ctrl, &tu_calc_table);
> +
> +	dp_tu |= tu_calc_table.tu_size_minus1;
> +	valid_boundary |= tu_calc_table.valid_boundary_link;
> +	valid_boundary |= (tu_calc_table.delay_start_link << 16);
> +
> +	valid_boundary2 |= (tu_calc_table.valid_lower_boundary_link << 1);
> +	valid_boundary2 |= (tu_calc_table.upper_boundary_count << 16);
> +	valid_boundary2 |= (tu_calc_table.lower_boundary_count << 20);
> +
> +	if (tu_calc_table.boundary_moderation_en)
> +		valid_boundary2 |= BIT(0);
> +
> +	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
> +			dp_tu, valid_boundary, valid_boundary2);
> +
> +	ctrl->catalog->dp_tu = dp_tu;
> +	ctrl->catalog->valid_boundary = valid_boundary;
> +	ctrl->catalog->valid_boundary2 = valid_boundary2;
> +
> +	ctrl->catalog->update_transfer_unit(ctrl->catalog);

Again here, if you just call the function directly, you can avoid the callback.
If you add function arguments, you can avoid having to store dp_tu/valid_boundary/
valid_boundary2 entirely.

> +}
> +
> +static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);

Break out the timeout into a #define

> +	if (ret <= 0) {
> +		pr_err("Link Train timedout\n");
> +		ret = -EINVAL;
> +	}
> +
> +	return ret;

You're not checking the return value at the callsite.

> +}
> +
> +static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl,
> +				     u32 voltage_level, u32 pre_emphasis_level)

I don't think this needs to be a function, just move it all into
dp_ctrl_update_vx_px.

> +{
> +	int i;
> +	u8 buf[4];
> +	u32 max_level_reached = 0;
> +
> +	if (voltage_level == DP_LINK_VOLTAGE_MAX) {
> +		pr_debug("max. voltage swing level reached %d\n",
> +				voltage_level);
> +		max_level_reached |= BIT(2);

        DP_TRAIN_MAX_SWING_REACHED

> +	}
> +
> +	if (pre_emphasis_level == DP_LINK_PRE_EMPHASIS_MAX) {
> +		pr_debug("max. pre-emphasis level reached %d\n",
> +				pre_emphasis_level);
> +		max_level_reached  |= BIT(5);

        DP_TRAIN_MAX_PRE_EMPHASIS_REACHED

> +	}
> +
> +	pre_emphasis_level <<= 3;

This is DP_TRAIN_PRE_EMPHASIS_SHIFT, but I'm guessing you aren't using the
DP_TRAIN_PRE_EMPH_LEVEL_* values when you set p_level. So the right way to fix
this is to use those #defines and get rid of this shift.

> +
> +	for (i = 0; i < 4; i++)

You shouldn't assume 4 lanes here, use drm_dp_link->num_lanes

> +		buf[i] = voltage_level | pre_emphasis_level | max_level_reached;
> +
> +	pr_debug("sink: p|v=0x%x\n", voltage_level | pre_emphasis_level);
> +	return drm_dp_dpcd_write(ctrl->aux->drm_aux, 0x103, buf, 4);

s/0x103/DP_TRAINING_LANE0_SET/ and s/4/drm_dp_link->num_lanes/

Also, this will return number of bytes transmitted, not (0 || -errno).


> +}
> +
> +static void dp_ctrl_update_vx_px(struct dp_ctrl_private *ctrl)
> +{
> +	struct dp_link *link = ctrl->link;
> +
> +	ctrl->catalog->update_vx_px(ctrl->catalog,
> +		link->phy_params.v_level, link->phy_params.p_level);
> +
> +	dp_ctrl_update_sink_vx_px(ctrl, link->phy_params.v_level,
> +		link->phy_params.p_level);

Fortunately (or unfortunately), the return value isn't checked. So please check
the return value.

> +}
> +
> +static void dp_ctrl_train_pattern_set(struct dp_ctrl_private *ctrl,
> +		u8 pattern)
> +{
> +	u8 buf[4];

Why 4?

> +
> +	pr_debug("sink: pattern=%x\n", pattern);
> +
> +	buf[0] = pattern;
> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_TRAINING_PATTERN_SET, buf, 1);

Check the return value of this and alll drm_dp_dpcd_(read|write) calls.

> +}
> +
> +static int dp_ctrl_read_link_status(struct dp_ctrl_private *ctrl,
> +				    u8 *link_status)
> +{
> +	int ret = 0, len;
> +	u32 const offset = DP_LANE_ALIGN_STATUS_UPDATED - DP_LANE0_1_STATUS;
> +	u32 link_status_read_max_retries = 100;
> +
> +	while (--link_status_read_max_retries) {
> +		len = drm_dp_dpcd_read_link_status(ctrl->aux->drm_aux,
> +			link_status);
> +		if (len != DP_LINK_STATUS_SIZE) {
> +			pr_err("DP link status read failed, err: %d\n", len);
> +			ret = len;
> +			break;

Just return directly here. You can also just drop len and use ret (or drop ret
and use len).

> +		}
> +
> +		if (!(link_status[offset] & DP_LINK_STATUS_UPDATED))
> +			break;

And return 0 directly here

> +	}
> +
> +	return ret;

Here you're returning successful in the timeout case :( Once you convert the above
to direct returns, this can become return -ETIMEDOUT;

I think you should also drop the number of retries drastically.

> +}
> +
> +static int dp_ctrl_link_train_1(struct dp_ctrl_private *ctrl)
> +{
> +	int tries, old_v_level, ret = 0;
> +	u8 link_status[DP_LINK_STATUS_SIZE];
> +	int const maximum_retries = 5;
> +
> +	dp_ctrl_state_ctrl(ctrl, 0);
> +	/* Make sure to clear the current pattern before starting a new one */
> +	wmb();
> +
> +	ctrl->catalog->set_pattern(ctrl->catalog, 0x01);

#define that bit please

> +	dp_ctrl_train_pattern_set(ctrl, DP_TRAINING_PATTERN_1 |
> +		DP_LINK_SCRAMBLING_DISABLE); /* train_1 */

the train_1 comment isn't needed.

> +	dp_ctrl_update_vx_px(ctrl);
> +
> +	tries = 0;
> +	old_v_level = ctrl->link->phy_params.v_level;
> +	while (1) {

Instead of unbounded, this should be:
        for (tries = 0; tries < maximum_retries; tries++) {

You'll need to s/break/return ret/ in the rest of the loop and move the timeout
error to the bottom of the function

> +		drm_dp_link_train_clock_recovery_delay(ctrl->panel->dpcd);
> +
> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
> +		if (ret)
> +			break;
> +
> +		if (drm_dp_clock_recovery_ok(link_status,
> +			ctrl->link->link_params.lane_count)) {
> +			break;
> +		}
> +
> +		if (ctrl->link->phy_params.v_level == DP_LINK_VOLTAGE_MAX) {

Since DP_LINK_VOLTAGE_MAX == DP_LINK_VOLTAGE_LEVEL_2, you'll end up not retrying
LEVEL_2 at all.

> +			pr_err_ratelimited("max v_level reached\n");
> +			ret = -EAGAIN;
> +			break;
> +		}
> +
> +		if (old_v_level == ctrl->link->phy_params.v_level) {
> +			tries++;
> +			if (tries >= maximum_retries) {
> +				pr_err("max tries reached\n");
> +				ret = -ETIMEDOUT;
> +				break;
> +			}
> +		} else {
> +			tries = 0;
> +			old_v_level = ctrl->link->phy_params.v_level;
> +		}
> +
> +		pr_debug("clock recovery not done, adjusting vx px\n");
> +
> +		ctrl->link->adjust_levels(ctrl->link, link_status);
> +		dp_ctrl_update_vx_px(ctrl);
> +	}
> +
> +	return ret;
> +}
> +
> +static int dp_ctrl_link_rate_down_shift(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	if (!ctrl)
> +		return -EINVAL;
> +
> +	switch (ctrl->link->link_params.bw_code) {
> +	case DP_LINK_BW_8_1:
> +		ctrl->link->link_params.bw_code = DP_LINK_BW_5_4;
> +		break;
> +	case DP_LINK_BW_5_4:
> +		ctrl->link->link_params.bw_code = DP_LINK_BW_2_7;
> +		break;
> +	case DP_LINK_BW_2_7:
> +	case DP_LINK_BW_1_62:
> +	default:
> +		ctrl->link->link_params.bw_code = DP_LINK_BW_1_62;
> +		break;
> +	};
> +
> +	pr_debug("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
> +
> +	return ret;
> +}
> +
> +static void dp_ctrl_clear_training_pattern(struct dp_ctrl_private *ctrl)
> +{
> +	dp_ctrl_train_pattern_set(ctrl, 0);


DP_TRAINING_PATTERN_DISABLE


> +	drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
> +}
> +
> +static int dp_ctrl_link_training_2(struct dp_ctrl_private *ctrl)
> +{
> +	int tries = 0, ret = 0;
> +	char pattern;
> +	int const maximum_retries = 5;
> +	u8 link_status[DP_LINK_STATUS_SIZE];
> +
> +	dp_ctrl_state_ctrl(ctrl, 0);
> +	/* Make sure to clear the current pattern before starting a new one */
> +	wmb();
> +
> +	if (drm_dp_tps3_supported(ctrl->panel->dpcd))
> +		pattern = DP_TRAINING_PATTERN_3;
> +	else
> +		pattern = DP_TRAINING_PATTERN_2;
> +
> +	dp_ctrl_update_vx_px(ctrl);
> +	ctrl->catalog->set_pattern(ctrl->catalog, pattern);
> +	dp_ctrl_train_pattern_set(ctrl, pattern | DP_RECOVERED_CLOCK_OUT_EN);
> +
> +	do  {

        for (tries = 0; tries < maximum_retries; tries++)

> +		drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
> +
> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
> +		if (ret)
> +			break;
> +
> +		if (drm_dp_channel_eq_ok(link_status,
> +			ctrl->link->link_params.lane_count))
> +			break;
> +
> +		if (tries > maximum_retries) {
> +			ret = -ETIMEDOUT;
> +			break;
> +		}
> +		tries++;
> +
> +		ctrl->link->adjust_levels(ctrl->link, link_status);
> +		dp_ctrl_update_vx_px(ctrl);
> +	} while (1);
> +
> +	return ret;
> +}
> +
> +static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +	u8 encoding = 0x1;

DP_SET_ANSI_8B10B

> +	struct drm_dp_link link_info = {0};
> +
> +	ctrl->link->phy_params.p_level = 0;
> +	ctrl->link->phy_params.v_level = 0;
> +
> +	dp_ctrl_config_ctrl(ctrl);
> +
> +	link_info.num_lanes = ctrl->link->link_params.lane_count;
> +	link_info.rate = drm_dp_bw_code_to_link_rate(
> +		ctrl->link->link_params.bw_code);
> +	link_info.capabilities = ctrl->panel->link_info.capabilities;

Drop the hand-rolled ctrl->panel->link_info and use drm_dp_link_probe to fill in
drm_dp_link.

> +
> +	drm_dp_link_configure(ctrl->aux->drm_aux, &link_info);
> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_MAIN_LINK_CHANNEL_CODING_SET,
> +				&encoding, 1);
> +
> +	ret = dp_ctrl_link_train_1(ctrl);
> +	if (ret) {
> +		pr_err("link training #1 failed\n");

print ret

> +		goto end;
> +	}
> +
> +	/* print success info as this is a result of user initiated action */
> +	pr_info("link training #1 successful\n");

this should be debug loglevel

> +
> +	ret = dp_ctrl_link_training_2(ctrl);
> +	if (ret) {
> +		pr_err("link training #2 failed\n");

print ret

> +		goto end;
> +	}
> +
> +	/* print success info as this is a result of user initiated action */
> +	pr_info("link training #2 successful\n");

debug loglevel

> +
> +end:
> +	dp_ctrl_state_ctrl(ctrl, 0);
> +	/* Make sure to clear the current pattern before starting a new one */
> +	wmb();

Same comments re: wmb

> +
> +	dp_ctrl_clear_training_pattern(ctrl);
> +	return ret;
> +}
> +
> +static int dp_ctrl_setup_main_link(struct dp_ctrl_private *ctrl, bool train)
> +{
> +	bool mainlink_ready = false;
> +	int ret = 0;
> +
> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
> +
> +	ret = ctrl->link->psm_config(ctrl->link,
> +		&ctrl->panel->link_info, false);

This can fit on one line

> +	if (ret)
> +		goto end;

All of the "goto end"'s can be replaced with "return ret", then delete the end
label.

> +
> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)

You should really protect sink_request with a lock, it's racy. I'm trying
to catch the race conditions while I review, but I'd urge you to audit the
driver for other places that need locking.

> +		goto end;
> +
> +	if (!train)
> +		goto send_video;

Instead of adding the label, just wrap the reset and train calls in an
if (train) {} block.


> +
> +	/*
> +	 * As part of previous calls, DP controller state might have
> +	 * transitioned to PUSH_IDLE. In order to start transmitting a link
> +	 * training pattern, we have to first to a DP software reset.

"we have to first _do_ a..."

> +	 */
> +	ctrl->catalog->reset(ctrl->catalog);
> +
> +	ret = dp_ctrl_link_train(ctrl);
> +	if (ret)
> +		goto end;
> +
> +send_video:
> +	/*
> +	 * Set up transfer unit values and set controller state to send
> +	 * video.
> +	 */
> +	dp_ctrl_setup_tr_unit(ctrl);
> +	ctrl->catalog->state_ctrl(ctrl->catalog, ST_SEND_VIDEO);
> +
> +	dp_ctrl_wait4video_ready(ctrl);

Check return value please

> +	mainlink_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
> +	pr_debug("mainlink %s\n", mainlink_ready ? "READY" : "NOT READY");
> +end:
> +	return ret;
> +}
> +
> +static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
> +				   char *name, u32 rate)
> +{
> +	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
> +	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
> +
> +	while (num && strcmp(cfg->clk_name, name)) {
> +		num--;
> +		cfg++;
> +	}
> +
> +	pr_debug("setting rate=%d on clk=%s\n", rate, name);
> +
> +	if (num)
> +		cfg->rate = rate;
> +	else
> +		pr_err("%s clock could not be set with rate %d\n", name, rate);
> +}

Instead of doing all of this work, just store pointers to the link and pixel
clock when you parse the dt. That way you can just access them directly in
dp_ctrl_enable_mainlink_clocks.

> +
> +static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	ctrl->power->set_pixel_clk_parent(ctrl->power);
> +
> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
> +		drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code));
> +
> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_pixel_clk", ctrl->pixel_rate);
> +
> +	ret = ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, true);
> +	if (ret) {
> +		pr_err("Unabled to start link clocks\n");
> +		ret = -EINVAL;
> +	}
> +
> +	return ret;
> +}
> +
> +static int dp_ctrl_disable_mainlink_clocks(struct dp_ctrl_private *ctrl)
> +{
> +	return ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, false);
> +}

This function isn't necesary (even less so when all of the catalog abstractions
are gone).

> +
> +static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip)
> +{
> +	struct dp_ctrl_private *ctrl;
> +	struct dp_catalog_ctrl *catalog;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return -EINVAL;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	ctrl->orientation = flip;
> +	catalog = ctrl->catalog;
> +
> +	catalog->usb_reset(ctrl->catalog, flip);
> +	catalog->phy_reset(ctrl->catalog);
> +	catalog->enable_irq(ctrl->catalog, true);
> +
> +	return 0;
> +}
> +
> +/**
> + * dp_ctrl_host_deinit() - Uninitialize DP controller
> + * @ctrl: Display Port Driver data
> + *
> + * Perform required steps to uninitialize DP controller
> + * and its resources.
> + */
> +static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("Invalid input data\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	ctrl->catalog->enable_irq(ctrl->catalog, false);
> +
> +	pr_debug("Host deinitialized successfully\n");
> +}
> +
> +static bool dp_ctrl_use_fixed_nvid(struct dp_ctrl_private *ctrl)
> +{
> +	u8 *dpcd = ctrl->panel->dpcd;
> +
> +	/*
> +	 * For better interop experience, used a fixed NVID=0x8000
> +	 * whenever connected to a VGA dongle downstream.
> +	 */
> +	if (dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) {
> +		u8 type = dpcd[DP_DOWNSTREAMPORT_PRESENT] &
> +			DP_DWN_STRM_PORT_TYPE_MASK;
> +		if (type == DP_DWN_STRM_PORT_TYPE_ANALOG)
> +			return true;
> +	}
> +
> +	return false;
> +}

For this, you should use the DP_DPCD_QUIRK_CONSTANT_N quirk and
drm_dp_has_quirk() instead.


> +
> +static int dp_ctrl_link_maintenance(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
> +
> +	ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
> +
> +	do {
> +		if (ret == -EAGAIN) {
> +			/* try with lower link rate */
> +			dp_ctrl_link_rate_down_shift(ctrl);
> +
> +			ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
> +		}
> +
> +		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
> +			ctrl->orientation, ctrl->link->link_params.lane_count);
> +
> +		/*
> +		 * Disable and re-enable the mainlink clock since the
> +		 * link clock might have been adjusted as part of the
> +		 * link maintenance.
> +		 */
> +		dp_ctrl_disable_mainlink_clocks(ctrl);

Return value should be checked


Below you have:

+		/* hw recommended delay before re-enabling clocks */
+		msleep(20);

Between the disable and enable, so you should probably have that here too?

> +
> +		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
> +		if (ret)
> +			continue;

Do you really want to continue here? Seems like you could get into an infinite
loop pretty easily in the -EINVAL case.

> +
> +		dp_ctrl_configure_source_params(ctrl);
> +
> +		ctrl->catalog->config_msa(ctrl->catalog,
> +			drm_dp_bw_code_to_link_rate(
> +			ctrl->link->link_params.bw_code),
> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
> +
> +		reinit_completion(&ctrl->idle_comp);

Are you guaranteed that this doesn't race with other idle_comp uses?

> +
> +		ret = dp_ctrl_setup_main_link(ctrl, true);
> +	} while (ret == -EAGAIN);

The do/while is a bit awkward, especially since it starts with a conditional
block that can't possibly be true on the first iteration. How about:

	for (tries = 0; tries < max_tries; tries++) {
		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
			ctrl->orientation, ctrl->link->link_params.lane_count);

		/*
		 * Disable and re-enable the mainlink clock since the
		 * link clock might have been adjusted as part of the
		 * link maintenance.
		 */
		ret = dp_ctrl_disable_mainlink_clocks(ctrl);
                if (ret)
                        return ret;

		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
		if (ret)
			return ret;

		dp_ctrl_configure_source_params(ctrl);

		ctrl->catalog->config_msa(ctrl->catalog,
			drm_dp_bw_code_to_link_rate(
			ctrl->link->link_params.bw_code),
			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));

		reinit_completion(&ctrl->idle_comp);

		ret = dp_ctrl_setup_main_link(ctrl, true);
		if (ret != -EAGAIN)
                        return ret;

                /* try with lower link rate */
                dp_ctrl_link_rate_down_shift(ctrl);

                ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
	}

        return -ETIMEDOUT;


There's a lot of similarity between this code and dp_ctrl_on. If the code were
shared, we wouldn't have the missing 20ms delay above. So can you please pull
the common bits which [re-]initialize the link into a helper function that you
call from both functions?

> +
> +	return ret;

It's nice that we return a value here, but it's never checked by our callers :(

> +}
> +
> +static void dp_ctrl_process_phy_test_request(struct dp_ctrl_private *ctrl)
> +{
> +	int ret = 0;
> +
> +	if (!ctrl->link->phy_params.phy_test_pattern_sel) {
> +		pr_debug("no test pattern selected by sink\n");
> +		return;
> +	}
> +
> +	pr_debug("start\n");

This and the "end" debug statements should be removed

> +
> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
> +	/*
> +	 * The global reset will need DP link ralated clocks to be

s/related/ralated/

> +	 * running. Add the global reset just before disabling the
> +	 * link clocks and core clocks.
> +	 */
> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
> +	ctrl->dp_ctrl.off(&ctrl->dp_ctrl);
> +
> +	ret = ctrl->dp_ctrl.on(&ctrl->dp_ctrl);
> +	if (ret)
> +		pr_err("failed to enable DP controller\n");

Please propagate errors instead of swallowing them.

> +
> +	pr_debug("end\n");
> +}
> +
> +static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private *ctrl)
> +{
> +	bool success = false;
> +	u32 pattern_sent = 0x0;
> +	u32 pattern_requested = ctrl->link->phy_params.phy_test_pattern_sel;
> +
> +	pr_debug("request: %s\n",
> +			dp_link_get_phy_test_pattern(pattern_requested));
> +
> +	ctrl->catalog->update_vx_px(ctrl->catalog,
> +			ctrl->link->phy_params.v_level,
> +			ctrl->link->phy_params.p_level);
> +	ctrl->catalog->send_phy_pattern(ctrl->catalog, pattern_requested);
> +	ctrl->link->send_test_response(ctrl->link);
> +
> +	pattern_sent = ctrl->catalog->read_phy_pattern(ctrl->catalog);
> +
> +	switch (pattern_sent) {
> +	case MR_LINK_TRAINING1:
> +		if (pattern_requested ==
> +				DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING)
> +			success = true;


success = pattern_requested == DP_LINK_QUAL_PATTERN_11_D10_2;

Same can be done below.


> +		break;
> +	case MR_LINK_SYMBOL_ERM:
> +		if ((pattern_requested ==
> +				DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT)
> +			|| (pattern_requested ==
> +				DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN))
> +			success = true;
> +		break;
> +	case MR_LINK_PRBS7:
> +		if (pattern_requested == DP_TEST_PHY_PATTERN_PRBS7)
> +			success = true;
> +		break;
> +	case MR_LINK_CUSTOM80:
> +		if (pattern_requested ==
> +				DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN)
> +			success = true;
> +		break;
> +	default:
> +		success = false;
> +		return;
> +	}

I feel like you should return success (or a ret). As it is, this doesn't do much.

> +
> +	pr_debug("%s: %s\n", success ? "success" : "failed",
> +			dp_link_get_phy_test_pattern(pattern_requested));
> +}
> +
> +static void dp_ctrl_handle_sink_request(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +	u32 sink_request = 0x0;
> +
> +	if (!dp_ctrl) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +	sink_request = ctrl->link->sink_request;
> +
> +	if (sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
> +		pr_info("PHY_TEST_PATTERN request\n");

Downgrade to DEBUG level please

> +		dp_ctrl_process_phy_test_request(ctrl);
> +	}
> +
> +	if (sink_request & DP_LINK_STATUS_UPDATED)
> +		dp_ctrl_link_maintenance(ctrl);

Check return value

> +
> +	if (sink_request & DP_TEST_LINK_TRAINING) {
> +		ctrl->link->send_test_response(ctrl->link);
> +		dp_ctrl_link_maintenance(ctrl);

Check return value

> +	}
> +}
> +
> +static void dp_ctrl_reset(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl) {
> +		pr_err("invalid params\n");
> +		return;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +	ctrl->catalog->reset(ctrl->catalog);
> +}

I think this function goes away with all of the catalog stuff removed.

> +
> +static int dp_ctrl_on(struct dp_ctrl *dp_ctrl)
> +{
> +	int rc = 0;
> +	struct dp_ctrl_private *ctrl;
> +	u32 rate = 0;
> +	u32 link_train_max_retries = 100;

This amount is excessive, 5 times should suffice (unless you have data that
suggests otherwise).

> +	u32 const phy_cts_pixel_clk_khz = 148500;

Should this be a #define in drm_dp_helper?

> +
> +	if (!dp_ctrl) {
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	atomic_set(&ctrl->aborted, 0);

Why is this needed over is_connected? It seems like if you had proper locking
around is_connected (which I think is necessary), you could just acquire the lock
and try the training. If it fails b/c someone unplugged the cable, that's quite
Ok.

> +	rate = ctrl->panel->link_info.rate;
> +
> +	ctrl->power->clk_enable(ctrl->power, DP_CORE_PM, true);
> +	ctrl->catalog->hpd_config(ctrl->catalog, true);
> +
> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
> +		pr_debug("using phy test link parameters\n");
> +		if (!ctrl->panel->pinfo.pixel_clk_khz)
> +			ctrl->pixel_rate = phy_cts_pixel_clk_khz;
> +	} else {
> +		ctrl->link->link_params.bw_code =
> +			drm_dp_link_rate_to_bw_code(rate);
> +		ctrl->link->link_params.lane_count =
> +			ctrl->panel->link_info.num_lanes;
> +		ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
> +	}
> +
> +	pr_debug("bw_code=%d, lane_count=%d, pixel_rate=%d\n",
> +		ctrl->link->link_params.bw_code,
> +		ctrl->link->link_params.lane_count, ctrl->pixel_rate);
> +
> +	ctrl->catalog->phy_lane_cfg(ctrl->catalog,
> +			ctrl->orientation, ctrl->link->link_params.lane_count);
> +
> +	rc = dp_ctrl_enable_mainlink_clocks(ctrl);
> +	if (rc)
> +		goto end;
> +
> +	reinit_completion(&ctrl->idle_comp);

Are you guaranteed that this doesn't race with other idle_comp uses (or other
dp_ctrl_on callers)?

> +
> +	dp_ctrl_configure_source_params(ctrl);
> +
> +	while (--link_train_max_retries && !atomic_read(&ctrl->aborted)) {
> +		ctrl->catalog->config_msa(ctrl->catalog,
> +			drm_dp_bw_code_to_link_rate(
> +			ctrl->link->link_params.bw_code),
> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
> +
> +		rc = dp_ctrl_setup_main_link(ctrl, true);
> +		if (!rc)
> +			break;
> +
> +		/* try with lower link rate */
> +		dp_ctrl_link_rate_down_shift(ctrl);
> +
> +		ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
> +
> +		dp_ctrl_disable_mainlink_clocks(ctrl);

Check return code

> +		/* hw recommended delay before re-enabling clocks */
> +		msleep(20);
> +
> +		dp_ctrl_enable_mainlink_clocks(ctrl);

Check return code

> +	}

Same comment here as in dp_ctrl_link_maintenance(), we should pull out the
common code and put it in a helper.

> +
> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)

This is racy, sink_request could change between the check above and here.

> +		dp_ctrl_send_phy_test_pattern(ctrl);
> +
> +	pr_debug("End-\n");

Please remove

> +
> +end:
> +	return rc;
> +}
> +
> +static void dp_ctrl_off(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl)
> +		return;
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
> +	ctrl->catalog->reset(ctrl->catalog);
> +
> +	/* Make sure DP is disabled before clk disable */
> +	wmb();

readl/wmb nit

> +
> +	dp_ctrl_disable_mainlink_clocks(ctrl);

Check and propagate return value

> +
> +	pr_debug("DP off done\n");
> +}
> +
> +static void dp_ctrl_isr(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl)
> +		return;
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	ctrl->catalog->get_interrupt(ctrl->catalog);

This should return the isr instead of store it in ctrl->catalog->isr, since that
could potentially be overwritten after this function acks the current
interrupts.

(Also, it's only used in this function, so there's no need to store it). One you
remove the catalog indirection, hopefully there will be a bunch of these cases
that become clear.


> +
> +	if (ctrl->catalog->isr & DP_CTRL_INTR_READY_FOR_VIDEO)
> +		dp_ctrl_video_ready(ctrl);
> +
> +	if (ctrl->catalog->isr & DP_CTRL_INTR_IDLE_PATTERN_SENT)
> +		dp_ctrl_idle_patterns_sent(ctrl);

As mentioned above, just call the completions directly.

> +}
> +
> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
> +{
> +	int rc = 0;
> +	struct dp_ctrl_private *ctrl;
> +	struct dp_ctrl *dp_ctrl;
> +
> +	if (!in->dev || !in->panel || !in->aux ||
> +	    !in->link || !in->catalog) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	ctrl = devm_kzalloc(in->dev, sizeof(*ctrl), GFP_KERNEL);
> +	if (!ctrl) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	init_completion(&ctrl->idle_comp);
> +	init_completion(&ctrl->video_comp);
> +
> +	/* in parameters */
> +	ctrl->parser   = in->parser;
> +	ctrl->panel    = in->panel;
> +	ctrl->power    = in->power;
> +	ctrl->aux      = in->aux;
> +	ctrl->link     = in->link;
> +	ctrl->catalog  = in->catalog;
> +	ctrl->dev      = in->dev;
> +
> +	dp_ctrl = &ctrl->dp_ctrl;
> +
> +	/* out parameters */
> +	dp_ctrl->init      = dp_ctrl_host_init;
> +	dp_ctrl->deinit    = dp_ctrl_host_deinit;
> +	dp_ctrl->on        = dp_ctrl_on;
> +	dp_ctrl->off       = dp_ctrl_off;
> +	dp_ctrl->push_idle = dp_ctrl_push_idle;
> +	dp_ctrl->abort     = dp_ctrl_abort;
> +	dp_ctrl->isr       = dp_ctrl_isr;
> +	dp_ctrl->reset	   = dp_ctrl_reset;
> +	dp_ctrl->handle_sink_request = dp_ctrl_handle_sink_request;
> +
> +	return dp_ctrl;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl)
> +{
> +	struct dp_ctrl_private *ctrl;
> +
> +	if (!dp_ctrl)
> +		return;
> +
> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> +
> +	devm_kfree(ctrl->dev, ctrl);
> +}

Once again, these functions can be deleted. Just store the _necessary_ data in a
central struct (with substructs as necessary) and call functions directly.


> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.h b/drivers/gpu/drm/msm/dp/dp_ctrl.h
> new file mode 100644
> index 0000000..6ab221a
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.h
> @@ -0,0 +1,50 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_CTRL_H_
> +#define _DP_CTRL_H_
> +
> +#include "dp_aux.h"
> +#include "dp_panel.h"
> +#include "dp_link.h"
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +
> +struct dp_ctrl {
> +	int (*init)(struct dp_ctrl *dp_ctrl, bool flip);
> +	void (*deinit)(struct dp_ctrl *dp_ctrl);
> +	int (*on)(struct dp_ctrl *dp_ctrl);
> +	void (*off)(struct dp_ctrl *dp_ctrl);
> +	void (*reset)(struct dp_ctrl *dp_ctrl);
> +	void (*push_idle)(struct dp_ctrl *dp_ctrl);
> +	void (*abort)(struct dp_ctrl *dp_ctrl);
> +	void (*isr)(struct dp_ctrl *dp_ctrl);
> +	void (*handle_sink_request)(struct dp_ctrl *dp_ctrl);
> +};

Same comment as catalog, these should just be functions to be called directly.

> +
> +struct dp_ctrl_in {
> +	struct device *dev;
> +	struct dp_panel *panel;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_parser *parser;
> +	struct dp_power *power;
> +	struct dp_catalog_ctrl *catalog;
> +};

This struct is not needed, function arguments work just as well.

> +
> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in);
> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl);
> +
> +#endif /* _DP_CTRL_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.c b/drivers/gpu/drm/msm/dp/dp_debug.c
> new file mode 100644
> index 0000000..5c0a8ce
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_debug.c
> @@ -0,0 +1,507 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/debugfs.h>
> +#include <drm/drm_connector.h>
> +
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +#include "dp_aux.h"
> +#include "dp_ctrl.h"
> +#include "dp_debug.h"
> +#include "dp_display.h"
> +
> +#define DEBUG_NAME "drm_dp"
> +
> +struct dp_debug_private {
> +	struct dentry *root;
> +
> +	struct dp_usbpd *usbpd;
> +	struct dp_link *link;
> +	struct dp_panel *panel;
> +	struct drm_connector **connector;
> +	struct device *dev;
> +
> +	struct dp_debug dp_debug;
> +};
> +
> +static ssize_t dp_debug_write_hpd(struct file *file,
> +		const char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_8];
> +	size_t len = 0;
> +	int hpd;
> +
> +	if (!debug)
> +		return -ENODEV;
> +
> +	if (*ppos)
> +		return 0;
> +
> +	/* Leave room for termination char */
> +	len = min_t(size_t, count, SZ_8 - 1);
> +	if (copy_from_user(buf, user_buff, len))
> +		goto end;
> +
> +	buf[len] = '\0';
> +
> +	if (kstrtoint(buf, 10, &hpd) != 0)
> +		goto end;
> +
> +	if (debug->usbpd && debug->usbpd->connect)
> +		debug->usbpd->connect(debug->usbpd, hpd);
> +
> +end:
> +	return -len;
> +}
> +
> +static ssize_t dp_debug_write_edid_modes(struct file *file,
> +		const char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_32];
> +	size_t len = 0;
> +	int hdisplay = 0, vdisplay = 0, vrefresh = 0;
> +
> +	if (!debug)
> +		return -ENODEV;
> +
> +	if (*ppos)
> +		goto end;
> +
> +	/* Leave room for termination char */
> +	len = min_t(size_t, count, SZ_32 - 1);
> +	if (copy_from_user(buf, user_buff, len))
> +		goto clear;
> +
> +	buf[len] = '\0';
> +
> +	if (sscanf(buf, "%d %d %d", &hdisplay, &vdisplay, &vrefresh) != 3)
> +		goto clear;
> +
> +	if (!hdisplay || !vdisplay || !vrefresh)
> +		goto clear;
> +
> +	debug->dp_debug.debug_en = true;
> +	debug->dp_debug.hdisplay = hdisplay;
> +	debug->dp_debug.vdisplay = vdisplay;
> +	debug->dp_debug.vrefresh = vrefresh;
> +	goto end;
> +clear:
> +	pr_debug("clearing debug modes\n");
> +	debug->dp_debug.debug_en = false;
> +end:
> +	return len;
> +}
> +
> +static ssize_t dp_debug_read_connected(struct file *file,
> +		char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char buf[SZ_8];
> +	u32 len = 0;
> +
> +	if (!debug)
> +		return -ENODEV;
> +
> +	if (*ppos)
> +		return 0;
> +
> +	if (!debug->usbpd)
> +		return -ENODEV;
> +
> +	len += snprintf(buf, SZ_8, "%d\n", debug->usbpd->hpd_high);
> +
> +	if (copy_to_user(user_buff, buf, len))
> +		return -EFAULT;
> +
> +	*ppos += len;
> +	return len;
> +}
> +
> +static ssize_t dp_debug_read_edid_modes(struct file *file,
> +		char __user *user_buff, size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char *buf;
> +	u32 len = 0;
> +	int rc = 0;
> +	struct drm_connector *connector;
> +	struct drm_display_mode *mode;
> +
> +	if (!debug) {
> +		pr_err("invalid data\n");
> +		rc = -ENODEV;
> +		goto error;
> +	}
> +
> +	connector = *debug->connector;
> +
> +	if (!connector) {
> +		pr_err("connector is NULL\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	if (*ppos)
> +		goto error;
> +
> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
> +	if (!buf) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	list_for_each_entry(mode, &connector->modes, head) {
> +		len += snprintf(buf + len, SZ_4K - len,
> +		"%s %d %d %d %d %d %d %d %d %d 0x%x\n",
> +		mode->name, mode->vrefresh, mode->hdisplay,
> +		mode->hsync_start, mode->hsync_end, mode->htotal,
> +		mode->vdisplay, mode->vsync_start, mode->vsync_end,
> +		mode->vtotal, mode->flags);
> +	}
> +
> +	if (copy_to_user(user_buff, buf, len)) {
> +		kfree(buf);
> +		rc = -EFAULT;
> +		goto error;
> +	}
> +
> +	*ppos += len;
> +	kfree(buf);
> +
> +	return len;
> +error:
> +	return rc;
> +}
> +
> +static int dp_debug_check_buffer_overflow(int rc, int *max_size, int *len)
> +{
> +	if (rc >= *max_size) {
> +		pr_err("buffer overflow\n");
> +		return -EINVAL;
> +	}
> +	*len += rc;
> +	*max_size = SZ_4K - *len;
> +
> +	return 0;
> +}
> +
> +static ssize_t dp_debug_read_info(struct file *file, char __user *user_buff,
> +		size_t count, loff_t *ppos)
> +{
> +	struct dp_debug_private *debug = file->private_data;
> +	char *buf;
> +	u32 len = 0, rc = 0;
> +	u64 lclk = 0;
> +	u32 max_size = SZ_4K;
> +
> +	if (!debug)
> +		return -ENODEV;
> +
> +	if (*ppos)
> +		return 0;
> +
> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
> +	if (!buf)
> +		return -ENOMEM;
> +
> +	rc = snprintf(buf + len, max_size, "\tname = %s\n", DEBUG_NAME);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_panel\n\t\tmax_pclk_khz = %d\n",
> +		debug->panel->max_pclk_khz);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\tdrm_dp_link\n\t\trate = %u\n",
> +		debug->panel->link_info.rate);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tnum_lanes = %u\n",
> +		debug->panel->link_info.num_lanes);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tcapabilities = %lu\n",
> +		debug->panel->link_info.capabilities);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_panel_info:\n\t\tactive = %dx%d\n",
> +		debug->panel->pinfo.h_active,
> +		debug->panel->pinfo.v_active);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tback_porch = %dx%d\n",
> +		debug->panel->pinfo.h_back_porch,
> +		debug->panel->pinfo.v_back_porch);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tfront_porch = %dx%d\n",
> +		debug->panel->pinfo.h_front_porch,
> +		debug->panel->pinfo.v_front_porch);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tsync_width = %dx%d\n",
> +		debug->panel->pinfo.h_sync_width,
> +		debug->panel->pinfo.v_sync_width);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tactive_low = %dx%d\n",
> +		debug->panel->pinfo.h_active_low,
> +		debug->panel->pinfo.v_active_low);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\th_skew = %d\n",
> +		debug->panel->pinfo.h_skew);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\trefresh rate = %d\n",
> +		debug->panel->pinfo.refresh_rate);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tpixel clock khz = %d\n",
> +		debug->panel->pinfo.pixel_clk_khz);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tbpp = %d\n",
> +		debug->panel->pinfo.bpp);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	/* Link Information */
> +	rc = snprintf(buf + len, max_size,
> +		"\tdp_link:\n\t\ttest_requested = %d\n",
> +		debug->link->sink_request);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tlane_count = %d\n", debug->link->link_params.lane_count);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tbw_code = %d\n", debug->link->link_params.bw_code);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	lclk = drm_dp_bw_code_to_link_rate(
> +			debug->link->link_params.bw_code) * 1000;
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tlclk = %lld\n", lclk);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tv_level = %d\n", debug->link->phy_params.v_level);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	rc = snprintf(buf + len, max_size,
> +		"\t\tp_level = %d\n", debug->link->phy_params.p_level);
> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
> +		goto error;
> +
> +	if (copy_to_user(user_buff, buf, len))
> +		goto error;
> +
> +	*ppos += len;
> +
> +	kfree(buf);
> +	return len;
> +error:
> +	kfree(buf);
> +	return -EINVAL;
> +}
> +
> +static const struct file_operations dp_debug_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_info,
> +};
> +
> +static const struct file_operations edid_modes_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_edid_modes,
> +	.write = dp_debug_write_edid_modes,
> +};
> +
> +static const struct file_operations hpd_fops = {
> +	.open = simple_open,
> +	.write = dp_debug_write_hpd,
> +};
> +
> +static const struct file_operations connected_fops = {
> +	.open = simple_open,
> +	.read = dp_debug_read_connected,
> +};

edid, hpd, and connected can all be deleted. They're provided by core.

AFAICT, you can also infer the information from dp_debug, so I think you can
just drop this entire file.

> +
> +static int dp_debug_init(struct dp_debug *dp_debug)
> +{
> +	int rc = 0;
> +	struct dp_debug_private *debug = container_of(dp_debug,
> +		struct dp_debug_private, dp_debug);
> +	struct dentry *dir, *file, *edid_modes;
> +	struct dentry *hpd, *connected;
> +
> +	dir = debugfs_create_dir(DEBUG_NAME, NULL);
> +	if (IS_ERR_OR_NULL(dir)) {
> +		rc = PTR_ERR(dir);
> +		pr_err("[%s] debugfs create dir failed, rc = %d\n",
> +		       DEBUG_NAME, rc);
> +		goto error;
> +	}
> +
> +	file = debugfs_create_file("dp_debug", 0444, dir,
> +				debug, &dp_debug_fops);
> +	if (IS_ERR_OR_NULL(file)) {
> +		rc = PTR_ERR(file);
> +		pr_err("[%s] debugfs create file failed, rc=%d\n",
> +		       DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	edid_modes = debugfs_create_file("edid_modes", 0644, dir,
> +					debug, &edid_modes_fops);
> +	if (IS_ERR_OR_NULL(edid_modes)) {
> +		rc = PTR_ERR(edid_modes);
> +		pr_err("[%s] debugfs create edid_modes failed, rc=%d\n",
> +		       DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	hpd = debugfs_create_file("hpd", 0644, dir,
> +					debug, &hpd_fops);
> +	if (IS_ERR_OR_NULL(hpd)) {
> +		rc = PTR_ERR(hpd);
> +		pr_err("[%s] debugfs hpd failed, rc=%d\n",
> +			DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	connected = debugfs_create_file("connected", 0444, dir,
> +					debug, &connected_fops);
> +	if (IS_ERR_OR_NULL(connected)) {
> +		rc = PTR_ERR(connected);
> +		pr_err("[%s] debugfs connected failed, rc=%d\n",
> +			DEBUG_NAME, rc);
> +		goto error_remove_dir;
> +	}
> +
> +	debug->root = dir;
> +	return rc;
> +error_remove_dir:
> +	debugfs_remove(dir);
> +error:
> +	return rc;
> +}
> +
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector)
> +{
> +	int rc = 0;
> +	struct dp_debug_private *debug;
> +	struct dp_debug *dp_debug;
> +
> +	if (!dev || !panel || !usbpd || !link) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
> +	if (!debug) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	debug->dp_debug.debug_en = false;
> +	debug->usbpd = usbpd;
> +	debug->link = link;
> +	debug->panel = panel;
> +	debug->dev = dev;
> +	debug->connector = connector;
> +
> +	dp_debug = &debug->dp_debug;
> +	dp_debug->vdisplay = 0;
> +	dp_debug->hdisplay = 0;
> +	dp_debug->vrefresh = 0;
> +
> +	rc = dp_debug_init(dp_debug);
> +	if (rc) {
> +		devm_kfree(dev, debug);
> +		goto error;
> +	}
> +
> +	return dp_debug;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +static int dp_debug_deinit(struct dp_debug *dp_debug)
> +{
> +	struct dp_debug_private *debug;
> +
> +	if (!dp_debug)
> +		return -EINVAL;
> +
> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
> +
> +	debugfs_remove_recursive(debug->root);
> +
> +	return 0;
> +}
> +
> +void dp_debug_put(struct dp_debug *dp_debug)
> +{
> +	struct dp_debug_private *debug;
> +
> +	if (!dp_debug)
> +		return;
> +
> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
> +
> +	dp_debug_deinit(dp_debug);
> +
> +	devm_kfree(debug->dev, debug);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.h b/drivers/gpu/drm/msm/dp/dp_debug.h
> new file mode 100644
> index 0000000..a6480e1
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_debug.h
> @@ -0,0 +1,81 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_DEBUG_H_
> +#define _DP_DEBUG_H_
> +
> +#include "dp_panel.h"
> +#include "dp_link.h"
> +#include "dp_extcon.h"
> +
> +/**
> + * struct dp_debug
> + * @debug_en: specifies whether debug mode enabled
> + * @vdisplay: used to filter out vdisplay value
> + * @hdisplay: used to filter out hdisplay value
> + * @vrefresh: used to filter out vrefresh value
> + * @tpg_state: specifies whether tpg feature is enabled
> + */
> +struct dp_debug {
> +	bool debug_en;
> +	int aspect_ratio;
> +	int vdisplay;
> +	int hdisplay;
> +	int vrefresh;
> +};
> +
> +#if defined(CONFIG_DEBUG_FS)
> +
> +/**
> + * dp_debug_get() - configure and get the DisplayPlot debug module data
> + *
> + * @dev: device instance of the caller
> + * @panel: instance of panel module
> + * @usbpd: instance of usbpd module
> + * @link: instance of link module
> + * @connector: double pointer to display connector
> + * return: pointer to allocated debug module data
> + *
> + * This function sets up the debug module and provides a way
> + * for debugfs input to be communicated with existing modules
> + */
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector);
> +/**
> + * dp_debug_put()
> + *
> + * Cleans up dp_debug instance
> + *
> + * @dp_debug: instance of dp_debug
> + */
> +void dp_debug_put(struct dp_debug *dp_debug);
> +
> +#else
> +
> +static inline
> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel *panel,
> +			struct dp_usbpd *usbpd, struct dp_link *link,
> +			struct drm_connector **connector)
> +{
> +	return ERR_PTR(-EINVAL);
> +}
> +
> +static inline void dp_debug_put(struct dp_debug *dp_debug)
> +{
> +}
> +
> +#endif /* defined(CONFIG_DEBUG_FS) */

Drop this too

> +
> +#endif /* _DP_DEBUG_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
> new file mode 100644
> index 0000000..8c98399
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
> @@ -0,0 +1,977 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/uaccess.h>
> +#include <linux/debugfs.h>
> +#include <linux/component.h>
> +#include <linux/of_irq.h>
> +
> +#include "msm_drv.h"
> +#include "dp_extcon.h"
> +#include "dp_parser.h"
> +#include "dp_power.h"
> +#include "dp_catalog.h"
> +#include "dp_aux.h"
> +#include "dp_link.h"
> +#include "dp_panel.h"
> +#include "dp_ctrl.h"
> +#include "dp_display.h"
> +#include "dp_drm.h"
> +#include "dp_debug.h"
> +
> +static struct msm_dp *g_dp_display;
> +#define HPD_STRING_SIZE 30
> +
> +struct dp_display_private {
> +	char *name;
> +	int irq;
> +
> +	/* state variables */
> +	bool core_initialized;
> +	bool power_on;
> +	bool hpd_irq_on;
> +	bool audio_supported;
> +
> +	struct platform_device *pdev;
> +	struct dentry *root;
> +	struct completion notification_comp;
> +
> +	struct dp_usbpd   *usbpd;
> +	struct dp_parser  *parser;
> +	struct dp_power   *power;
> +	struct dp_catalog *catalog;
> +	struct dp_aux     *aux;
> +	struct dp_link    *link;
> +	struct dp_panel   *panel;
> +	struct dp_ctrl    *ctrl;
> +	struct dp_debug   *debug;
> +
> +	struct dp_usbpd_cb usbpd_cb;
> +	struct dp_display_mode mode;
> +	struct msm_dp dp_display;
> +
> +};
> +
> +static const struct of_device_id dp_dt_match[] = {
> +	{.compatible = "qcom,dp-display"},
> +	{}
> +};
> +
> +static irqreturn_t dp_display_irq(int irq, void *dev_id)
> +{
> +	struct dp_display_private *dp = dev_id;
> +
> +	if (!dp) {
> +		pr_err("invalid data\n");
> +		return IRQ_NONE;
> +	}
> +
> +	/* DP controller isr */
> +	dp->ctrl->isr(dp->ctrl);
> +
> +	/* DP aux isr */
> +	dp->aux->isr(dp->aux);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int dp_display_bind(struct device *dev, struct device *master,
> +			   void *data)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +	struct drm_device *drm;
> +	struct msm_drm_private *priv;
> +	struct platform_device *pdev = to_platform_device(dev);
> +
> +	if (!dev || !pdev || !master) {
> +		pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
> +				dev, pdev, master);
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	drm = dev_get_drvdata(master);
> +	dp = platform_get_drvdata(pdev);
> +	if (!drm || !dp) {
> +		pr_err("invalid param(s), drm %pK, dp %pK\n",
> +				drm, dp);
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp->dp_display.drm_dev = drm;
> +	priv = drm->dev_private;
> +	priv->dp = &(dp->dp_display);
> +
> +	rc = dp->parser->parse(dp->parser);
> +	if (rc) {
> +		pr_err("device tree parsing failed\n");
> +		goto end;
> +	}
> +
> +	rc = dp->aux->drm_aux_register(dp->aux);
> +	if (rc) {
> +		pr_err("DRM DP AUX register failed\n");
> +		goto end;
> +	}
> +
> +	rc = dp->power->power_client_init(dp->power);
> +	if (rc) {
> +		pr_err("Power client create failed\n");
> +		goto end;
> +	}
> +
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_unbind(struct device *dev, struct device *master,
> +			      void *data)
> +{
> +	struct dp_display_private *dp;
> +	struct platform_device *pdev = to_platform_device(dev);
> +	struct drm_device *drm = dev_get_drvdata(master);
> +	struct msm_drm_private *priv = drm->dev_private;
> +
> +	if (!dev || !pdev) {
> +		pr_err("invalid param(s)\n");
> +		return;
> +	}
> +
> +	dp = platform_get_drvdata(pdev);
> +	if (!dp) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	(void)dp->power->power_client_deinit(dp->power);
> +	(void)dp->aux->drm_aux_deregister(dp->aux);
> +	priv->dp = NULL;
> +}
> +
> +static const struct component_ops dp_display_comp_ops = {
> +	.bind = dp_display_bind,
> +	.unbind = dp_display_unbind,
> +};
> +
> +static bool dp_display_is_ds_bridge(struct dp_panel *panel)
> +{
> +	return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
> +		DP_DWN_STRM_PORT_PRESENT);
> +}
> +
> +static bool dp_display_is_sink_count_zero(struct dp_display_private *dp)
> +{
> +	return dp_display_is_ds_bridge(dp->panel) &&
> +		(dp->link->sink_count.count == 0);
> +}
> +
> +static void dp_display_send_hpd_event(struct msm_dp *dp_display)
> +{
> +	struct dp_display_private *dp;
> +	struct drm_connector *connector;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return;
> +	}
> +
> +	connector = dp->dp_display.connector;
> +	drm_helper_hpd_irq_event(connector->dev);
> +}
> +
> +static int dp_display_send_hpd_notification(struct dp_display_private *dp,
> +					    bool hpd)

This function is called from a few different threads with no locking. It seems
like there's good opportunity for is_connected and notification_comp to get out
of sync.

Additionally, is_connected is set to true before the function returns (and
enable has been completed). So is that going to cause problems when we call
detect/get_modes where is_connected == true and the hw is not up?

Perhaps I'm misreading this function, but it seems like the plan is to block
until userspace has been notified and does a full modeset (ie: enable)? If that
is the case, we usually don't want to have the hardware lit up until it's
actually going to be used. In these cases, we'll wrap get_modes in
enable/disable (with proper locking), and wait for modeset to leave it on.

> +{
> +	if ((hpd && dp->dp_display.is_connected) ||
> +			(!hpd && !dp->dp_display.is_connected)) {
> +		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
> +		return 0;
> +	}
> +
> +	/* reset video pattern flag on disconnect */
> +	if (!hpd)
> +		dp->panel->video_test = false;
> +
> +	dp->dp_display.is_connected = hpd;
> +	reinit_completion(&dp->notification_comp);
> +	dp_display_send_hpd_event(&dp->dp_display);
> +
> +	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
> +		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +static int dp_display_process_hpd_high(struct dp_display_private *dp)
> +{
> +	int rc = 0;
> +	struct edid *edid;
> +
> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
> +
> +	if (dp->link->psm_enabled)
> +		goto notify;
> +
> +	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);
> +	if (rc)
> +		goto notify;
> +
> +	dp->link->process_request(dp->link);
> +
> +	if (dp_display_is_sink_count_zero(dp)) {
> +		pr_debug("no downstream devices connected\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	edid = dp->panel->edid;
> +
> +	dp->audio_supported = drm_detect_monitor_audio(edid);
> +
> +	dp->panel->handle_sink_request(dp->panel);
> +
> +	dp->dp_display.max_pclk_khz = dp->parser->max_pclk_khz;
> +notify:
> +	dp_display_send_hpd_notification(dp, true);
> +
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_host_init(struct dp_display_private *dp)
> +{
> +	bool flip = false;
> +
> +	if (dp->core_initialized) {
> +		pr_debug("DP core already initialized\n");
> +		return;
> +	}
> +
> +	if (dp->usbpd->orientation == ORIENTATION_CC2)
> +		flip = true;
> +
> +	dp->power->init(dp->power, flip);
> +	dp->ctrl->init(dp->ctrl, flip);
> +	enable_irq(dp->irq);
> +	dp->core_initialized = true;
> +}
> +
> +static void dp_display_host_deinit(struct dp_display_private *dp)
> +{
> +	if (!dp->core_initialized) {
> +		pr_debug("DP core already off\n");
> +		return;
> +	}
> +
> +	dp->ctrl->deinit(dp->ctrl);
> +	dp->power->deinit(dp->power);
> +	disable_irq(dp->irq);
> +	dp->core_initialized = false;
> +}
> +
> +static void dp_display_process_hpd_low(struct dp_display_private *dp)
> +{
> +	/* cancel any pending request */
> +	dp->ctrl->abort(dp->ctrl);
> +
> +	dp_display_send_hpd_notification(dp, false);
> +
> +	dp->aux->deinit(dp->aux);
> +}
> +
> +static int dp_display_usbpd_configure_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		rc = -ENODEV;
> +		goto end;
> +	}
> +
> +	dp_display_host_init(dp);
> +
> +	if (dp->usbpd->hpd_high)
> +		dp_display_process_hpd_high(dp);
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_clean(struct dp_display_private *dp)
> +{
> +	dp->ctrl->push_idle(dp->ctrl);
> +	dp->ctrl->off(dp->ctrl);
> +}
> +
> +static int dp_display_usbpd_disconnect_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		rc = -ENODEV;
> +		goto end;
> +	}
> +
> +	/* cancel any pending request */
> +	dp->ctrl->abort(dp->ctrl);
> +
> +	rc = dp_display_send_hpd_notification(dp, false);
> +
> +	/* if cable is disconnected, reset psm_enabled flag */
> +	if (!dp->usbpd->alt_mode_cfg_done)
> +		dp->link->psm_enabled = false;
> +
> +	if ((rc < 0) && dp->power_on)
> +		dp_display_clean(dp);
> +
> +	dp_display_host_deinit(dp);
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_handle_video_request(struct dp_display_private *dp)
> +{
> +	if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
> +		/* force disconnect followed by connect */
> +		dp->usbpd->connect(dp->usbpd, false);
> +		dp->panel->video_test = true;
> +		dp->usbpd->connect(dp->usbpd, true);
> +		dp->link->send_test_response(dp->link);
> +	}
> +}
> +
> +static int dp_display_handle_hpd_irq(struct dp_display_private *dp)
> +{
> +	if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) {
> +		dp_display_send_hpd_notification(dp, false);
> +
> +		if (dp_display_is_sink_count_zero(dp)) {
> +			pr_debug("sink count is zero, nothing to do\n");
> +			return 0;
> +		}
> +
> +		return dp_display_process_hpd_high(dp);
> +	}
> +
> +	dp->ctrl->handle_sink_request(dp->ctrl);
> +
> +	dp_display_handle_video_request(dp);
> +
> +	return 0;
> +}
> +
> +static int dp_display_usbpd_attention_cb(struct device *dev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dev) {
> +		pr_err("invalid dev\n");
> +		return -EINVAL;
> +	}
> +
> +	dp = dev_get_drvdata(dev);
> +	if (!dp) {
> +		pr_err("no driver data found\n");
> +		return -ENODEV;
> +	}
> +
> +	if (dp->usbpd->hpd_irq) {
> +		dp->hpd_irq_on = true;
> +
> +		rc = dp->link->process_request(dp->link);
> +		/* check for any test request issued by sink */
> +		if (!rc)
> +			dp_display_handle_hpd_irq(dp);
> +
> +		dp->hpd_irq_on = false;
> +		goto end;
> +	}
> +
> +	if (!dp->usbpd->hpd_high) {
> +		dp_display_process_hpd_low(dp);
> +		goto end;
> +	}
> +
> +	if (dp->usbpd->alt_mode_cfg_done)
> +		dp_display_process_hpd_high(dp);
> +end:
> +	return rc;
> +}
> +
> +static void dp_display_deinit_sub_modules(struct dp_display_private *dp)
> +{
> +	dp_ctrl_put(dp->ctrl);
> +	dp_link_put(dp->link);
> +	dp_panel_put(dp->panel);
> +	dp_aux_put(dp->aux);
> +	dp_power_put(dp->power);
> +	dp_catalog_put(dp->catalog);
> +	dp_parser_put(dp->parser);
> +	dp_debug_put(dp->debug);
> +}
> +
> +static int dp_init_sub_modules(struct dp_display_private *dp)
> +{
> +	int rc = 0;
> +	struct device *dev = &dp->pdev->dev;
> +	struct dp_usbpd_cb *cb = &dp->usbpd_cb;
> +	struct dp_ctrl_in ctrl_in = {
> +		.dev = dev,
> +	};
> +	struct dp_panel_in panel_in = {
> +		.dev = dev,
> +	};
> +
> +	/* Callback APIs used for cable status change event */
> +	cb->configure  = dp_display_usbpd_configure_cb;
> +	cb->disconnect = dp_display_usbpd_disconnect_cb;
> +	cb->attention  = dp_display_usbpd_attention_cb;
> +
> +	dp->parser = dp_parser_get(dp->pdev);
> +	if (IS_ERR(dp->parser)) {
> +		rc = PTR_ERR(dp->parser);
> +		pr_err("failed to initialize parser, rc = %d\n", rc);
> +		dp->parser = NULL;
> +		goto error_parser;
> +	}
> +
> +	dp->catalog = dp_catalog_get(dev, &dp->parser->io);
> +	if (IS_ERR(dp->catalog)) {
> +		rc = PTR_ERR(dp->catalog);
> +		pr_err("failed to initialize catalog, rc = %d\n", rc);
> +		dp->catalog = NULL;
> +		goto error_catalog;
> +	}
> +
> +	dp->power = dp_power_get(dp->parser);
> +	if (IS_ERR(dp->power)) {
> +		rc = PTR_ERR(dp->power);
> +		pr_err("failed to initialize power, rc = %d\n", rc);
> +		dp->power = NULL;
> +		goto error_power;
> +	}
> +
> +	dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser->aux_cfg);
> +	if (IS_ERR(dp->aux)) {
> +		rc = PTR_ERR(dp->aux);
> +		pr_err("failed to initialize aux, rc = %d\n", rc);
> +		dp->aux = NULL;
> +		goto error_aux;
> +	}
> +
> +	dp->link = dp_link_get(dev, dp->aux);
> +	if (IS_ERR(dp->link)) {
> +		rc = PTR_ERR(dp->link);
> +		pr_err("failed to initialize link, rc = %d\n", rc);
> +		dp->link = NULL;
> +		goto error_link;
> +	}
> +
> +	panel_in.aux = dp->aux;
> +	panel_in.catalog = &dp->catalog->panel;
> +	panel_in.link = dp->link;
> +
> +	dp->panel = dp_panel_get(&panel_in);
> +	if (IS_ERR(dp->panel)) {
> +		rc = PTR_ERR(dp->panel);
> +		pr_err("failed to initialize panel, rc = %d\n", rc);
> +		dp->panel = NULL;
> +		goto error_panel;
> +	}
> +
> +	ctrl_in.link = dp->link;
> +	ctrl_in.panel = dp->panel;
> +	ctrl_in.aux = dp->aux;
> +	ctrl_in.power = dp->power;
> +	ctrl_in.catalog = &dp->catalog->ctrl;
> +	ctrl_in.parser = dp->parser;
> +
> +	dp->ctrl = dp_ctrl_get(&ctrl_in);
> +	if (IS_ERR(dp->ctrl)) {
> +		rc = PTR_ERR(dp->ctrl);
> +		pr_err("failed to initialize ctrl, rc = %d\n", rc);
> +		dp->ctrl = NULL;
> +		goto error_ctrl;
> +	}
> +
> +	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
> +				dp->link, &dp->dp_display.connector);
> +	if (IS_ERR(dp->debug)) {
> +		rc = PTR_ERR(dp->debug);
> +		pr_err("failed to initialize debug, rc = %d\n", rc);
> +		dp->debug = NULL;
> +		goto error_debug;
> +	}
> +
> +	return rc;
> +error_debug:
> +	dp_ctrl_put(dp->ctrl);
> +error_ctrl:
> +	dp_panel_put(dp->panel);
> +error_panel:
> +	dp_link_put(dp->link);
> +error_link:
> +	dp_aux_put(dp->aux);
> +error_aux:
> +	dp_power_put(dp->power);
> +error_power:
> +	dp_catalog_put(dp->catalog);
> +error_catalog:
> +	dp_parser_put(dp->parser);
> +error_parser:
> +	return rc;
> +}
> +
> +static int dp_display_set_mode(struct msm_dp *dp_display,
> +			       struct dp_display_mode *mode)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	dp->panel->pinfo = mode->timing;
> +	dp->panel->init_info(dp->panel);
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_prepare(struct msm_dp *dp)
> +{
> +	return 0;
> +}
> +
> +static int dp_display_enable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (dp->power_on) {
> +		pr_debug("Link already setup, return\n");
> +		return 0;
> +	}
> +
> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
> +
> +	rc = dp->ctrl->on(dp->ctrl);
> +	if (!rc)
> +		dp->power_on = true;
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_post_enable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	complete_all(&dp->notification_comp);
> +
> +end:
> +	return rc;
> +}
> +
> +static int dp_display_pre_disable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (dp->usbpd->alt_mode_cfg_done && (dp->usbpd->hpd_high ||
> +		dp->usbpd->forced_disconnect))
> +		dp->link->psm_config(dp->link, &dp->panel->link_info, true);
> +
> +	dp->ctrl->push_idle(dp->ctrl);
> +error:
> +	return rc;
> +}
> +
> +static int dp_display_disable(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	if (!dp->power_on || !dp->core_initialized)
> +		goto error;
> +
> +	dp->ctrl->off(dp->ctrl);
> +
> +	dp->power_on = false;
> +
> +	complete_all(&dp->notification_comp);
> +error:
> +	return rc;
> +}
> +
> +static int dp_request_irq(struct msm_dp *dp_display)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
> +	if (dp->irq < 0) {
> +		rc = dp->irq;
> +		pr_err("failed to get irq: %d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq,
> +		IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
> +	if (rc < 0) {
> +		pr_err("failed to request IRQ%u: %d\n",
> +				dp->irq, rc);
> +		return rc;
> +	}
> +	disable_irq(dp->irq);
> +
> +	return 0;
> +}
> +
> +static struct dp_debug *dp_get_debug(struct msm_dp *dp_display)
> +{
> +	struct dp_display_private *dp;
> +
> +	if (!dp_display) {
> +		pr_err("invalid input\n");
> +		return ERR_PTR(-EINVAL);
> +	}
> +
> +	dp = container_of(dp_display, struct dp_display_private, dp_display);
> +
> +	return dp->debug;
> +}
> +
> +static int dp_display_unprepare(struct msm_dp *dp)
> +{
> +	return 0;
> +}
> +
> +static int dp_display_validate_mode(struct msm_dp *dp, u32 mode_pclk_khz)
> +{
> +	const u32 num_components = 3, default_bpp = 24;
> +	struct dp_display_private *dp_display;
> +	struct drm_dp_link *link_info;
> +	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
> +
> +	if (!dp || !mode_pclk_khz || !dp->connector) {
> +		pr_err("invalid params\n");
> +		return -EINVAL;
> +	}
> +
> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +	link_info = &dp_display->panel->link_info;
> +
> +	mode_bpp = dp->connector->display_info.bpc * num_components;
> +	if (!mode_bpp)
> +		mode_bpp = default_bpp;
> +
> +	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,
> +			mode_bpp, mode_pclk_khz);
> +
> +	mode_rate_khz = mode_pclk_khz * mode_bpp;
> +	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
> +
> +	if (mode_rate_khz > supported_rate_khz)
> +		return MODE_BAD;
> +
> +	return MODE_OK;
> +}
> +
> +static int dp_display_get_modes(struct msm_dp *dp,
> +				struct dp_display_mode *dp_mode)
> +{
> +	struct dp_display_private *dp_display;
> +	int ret = 0;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return 0;
> +	}
> +
> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	ret = dp_display->panel->get_modes(dp_display->panel,
> +		dp->connector, dp_mode);
> +	if (dp_mode->timing.pixel_clk_khz)
> +		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;
> +	return ret;
> +}
> +
> +static bool dp_display_check_video_test(struct msm_dp *dp)
> +{
> +	struct dp_display_private *dp_display;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return false;
> +	}
> +
> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	if (dp_display->panel->video_test)
> +		return true;
> +
> +	return false;
> +}
> +
> +static int dp_display_get_test_bpp(struct msm_dp *dp)
> +{
> +	struct dp_display_private *dp_display;
> +
> +	if (!dp) {
> +		pr_err("invalid params\n");
> +		return 0;
> +	}
> +
> +	dp_display = container_of(dp, struct dp_display_private, dp_display);
> +
> +	return dp_link_bit_depth_to_bpp(
> +		dp_display->link->test_video.test_bit_depth);
> +}
> +
> +static int dp_display_probe(struct platform_device *pdev)
> +{
> +	int rc = 0;
> +	struct dp_display_private *dp;
> +
> +	if (!pdev || !pdev->dev.of_node) {
> +		pr_err("pdev not found\n");
> +		return -ENODEV;
> +	}
> +
> +	dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
> +	if (!dp)
> +		return -ENOMEM;
> +
> +	init_completion(&dp->notification_comp);
> +
> +	dp->pdev = pdev;
> +	dp->name = "drm_dp";
> +
> +	rc = dp_init_sub_modules(dp);
> +	if (rc) {
> +		pr_err("init sub module failed\n");
> +		devm_kfree(&pdev->dev, dp);
> +		return -EPROBE_DEFER;
> +	}
> +
> +	platform_set_drvdata(pdev, dp);
> +
> +	g_dp_display = &dp->dp_display;
> +
> +	g_dp_display->enable        = dp_display_enable;
> +	g_dp_display->post_enable   = dp_display_post_enable;
> +	g_dp_display->pre_disable   = dp_display_pre_disable;
> +	g_dp_display->disable       = dp_display_disable;
> +	g_dp_display->set_mode      = dp_display_set_mode;
> +	g_dp_display->validate_mode = dp_display_validate_mode;
> +	g_dp_display->get_modes     = dp_display_get_modes;
> +	g_dp_display->prepare       = dp_display_prepare;
> +	g_dp_display->unprepare     = dp_display_unprepare;
> +	g_dp_display->request_irq   = dp_request_irq;
> +	g_dp_display->get_debug     = dp_get_debug;
> +	g_dp_display->send_hpd_event    = dp_display_send_hpd_event;
> +	g_dp_display->is_video_test = dp_display_check_video_test;
> +	g_dp_display->get_test_bpp = dp_display_get_test_bpp;
> +
> +	rc = component_add(&pdev->dev, &dp_display_comp_ops);
> +	if (rc) {
> +		pr_err("component add failed, rc=%d\n", rc);
> +		dp_display_deinit_sub_modules(dp);
> +		devm_kfree(&pdev->dev, dp);
> +	}
> +
> +	return rc;
> +}
> +
> +int dp_display_get_displays(void **displays, int count)
> +{
> +	if (!displays) {
> +		pr_err("invalid data\n");
> +		return -EINVAL;
> +	}
> +
> +	if (count != 1) {
> +		pr_err("invalid number of displays\n");
> +		return -EINVAL;
> +	}
> +
> +	displays[0] = g_dp_display;
> +	return count;
> +}
> +
> +int dp_display_get_num_of_displays(void)
> +{
> +	return 1;
> +}

These 2 functions are never used, and as such g_dp_display is never used.
AFAICT, the callback hooks linked from g_dp_display also aren't called from
anywhere else. So can you just dump these functions, the struct, and all of the
unused callback hooks?

> +
> +static int dp_display_remove(struct platform_device *pdev)
> +{
> +	struct dp_display_private *dp;
> +
> +	if (!pdev)
> +		return -EINVAL;
> +
> +	dp = platform_get_drvdata(pdev);
> +
> +	dp_display_deinit_sub_modules(dp);
> +
> +	platform_set_drvdata(pdev, NULL);
> +	devm_kfree(&pdev->dev, dp);
> +
> +	return 0;
> +}
> +
> +static struct platform_driver dp_display_driver = {
> +	.probe  = dp_display_probe,
> +	.remove = dp_display_remove,
> +	.driver = {
> +		.name = "msm-dp-display",
> +		.of_match_table = dp_dt_match,
> +	},
> +};
> +
> +int __init msm_dp_register(void)
> +{
> +	int ret;
> +
> +	ret = platform_driver_register(&dp_display_driver);
> +	if (ret) {
> +		pr_err("driver register failed");
> +		return ret;
> +	}
> +
> +	return ret;
> +}
> +
> +void __exit msm_dp_unregister(void)
> +{
> +	platform_driver_unregister(&dp_display_driver);
> +}
> +
> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
> +			struct drm_encoder *encoder)

Where is this called?

> +{
> +	struct msm_drm_private *priv;
> +	int ret;
> +
> +	if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
> +		return -EINVAL;
> +
> +	priv = dev->dev_private;
> +	dp_display->drm_dev = dev;
> +
> +	ret = dp_drm_bridge_init(dp_display, encoder);
> +	if (ret) {
> +		dev_err(dev->dev, "failed to create dp bridge: %d\n", ret);
> +		dp_display->bridge = NULL;
> +		return ret;
> +	}
> +	dp_display->encoder = encoder;
> +
> +	dp_display->connector = dp_drm_connector_init(dp_display);
> +	if (IS_ERR(dp_display->connector)) {
> +		ret = PTR_ERR(dp_display->connector);
> +		dev_err(dev->dev,
> +			"failed to create dp connector: %d\n", ret);
> +		dp_display->connector = NULL;
> +		goto conn_fail;
> +	}
> +
> +	priv->bridges[priv->num_bridges++] = dp_display->bridge;
> +	priv->connectors[priv->num_connectors++] = dp_display->connector;
> +	return 0;
> +
> +conn_fail:
> +	if (dp_display->bridge) {
> +		dp_drm_bridge_deinit(dp_display);
> +		dp_display->bridge = NULL;
> +	}
> +	return ret;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
> new file mode 100644
> index 0000000..ca5eae5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
> @@ -0,0 +1,55 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_DISPLAY_H_
> +#define _DP_DISPLAY_H_
> +
> +#include <drm/drmP.h>
> +
> +#include "dp_panel.h"
> +
> +struct msm_dp {
> +	struct drm_device *drm_dev;
> +	struct dp_bridge *dp_bridge;
> +	struct drm_connector *connector;
> +	struct drm_bridge *bridge;
> +
> +	/* the encoder we are hooked to (outside of dsi block) */
> +	struct drm_encoder *encoder;
> +	bool is_connected;
> +	u32 max_pclk_khz;
> +
> +	int (*enable)(struct msm_dp *dp_display);
> +	int (*post_enable)(struct msm_dp *dp_display);
> +
> +	int (*pre_disable)(struct msm_dp *dp_display);
> +	int (*disable)(struct msm_dp *dp_display);
> +
> +	int (*set_mode)(struct msm_dp *dp_display,
> +			struct dp_display_mode *mode);
> +	int (*validate_mode)(struct msm_dp *dp_display, u32 mode_pclk_khz);
> +	int (*get_modes)(struct msm_dp *dp_display,
> +		struct dp_display_mode *dp_mode);
> +	int (*prepare)(struct msm_dp *dp_display);
> +	int (*unprepare)(struct msm_dp *dp_display);
> +	int (*request_irq)(struct msm_dp *dp_display);
> +	struct dp_debug *(*get_debug)(struct msm_dp *dp_display);
> +	void (*send_hpd_event)(struct msm_dp *dp_display);
> +	bool (*is_video_test)(struct msm_dp *dp_display);
> +	int (*get_test_bpp)(struct msm_dp *dp_display);
> +};
> +
> +int dp_display_get_num_of_displays(void);
> +int dp_display_get_displays(void **displays, int count);
> +#endif /* _DP_DISPLAY_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.c b/drivers/gpu/drm/msm/dp/dp_drm.c
> new file mode 100644
> index 0000000..64d6449
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_drm.c
> @@ -0,0 +1,542 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
> +
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_crtc.h>
> +
> +#include "msm_drv.h"
> +#include "msm_kms.h"
> +//#include "dpu_connector.h"
> +#include "dp_drm.h"
> +#include "dp_debug.h"
> +
> +struct dp_connector {
> +	struct drm_connector base;
> +	struct msm_dp *dp_display;
> +};
> +#define to_dp_connector(x) container_of(x, struct dp_connector, base)
> +#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
> +
> +static void convert_to_dp_mode(const struct drm_display_mode *drm_mode,
> +			struct dp_display_mode *dp_mode, struct msm_dp *dp)
> +{
> +	const u32 num_components = 3;
> +
> +	memset(dp_mode, 0, sizeof(*dp_mode));
> +
> +	dp_mode->timing.h_active = drm_mode->hdisplay;
> +	dp_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;
> +	dp_mode->timing.h_sync_width = drm_mode->htotal -
> +			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);
> +	dp_mode->timing.h_front_porch = drm_mode->hsync_start -
> +					 drm_mode->hdisplay;
> +	dp_mode->timing.h_skew = drm_mode->hskew;
> +
> +	dp_mode->timing.v_active = drm_mode->vdisplay;
> +	dp_mode->timing.v_back_porch = drm_mode->vtotal - drm_mode->vsync_end;
> +	dp_mode->timing.v_sync_width = drm_mode->vtotal -
> +		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);
> +
> +	dp_mode->timing.v_front_porch = drm_mode->vsync_start -
> +					 drm_mode->vdisplay;
> +
> +	if (dp->is_video_test(dp))
> +		dp_mode->timing.bpp = dp->get_test_bpp(dp);
> +	else
> +		dp_mode->timing.bpp = dp->connector->display_info.bpc *
> +		num_components;
> +
> +	if (!dp_mode->timing.bpp)
> +		dp_mode->timing.bpp = 24;
> +
> +	dp_mode->timing.refresh_rate = drm_mode->vrefresh;
> +
> +	dp_mode->timing.pixel_clk_khz = drm_mode->clock;
> +
> +	dp_mode->timing.v_active_low =
> +		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);
> +
> +	dp_mode->timing.h_active_low =
> +		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);
> +}
> +
> +static void convert_to_drm_mode(const struct dp_display_mode *dp_mode,
> +				struct drm_display_mode *drm_mode)
> +{
> +	u32 flags = 0;
> +
> +	memset(drm_mode, 0, sizeof(*drm_mode));
> +
> +	drm_mode->hdisplay = dp_mode->timing.h_active;
> +	drm_mode->hsync_start = drm_mode->hdisplay +
> +				dp_mode->timing.h_front_porch;
> +	drm_mode->hsync_end = drm_mode->hsync_start +
> +			      dp_mode->timing.h_sync_width;
> +	drm_mode->htotal = drm_mode->hsync_end + dp_mode->timing.h_back_porch;
> +	drm_mode->hskew = dp_mode->timing.h_skew;
> +
> +	drm_mode->vdisplay = dp_mode->timing.v_active;
> +	drm_mode->vsync_start = drm_mode->vdisplay +
> +				dp_mode->timing.v_front_porch;
> +	drm_mode->vsync_end = drm_mode->vsync_start +
> +			      dp_mode->timing.v_sync_width;
> +	drm_mode->vtotal = drm_mode->vsync_end + dp_mode->timing.v_back_porch;
> +
> +	drm_mode->vrefresh = dp_mode->timing.refresh_rate;
> +	drm_mode->clock = dp_mode->timing.pixel_clk_khz;
> +
> +	if (dp_mode->timing.h_active_low)
> +		flags |= DRM_MODE_FLAG_NHSYNC;
> +	else
> +		flags |= DRM_MODE_FLAG_PHSYNC;
> +
> +	if (dp_mode->timing.v_active_low)
> +		flags |= DRM_MODE_FLAG_NVSYNC;
> +	else
> +		flags |= DRM_MODE_FLAG_PVSYNC;
> +
> +	drm_mode->flags = flags;
> +
> +	drm_mode->type = 0x48;
> +	drm_mode_set_name(drm_mode);
> +}

Just use the drm modes directly and delete these functions.

> +
> +static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	/* By this point mode should have been validated through mode_fixup */
> +	rc = dp->set_mode(dp, &bridge->dp_mode);
> +	if (rc) {
> +		pr_err("[%d] failed to perform a mode set, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->prepare(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display prepare failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->enable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display enable failed, rc=%d\n",
> +		       bridge->id, rc);
> +		dp->unprepare(dp);
> +	}
> +}
> +
> +static void dp_bridge_enable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->post_enable(dp);
> +	if (rc)
> +		pr_err("[%d] DP display post enable failed, rc=%d\n",
> +		       bridge->id, rc);
> +}
> +
> +static void dp_bridge_disable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->pre_disable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display pre disable failed, rc=%d\n",
> +		       bridge->id, rc);
> +	}
> +}
> +
> +static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
> +{
> +	int rc = 0;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	rc = dp->disable(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display disable failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +
> +	rc = dp->unprepare(dp);
> +	if (rc) {
> +		pr_err("[%d] DP display unprepare failed, rc=%d\n",
> +		       bridge->id, rc);
> +		return;
> +	}
> +}
> +
> +static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
> +				struct drm_display_mode *mode,
> +				struct drm_display_mode *adjusted_mode)
> +{
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge || !mode || !adjusted_mode) {
> +		pr_err("Invalid params\n");
> +		return;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
> +	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode, dp);
> +}
> +
> +static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
> +				  const struct drm_display_mode *mode,
> +				  struct drm_display_mode *adjusted_mode)
> +{
> +	bool ret = true;
> +	struct dp_display_mode dp_mode;
> +	struct dp_bridge *bridge;
> +	struct msm_dp *dp;
> +
> +	if (!drm_bridge || !mode || !adjusted_mode) {
> +		pr_err("Invalid params\n");
> +		ret = false;
> +		goto end;
> +	}
> +
> +	bridge = to_dp_bridge(drm_bridge);
> +	dp = bridge->display;
> +
> +	convert_to_dp_mode(mode, &dp_mode, dp);
> +	convert_to_drm_mode(&dp_mode, adjusted_mode);
> +end:
> +	return ret;
> +}
> +
> +static const struct drm_bridge_funcs dp_bridge_ops = {
> +	.mode_fixup   = dp_bridge_mode_fixup,
> +	.pre_enable   = dp_bridge_pre_enable,
> +	.enable       = dp_bridge_enable,
> +	.disable      = dp_bridge_disable,
> +	.post_disable = dp_bridge_post_disable,
> +	.mode_set     = dp_bridge_mode_set,
> +};

I'm not convinced you need any of this. The only advantage a bridge gets you is
to be involved in modeset. However the only thing you do in modeset is save the
mode (which is only used in enable). So why not just use the mode from the
crtc's state when encoder->enable is called?

That allows you to delete all of the bridge stuff here.

> +
> +int dp_connector_post_init(struct drm_connector *connector, void *display)
> +{
> +	struct msm_dp *dp_display = display;
> +
> +	if (!dp_display)
> +		return -EINVAL;
> +
> +	dp_display->connector = connector;
> +	return 0;
> +}

This isn't called from anything?

> +
> +/**
> + * dp_connector_detect - callback to determine if connector is connected
> + * @connector: Pointer to drm connector structure
> + * @force: Force detect setting from drm framework
> + * Returns: Connector 'is connected' status
> + */
> +static enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
> +		bool force)
> +{
> +	enum drm_connector_status status = connector_status_unknown;
> +	static enum drm_connector_status current_status = connector_status_unknown;
> +	struct msm_dp *dp;
> +	struct dp_connector *dp_conn;
> +	struct msm_drm_private *priv = conn->dev->dev_private;
> +	struct msm_kms *kms = priv->kms;
> +
> +	dp_conn = to_dp_connector(conn);
> +	dp = dp_conn->dp_display;

no need for dp_conn, just do

        dp = to_dp_connector(conn)->dp_display;

> +
> +	pr_err("is_connected = %s\n",
> +		(dp->is_connected) ? "true" : "false");
> +
> +	status = (dp->is_connected) ? connector_status_connected :
> +					connector_status_disconnected;
> +
> +	if (dp->is_connected && dp->bridge->encoder
> +				&& (current_status != status)

This is always true.

> +				&& kms->funcs->set_encoder_mode) {
> +		kms->funcs->set_encoder_mode(kms,
> +				dp->bridge->encoder, false);
> +		pr_err("call set_encoder_mode\n");

detect() should never do work, please remove.

> +	}
> +	current_status = status;

Why?

> +	return status;
> +}
> +
> +static void dp_connector_destroy(struct drm_connector *connector)
> +{
> +	struct dp_connector *dp_conn = to_dp_connector(connector);
> +
> +	DBG("");
> +
> +	drm_connector_cleanup(connector);
> +
> +	kfree(dp_conn);

Once dp_conn is devm managed, you can just remove this function and set .destroy
to drm_connector_cleanup

> +}
> +
> +void dp_connector_send_hpd_event(void *display)

Where is this called?

> +{
> +	struct msm_dp *dp;
> +
> +	if (!display) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	dp = display;
> +
> +	if (dp->send_hpd_event)
> +		dp->send_hpd_event(dp);
> +}
> +
> +/**
> + * dp_connector_get_modes - callback to add drm modes via drm_mode_probed_add()
> + * @connector: Pointer to drm connector structure
> + * Returns: Number of modes added
> + */
> +static int dp_connector_get_modes(struct drm_connector *connector)
> +{
> +	int rc = 0;
> +	struct msm_dp *dp;
> +	struct dp_display_mode *dp_mode = NULL;
> +	struct drm_display_mode *m, drm_mode;
> +	struct dp_connector *dp_conn;
> +
> +	if (!connector)
> +		return 0;
> +
> +	dp_conn = to_dp_connector(connector);
> +	dp = dp_conn->dp_display;
> +
> +	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
> +	if (!dp_mode)
> +		return 0;

When you get rid of dp_display_mode, please use the stack for the new
drm_display_mode

> +
> +	/* pluggable case assumes EDID is read when HPD */
> +	if (dp->is_connected) {
> +		rc = dp->get_modes(dp, dp_mode);

Why is only one mode returned?

> +		if (!rc)

This can also return -errno, you should check for that too.

> +			pr_err("failed to get DP sink modes, rc=%d\n", rc);

Why continue if you know you failed?

> +
> +		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
> +			memset(&drm_mode, 0x0, sizeof(drm_mode));
> +			convert_to_drm_mode(dp_mode, &drm_mode);
> +			m = drm_mode_duplicate(connector->dev, &drm_mode);
> +			if (!m) {
> +				pr_err("failed to add mode %ux%u\n",
> +				       drm_mode.hdisplay,
> +				       drm_mode.vdisplay);
> +				kfree(dp_mode);
> +				return 0;
> +			}
> +			m->width_mm = connector->display_info.width_mm;
> +			m->height_mm = connector->display_info.height_mm;

You shouldn't overwrite these.

> +			drm_mode_probed_add(connector, m);
> +		}
> +	} else {
> +		pr_err("No sink connected\n");

This shouldn't be an error

> +	}
> +	kfree(dp_mode);
> +
> +	return rc;
> +}
> +
> +int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
> +{
> +	int rc = 0;
> +	struct dp_bridge *dp_bridge;
> +	struct drm_device *dev;
> +	struct msm_dp *dp_display = data;
> +	struct msm_drm_private *priv = NULL;
> +
> +	dp_bridge = kzalloc(sizeof(*dp_bridge), GFP_KERNEL);
> +	if (!dp_bridge) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	dev = dp_display->drm_dev;
> +	dp_bridge->display = dp_display;
> +	dp_bridge->base.funcs = &dp_bridge_ops;
> +	dp_bridge->base.encoder = encoder;
> +
> +	priv = dev->dev_private;
> +
> +	rc = drm_bridge_attach(encoder, &dp_bridge->base, NULL);
> +	if (rc) {
> +		pr_err("failed to attach bridge, rc=%d\n", rc);
> +		goto error_free_bridge;
> +	}
> +
> +	rc = dp_display->request_irq(dp_display);
> +	if (rc) {
> +		pr_err("request_irq failed, rc=%d\n", rc);
> +		goto error_free_bridge;
> +	}
> +
> +	encoder->bridge = &dp_bridge->base;
> +	dp_display->dp_bridge = dp_bridge;
> +	dp_display->bridge = &dp_bridge->base;
> +
> +	return 0;
> +error_free_bridge:
> +	kfree(dp_bridge);
> +error:
> +	return rc;
> +}
> +
> +void dp_drm_bridge_deinit(void *data)
> +{
> +	struct msm_dp *display = data;
> +	struct dp_bridge *bridge = display->dp_bridge;
> +
> +	if (bridge && bridge->base.encoder)
> +		bridge->base.encoder->bridge = NULL;
> +
> +	kfree(bridge);
> +}
> +
> +/**
> + * dp_connector_mode_valid - callback to determine if specified mode is valid
> + * @connector: Pointer to drm connector structure
> + * @mode: Pointer to drm mode structure
> + * Returns: Validity status for specified mode
> + */
> +static enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,
> +		struct drm_display_mode *mode)
> +{
> +	struct msm_dp *dp_disp;
> +	struct dp_debug *debug;
> +	struct dp_connector *dp_conn;
> +
> +	if (!mode || !connector) {
> +		pr_err("invalid params\n");
> +		return MODE_ERROR;
> +	}
> +
> +	dp_conn = to_dp_connector(connector);
> +	dp_disp = dp_conn->dp_display;
> +	debug = dp_disp->get_debug(dp_disp);
> +
> +	mode->vrefresh = drm_mode_vrefresh(mode);
> +
> +	if (mode->clock > dp_disp->max_pclk_khz)

I think the value of max_pclk_khz is racy, you'll probably want to audit its
use.


> +		return MODE_BAD;
> +
> +	if (debug->debug_en && (mode->hdisplay != debug->hdisplay ||
> +			mode->vdisplay != debug->vdisplay ||
> +			mode->vrefresh != debug->vrefresh ||
> +			mode->picture_aspect_ratio != debug->aspect_ratio))
> +		return MODE_BAD;

Please drop this.

> +
> +	return dp_disp->validate_mode(dp_disp, mode->clock);

So I guess I was wrong when I said none of the g_dp_display functions are being
used. I'm still unsure where they're set, perhaps there's some missing code. At
any rate, what's the benefit of sticking all of that work into an abstract
callback hook when it only has one implementation and one callsite.

All of that code can move in here (and the same goes for the other callbacks
(move the code where it's used).

> +}
> +
> +static const struct drm_connector_funcs dp_connector_funcs = {
> +	.detect = dp_connector_detect,
> +	.fill_modes = drm_helper_probe_single_connector_modes,
> +	.destroy = dp_connector_destroy,
> +	.reset = drm_atomic_helper_connector_reset,
> +	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
> +};
> +
> +static const struct drm_connector_helper_funcs dp_connector_helper_funcs = {
> +	.get_modes = dp_connector_get_modes,
> +	.mode_valid = dp_connector_mode_valid,
> +};
> +
> +/* connector initialization */
> +struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display)
> +{
> +	struct drm_connector *connector = NULL;
> +	struct dp_connector *dp_connector;
> +	int ret;
> +
> +	dp_connector = kzalloc(sizeof(*dp_connector), GFP_KERNEL);

Use devm_kzalloc (you've already got a memory leak if drm_connector_init fails
below).

> +	if (!dp_connector)
> +		return ERR_PTR(-ENOMEM);
> +
> +	dp_connector->dp_display = dp_display;
> +
> +	connector = &dp_connector->base;
> +
> +	ret = drm_connector_init(dp_display->drm_dev, connector, &dp_connector_funcs,
> +			DRM_MODE_CONNECTOR_DisplayPort);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	drm_connector_helper_add(connector, &dp_connector_helper_funcs);
> +
> +	/*
> +	 * Enable HPD to let hpd event is handled
> +	 * when cable is attached to the host.

These lines don't extend to 80 chars

> +	 */
> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
> +
> +	/* Display driver doesn't support interlace now. */
> +	connector->interlace_allowed = false;
> +	connector->doublescan_allowed = false;

These are already false by virtue of kzalloc

> +
> +	drm_connector_attach_encoder(connector, dp_display->encoder);
> +
> +	return connector;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.h b/drivers/gpu/drm/msm/dp/dp_drm.h
> new file mode 100644
> index 0000000..efbc1be
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_drm.h
> @@ -0,0 +1,52 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_DRM_H_
> +#define _DP_DRM_H_
> +
> +#include <linux/types.h>
> +#include <drm/drmP.h>
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_crtc_helper.h>
> +
> +#include "msm_drv.h"
> +#include "dp_display.h"
> +
> +struct dp_bridge {
> +	struct drm_bridge base;
> +	u32 id;
> +
> +	struct msm_dp *display;
> +	struct dp_display_mode dp_mode;
> +};
> +
> +/**
> + * dp_connector_post_init - callback to perform additional initialization steps
> + * @connector: Pointer to drm connector structure
> + * @display: Pointer to private display handle
> + * Returns: Zero on success
> + */
> +int dp_connector_post_init(struct drm_connector *connector, void *display);
> +
> +void dp_connector_send_hpd_event(void *display);
> +
> +int dp_drm_bridge_init(void *display,
> +	struct drm_encoder *encoder);
> +
> +void dp_drm_bridge_deinit(void *display);
> +
> +struct drm_connector *dp_drm_connector_init(struct msm_dp *dp_display);
> +
> +#endif /* _DP_DRM_H_ */
> +
> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.c b/drivers/gpu/drm/msm/dp/dp_extcon.c
> new file mode 100644
> index 0000000..635c13b
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.c
> @@ -0,0 +1,400 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/slab.h>
> +#include <linux/device.h>
> +#include <linux/extcon.h>
> +
> +#include "dp_extcon.h"
> +
> +/* DP specific VDM commands */
> +#define DP_USBPD_VDM_STATUS	0x10
> +#define DP_USBPD_VDM_CONFIGURE	0x11
> +
> +/* USBPD-TypeC specific Macros */
> +#define VDM_VERSION		0x0
> +#define USB_C_DP_SID		0xFF01
> +
> +enum dp_usbpd_pin_assignment {
> +	DP_USBPD_PIN_A,
> +	DP_USBPD_PIN_B,
> +	DP_USBPD_PIN_C,
> +	DP_USBPD_PIN_D,
> +	DP_USBPD_PIN_E,
> +	DP_USBPD_PIN_F,
> +	DP_USBPD_PIN_MAX,
> +};
> +
> +struct dp_usbpd_capabilities {
> +	enum dp_usbpd_port port;
> +	bool receptacle_state;
> +	u8 ulink_pin_config;
> +	u8 dlink_pin_config;
> +};

Where is this used?

> +
> +struct dp_extcon_private {
> +	u32 vdo;
> +	struct device *dev;
> +	struct notifier_block extcon_nb;
> +	struct extcon_dev *extcon;
> +	struct workqueue_struct *extcon_wq;
> +	struct work_struct event_work;
> +	struct usbpd *pd;
> +	struct dp_usbpd_cb *dp_cb;
> +	struct dp_usbpd_capabilities cap;
> +	struct dp_usbpd dp_usbpd;
> +};
> +
> +static const char *dp_usbpd_pin_name(u8 pin)
> +{
> +	switch (pin) {
> +	case DP_USBPD_PIN_A: return "DP_USBPD_PIN_ASSIGNMENT_A";
> +	case DP_USBPD_PIN_B: return "DP_USBPD_PIN_ASSIGNMENT_B";
> +	case DP_USBPD_PIN_C: return "DP_USBPD_PIN_ASSIGNMENT_C";
> +	case DP_USBPD_PIN_D: return "DP_USBPD_PIN_ASSIGNMENT_D";
> +	case DP_USBPD_PIN_E: return "DP_USBPD_PIN_ASSIGNMENT_E";
> +	case DP_USBPD_PIN_F: return "DP_USBPD_PIN_ASSIGNMENT_F";
> +	default: return "UNKNOWN";
> +	}
> +}

No need to have this just for one debug statement, just print the enum value
with %d below.

> +
> +static const char *dp_usbpd_port_name(enum dp_usbpd_port port)
> +{
> +	switch (port) {
> +	case DP_USBPD_PORT_NONE: return "DP_USBPD_PORT_NONE";
> +	case DP_USBPD_PORT_UFP_D: return "DP_USBPD_PORT_UFP_D";
> +	case DP_USBPD_PORT_DFP_D: return "DP_USBPD_PORT_DFP_D";
> +	case DP_USBPD_PORT_D_UFP_D: return "DP_USBPD_PORT_D_UFP_D";
> +	default: return "DP_USBPD_PORT_NONE";
> +	}
> +}

Same here.

> +
> +static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
> +{
> +	switch (in_port) {
> +	case 0:
> +		*port = DP_USBPD_PORT_NONE;
> +		break;
> +	case 1:
> +		*port = DP_USBPD_PORT_UFP_D;
> +		break;
> +	case 2:
> +		*port = DP_USBPD_PORT_DFP_D;
> +		break;
> +	case 3:
> +		*port = DP_USBPD_PORT_D_UFP_D;
> +		break;
> +	default:
> +		*port = DP_USBPD_PORT_NONE;
> +	}
> +	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
> +}
> +
> +void dp_usbpd_get_capabilities(struct dp_extcon_private *pd)

Where is this called from?

> +{
> +	struct dp_usbpd_capabilities *cap = &pd->cap;
> +	u32 buf = pd->vdo;
> +	int port = buf & 0x3;
> +
> +	cap->receptacle_state = (buf & BIT(6)) ? true : false;
> +	cap->dlink_pin_config = (buf >> 8) & 0xff;
> +	cap->ulink_pin_config = (buf >> 16) & 0xff;

Please #define hardcoded values

> +
> +	dp_usbpd_init_port(&cap->port, port);

All of the values in cap->port seem to be hardcoded, so why not just use the
#define's directly where applicable?

> +}
> +
> +void dp_usbpd_get_status(struct dp_extcon_private *pd)

Where is this called?

> +{
> +	struct dp_usbpd *status = &pd->dp_usbpd;
> +	u32 buf = pd->vdo;
> +	int port = buf & 0x3;
> +
> +	status->low_pow_st     = (buf & BIT(2)) ? true : false;
> +	status->adaptor_dp_en  = (buf & BIT(3)) ? true : false;
> +	status->multi_func     = (buf & BIT(4)) ? true : false;
> +	status->usb_config_req = (buf & BIT(5)) ? true : false;
> +	status->exit_dp_mode   = (buf & BIT(6)) ? true : false;
> +	status->hpd_high       = (buf & BIT(7)) ? true : false;
> +	status->hpd_irq        = (buf & BIT(8)) ? true : false;
> +
> +	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
> +			status->low_pow_st, status->adaptor_dp_en,
> +			status->multi_func);
> +	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
> +			status->usb_config_req,
> +			status->exit_dp_mode, status->hpd_high);
> +	pr_debug("hpd_irq = %d\n", status->hpd_irq);
> +
> +	dp_usbpd_init_port(&status->port, port);

Only multi_func, hpd_high, and hpd_irq are used out of this struct. Can you cull
the values down? hpd_irq is also only set to its hardcoded value, so just use
that value directly where applicable.


> +}
> +
> +u32 dp_usbpd_gen_config_pkt(struct dp_extcon_private *pd)

This function is also unused

> +{
> +	u8 pin_cfg, pin;
> +	u32 config = 0;
> +	const u32 ufp_d_config = 0x2, dp_ver = 0x1;
> +
> +	if (pd->cap.receptacle_state)
> +		pin_cfg = pd->cap.ulink_pin_config;
> +	else
> +		pin_cfg = pd->cap.dlink_pin_config;
> +
> +	for (pin = DP_USBPD_PIN_A; pin < DP_USBPD_PIN_MAX; pin++) {
> +		if (pin_cfg & BIT(pin)) {
> +			if (pd->dp_usbpd.multi_func) {
> +				if (pin == DP_USBPD_PIN_D)
> +					break;
> +			} else {
> +				break;
> +			}
> +		}
> +	}
> +
> +	if (pin == DP_USBPD_PIN_MAX)
> +		pin = DP_USBPD_PIN_C;
> +
> +	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
> +
> +	config |= BIT(pin) << 8;
> +
> +	config |= (dp_ver << 2);
> +	config |= ufp_d_config;
> +
> +	pr_debug("config = 0x%x\n", config);
> +	return config;
> +}
> +
> +static int dp_extcon_connect(struct dp_usbpd *dp_usbpd, bool hpd)
> +{
> +	int rc = 0;
> +	struct dp_extcon_private *extcon;
> +
> +	if (!dp_usbpd) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;

Just return -EINVAL and get rid of the error label and rc.

> +	}
> +
> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	dp_usbpd->hpd_high = hpd;
> +	dp_usbpd->forced_disconnect = !hpd;

If forced_disconnect is always !dp_usbpd->hpd_high, why not just use
!dp_usbpd->hpd_high directly?

> +
> +	if (hpd)
> +		extcon->dp_cb->configure(extcon->dev);
> +	else
> +		extcon->dp_cb->disconnect(extcon->dev);

Do you need locking in this function/file?

> +
> +error:
> +	return rc;
> +}
> +
> +static int dp_extcon_get_lanes(struct dp_extcon_private *extcon_priv)
> +{
> +	union extcon_property_value property;
> +	u8 lanes;
> +
> +	if (!extcon_priv || !extcon_priv->extcon) {
> +		pr_err("Invalid input arguments\n");
> +		return 0;
> +	}
> +
> +	extcon_get_property(extcon_priv->extcon,
> +					EXTCON_DISP_DP,
> +					EXTCON_PROP_USB_SS,
> +					&property);
> +	lanes = ();
> +
> +	return lanes;

        return (property.intval) ? 2 : 4;

and delete lanes


> +}
> +
> +
> +static void dp_extcon_event_work(struct work_struct *work)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +	int dp_state, ret;
> +	int lanes;
> +	union extcon_property_value property;
> +
> +	extcon_priv = container_of(work,
> +			struct dp_extcon_private, event_work);
> +
> +	if (!extcon_priv || !extcon_priv->extcon) {
> +		pr_err("Invalid extcon device handler\n");
> +		return;
> +	}
> +
> +	dp_state = extcon_get_state(extcon_priv->extcon,
> +						EXTCON_DISP_DP);

Can fit on 1 line

> +
> +	if (dp_state > 0) {
> +		ret = extcon_get_property(extcon_priv->extcon,
> +					EXTCON_DISP_DP,
> +					EXTCON_PROP_USB_TYPEC_POLARITY,
> +					&property);
> +		if (ret) {
> +			pr_err("Get Polarity property failed\n");
> +			return;
> +		}
> +		extcon_priv->dp_usbpd.orientation =
> +			((property.intval) ?

Can fit on 1 line, plus remove all () from this, they're not needed.

> +				ORIENTATION_CC2 : ORIENTATION_CC1);
> +
> +		lanes = dp_extcon_get_lanes(extcon_priv);
> +		if (!lanes)
> +			return;
> +		extcon_priv->dp_usbpd.multi_func =
> +					((lanes == 2) ? false : true);

This part is a bit confusing, you add a helper function to get the lanes, and
interpret the USB_SS property to return 2 vs. 4, but then immediately convert
that back into what the USB_SS property returns. Instead, remove the helper
function and read USB_SS directly here.

> +
> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->configure)

I feel like this can never be false anyways, but you're not using either of
these members in the conditional block. So why not just call dp_extcon_connect
unconditionally?

> +			dp_extcon_connect(&extcon_priv->dp_usbpd, true);

Check return value

> +	} else {
> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->disconnect)

Same here.

> +			dp_extcon_connect(&extcon_priv->dp_usbpd, false);

Check return value

> +	}
> +}
> +
> +static int dp_extcon_create_workqueue(struct dp_extcon_private *extcon_priv)
> +{
> +	extcon_priv->extcon_wq = create_singlethread_workqueue("drm_dp_extcon");

What's the benefit of using a dedicated workqueue instead of the system wq?

> +	if (IS_ERR_OR_NULL(extcon_priv->extcon_wq)) {
> +		pr_err("Error creating extcon wq\n");
> +		return -EPERM;
> +	}
> +
> +	INIT_WORK(&extcon_priv->event_work, dp_extcon_event_work);
> +
> +	return 0;

This function can't fail, so it should return void. In fact, this really doesn't
need to be a separate function, roll it into dp_extcon_register().

> +}
> +
> +static int dp_extcon_event_notify(struct notifier_block *nb,
> +				  unsigned long event, void *priv)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +
> +	extcon_priv = container_of(nb, struct dp_extcon_private,
> +						extcon_nb);
> +
> +	queue_work(extcon_priv->extcon_wq, &extcon_priv->event_work);
> +	return NOTIFY_DONE;
> +}
> +
> +int dp_extcon_register(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +	int ret = 0;
> +
> +	if (!dp_usbpd)
> +		return -EINVAL;
> +
> +	pr_err("Start++++");

Yikes, this doesn't look like an error!

> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	extcon_priv->extcon_nb.notifier_call = dp_extcon_event_notify;
> +	ret = devm_extcon_register_notifier(extcon_priv->dev, extcon_priv->extcon,
> +					    EXTCON_DISP_DP,
> +					    &extcon_priv->extcon_nb);
> +	if (ret) {
> +		dev_err(extcon_priv->dev,
> +			"register EXTCON_DISP_DP notifier err\n");
> +		ret = -EINVAL;

Why keep going and create the workqueue if we have no notifier? This should
probably be a return.

> +	}
> +
> +	ret = dp_extcon_create_workqueue(extcon_priv);
> +	if (ret) {
> +		pr_err("Failed to create workqueue\n");
> +		dp_extcon_unregister(dp_usbpd);

return ret?

> +	}
> +
> +	pr_err("End----");

Same here

> +	return ret;
> +}
> +
> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon_priv;
> +
> +	if (!dp_usbpd) {
> +		pr_err("Invalid input\n");
> +		return;
> +	}
> +
> +	pr_err("Start++++");

remove.

> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	devm_extcon_unregister_notifier(extcon_priv->dev, extcon_priv->extcon,
> +					    EXTCON_DISP_DP,
> +					    &extcon_priv->extcon_nb);
> +
> +	if (extcon_priv->extcon_wq)
> +		destroy_workqueue(extcon_priv->extcon_wq);
> +
> +	pr_err("End----");

remove.

> +	return;
> +}
> +
> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb)
> +{
> +	int rc = 0;
> +	struct dp_extcon_private *dp_extcon;
> +	struct dp_usbpd *dp_usbpd;
> +
> +	if (!cb) {
> +		pr_err("invalid cb data\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	pr_err("%s: Start", __func__);

remove.

> +	dp_extcon = devm_kzalloc(dev, sizeof(*dp_extcon), GFP_KERNEL);
> +	if (!dp_extcon) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	dp_extcon->extcon = extcon_get_edev_by_phandle(dev, 0);
> +	if (!dp_extcon->extcon) {
> +		pr_err("invalid extcon data\n");
> +		rc = -EINVAL;
> +		devm_kfree(dev, dp_extcon);
> +		goto error;
> +        }
> +
> +	dp_extcon->dev = dev;
> +	dp_extcon->dp_cb = cb;
> +
> +	dp_extcon->dp_usbpd.connect = dp_extcon_connect;
> +	dp_usbpd = &dp_extcon->dp_usbpd;
> +
> +	pr_err("%s: end", __func__);

remove.

> +	return dp_usbpd;
> +error:

This label isn't useful, return directly where applicable.

> +	return ERR_PTR(rc);
> +}
> +
> +void dp_extcon_put(struct dp_usbpd *dp_usbpd)
> +{
> +	struct dp_extcon_private *extcon;
> +
> +	if (!dp_usbpd)
> +		return;
> +
> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
> +
> +	devm_kfree(extcon->dev, extcon);
> +
> +	pr_err("%s: end", __func__);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.h b/drivers/gpu/drm/msm/dp/dp_extcon.h
> new file mode 100644
> index 0000000..1f83a18
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.h
> @@ -0,0 +1,111 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_EXTCON_H_
> +#define _DP_EXTCON_H_
> +
> +//#include <linux/usb/usbpd.h>
> +
> +#include <linux/types.h>
> +#include <linux/device.h>
> +
> +/**
> + * enum dp_usbpd_port - usb/dp port type
> + * @DP_USBPD_PORT_NONE: port not configured
> + * @DP_USBPD_PORT_UFP_D: Upstream Facing Port - DisplayPort
> + * @DP_USBPD_PORT_DFP_D: Downstream Facing Port - DisplayPort
> + * @DP_USBPD_PORT_D_UFP_D: Both UFP & DFP - DisplayPort
> + */
> +
> +enum dp_usbpd_port {
> +	DP_USBPD_PORT_NONE,
> +	DP_USBPD_PORT_UFP_D,
> +	DP_USBPD_PORT_DFP_D,
> +	DP_USBPD_PORT_D_UFP_D,
> +};
> +
> +enum plug_orientation {
> +	ORIENTATION_NONE,
> +	ORIENTATION_CC1,
> +	ORIENTATION_CC2,
> +};
> +
> +/**
> + * struct dp_usbpd - DisplayPort status
> + *
> + * @port: port configured
> + * orientation: plug orientation configuration
> + * @low_pow_st: low power state
> + * @adaptor_dp_en: adaptor functionality enabled
> + * @multi_func: multi-function preferred
> + * @usb_config_req: request to switch to usb
> + * @exit_dp_mode: request exit from displayport mode
> + * @hpd_high: Hot Plug Detect signal is high.
> + * @hpd_irq: Change in the status since last message
> + * @alt_mode_cfg_done: bool to specify alt mode status
> + * @debug_en: bool to specify debug mode
> + * @connect: simulate disconnect or connect for debug mode
> + */
> +struct dp_usbpd {
> +	enum dp_usbpd_port port;
> +	enum plug_orientation orientation;
> +	bool low_pow_st;
> +	bool adaptor_dp_en;
> +	bool multi_func;
> +	bool usb_config_req;
> +	bool exit_dp_mode;
> +	bool hpd_high;
> +	bool hpd_irq;
> +	bool alt_mode_cfg_done;
> +	bool debug_en;
> +	bool forced_disconnect;
> +
> +	int (*connect)(struct dp_usbpd *dp_usbpd, bool hpd);
> +};
> +
> +/**
> + * struct dp_usbpd_cb - callback functions provided by the client
> + *
> + * @configure: called by usbpd module when PD communication has
> + * been completed and the usb peripheral has been configured on
> + * dp mode.
> + * @disconnect: notify the cable disconnect issued by usb.
> + * @attention: notify any attention message issued by usb.
> + */
> +struct dp_usbpd_cb {
> +	int (*configure)(struct device *dev);
> +	int (*disconnect)(struct device *dev);
> +	int (*attention)(struct device *dev);
> +};
> +
> +/**
> + * dp_extcon_get() - setup usbpd module
> + *
> + * @dev: device instance of the caller
> + * @cb: struct containing callback function pointers.
> + *
> + * This function allows the client to initialize the usbpd
> + * module. The module will communicate with usb driver and
> + * handles the power delivery (PD) communication with the
> + * sink/usb device. This module will notify the client using
> + * the callback functions about the connection and status.
> + */
> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb *cb);
> +
> +void dp_extcon_put(struct dp_usbpd *pd);
> +
> +int dp_extcon_register(struct dp_usbpd *dp_usbpd);
> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd);
> +
> +#endif /* _DP_EXTCON_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_link.c b/drivers/gpu/drm/msm/dp/dp_link.c
> new file mode 100644
> index 0000000..5ab1efc
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_link.c
> @@ -0,0 +1,1549 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include "dp_link.h"
> +#include "dp_panel.h"
> +
> +enum dynamic_range {
> +	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
> +	DP_DYNAMIC_RANGE_RGB_CEA = 0x01,
> +	DP_DYNAMIC_RANGE_UNKNOWN = 0xFFFFFFFF,
> +};

These should be in drm_dp_helper.h

> +
> +enum audio_sample_rate {
> +	AUDIO_SAMPLE_RATE_32_KHZ	= 0x00,
> +	AUDIO_SAMPLE_RATE_44_1_KHZ	= 0x01,
> +	AUDIO_SAMPLE_RATE_48_KHZ	= 0x02,
> +	AUDIO_SAMPLE_RATE_88_2_KHZ	= 0x03,
> +	AUDIO_SAMPLE_RATE_96_KHZ	= 0x04,
> +	AUDIO_SAMPLE_RATE_176_4_KHZ	= 0x05,
> +	AUDIO_SAMPLE_RATE_192_KHZ	= 0x06,
> +};
> +
> +enum audio_pattern_type {
> +	AUDIO_TEST_PATTERN_OPERATOR_DEFINED	= 0x00,
> +	AUDIO_TEST_PATTERN_SAWTOOTH		= 0x01,
> +};
> +
> +struct dp_link_request {
> +	u32 test_requested;
> +	u32 test_link_rate;
> +	u32 test_lane_count;
> +};
> +
> +struct dp_link_private {
> +	u32 prev_sink_count;
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_link dp_link;
> +
> +	struct dp_link_request request;
> +	u8 link_status[DP_LINK_STATUS_SIZE];
> +};
> +
> +static char *dp_link_get_audio_test_pattern(u32 pattern)
> +{
> +	switch (pattern) {
> +	case AUDIO_TEST_PATTERN_OPERATOR_DEFINED:
> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_OPERATOR_DEFINED);
> +	case AUDIO_TEST_PATTERN_SAWTOOTH:
> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_SAWTOOTH);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static char *dp_link_get_audio_sample_rate(u32 rate)
> +{
> +	switch (rate) {
> +	case AUDIO_SAMPLE_RATE_32_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_32_KHZ);
> +	case AUDIO_SAMPLE_RATE_44_1_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_44_1_KHZ);
> +	case AUDIO_SAMPLE_RATE_48_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_48_KHZ);
> +	case AUDIO_SAMPLE_RATE_88_2_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_88_2_KHZ);
> +	case AUDIO_SAMPLE_RATE_96_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_96_KHZ);
> +	case AUDIO_SAMPLE_RATE_176_4_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_176_4_KHZ);
> +	case AUDIO_SAMPLE_RATE_192_KHZ:
> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_192_KHZ);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static int dp_link_get_period(struct dp_link_private *link, int const addr)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	u32 const param_len = 0x1;
> +	u32 const max_audio_period = 0xA;
> +
> +	/* TEST_AUDIO_PERIOD_CH_XX */
> +	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
> +		param_len) < param_len) {
> +		pr_err("failed to read test_audio_period (0x%x)\n", addr);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	data = bp;
> +
> +	/* Period - Bits 3:0 */
> +	data = data & 0xF;
> +	if ((int)data > max_audio_period) {
> +		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	ret = data;
> +exit:
> +	return ret;
> +}
> +
> +static int dp_link_parse_audio_channel_period(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	struct dp_link_test_audio *req = &link->dp_link.test_audio;
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_1 = ret;
> +	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_2 = ret;
> +	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
> +
> +	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_3 = ret;
> +	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_4 = ret;
> +	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_5 = ret;
> +	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_6 = ret;
> +	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_7 = ret;
> +	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
> +
> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
> +	if (ret == -EINVAL)
> +		goto exit;
> +
> +	req->test_audio_period_ch_8 = ret;
> +	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
> +exit:
> +	return ret;
> +}
> +
> +static int dp_link_parse_audio_pattern_type(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	int rlen;
> +	int const param_len = 0x1;
> +	int const max_audio_pattern_type = 0x1;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
> +		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link audio mode data\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	/* Audio Pattern Type - Bits 7:0 */
> +	if ((int)data > max_audio_pattern_type) {
> +		pr_err("invalid audio pattern type = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_audio.test_audio_pattern_type = data;
> +	pr_debug("audio pattern type = %s\n",
> +			dp_link_get_audio_test_pattern(data));
> +exit:
> +	return ret;
> +}
> +
> +static int dp_link_parse_audio_mode(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;
> +	int rlen;
> +	int const param_len = 0x1;
> +	int const max_audio_sampling_rate = 0x6;
> +	int const max_audio_channel_count = 0x8;
> +	int sampling_rate = 0x0;
> +	int channel_count = 0x0;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link audio mode data\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	/* Sampling Rate - Bits 3:0 */
> +	sampling_rate = data & 0xF;
> +	if (sampling_rate > max_audio_sampling_rate) {
> +		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
> +				sampling_rate, max_audio_sampling_rate);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	/* Channel Count - Bits 7:4 */
> +	channel_count = ((data & 0xF0) >> 4) + 1;
> +	if (channel_count > max_audio_channel_count) {
> +		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
> +				channel_count, max_audio_channel_count);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
> +	link->dp_link.test_audio.test_audio_channel_count = channel_count;
> +	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
> +		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
> +exit:
> +	return ret;
> +}
> +
> +/**
> + * dp_parse_audio_pattern_params() - parses audio pattern parameters from DPCD
> + * @link: Display Port Driver data
> + *
> + * Returns 0 if it successfully parses the audio link pattern parameters.
> + */
> +static int dp_link_parse_audio_pattern_params(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +
> +	ret = dp_link_parse_audio_mode(link);
> +	if (ret)
> +		goto exit;
> +
> +	ret = dp_link_parse_audio_pattern_type(link);
> +	if (ret)
> +		goto exit;
> +
> +	ret = dp_link_parse_audio_channel_period(link);
> +
> +exit:
> +	return ret;
> +}
> +
> +/**
> + * dp_link_is_video_pattern_valid() - validates the video pattern
> + * @pattern: video pattern requested by the sink
> + *
> + * Returns true if the requested video pattern is supported.
> + */
> +static bool dp_link_is_video_pattern_valid(u32 pattern)
> +{
> +	switch (pattern) {
> +	case DP_NO_TEST_PATTERN:
> +	case DP_COLOR_RAMP:
> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
> +	case DP_COLOR_SQUARE:
> +		return true;
> +	default:
> +		return false;
> +	}
> +}
> +
> +static char *dp_link_video_pattern_to_string(u32 test_video_pattern)
> +{
> +	switch (test_video_pattern) {
> +	case DP_NO_TEST_PATTERN:
> +		return DP_LINK_ENUM_STR(DP_NO_TEST_PATTERN);
> +	case DP_COLOR_RAMP:
> +		return DP_LINK_ENUM_STR(DP_COLOR_RAMP);
> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
> +		return DP_LINK_ENUM_STR(DP_BLACK_AND_WHITE_VERTICAL_LINES);
> +	case DP_COLOR_SQUARE:
> +		return DP_LINK_ENUM_STR(DP_COLOR_SQUARE);
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +/**
> + * dp_link_is_dynamic_range_valid() - validates the dynamic range
> + * @bit_depth: the dynamic range value to be checked
> + *
> + * Returns true if the dynamic range value is supported.
> + */
> +static bool dp_link_is_dynamic_range_valid(u32 dr)
> +{
> +	switch (dr) {
> +	case DP_DYNAMIC_RANGE_RGB_VESA:
> +	case DP_DYNAMIC_RANGE_RGB_CEA:
> +		return true;
> +	default:
> +		return false;
> +	}
> +}
> +
> +static char *dp_link_dynamic_range_to_string(u32 dr)
> +{
> +	switch (dr) {
> +	case DP_DYNAMIC_RANGE_RGB_VESA:
> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_VESA);
> +	case DP_DYNAMIC_RANGE_RGB_CEA:
> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_CEA);
> +	case DP_DYNAMIC_RANGE_UNKNOWN:
> +	default:
> +		return "unknown";
> +	}
> +}

No need for this, just print the value in the debug statement.

> +
> +/**
> + * dp_link_is_bit_depth_valid() - validates the bit depth requested
> + * @bit_depth: bit depth requested by the sink
> + *
> + * Returns true if the requested bit depth is supported.
> + */
> +static bool dp_link_is_bit_depth_valid(u32 tbd)
> +{
> +	/* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */
> +	switch (tbd) {
> +	case DP_TEST_BIT_DEPTH_6:
> +	case DP_TEST_BIT_DEPTH_8:
> +	case DP_TEST_BIT_DEPTH_10:
> +		return true;
> +	default:
> +		return false;
> +	}
> +}
> +
> +static char *dp_link_bit_depth_to_string(u32 tbd)
> +{
> +	switch (tbd) {
> +	case DP_TEST_BIT_DEPTH_6:
> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_6);
> +	case DP_TEST_BIT_DEPTH_8:
> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_8);
> +	case DP_TEST_BIT_DEPTH_10:
> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_10);
> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
> +	default:
> +		return "unknown";
> +	}
> +}

Same thing here, just remove this and print the enum value.

> +
> +static int dp_link_parse_timing_params1(struct dp_link_private *link,
> +					int const addr, int const len, u32 *val)

pass-by-value doesn't need const same comment applies elsewhere, please sweep
the code for other instances.

> +{
> +	u8 bp[2];
> +	int rlen;
> +
> +	if (len < 2)

If you're going to check len < 2, you should probably also check len > 2 to
prevent overflow. At this point, len can really only be 2, so you can just remove
it entirely as an argument.

> +		return -EINVAL;
> +
> +	/* Read the requested video link pattern (Byte 0x221). */
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
> +	if (rlen < len) {
> +		pr_err("failed to read 0x%x\n", addr);
> +		return -EINVAL;
> +	}
> +
> +	*val = bp[1] | (bp[0] << 8);
> +
> +	return 0;
> +}
> +
> +static int dp_link_parse_timing_params2(struct dp_link_private *link,
> +					int const addr, int const len,
> +					u32 *val1, u32 *val2)
> +{
> +	u8 bp[2];
> +	int rlen;
> +
> +	if (len < 2)

Same comment here rt bounds checking

> +		return -EINVAL;
> +
> +	/* Read the requested video link pattern (Byte 0x221). */
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
> +	if (rlen < len) {
> +		pr_err("failed to read 0x%x\n", addr);
> +		return -EINVAL;
> +	}
> +
> +	*val1 = (bp[0] & BIT(7)) >> 7;
> +	*val2 = bp[1] | ((bp[0] & 0x7F) << 8);
> +
> +	return 0;
> +}
> +
> +static int dp_link_parse_timing_params3(struct dp_link_private *link,
> +					int const addr, u32 *val)
> +{
> +	u8 bp;
> +	u32 len = 1;
> +	int rlen;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp, len);
> +	if (rlen < 1) {
> +		pr_err("failed to read 0x%x\n", addr);
> +		return -EINVAL;
> +	}
> +	*val = bp;
> +
> +	return 0;
> +}

Putting aside the uninformative names, these dp_link_parse_timing_params*
can be combined into one pretty easily, like:

static int dp_link_read_u32(struct dp_link_private *link, unsigned int offset,
		            u32 *val, int num_bytes)
{
        int i;
        ssize_t ret;
        __be32 tmp_val;

        for (i = 0; num_bytes > 0; i += sizeof(*val)) {
                int to_read = min(sizeof(tmp_val), num_bytes);

                tmp_val = 0;
                ret = drm_dp_dpcd_read(link->aux->drm_aux, offset + i, &tmp_val,
                                       to_read);
                if (rlen < 0) {
                        /* print error message here */
                        return rlen;
                }
                val[i] = be32_to_cpu(tmp_val);
                num_bytes -= to_read;
        }
        return 0;
}

If you need to strip off the first bit, do it from the caller.

I didn't compile or test this, so it might need tweaking, but you get the idea.


> +
> +/**
> + * dp_parse_video_pattern_params() - parses video pattern parameters from DPCD
> + * @link: Display Port Driver data
> + *
> + * Returns 0 if it successfully parses the video link pattern and the link
> + * bit depth requested by the sink and, and if the values parsed are valid.
> + */
> +static int dp_link_parse_video_pattern_params(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	int rlen;

ssize_t

> +	u8 bp;
> +	u8 data;

Why do you need data and bp? I think you only need one.

> +	u32 dyn_range;
> +	int const param_len = 0x1;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PATTERN,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link video pattern\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	if (!dp_link_is_video_pattern_valid(data)) {
> +		pr_err("invalid link video pattern = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_video.test_video_pattern = data;
> +	pr_debug("link video pattern = 0x%x (%s)\n",
> +		link->dp_link.test_video.test_video_pattern,
> +		dp_link_video_pattern_to_string(
> +			link->dp_link.test_video.test_video_pattern));
> +
> +	/* Read the requested color bit depth and dynamic range (Byte 0x232) */
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_MISC0,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link bit depth\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	/* Dynamic Range */
> +	dyn_range = (data & DP_TEST_DYNAMIC_RANGE_CEA) >> 3;

This mask isolates one bit from data

> +	if (!dp_link_is_dynamic_range_valid(dyn_range)) {

and this function returns true if the input is 0 || 1

So remove this code, and remove dp_link_is_dynamic_range_valid.

> +		pr_err("invalid link dynamic range = 0x%x", dyn_range);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	link->dp_link.test_video.test_dyn_range = dyn_range;

And now you can just assign this directly. You should probably stay consistent
and store the value shifted like the other values you're storing.

> +	pr_debug("link dynamic range = 0x%x (%s)\n",
> +		link->dp_link.test_video.test_dyn_range,
> +		dp_link_dynamic_range_to_string(
> +			link->dp_link.test_video.test_dyn_range));
> +
> +	/* Color bit depth */
> +	data &= DP_TEST_BIT_DEPTH_MASK;
> +	if (!dp_link_is_bit_depth_valid(data)) {
> +		pr_err("invalid link bit depth = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->dp_link.test_video.test_bit_depth = data;
> +	pr_debug("link bit depth = 0x%x (%s)\n",
> +		link->dp_link.test_video.test_bit_depth,
> +		dp_link_bit_depth_to_string(
> +		link->dp_link.test_video.test_bit_depth));
> +
> +	/* resolution timing params */
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
> +			&link->dp_link.test_video.test_h_total);
> +	if (ret) {
> +		pr_err("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_H_TOTAL = %d\n", link->dp_link.test_video.test_h_total);
> +
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
> +			&link->dp_link.test_video.test_v_total);
> +	if (ret) {
> +		pr_err("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_V_TOTAL = %d\n", link->dp_link.test_video.test_v_total);
> +
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
> +			&link->dp_link.test_video.test_h_start);
> +	if (ret) {
> +		pr_err("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_H_START = %d\n", link->dp_link.test_video.test_h_start);
> +
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
> +			&link->dp_link.test_video.test_v_start);
> +	if (ret) {
> +		pr_err("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_V_START = %d\n", link->dp_link.test_video.test_v_start);
> +
> +	ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
> +			&link->dp_link.test_video.test_hsync_pol,
> +			&link->dp_link.test_video.test_hsync_width);
> +	if (ret) {
> +		pr_err("failed to parse (DP_TEST_HSYNC_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_HSYNC_POL = %d\n",
> +		link->dp_link.test_video.test_hsync_pol);
> +	pr_debug("TEST_HSYNC_WIDTH = %d\n",
> +		link->dp_link.test_video.test_hsync_width);
> +
> +	ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
> +			&link->dp_link.test_video.test_vsync_pol,
> +			&link->dp_link.test_video.test_vsync_width);
> +	if (ret) {
> +		pr_err("failed to parse (DP_TEST_VSYNC_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_VSYNC_POL = %d\n",
> +		link->dp_link.test_video.test_vsync_pol);
> +	pr_debug("TEST_VSYNC_WIDTH = %d\n",
> +		link->dp_link.test_video.test_vsync_width);
> +
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
> +			&link->dp_link.test_video.test_h_width);
> +	if (ret) {
> +		pr_err("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_H_WIDTH = %d\n", link->dp_link.test_video.test_h_width);
> +
> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
> +			&link->dp_link.test_video.test_v_height);
> +	if (ret) {
> +		pr_err("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_V_HEIGHT = %d\n",
> +		link->dp_link.test_video.test_v_height);
> +
> +	ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
> +		&link->dp_link.test_video.test_rr_d);
> +	link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
> +	if (ret) {
> +		pr_err("failed to parse test_rr_d (DP_TEST_MISC1)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_REFRESH_DENOMINATOR = %d\n",
> +		link->dp_link.test_video.test_rr_d);
> +
> +	ret = dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR,
> +		&link->dp_link.test_video.test_rr_n);
> +	if (ret) {
> +		pr_err("failed to parse test_rr_n (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
> +		goto exit;
> +	}
> +	pr_debug("TEST_REFRESH_NUMERATOR = %d\n",
> +		link->dp_link.test_video.test_rr_n);

Instead of sprinkling all of these pr_debug messages around, just have one big
debug at the end to print everything.

> +exit:

This label isn't useful, just return directly above

> +	return ret;
> +}
> +
> +/**
> + * dp_link_parse_link_training_params() - parses link training parameters from
> + * DPCD
> + * @link: Display Port Driver data
> + *
> + * Returns 0 if it successfully parses the link rate (Byte 0x219) and lane
> + * count (Byte 0x220), and if these values parse are valid.
> + */
> +static int dp_link_parse_link_training_params(struct dp_link_private *link)
> +{
> +	u8 bp;
> +	u8 data;

You don't need both bp and data

> +	int ret = 0;
> +	int rlen;

ssize_t

> +	int const param_len = 0x1;

Just use 1 directly below.

> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LINK_RATE,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read link rate\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +
> +	if (!is_link_rate_valid(data)) {
> +		pr_err("invalid link rate = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->request.test_link_rate = data;
> +	pr_debug("link rate = 0x%x\n", link->request.test_link_rate);
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LANE_COUNT,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read lane count\n");
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +	data = bp;
> +	data &= 0x1F;

DP_MAX_LANE_COUNT_MASK

> +
> +	if (!is_lane_count_valid(data)) {

You might also want to data against max lanes

> +		pr_err("invalid lane count = 0x%x\n", data);
> +		ret = -EINVAL;
> +		goto exit;
> +	}
> +
> +	link->request.test_lane_count = data;
> +	pr_debug("lane count = 0x%x\n", link->request.test_lane_count);
> +exit:
> +	return ret;

return directly above and remove exit + ret;

> +}
> +
> +static bool dp_link_is_phy_test_pattern_supported(u32 phy_test_pattern_sel)
> +{
> +	switch (phy_test_pattern_sel) {
> +	case DP_TEST_PHY_PATTERN_NONE:
> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
> +	case DP_TEST_PHY_PATTERN_PRBS7:
> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
> +		return true;
> +	default:
> +		return false;
> +	}
> +}
> +
> +/**
> + * dp_parse_phy_test_params() - parses the phy link parameters
> + * @link: Display Port Driver data
> + *
> + * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is being
> + * requested.
> + */
> +static int dp_link_parse_phy_test_params(struct dp_link_private *link)
> +{
> +	u8 bp;
> +	u8 data;

Only need one of these.

> +	int rlen;

ssize_t

> +	int const param_len = 0x1;

Just use 1 below

> +	int ret = 0;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PHY_PATTERN,
> +			&bp, param_len);
> +	if (rlen < param_len) {

FWIW, drm_dp_dpcd_read will return either len or an -errno. Partial reads return
-EPROTO. So instead of checking that rlen < param_len, you can just do rlen < 0.

Please also change all of the 1-byte reads over to using drm_dp_dpcd_readb().


> +		pr_err("failed to read phy link pattern\n");

print and return rlen.

> +		ret = -EINVAL;
> +		goto end;
> +	}
> +
> +	data = bp;
> +
> +	link->dp_link.phy_params.phy_test_pattern_sel = data;
> +
> +	pr_debug("phy_test_pattern_sel = %s\n",
> +			dp_link_get_phy_test_pattern(data));
> +
> +	if (!dp_link_is_phy_test_pattern_supported(data))

Just embed that code here.

> +		ret = -EINVAL;
> +end:

Remove label/ret and return directly

> +	return ret;
> +}
> +
> +static char *dp_link_get_test_name(u32 test_requested)
> +{
> +	switch (test_requested) {
> +	case DP_TEST_LINK_TRAINING:
> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_TRAINING);
> +	case DP_TEST_LINK_VIDEO_PATTERN:
> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_VIDEO_PATTERN);
> +	case DP_TEST_LINK_EDID_READ:
> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_EDID_READ);
> +	case DP_TEST_LINK_PHY_TEST_PATTERN:
> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_PHY_TEST_PATTERN);
> +	case DP_TEST_LINK_AUDIO_PATTERN:
> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_AUDIO_PATTERN);
> +	default:
> +		return "unknown";
> +	}
> +}

Remove this and just print the enum.

> +
> +/**
> + * dp_link_is_video_audio_test_requested() - checks for audio/video link request
> + * @link: link requested by the sink
> + *
> + * Returns true if the requested link is a permitted audio/video link.
> + */
> +static bool dp_link_is_video_audio_test_requested(u32 link)
> +{

Should you be masking link to isolate these bits?

> +	return (link == DP_TEST_LINK_VIDEO_PATTERN) ||
> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
> +		DP_TEST_LINK_VIDEO_PATTERN)) ||
> +		(link == DP_TEST_LINK_AUDIO_PATTERN) ||
> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO));

And once you mask the value, just check if any of the bits are set instead of
enumerating all possible values.


> +}
> +
> +/**
> + * dp_link_supported() - checks if link requested by sink is supported
> + * @test_requested: link requested by the sink
> + *
> + * Returns true if the requested link is supported.
> + */
> +static bool dp_link_is_test_supported(u32 test_requested)
> +{
> +	return (test_requested == DP_TEST_LINK_TRAINING) ||
> +		(test_requested == DP_TEST_LINK_EDID_READ) ||
> +		(test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) ||
> +		dp_link_is_video_audio_test_requested(test_requested);

I think this all equates to:

	return test_requested != DP_TEST_LINK_FAUX_PATTERN;

and in that case, you can just remove this function and insert that condition in
the if statement below.

> +}
> +
> +static bool dp_link_is_test_edid_read(struct dp_link_private *link)
> +{
> +	return (link->request.test_requested == DP_TEST_LINK_EDID_READ);
> +}

This doesn't warrant its own function. Also, should this be & instead of ==?

> +
> +/**
> + * dp_sink_parse_test_request() - parses link request parameters from sink
> + * @link: Display Port Driver data
> + *
> + * Parses the DPCD to check if an automated link is requested (Byte 0x201),
> + * and what type of link automation is being requested (Byte 0x218).
> + */
> +static int dp_link_parse_request(struct dp_link_private *link)
> +{
> +	int ret = 0;
> +	u8 bp;
> +	u8 data;

Only need 1 of bp/data

> +	int rlen;

ssize_t

> +	u32 const param_len = 0x1;

Not needed, use drm_dp_dpcd_readb()

> +
> +	/**
> +	 * Read the device service IRQ vector (Byte 0x201) to determine
> +	 * whether an automated link has been requested by the sink.
> +	 */
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
> +		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("aux read failed\n");

Print error. This goes for other failure messages in this file.

> +		ret = -EINVAL;
> +		goto end;
> +	}
> +
> +	data = bp;
> +
> +	pr_debug("device service irq vector = 0x%x\n", data);
> +
> +	if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
> +		pr_debug("no test requested\n");
> +		return 0;
> +	}
> +
> +	/**
> +	 * Read the link request byte (Byte 0x218) to determine what type
> +	 * of automated link has been requested by the sink.
> +	 */
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("aux read failed\n");
> +		ret = -EINVAL;
> +		goto end;
> +	}
> +
> +	data = bp;
> +
> +	if (!dp_link_is_test_supported(data)) {
> +		pr_debug("link 0x%x not supported\n", data);
> +		goto end;
> +	}
> +
> +	pr_debug("%s (0x%x) requested\n", dp_link_get_test_name(data), data);
> +	link->request.test_requested = data;

If test_requested is only used in the scope of this function, just use a local
and pass it around. If test_requested is used outside the scope of this
function, you need locking.

> +
> +	if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) {
> +		ret = dp_link_parse_phy_test_params(link);
> +		if (ret)
> +			goto end;
> +		ret = dp_link_parse_link_training_params(link);

Check the return here or it could get stomped

> +	}
> +
> +	if (link->request.test_requested == DP_TEST_LINK_TRAINING)
> +		ret = dp_link_parse_link_training_params(link);

Check the return here or it could get stomped

> +
> +	if (dp_link_is_video_audio_test_requested(
> +			link->request.test_requested)) {

Should fit on 1 line, I think

> +		ret = dp_link_parse_video_pattern_params(link);
> +		if (ret)
> +			goto end;
> +
> +		ret = dp_link_parse_audio_pattern_params(link);

Check the return here or it could get stomped

> +	}
> +end:
> +	/**

/*

> +	 * Send a DP_TEST_ACK if all link parameters are valid, otherwise send
> +	 * a DP_TEST_NAK.
> +	 */
> +	if (ret) {
> +		link->dp_link.test_response = DP_TEST_NAK;
> +	} else {
> +		if (!dp_link_is_test_edid_read(link))
> +			link->dp_link.test_response = DP_TEST_ACK;
> +		else
> +			link->dp_link.test_response =
> +				DP_TEST_EDID_CHECKSUM_WRITE;
> +	}
> +
> +	return ret;
> +}
> +
> +/**
> + * dp_link_parse_sink_count() - parses the sink count
> + *
> + * Parses the DPCD to check if there is an update to the sink count
> + * (Byte 0x200), and whether all the sink devices connected have Content
> + * Protection enabled.
> + */
> +static int dp_link_parse_sink_count(struct dp_link *dp_link)
> +{
> +	int rlen;
> +	int const param_len = 0x1;

drm_dp_dpcd_readb

> +	struct dp_link_private *link = container_of(dp_link,
> +			struct dp_link_private, dp_link);
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_SINK_COUNT,
> +			&link->dp_link.sink_count.count, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed to read sink count\n");

print ret

> +		return -EINVAL;

return ret

> +	}
> +
> +	link->dp_link.sink_count.cp_ready =
> +		link->dp_link.sink_count.count & DP_SINK_CP_READY;

cp_ready is only used in this function, please don't store stuff like this
beyond its scope.

> +	/* BIT 7, BIT 5:0 */

Don't need this comment

> +	link->dp_link.sink_count.count =
> +		DP_GET_SINK_COUNT(link->dp_link.sink_count.count);
> +
> +	pr_debug("sink_count = 0x%x, cp_ready = 0x%x\n",
> +		link->dp_link.sink_count.count,
> +		link->dp_link.sink_count.cp_ready);
> +	return 0;
> +}
> +
> +static void dp_link_parse_sink_status_field(struct dp_link_private *link)
> +{
> +	int len = 0;
> +
> +	link->prev_sink_count = link->dp_link.sink_count.count;
> +	dp_link_parse_sink_count(&link->dp_link);
> +
> +	len = drm_dp_dpcd_read_link_status(link->aux->drm_aux,
> +		link->link_status);
> +	if (len < DP_LINK_STATUS_SIZE)
> +		pr_err("DP link status read failed\n");
> +	dp_link_parse_request(link);
> +}
> +
> +static bool dp_link_is_link_training_requested(struct dp_link_private *link)
> +{
> +	return (link->request.test_requested == DP_TEST_LINK_TRAINING);
> +}

No need for dedicated function

> +
> +/**
> + * dp_link_process_link_training_request() - processes new training requests
> + * @link: Display Port link data
> + *
> + * This function will handle new link training requests that are initiated by
> + * the sink. In particular, it will update the requested lane count and link
> + * link rate, and then trigger the link retraining procedure.
> + *
> + * The function will return 0 if a link training request has been processed,
> + * otherwise it will return -EINVAL.
> + */
> +static int dp_link_process_link_training_request(struct dp_link_private *link)
> +{
> +	if (!dp_link_is_link_training_requested(link))
> +		return -EINVAL;
> +
> +	pr_debug("%s link rate = 0x%x, lane count = 0x%x\n",
> +			dp_link_get_test_name(DP_TEST_LINK_TRAINING),
> +			link->request.test_link_rate,
> +			link->request.test_lane_count);
> +
> +	link->dp_link.link_params.lane_count = link->request.test_lane_count;
> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;

Should be using dp helper structs for this stuff

> +
> +	return 0;
> +}
> +
> +static void dp_link_send_test_response(struct dp_link *dp_link)
> +{
> +	struct dp_link_private *link = NULL;
> +	u32 const response_len = 0x1;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
> +			&dp_link->test_response, response_len);

I strongly suspect you should have locking protecting test_response.

> +}
> +
> +static int dp_link_psm_config(struct dp_link *dp_link,
> +			      struct drm_dp_link *link_info, bool enable)

This is another racy function where you could be simultaneously powering up and
powering down the link. So you might want some locking.

> +{
> +	struct dp_link_private *link = NULL;
> +	int ret = 0;
> +
> +	if (!dp_link) {
> +		pr_err("invalid params\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	if (enable)
> +		ret = drm_dp_link_power_down(link->aux->drm_aux, link_info);
> +	else
> +		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
> +
> +	if (ret)
> +		pr_err("Failed to %s low power mode\n",
> +			(enable ? "enter" : "exit"));

unneeded (). You could probably reword to fit on one line too

> +	else
> +		dp_link->psm_enabled = enable;
> +
> +	return ret;
> +}
> +
> +static void dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum)
> +{
> +	struct dp_link_private *link = NULL;
> +	u32 const response_len = 0x1;

drm_dp_dpcd_readb. I'll stop commenting on these, just please go through and
convert all 1-byte reads/writes

> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_EDID_CHECKSUM,
> +			&checksum, response_len);

Check and return the result

> +}
> +
> +static int dp_link_parse_vx_px(struct dp_link_private *link)
> +{
> +	u8 bp;
> +	u8 data;

Only need one of these

> +	int const param_len = 0x1;

drm_dp_dpcd_readb

> +	int ret = 0;
> +	u32 v0, p0, v1, p1, v2, p2, v3, p3;
> +	int rlen;

ssize_t

> +
> +	pr_debug("\n");

remove

> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE0_1,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed reading lanes 0/1\n");

print error

> +		ret = -EINVAL;
> +		goto end;
> +	}
> +
> +	data = bp;
> +
> +	pr_debug("lanes 0/1 (Byte 0x206): 0x%x\n", data);
> +
> +	v0 = data & 0x3;
> +	data = data >> 2;
> +	p0 = data & 0x3;
> +	data = data >> 2;
> +
> +	v1 = data & 0x3;
> +	data = data >> 2;
> +	p1 = data & 0x3;
> +	data = data >> 2;
> +
> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_ADJUST_REQUEST_LANE2_3,
> +			&bp, param_len);
> +	if (rlen < param_len) {
> +		pr_err("failed reading lanes 2/3\n");
> +		ret = -EINVAL;
> +		goto end;
> +	}
> +
> +	data = bp;
> +
> +	pr_debug("lanes 2/3 (Byte 0x207): 0x%x\n", data);
> +
> +	v2 = data & 0x3;
> +	data = data >> 2;
> +	p2 = data & 0x3;
> +	data = data >> 2;
> +
> +	v3 = data & 0x3;
> +	data = data >> 2;
> +	p3 = data & 0x3;
> +	data = data >> 2;

I think you can use drm_dp_get_adjust_request_voltage() for all of this.

> +
> +	pr_debug("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
> +	pr_debug("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
> +
> +	/**
> +	 * Update the voltage and pre-emphasis levels as per DPCD request
> +	 * vector.
> +	 */
> +	pr_debug("Current: v_level = 0x%x, p_level = 0x%x\n",
> +			link->dp_link.phy_params.v_level,
> +			link->dp_link.phy_params.p_level);
> +	pr_debug("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
> +	link->dp_link.phy_params.v_level = v0;
> +	link->dp_link.phy_params.p_level = p0;
> +
> +	pr_debug("Success\n");

Remove

> +end:

return directly everywhere and remove end & ret

> +	return ret;
> +}
> +
> +/**
> + * dp_link_process_phy_test_pattern_request() - process new phy link requests
> + * @link: Display Port Driver data
> + *
> + * This function will handle new phy link pattern requests that are initiated
> + * by the sink. The function will return 0 if a phy link pattern has been
> + * processed, otherwise it will return -EINVAL.
> + */
> +static int dp_link_process_phy_test_pattern_request(
> +		struct dp_link_private *link)
> +{
> +	u32 test_link_rate = 0, test_lane_count = 0;
> +
> +	if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) {

Is test_requested always expected to have this value populated when
dp_link_process_request()?

> +		pr_debug("no phy test\n");
> +		return -EINVAL;
> +	}
> +
> +	test_link_rate = link->request.test_link_rate;
> +	test_lane_count = link->request.test_lane_count;

Just use these values directly instead of adding more locals.

> +
> +	if (!is_link_rate_valid(test_link_rate) ||
> +		!is_lane_count_valid(test_lane_count)) {
> +		pr_err("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
> +				test_link_rate, test_lane_count);
> +		return -EINVAL;
> +	}
> +
> +	pr_debug("start\n");

Remove

> +
> +	pr_info("Current: bw_code = 0x%x, lane count = 0x%x\n",
> +			link->dp_link.link_params.bw_code,
> +			link->dp_link.link_params.lane_count);
> +
> +	pr_info("Requested: bw_code = 0x%x, lane count = 0x%x\n",
> +			test_link_rate, test_lane_count);

These should be debug level prints

> +
> +	link->dp_link.link_params.lane_count = link->request.test_lane_count;
> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;
> +
> +	dp_link_parse_vx_px(link);

Check return value and propagate it.

> +
> +	pr_debug("end\n");

Remove

> +
> +	return 0;
> +}
> +
> +static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r)
> +{
> +	return link_status[r - DP_LANE0_1_STATUS];

I don't think you're really supposed to reach into the link_status like this.
How about adding a new helper to check for DP_LINK_STATUS_UPDATED and one for
DP_DOWNSTREAM_PORT_STATUS_CHANGED?

> +}
> +
> +/**
> + * dp_link_process_link_status_update() - processes link status updates
> + * @link: Display Port link module data
> + *
> + * This function will check for changes in the link status, e.g. clock
> + * recovery done on all lanes, and trigger link training if there is a
> + * failure/error on the link.
> + *
> + * The function will return 0 if the a link status update has been processed,
> + * otherwise it will return -EINVAL.
> + */
> +static int dp_link_process_link_status_update(struct dp_link_private *link)
> +{
> +	if (!(get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) &
> +		DP_LINK_STATUS_UPDATED) || /* link status updated */
> +		(drm_dp_clock_recovery_ok(link->link_status,
> +			link->dp_link.link_params.lane_count) &&
> +	     drm_dp_channel_eq_ok(link->link_status,
> +			link->dp_link.link_params.lane_count)))

Can you please fix the alignment here, it's tough to read.

> +		return -EINVAL;
> +
> +	pr_debug("channel_eq_done = %d, clock_recovery_done = %d\n",
> +			drm_dp_clock_recovery_ok(link->link_status,
> +			link->dp_link.link_params.lane_count),
> +			drm_dp_clock_recovery_ok(link->link_status,
> +			link->dp_link.link_params.lane_count));
> +
> +	return 0;
> +}
> +
> +static bool dp_link_is_ds_port_status_changed(struct dp_link_private *link)
> +{
> +	if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) &
> +		DP_DOWNSTREAM_PORT_STATUS_CHANGED) /* port status changed */
> +		return true;
> +
> +	if (link->prev_sink_count != link->dp_link.sink_count.count)

It seems like this is running in a separate thread from where prev_sink_count is
set, potential race here?

> +		return true;
> +
> +	return false;

	return link->prev_sink_count != link->dp_link.sink_count.count;

> +}
> +
> +/**
> + * dp_link_process_downstream_port_status_change() - process port status changes
> + * @link: Display Port Driver data
> + *
> + * This function will handle downstream port updates that are initiated by
> + * the sink. If the downstream port status has changed, the EDID is read via
> + * AUX.
> + *
> + * The function will return 0 if a downstream port update has been
> + * processed, otherwise it will return -EINVAL.
> + */
> +static int dp_link_process_ds_port_status_change(struct dp_link_private *link)
> +{
> +	if (!dp_link_is_ds_port_status_changed(link))

Just embed the contents of is_ds_port_status_changed here, no need for 2 funcs

> +		return -EINVAL;
> +
> +	/* reset prev_sink_count */
> +	link->prev_sink_count = link->dp_link.sink_count.count;
> +
> +	return 0;
> +}
> +
> +static bool dp_link_is_video_pattern_requested(struct dp_link_private *link)
> +{
> +	return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN)
> +		&& !(link->request.test_requested &
> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
> +}
> +
> +static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link)
> +{
> +	return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN);
> +}
> +
> +/**
> + * dp_link_process_video_pattern_request() - process new video pattern request
> + * @link: Display Port link module's data
> + *
> + * This function will handle a new video pattern request that are initiated by
> + * the sink. This is acheieved by first sending a disconnect notification to
> + * the sink followed by a subsequent connect notification to the user modules,
> + * where it is expected that the user modules would draw the required link
> + * pattern.
> + */
> +static int dp_link_process_video_pattern_request(struct dp_link_private *link)
> +{
> +	if (!dp_link_is_video_pattern_requested(link))

Just do this directly in dp_link_process_request and get rid of this function

> +		goto end;
> +
> +	pr_debug("%s: bit depth=%d(%d bpp) pattern=%s\n",
> +		dp_link_get_test_name(DP_TEST_LINK_VIDEO_PATTERN),
> +		link->dp_link.test_video.test_bit_depth,
> +		dp_link_bit_depth_to_bpp(
> +		link->dp_link.test_video.test_bit_depth),
> +		dp_link_video_pattern_to_string(
> +			link->dp_link.test_video.test_video_pattern));
> +
> +	return 0;
> +end:
> +	return -EINVAL;
> +}
> +
> +/**
> + * dp_link_process_audio_pattern_request() - process new audio pattern request
> + * @link: Display Port link module data
> + *
> + * This function will handle a new audio pattern request that is initiated by
> + * the sink. This is acheieved by sending the necessary secondary data packets
> + * to the sink. It is expected that any simulatenous requests for video
> + * patterns will be handled before the audio pattern is sent to the sink.
> + */
> +static int dp_link_process_audio_pattern_request(struct dp_link_private *link)
> +{
> +	if (!dp_link_is_audio_pattern_requested(link))

Same here

> +		return -EINVAL;
> +
> +	pr_debug("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
> +		dp_link_get_audio_sample_rate(
> +			link->dp_link.test_audio.test_audio_sampling_rate),
> +		link->dp_link.test_audio.test_audio_channel_count,
> +		dp_link_get_audio_test_pattern(
> +			link->dp_link.test_audio.test_audio_pattern_type));
> +
> +	pr_debug("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
> +		link->dp_link.test_audio.test_audio_period_ch_1,
> +		link->dp_link.test_audio.test_audio_period_ch_2,
> +		link->dp_link.test_audio.test_audio_period_ch_3,
> +		link->dp_link.test_audio.test_audio_period_ch_4);
> +
> +	pr_debug("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
> +		link->dp_link.test_audio.test_audio_period_ch_5,
> +		link->dp_link.test_audio.test_audio_period_ch_6,
> +		link->dp_link.test_audio.test_audio_period_ch_7,
> +		link->dp_link.test_audio.test_audio_period_ch_8);
> +
> +	return 0;
> +}
> +
> +static void dp_link_reset_data(struct dp_link_private *link)
> +{
> +	link->request = (const struct dp_link_request){ 0 };
> +	link->dp_link.test_video = (const struct dp_link_test_video){ 0 };
> +	link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN;
> +	link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 };
> +	link->dp_link.phy_params.phy_test_pattern_sel = 0;
> +	link->dp_link.sink_request = 0;
> +	link->dp_link.test_response = 0;

	memset?

> +}
> +
> +/**
> + * dp_link_process_request() - handle HPD IRQ transition to HIGH
> + * @link: pointer to link module data
> + *
> + * This function will handle the HPD IRQ state transitions from LOW to HIGH
> + * (including cases when there are back to back HPD IRQ HIGH) indicating
> + * the start of a new link training request or sink status update.
> + */
> +static int dp_link_process_request(struct dp_link *dp_link)
> +{
> +	int ret = 0;
> +	struct dp_link_private *link;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	pr_debug("start\n");
> +
> +	dp_link_reset_data(link);
> +
> +	dp_link_parse_sink_status_field(link);
> +
> +	if (dp_link_is_test_edid_read(link)) {
> +		dp_link->sink_request |= DP_TEST_LINK_EDID_READ;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_ds_port_status_change(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DS_PORT_STATUS_CHANGED;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_link_training_request(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DP_TEST_LINK_TRAINING;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_phy_test_pattern_request(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_link_status_update(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DP_LINK_STATUS_UPDATED;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_video_pattern_request(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN;
> +		goto exit;
> +	}
> +
> +	ret = dp_link_process_audio_pattern_request(link);
> +	if (!ret) {
> +		dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN;
> +		goto exit;
> +	}
> +
> +	pr_debug("done\n");
> +exit:

remove exit & ret, just return values directly

> +	return ret;
> +}
> +
> +static int dp_link_get_colorimetry_config(struct dp_link *dp_link)
> +{
> +	u32 cc;
> +	enum dynamic_range dr;
> +	struct dp_link_private *link;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	/* unless a video pattern CTS test is ongoing, use CEA_VESA */

s/CEA_VESA/RGB_VESA?

> +	if (dp_link_is_video_pattern_requested(link))
> +		dr = link->dp_link.test_video.test_dyn_range;
> +	else
> +		dr = DP_DYNAMIC_RANGE_RGB_VESA;
> +
> +	/* Only RGB_VESA nd RGB_CEA supported for now */

s/nd/and/

> +	switch (dr) {
> +	case DP_DYNAMIC_RANGE_RGB_CEA:
> +		cc = BIT(3);
> +		break;
> +	case DP_DYNAMIC_RANGE_RGB_VESA:
> +	default:
> +		cc = 0;
> +	}

If you store the value shifted like I suggested, you don't have to do this
switch (which really should be an if anyways since the range is 0:1).

> +
> +	return cc;
> +}
> +
> +static int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status)
> +{
> +	int i;
> +	int max = 0;
> +	u8 data;
> +	struct dp_link_private *link;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	/* use the max level across lanes */
> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
> +		data = drm_dp_get_adjust_request_voltage(link_status, i);
> +		pr_debug("lane=%d req_voltage_swing=%d\n", i, data);
> +		if (max < data)
> +			max = data;
> +	}
> +
> +	dp_link->phy_params.v_level = max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
> +
> +	/* use the max level across lanes */
> +	max = 0;
> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
> +		data = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
> +		pr_debug("lane=%d req_pre_emphasis=%d\n", i, data);
> +		if (max < data)
> +			max = data;
> +	}

You can combine these loops and do the work at once (check out
intel_get_adjust_train)

> +
> +	dp_link->phy_params.p_level = max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
> +
> +	/**
> +	 * Adjust the voltage swing and pre-emphasis level combination to within
> +	 * the allowable range.
> +	 */
> +	if (dp_link->phy_params.v_level > DP_LINK_VOLTAGE_MAX) {
> +		pr_debug("Requested vSwingLevel=%d, change to %d\n",
> +			dp_link->phy_params.v_level, DP_LINK_VOLTAGE_MAX);
> +		dp_link->phy_params.v_level = DP_LINK_VOLTAGE_MAX;
> +	}
> +
> +	if (dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_MAX) {
> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
> +			dp_link->phy_params.p_level, DP_LINK_PRE_EMPHASIS_MAX);
> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_MAX;
> +	}
> +
> +	if ((dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_LEVEL_1)
> +		&& (dp_link->phy_params.v_level == DP_LINK_VOLTAGE_LEVEL_2)) {
> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
> +			dp_link->phy_params.p_level,
> +			DP_LINK_PRE_EMPHASIS_LEVEL_1);
> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_LEVEL_1;
> +	}
> +
> +	pr_debug("adjusted: v_level=%d, p_level=%d\n",
> +		dp_link->phy_params.v_level, dp_link->phy_params.p_level);
> +
> +	return 0;
> +}
> +
> +static int dp_link_send_psm_request(struct dp_link *dp_link, bool req)
> +{
> +	struct dp_link_private *link;
> +
> +	if (!dp_link) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);

This is a stub, why do this?

> +
> +	return 0;

Further, why have a stub at all? The hook is never called, so delete it all
please.

> +}
> +
> +static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp)
> +{
> +	u32 tbd;
> +
> +	/*
> +	 * Few simplistic rules and assumptions made here:
> +	 *    1. Test bit depth is bit depth per color component
> +	 *    2. Assume 3 color components
> +	 */
> +	switch (bpp) {
> +	case 18:
> +		tbd = DP_TEST_BIT_DEPTH_6;
> +		break;
> +	case 24:
> +		tbd = DP_TEST_BIT_DEPTH_8;
> +		break;
> +	case 30:
> +		tbd = DP_TEST_BIT_DEPTH_10;
> +		break;
> +	default:
> +		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
> +		break;
> +	}
> +
> +	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
> +		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);

AFAICT tbd corresponds to a SoC register value, as opposed to the DPCD value.
It's a happy coincidence that they're the same, however I think you should use a
separate msm-specific #define instead of the drm_dp_helper values.

> +
> +	return tbd;
> +}
> +
> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
> +{
> +	int rc = 0;
> +	struct dp_link_private *link;
> +	struct dp_link *dp_link;
> +
> +	if (!dev || !aux) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
> +	if (!link) {
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	link->dev   = dev;
> +	link->aux   = aux;
> +
> +	dp_link = &link->dp_link;
> +
> +	dp_link->process_request        = dp_link_process_request;
> +	dp_link->get_test_bits_depth    = dp_link_get_test_bits_depth;
> +	dp_link->get_colorimetry_config = dp_link_get_colorimetry_config;
> +	dp_link->adjust_levels          = dp_link_adjust_levels;
> +	dp_link->send_psm_request       = dp_link_send_psm_request;
> +	dp_link->send_test_response     = dp_link_send_test_response;
> +	dp_link->psm_config             = dp_link_psm_config;
> +	dp_link->send_edid_checksum     = dp_link_send_edid_checksum;
> +
> +	return dp_link;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_link_put(struct dp_link *dp_link)
> +{
> +	struct dp_link_private *link;
> +
> +	if (!dp_link)
> +		return;
> +
> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> +
> +	devm_kfree(link->dev, link);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_link.h b/drivers/gpu/drm/msm/dp/dp_link.h
> new file mode 100644
> index 0000000..6d6ef43
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_link.h
> @@ -0,0 +1,184 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_LINK_H_
> +#define _DP_LINK_H_
> +
> +#include "dp_aux.h"
> +
> +#define DS_PORT_STATUS_CHANGED 0x200
> +#define DP_TEST_BIT_DEPTH_UNKNOWN 0xFFFFFFFF
> +#define DP_LINK_ENUM_STR(x)		#x
> +
> +enum dp_link_voltage_level {
> +	DP_LINK_VOLTAGE_LEVEL_0	= 0,
> +	DP_LINK_VOLTAGE_LEVEL_1	= 1,
> +	DP_LINK_VOLTAGE_LEVEL_2	= 2,
> +	DP_LINK_VOLTAGE_MAX	= DP_LINK_VOLTAGE_LEVEL_2,
> +};

DP_TRAIN_VOLTAGE_SWING_*

> +
> +enum dp_link_preemaphasis_level {
> +	DP_LINK_PRE_EMPHASIS_LEVEL_0	= 0,
> +	DP_LINK_PRE_EMPHASIS_LEVEL_1	= 1,
> +	DP_LINK_PRE_EMPHASIS_LEVEL_2	= 2,
> +	DP_LINK_PRE_EMPHASIS_MAX	= DP_LINK_PRE_EMPHASIS_LEVEL_2,
> +};

DP_TRAIN_PRE_EMPH*

> +
> +struct dp_link_sink_count {
> +	u32 count;
> +	bool cp_ready;
> +};
> +
> +struct dp_link_test_video {
> +	u32 test_video_pattern;
> +	u32 test_bit_depth;
> +	u32 test_dyn_range;
> +	u32 test_h_total;
> +	u32 test_v_total;
> +	u32 test_h_start;
> +	u32 test_v_start;
> +	u32 test_hsync_pol;
> +	u32 test_hsync_width;
> +	u32 test_vsync_pol;
> +	u32 test_vsync_width;
> +	u32 test_h_width;
> +	u32 test_v_height;
> +	u32 test_rr_d;
> +	u32 test_rr_n;
> +};
> +
> +struct dp_link_test_audio {
> +	u32 test_audio_sampling_rate;
> +	u32 test_audio_channel_count;
> +	u32 test_audio_pattern_type;
> +	u32 test_audio_period_ch_1;
> +	u32 test_audio_period_ch_2;
> +	u32 test_audio_period_ch_3;
> +	u32 test_audio_period_ch_4;
> +	u32 test_audio_period_ch_5;
> +	u32 test_audio_period_ch_6;
> +	u32 test_audio_period_ch_7;
> +	u32 test_audio_period_ch_8;
> +};
> +
> +struct dp_link_phy_params {
> +	u32 phy_test_pattern_sel;
> +	u8 v_level;
> +	u8 p_level;
> +};
> +
> +struct dp_link_params {
> +	u32 lane_count;
> +	u32 bw_code;
> +};

Use drm_dp_link

> +
> +struct dp_link {
> +	u32 sink_request;
> +	u32 test_response;
> +	bool psm_enabled;
> +
> +	struct dp_link_sink_count sink_count;
> +	struct dp_link_test_video test_video;
> +	struct dp_link_test_audio test_audio;
> +	struct dp_link_phy_params phy_params;
> +	struct dp_link_params link_params;
> +
> +	u32 (*get_test_bits_depth)(struct dp_link *dp_link, u32 bpp);
> +	int (*process_request)(struct dp_link *dp_link);
> +	int (*get_colorimetry_config)(struct dp_link *dp_link);
> +	int (*adjust_levels)(struct dp_link *dp_link, u8 *link_status);
> +	int (*send_psm_request)(struct dp_link *dp_link, bool req);
> +	void (*send_test_response)(struct dp_link *dp_link);
> +	int (*psm_config)(struct dp_link *dp_link,
> +		struct drm_dp_link *link_info, bool enable);
> +	void (*send_edid_checksum)(struct dp_link *dp_link, u8 checksum);
> +};
> +
> +static inline char *dp_link_get_phy_test_pattern(u32 phy_test_pattern_sel)
> +{
> +	switch (phy_test_pattern_sel) {
> +	case DP_TEST_PHY_PATTERN_NONE:
> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_NONE);
> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING);
> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT);
> +	case DP_TEST_PHY_PATTERN_PRBS7:
> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_PRBS7);
> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN);
> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
> +		return DP_LINK_ENUM_STR(
> +			DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN);
> +	default:
> +		return "unknown";
> +	}
> +}

This is only used for debug statements, just remove it and print the enum as an
int. This will let you remove DP_LINK_ENUM_STR as well.

> +
> +/**
> + * mdss_dp_test_bit_depth_to_bpp() - convert test bit depth to bpp
> + * @tbd: test bit depth
> + *
> + * Returns the bits per pixel (bpp) to be used corresponding to the
> + * git bit depth value. This function assumes that bit depth has
> + * already been validated.
> + */
> +static inline u32 dp_link_bit_depth_to_bpp(u32 tbd)
> +{
> +	u32 bpp;
> +
> +	/*
> +	 * Few simplistic rules and assumptions made here:
> +	 *    1. Bit depth is per color component
> +	 *    2. If bit depth is unknown return 0
> +	 *    3. Assume 3 color components
> +	 */
> +	switch (tbd) {
> +	case DP_TEST_BIT_DEPTH_6:
> +		bpp = 18;
> +		break;
> +	case DP_TEST_BIT_DEPTH_8:
> +		bpp = 24;
> +		break;
> +	case DP_TEST_BIT_DEPTH_10:
> +		bpp = 30;
> +		break;
> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
> +	default:
> +		bpp = 0;
> +	}
> +
> +	return bpp;

Just return directly from each case.

> +}
> +
> +/**
> + * dp_link_get() - get the functionalities of dp test module
> + *
> + *
> + * return: a pointer to dp_link struct
> + */
> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux);
> +
> +/**
> + * dp_link_put() - releases the dp test module's resources
> + *
> + * @dp_link: an instance of dp_link module
> + *
> + */
> +void dp_link_put(struct dp_link *dp_link);
> +
> +#endif /* _DP_LINK_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.c b/drivers/gpu/drm/msm/dp/dp_panel.c
> new file mode 100644
> index 0000000..e497b44
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_panel.c
> @@ -0,0 +1,624 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include "dp_panel.h"
> +
> +#include <drm/drm_connector.h>
> +#include <drm/drm_edid.h>
> +
> +#define DP_PANEL_DEFAULT_BPP 24

unused

> +#define DP_MAX_DS_PORT_COUNT 1
> +
> +enum {
> +	DP_LINK_RATE_MULTIPLIER = 27000000,
> +};

unused

> +
> +struct dp_panel_private {
> +	struct device *dev;
> +	struct dp_panel dp_panel;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_catalog_panel *catalog;
> +	bool panel_on;
> +	bool aux_cfg_update_done;
> +};
> +
> +static const struct dp_panel_info fail_safe = {
> +	.h_active = 640,
> +	.v_active = 480,
> +	.h_back_porch = 48,
> +	.h_front_porch = 16,
> +	.h_sync_width = 96,
> +	.h_active_low = 0,
> +	.v_back_porch = 33,
> +	.v_front_porch = 10,
> +	.v_sync_width = 2,
> +	.v_active_low = 0,
> +	.h_skew = 0,
> +	.refresh_rate = 60,
> +	.pixel_clk_khz = 25200,
> +	.bpp = 24,
> +};

Drop this, userspace can add a mode if appropriate

> +
> +static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
> +{
> +	int rlen, rc = 0;
> +	struct dp_panel_private *panel;
> +	struct drm_dp_link *link_info;
> +	u8 *dpcd, major = 0, minor = 0;
> +	u32 dfp_count = 0;
> +	unsigned long caps = DP_LINK_CAP_ENHANCED_FRAMING;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	dpcd = dp_panel->dpcd;
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	link_info = &dp_panel->link_info;
> +
> +	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DPCD_REV,
> +		dpcd, (DP_RECEIVER_CAP_SIZE + 1));
> +	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
> +		pr_err("dpcd read failed, rlen=%d\n", rlen);
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	link_info->revision = dp_panel->dpcd[DP_DPCD_REV];
> +
> +	major = (link_info->revision >> 4) & 0x0f;
> +	minor = link_info->revision & 0x0f;
> +	pr_debug("version: %d.%d\n", major, minor);
> +
> +	link_info->rate =
> +		drm_dp_bw_code_to_link_rate(dp_panel->dpcd[DP_MAX_LINK_RATE]);
> +	pr_debug("link_rate=%d\n", link_info->rate);
> +
> +	link_info->num_lanes = dp_panel->dpcd[DP_MAX_LANE_COUNT] &
> +				DP_MAX_LANE_COUNT_MASK;
> +
> +	pr_debug("lane_count=%d\n", link_info->num_lanes);
> +
> +	if (drm_dp_enhanced_frame_cap(dpcd))
> +		link_info->capabilities |= caps;

All of the link_info initialization should be done by drm_dp_link_probe().

> +
> +	dfp_count = dpcd[DP_DOWN_STREAM_PORT_COUNT] &
> +						DP_DOWN_STREAM_PORT_COUNT;

Move this down to where it's used

> +
> +	if ((dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)
> +		&& (dpcd[DP_DPCD_REV] > 0x10)) {
> +		rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
> +			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
> +			DP_MAX_DOWNSTREAM_PORTS);
> +		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
> +			pr_err("ds port status failed, rlen=%d\n", rlen);
> +			rc = -EINVAL;
> +			goto end;
> +		}
> +	}

You don't use ds_ports anywhere, so remove this and remove ds_ports

> +
> +	if (dfp_count > DP_MAX_DS_PORT_COUNT)
> +		pr_debug("DS port count %d greater that max (%d) supported\n",
> +			dfp_count, DP_MAX_DS_PORT_COUNT);

Should this be an error?

> +
> +end:
> +	return rc;

Same drill as before

> +}
> +
> +static int dp_panel_set_default_link_params(struct dp_panel *dp_panel)
> +{

Let's just fail instead of doing this.

> +	struct drm_dp_link *link_info;
> +	const int default_bw_code = 162000;
> +	const int default_num_lanes = 1;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +	link_info = &dp_panel->link_info;
> +	link_info->rate = default_bw_code;
> +	link_info->num_lanes = default_num_lanes;
> +	pr_debug("link_rate=%d num_lanes=%d\n",
> +		link_info->rate, link_info->num_lanes);
> +	return 0;
> +}
> +
> +static int dp_panel_read_edid(struct dp_panel *dp_panel,
> +	struct drm_connector *connector)
> +{
> +	int retry_cnt = 0;
> +	const int max_retry = 10;
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	do {
> +		kfree(dp_panel->edid);
> +		dp_panel->edid = drm_get_edid(connector,
> +					      &panel->aux->drm_aux->ddc);
> +		if (!dp_panel->edid) {
> +			pr_err("EDID read failed\n");
> +			retry_cnt++;
> +			panel->aux->reconfig(panel->aux);
> +			panel->aux_cfg_update_done = true;
> +		} else {
> +			return 0;
> +		}
> +	} while (retry_cnt < max_retry);

The core will do retrys when aux reads fail, so you don't need to. With that,
you can just remove this function and call drm_get_edid in read_sink_caps

> +
> +	return -EINVAL;
> +}
> +
> +static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
> +	struct drm_connector *connector)
> +{
> +	int rc = 0;
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel || !connector) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	rc = dp_panel_read_dpcd(dp_panel);
> +	if (rc || !is_link_rate_valid(drm_dp_link_rate_to_bw_code(
> +		dp_panel->link_info.rate)) || !is_lane_count_valid(
> +		dp_panel->link_info.num_lanes) ||
> +		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
> +		dp_panel->max_bw_code)) {
> +		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
> +			pr_err("DPCD read failed, return early\n");
> +			return rc;
> +		}
> +		pr_err("panel dpcd read failed/incorrect, set default params\n");
> +		dp_panel_set_default_link_params(dp_panel);
> +	}

Since the defaults are going away, this gets simpler (and even simpler if you
stash bw_code):

	bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate);
	if (rc || !is_link_rate_valid(bw_code) ||
            !is_lane_count_valid(dp_panel->link_info.num_lanes) ||
	    bw_code > dp_panel->max_bw_code) {
		pr_err("read_dpcd failed %d\n", rc);
		return rc;
	}

> +
> +	rc = dp_panel_read_edid(dp_panel, connector);

Why read the edid so early? Can't you wait until get_modes is called (you'll
have to re-read anyways).

> +	if (rc) {
> +		pr_err("panel edid read failed, set failsafe mode\n");
> +		return rc;
> +	}
> +
> +	if (panel->aux_cfg_update_done) {
> +		pr_debug("read DPCD with updated AUX config\n");
> +		dp_panel_read_dpcd(dp_panel);

Check return value. Should you also check the rate/lane_count validity again too?

> +		panel->aux_cfg_update_done = false;

Should you have locking for aux_cfg_update_done?

> +	}
> +
> +	return 0;
> +}
> +
> +static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
> +{
> +	struct drm_dp_link *link_info;
> +	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
> +	u32 bpp = 0, data_rate_khz = 0;
> +
> +	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
> +
> +	link_info = &dp_panel->link_info;
> +	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
> +
> +	while (bpp > min_supported_bpp) {
> +		if (mode_pclk_khz * bpp <= data_rate_khz)
> +			break;
> +		bpp -= 6;

Watch out for underflow here.

> +	}
> +
> +	return bpp;
> +}
> +
> +static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
> +{
> +	struct dp_panel_private *panel;
> +	u32 bpp = mode_edid_bpp;
> +
> +	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
> +		pr_err("invalid input\n");
> +		return 0;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (dp_panel->video_test)
> +		bpp = dp_link_bit_depth_to_bpp(
> +				panel->link->test_video.test_bit_depth);
> +	else
> +		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
> +				mode_pclk_khz);
> +
> +	return bpp;
> +}
> +
> +static void dp_panel_set_test_mode(struct dp_panel_private *panel,
> +		struct dp_display_mode *mode)
> +{
> +	struct dp_panel_info *pinfo = NULL;


As mentioned earlier, no need to duplicate drm_display_mode into
dp_display_mode, same goes for dp_panel_info, please just use drm_display_mode.

> +	struct dp_link_test_video *test_info = NULL;
> +
> +	if (!panel) {
> +		pr_err("invalid params\n");
> +		return;
> +	}
> +
> +	pinfo = &mode->timing;
> +	test_info = &panel->link->test_video;
> +
> +	pinfo->h_active = test_info->test_h_width;
> +	pinfo->h_sync_width = test_info->test_hsync_width;
> +	pinfo->h_back_porch = test_info->test_h_start -
> +		test_info->test_hsync_width;
> +	pinfo->h_front_porch = test_info->test_h_total -
> +		(test_info->test_h_start + test_info->test_h_width);
> +
> +	pinfo->v_active = test_info->test_v_height;
> +	pinfo->v_sync_width = test_info->test_vsync_width;
> +	pinfo->v_back_porch = test_info->test_v_start -
> +		test_info->test_vsync_width;
> +	pinfo->v_front_porch = test_info->test_v_total -
> +		(test_info->test_v_start + test_info->test_v_height);
> +
> +	pinfo->bpp = dp_link_bit_depth_to_bpp(test_info->test_bit_depth);
> +	pinfo->h_active_low = test_info->test_hsync_pol;
> +	pinfo->v_active_low = test_info->test_vsync_pol;
> +
> +	pinfo->refresh_rate = test_info->test_rr_n;
> +	pinfo->pixel_clk_khz = test_info->test_h_total *
> +		test_info->test_v_total * pinfo->refresh_rate;
> +
> +	if (test_info->test_rr_d == 0)
> +		pinfo->pixel_clk_khz /= 1000;
> +	else
> +		pinfo->pixel_clk_khz /= 1001;
> +
> +	if (test_info->test_h_width == 640)
> +		pinfo->pixel_clk_khz = 25170;
> +}
> +
> +static int dp_panel_update_modes(struct drm_connector *connector,
> +	struct edid *edid)
> +{
> +	int rc = 0;
> +
> +	pr_debug("%s +", __func__);

remove

Ok, so this is where you should be reading edid.

> +	if (edid) {
> +		drm_connector_update_edid_property(connector,
> +			edid);

Join on one line and check return value

> +		rc = drm_add_edid_modes(connector, edid);
> +		pr_debug("%s -", __func__);
> +		return rc;
> +	}
> +
> +	drm_connector_update_edid_property(connector, NULL);

Check return value

> +	pr_debug("%s null edid -", __func__);
> +	return rc;

This is always 0

> +}
> +
> +static int dp_panel_get_modes(struct dp_panel *dp_panel,
> +	struct drm_connector *connector, struct dp_display_mode *mode)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return -EINVAL;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (dp_panel->video_test) {
> +		dp_panel_set_test_mode(panel, mode);
> +		return 1;
> +	} else if (dp_panel->edid) {
> +	  return dp_panel_update_modes(connector, dp_panel->edid);

Indentation is wrong

> +	}
> +
> +	/* fail-safe mode */
> +	memcpy(&mode->timing, &fail_safe,
> +		sizeof(fail_safe));
> +	return 1;

Delete fail safe and return 0;

> +}
> +
> +static u8 dp_panel_get_edid_checksum(struct edid *edid)
> +{
> +	struct edid *last_block = NULL;
> +	u8 *raw_edid = NULL;

No need to initialize these.

> +
> +	if (!edid) {
> +		pr_err("invalid edid input\n");
> +		return 0;
> +	}
> +
> +	raw_edid = (u8 *)edid;
> +	raw_edid += (edid->extensions * EDID_LENGTH);
> +	last_block = (struct edid *)raw_edid;
> +
> +	if (last_block)

I doubt last_block will ever be NULL, so this check is kind of pointless.
Perhaps call drm_edid_block_valid() instead.

> +		return last_block->checksum;
> +
> +	pr_err("Invalid block, no checksum\n");
> +	return 0;
> +}
> +
> +static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
> +		u8 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
> +
> +		panel->link->send_edid_checksum(panel->link, checksum);
> +		panel->link->send_test_response(panel->link);
> +	}
> +}
> +
> +static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool enable)
> +{
> +	u32 hsync_start_x, hsync_end_x;
> +	struct dp_catalog_panel *catalog;
> +	struct dp_panel_private *panel;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		return;
> +	}
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	catalog = panel->catalog;
> +	pinfo = &panel->dp_panel.pinfo;
> +
> +	if (!panel->panel_on) {
> +		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
> +		return;
> +	}
> +
> +	if (!enable) {
> +		panel->catalog->tpg_config(catalog, false);
> +		return;
> +	}
> +
> +	/* TPG config */
> +	catalog->hsync_period = pinfo->h_sync_width + pinfo->h_back_porch +
> +			pinfo->h_active + pinfo->h_front_porch;
> +	catalog->vsync_period = pinfo->v_sync_width + pinfo->v_back_porch +
> +			pinfo->v_active + pinfo->v_front_porch;
> +
> +	catalog->display_v_start = ((pinfo->v_sync_width +
> +			pinfo->v_back_porch) * catalog->hsync_period);
> +	catalog->display_v_end = ((catalog->vsync_period -
> +			pinfo->v_front_porch) * catalog->hsync_period) - 1;
> +
> +	catalog->display_v_start += pinfo->h_sync_width + pinfo->h_back_porch;
> +	catalog->display_v_end -= pinfo->h_front_porch;
> +
> +	hsync_start_x = pinfo->h_back_porch + pinfo->h_sync_width;
> +	hsync_end_x = catalog->hsync_period - pinfo->h_front_porch - 1;
> +
> +	catalog->v_sync_width = pinfo->v_sync_width;
> +
> +	catalog->hsync_ctl = (catalog->hsync_period << 16) |
> +			pinfo->h_sync_width;
> +	catalog->display_hctl = (hsync_end_x << 16) | hsync_start_x;

More mode timing parameters to delete!

> +
> +	pr_err("%s: calling catalog tpg_config\n", __func__);
> +	panel->catalog->tpg_config(catalog, true);
> +}
> +
> +static int dp_panel_timing_cfg(struct dp_panel *dp_panel)
> +{
> +	int rc = 0;
> +	u32 data, total_ver, total_hor;
> +	struct dp_catalog_panel *catalog;
> +	struct dp_panel_private *panel;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
This is called from 2 different places, do you need locking?

> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +	catalog = panel->catalog;
> +	pinfo = &panel->dp_panel.pinfo;
> +
> +	pr_debug("width=%d hporch= %d %d %d\n",
> +		pinfo->h_active, pinfo->h_back_porch,
> +		pinfo->h_front_porch, pinfo->h_sync_width);
> +
> +	pr_debug("height=%d vporch= %d %d %d\n",
> +		pinfo->v_active, pinfo->v_back_porch,
> +		pinfo->v_front_porch, pinfo->v_sync_width);
> +
> +	total_hor = pinfo->h_active + pinfo->h_back_porch +
> +		pinfo->h_front_porch + pinfo->h_sync_width;
> +
> +	total_ver = pinfo->v_active + pinfo->v_back_porch +
> +			pinfo->v_front_porch + pinfo->v_sync_width;
> +
> +	data = total_ver;
> +	data <<= 16;
> +	data |= total_hor;
> +
> +	catalog->total = data;
> +
> +	data = (pinfo->v_back_porch + pinfo->v_sync_width);
> +	data <<= 16;
> +	data |= (pinfo->h_back_porch + pinfo->h_sync_width);
> +
> +	catalog->sync_start = data;
> +
> +	data = pinfo->v_sync_width;
> +	data <<= 16;
> +	data |= (pinfo->v_active_low << 31);
> +	data |= pinfo->h_sync_width;
> +	data |= (pinfo->h_active_low << 15);
> +
> +	catalog->width_blanking = data;
> +
> +	data = pinfo->v_active;
> +	data <<= 16;
> +	data |= pinfo->h_active;
> +
> +	catalog->dp_active = data;
> +
> +	panel->catalog->timing_cfg(catalog);
> +	panel->panel_on = true;

Again, all of this should be derived from a drm_display_mode at the point where
it is committed to hardware. No need to store it in another form in the interim


> +end:
> +	return rc;

Remove end/rc and return directly

> +}
> +
> +static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
> +{
> +	int rc = 0;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto end;
> +	}
> +
> +	pinfo = &dp_panel->pinfo;
> +
> +	/*
> +	 * print resolution info as this is a result
> +	 * of user initiated action of cable connection
> +	 */
> +	pr_info("SET NEW RESOLUTION:\n");
> +	pr_info("%dx%d@%dfps\n", pinfo->h_active,
> +		pinfo->v_active, pinfo->refresh_rate);
> +	pr_info("h_porches(back|front|width) = (%d|%d|%d)\n",
> +			pinfo->h_back_porch,
> +			pinfo->h_front_porch,
> +			pinfo->h_sync_width);
> +	pr_info("v_porches(back|front|width) = (%d|%d|%d)\n",
> +			pinfo->v_back_porch,
> +			pinfo->v_front_porch,
> +			pinfo->v_sync_width);
> +	pr_info("pixel clock (KHz)=(%d)\n", pinfo->pixel_clk_khz);
> +	pr_info("bpp = %d\n", pinfo->bpp);
> +	pr_info("active low (h|v)=(%d|%d)\n", pinfo->h_active_low,
> +		pinfo->v_active_low);
> +
> +	pinfo->bpp = max_t(u32, 18, min_t(u32, pinfo->bpp, 30));
> +	pr_info("updated bpp = %d\n", pinfo->bpp);


No info level logs, please.

> +end:
> +	return rc;

Remove end/rc and return directly

> +}
> +
> +static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
> +{
> +	const u32 encoding_factx10 = 8;
> +	u32 min_link_rate_khz = 0, lane_cnt;
> +	struct dp_panel_info *pinfo;
> +
> +	if (!dp_panel) {

The only way to call this function is through a dp_panel callback, and yet we
check if dp_panel is NULL :)

The same is true for most functions in this patch. Things will be a lot simpler
when all of these are removed. This function will no longer have an error path
and lane_cnt/pinfo can be initialized directly above.


> +		pr_err("invalid input\n");
> +		goto end;
> +	}
> +
> +	lane_cnt = dp_panel->link_info.num_lanes;
> +	pinfo = &dp_panel->pinfo;
> +
> +	/* num_lanes * lane_count * 8 >= pclk * bpp * 10 */
> +	min_link_rate_khz = pinfo->pixel_clk_khz /
> +				(lane_cnt * encoding_factx10);
> +	min_link_rate_khz *= pinfo->bpp;
> +
> +	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
> +		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
> +		pinfo->bpp);
> +end:
> +	return min_link_rate_khz;

Remove end and return directly above

> +}
> +
> +struct dp_panel *dp_panel_get(struct dp_panel_in *in)
> +{
> +	int rc = 0;
> +	struct dp_panel_private *panel;
> +	struct dp_panel *dp_panel;
> +
> +	if (!in->dev || !in->catalog || !in->aux || !in->link) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
> +	if (!panel) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	panel->dev = in->dev;
> +	panel->aux = in->aux;
> +	panel->catalog = in->catalog;
> +	panel->link = in->link;
> +
> +	dp_panel = &panel->dp_panel;
> +	dp_panel->max_bw_code = DP_LINK_BW_8_1;
> +	panel->aux_cfg_update_done = false;
> +
> +	dp_panel->init_info = dp_panel_init_panel_info;
> +	dp_panel->timing_cfg = dp_panel_timing_cfg;
> +	dp_panel->read_sink_caps = dp_panel_read_sink_caps;
> +	dp_panel->get_min_req_link_rate = dp_panel_get_min_req_link_rate;
> +	dp_panel->get_mode_bpp = dp_panel_get_mode_bpp;
> +	dp_panel->get_modes = dp_panel_get_modes;
> +	dp_panel->handle_sink_request = dp_panel_handle_sink_request;
> +	dp_panel->tpg_config = dp_panel_tpg_config;
> +
> +	return dp_panel;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_panel_put(struct dp_panel *dp_panel)
> +{
> +	struct dp_panel_private *panel;
> +
> +	if (!dp_panel)
> +		return;
> +
> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
> +
> +	kfree(dp_panel->edid);
> +	dp_panel->edid = NULL;
> +	devm_kfree(panel->dev, panel);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.h b/drivers/gpu/drm/msm/dp/dp_panel.h
> new file mode 100644
> index 0000000..bf802df
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_panel.h
> @@ -0,0 +1,121 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_PANEL_H_
> +#define _DP_PANEL_H_
> +
> +#include <drm/msm_drm.h>
> +
> +#include "dp_aux.h"
> +#include "dp_link.h"
> +#include "dp_extcon.h"
> +
> +struct edid;
> +
> +enum dp_lane_count {
> +	DP_LANE_COUNT_1	= 1,
> +	DP_LANE_COUNT_2	= 2,
> +	DP_LANE_COUNT_4	= 4,
> +};

You don't need an enum for this, the value coming from dpcd is just an integer and
can be used as such.

> +
> +#define DP_MAX_DOWNSTREAM_PORTS 0x10
> +
> +struct dp_panel_info {
> +	u32 h_active;
> +	u32 v_active;
> +	u32 h_back_porch;
> +	u32 h_front_porch;
> +	u32 h_sync_width;
> +	u32 h_active_low;
> +	u32 v_back_porch;
> +	u32 v_front_porch;
> +	u32 v_sync_width;
> +	u32 v_active_low;
> +	u32 h_skew;
> +	u32 refresh_rate;
> +	u32 pixel_clk_khz;
> +	u32 bpp;
> +};

Drop this struct and use drm_display_mode


> +
> +struct dp_display_mode {
> +	struct dp_panel_info timing;
> +	u32 capabilities;
> +};
> +
> +struct dp_panel_in {
> +	struct device *dev;
> +	struct dp_aux *aux;
> +	struct dp_link *link;
> +	struct dp_catalog_panel *catalog;
> +};
> +
> +struct dp_panel {
> +	/* dpcd raw data */
> +	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];

Why + 1?

> +	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
> +
> +	struct drm_dp_link link_info;
> +	struct edid *edid;
> +	struct drm_connector *connector;
> +	struct dp_panel_info pinfo;
> +	bool video_test;
> +
> +	u32 vic;
> +	u32 max_pclk_khz;
> +
> +	u32 max_bw_code;
> +	int (*init_info)(struct dp_panel *dp_panel);
> +	int (*deinit)(struct dp_panel *dp_panel);
> +	int (*timing_cfg)(struct dp_panel *dp_panel);
> +	int (*read_sink_caps)(struct dp_panel *dp_panel,
> +		struct drm_connector *connector);
> +	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);

This function isn't called anywhere

> +	u32 (*get_mode_bpp)(struct dp_panel *dp_panel, u32 mode_max_bpp,
> +			u32 mode_pclk_khz);
> +	int (*get_modes)(struct dp_panel *dp_panel,
> +		struct drm_connector *connector, struct dp_display_mode *mode);
> +	void (*handle_sink_request)(struct dp_panel *dp_panel);
> +	void (*tpg_config)(struct dp_panel *dp_panel, bool enable);
> +};
> +
> +/**
> + * is_link_rate_valid() - validates the link rate
> + * @lane_rate: link rate requested by the sink
> + *
> + * Returns true if the requested link rate is supported.
> + */
> +static inline bool is_link_rate_valid(u32 bw_code)
> +{
> +	return ((bw_code == DP_LINK_BW_1_62) ||
> +		(bw_code == DP_LINK_BW_2_7) ||
> +		(bw_code == DP_LINK_BW_5_4) ||
> +		(bw_code == DP_LINK_BW_8_1));

Each of these conditions has unneeded ()

> +}
> +
> +/**
> + * dp_link_is_lane_count_valid() - validates the lane count
> + * @lane_count: lane count requested by the sink
> + *
> + * Returns true if the requested lane count is supported.
> + */
> +static inline bool is_lane_count_valid(u32 lane_count)
> +{
> +	return (lane_count == DP_LANE_COUNT_1) ||
> +		(lane_count == DP_LANE_COUNT_2) ||
> +		(lane_count == DP_LANE_COUNT_4);
> +}
> +
> +struct dp_panel *dp_panel_get(struct dp_panel_in *in);
> +void dp_panel_put(struct dp_panel *dp_panel);
> +#endif /* _DP_PANEL_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.c b/drivers/gpu/drm/msm/dp/dp_parser.c
> new file mode 100644
> index 0000000..a366dc5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_parser.c
> @@ -0,0 +1,679 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/of_gpio.h>
> +
> +#include "dp_parser.h"
> +
> +static void dp_parser_unmap_io_resources(struct dp_parser *parser)
> +{
> +	struct dp_io *io = &parser->io;
> +
> +	msm_dss_iounmap(&io->dp_ahb);
> +	msm_dss_iounmap(&io->dp_aux);
> +	msm_dss_iounmap(&io->dp_link);
> +	msm_dss_iounmap(&io->dp_p0);
> +	msm_dss_iounmap(&io->phy_io);
> +	msm_dss_iounmap(&io->ln_tx0_io);
> +	msm_dss_iounmap(&io->ln_tx0_io);
> +	msm_dss_iounmap(&io->dp_pll_io);
> +	msm_dss_iounmap(&io->dp_cc_io);
> +	msm_dss_iounmap(&io->usb3_dp_com);
> +	msm_dss_iounmap(&io->qfprom_io);
> +}
> +
> +static int dp_parser_ctrl_res(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	u32 index;
> +	struct platform_device *pdev = parser->pdev;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	struct dp_io *io = &parser->io;
> +
> +	rc = of_property_read_u32(of_node, "cell-index", &index);
> +	if (rc) {
> +		pr_err("cell-index not specified, rc=%d\n", rc);
> +		goto err;

This can be a direct return of rc.

> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_ahb, "dp_ahb");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");

Print rc here and below.

> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_aux, "dp_aux");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_link, "dp_link");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_p0, "dp_p0");
> +	if (rc) {
> +		pr_err("unable to remap dp io resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->phy_io, "dp_phy");
> +	if (rc) {
> +		pr_err("unable to remap dp PHY resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx0_io, "dp_ln_tx0");
> +	if (rc) {
> +		pr_err("unable to remap dp TX0 resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx1_io, "dp_ln_tx1");
> +	if (rc) {
> +		pr_err("unable to remap dp TX1 resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_pll_io, "dp_pll");
> +	if (rc) {
> +		pr_err("unable to remap DP PLL resources\n");
> +		goto err;
> +	}
> +
> +	rc = msm_dss_ioremap_byname(pdev, &io->usb3_dp_com, "usb3_dp_com");
> +	if (rc) {
> +		pr_err("unable to remap USB3 DP com resources\n");
> +		goto err;
> +	}
> +
> +	if (msm_dss_ioremap_byname(pdev, &io->dp_cc_io, "dp_mmss_cc")) {
> +		pr_err("unable to remap dp MMSS_CC resources\n");
> +		goto err;
> +	}
> +
> +	if (msm_dss_ioremap_byname(pdev, &io->qfprom_io, "qfprom_physical"))
> +		pr_warn("unable to remap dp qfprom resources\n");
> +
> +	return 0;
> +err:
> +	dp_parser_unmap_io_resources(parser);
> +	return rc;
> +}
> +
> +static const char *dp_get_phy_aux_config_property(u32 cfg_type)
> +{
> +	switch (cfg_type) {
> +	case PHY_AUX_CFG0:
> +		return "qcom,aux-cfg0-settings";
> +	case PHY_AUX_CFG1:
> +		return "qcom,aux-cfg1-settings";
> +	case PHY_AUX_CFG2:
> +		return "qcom,aux-cfg2-settings";
> +	case PHY_AUX_CFG3:
> +		return "qcom,aux-cfg3-settings";
> +	case PHY_AUX_CFG4:
> +		return "qcom,aux-cfg4-settings";
> +	case PHY_AUX_CFG5:
> +		return "qcom,aux-cfg5-settings";
> +	case PHY_AUX_CFG6:
> +		return "qcom,aux-cfg6-settings";
> +	case PHY_AUX_CFG7:
> +		return "qcom,aux-cfg7-settings";
> +	case PHY_AUX_CFG8:
> +		return "qcom,aux-cfg8-settings";
> +	case PHY_AUX_CFG9:
> +		return "qcom,aux-cfg9-settings";
> +	default:
> +		return "unknown";
> +	}
> +}
> +
> +static void dp_parser_phy_aux_cfg_reset(struct dp_parser *parser)
> +{
> +	int i = 0;
> +
> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
> +		parser->aux_cfg[i] = (const struct dp_aux_cfg){ 0 };
> +}

No need for a separate function, just put the loop in the error label below.

> +
> +static int dp_parser_aux(struct dp_parser *parser)
> +{
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	int len = 0, i = 0, j = 0, config_count = 0;
> +	const char *data;
> +	int const minimum_config_count = 1;

Just use 1 directly

> +
> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
> +		const char *property = dp_get_phy_aux_config_property(i);
> +
> +		data = of_get_property(of_node, property, &len);
> +		if (!data) {

You should use of_property_read_u32() instead of reading as a string

> +			pr_err("Unable to read %s\n", property);
> +			goto error;
> +		}
> +
> +		config_count = len - 1;
> +		if ((config_count < minimum_config_count) ||
> +			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {

Remove extra ()

> +			pr_err("Invalid config count (%d) configs for %s\n",
> +					config_count, property);
> +			goto error;
> +		}
> +
> +		parser->aux_cfg[i].offset = data[0];
> +		parser->aux_cfg[i].cfg_cnt = config_count;
> +		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
> +				property,
> +				parser->aux_cfg[i].offset,
> +				parser->aux_cfg[i].cfg_cnt);
> +		for (j = 1; j < len; j++) {
> +			parser->aux_cfg[i].lut[j - 1] = data[j];

And this could use of_property_read_u32_array()

> +			pr_debug("%s lut[%d]=0x%x\n",
> +					property,
> +					i,
> +					parser->aux_cfg[i].lut[j - 1]);
> +		}
> +	}
> +		return 0;
> +
> +error:
> +	dp_parser_phy_aux_cfg_reset(parser);
> +	return -EINVAL;
> +}
> +
> +static int dp_parser_misc(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +
> +	rc = of_property_read_u32(of_node,
> +		"qcom,max-pclk-frequency-khz", &parser->max_pclk_khz);
> +	if (rc)
> +		parser->max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;
> +
> +	return 0;
> +}
> +
> +static int dp_parser_pinctrl(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct dp_pinctrl *pinctrl = &parser->pinctrl;
> +
> +	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
> +
> +	if (IS_ERR_OR_NULL(pinctrl->pin)) {
> +		rc = PTR_ERR(pinctrl->pin);
> +		pr_err("failed to get pinctrl, rc=%d\n", rc);
> +		goto error;
> +	}
> +
> +	pinctrl->state_active = pinctrl_lookup_state(pinctrl->pin,
> +					"mdss_dp_active");
> +	if (IS_ERR_OR_NULL(pinctrl->state_active)) {
> +		rc = PTR_ERR(pinctrl->state_active);

What if it's NULL?

> +		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
> +		goto error;
> +	}
> +
> +	pinctrl->state_suspend = pinctrl_lookup_state(pinctrl->pin,
> +					"mdss_dp_sleep");
> +	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
> +		rc = PTR_ERR(pinctrl->state_suspend);

What if it's NULL?

> +		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
> +		goto error;
> +	}
> +error:
> +	return rc;
> +}
> +
> +static int dp_parser_gpio(struct dp_parser *parser)
> +{
> +	int i = 0;
> +	struct device *dev = &parser->pdev->dev;
> +	struct device_node *of_node = dev->of_node;
> +	struct dss_module_power *mp = &parser->mp[DP_CORE_PM];
> +	static const char * const dp_gpios[] = {
> +		"qcom,aux-en-gpio",
> +		"qcom,aux-sel-gpio",
> +		"qcom,usbplug-cc-gpio",
> +	};
> +
> +	mp->gpio_config = devm_kzalloc(dev,
> +		sizeof(struct dss_gpio) * ARRAY_SIZE(dp_gpios), GFP_KERNEL);
> +	if (!mp->gpio_config)
> +		return -ENOMEM;
> +
> +	mp->num_gpio = ARRAY_SIZE(dp_gpios);

If you do this first, you can s/ARRAY_SIZE(dp_gpios)/mp->num_gpio/ in the rest
of the function.

> +
> +	for (i = 0; i < ARRAY_SIZE(dp_gpios); i++) {
> +		mp->gpio_config[i].gpio = of_get_named_gpio(of_node,
> +			dp_gpios[i], 0);
> +
> +		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
> +			pr_err("%s gpio not specified\n", dp_gpios[i]);
> +			return -EINVAL;
> +		}
> +
> +		strlcpy(mp->gpio_config[i].gpio_name, dp_gpios[i],
> +			sizeof(mp->gpio_config[i].gpio_name));

As mentioned earlier, please don't implement your own string store/lookup, just
provide access to the gpios in a more direct manner (pointer or function).

> +
> +		mp->gpio_config[i].value = 0;
> +	}
> +
> +	return 0;
> +}
> +
> +static const char *dp_parser_supply_node_name(enum dp_pm_type module)
> +{
> +	switch (module) {
> +	case DP_CORE_PM:	return "qcom,core-supply-entries";
> +	case DP_CTRL_PM:	return "qcom,ctrl-supply-entries";
> +	case DP_PHY_PM:		return "qcom,phy-supply-entries";
> +	default:		return "???";
> +	}
> +}
> +
> +static int dp_parser_get_vreg(struct dp_parser *parser,
> +		enum dp_pm_type module)
> +{
> +	int i = 0, rc = 0;
> +	u32 tmp = 0;
> +	const char *pm_supply_name = NULL;
> +	struct device_node *supply_node = NULL;
> +	struct device_node *of_node = parser->pdev->dev.of_node;
> +	struct device_node *supply_root_node = NULL;
> +	struct dss_module_power *mp = &parser->mp[module];
> +
> +	mp->num_vreg = 0;
> +	pm_supply_name = dp_parser_supply_node_name(module);
> +	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
> +	if (!supply_root_node) {
> +		pr_err("no supply entry present: %s\n", pm_supply_name);
> +		goto novreg;
> +	}
> +
> +	mp->num_vreg = of_get_available_child_count(supply_root_node);
> +
> +	if (mp->num_vreg == 0) {
> +		pr_debug("no vreg\n");
> +		goto novreg;
> +	} else {
> +		pr_debug("vreg found. count=%d\n", mp->num_vreg);

This doesn't need to be wrapped in an else

> +	}
> +
> +	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
> +		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
> +	if (!mp->vreg_config) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	for_each_child_of_node(supply_root_node, supply_node) {
> +		const char *st = NULL;
> +		/* vreg-name */
> +		rc = of_property_read_string(supply_node,
> +			"qcom,supply-name", &st);
> +		if (rc) {
> +			pr_err("error reading name. rc=%d\n",
> +				 rc);
> +			goto error;
> +		}
> +		snprintf(mp->vreg_config[i].vreg_name,
> +			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);

Instead of storing the name just to get a regulator reference later, why don't
you just grab the reference now and avoid the string ops?

> +		/* vreg-min-voltage */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-min-voltage", &tmp);
> +		if (rc) {
> +			pr_err("error reading min volt. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].min_voltage = tmp;
> +
> +		/* vreg-max-voltage */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-max-voltage", &tmp);
> +		if (rc) {
> +			pr_err("error reading max volt. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].max_voltage = tmp;
> +
> +		/* enable-load */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-enable-load", &tmp);
> +		if (rc) {
> +			pr_err("error reading enable load. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].enable_load = tmp;
> +
> +		/* disable-load */
> +		rc = of_property_read_u32(supply_node,
> +			"qcom,supply-disable-load", &tmp);
> +		if (rc) {
> +			pr_err("error reading disable load. rc=%d\n",
> +				rc);
> +			goto error;
> +		}
> +		mp->vreg_config[i].disable_load = tmp;
> +
> +		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
> +			mp->vreg_config[i].vreg_name,
> +			mp->vreg_config[i].min_voltage,
> +			mp->vreg_config[i].max_voltage,
> +			mp->vreg_config[i].enable_load,
> +			mp->vreg_config[i].disable_load
> +			);
> +		++i;
> +	}
> +
> +	return rc;
> +
> +error:
> +	if (mp->vreg_config) {
> +		devm_kfree(&parser->pdev->dev, mp->vreg_config);
> +		mp->vreg_config = NULL;
> +	}

This shouldn't be necessary, that's the nice thing about device managed
resources.

> +novreg:
> +	mp->num_vreg = 0;
> +
> +	return rc;
> +}
> +
> +static void dp_parser_put_vreg_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("invalid input\n");
> +		return;
> +	}
> +
> +	if (mp->vreg_config) {
> +		devm_kfree(dev, mp->vreg_config);
> +		mp->vreg_config = NULL;
> +	}

Same here, this function can go away once you take out the dp_parser
abstraction layer.

> +	mp->num_vreg = 0;
> +}
> +
> +static int dp_parser_regulator(struct dp_parser *parser)
> +{
> +	int i, rc = 0;
> +	struct platform_device *pdev = parser->pdev;
> +
> +	/* Parse the regulator information */
> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
> +		rc = dp_parser_get_vreg(parser, i);
> +		if (rc) {
> +			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
> +				dp_parser_pm_name(i), rc);
> +			i--;
> +			for (; i >= DP_CORE_PM; i--)
> +				dp_parser_put_vreg_data(&pdev->dev,
> +					&parser->mp[i]);
> +			break;

And here you can just return the error directly and the resources will be freed
magically.

> +		}
> +	}
> +
> +	return rc;

And this becomes return 0;

> +}
> +
> +static bool dp_parser_check_prefix(const char *clk_prefix, const char *clk_name)
> +{
> +	return !!strnstr(clk_name, clk_prefix, strlen(clk_name));

This is likely not what you want since this will look for prefix _anywhere_ in
clk name. An example of how this could go sideways:

	dp_parser_check_prefix("core", "core-dp-power-ctrl");
	dp_parser_check_prefix("ctrl", "core-dp-power-ctrl");

Both return true.

Anyways, strncmp is a better choice here (if we must do string operations).

> +}
> +
> +static void dp_parser_put_clk_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("%s: invalid input\n", __func__);
> +		return;
> +	}
> +
> +	if (mp->clk_config) {
> +		devm_kfree(dev, mp->clk_config);
> +		mp->clk_config = NULL;
> +	}
> +
> +	mp->num_clk = 0;
> +}
> +
> +static void dp_parser_put_gpio_data(struct device *dev,
> +	struct dss_module_power *mp)
> +{
> +	if (!mp) {
> +		DEV_ERR("%s: invalid input\n", __func__);
> +		return;
> +	}
> +
> +	if (mp->gpio_config) {
> +		devm_kfree(dev, mp->gpio_config);
> +		mp->gpio_config = NULL;
> +	}
> +
> +	mp->num_gpio = 0;
> +}
> +
> +static int dp_parser_init_clk_data(struct dp_parser *parser)
> +{
> +	int num_clk = 0, i = 0, rc = 0;
> +	int core_clk_count = 0, ctrl_clk_count = 0;
> +	const char *core_clk = "core";
> +	const char *ctrl_clk = "ctrl";
> +	const char *clk_name;
> +	struct device *dev = &parser->pdev->dev;
> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> +
> +	num_clk = of_property_count_strings(dev->of_node, "clock-names");
> +	if (num_clk <= 0) {
> +		pr_err("no clocks are defined\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	for (i = 0; i < num_clk; i++) {
> +		of_property_read_string_index(dev->of_node,
> +				"clock-names", i, &clk_name);

Check return value

> +
> +		if (dp_parser_check_prefix(core_clk, clk_name))
> +			core_clk_count++;
> +
> +		if (dp_parser_check_prefix(ctrl_clk, clk_name))
> +			ctrl_clk_count++;

Just use "core"/"ctrl" directly here.

Have you considered just having 2 clock lists? That would avoid having to do
this.

> +	}
> +
> +	/* Initialize the CORE power module */
> +	if (core_clk_count <= 0) {

How does this get below 0?

> +		pr_err("no core clocks are defined\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	core_power->num_clk = core_clk_count;
> +	core_power->clk_config = devm_kzalloc(dev,
> +			sizeof(struct dss_clk) * core_power->num_clk,
> +			GFP_KERNEL);
> +	if (!core_power->clk_config) {
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	/* Initialize the CTRL power module */
> +	if (ctrl_clk_count <= 0) {

How does this get below 0?

> +		pr_err("no ctrl clocks are defined\n");
> +		rc = -EINVAL;
> +		goto ctrl_clock_error;
> +	}
> +
> +	ctrl_power->num_clk = ctrl_clk_count;
> +	ctrl_power->clk_config = devm_kzalloc(dev,
> +			sizeof(struct dss_clk) * ctrl_power->num_clk,
> +			GFP_KERNEL);
> +	if (!ctrl_power->clk_config) {
> +		ctrl_power->num_clk = 0;
> +		rc = -EINVAL;
> +		goto ctrl_clock_error;
> +	}
> +
> +	return rc;
> +
> +ctrl_clock_error:
> +	dp_parser_put_clk_data(dev, core_power);
> +exit:
> +	return rc;

Just return directly and delete exit

> +}
> +
> +static int dp_parser_clock(struct dp_parser *parser)
> +{
> +	int rc = 0, i = 0;
> +	int num_clk = 0;
> +	int core_clk_index = 0, ctrl_clk_index = 0;
> +	int core_clk_count = 0, ctrl_clk_count = 0;
> +	const char *clk_name;
> +	const char *core_clk = "core";
> +	const char *ctrl_clk = "ctrl";
> +	struct device *dev = &parser->pdev->dev;

---- START hmmmm

> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> +
> +	core_power = &parser->mp[DP_CORE_PM];
> +	ctrl_power = &parser->mp[DP_CTRL_PM];

---- END hmmmm

> +
> +	rc =  dp_parser_init_clk_data(parser);
> +	if (rc) {
> +		pr_err("failed to initialize power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	core_clk_count = core_power->num_clk;
> +	ctrl_clk_count = ctrl_power->num_clk;
> +
> +	num_clk = core_clk_count + ctrl_clk_count;
> +
> +	for (i = 0; i < num_clk; i++) {
> +		of_property_read_string_index(dev->of_node, "clock-names",
> +				i, &clk_name);

Check return value

> +
> +		if (dp_parser_check_prefix(core_clk, clk_name) &&
> +				core_clk_index < core_clk_count) {
> +			struct dss_clk *clk =
> +				&core_power->clk_config[core_clk_index];
> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
> +			clk->type = DSS_CLK_AHB;
> +			core_clk_index++;
> +		} else if (dp_parser_check_prefix(ctrl_clk, clk_name) &&
> +			   ctrl_clk_index < ctrl_clk_count) {
> +			struct dss_clk *clk =
> +				&ctrl_power->clk_config[ctrl_clk_index];
> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
> +			ctrl_clk_index++;
> +
> +			if (!strcmp(clk_name, "ctrl_link_clk") ||
> +			    !strcmp(clk_name, "ctrl_pixel_clk"))

strncmp

> +				clk->type = DSS_CLK_PCLK;
> +			else
> +				clk->type = DSS_CLK_AHB;
> +		}
> +	}
> +
> +	pr_debug("clock parsing successful\n");
> +
> +exit:

Delete the label and return directly

> +	return rc;
> +}
> +
> +static int dp_parser_parse(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +
> +	if (!parser) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto err;
> +	}
> +
> +	rc = dp_parser_ctrl_res(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_aux(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_misc(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_clock(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_regulator(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_gpio(parser);
> +	if (rc)
> +		goto err;
> +
> +	rc = dp_parser_pinctrl(parser);
> +err:

Delete the label and return directly

> +	return rc;
> +}
> +
> +struct dp_parser *dp_parser_get(struct platform_device *pdev)
> +{
> +	struct dp_parser *parser;
> +
> +	parser = devm_kzalloc(&pdev->dev, sizeof(*parser), GFP_KERNEL);
> +	if (!parser)
> +		return ERR_PTR(-ENOMEM);
> +
> +	parser->parse = dp_parser_parse;
> +	parser->pdev = pdev;
> +
> +	return parser;
> +}
> +
> +void dp_parser_put(struct dp_parser *parser)
> +{
> +	int i = 0;
> +	struct dss_module_power *power = NULL;
> +
> +	if (!parser) {
> +		pr_err("invalid parser module\n");
> +		return;
> +	}
> +
> +	power = parser->mp;
> +
> +	for (i = 0; i < DP_MAX_PM; i++) {
> +		dp_parser_put_clk_data(&parser->pdev->dev, &power[i]);
> +		dp_parser_put_vreg_data(&parser->pdev->dev, &power[i]);
> +		dp_parser_put_gpio_data(&parser->pdev->dev, &power[i]);
> +	}
> +
> +	devm_kfree(&parser->pdev->dev, parser);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h b/drivers/gpu/drm/msm/dp/dp_parser.h
> new file mode 100644
> index 0000000..b39ea02
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_parser.h
> @@ -0,0 +1,205 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_PARSER_H_
> +#define _DP_PARSER_H_
> +
> +#include "dpu_io_util.h"
> +
> +#define DP_LABEL "MDSS DP DISPLAY"
> +#define AUX_CFG_LEN	10
> +#define DP_MAX_PIXEL_CLK_KHZ	675000
> +
> +enum dp_pm_type {
> +	DP_CORE_PM,
> +	DP_CTRL_PM,
> +	DP_PHY_PM,
> +	DP_MAX_PM
> +};
> +
> +static inline const char *dp_parser_pm_name(enum dp_pm_type module)
> +{
> +	switch (module) {
> +	case DP_CORE_PM:	return "DP_CORE_PM";
> +	case DP_CTRL_PM:	return "DP_CTRL_PM";
> +	case DP_PHY_PM:		return "DP_PHY_PM";
> +	default:		return "???";
> +	}
> +}

Delete the function and just print the enum value

> +
> +/**
> + * struct dp_display_data  - display related device tree data.
> + *
> + * @ctrl_node: referece to controller device
> + * @phy_node:  reference to phy device
> + * @is_active: is the controller currently active
> + * @name: name of the display
> + * @display_type: type of the display
> + */
> +struct dp_display_data {
> +	struct device_node *ctrl_node;
> +	struct device_node *phy_node;
> +	bool is_active;
> +	const char *name;
> +	const char *display_type;
> +};
> +
> +/**
> + * struct dp_ctrl_resource - controller's IO related data
> + *
> + * @dp_ahb: controller's ahb mapped memory address
> + * @dp_aux: controller's aux mapped memory address
> + * @dp_link: controller's link mapped memory address
> + * @dp_p0: controller's p0 mapped memory address
> + * @phy_io: phy's mapped memory address
> + * @ln_tx0_io: USB-DP lane TX0's mapped memory address
> + * @ln_tx1_io: USB-DP lane TX1's mapped memory address
> + * @dp_cc_io: DP cc's mapped memory address
> + * @qfprom_io: qfprom's mapped memory address
> + * @dp_pll_io: DP PLL mapped memory address
> + * @usb3_dp_com: USB3 DP PHY combo mapped memory address
> + */
> +struct dp_io {
> +	struct dss_io_data ctrl_io;
> +	struct dss_io_data dp_ahb;
> +	struct dss_io_data dp_aux;
> +	struct dss_io_data dp_link;
> +	struct dss_io_data dp_p0;
> +	struct dss_io_data phy_io;
> +	struct dss_io_data ln_tx0_io;
> +	struct dss_io_data ln_tx1_io;
> +	struct dss_io_data dp_cc_io;
> +	struct dss_io_data qfprom_io;
> +	struct dss_io_data dp_pll_io;
> +	struct dss_io_data usb3_dp_com;
> +};
> +
> +/**
> + * struct dp_pinctrl - DP's pin control
> + *
> + * @pin: pin-controller's instance
> + * @state_active: active state pin control
> + * @state_hpd_active: hpd active state pin control
> + * @state_suspend: suspend state pin control
> + */
> +struct dp_pinctrl {
> +	struct pinctrl *pin;
> +	struct pinctrl_state *state_active;
> +	struct pinctrl_state *state_hpd_active;
> +	struct pinctrl_state *state_suspend;
> +};
> +
> +#define DP_ENUM_STR(x)	#x

Once you get rid of all of the enum->string functions that are used for
debugging, you can delete this.

> +#define DP_AUX_CFG_MAX_VALUE_CNT 3
> +/**
> + * struct dp_aux_cfg - DP's AUX configuration settings
> + *
> + * @cfg_cnt: count of the configurable settings for the AUX register
> + * @current_index: current index of the AUX config lut
> + * @offset: register offset of the AUX config register
> + * @lut: look up table for the AUX config values for this register
> + */
> +struct dp_aux_cfg {
> +	u32 cfg_cnt;
> +	u32 current_index;
> +	u32 offset;
> +	u32 lut[DP_AUX_CFG_MAX_VALUE_CNT];
> +};
> +
> +/* PHY AUX config registers */
> +enum dp_phy_aux_config_type {
> +	PHY_AUX_CFG0,
> +	PHY_AUX_CFG1,
> +	PHY_AUX_CFG2,
> +	PHY_AUX_CFG3,
> +	PHY_AUX_CFG4,
> +	PHY_AUX_CFG5,
> +	PHY_AUX_CFG6,
> +	PHY_AUX_CFG7,
> +	PHY_AUX_CFG8,
> +	PHY_AUX_CFG9,
> +	PHY_AUX_CFG_MAX,
> +};
> +
> +static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type)
> +{
> +	switch (cfg_type) {
> +	case PHY_AUX_CFG0:
> +		return DP_ENUM_STR(PHY_AUX_CFG0);
> +	case PHY_AUX_CFG1:
> +		return DP_ENUM_STR(PHY_AUX_CFG1);
> +	case PHY_AUX_CFG2:
> +		return DP_ENUM_STR(PHY_AUX_CFG2);
> +	case PHY_AUX_CFG3:
> +		return DP_ENUM_STR(PHY_AUX_CFG3);
> +	case PHY_AUX_CFG4:
> +		return DP_ENUM_STR(PHY_AUX_CFG4);
> +	case PHY_AUX_CFG5:
> +		return DP_ENUM_STR(PHY_AUX_CFG5);
> +	case PHY_AUX_CFG6:
> +		return DP_ENUM_STR(PHY_AUX_CFG6);
> +	case PHY_AUX_CFG7:
> +		return DP_ENUM_STR(PHY_AUX_CFG7);
> +	case PHY_AUX_CFG8:
> +		return DP_ENUM_STR(PHY_AUX_CFG8);
> +	case PHY_AUX_CFG9:
> +		return DP_ENUM_STR(PHY_AUX_CFG9);
> +	default:
> +		return "unknown";
> +	}
> +}

Same deal as the others, remove and print the enum value instead.

> +
> +/**
> + * struct dp_parser - DP parser's data exposed to clients
> + *
> + * @pdev: platform data of the client
> + * @mp: gpio, regulator and clock related data
> + * @pinctrl: pin-control related data
> + * @disp_data: controller's display related data
> + * @parse: function to be called by client to parse device tree.
> + */
> +struct dp_parser {
> +	struct platform_device *pdev;
> +	struct dss_module_power mp[DP_MAX_PM];
> +	struct dp_pinctrl pinctrl;
> +	struct dp_io io;
> +	struct dp_display_data disp_data;
> +
> +	u8 l_map[4];
> +	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
> +	u32 max_pclk_khz;
> +
> +	int (*parse)(struct dp_parser *parser);
> +};
> +
> +/**
> + * dp_parser_get() - get the DP's device tree parser module
> + *
> + * @pdev: platform data of the client
> + * return: pointer to dp_parser structure.
> + *
> + * This function provides client capability to parse the
> + * device tree and populate the data structures. The data
> + * related to clock, regulators, pin-control and other
> + * can be parsed using this module.
> + */
> +struct dp_parser *dp_parser_get(struct platform_device *pdev);
> +
> +/**
> + * dp_parser_put() - cleans the dp_parser module
> + *
> + * @parser: pointer to the parser's data.
> + */
> +void dp_parser_put(struct dp_parser *parser);
> +#endif
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
> new file mode 100644
> index 0000000..1d58480
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
> @@ -0,0 +1,599 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
> +
> +#include <linux/clk.h>
> +#include "dp_power.h"
> +
> +#define DP_CLIENT_NAME_SIZE	20

Unused

> +
> +struct dp_power_private {
> +	struct dp_parser *parser;
> +	struct platform_device *pdev;
> +	struct clk *pixel_clk_rcg;
> +	struct clk *pixel_parent;
> +
> +	struct dp_power dp_power;
> +
> +	bool core_clks_on;
> +	bool link_clks_on;
> +};
> +
> +static int dp_power_regulator_init(struct dp_power_private *power)
> +{
> +	int rc = 0, i = 0, j = 0;
> +	struct platform_device *pdev;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +	pdev = power->pdev;

Move these initializations up to the declaration. Please apply this to the rest
of the code as well.


> +
> +	for (i = DP_CORE_PM; !rc && (i < DP_MAX_PM); i++) {

No need to check rc when the only place it can go non-zero is the place that
has a break;

> +		rc = msm_dss_config_vreg(&pdev->dev,
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, 1);
> +		if (rc) {
> +			pr_err("failed to init vregs for %s\n",
> +				dp_parser_pm_name(i));
> +			for (j = i - 1; j >= DP_CORE_PM; j--) {
> +				msm_dss_config_vreg(&pdev->dev,
> +				parser->mp[j].vreg_config,
> +				parser->mp[j].num_vreg, 0);
> +			}

Put this loop in the error label and return 0 above it. Better yet, just call
the dp_power_regulator_deinit in error.

> +
> +			goto error;
> +		}
> +	}
> +error:
> +	return rc;
> +}
> +
> +static void dp_power_regulator_deinit(struct dp_power_private *power)
> +{
> +	int rc = 0, i = 0;
> +	struct platform_device *pdev;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +	pdev = power->pdev;
> +
> +	for (i = DP_CORE_PM; (i < DP_MAX_PM); i++) {

Unnecessary (), applies elsewhere too, please make a pass

> +		rc = msm_dss_config_vreg(&pdev->dev,
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, 0);
> +		if (rc)
> +			pr_err("failed to deinit vregs for %s\n",
> +				dp_parser_pm_name(i));
> +	}
> +}
> +
> +static int dp_power_regulator_ctrl(struct dp_power_private *power, bool enable)
> +{
> +	int rc = 0, i = 0, j = 0;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +
> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
> +		rc = msm_dss_enable_vreg(
> +			parser->mp[i].vreg_config,
> +			parser->mp[i].num_vreg, enable);
> +		if (rc) {
> +			pr_err("failed to '%s' vregs for %s\n",
> +					enable ? "enable" : "disable",
> +					dp_parser_pm_name(i));
> +			if (enable) {
> +				for (j = i-1; j >= DP_CORE_PM; j--) {
> +					msm_dss_enable_vreg(
> +					parser->mp[j].vreg_config,
> +					parser->mp[j].num_vreg, 0);
> +				}
> +			}
> +			goto error;
> +		}
> +	}
> +error:
> +	return rc;
> +}

This function is basically identical to dp_power_regulator_init(), please
delete this function and use dp_power_regulator_init().


> +
> +static int dp_power_pinctrl_set(struct dp_power_private *power, bool active)
> +{
> +	int rc = -EFAULT;
> +	struct pinctrl_state *pin_state;
> +	struct dp_parser *parser;
> +
> +	parser = power->parser;
> +
> +	if (IS_ERR_OR_NULL(parser->pinctrl.pin))
> +		return PTR_ERR(parser->pinctrl.pin);
> +
> +	pin_state = active ? parser->pinctrl.state_active
> +				: parser->pinctrl.state_suspend;
> +	if (!IS_ERR_OR_NULL(pin_state)) {

How is this not possible? You check these on initialization.

> +		rc = pinctrl_select_state(parser->pinctrl.pin,
> +				pin_state);

Combine on 1 line

> +		if (rc)
> +			pr_err("can not set %s pins\n",
> +			       active ? "dp_active"
> +			       : "dp_sleep");


Combine on one line. Also return immediately if this is the case.

> +	} else {
> +		pr_err("invalid '%s' pinstate\n",
> +		       active ? "dp_active"
> +		       : "dp_sleep");
> +	}
> +
> +	return rc;
> +}
> +
> +static int dp_power_clk_init(struct dp_power_private *power, bool enable)

Split this into init/deinit, the paths don't share code.

> +{
> +	int rc = 0;
> +	struct dss_module_power *core, *ctrl;
> +	struct device *dev;
> +
> +	core = &power->parser->mp[DP_CORE_PM];
> +	ctrl = &power->parser->mp[DP_CTRL_PM];
> +
> +	dev = &power->pdev->dev;
> +
> +	if (!core || !ctrl) {
> +		pr_err("invalid power_data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	if (enable) {
> +		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
> +		if (rc) {
> +			pr_err("failed to get %s clk. err=%d\n",
> +				dp_parser_pm_name(DP_CORE_PM), rc);
> +			goto exit;
> +		}
> +
> +		rc = msm_dss_get_clk(dev, ctrl->clk_config, ctrl->num_clk);
> +		if (rc) {
> +			pr_err("failed to get %s clk. err=%d\n",
> +				dp_parser_pm_name(DP_CTRL_PM), rc);
> +			goto ctrl_get_error;
> +		}
> +
> +		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
> +		if (IS_ERR(power->pixel_clk_rcg)) {
> +			pr_debug("Unable to get DP pixel clk RCG\n");
> +			power->pixel_clk_rcg = NULL;
> +		}
> +
> +		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
> +		if (IS_ERR(power->pixel_parent)) {
> +			pr_debug("Unable to get DP pixel RCG parent\n");
> +			power->pixel_parent = NULL;
> +		}
> +	} else {
> +		if (power->pixel_parent)
> +			devm_clk_put(dev, power->pixel_parent);
> +
> +		if (power->pixel_clk_rcg)
> +			devm_clk_put(dev, power->pixel_clk_rcg);

device managed resources don't need to be freed

> +
> +		msm_dss_put_clk(ctrl->clk_config, ctrl->num_clk);
> +		msm_dss_put_clk(core->clk_config, core->num_clk);
> +	}
> +
> +	return rc;
> +
> +ctrl_get_error:
> +	msm_dss_put_clk(core->clk_config, core->num_clk);

Since this is only used in one place, just do it above and return directly.

> +exit:

Delete exit label and return directly

> +	return rc;
> +}
> +
> +static int dp_power_clk_set_rate(struct dp_power_private *power,
> +		enum dp_pm_type module, bool enable)
> +{
> +	int rc = 0;
> +	struct dss_module_power *mp;
> +
> +	if (!power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	mp = &power->parser->mp[module];
> +
> +	if (enable) {
> +		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
> +		if (rc) {
> +			pr_err("failed to set clks rate.\n");
> +			goto exit;
> +		}
> +
> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
> +		if (rc) {
> +			pr_err("failed to enable clks\n");
> +			goto exit;
> +		}
> +	} else {
> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
> +		if (rc) {
> +			pr_err("failed to disable clks\n");
> +				goto exit;
> +		}

This function actually can share code, but it doesn't :( Please pull this out
for both paths

> +	}
> +exit:

Delete exit label and return directly

> +	return rc;
> +}
> +
> +static int dp_power_clk_enable(struct dp_power *dp_power,
> +		enum dp_pm_type pm_type, bool enable)
> +{
> +	int rc = 0;
> +	struct dss_module_power *mp;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	mp = &power->parser->mp[pm_type];
> +
> +	if ((pm_type != DP_CORE_PM) && (pm_type != DP_CTRL_PM)) {

Strip out unnecessary ()

> +		pr_err("unsupported power module: %s\n",
> +				dp_parser_pm_name(pm_type));
> +		return -EINVAL;
> +	}
> +
> +	if (enable) {
> +		if ((pm_type == DP_CORE_PM)
> +			&& (power->core_clks_on)) {

Here too

Combine on one line as well

> +			pr_debug("core clks already enabled\n");
> +			return 0;
> +		}
> +
> +		if ((pm_type == DP_CTRL_PM)
> +			&& (power->link_clks_on)) {

and here

> +			pr_debug("links clks already enabled\n");
> +			return 0;
> +		}
> +
> +		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {

and here

> +			pr_debug("Need to enable core clks before link clks\n");
> +
> +			rc = dp_power_clk_set_rate(power, DP_CORE_PM, enable);
> +			if (rc) {
> +				pr_err("failed to enable clks: %s. err=%d\n",
> +					dp_parser_pm_name(DP_CORE_PM), rc);
> +				goto error;
> +			} else {
> +				power->core_clks_on = true;

This doesn't need to be wrapped in the else

> +			}
> +		}
> +	}
> +
> +	rc = dp_power_clk_set_rate(power, pm_type, enable);
> +	if (rc) {
> +		pr_err("failed to '%s' clks for: %s. err=%d\n",
> +			enable ? "enable" : "disable",
> +			dp_parser_pm_name(pm_type), rc);
> +			goto error;
> +	}
> +
> +	if (pm_type == DP_CORE_PM)
> +		power->core_clks_on = enable;
> +	else
> +		power->link_clks_on = enable;
> +
> +	pr_debug("%s clocks for %s\n",
> +			enable ? "enable" : "disable",
> +			dp_parser_pm_name(pm_type));
> +	pr_debug("link_clks:%s core_clks:%s\n",
> +		power->link_clks_on ? "on" : "off",
> +		power->core_clks_on ? "on" : "off");
> +error:

Delete error label and return directly

> +	return rc;
> +}
> +
> +static int dp_power_request_gpios(struct dp_power_private *power)
> +{
> +	int rc = 0, i;
> +	struct device *dev;
> +	struct dss_module_power *mp;
> +	static const char * const gpio_names[] = {
> +		"aux_enable", "aux_sel", "usbplug_cc",
> +	};
> +
> +	if (!power) {
> +		pr_err("invalid power data\n");
> +		return -EINVAL;
> +	}
> +
> +	dev = &power->pdev->dev;
> +	mp = &power->parser->mp[DP_CORE_PM];
> +
> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
> +		unsigned int gpio = mp->gpio_config[i].gpio;
> +
> +		if (gpio_is_valid(gpio)) {

if (!gpio_is_valid(gpio))
	continue;

and save yourself some indent space

> +			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
> +			if (rc) {
> +				pr_err("request %s gpio failed, rc=%d\n",
> +					       gpio_names[i], rc);
> +				goto error;
> +			}
> +		}
> +	}
> +	return 0;
> +error:
> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
> +		unsigned int gpio = mp->gpio_config[i].gpio;
> +
> +		if (gpio_is_valid(gpio))
> +			gpio_free(gpio);
> +	}

gpios are device managed, so you shouldn't need this.

> +	return rc;
> +}
> +
> +static bool dp_power_find_gpio(const char *gpio1, const char *gpio2)
> +{
> +	return !!strnstr(gpio1, gpio2, strlen(gpio1));
> +}
> +
> +static void dp_power_set_gpio(struct dp_power_private *power, bool flip)
> +{
> +	int i;
> +	struct dss_module_power *mp = &power->parser->mp[DP_CORE_PM];
> +	struct dss_gpio *config = mp->gpio_config;
> +
> +	for (i = 0; i < mp->num_gpio; i++) {
> +		if (dp_power_find_gpio(config->gpio_name, "aux-sel"))
> +			config->value = flip;
> +
> +		if (gpio_is_valid(config->gpio)) {
> +			pr_debug("gpio %s, value %d\n", config->gpio_name,
> +				config->value);
> +
> +			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
> +			    dp_power_find_gpio(config->gpio_name, "aux-sel"))
> +				gpio_direction_output(config->gpio,
> +					config->value);
> +			else
> +				gpio_set_value(config->gpio, config->value);
> +
> +		}
> +		config++;
> +	}

Instead of all of these string ops, please just make pointers accessible so you
can get at the gpio directly.

> +}
> +
> +static int dp_power_config_gpios(struct dp_power_private *power, bool flip,
> +					bool enable)

Split into 2 functions

> +{
> +	int rc = 0, i;
> +	struct dss_module_power *mp;
> +	struct dss_gpio *config;
> +
> +	mp = &power->parser->mp[DP_CORE_PM];
> +	config = mp->gpio_config;
> +
> +	if (enable) {
> +		rc = dp_power_request_gpios(power);
> +		if (rc) {
> +			pr_err("gpio request failed\n");
> +			return rc;
> +		}
> +
> +		dp_power_set_gpio(power, flip);
> +	} else {
> +		for (i = 0; i < mp->num_gpio; i++) {
> +			gpio_set_value(config[i].gpio, 0);
> +			gpio_free(config[i].gpio);
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int dp_power_client_init(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		return -EINVAL;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	pm_runtime_enable(&power->pdev->dev);
> +
> +	rc = dp_power_regulator_init(power);
> +	if (rc) {
> +		pr_err("failed to init regulators\n");

Print rc

> +		goto error_power;
> +	}
> +
> +	rc = dp_power_clk_init(power, true);
> +	if (rc) {
> +		pr_err("failed to init clocks\n");

Print rc

> +		goto error_clk;
> +	}
> +	return 0;
> +
> +error_clk:
> +	dp_power_regulator_deinit(power);
> +error_power:
> +	pm_runtime_disable(&power->pdev->dev);
> +	return rc;
> +}
> +
> +static void dp_power_client_deinit(struct dp_power *dp_power)
> +{
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		return;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	dp_power_clk_init(power, false);
> +	dp_power_regulator_deinit(power);
> +	pm_runtime_disable(&power->pdev->dev);
> +
> +}
> +
> +static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	if (power->pixel_clk_rcg && power->pixel_parent)
> +		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);

Check return value

> +exit:

Delete label/rc, return immediately.

> +	return rc;
> +}
> +
> +static int dp_power_init(struct dp_power *dp_power, bool flip)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	pm_runtime_get_sync(&power->pdev->dev);
> +	rc = dp_power_regulator_ctrl(power, true);
> +	if (rc) {
> +		pr_err("failed to enable regulators\n");

Print rc

> +		goto exit;
> +	}
> +
> +	rc = dp_power_pinctrl_set(power, true);
> +	if (rc) {

Print rc

> +		pr_err("failed to set pinctrl state\n");
> +		goto err_pinctrl;
> +	}
> +
> +	rc = dp_power_config_gpios(power, flip, true);
> +	if (rc) {

Print rc

> +		pr_err("failed to enable gpios\n");
> +		goto err_gpio;
> +	}
> +
> +	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
> +	if (rc) {

Print rc

> +		pr_err("failed to enable DP core clocks\n");
> +		goto err_clk;
> +	}
> +
> +	return 0;
> +
> +err_clk:
> +	dp_power_config_gpios(power, flip, false);
> +err_gpio:
> +	dp_power_pinctrl_set(power, false);
> +err_pinctrl:
> +	dp_power_regulator_ctrl(power, false);
> +exit:
> +	pm_runtime_put_sync(&power->pdev->dev);
> +	return rc;
> +}
> +
> +static int dp_power_deinit(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	dp_power_clk_enable(dp_power, DP_CORE_PM, false);
> +	dp_power_config_gpios(power, false, false);
> +	dp_power_pinctrl_set(power, false);
> +	dp_power_regulator_ctrl(power, false);
> +	pm_runtime_put_sync(&power->pdev->dev);
> +exit:

Delete exit label/rc and return directly

> +	return rc;
> +}
> +
> +struct dp_power *dp_power_get(struct dp_parser *parser)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +	struct dp_power *dp_power;
> +
> +	if (!parser) {
> +		pr_err("invalid input\n");
> +		rc = -EINVAL;
> +		goto error;
> +	}
> +
> +	power = devm_kzalloc(&parser->pdev->dev, sizeof(*power), GFP_KERNEL);
> +	if (!power) {
> +		rc = -ENOMEM;
> +		goto error;
> +	}
> +
> +	power->parser = parser;
> +	power->pdev = parser->pdev;
> +
> +	dp_power = &power->dp_power;
> +
> +	dp_power->init = dp_power_init;
> +	dp_power->deinit = dp_power_deinit;
> +	dp_power->clk_enable = dp_power_clk_enable;
> +	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
> +	dp_power->power_client_init = dp_power_client_init;
> +	dp_power->power_client_deinit = dp_power_client_deinit;
> +
> +	return dp_power;
> +error:
> +	return ERR_PTR(rc);
> +}
> +
> +void dp_power_put(struct dp_power *dp_power)
> +{
> +	struct dp_power_private *power = NULL;
> +
> +	if (!dp_power)
> +		return;
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	devm_kfree(&power->pdev->dev, power);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
> new file mode 100644
> index 0000000..d1adaaf
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
> @@ -0,0 +1,57 @@
> +/*
> + * Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_POWER_H_
> +#define _DP_POWER_H_
> +
> +#include "dp_parser.h"
> +#include "dpu_power_handle.h"
> +
> +/**
> + * sruct dp_power - DisplayPort's power related data
> + *
> + * @init: initializes the regulators/core clocks/GPIOs/pinctrl
> + * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
> + * @clk_enable: enable/disable the DP clocks
> + * @set_pixel_clk_parent: set the parent of DP pixel clock
> + */
> +struct dp_power {
> +	int (*init)(struct dp_power *power, bool flip);
> +	int (*deinit)(struct dp_power *power);
> +	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
> +				bool enable);
> +	int (*set_pixel_clk_parent)(struct dp_power *power);
> +	int (*power_client_init)(struct dp_power *power);
> +	void (*power_client_deinit)(struct dp_power *power);
> +};
> +
> +/**
> + * dp_power_get() - configure and get the DisplayPort power module data
> + *
> + * @parser: instance of parser module
> + * return: pointer to allocated power module data
> + *
> + * This API will configure the DisplayPort's power module and provides
> + * methods to be called by the client to configure the power related
> + * modueles.
> + */
> +struct dp_power *dp_power_get(struct dp_parser *parser);
> +
> +/**
> + * dp_power_put() - release the power related resources
> + *
> + * @power: pointer to the power module's data
> + */
> +void dp_power_put(struct dp_power *power);
> +#endif /* _DP_POWER_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_reg.h b/drivers/gpu/drm/msm/dp/dp_reg.h
> new file mode 100644
> index 0000000..77b5c0e
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/dp_reg.h
> @@ -0,0 +1,357 @@
> +/*
> + * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef _DP_REG_H_
> +#define _DP_REG_H_
> +
> +/* DP_TX Registers */
> +#define DP_HW_VERSION				(0x00000000)
> +#define DP_SW_RESET				(0x00000010)
> +#define DP_PHY_CTRL				(0x00000014)
> +#define DP_CLK_CTRL				(0x00000018)
> +#define DP_CLK_ACTIVE				(0x0000001C)
> +#define DP_INTR_STATUS				(0x00000020)
> +#define DP_INTR_STATUS2				(0x00000024)
> +#define DP_INTR_STATUS3				(0x00000028)
> +
> +#define DP_DP_HPD_CTRL				(0x00000000)
> +#define DP_DP_HPD_INT_STATUS			(0x00000004)
> +#define DP_DP_HPD_INT_ACK			(0x00000008)
> +#define DP_DP_HPD_INT_MASK			(0x0000000C)
> +#define DP_DP_HPD_REFTIMER			(0x00000018)
> +#define DP_DP_HPD_EVENT_TIME_0			(0x0000001C)
> +#define DP_DP_HPD_EVENT_TIME_1			(0x00000020)
> +#define DP_AUX_CTRL				(0x00000030)
> +#define DP_AUX_DATA				(0x00000034)
> +#define DP_AUX_TRANS_CTRL			(0x00000038)
> +#define DP_TIMEOUT_COUNT			(0x0000003C)
> +#define DP_AUX_LIMITS				(0x00000040)
> +#define DP_AUX_STATUS				(0x00000044)
> +
> +#define DP_DPCD_CP_IRQ				(0x201)
> +#define DP_DPCD_RXSTATUS			(0x69493)
> +
> +#define DP_INTERRUPT_TRANS_NUM			(0x000000A0)
> +
> +#define DP_MAINLINK_CTRL			(0x00000000)
> +#define DP_STATE_CTRL				(0x00000004)
> +#define DP_CONFIGURATION_CTRL			(0x00000008)
> +#define DP_SOFTWARE_MVID			(0x00000010)
> +#define DP_SOFTWARE_NVID			(0x00000018)
> +#define DP_TOTAL_HOR_VER			(0x0000001C)
> +#define DP_START_HOR_VER_FROM_SYNC		(0x00000020)
> +#define DP_HSYNC_VSYNC_WIDTH_POLARITY		(0x00000024)
> +#define DP_ACTIVE_HOR_VER			(0x00000028)
> +#define DP_MISC1_MISC0				(0x0000002C)
> +#define DP_VALID_BOUNDARY			(0x00000030)
> +#define DP_VALID_BOUNDARY_2			(0x00000034)
> +#define DP_LOGICAL2PHYSICAL_LANE_MAPPING	(0x00000038)
> +
> +#define DP_MAINLINK_READY			(0x00000040)
> +#define DP_MAINLINK_LEVELS			(0x00000044)
> +#define DP_TU					(0x0000004C)
> +
> +#define DP_HBR2_COMPLIANCE_SCRAMBLER_RESET	(0x00000054)
> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG0	(0x000000C0)
> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG1	(0x000000C4)
> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG2	(0x000000C8)
> +
> +#define MMSS_DP_MISC1_MISC0			(0x0000002C)
> +#define MMSS_DP_AUDIO_TIMING_GEN		(0x00000080)
> +#define MMSS_DP_AUDIO_TIMING_RBR_32		(0x00000084)
> +#define MMSS_DP_AUDIO_TIMING_HBR_32		(0x00000088)
> +#define MMSS_DP_AUDIO_TIMING_RBR_44		(0x0000008C)
> +#define MMSS_DP_AUDIO_TIMING_HBR_44		(0x00000090)
> +#define MMSS_DP_AUDIO_TIMING_RBR_48		(0x00000094)
> +#define MMSS_DP_AUDIO_TIMING_HBR_48		(0x00000098)
> +
> +#define MMSS_DP_PSR_CRC_RG			(0x00000154)
> +#define MMSS_DP_PSR_CRC_B			(0x00000158)
> +
> +#define DP_COMPRESSION_MODE_CTRL		(0x00000180)
> +
> +#define MMSS_DP_AUDIO_CFG			(0x00000200)
> +#define MMSS_DP_AUDIO_STATUS			(0x00000204)
> +#define MMSS_DP_AUDIO_PKT_CTRL			(0x00000208)
> +#define MMSS_DP_AUDIO_PKT_CTRL2			(0x0000020C)
> +#define MMSS_DP_AUDIO_ACR_CTRL			(0x00000210)
> +#define MMSS_DP_AUDIO_CTRL_RESET		(0x00000214)
> +
> +#define MMSS_DP_SDP_CFG				(0x00000228)
> +#define MMSS_DP_SDP_CFG2			(0x0000022C)
> +#define MMSS_DP_AUDIO_TIMESTAMP_0		(0x00000230)
> +#define MMSS_DP_AUDIO_TIMESTAMP_1		(0x00000234)
> +
> +#define MMSS_DP_AUDIO_STREAM_0			(0x00000240)
> +#define MMSS_DP_AUDIO_STREAM_1			(0x00000244)
> +
> +#define MMSS_DP_EXTENSION_0			(0x00000250)
> +#define MMSS_DP_EXTENSION_1			(0x00000254)
> +#define MMSS_DP_EXTENSION_2			(0x00000258)
> +#define MMSS_DP_EXTENSION_3			(0x0000025C)
> +#define MMSS_DP_EXTENSION_4			(0x00000260)
> +#define MMSS_DP_EXTENSION_5			(0x00000264)
> +#define MMSS_DP_EXTENSION_6			(0x00000268)
> +#define MMSS_DP_EXTENSION_7			(0x0000026C)
> +#define MMSS_DP_EXTENSION_8			(0x00000270)
> +#define MMSS_DP_EXTENSION_9			(0x00000274)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_0		(0x00000278)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_1		(0x0000027C)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_2		(0x00000280)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_3		(0x00000284)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_4		(0x00000288)
> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_5		(0x0000028C)
> +#define MMSS_DP_AUDIO_ISRC_0			(0x00000290)
> +#define MMSS_DP_AUDIO_ISRC_1			(0x00000294)
> +#define MMSS_DP_AUDIO_ISRC_2			(0x00000298)
> +#define MMSS_DP_AUDIO_ISRC_3			(0x0000029C)
> +#define MMSS_DP_AUDIO_ISRC_4			(0x000002A0)
> +#define MMSS_DP_AUDIO_ISRC_5			(0x000002A4)
> +#define MMSS_DP_AUDIO_INFOFRAME_0		(0x000002A8)
> +#define MMSS_DP_AUDIO_INFOFRAME_1		(0x000002AC)
> +#define MMSS_DP_AUDIO_INFOFRAME_2		(0x000002B0)
> +
> +#define MMSS_DP_GENERIC0_0			(0x00000300)
> +#define MMSS_DP_GENERIC0_1			(0x00000304)
> +#define MMSS_DP_GENERIC0_2			(0x00000308)
> +#define MMSS_DP_GENERIC0_3			(0x0000030C)
> +#define MMSS_DP_GENERIC0_4			(0x00000310)
> +#define MMSS_DP_GENERIC0_5			(0x00000314)
> +#define MMSS_DP_GENERIC0_6			(0x00000318)
> +#define MMSS_DP_GENERIC0_7			(0x0000031C)
> +#define MMSS_DP_GENERIC0_8			(0x00000320)
> +#define MMSS_DP_GENERIC0_9			(0x00000324)
> +#define MMSS_DP_GENERIC1_0			(0x00000328)
> +#define MMSS_DP_GENERIC1_1			(0x0000032C)
> +#define MMSS_DP_GENERIC1_2			(0x00000330)
> +#define MMSS_DP_GENERIC1_3			(0x00000334)
> +#define MMSS_DP_GENERIC1_4			(0x00000338)
> +#define MMSS_DP_GENERIC1_5			(0x0000033C)
> +#define MMSS_DP_GENERIC1_6			(0x00000340)
> +#define MMSS_DP_GENERIC1_7			(0x00000344)
> +#define MMSS_DP_GENERIC1_8			(0x00000348)
> +#define MMSS_DP_GENERIC1_9			(0x0000034C)
> +
> +#define MMSS_DP_VSCEXT_0			(0x000002D0)
> +#define MMSS_DP_VSCEXT_1			(0x000002D4)
> +#define MMSS_DP_VSCEXT_2			(0x000002D8)
> +#define MMSS_DP_VSCEXT_3			(0x000002DC)
> +#define MMSS_DP_VSCEXT_4			(0x000002E0)
> +#define MMSS_DP_VSCEXT_5			(0x000002E4)
> +#define MMSS_DP_VSCEXT_6			(0x000002E8)
> +#define MMSS_DP_VSCEXT_7			(0x000002EC)
> +#define MMSS_DP_VSCEXT_8			(0x000002F0)
> +#define MMSS_DP_VSCEXT_9			(0x000002F4)
> +
> +#define MMSS_DP_BIST_ENABLE			(0x00000000)
> +#define MMSS_DP_TIMING_ENGINE_EN		(0x00000010)
> +#define MMSS_DP_INTF_CONFIG			(0x00000014)
> +#define MMSS_DP_INTF_HSYNC_CTL			(0x00000018)
> +#define MMSS_DP_INTF_VSYNC_PERIOD_F0		(0x0000001C)
> +#define MMSS_DP_INTF_VSYNC_PERIOD_F1		(0x00000020)
> +#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0	(0x00000024)
> +#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1	(0x00000028)
> +#define MMSS_INTF_DISPLAY_V_START_F0		(0x0000002C)
> +#define MMSS_INTF_DISPLAY_V_START_F1		(0x00000030)
> +#define MMSS_DP_INTF_DISPLAY_V_END_F0		(0x00000034)
> +#define MMSS_DP_INTF_DISPLAY_V_END_F1		(0x00000038)
> +#define MMSS_DP_INTF_ACTIVE_V_START_F0		(0x0000003C)
> +#define MMSS_DP_INTF_ACTIVE_V_START_F1		(0x00000040)
> +#define MMSS_DP_INTF_ACTIVE_V_END_F0		(0x00000044)
> +#define MMSS_DP_INTF_ACTIVE_V_END_F1		(0x00000048)
> +#define MMSS_DP_INTF_DISPLAY_HCTL		(0x0000004C)
> +#define MMSS_DP_INTF_ACTIVE_HCTL		(0x00000050)
> +#define MMSS_DP_INTF_POLARITY_CTL		(0x00000058)
> +#define MMSS_DP_TPG_MAIN_CONTROL		(0x00000060)
> +#define MMSS_DP_TPG_VIDEO_CONFIG		(0x00000064)
> +#define MMSS_DP_ASYNC_FIFO_CONFIG		(0x00000088)
> +
> +/*DP PHY Register offsets */
> +#define DP_PHY_REVISION_ID0                     (0x00000000)
> +#define DP_PHY_REVISION_ID1                     (0x00000004)
> +#define DP_PHY_REVISION_ID2                     (0x00000008)
> +#define DP_PHY_REVISION_ID3                     (0x0000000C)
> +
> +#define DP_PHY_CFG                              (0x00000010)
> +#define DP_PHY_PD_CTL                           (0x00000018)
> +#define DP_PHY_MODE                             (0x0000001C)
> +
> +#define DP_PHY_AUX_CFG0                         (0x00000020)
> +#define DP_PHY_AUX_CFG1                         (0x00000024)
> +#define DP_PHY_AUX_CFG2                         (0x00000028)
> +#define DP_PHY_AUX_CFG3                         (0x0000002C)
> +#define DP_PHY_AUX_CFG4                         (0x00000030)
> +#define DP_PHY_AUX_CFG5                         (0x00000034)
> +#define DP_PHY_AUX_CFG6                         (0x00000038)
> +#define DP_PHY_AUX_CFG7                         (0x0000003C)
> +#define DP_PHY_AUX_CFG8                         (0x00000040)
> +#define DP_PHY_AUX_CFG9                         (0x00000044)
> +#define DP_PHY_AUX_INTERRUPT_MASK               (0x00000048)
> +#define DP_PHY_AUX_INTERRUPT_CLEAR              (0x0000004C)
> +#define DP_PHY_AUX_BIST_CFG			(0x00000050)
> +
> +#define DP_PHY_VCO_DIV				0x0064
> +#define DP_PHY_TX0_TX1_LANE_CTL			0x006C
> +#define DP_PHY_TX2_TX3_LANE_CTL			0x0088
> +
> +#define DP_PHY_SPARE0				(0x00AC)
> +#define DP_PHY_STATUS				(0x00C0)
> +
> +/* Tx registers */
> +#define TXn_BIST_MODE_LANENO			0x0000
> +#define TXn_CLKBUF_ENABLE			0x0008
> +#define TXn_TX_EMP_POST1_LVL			0x000C
> +
> +#define TXn_TX_DRV_LVL				0x001C
> +
> +#define TXn_RESET_TSYNC_EN			0x0024
> +#define TXn_PRE_STALL_LDO_BOOST_EN		0x0028
> +#define TXn_TX_BAND				0x002C
> +#define TXn_SLEW_CNTL				0x0030
> +#define TXn_INTERFACE_SELECT			0x0034
> +
> +#define TXn_RES_CODE_LANE_TX			0x003C
> +#define TXn_RES_CODE_LANE_RX			0x0040
> +#define TXn_RES_CODE_LANE_OFFSET_TX		0x0044
> +#define TXn_RES_CODE_LANE_OFFSET_RX		0x0048
> +
> +#define TXn_DEBUG_BUS_SEL			0x0058
> +#define TXn_TRANSCEIVER_BIAS_EN			0x005C
> +#define TXn_HIGHZ_DRVR_EN			0x0060
> +#define TXn_TX_POL_INV				0x0064
> +#define TXn_PARRATE_REC_DETECT_IDLE_EN		0x0068
> +
> +#define TXn_LANE_MODE_1				0x008C
> +
> +#define TXn_TRAN_DRVR_EMP_EN			0x00C0
> +#define TXn_TX_INTERFACE_MODE			0x00C4
> +
> +#define TXn_VMODE_CTRL1				0x00F0
> +
> +/* PLL register offset */
> +#define QSERDES_COM_ATB_SEL1			0x0000
> +#define QSERDES_COM_ATB_SEL2			0x0004
> +#define QSERDES_COM_FREQ_UPDATE			0x0008
> +#define QSERDES_COM_BG_TIMER			0x000C
> +#define QSERDES_COM_SSC_EN_CENTER		0x0010
> +#define QSERDES_COM_SSC_ADJ_PER1		0x0014
> +#define QSERDES_COM_SSC_ADJ_PER2		0x0018
> +#define QSERDES_COM_SSC_PER1			0x001C
> +#define QSERDES_COM_SSC_PER2			0x0020
> +#define QSERDES_COM_SSC_STEP_SIZE1		0x0024
> +#define QSERDES_COM_SSC_STEP_SIZE2		0x0028
> +#define QSERDES_COM_POST_DIV			0x002C
> +#define QSERDES_COM_POST_DIV_MUX		0x0030
> +#define QSERDES_COM_BIAS_EN_CLKBUFLR_EN		0x0034
> +#define QSERDES_COM_CLK_ENABLE1			0x0038
> +#define QSERDES_COM_SYS_CLK_CTRL		0x003C
> +#define QSERDES_COM_SYSCLK_BUF_ENABLE		0x0040
> +#define QSERDES_COM_PLL_EN			0x0044
> +#define QSERDES_COM_PLL_IVCO			0x0048
> +#define QSERDES_COM_CMN_IETRIM			0x004C
> +#define QSERDES_COM_CMN_IPTRIM			0x0050
> +
> +#define QSERDES_COM_CP_CTRL_MODE0		0x0060
> +#define QSERDES_COM_CP_CTRL_MODE1		0x0064
> +#define QSERDES_COM_PLL_RCTRL_MODE0		0x0068
> +#define QSERDES_COM_PLL_RCTRL_MODE1		0x006C
> +#define QSERDES_COM_PLL_CCTRL_MODE0		0x0070
> +#define QSERDES_COM_PLL_CCTRL_MODE1		0x0074
> +#define QSERDES_COM_PLL_CNTRL			0x0078
> +#define QSERDES_COM_BIAS_EN_CTRL_BY_PSM		0x007C
> +#define QSERDES_COM_SYSCLK_EN_SEL		0x0080
> +#define QSERDES_COM_CML_SYSCLK_SEL		0x0084
> +#define QSERDES_COM_RESETSM_CNTRL		0x0088
> +#define QSERDES_COM_RESETSM_CNTRL2		0x008C
> +#define QSERDES_COM_LOCK_CMP_EN			0x0090
> +#define QSERDES_COM_LOCK_CMP_CFG		0x0094
> +#define QSERDES_COM_LOCK_CMP1_MODE0		0x0098
> +#define QSERDES_COM_LOCK_CMP2_MODE0		0x009C
> +#define QSERDES_COM_LOCK_CMP3_MODE0		0x00A0
> +
> +#define QSERDES_COM_DEC_START_MODE0		0x00B0
> +#define QSERDES_COM_DEC_START_MODE1		0x00B4
> +#define QSERDES_COM_DIV_FRAC_START1_MODE0	0x00B8
> +#define QSERDES_COM_DIV_FRAC_START2_MODE0	0x00BC
> +#define QSERDES_COM_DIV_FRAC_START3_MODE0	0x00C0
> +#define QSERDES_COM_DIV_FRAC_START1_MODE1	0x00C4
> +#define QSERDES_COM_DIV_FRAC_START2_MODE1	0x00C8
> +#define QSERDES_COM_DIV_FRAC_START3_MODE1	0x00CC
> +#define QSERDES_COM_INTEGLOOP_INITVAL		0x00D0
> +#define QSERDES_COM_INTEGLOOP_EN		0x00D4
> +#define QSERDES_COM_INTEGLOOP_GAIN0_MODE0	0x00D8
> +#define QSERDES_COM_INTEGLOOP_GAIN1_MODE0	0x00DC
> +#define QSERDES_COM_INTEGLOOP_GAIN0_MODE1	0x00E0
> +#define QSERDES_COM_INTEGLOOP_GAIN1_MODE1	0x00E4
> +#define QSERDES_COM_VCOCAL_DEADMAN_CTRL		0x00E8
> +#define QSERDES_COM_VCO_TUNE_CTRL		0x00EC
> +#define QSERDES_COM_VCO_TUNE_MAP		0x00F0
> +
> +#define QSERDES_COM_CMN_STATUS			0x0124
> +#define QSERDES_COM_RESET_SM_STATUS		0x0128
> +
> +#define QSERDES_COM_CLK_SEL			0x0138
> +#define QSERDES_COM_HSCLK_SEL			0x013C
> +
> +#define QSERDES_COM_CORECLK_DIV_MODE0		0x0148
> +
> +#define QSERDES_COM_SW_RESET			0x0150
> +#define QSERDES_COM_CORE_CLK_EN			0x0154
> +#define QSERDES_COM_C_READY_STATUS		0x0158
> +#define QSERDES_COM_CMN_CONFIG			0x015C
> +
> +#define QSERDES_COM_SVS_MODE_CLK_SEL		0x0164
> +
> +/* DP MMSS_CC registers */
> +#define MMSS_DP_LINK_CMD_RCGR			(0x0138)
> +#define MMSS_DP_LINK_CFG_RCGR			(0x013C)
> +#define MMSS_DP_PIXEL_M				(0x0174)
> +#define MMSS_DP_PIXEL_N				(0x0178)
> +
> +/* DP HDCP 1.3 registers */
> +#define DP_HDCP_CTRL                                   (0x0A0)
> +#define DP_HDCP_STATUS                                 (0x0A4)
> +#define DP_HDCP_SW_UPPER_AKSV                          (0x098)
> +#define DP_HDCP_SW_LOWER_AKSV                          (0x09C)
> +#define DP_HDCP_ENTROPY_CTRL0                          (0x350)
> +#define DP_HDCP_ENTROPY_CTRL1                          (0x35C)
> +#define DP_HDCP_SHA_STATUS                             (0x0C8)
> +#define DP_HDCP_RCVPORT_DATA2_0                        (0x0B0)
> +#define DP_HDCP_RCVPORT_DATA3                          (0x0A4)
> +#define DP_HDCP_RCVPORT_DATA4                          (0x0A8)
> +#define DP_HDCP_RCVPORT_DATA5                          (0x0C0)
> +#define DP_HDCP_RCVPORT_DATA6                          (0x0C4)
> +
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_CTRL           (0x024)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_DATA           (0x028)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA0      (0x004)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA1      (0x008)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA7      (0x00C)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA8      (0x010)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA9      (0x014)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA10     (0x018)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA11     (0x01C)
> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA12     (0x020)
> +
> +/* USB3 DP COM registers */
> +#define USB3_DP_COM_RESET_OVRD_CTRL (0x1C)
> +#define USB3_DP_COM_PHY_MODE_CTRL   (0x00)
> +#define USB3_DP_COM_SW_RESET        (0x04)
> +#define USB3_DP_COM_TYPEC_CTRL      (0x10)
> +#define USB3_DP_COM_SWI_CTRL        (0x0c)
> +#define USB3_DP_COM_POWER_DOWN_CTRL (0x08)
> +
> +
> +
> +#endif /* _DP_REG_H_ */
> diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
> index f5cd7f6..be801be 100644
> --- a/drivers/gpu/drm/msm/msm_drv.c
> +++ b/drivers/gpu/drm/msm/msm_drv.c
> @@ -1367,6 +1367,7 @@ static int __init msm_drm_register(void)
>  	msm_dsi_register();
>  	msm_edp_register();
>  	msm_hdmi_register();
> +	msm_dp_register();
>  	adreno_register();
>  	return platform_driver_register(&msm_platform_driver);
>  }
> @@ -1375,6 +1376,7 @@ static void __exit msm_drm_unregister(void)
>  {
>  	DBG("fini");
>  	platform_driver_unregister(&msm_platform_driver);
> +	msm_dp_unregister();
>  	msm_hdmi_unregister();
>  	adreno_unregister();
>  	msm_edp_unregister();
> diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
> index 9d11f32..fb1e6f4 100644
> --- a/drivers/gpu/drm/msm/msm_drv.h
> +++ b/drivers/gpu/drm/msm/msm_drv.h
> @@ -176,6 +176,7 @@ struct msm_drm_private {
>  	/* DSI is shared by mdp4 and mdp5 */
>  	struct msm_dsi *dsi[2];
>  
> +	struct msm_dp *dp;

Can you please add an extra line here?

>  	/* when we have more than one 'msm_gpu' these need to be an array: */
>  	struct msm_gpu *gpu;
>  	struct msm_file_private *lastctx;
> @@ -364,6 +365,27 @@ static inline int msm_dsi_modeset_init(struct msm_dsi *msm_dsi,
>  }
>  #endif
>  
> +#ifdef CONFIG_DRM_MSM_DP
> +int __init msm_dp_register(void);
> +void __exit msm_dp_unregister(void);
> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev,
> +			 struct drm_encoder *encoder);
> +#else
> +static inline int __init msm_dp_register(void)
> +{
> +	return -EINVAL;
> +}
> +static inline void __exit msm_dp_unregister(void)
> +{
> +}
> +static inline int msm_dp_modeset_init(struct msm_dp *dp_display,
> +				       struct drm_device *dev,
> +				       struct drm_encoder *encoder)
> +{
> +	return -EINVAL;
> +}
> +#endif
> +
>  void __init msm_mdp_register(void);
>  void __exit msm_mdp_unregister(void);
>  void __init msm_dpu_register(void);
> diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
> index 2a3843f..b0816f5 100644
> --- a/include/drm/drm_dp_helper.h
> +++ b/include/drm/drm_dp_helper.h

Split these changes out into a separate patch, please

> @@ -551,6 +551,8 @@
>  # define DP_TEST_LINK_EDID_READ		    (1 << 2)
>  # define DP_TEST_LINK_PHY_TEST_PATTERN	    (1 << 3) /* DPCD >= 1.1 */
>  # define DP_TEST_LINK_FAUX_PATTERN	    (1 << 4) /* DPCD >= 1.2 */
> +# define DP_TEST_LINK_AUDIO_PATTERN     (1 << 5)
> +# define DP_TEST_LINK_AUDIO_DISABLED_VIDEO (1 << 6)

Add DPCD version in comments for these like above.

>  
>  #define DP_TEST_LINK_RATE		    0x219
>  # define DP_LINK_RATE_162		    (0x6)
> @@ -639,6 +641,13 @@
>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_71_64  0x258
>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_79_72  0x259
>  
> +#define DP_TEST_PHY_PATTERN_NONE			0x0
> +#define DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING	0x1
> +#define DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT 0x2
> +#define DP_TEST_PHY_PATTERN_PRBS7			0x3
> +#define DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN	0x4
> +#define DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN	0x5

These are already in drm_dp_helper under DP_LINK_QUAL_PATTERN_*

> +
>  #define DP_TEST_RESPONSE		    0x260
>  # define DP_TEST_ACK			    (1 << 0)
>  # define DP_TEST_NAK			    (1 << 1)
> @@ -648,6 +657,16 @@
>  
>  #define DP_TEST_SINK			    0x270
>  # define DP_TEST_SINK_START		    (1 << 0)
> +#define DP_TEST_AUDIO_MODE		    0x271
> +#define DP_TEST_AUDIO_PATTERN_TYPE	    0x272
> +#define DP_TEST_AUDIO_PERIOD_CH1	    0x273
> +#define DP_TEST_AUDIO_PERIOD_CH2	    0x274
> +#define DP_TEST_AUDIO_PERIOD_CH3	    0x275
> +#define DP_TEST_AUDIO_PERIOD_CH4	    0x276
> +#define DP_TEST_AUDIO_PERIOD_CH5	    0x277
> +#define DP_TEST_AUDIO_PERIOD_CH6	    0x278
> +#define DP_TEST_AUDIO_PERIOD_CH7	    0x279
> +#define DP_TEST_AUDIO_PERIOD_CH8	    0x27A
>  
>  #define DP_FEC_STATUS			    0x280    /* 1.4 */
>  # define DP_FEC_DECODE_EN_DETECTED	    (1 << 0)
> -- 
> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
> a Linux Foundation Collaborative Project
> 
> _______________________________________________
> Freedreno mailing list
> Freedreno@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/freedreno

-- 
Sean Paul, Software Engineer, Google / Chromium OS
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[chandanu-sgV2jX0FEOL9JmXXK+q4OQ]

On 2018-10-23 09:28, Sean Paul wrote:
> On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
>> Add the needed displayPort files to enable DP driver
>> on msm target.
>> 
>> "dp_display" module is the main module that calls into
>> other sub-modules. "dp_drm" file represents the interface
>> between DRM framework and DP driver.
>> 
> 

Hello Sean,
I had few queries regarding your comments. Shared my queries below. 
Please share your feedback.


> Hi Chandan,
> A few themes which I've pointed out below, but want to call out at the 
> top so
> it's obvious.
> 
> - Please remove all superfluous NULL checks at the beginning of 
> functions.
>   Included in this is reflowing initialization of variables and 
> checking that
>   return types still make sense (ie: if a function's only error path is 
> the NULL
>   check, make it void).
> - Please remove all of the new callbacks and just call functions 
> directly. This
>   should also get rid of the _get/_put functions that allocate/set them 
> up
> - Please consolidate state structs into one struct with a few 
> substructs,
>   there's too much state right now.
> - Please #define hardcoded values
> - Instead of sprinkling wmb() everywhere, use readl/writel instead of 
> *_relaxed
> - There are a bunch of races that I found, please audit the code and 
> remove
>   races with locks as necessary
> - I tried to catch as much dead code as possible, please audit the rest 
> for
>   unused structs/variables/functions/etc
> - Use drm dp helper structs for link parameter storage
> 
> 
>> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
>> ---
>>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>>  drivers/gpu/drm/msm/Makefile                |   15 +-
>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 
>> ++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 
>> +++++++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 
>> +++++++++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>>  include/drm/drm_dp_helper.h                 |   19 +
>>  30 files changed, 10887 insertions(+), 1 deletion(-)
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
>> 
>> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
>> index 843a9d4..c363f24 100644
>> --- a/drivers/gpu/drm/msm/Kconfig
>> +++ b/drivers/gpu/drm/msm/Kconfig
>> @@ -49,6 +49,15 @@ config DRM_MSM_HDMI_HDCP
>>  	help
>>  	  Choose this option to enable HDCP state machine
>> 
>> +config DRM_MSM_DP
>> +	bool "Enable DP support in MSM DRM driver"
>> +	depends on DRM_MSM
>> +	default n
>> +	help
>> +	  Compile in support for DP driver in msm drm
>> +	  driver. DP external display support is enabled
>> +	  through this config option. It can be primary or
>> +	  secondary display on device.
> 
> Why are these line lengths so short? You can go to 80 columns. Please 
> also add
> an empty line here.
> 
>>  config DRM_MSM_DSI
>>  	bool "Enable DSI support in MSM DRM driver"
>>  	depends on DRM_MSM
>> diff --git a/drivers/gpu/drm/msm/Makefile 
>> b/drivers/gpu/drm/msm/Makefile
>> index 19ab521..765a8d8 100644
>> --- a/drivers/gpu/drm/msm/Makefile
>> +++ b/drivers/gpu/drm/msm/Makefile
>> @@ -2,6 +2,7 @@
>>  ccflags-y := -Idrivers/gpu/drm/msm
>>  ccflags-y += -Idrivers/gpu/drm/msm/disp/dpu1
>>  ccflags-$(CONFIG_DRM_MSM_DSI) += -Idrivers/gpu/drm/msm/dsi
>> +ccflags-$(CONFIG_DRM_MSM_DP) += -Idrivers/gpu/drm/msm/dp
>> 
>>  msm-y := \
>>  	adreno/adreno_device.o \
>> @@ -93,7 +94,19 @@ msm-y := \
>>  	msm_submitqueue.o
>> 
>>  msm-$(CONFIG_DEBUG_FS) += adreno/a5xx_debugfs.o \
>> -			  disp/dpu1/dpu_dbg.o
>> +			  disp/dpu1/dpu_dbg.o \
>> +			  dp/dp_debug.o
> 
> Does this compile if CONFIG_DEBUG_FS is selected, but not 
> CONFIG_DRM_MSM_DP?
> 
>> +
>> +msm-$(CONFIG_DRM_MSM_DP)+= dp/dp_extcon.o \
>> +	dp/dp_parser.o \
>> +	dp/dp_power.o \
>> +	dp/dp_catalog.o \
>> +	dp/dp_aux.o \
>> +	dp/dp_panel.o \
>> +	dp/dp_link.o \
>> +	dp/dp_ctrl.o \
>> +	dp/dp_display.o \
>> +	dp/dp_drm.o
> 
> The rest of the file has files in alphabetical order, this should too.
> 
>> 
>>  msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
>>  msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c 
>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> index 790d39f..0f53a15 100644
>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> @@ -14,10 +14,216 @@
>>  #include <linux/clk.h>
>>  #include <linux/clk/clk-conf.h>
>>  #include <linux/err.h>
>> +#include <linux/io.h>
>> +#include <linux/regulator/consumer.h>
>>  #include <linux/delay.h>
>> 
>>  #include "dpu_io_util.h"
>> 
>> +static struct resource *msm_dss_get_res_byname(struct platform_device 
>> *pdev,
>> +					       unsigned int type,
>> +					       const char *name)
>> +{
>> +	struct resource *res = NULL;
>> +
>> +	res = platform_get_resource_byname(pdev, type, name);
>> +	if (!res)
>> +		DEV_ERR("%s: '%s' resource not found\n", __func__, name);
>> +
>> +	return res;
>> +} /* msm_dss_get_res_byname */
> 
> Why don't you just call platform_get_resource_byname directly?
> 
>> +
>> +int msm_dss_ioremap_byname(struct platform_device *pdev,
>> +			   struct dss_io_data *io_data, const char *name)
>> +{
>> +	struct resource *res = NULL;
>> +
>> +	if (!pdev || !io_data) {
> 
> Given that we've been aggressively trying to get rid of these 
> superfluous
> checks, I'm not thrilled that they're being re-introduced. Can you 
> please go
> through the patch and remove all of the unnecessary checks?
> 
>> +		DEV_ERR("%pS->%s: invalid input\n",
>> +			__builtin_return_address(0), __func__);
>> +		return -EINVAL;
>> +	}
>> +
>> +	res = msm_dss_get_res_byname(pdev, IORESOURCE_MEM, name);
>> +	if (!res) {
>> +		DEV_ERR("%pS->%s: '%s' msm_dss_get_res_byname failed\n",
>> +			__builtin_return_address(0), __func__, name);
> 
> Yet another error format :) Could we please stick with one of 
> DPU_ERROR,
> DRM_ERROR, or DRM_DEV_ERROR?
> 
>> +		return -ENODEV;
>> +	}
>> +
>> +	io_data->len = (u32)resource_size(res);
>> +	io_data->base = ioremap(res->start, io_data->len);
>> +	if (!io_data->base) {
>> +		DEV_ERR("%pS->%s: '%s' ioremap failed\n",
>> +			__builtin_return_address(0), __func__, name);
>> +		return -EIO;
>> +	}
>> +
>> +	return 0;
>> +} /* msm_dss_ioremap_byname */
>> +
>> +void msm_dss_iounmap(struct dss_io_data *io_data)
>> +{
>> +	if (!io_data) {
>> +		DEV_ERR("%pS->%s: invalid input\n",
>> +			__builtin_return_address(0), __func__);
>> +		return;
>> +	}
>> +
>> +	if (io_data->base) {
>> +		iounmap(io_data->base);
>> +		io_data->base = NULL;
>> +	}
>> +	io_data->len = 0;
>> +} /* msm_dss_iounmap */
> 
> These two functions are only used in dp_parser.c, why not just make 
> them static
> functions there?
> 
>> +
>> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
>> +			int num_vreg, int config)
> 
> This should be 2 functions, one for initialization and one for 
> deinitializing,
> the 2 paths don't share any code, so there's no need to combine them.
> 
>> +{
>> +	int i = 0, rc = 0;
>> +	struct dss_vreg *curr_vreg = NULL;
>> +	enum dss_vreg_type type;
>> +
>> +	if (!in_vreg || !num_vreg)
>> +		return rc;
>> +
>> +	if (config) {
>> +		for (i = 0; i < num_vreg; i++) {
>> +			curr_vreg = &in_vreg[i];
>> +			curr_vreg->vreg = regulator_get(dev,
> 
> Use devm_* please
> 
>> +				curr_vreg->vreg_name);
>> +			rc = PTR_RET(curr_vreg->vreg);
> 
> PTR_RET is deprecated. The pattern for this is usually:
> 
>                         ptr = some_func();
>                         if (IS_ERR_OR_NULL(ptr)) {
>                                 ...
>                                 rc = PTR_ERR(ptr);
>                                 goto fail_label:
>                         }
> 
>> +			if (rc) {
>> +				DEV_ERR("%pS->%s: %s get failed. rc=%d\n",
>> +					 __builtin_return_address(0), __func__,
>> +					 curr_vreg->vreg_name, rc);
>> +				curr_vreg->vreg = NULL;
>> +				goto vreg_get_fail;
>> +			}
>> +			type = (regulator_count_voltages(curr_vreg->vreg) > 0)
>> +					? DSS_REG_LDO : DSS_REG_VS;
>> +			if (type == DSS_REG_LDO) {
>> +				rc = regulator_set_voltage(
>> +					curr_vreg->vreg,
>> +					curr_vreg->min_voltage,
>> +					curr_vreg->max_voltage);
>> +				if (rc < 0) {
>> +					DEV_ERR("%pS->%s: %s set vltg fail\n",
>> +						__builtin_return_address(0),
>> +						__func__,
>> +						curr_vreg->vreg_name);
>> +					goto vreg_set_voltage_fail;
>> +				}
>> +			}
>> +		}
>> +	} else {
>> +		for (i = num_vreg-1; i >= 0; i--) {
>> +			curr_vreg = &in_vreg[i];
>> +			if (curr_vreg->vreg) {
>> +				type = (regulator_count_voltages(
>> +					curr_vreg->vreg) > 0)
>> +					? DSS_REG_LDO : DSS_REG_VS;
>> +				if (type == DSS_REG_LDO) {
>> +					regulator_set_voltage(curr_vreg->vreg,
>> +						0, curr_vreg->max_voltage);
>> +				}
>> +				regulator_put(curr_vreg->vreg);
>> +				curr_vreg->vreg = NULL;
>> +			}
>> +		}
>> +	}
>> +	return 0;
>> +
>> +vreg_unconfig:
>> +if (type == DSS_REG_LDO)
>> +	regulator_set_load(curr_vreg->vreg, 0);
>> +
>> +vreg_set_voltage_fail:
>> +	regulator_put(curr_vreg->vreg);
>> +	curr_vreg->vreg = NULL;
>> +
>> +vreg_get_fail:
>> +	for (i--; i >= 0; i--) {
>> +		curr_vreg = &in_vreg[i];
>> +		type = (regulator_count_voltages(curr_vreg->vreg) > 0)
>> +			? DSS_REG_LDO : DSS_REG_VS;
>> +		goto vreg_unconfig;
>> +	}
>> +	return rc;
>> +} /* msm_dss_config_vreg */
>> +
>> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg, int 
>> enable)
>> +{
>> +	int i = 0, rc = 0;
>> +	bool need_sleep;
>> +
>> +	if (enable) {
>> +		for (i = 0; i < num_vreg; i++) {
>> +			rc = PTR_RET(in_vreg[i].vreg);
>> +			if (rc) {
>> +				DEV_ERR("%pS->%s: %s regulator error. rc=%d\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name, rc);
>> +				goto vreg_set_opt_mode_fail;
>> +			}
>> +			need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
>> +			if (in_vreg[i].pre_on_sleep && need_sleep)
>> +				usleep_range(in_vreg[i].pre_on_sleep * 1000,
>> +					in_vreg[i].pre_on_sleep * 1000);
>> +			rc = regulator_set_load(in_vreg[i].vreg,
>> +				in_vreg[i].enable_load);
>> +			if (rc < 0) {
>> +				DEV_ERR("%pS->%s: %s set opt m fail\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name);
>> +				goto vreg_set_opt_mode_fail;
>> +			}
>> +			rc = regulator_enable(in_vreg[i].vreg);
>> +			if (in_vreg[i].post_on_sleep && need_sleep)
>> +				usleep_range(in_vreg[i].post_on_sleep * 1000,
>> +					in_vreg[i].post_on_sleep * 1000);
>> +			if (rc < 0) {
>> +				DEV_ERR("%pS->%s: %s enable failed\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name);
>> +				goto disable_vreg;
>> +			}
>> +		}
>> +	} else {
>> +		for (i = num_vreg-1; i >= 0; i--) {
>> +			if (in_vreg[i].pre_off_sleep)
>> +				usleep_range(in_vreg[i].pre_off_sleep * 1000,
>> +					in_vreg[i].pre_off_sleep * 1000);
>> +			regulator_set_load(in_vreg[i].vreg,
>> +				in_vreg[i].disable_load);
>> +			regulator_disable(in_vreg[i].vreg);
>> +			if (in_vreg[i].post_off_sleep)
>> +				usleep_range(in_vreg[i].post_off_sleep * 1000,
>> +					in_vreg[i].post_off_sleep * 1000);
>> +		}
>> +	}
>> +	return rc;
>> +
>> +disable_vreg:
>> +	regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
>> +
>> +vreg_set_opt_mode_fail:
>> +	for (i--; i >= 0; i--) {
>> +		if (in_vreg[i].pre_off_sleep)
>> +			usleep_range(in_vreg[i].pre_off_sleep * 1000,
>> +				in_vreg[i].pre_off_sleep * 1000);
>> +		regulator_set_load(in_vreg[i].vreg,
>> +			in_vreg[i].disable_load);
>> +		regulator_disable(in_vreg[i].vreg);
>> +		if (in_vreg[i].post_off_sleep)
>> +			usleep_range(in_vreg[i].post_off_sleep * 1000,
>> +				in_vreg[i].post_off_sleep * 1000);
>> +	}
>> +
>> +	return rc;
>> +} /* msm_dss_enable_vreg */
>> +
> 
> Same question here, but with dp_power.
> 
>> +
>>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk)
>>  {
>>  	int i;
>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h 
>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> index bc07381..524b394 100644
>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> @@ -15,6 +15,7 @@
>> 
>>  #include <linux/gpio.h>
>>  #include <linux/platform_device.h>
>> +#include <linux/regulator/consumer.h>
>>  #include <linux/types.h>
>> 
>>  #define DEV_DBG(fmt, args...)   pr_debug(fmt, ##args)
>> @@ -22,6 +23,39 @@
>>  #define DEV_WARN(fmt, args...)  pr_warn(fmt, ##args)
>>  #define DEV_ERR(fmt, args...)   pr_err(fmt, ##args)
>> 
>> +struct dss_io_data {
>> +	u32 len;
>> +	void __iomem *base;
>> +};
> 
> len isn't used anywhere, so this struct can go away. If the struct goes 
> away,
> you can really simplify (or eliminate msm_dss_ioremap_byname())
> 
>> +
>> +/*
>> +void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 
>> debug);
>> +u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug);
>> +void dss_reg_dump(void __iomem *base, u32 len, const char *prefix, 
>> u32 debug);
>> +
>> +#define DSS_REG_W_ND(io, offset, val)  dss_reg_w(io, offset, val, 
>> false)
>> +#define DSS_REG_W(io, offset, val)     dss_reg_w(io, offset, val, 
>> true)
>> +#define DSS_REG_R_ND(io, offset)       dss_reg_r(io, offset, false)
>> +#define DSS_REG_R(io, offset)          dss_reg_r(io, offset, true)
>> +*/
> 
> None of the dss_reg_*/DSS_REG_* functions/macros are used. Please 
> remove.
> 
> 
>> +enum dss_vreg_type {
>> +	DSS_REG_LDO,
>> +	DSS_REG_VS,
>> +};
> 
> These are only used in msm_dss_config_vreg(). Please remove.
> 
>> +
>> +struct dss_vreg {
>> +	struct regulator *vreg; /* vreg handle */
>> +	char vreg_name[32];
>> +	int min_voltage;
>> +	int max_voltage;
> 
> Can't we deduce these from the regulator subsystem with
> regulator_list_voltage()?
> 
>> +	int enable_load;
>> +	int disable_load;
> 
> These are really a function of the dp device than the regulator.
> 
>> +	int pre_on_sleep;
>> +	int post_on_sleep;
>> +	int pre_off_sleep;
>> +	int post_off_sleep;
> 
> None of these sleep values are set? Also, shouldn't these constraints 
> usually
> expressed/acted upon in the regulator driver?
> 
>> +};
> 
> So if we can remove all of the extra goop around the regulator, then we 
> can get
> rid of dss_vreg.
> 
>> +
>>  struct dss_gpio {
>>  	unsigned int gpio;
>>  	unsigned int value;
>> @@ -42,12 +76,22 @@ struct dss_clk {
>>  };
>> 
>>  struct dss_module_power {
>> +	unsigned int num_vreg;
>> +	struct dss_vreg *vreg_config;
>>  	unsigned int num_gpio;
>>  	struct dss_gpio *gpio_config;
>>  	unsigned int num_clk;
>>  	struct dss_clk *clk_config;
>>  };
>> 
>> +int msm_dss_ioremap_byname(struct platform_device *pdev,
>> +			   struct dss_io_data *io_data, const char *name);
>> +void msm_dss_iounmap(struct dss_io_data *io_data);
>> +
>> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
>> +			int num_vreg, int config);
>> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg,	int 
>> enable);
>> +
>>  int msm_dss_get_clk(struct device *dev, struct dss_clk *clk_arry, int 
>> num_clk);
>>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk);
> 
> 
> Why are these msm_dss* functions in dpu_io_util.h?
> 
>>  int msm_dss_clk_set_rate(struct dss_clk *clk_arry, int num_clk);
>> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c 
>> b/drivers/gpu/drm/msm/dp/dp_aux.c
>> new file mode 100644
>> index 0000000..00b82c2
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_aux.c
>> @@ -0,0 +1,570 @@
> 
> /snip
> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h 
>> b/drivers/gpu/drm/msm/dp/dp_aux.h
>> new file mode 100644
>> index 0000000..0c300ed
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_aux.h
> 
> /snip
> 
> I didn't really review the dp_aux.* files as-is. Please convert to 
> using
> drm_dp_aux and I'll take another look.
> 

Please correct me if I am wrong. Looks like you are suggesting to use 
most of the drm_dp_aux struct variable
instead of what we have defined locally.

> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c 
>> b/drivers/gpu/drm/msm/dp/dp_catalog.c
>> new file mode 100644
>> index 0000000..5818612
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
>> @@ -0,0 +1,1188 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/delay.h>
>> +#include <drm/drm_dp_helper.h>
>> +
>> +#include "dp_catalog.h"
>> +#include "dp_reg.h"
>> +
>> +#define DP_GET_MSB(x)	(x >> 8)
>> +#define DP_GET_LSB(x)	(x & 0xff)
> 
> These aren't used anywhere
> 
>> +
>> +#define dp_read(offset) readl_relaxed((offset))
>> +#define dp_write(offset, data) writel_relaxed((data), (offset))
> 
> These macros aren't useful. I think you'd be much better having a 
> read_/write_
> for the different io types, ie:
> 
> static inline u32 dp_read_audio(struct dp_catalog *catalog, u32 offset)
> {
>         return readl_relaxed(catalog->io->dp_link.base + offset);
> }
> 
> Then you can remove a ton of boilerplate code below getting base;
> 
>> +
>> +#define dp_catalog_get_priv(x) { \
> 
> static inline struct dp_catalog_private *dp_catalog_get_priv(...)
> {
>         ...
> }
> 
>> +	struct dp_catalog *dp_catalog; \
>> +	dp_catalog = container_of(x, struct dp_catalog, x); \
>> +	catalog = container_of(dp_catalog, struct dp_catalog_private, \
>> +				dp_catalog); \
>> +}
>> +
>> +#define DP_INTERRUPT_STATUS1 \
>> +	(DP_INTR_AUX_I2C_DONE| \
>> +	DP_INTR_WRONG_ADDR | DP_INTR_TIMEOUT | \
>> +	DP_INTR_NACK_DEFER | DP_INTR_WRONG_DATA_CNT | \
>> +	DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER | \
>> +	DP_INTR_PLL_UNLOCKED | DP_INTR_AUX_ERROR)
>> +
>> +#define DP_INTR_MASK1		(DP_INTERRUPT_STATUS1 << 2)
>> +
>> +#define DP_INTERRUPT_STATUS2 \
>> +	(DP_INTR_READY_FOR_VIDEO | DP_INTR_IDLE_PATTERN_SENT | \
>> +	DP_INTR_FRAME_END | DP_INTR_CRC_UPDATED)
>> +
>> +#define DP_INTR_MASK2		(DP_INTERRUPT_STATUS2 << 2)
> 
> Can you please rename these to be consistent with each other?
> DP_INTERRUPT_STATUS2_MASK perhaps?
> 
>> +
>> +static u8 const vm_pre_emphasis[4][4] = {
>> +	{0x00, 0x0B, 0x12, 0xFF},       /* pe0, 0 db */
>> +	{0x00, 0x0A, 0x12, 0xFF},       /* pe1, 3.5 db */
>> +	{0x00, 0x0C, 0xFF, 0xFF},       /* pe2, 6.0 db */
>> +	{0xFF, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
>> +};
>> +
>> +/* voltage swing, 0.2v and 1.0v are not support */
>> +static u8 const vm_voltage_swing[4][4] = {
>> +	{0x07, 0x0F, 0x14, 0xFF}, /* sw0, 0.4v  */
>> +	{0x11, 0x1D, 0x1F, 0xFF}, /* sw1, 0.6 v */
>> +	{0x18, 0x1F, 0xFF, 0xFF}, /* sw1, 0.8 v */
>> +	{0xFF, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
>> +};
>> +
>> +/* audio related catalog functions */
>> +struct dp_catalog_private {
>> +	struct device *dev;
>> +	struct dp_io *io;
>> +
>> +	u32 (*audio_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	struct dp_catalog dp_catalog;
>> +};
>> +
>> +/* aux related catalog functions */
>> +static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
> 
> And another logging type, please remove pr_* and use a 
> DPU_/DRM_/DRM_DEV_
> variant.
> 
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	return dp_read(base + DP_AUX_DATA);
>> +end:
>> +	return 0;
> 
> ... or you could just return directly in the if above and remove the 
> label :)
> Same comment applies below.
> 
> Also, probably shouldn't return 0 in an error case.
> 
> Then again, I'm guessing hitting the NULL case is likely impossible, so 
> you can
> probably remove all of the machinery around checking !aux.
> 
>> +}
>> +
>> +static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	dp_write(base + DP_AUX_DATA, aux->data);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	dp_write(base + DP_AUX_TRANS_CTRL, aux->data);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, 
>> bool read)
>> +{
>> +	int rc = 0;
>> +	u32 data = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	if (read) {
>> +		data = dp_read(base + DP_AUX_TRANS_CTRL);
>> +		data &= ~BIT(9);
>> +		dp_write(base + DP_AUX_TRANS_CTRL, data);
>> +	} else {
>> +		dp_write(base + DP_AUX_TRANS_CTRL, 0);
>> +	}
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
>> +{
>> +	u32 aux_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
>> +
>> +	aux_ctrl |= BIT(1);
> 
> What's BIT(1)? Can you please #define it?
> 
>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> 10us diff is right on the line of enough delay to make usleep_range 
> worth it.
> I'd recommend increasing to 100us to increase the chance of the 
> scheduler being
> able to batch this wakeup with another.
> 
>> +
>> +	aux_ctrl &= ~BIT(1);
>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +	wmb();
> 
> Can you just use writel for these cases instead of using _relaxed and 
> then
> wmb()? This applies elsewhere too.
> 
>> +}
>> +
>> +static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool 
>> enable)
>> +{
>> +	u32 aux_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_TIMEOUT_COUNT, 0xffff);
>> +		dp_write(base + DP_AUX_LIMITS, 0xffff);
>> +		aux_ctrl |= BIT(0);
> 
> Please #define BIT(0)
> 
>> +	} else {
>> +		aux_ctrl &= ~BIT(0);
>> +	}
>> +
>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +}
>> +
>> +static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 new_index = 0, current_index = 0;
>> +
>> +	if (!aux || !cfg || (type >= PHY_AUX_CFG_MAX)) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +
>> +	current_index = cfg[type].current_index;
>> +	new_index = (current_index + 1) % cfg[type].cfg_cnt;
>> +	pr_debug("Updating %s from 0x%08x to 0x%08x\n",
>> +		dp_phy_aux_config_type_to_string(type),
>> +	cfg[type].lut[current_index], cfg[type].lut[new_index]);
>> +
>> +	dp_write(catalog->io->phy_io.base + cfg[type].offset,
>> +			cfg[type].lut[new_index]);
>> +	cfg[type].current_index = new_index;
>> +}
>> +
>> +static void dp_catalog_aux_setup(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	int i = 0;
>> +
>> +	if (!aux || !cfg) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_PD_CTL, 0x65);
> 
> What's 0x65? Please #define
> 
>> +	wmb(); /* make sure PD programming happened */
>> +
>> +	/* Turn on BIAS current for PHY/PLL */
>> +	dp_write(catalog->io->dp_pll_io.base +
>> +		QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x1b);
> 
> Same here for 0x1b. I'm going to stop mentioning this, please audit the 
> driver
> for other instances of hardcoded values (like this and the one at the 
> end of
> this function) and break them out into meaningful #defines.
> 
>> +
>> +	/* DP AUX CFG register programming */
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
>> +		pr_debug("%s: offset=0x%08x, value=0x%08x\n",
>> +			dp_phy_aux_config_type_to_string(i),
>> +			cfg[i].offset, cfg[i].lut[cfg[i].current_index]);
>> +		dp_write(catalog->io->phy_io.base + cfg[i].offset,
>> +			cfg[i].lut[cfg[i].current_index]);
>> +	}
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_AUX_INTERRUPT_MASK, 
>> 0x1F);
>> +}
>> +
>> +static void dp_catalog_aux_get_irq(struct dp_catalog_aux *aux, bool 
>> cmd_busy)
>> +{
>> +	u32 ack;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *ahb_base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	ahb_base = catalog->io->dp_ahb.base;
>> +
>> +	aux->isr = dp_read(ahb_base + DP_INTR_STATUS);
>> +	aux->isr &= ~DP_INTR_MASK1;
>> +	ack = aux->isr & DP_INTERRUPT_STATUS1;
>> +	ack <<= 1;
>> +	ack |= DP_INTR_MASK1;
>> +	dp_write(ahb_base + DP_INTR_STATUS, ack);
>> +}
>> +
>> +/* controller related catalog functions */
>> +static void dp_catalog_ctrl_update_transfer_unit(struct 
>> dp_catalog_ctrl *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_VALID_BOUNDARY, ctrl->valid_boundary);
>> +	dp_write(base + DP_TU, ctrl->dp_tu);
>> +	dp_write(base + DP_VALID_BOUNDARY_2, ctrl->valid_boundary2);
>> +}
>> +
>> +static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, 
>> u32 state)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_STATE_CTRL, state);
>> +}
>> +
>> +static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, 
>> u32 cfg)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *link_base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	link_base = catalog->io->dp_link.base;
>> +
>> +	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
>> +
>> +	dp_write(link_base + DP_CONFIGURATION_CTRL, cfg);
>> +}
>> +
>> +static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_LOGICAL2PHYSICAL_LANE_MAPPING, 0xe4);
>> +}
>> +
>> +static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl 
>> *ctrl,
>> +						bool enable)
>> +{
>> +	u32 mainlink_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
>> +		wmb(); /* make sure mainlink is turned off before reset */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000002);
>> +		wmb(); /* make sure mainlink entered reset */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
>> +		wmb(); /* make sure mainlink reset done */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000001);
>> +		wmb(); /* make sure mainlink turned on */
> 
> Same comments here re: readl vs readl_relaxed + wmb
> 
> Please #define the bits you're setting.
> 
> 
>> +	} else {
>> +		mainlink_ctrl = dp_read(base + DP_MAINLINK_CTRL);
>> +		mainlink_ctrl &= ~BIT(0);
>> +		dp_write(base + DP_MAINLINK_CTRL, mainlink_ctrl);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_config_misc(struct dp_catalog_ctrl *ctrl,
>> +					u32 cc, u32 tb)
>> +{
>> +	u32 misc_val;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	misc_val = dp_read(base + DP_MISC1_MISC0);
>> +	misc_val |= cc;
> 
> Should you mask this so it doesn't stomp areas it shouldn't?
> 
>> +	misc_val |= (tb << 5);
> 
> Parentheses are unnecessary
> 
>> +	misc_val |= BIT(0); /* Configure clock to synchronous mode */
>> +
>> +	pr_debug("misc settings = 0x%x\n", misc_val);
>> +	dp_write(base + DP_MISC1_MISC0, misc_val);
>> +}
>> +
>> +static void dp_catalog_ctrl_config_msa(struct dp_catalog_ctrl *ctrl,
>> +					u32 rate, u32 stream_rate_khz,
>> +					bool fixed_nvid)
>> +{
>> +	u32 pixel_m, pixel_n;
>> +	u32 mvid, nvid;
>> +	u64 mvid_calc;
>> +	u32 const nvid_fixed = 0x8000;
> 
> You should pull this out into a #define in drm_dp_helper.h and use the 
> new
> define in the i915 driver (in a separate patch) as well as here.
> 
>> +	u32 const link_rate_hbr2 = 540000;
>> +	u32 const link_rate_hbr3 = 810000;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base_cc, *base_ctrl;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	if (fixed_nvid) {
>> +		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
>> +		nvid = nvid_fixed;
>> +
>> +		pr_debug("link rate=%dkbps, stream_rate_khz=%uKhz",
>> +			rate, stream_rate_khz);
>> +
>> +		/*
>> +		 * For intermediate results, use 64 bit arithmetic to avoid
>> +		 * loss of precision.
>> +		 */
>> +		mvid_calc = (u64) stream_rate_khz * nvid;
>> +		mvid_calc = div_u64(mvid_calc, rate);
>> +
>> +		/*
>> +		 * truncate back to 32 bits as this final divided value will
>> +		 * always be within the range of a 32 bit unsigned int.
>> +		 */
>> +		mvid = (u32) mvid_calc;
>> +	} else {
>> +		base_cc = catalog->io->dp_cc_io.base;
>> +
>> +		pixel_m = dp_read(base_cc + MMSS_DP_PIXEL_M);
>> +		pixel_n = dp_read(base_cc + MMSS_DP_PIXEL_N);
>> +		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
>> +
>> +		mvid = (pixel_m & 0xFFFF) * 5;
>> +		nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
>> +
>> +		pr_debug("rate = %d\n", rate);
>> +
>> +		if (link_rate_hbr2 == rate)
>> +			nvid *= 2;
>> +
>> +		if (link_rate_hbr3 == rate)
>> +			nvid *= 3;
> 
>                 switch (drm_dp_bw_code_to_link_rate(rate)) {
>                 case DP_LINK_BW_5_4:
>                         nvid *= 2;
>                         break;
>                 case DP_LINK_BW_8_1:
>                         nvid *= 3;
>                         break;
>                 default:
>                         break;
>                 }
> 
> And remove link_rate_hbr* above.
> 
> 
>> +	}
>> +
>> +	base_ctrl = catalog->io->dp_link.base;
>> +	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
>> +	dp_write(base_ctrl + DP_SOFTWARE_MVID, mvid);
>> +	dp_write(base_ctrl + DP_SOFTWARE_NVID, nvid);
>> +}
>> +
>> +static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
>> +					u32 pattern)
>> +{
>> +	int bit, cnt = 10;
>> +	u32 data;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	bit = 1;
>> +	bit <<= (pattern - 1);
> 
>         bit = BIT(pattern - 1);
> 
>> +	pr_debug("hw: bit=%d train=%d\n", bit, pattern);
>> +	dp_write(base + DP_STATE_CTRL, bit);
>> +
>> +	bit = 8;
>> +	bit <<= (pattern - 1);
> 
>         bit = BIT(pattern - 1) << 3;
>> +
>> +	while (cnt--) {
>> +		data = dp_read(base + DP_MAINLINK_READY);
>> +		if (data & bit)
>> +			break;
> 
> Should there be a sleep in here? Also, consider using 
> readx_poll_timeout instead
> of rolling your own polling.
> 
>> +	}
>> +
>> +	if (cnt == 0)
>> +		pr_err("set link_train=%d failed\n", pattern);
> 
> This function should return an int and report this failure instead of 
> ignoring
> it.
> 
>> +}
>> +
>> +static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, 
>> bool flip)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->usb3_dp_com.base;
>> +
>> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x0a);
> 
> Again, all of these magic values need to be pulled out into #defines so 
> we know
> what the values mean.
> 
>> +	dp_write(base + USB3_DP_COM_PHY_MODE_CTRL, 0x02);
>> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x01);
>> +	/* make sure usb3 com phy software reset is done */
>> +	wmb();
> 
> Same comments here wrt wmb()
> 
>> +
>> +	if (!flip) /* CC1 */
>> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x02);
>> +	else /* CC2 */
>> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x03);
> 
> 
>         u32 val;
>         ...
>         val = SOME_DEFINE_THAT_MAKES_SENSE;
>         if (flip)
>                 val |= ANOTHER_DEFINE_THAT_MEANS_FLIP;
> 
>         dp_io_write(USB3_DP_COM_TYPEC_CTRL, val);
> 
>> +
>> +	dp_write(base + USB3_DP_COM_SWI_CTRL, 0x00);
>> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x00);
>> +	/* make sure the software reset is done */
>> +	wmb();
>> +
>> +	dp_write(base + USB3_DP_COM_POWER_DOWN_CTRL, 0x01);
>> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x00);
>> +	/* make sure phy is brought out of reset */
>> +	wmb();
>> +
>> +}
>> +
>> +static void dp_catalog_panel_tpg_cfg(struct dp_catalog_panel *panel,
>> +	bool enable)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(panel);
>> +	base = catalog->io->dp_p0.base;
>> +
>> +	if (!enable) {
>> +		dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x0);
>> +		dp_write(base + MMSS_DP_BIST_ENABLE, 0x0);
>> +		dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x0);
>> +		wmb(); /* ensure Timing generator is turned off */
>> +		return;
>> +	}
> 
> There's really no reason to have both the enable + disable path in the 
> same
> function, they don't share any code (aside from writing a few different 
> values
> to the same registers). Could you please split this function into a
> timing_generator_disable and timing_generator_enable?
> 
>> +
>> +	dp_write(base + MMSS_DP_INTF_CONFIG, 0x0);
>> +	dp_write(base + MMSS_DP_INTF_HSYNC_CTL, panel->hsync_ctl);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F0, panel->vsync_period *
>> +			panel->hsync_period);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0, 
>> panel->v_sync_width *
>> +			panel->hsync_period);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_HCTL, panel->display_hctl);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_HCTL, 0);
>> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F0, 
>> panel->display_v_start);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F0, 
>> panel->display_v_end);
>> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F0, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F0, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_POLARITY_CTL, 0);
>> +	wmb(); /* ensure TPG registers are programmed */
>> +
>> +	dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x100);
>> +	dp_write(base + MMSS_DP_TPG_VIDEO_CONFIG, 0x5);
>> +	wmb(); /* ensure TPG config is programmed */
>> +	dp_write(base + MMSS_DP_BIST_ENABLE, 0x1);
>> +	dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x1);
>> +	wmb(); /* ensure Timing generator is turned on */
>> +	pr_debug("%s: enabled tpg\n", __func__);
>> +}
>> +
>> +static void dp_catalog_ctrl_reset(struct dp_catalog_ctrl *ctrl)
>> +{
>> +	u32 sw_reset;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	sw_reset = dp_read(base + DP_SW_RESET);
>> +
>> +	sw_reset |= BIT(0);
> 
> Should be a #define
> 
>> +	dp_write(base + DP_SW_RESET, sw_reset);
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> Same comment here regarding the 10us range
> 
>> +
>> +	sw_reset &= ~BIT(0);
>> +	dp_write(base + DP_SW_RESET, sw_reset);
>> +}
>> +
>> +static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	u32 data;
>> +	int cnt = 10;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	while (--cnt) {
>> +		/* DP_MAINLINK_READY */
>> +		data = dp_read(base + DP_MAINLINK_READY);
>> +		if (data & BIT(0))
>> +			return true;
>> +
>> +		usleep_range(1000, 1010); /* 1ms wait before next reg read */
> 
> Same comment here regarding using readx_poll_timeout wrapped in a 
> helper, also
> 10us comment.
> 
>> +	}
>> +	pr_err("mainlink not ready\n");
>> +end:
>> +	return false;
>> +}
>> +
>> +static void dp_catalog_ctrl_enable_irq(struct dp_catalog_ctrl *ctrl,
>> +						bool enable)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_INTR_STATUS, DP_INTR_MASK1);
>> +		dp_write(base + DP_INTR_STATUS2, DP_INTR_MASK2);
>> +	} else {
>> +		dp_write(base + DP_INTR_STATUS, 0x00);
>> +		dp_write(base + DP_INTR_STATUS2, 0x00);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_hpd_config(struct dp_catalog_ctrl *ctrl, 
>> bool en)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	if (en) {
>> +		u32 reftimer = dp_read(base + DP_DP_HPD_REFTIMER);
>> +
>> +		dp_write(base + DP_DP_HPD_INT_ACK, 0xF);
>> +		dp_write(base + DP_DP_HPD_INT_MASK, 0xF);
>> +
>> +		/* Enabling REFTIMER */
>> +		reftimer |= BIT(16);
> 
> You don't use this anywhere?
> 
>> +		dp_write(base + DP_DP_HPD_REFTIMER, 0xF);
>> +		/* Enable HPD */
>> +		dp_write(base + DP_DP_HPD_CTRL, 0x1);
>> +	} else {
>> +		/*Disable HPD */
> 
> Space after *
> 
>> +		dp_write(base + DP_DP_HPD_CTRL, 0x0);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_get_interrupt(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	u32 ack = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	ctrl->isr = dp_read(base + DP_INTR_STATUS2);
> 
> This value should just get returned instead of being stored.
> 
>> +	ctrl->isr &= ~DP_INTR_MASK2;
> 
> Unmasking the interrupts should not be returned from this function, it 
> should
> be part of the ack below.
> 
>> +	ack = ctrl->isr & DP_INTERRUPT_STATUS2;
> 
> And this does the above unmask already, so you can just turf it.
> 
>> +	ack <<= 1;
>> +	ack |= DP_INTR_MASK2;
> 
> Instead of rolling the ack code yourself, I'd prefer what you did with 
> _MASK,
> where you define DP_INTERRUPT_STATUS2_ACK above and just do a 
> bitwise-OR to add
> the acks here. Without the register map in front of me, it would take a 
> while
> to figure out what you're trying to accomplish.
> 
>> +	dp_write(base + DP_INTR_STATUS2, ack);
>> +}
>> +
>> +static void dp_catalog_ctrl_phy_reset(struct dp_catalog_ctrl *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	dp_write(base + DP_PHY_CTRL, 0x5); /* bit 0 & 2 */
> 
> The comment doesn't help here, please #define these bits
> 
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> Same comment re: delay range
> 
>> +	dp_write(base + DP_PHY_CTRL, 0x0);
>> +	wmb(); /* make sure PHY reset done */
> 
> Same comment re: wmb
> 
>> +}
>> +
>> +static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl 
>> *ctrl,
>> +		bool flipped, u8 ln_cnt)
>> +{
>> +	u32 info = 0x0;
>> +	struct dp_catalog_private *catalog;
>> +	u8 orientation = BIT(!!flipped);
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	info |= (ln_cnt & 0x0F);
> 
> Remove the | and just make this an assignment (and you can remove the
> initialization to 0 above)
> 
>> +	info |= ((orientation & 0x0F) << 4);
>> +	pr_debug("Shared Info = 0x%x\n", info);
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_SPARE0, info);
>> +}
>> +
>> +static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl 
>> *ctrl,
>> +		u8 v_level, u8 p_level)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base0, *base1;
>> +	u8 value0, value1;
> 
> Can we please pick better names for these?!
> 
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base0 = catalog->io->ln_tx0_io.base;
>> +	base1 = catalog->io->ln_tx1_io.base;
>> +
>> +	pr_debug("hw: v=%d p=%d\n", v_level, p_level);
>> +
>> +	value0 = vm_voltage_swing[v_level][p_level];
>> +	value1 = vm_pre_emphasis[v_level][p_level];
>> +
>> +	/* program default setting first */
> 
> Why do you need to do this?
> 
>> +	dp_write(base0 + TXn_TX_DRV_LVL, 0x2A);
>> +	dp_write(base1 + TXn_TX_DRV_LVL, 0x2A);
>> +	dp_write(base0 + TXn_TX_EMP_POST1_LVL, 0x20);
>> +	dp_write(base1 + TXn_TX_EMP_POST1_LVL, 0x20);
> 
> #define these magic values
> 
>> +
>> +	/* Enable MUX to use Cursor values from these registers */
>> +	value0 |= BIT(5);
>> +	value1 |= BIT(5);
> 
> #define these bits please
> 
>> +
>> +	/* Configure host and panel only if both values are allowed */
>> +	if (value0 != 0xFF && value1 != 0xFF) {
> 
> You can check this a lot earlier in the function.
> 
>> +		dp_write(base0 + TXn_TX_DRV_LVL, value0);
>> +		dp_write(base1 + TXn_TX_DRV_LVL, value0);
>> +		dp_write(base0 + TXn_TX_EMP_POST1_LVL, value1);
>> +		dp_write(base1 + TXn_TX_EMP_POST1_LVL, value1);
>> +
>> +		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
>> +			value0, value1);
>> +	} else {
>> +		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
>> +			v_level, value0, p_level, value1);
> 
> Seems like returning an error in this case would be useful
> 
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl 
>> *ctrl,
>> +			u32 pattern)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 value = 0x0;
>> +	void __iomem *base = NULL;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_STATE_CTRL, 0x0);
> 
> Do you really need to do this?
> 
>> +
>> +	switch (pattern) {
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +		dp_write(base + DP_STATE_CTRL, 0x1);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +		value &= ~(1 << 16);
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		value |= 0xFC;
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
>> +		dp_write(base + DP_STATE_CTRL, 0x10);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +		dp_write(base + DP_STATE_CTRL, 0x20);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +		dp_write(base + DP_STATE_CTRL, 0x40);
>> +		/* 00111110000011111000001111100000 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG0, 0x3E0F83E0);
>> +		/* 00001111100000111110000011111000 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG1, 0x0F83E0F8);
>> +		/* 1111100000111110 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG2, 0x0000F83E);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		value = BIT(16);
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		value |= 0xFC;
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
>> +		dp_write(base + DP_STATE_CTRL, 0x10);
> 
> This code is the exact same as the case for
> DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT, aside from BIT(16) vs
> ~BIT(16). Can you please combine these cases
> and share code?
> 
>> +		break;
>> +	default:
>> +		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
>> +		return;
>> +	}
> 
> All of the DP_STATE_CTRL values should be #defined, and you can move 
> the write
> down here instead of duplicating it everywhere (with
> DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN writing a 0).
> 
>> +
>> +	/* Make sure the test pattern is programmed in the hardware */
>> +	wmb();
>> +}
>> +
>> +static u32 dp_catalog_ctrl_read_phy_pattern(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base = NULL;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->dp_link.base;
>> +
>> +	return dp_read(base + DP_MAINLINK_READY);
>> +}
>> +
>> +/* panel related catalog functions */
>> +static int dp_catalog_panel_timing_cfg(struct dp_catalog_panel 
>> *panel)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(panel);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_TOTAL_HOR_VER, panel->total);
>> +	dp_write(base + DP_START_HOR_VER_FROM_SYNC, panel->sync_start);
>> +	dp_write(base + DP_HSYNC_VSYNC_WIDTH_POLARITY, 
>> panel->width_blanking);
>> +	dp_write(base + DP_ACTIVE_HOR_VER, panel->dp_active);
>> +end:
> 
> useless label, but it'll probably go away when you strip out all of the
> unnecessary NULL checks from the driver.
> 
>> +	return 0;
>> +}
>> +
>> +static void dp_catalog_audio_init(struct dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	static u32 sdp_map[][DP_AUDIO_SDP_HEADER_MAX] = {
>> +		{
>> +			MMSS_DP_AUDIO_STREAM_0,
>> +			MMSS_DP_AUDIO_STREAM_1,
>> +			MMSS_DP_AUDIO_STREAM_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_TIMESTAMP_0,
>> +			MMSS_DP_AUDIO_TIMESTAMP_1,
>> +			MMSS_DP_AUDIO_TIMESTAMP_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_INFOFRAME_0,
>> +			MMSS_DP_AUDIO_INFOFRAME_1,
>> +			MMSS_DP_AUDIO_INFOFRAME_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_0,
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_ISRC_0,
>> +			MMSS_DP_AUDIO_ISRC_1,
>> +			MMSS_DP_AUDIO_ISRC_1,
>> +		},
>> +	};
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	catalog->audio_map = sdp_map;
> 
> Hmm, this is a bit spooky, we're storing a (non-const) pointer to a 
> static
> stack variable. Fortunately this looks like it'll be easy to fix since 
> this
> data is only accessed in this file. So move the map into a static const 
> global
> and reference it directly when needed (and drop audio_map).
> 
>> +}
>> +
>> +static void dp_catalog_audio_config_sdp(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 sdp_cfg = 0;
>> +	u32 sdp_cfg2 = 0;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	sdp_cfg = dp_read(base + MMSS_DP_SDP_CFG);
>> +
>> +	/* AUDIO_TIMESTAMP_SDP_EN */
>> +	sdp_cfg |= BIT(1);
>> +	/* AUDIO_STREAM_SDP_EN */
>> +	sdp_cfg |= BIT(2);
>> +	/* AUDIO_COPY_MANAGEMENT_SDP_EN */
>> +	sdp_cfg |= BIT(5);
>> +	/* AUDIO_ISRC_SDP_EN  */
>> +	sdp_cfg |= BIT(6);
>> +	/* AUDIO_INFOFRAME_SDP_EN  */
>> +	sdp_cfg |= BIT(20);
> 
> #define the values and combine the assignment
> 
>> +
>> +	pr_debug("sdp_cfg = 0x%x\n", sdp_cfg);
>> +	dp_write(base + MMSS_DP_SDP_CFG, sdp_cfg);
>> +
>> +	sdp_cfg2 = dp_read(base + MMSS_DP_SDP_CFG2);
>> +	/* IFRM_REGSRC -> Do not use reg values */
>> +	sdp_cfg2 &= ~BIT(0);
>> +	/* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
>> +	sdp_cfg2 &= ~BIT(1);
> 
> The reset value of this register is 0x4, so how can the bits in 
> position 0/1
> get flipped? We shouldn't need this code, afaict.
> 
> If we do, the same comments regarding #define and combination as above.
> 
>> +
>> +	pr_debug("sdp_cfg2 = 0x%x\n", sdp_cfg2);
>> +	dp_write(base + MMSS_DP_SDP_CFG2, sdp_cfg2);
>> +}
>> +
>> +static void dp_catalog_audio_get_header(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	void __iomem *base;
>> +	enum dp_catalog_audio_sdp_type sdp;
>> +	enum dp_catalog_audio_header_type header;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base    = catalog->io->dp_link.base;
>> +	sdp_map = catalog->audio_map;
>> +	sdp     = audio->sdp_type;
>> +	header  = audio->sdp_header;
>> +
>> +	audio->data = dp_read(base + sdp_map[sdp][header]);
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +static void dp_catalog_audio_set_header(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	void __iomem *base;
>> +	enum dp_catalog_audio_sdp_type sdp;
>> +	enum dp_catalog_audio_header_type header;
>> +	u32 data;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base    = catalog->io->dp_link.base;
>> +	sdp_map = catalog->audio_map;
>> +	sdp     = audio->sdp_type;
>> +	header  = audio->sdp_header;
>> +	data    = audio->data;
>> +
>> +	dp_write(base + sdp_map[sdp][header], data);
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +static void dp_catalog_audio_config_acr(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 acr_ctrl, select;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	select = audio->data;
>> +	base   = catalog->io->dp_link.base;
>> +
>> +	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
>> +
>> +	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
>> +
>> +	dp_write(base + MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +static void dp_catalog_audio_safe_to_exit_level(struct 
>> dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 mainlink_levels, safe_to_exit_level;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base   = catalog->io->dp_link.base;
>> +	safe_to_exit_level = audio->data;
>> +
>> +	mainlink_levels = dp_read(base + DP_MAINLINK_LEVELS);
>> +	mainlink_levels &= 0xFE0;
>> +	mainlink_levels |= safe_to_exit_level;
>> +
>> +	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
>> +			mainlink_levels, safe_to_exit_level);
>> +
>> +	dp_write(base + DP_MAINLINK_LEVELS, mainlink_levels);
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	bool enable;
>> +	u32 audio_ctrl;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base   = catalog->io->dp_link.base;
>> +	enable = !!audio->data;
>> +
>> +	audio_ctrl = dp_read(base + MMSS_DP_AUDIO_CFG);
>> +
>> +	if (enable)
>> +		audio_ctrl |= BIT(0);
>> +	else
>> +		audio_ctrl &= ~BIT(0);
>> +
>> +	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
>> +	dp_write(base + MMSS_DP_AUDIO_CFG, audio_ctrl);
>> +
>> +	/* make sure audio engine is disabled */
>> +	wmb();
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io 
>> *io)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog *dp_catalog;
>> +	struct dp_catalog_private *catalog;
>> +	struct dp_catalog_aux aux = {
>> +		.read_data     = dp_catalog_aux_read_data,
>> +		.write_data    = dp_catalog_aux_write_data,
>> +		.write_trans   = dp_catalog_aux_write_trans,
>> +		.clear_trans   = dp_catalog_aux_clear_trans,
>> +		.reset         = dp_catalog_aux_reset,
>> +		.update_aux_cfg = dp_catalog_aux_update_cfg,
>> +		.enable        = dp_catalog_aux_enable,
>> +		.setup         = dp_catalog_aux_setup,
>> +		.get_irq       = dp_catalog_aux_get_irq,
> 
> Out of these, it seems like write_trans, clear_trans, update_aux_cfg, 
> setup and
> get_irq are all unused. Please remove them.
> 
> Please also check the other functions to ensure they're used.
> 
>> +	};
>> +	struct dp_catalog_ctrl ctrl = {
>> +		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
>> +		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
>> +		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
>> +		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
>> +		.config_misc    = dp_catalog_ctrl_config_misc,
>> +		.config_msa     = dp_catalog_ctrl_config_msa,
>> +		.set_pattern    = dp_catalog_ctrl_set_pattern,
>> +		.reset          = dp_catalog_ctrl_reset,
>> +		.usb_reset      = dp_catalog_ctrl_usb_reset,
>> +		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
>> +		.enable_irq     = dp_catalog_ctrl_enable_irq,
>> +		.hpd_config     = dp_catalog_ctrl_hpd_config,
>> +		.phy_reset      = dp_catalog_ctrl_phy_reset,
>> +		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
>> +		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
>> +		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
>> +		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
>> +		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
>> +		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,
> 
> So, what's the benefit of adding the catalog abstractions? Do you ever 
> have
> multiple/alternate implementations of a catalog? It doesn't seem like 
> it. You
> should just remove all of the catalog overhead and call the functions 
> directly.

We use catalog abstractions for two different reasons:
1. To support multiple hardware since these implementations are hardware 
specific.
2. To virtualize DP hardware.

Our internal hardware already supports multiple chips. We want to keep 
these abstractions to
make the code consistent between upstream and internal implementation.

> 
>> +	};
>> +	struct dp_catalog_audio audio = {
>> +		.init       = dp_catalog_audio_init,
>> +		.config_acr = dp_catalog_audio_config_acr,
>> +		.enable     = dp_catalog_audio_enable,
>> +		.config_sdp = dp_catalog_audio_config_sdp,
>> +		.set_header = dp_catalog_audio_set_header,
>> +		.get_header = dp_catalog_audio_get_header,
>> +		.safe_to_exit_level = dp_catalog_audio_safe_to_exit_level,
>> +	};
>> +	struct dp_catalog_panel panel = {
>> +		.timing_cfg = dp_catalog_panel_timing_cfg,
>> +		.tpg_config = dp_catalog_panel_tpg_cfg,
>> +	};
>> +
>> +	if (!io) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	catalog  = devm_kzalloc(dev, sizeof(*catalog), GFP_KERNEL);
>> +	if (!catalog) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	catalog->dev = dev;
>> +	catalog->io = io;
>> +
>> +	dp_catalog = &catalog->dp_catalog;
>> +
>> +	dp_catalog->aux   = aux;
>> +	dp_catalog->ctrl  = ctrl;
>> +	dp_catalog->audio = audio;
>> +	dp_catalog->panel = panel;
>> +
>> +	return dp_catalog;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_catalog_put(struct dp_catalog *dp_catalog)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +
>> +	if (!dp_catalog)
>> +		return;
>> +
>> +	catalog = container_of(dp_catalog, struct dp_catalog_private,
>> +				dp_catalog);
>> +
>> +	devm_kfree(catalog->dev, catalog);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h 
>> b/drivers/gpu/drm/msm/dp/dp_catalog.h
>> new file mode 100644
>> index 0000000..58951df
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
>> @@ -0,0 +1,144 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_CATALOG_H_
>> +#define _DP_CATALOG_H_
>> +
>> +#include "dp_parser.h"
>> +
>> +/* interrupts */
>> +#define DP_INTR_HPD		BIT(0)
>> +#define DP_INTR_AUX_I2C_DONE	BIT(3)
>> +#define DP_INTR_WRONG_ADDR	BIT(6)
>> +#define DP_INTR_TIMEOUT		BIT(9)
>> +#define DP_INTR_NACK_DEFER	BIT(12)
>> +#define DP_INTR_WRONG_DATA_CNT	BIT(15)
>> +#define DP_INTR_I2C_NACK	BIT(18)
>> +#define DP_INTR_I2C_DEFER	BIT(21)
>> +#define DP_INTR_PLL_UNLOCKED	BIT(24)
>> +#define DP_INTR_AUX_ERROR	BIT(27)
>> +
>> +#define DP_INTR_READY_FOR_VIDEO		BIT(0)
>> +#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
>> +#define DP_INTR_FRAME_END		BIT(6)
>> +#define DP_INTR_CRC_UPDATED		BIT(9)
>> +
>> +struct dp_catalog_aux {
>> +	u32 data;
>> +	u32 isr;
>> +
>> +	u32 (*read_data)(struct dp_catalog_aux *aux);
>> +	int (*write_data)(struct dp_catalog_aux *aux);
>> +	int (*write_trans)(struct dp_catalog_aux *aux);
>> +	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
>> +	void (*reset)(struct dp_catalog_aux *aux);
>> +	void (*enable)(struct dp_catalog_aux *aux, bool enable);
>> +	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
>> +	void (*setup)(struct dp_catalog_aux *aux,
>> +			struct dp_aux_cfg *aux_cfg);
>> +	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
>> +};
>> +
>> +struct dp_catalog_ctrl {
>> +	u32 dp_tu;
>> +	u32 valid_boundary;
>> +	u32 valid_boundary2;
>> +	u32 isr;
>> +
>> +	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
>> +	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
>> +	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
>> +	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
>> +	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
>> +				u32 stream_rate_khz, bool fixed_nvid);
>> +	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
>> +	void (*reset)(struct dp_catalog_ctrl *ctrl);
>> +	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
>> +	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
>> +	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
>> +	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
>> +				u8 lane_cnt);
>> +	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
>> +				u8 p_level);
>> +	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
>> +	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
>> +	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
>> +			u32 pattern);
>> +	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
>> +};
>> +
>> +enum dp_catalog_audio_sdp_type {
>> +	DP_AUDIO_SDP_STREAM,
>> +	DP_AUDIO_SDP_TIMESTAMP,
>> +	DP_AUDIO_SDP_INFOFRAME,
>> +	DP_AUDIO_SDP_COPYMANAGEMENT,
>> +	DP_AUDIO_SDP_ISRC,
>> +	DP_AUDIO_SDP_MAX,
>> +};
>> +
>> +enum dp_catalog_audio_header_type {
>> +	DP_AUDIO_SDP_HEADER_1,
>> +	DP_AUDIO_SDP_HEADER_2,
>> +	DP_AUDIO_SDP_HEADER_3,
>> +	DP_AUDIO_SDP_HEADER_MAX,
>> +};
>> +
>> +struct dp_catalog_audio {
>> +	enum dp_catalog_audio_sdp_type sdp_type;
>> +	enum dp_catalog_audio_header_type sdp_header;
>> +	u32 data;
>> +
>> +	void (*init)(struct dp_catalog_audio *audio);
>> +	void (*enable)(struct dp_catalog_audio *audio);
>> +	void (*config_acr)(struct dp_catalog_audio *audio);
>> +	void (*config_sdp)(struct dp_catalog_audio *audio);
>> +	void (*set_header)(struct dp_catalog_audio *audio);
>> +	void (*get_header)(struct dp_catalog_audio *audio);
>> +	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);
> 
> None of these are called? So get rid of this entire structure, the 
> functions
> that aren't called, and the audio enums above.
> 
>> +};
>> +
>> +struct dp_catalog_panel {
>> +	u32 total;
>> +	u32 sync_start;
>> +	u32 width_blanking;
>> +	u32 dp_active;
>> +
>> +	/* TPG */
>> +	u32 hsync_period;
>> +	u32 vsync_period;
>> +	u32 display_v_start;
>> +	u32 display_v_end;
>> +	u32 v_sync_width;
>> +	u32 hsync_ctl;
>> +	u32 display_hctl;
> 
> All of this information is already available from drm core, so it can 
> go.
> 
>> +
>> +	int (*timing_cfg)(struct dp_catalog_panel *panel);
>> +	void (*tpg_config)(struct dp_catalog_panel *panel, bool enable);
> 
> As suggested elsewhere, these functions should just be called directly 
> wherever
> applicable. So we can get rid of this struct.
> 
>> +};
>> +
>> +struct dp_catalog {
>> +	struct dp_catalog_aux aux;
>> +	struct dp_catalog_ctrl ctrl;
>> +	struct dp_catalog_audio audio;
>> +	struct dp_catalog_panel panel;
>> +};
>> +
>> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io 
>> *io);
>> +void dp_catalog_put(struct dp_catalog *catalog);
> 
> As mentioned above, all of this should be removed. We can just call the
> functions directly.
> 
>> +
>> +#endif /* _DP_CATALOG_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c 
>> b/drivers/gpu/drm/msm/dp/dp_ctrl.c
>> new file mode 100644
>> index 0000000..08a52f5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
>> @@ -0,0 +1,1475 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/types.h>
>> +#include <linux/completion.h>
>> +#include <linux/delay.h>
>> +
>> +#include "dp_ctrl.h"
>> +
>> +#define DP_KHZ_TO_HZ 1000
>> +
>> +#define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
>> +#define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
>> +
>> +/* dp state ctrl */
>> +#define ST_TRAIN_PATTERN_1		BIT(0)
>> +#define ST_TRAIN_PATTERN_2		BIT(1)
>> +#define ST_TRAIN_PATTERN_3		BIT(2)
>> +#define ST_TRAIN_PATTERN_4		BIT(3)
>> +#define ST_SYMBOL_ERR_RATE_MEASUREMENT	BIT(4)
>> +#define ST_PRBS7			BIT(5)
>> +#define ST_CUSTOM_80_BIT_PATTERN	BIT(6)
>> +#define ST_SEND_VIDEO			BIT(7)
>> +#define ST_PUSH_IDLE			BIT(8)
> 
> I'd like to see these defined with DP_STATE_CTRL (and 
> s/ST/DP_STATE_CTRL/).
> 
>> +
>> +#define MR_LINK_TRAINING1  0x8
>> +#define MR_LINK_SYMBOL_ERM 0x80
>> +#define MR_LINK_PRBS7 0x100
>> +#define MR_LINK_CUSTOM80 0x200
>> +
>> +struct dp_vc_tu_mapping_table {
>> +	u32 vic;
>> +	u8 lanes;
>> +	u8 lrate; /* DP_LINK_RATE -> 162(6), 270(10), 540(20), 810 (30) */
>> +	u8 bpp;
>> +	u8 valid_boundary_link;
>> +	u16 delay_start_link;
>> +	bool boundary_moderation_en;
>> +	u8 valid_lower_boundary_link;
>> +	u8 upper_boundary_count;
>> +	u8 lower_boundary_count;
>> +	u8 tu_size_minus1;
> 
> Please check this struct for unused members, there are at least a 
> couple.
> 
>> +};
>> +
>> +struct dp_ctrl_private {
>> +	struct dp_ctrl dp_ctrl;
>> +
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_panel *panel;
>> +	struct dp_link *link;
>> +	struct dp_power *power;
>> +	struct dp_parser *parser;
>> +	struct dp_catalog_ctrl *catalog;
> 
> Once you remove struct dp_ctrl and call the functions directly, I 
> suspect you
> can get rid of all of these.
> 
>> +
>> +	struct completion idle_comp;
>> +	struct completion video_comp;
>> +
>> +	bool orientation;
>> +	atomic_t aborted;
>> +
>> +	u32 pixel_rate;
>> +	u32 vic;
> 
> 'u32 vic' shows up in 3 places in this driver, but there is not one use 
> of any
> vic :) Please remove from here and elsewhere.
> 
>> +};
>> +
>> +enum notification_status {
>> +	NOTIFY_UNKNOWN,
>> +	NOTIFY_CONNECT,
>> +	NOTIFY_DISCONNECT,
>> +	NOTIFY_CONNECT_IRQ_HPD,
>> +	NOTIFY_DISCONNECT_IRQ_HPD,
>> +};
> 
> Unused, please remove.
> 
>> +
>> +static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
>> +{
>> +	pr_debug("idle_patterns_sent\n");
>> +	complete(&ctrl->idle_comp);
>> +}
>> +
>> +static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
>> +{
>> +	pr_debug("dp_video_ready\n");
>> +	complete(&ctrl->video_comp);
>> +}
> 
> These functions don't provide value, please remove and just call 
> complete()
> directly.
> 
>> +
>> +static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> 
> JFYI, this is sprinkled everywhere, would be a good candidate for an 
> inline
> function. Since dp_ctrl can be removed, it's kind of a moot point now.
> 
>> +
>> +	atomic_set(&ctrl->aborted, 1);
>> +}
>> +
>> +static void dp_ctrl_state_ctrl(struct dp_ctrl_private *ctrl, u32 
>> state)
>> +{
>> +	ctrl->catalog->state_ctrl(ctrl->catalog, state);
> 
> No need to wrap this in a function
> 
>> +}
>> +
>> +static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
>> +{
>> +	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;
> 
> This should be #define'd outside of the functioninstead. Also, why the 
> '_ms_'
> suffix? The units are in jiffies.
> 
> I think something like
> 
> #define IDLE_PATTERN_COMPLETION_TIMEOUT_JIFFIES (30 * HZ / 1000) /* 30 
> ms */
> 
> would be clearer.
> 
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	reinit_completion(&ctrl->idle_comp);
> 
> This function is called from a bunch of places, and idle_comp is also 
> used in a
> bunch of places. Are you certain this is thread-safe if you have 
> concurrent
> callers or users of idle_comp?
> 
>> +	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
>> +
>> +	if (!wait_for_completion_timeout(&ctrl->idle_comp,
>> +			idle_pattern_completion_timeout_ms))
>> +		pr_warn("PUSH_IDLE pattern timedout\n");
> 
> Return an error?
> 
>> +
>> +	pr_debug("mainlink off done\n");
>> +}
>> +
>> +static void dp_ctrl_config_ctrl(struct dp_ctrl_private *ctrl)
>> +{
>> +	u32 config = 0, tbd;
>> +	u8 *dpcd = ctrl->panel->dpcd;
>> +
>> +	config |= (2 << 13); /* Default-> LSCLK DIV: 1/4 LCLK  */
> 
> #define value
> 
>> +	config |= (0 << 11); /* RGB */
> 
> This is a no-op, can be removed
> 
>> +
>> +	/* Scrambler reset enable */
>> +	if (dpcd[DP_EDP_CONFIGURATION_CAP] & 
>> DP_ALTERNATE_SCRAMBLER_RESET_CAP)
>> +		config |= (1 << 10);
>> +
>> +	tbd = ctrl->link->get_test_bits_depth(ctrl->link,
>> +			ctrl->panel->pinfo.bpp);
>> +
>> +	if (tbd == DP_TEST_BIT_DEPTH_UNKNOWN)
> 
> Should we print a debug message here?
> 
>> +		tbd = DP_TEST_BIT_DEPTH_8;
>> +
>> +	config |= tbd << 8;
>> +
>> +	/* Num of Lanes */
>> +	config |= ((ctrl->link->link_params.lane_count - 1) << 4);
> 
> These shift values should be #defined
> 
>> +
>> +	if (drm_dp_enhanced_frame_cap(dpcd))
>> +		config |= 0x40;
> 
> #define 0x40
> 
>> +
>> +	config |= 0x04; /* progressive video */
>> +
>> +	config |= 0x03;	/* sycn clock & static Mvid */
> 
> And these, plus s/sycn/sync/
> 
>> +
>> +	ctrl->catalog->config_ctrl(ctrl->catalog, config);
>> +}
>> +
>> +/**
>> + * dp_ctrl_configure_source_params() - configures DP transmitter 
>> source params
>> + * @ctrl: Display Port Driver data
>> + *
>> + * Configures the DP transmitter source params including details such 
>> as lane
>> + * configuration, output format and sink/panel timing information.
>> + */
>> +static void dp_ctrl_configure_source_params(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	u32 cc, tb;
>> +
>> +	ctrl->catalog->lane_mapping(ctrl->catalog);
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
> 
> We go through ctrl->catalog->callback_hook to call a function that is 
> specific
> to ctrl and only called in this file. It could easily just be a static 
> function
> without having to go through 2 structs and a callback hook.
> 
>> +
>> +	dp_ctrl_config_ctrl(ctrl);
>> +
>> +	tb = ctrl->link->get_test_bits_depth(ctrl->link,
>> +		ctrl->panel->pinfo.bpp);
>> +	cc = ctrl->link->get_colorimetry_config(ctrl->link);
>> +	ctrl->catalog->config_misc(ctrl->catalog, cc, tb);
> 
> Same comments with these hooks, they're only called from this file. 
> I'll stop
> harping on this, but could we please remove the layers of indirection 
> and just
> embed and call functions as appropriate?
> 
>> +	ctrl->panel->timing_cfg(ctrl->panel);
>> +}
>> +
>> +static void dp_ctrl_get_extra_req_bytes(u64 result_valid,
>> +					int valid_bdary_link,
>> +					u64 value1, u64 value2,
>> +					bool *negative, u64 *result,
>> +					u64 compare)
>> +{
>> +	*negative = false;
>> +	if (result_valid >= compare) {
>> +		if (valid_bdary_link
>> +				>= compare)
>> +			*result = value1 + value2;
>> +		else {
>> +			if (value1 < value2)
>> +				*negative = true;
>> +			*result = (value1 >= value2) ?
>> +				(value1 - value2) : (value2 - value1);
>> +		}
>> +	} else {
>> +		if (valid_bdary_link
>> +				>= compare) {
>> +			if (value1 >= value2)
>> +				*negative = true;
>> +			*result = (value1 >= value2) ?
>> +				(value1 - value2) : (value2 - value1);
>> +		} else {
>> +			*result = value1 + value2;
>> +			*negative = true;
>> +		}
>> +	}
> 
> I think this can be simplified to the following, it's still super hard 
> to
> follow, but I'm not sure if that can be helped.
> 
>         bool result_bigger = result_valid >= compare;
>         bool valid_bdary_bigger = valid_bdary_link >= compare;
> 
> 	if (result_bigger && valid_bdary_bigger ||
>             !result_bigger && !valid_bdary_bigger) {
>                 *negative = !valid_bdary_bigger;
>                 return value1 + value2;
>         }
> 
>         *negative = (result_bigger && !valid_bdary_bigger && value1 < 
> value2) ||
>                     (!result_bigger && valid_bdary_bigger && value1 >= 
> value2);
>         return max(value1, value2) - min(value1, value2);
> 
> I don't know. The more I stare at this the less convinced I become that 
> it's
> better. So take it or leave it. At the very least you can collapse the
> 
> if (cond)
>         *negative = true;
> 
> to
> 
> *negative = cond;
> 
> and do the max(v,v) - min(v,v) trick to shave off some of the 
> conditionals in
> the original.
> 
> 
>> +}
>> +
>> +static u64 roundup_u64(u64 x, u64 y)
>> +{
>> +	x += (y - 1);
>> +	return (div64_ul(x, y) * y);
>> +}
> 
> Please replace all usage with DIV_ROUND_UP_ULL
> 
>> +
>> +static u64 rounddown_u64(u64 x, u64 y)
>> +{
>> +	u64 rem;
>> +
>> +	div64_u64_rem(x, y, &rem);
>> +	return (x - rem);
>> +}
> 
> Please replace all usage with DIV_ROUND_DOWN_ULL
> 
>> +
>> +static void dp_ctrl_calc_tu_parameters(struct dp_ctrl_private *ctrl,
>> +				       struct dp_vc_tu_mapping_table *tu_table)
>> +{
>> +	u32 multiplier = 1000000;
>> +	u64 pclk, lclk;
>> +	u8 bpp, ln_cnt;
>> +	int run_idx = 0;
>> +	u32 lwidth, h_blank;
>> +	u32 fifo_empty = 0;
>> +	u32 ratio_scale = 1001;
>> +	u64 temp, ratio, original_ratio;
>> +	u64 temp2, reminder;
>> +	u64 temp3, temp4, result = 0;
>> +
>> +	u64 err = multiplier;
>> +	u64 n_err = 0, n_n_err = 0;
>> +	bool n_err_neg, nn_err_neg;
>> +	u8 hblank_margin = 16;
>> +
>> +	u8 tu_size, tu_size_desired = 0, tu_size_minus1;
>> +	int valid_boundary_link;
>> +	u64 resulting_valid;
>> +	u64 total_valid;
>> +	u64 effective_valid;
>> +	u64 effective_valid_recorded;
>> +	int n_tus;
>> +	int n_tus_per_lane;
>> +	int paired_tus;
>> +	int remainder_tus;
>> +	int remainder_tus_upper, remainder_tus_lower;
>> +	int extra_bytes;
>> +	int filler_size;
>> +	int delay_start_link;
>> +	int boundary_moderation_en = 0;
>> +	int upper_bdry_cnt = 0;
>> +	int lower_bdry_cnt = 0;
>> +	int i_upper_bdry_cnt = 0;
>> +	int i_lower_bdry_cnt = 0;
>> +	int valid_lower_boundary_link = 0;
>> +	int even_distribution_bf = 0;
>> +	int even_distribution_legacy = 0;
>> +	int even_distribution = 0;
>> +	int min_hblank = 0;
>> +	int extra_pclk_cycles;
>> +	u8 extra_pclk_cycle_delay = 4;
>> +	int extra_pclk_cycles_in_link_clk;
>> +	u64 ratio_by_tu;
>> +	u64 average_valid2;
>> +	u64 extra_buffer_margin;
>> +	int new_valid_boundary_link;
>> +
>> +	u64 resulting_valid_tmp;
>> +	u64 ratio_by_tu_tmp;
>> +	int n_tus_tmp;
>> +	int extra_pclk_cycles_tmp;
>> +	int extra_pclk_cycles_in_lclk_tmp;
>> +	int extra_req_bytes_new_tmp;
>> +	int filler_size_tmp;
>> +	int lower_filler_size_tmp;
>> +	int delay_start_link_tmp;
>> +	int min_hblank_tmp = 0;
>> +	bool extra_req_bytes_is_neg = false;
>> +	struct dp_panel_info *pinfo = &ctrl->panel->pinfo;
>> +
>> +	u8 dp_brute_force = 1;
>> +	u64 brute_force_threshold = 10;
>> +	u64 diff_abs;
> 
> 
> 76 stack vars and ~450 lines must be a new record somewhere :)
> 
> I'm going to skip reviewing this function and let you 
> split/simplify/reduce it.
> Please just make it more readable (comments, docs, helper functions, 
> etc).

Yes, will try to split this function as modular as possible.
JFYI, this function is IP/hardware specific implementation. It might not 
be possible
to provide lot of comments to make is understandable.
> 
>> +
>> +	ln_cnt =  ctrl->link->link_params.lane_count;
>> +
>> +	bpp = pinfo->bpp;
>> +	lwidth = pinfo->h_active;
>> +	h_blank = pinfo->h_back_porch + pinfo->h_front_porch +
>> +				pinfo->h_sync_width;
>> +	pclk = pinfo->pixel_clk_khz * 1000;
>> +
>> +	boundary_moderation_en = 0;
>> +	upper_bdry_cnt = 0;
>> +	lower_bdry_cnt = 0;
>> +	i_upper_bdry_cnt = 0;
>> +	i_lower_bdry_cnt = 0;
>> +	valid_lower_boundary_link = 0;
>> +	even_distribution_bf = 0;
>> +	even_distribution_legacy = 0;
>> +	even_distribution = 0;
>> +	min_hblank = 0;
>> +
>> +	lclk = drm_dp_bw_code_to_link_rate(
>> +		ctrl->link->link_params.bw_code) * DP_KHZ_TO_HZ;
>> +
>> +	pr_debug("pclk=%lld, active_width=%d, h_blank=%d\n",
>> +						pclk, lwidth, h_blank);
>> +	pr_debug("lclk = %lld, ln_cnt = %d\n", lclk, ln_cnt);
>> +	ratio = div64_u64_rem(pclk * bpp * multiplier,
>> +				8 * ln_cnt * lclk, &reminder);
>> +	ratio = div64_u64((pclk * bpp * multiplier), (8 * ln_cnt * lclk));
>> +	original_ratio = ratio;
>> +
>> +	extra_buffer_margin = roundup_u64(div64_u64(extra_pclk_cycle_delay
>> +				* lclk * multiplier, pclk), multiplier);
>> +	extra_buffer_margin = div64_u64(extra_buffer_margin, multiplier);
>> +
>> +	/* To deal with cases where lines are not distributable */
>> +	if (((lwidth % ln_cnt) != 0) && ratio < multiplier) {
>> +		ratio = ratio * ratio_scale;
>> +		ratio = ratio < (1000 * multiplier)
>> +				? ratio : (1000 * multiplier);
>> +	}
>> +	pr_debug("ratio = %lld\n", ratio);
>> +
>> +	for (tu_size = 32; tu_size <= 64; tu_size++) {
>> +		temp = ratio * tu_size;
>> +		temp2 = ((temp / multiplier) + 1) * multiplier;
>> +		n_err = roundup_u64(temp, multiplier) - temp;
>> +
>> +		if (n_err < err) {
>> +			err = n_err;
>> +			tu_size_desired = tu_size;
>> +		}
>> +	}
>> +	pr_debug("Info: tu_size_desired = %d\n", tu_size_desired);
>> +
>> +	tu_size_minus1 = tu_size_desired - 1;
>> +
>> +	valid_boundary_link = roundup_u64(ratio * tu_size_desired, 
>> multiplier);
>> +	valid_boundary_link /= multiplier;
>> +	n_tus = rounddown((lwidth * bpp * multiplier)
>> +			/ (8 * valid_boundary_link), multiplier) / multiplier;
>> +	even_distribution_legacy = n_tus % ln_cnt == 0 ? 1 : 0;
>> +	pr_debug("Info: n_symbol_per_tu=%d, number_of_tus=%d\n",
>> +					valid_boundary_link, n_tus);
>> +
>> +	extra_bytes = roundup_u64((n_tus + 1)
>> +			* ((valid_boundary_link * multiplier)
>> +			- (original_ratio * tu_size_desired)), multiplier);
>> +	extra_bytes /= multiplier;
>> +	extra_pclk_cycles = roundup(extra_bytes * 8 * multiplier / bpp,
>> +			multiplier);
>> +	extra_pclk_cycles /= multiplier;
>> +	extra_pclk_cycles_in_link_clk = 
>> roundup_u64(div64_u64(extra_pclk_cycles
>> +				* lclk * multiplier, pclk), multiplier);
>> +	extra_pclk_cycles_in_link_clk /= multiplier;
>> +	filler_size = roundup_u64((tu_size_desired - valid_boundary_link)
>> +						* multiplier, multiplier);
>> +	filler_size /= multiplier;
>> +	ratio_by_tu = div64_u64(ratio * tu_size_desired, multiplier);
>> +
>> +	pr_debug("extra_pclk_cycles_in_link_clk=%d, extra_bytes=%d\n",
>> +				extra_pclk_cycles_in_link_clk, extra_bytes);
>> +	pr_debug("extra_pclk_cycles_in_link_clk=%d\n",
>> +				extra_pclk_cycles_in_link_clk);
>> +	pr_debug("filler_size=%d, extra_buffer_margin=%lld\n",
>> +				filler_size, extra_buffer_margin);
>> +
>> +	delay_start_link = ((extra_bytes > extra_pclk_cycles_in_link_clk)
>> +			? extra_bytes
>> +			: extra_pclk_cycles_in_link_clk)
>> +				+ filler_size + extra_buffer_margin;
>> +	resulting_valid = valid_boundary_link;
>> +	pr_debug("Info: delay_start_link=%d, filler_size=%d\n",
>> +				delay_start_link, filler_size);
>> +	pr_debug("valid_boundary_link=%d ratio_by_tu=%lld\n",
>> +				valid_boundary_link, ratio_by_tu);
>> +
>> +	diff_abs = (resulting_valid >= ratio_by_tu)
>> +				? (resulting_valid - ratio_by_tu)
>> +				: (ratio_by_tu - resulting_valid);
>> +
>> +	if (err != 0 && ((diff_abs > brute_force_threshold)
>> +			|| (even_distribution_legacy == 0)
>> +			|| (dp_brute_force == 1))) {
>> +		err = multiplier;
>> +		for (tu_size = 32; tu_size <= 64; tu_size++) {
>> +			for (i_upper_bdry_cnt = 1; i_upper_bdry_cnt <= 15;
>> +						i_upper_bdry_cnt++) {
>> +				for (i_lower_bdry_cnt = 1;
>> +					i_lower_bdry_cnt <= 15;
>> +					i_lower_bdry_cnt++) {
>> +					new_valid_boundary_link =
>> +						roundup_u64(ratio
>> +						* tu_size, multiplier);
>> +					average_valid2 = (i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +						+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier))
>> +						/ (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt);
>> +					n_tus = rounddown_u64(div64_u64(lwidth
>> +						* multiplier * multiplier
>> +						* (bpp / 8), average_valid2),
>> +							multiplier);
>> +					n_tus /= multiplier;
>> +					n_tus_per_lane
>> +						= rounddown(n_tus
>> +							* multiplier
>> +							/ ln_cnt, multiplier);
>> +					n_tus_per_lane /= multiplier;
>> +					paired_tus =
>> +						rounddown((n_tus_per_lane)
>> +							* multiplier
>> +							/ (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt),
>> +							multiplier);
>> +					paired_tus /= multiplier;
>> +					remainder_tus = n_tus_per_lane
>> +							- paired_tus
>> +						* (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt);
>> +					if ((remainder_tus
>> +						- i_upper_bdry_cnt) > 0) {
>> +						remainder_tus_upper
>> +							= i_upper_bdry_cnt;
>> +						remainder_tus_lower =
>> +							remainder_tus
>> +							- i_upper_bdry_cnt;
>> +					} else {
>> +						remainder_tus_upper
>> +							= remainder_tus;
>> +						remainder_tus_lower = 0;
>> +					}
>> +					total_valid = paired_tus
>> +						* (i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +							+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier))
>> +						+ (remainder_tus_upper
>> +						* new_valid_boundary_link)
>> +						+ (remainder_tus_lower
>> +						* (new_valid_boundary_link
>> +							- multiplier));
>> +					n_err_neg = nn_err_neg = false;
>> +					effective_valid
>> +						= div_u64(total_valid,
>> +							n_tus_per_lane);
>> +					n_n_err = (effective_valid
>> +							>= (ratio * tu_size))
>> +						? (effective_valid
>> +							- (ratio * tu_size))
>> +						: ((ratio * tu_size)
>> +							- effective_valid);
>> +					if (effective_valid < (ratio * tu_size))
>> +						nn_err_neg = true;
>> +					n_err = (average_valid2
>> +						>= (ratio * tu_size))
>> +						? (average_valid2
>> +							- (ratio * tu_size))
>> +						: ((ratio * tu_size)
>> +							- average_valid2);
>> +					if (average_valid2 < (ratio * tu_size))
>> +						n_err_neg = true;
>> +					even_distribution =
>> +						n_tus % ln_cnt == 0 ? 1 : 0;
>> +					diff_abs =
>> +						resulting_valid >= ratio_by_tu
>> +						? (resulting_valid
>> +							- ratio_by_tu)
>> +						: (ratio_by_tu
>> +							- resulting_valid);
>> +
>> +					resulting_valid_tmp = div64_u64(
>> +						(i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +						+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier)),
>> +						(i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt));
>> +					ratio_by_tu_tmp =
>> +						original_ratio * tu_size;
>> +					ratio_by_tu_tmp /= multiplier;
>> +					n_tus_tmp = rounddown_u64(
>> +						div64_u64(lwidth
>> +						* multiplier * multiplier
>> +						* bpp / 8,
>> +						resulting_valid_tmp),
>> +						multiplier);
>> +					n_tus_tmp /= multiplier;
>> +
>> +					temp3 = (resulting_valid_tmp
>> +						>= (original_ratio * tu_size))
>> +						? (resulting_valid_tmp
>> +						- original_ratio * tu_size)
>> +						: (original_ratio * tu_size)
>> +						- resulting_valid_tmp;
>> +					temp3 = (n_tus_tmp + 1) * temp3;
>> +					temp4 = (new_valid_boundary_link
>> +						>= (original_ratio * tu_size))
>> +						? (new_valid_boundary_link
>> +							- original_ratio
>> +							* tu_size)
>> +						: (original_ratio * tu_size)
>> +						- new_valid_boundary_link;
>> +					temp4 = (i_upper_bdry_cnt
>> +							* ln_cnt * temp4);
>> +
>> +					temp3 = roundup_u64(temp3, multiplier);
>> +					temp4 = roundup_u64(temp4, multiplier);
>> +					dp_ctrl_get_extra_req_bytes
>> +						(resulting_valid_tmp,
>> +						new_valid_boundary_link,
>> +						temp3, temp4,
>> +						&extra_req_bytes_is_neg,
>> +						&result,
>> +						(original_ratio * tu_size));
>> +					extra_req_bytes_new_tmp
>> +						= div64_ul(result, multiplier);
>> +					if ((extra_req_bytes_is_neg)
>> +						&& (extra_req_bytes_new_tmp
>> +							> 1))
>> +						extra_req_bytes_new_tmp
>> +						= extra_req_bytes_new_tmp - 1;
>> +					if (extra_req_bytes_new_tmp == 0)
>> +						extra_req_bytes_new_tmp = 1;
>> +					extra_pclk_cycles_tmp =
>> +						(u64)(extra_req_bytes_new_tmp
>> +						      * 8 * multiplier) / bpp;
>> +					extra_pclk_cycles_tmp /= multiplier;
>> +
>> +					if (extra_pclk_cycles_tmp <= 0)
>> +						extra_pclk_cycles_tmp = 1;
>> +					extra_pclk_cycles_in_lclk_tmp =
>> +						roundup_u64(div64_u64(
>> +							extra_pclk_cycles_tmp
>> +							* lclk * multiplier,
>> +							pclk), multiplier);
>> +					extra_pclk_cycles_in_lclk_tmp
>> +						/= multiplier;
>> +					filler_size_tmp = roundup_u64(
>> +						(tu_size * multiplier *
>> +						new_valid_boundary_link),
>> +						multiplier);
>> +					filler_size_tmp /= multiplier;
>> +					lower_filler_size_tmp =
>> +						filler_size_tmp + 1;
>> +					if (extra_req_bytes_is_neg)
>> +						temp3 = (extra_req_bytes_new_tmp
>> +						> extra_pclk_cycles_in_lclk_tmp
>> +						? extra_pclk_cycles_in_lclk_tmp
>> +						: extra_req_bytes_new_tmp);
>> +					else
>> +						temp3 = (extra_req_bytes_new_tmp
>> +						> extra_pclk_cycles_in_lclk_tmp
>> +						? extra_req_bytes_new_tmp :
>> +						extra_pclk_cycles_in_lclk_tmp);
>> +
>> +					temp4 = lower_filler_size_tmp
>> +						+ extra_buffer_margin;
>> +					if (extra_req_bytes_is_neg)
>> +						delay_start_link_tmp
>> +							= (temp3 >= temp4)
>> +							? (temp3 - temp4)
>> +							: (temp4 - temp3);
>> +					else
>> +						delay_start_link_tmp
>> +							= temp3 + temp4;
>> +
>> +					min_hblank_tmp = (int)div64_u64(
>> +						roundup_u64(
>> +						div64_u64(delay_start_link_tmp
>> +						* pclk * multiplier, lclk),
>> +						multiplier), multiplier)
>> +						+ hblank_margin;
>> +
>> +					if (((even_distribution == 1)
>> +						|| ((even_distribution_bf == 0)
>> +						&& (even_distribution_legacy
>> +								== 0)))
>> +						&& !n_err_neg && !nn_err_neg
>> +						&& n_n_err < err
>> +						&& (n_n_err < diff_abs
>> +						|| (dp_brute_force == 1))
>> +						&& (new_valid_boundary_link
>> +									- 1) > 0
>> +						&& (h_blank >=
>> +							(u32)min_hblank_tmp)) {
>> +						upper_bdry_cnt =
>> +							i_upper_bdry_cnt;
>> +						lower_bdry_cnt =
>> +							i_lower_bdry_cnt;
>> +						err = n_n_err;
>> +						boundary_moderation_en = 1;
>> +						tu_size_desired = tu_size;
>> +						valid_boundary_link =
>> +							new_valid_boundary_link;
>> +						effective_valid_recorded
>> +							= effective_valid;
>> +						delay_start_link
>> +							= delay_start_link_tmp;
>> +						filler_size = filler_size_tmp;
>> +						min_hblank = min_hblank_tmp;
>> +						n_tus = n_tus_tmp;
>> +						even_distribution_bf = 1;
>> +
>> +						pr_debug("upper_bdry_cnt=%d, lower_boundary_cnt=%d, err=%lld, 
>> tu_size_desired=%d, valid_boundary_link=%d, effective_valid=%lld\n",
>> +							upper_bdry_cnt,
>> +							lower_bdry_cnt, err,
>> +							tu_size_desired,
>> +							valid_boundary_link,
>> +							effective_valid);
>> +					}
>> +				}
>> +			}
>> +		}
>> +
>> +		if (boundary_moderation_en == 1) {
>> +			resulting_valid = (u64)(upper_bdry_cnt
>> +					*valid_boundary_link + lower_bdry_cnt
>> +					* (valid_boundary_link - 1))
>> +					/ (upper_bdry_cnt + lower_bdry_cnt);
>> +			ratio_by_tu = original_ratio * tu_size_desired;
>> +			valid_lower_boundary_link =
>> +				(valid_boundary_link / multiplier) - 1;
>> +
>> +			tu_size_minus1 = tu_size_desired - 1;
>> +			even_distribution_bf = 1;
>> +			valid_boundary_link /= multiplier;
>> +			pr_debug("Info: Boundary_moderation enabled\n");
>> +		}
>> +	}
>> +
>> +	min_hblank = ((int) roundup_u64(div64_u64(delay_start_link * pclk
>> +			* multiplier, lclk), multiplier))
>> +			/ multiplier + hblank_margin;
>> +	if (h_blank < (u32)min_hblank) {
>> +		pr_debug(" WARNING: run_idx=%d Programmed h_blank %d is smaller 
>> than the min_hblank %d supported.\n",
>> +					run_idx, h_blank, min_hblank);
>> +	}
>> +
>> +	if (fifo_empty)	{
>> +		tu_size_minus1 = 31;
>> +		valid_boundary_link = 32;
>> +		delay_start_link = 0;
>> +		boundary_moderation_en = 0;
>> +	}
>> +
>> +	pr_debug("tu_size_minus1=%d valid_boundary_link=%d 
>> delay_start_link=%d boundary_moderation_en=%d\n upper_boundary_cnt=%d 
>> lower_boundary_cnt=%d valid_lower_boundary_link=%d min_hblank=%d\n",
>> +		tu_size_minus1, valid_boundary_link, delay_start_link,
>> +		boundary_moderation_en, upper_bdry_cnt, lower_bdry_cnt,
>> +		valid_lower_boundary_link, min_hblank);
>> +
>> +	tu_table->valid_boundary_link = valid_boundary_link;
>> +	tu_table->delay_start_link = delay_start_link;
>> +	tu_table->boundary_moderation_en = boundary_moderation_en;
>> +	tu_table->valid_lower_boundary_link = valid_lower_boundary_link;
>> +	tu_table->upper_boundary_count = upper_bdry_cnt;
>> +	tu_table->lower_boundary_count = lower_bdry_cnt;
>> +	tu_table->tu_size_minus1 = tu_size_minus1;
>> +}
>> +
>> +static void dp_ctrl_setup_tr_unit(struct dp_ctrl_private *ctrl)
>> +{
>> +	u32 dp_tu = 0x0;
>> +	u32 valid_boundary = 0x0;
>> +	u32 valid_boundary2 = 0x0;
>> +	struct dp_vc_tu_mapping_table tu_calc_table;
>> +
>> +	dp_ctrl_calc_tu_parameters(ctrl, &tu_calc_table);
>> +
>> +	dp_tu |= tu_calc_table.tu_size_minus1;
>> +	valid_boundary |= tu_calc_table.valid_boundary_link;
>> +	valid_boundary |= (tu_calc_table.delay_start_link << 16);
>> +
>> +	valid_boundary2 |= (tu_calc_table.valid_lower_boundary_link << 1);
>> +	valid_boundary2 |= (tu_calc_table.upper_boundary_count << 16);
>> +	valid_boundary2 |= (tu_calc_table.lower_boundary_count << 20);
>> +
>> +	if (tu_calc_table.boundary_moderation_en)
>> +		valid_boundary2 |= BIT(0);
>> +
>> +	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
>> +			dp_tu, valid_boundary, valid_boundary2);
>> +
>> +	ctrl->catalog->dp_tu = dp_tu;
>> +	ctrl->catalog->valid_boundary = valid_boundary;
>> +	ctrl->catalog->valid_boundary2 = valid_boundary2;
>> +
>> +	ctrl->catalog->update_transfer_unit(ctrl->catalog);
> 
> Again here, if you just call the function directly, you can avoid the 
> callback.
> If you add function arguments, you can avoid having to store
> dp_tu/valid_boundary/
> valid_boundary2 entirely.
> 
>> +}
>> +
>> +static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);
> 
> Break out the timeout into a #define
> 
>> +	if (ret <= 0) {
>> +		pr_err("Link Train timedout\n");
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
> 
> You're not checking the return value at the callsite.
> 
>> +}
>> +
>> +static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl,
>> +				     u32 voltage_level, u32 pre_emphasis_level)
> 
> I don't think this needs to be a function, just move it all into
> dp_ctrl_update_vx_px.
> 
>> +{
>> +	int i;
>> +	u8 buf[4];
>> +	u32 max_level_reached = 0;
>> +
>> +	if (voltage_level == DP_LINK_VOLTAGE_MAX) {
>> +		pr_debug("max. voltage swing level reached %d\n",
>> +				voltage_level);
>> +		max_level_reached |= BIT(2);
> 
>         DP_TRAIN_MAX_SWING_REACHED
> 
>> +	}
>> +
>> +	if (pre_emphasis_level == DP_LINK_PRE_EMPHASIS_MAX) {
>> +		pr_debug("max. pre-emphasis level reached %d\n",
>> +				pre_emphasis_level);
>> +		max_level_reached  |= BIT(5);
> 
>         DP_TRAIN_MAX_PRE_EMPHASIS_REACHED
> 
>> +	}
>> +
>> +	pre_emphasis_level <<= 3;
> 
> This is DP_TRAIN_PRE_EMPHASIS_SHIFT, but I'm guessing you aren't using 
> the
> DP_TRAIN_PRE_EMPH_LEVEL_* values when you set p_level. So the right way 
> to fix
> this is to use those #defines and get rid of this shift.
> 
>> +
>> +	for (i = 0; i < 4; i++)
> 
> You shouldn't assume 4 lanes here, use drm_dp_link->num_lanes
> 
>> +		buf[i] = voltage_level | pre_emphasis_level | max_level_reached;
>> +
>> +	pr_debug("sink: p|v=0x%x\n", voltage_level | pre_emphasis_level);
>> +	return drm_dp_dpcd_write(ctrl->aux->drm_aux, 0x103, buf, 4);
> 
> s/0x103/DP_TRAINING_LANE0_SET/ and s/4/drm_dp_link->num_lanes/
> 
> Also, this will return number of bytes transmitted, not (0 || -errno).
> 
> 
>> +}
>> +
>> +static void dp_ctrl_update_vx_px(struct dp_ctrl_private *ctrl)
>> +{
>> +	struct dp_link *link = ctrl->link;
>> +
>> +	ctrl->catalog->update_vx_px(ctrl->catalog,
>> +		link->phy_params.v_level, link->phy_params.p_level);
>> +
>> +	dp_ctrl_update_sink_vx_px(ctrl, link->phy_params.v_level,
>> +		link->phy_params.p_level);
> 
> Fortunately (or unfortunately), the return value isn't checked. So 
> please check
> the return value.
> 
>> +}
>> +
>> +static void dp_ctrl_train_pattern_set(struct dp_ctrl_private *ctrl,
>> +		u8 pattern)
>> +{
>> +	u8 buf[4];
> 
> Why 4?
> 
>> +
>> +	pr_debug("sink: pattern=%x\n", pattern);
>> +
>> +	buf[0] = pattern;
>> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_TRAINING_PATTERN_SET, buf, 
>> 1);
> 
> Check the return value of this and alll drm_dp_dpcd_(read|write) calls.
> 
>> +}
>> +
>> +static int dp_ctrl_read_link_status(struct dp_ctrl_private *ctrl,
>> +				    u8 *link_status)
>> +{
>> +	int ret = 0, len;
>> +	u32 const offset = DP_LANE_ALIGN_STATUS_UPDATED - DP_LANE0_1_STATUS;
>> +	u32 link_status_read_max_retries = 100;
>> +
>> +	while (--link_status_read_max_retries) {
>> +		len = drm_dp_dpcd_read_link_status(ctrl->aux->drm_aux,
>> +			link_status);
>> +		if (len != DP_LINK_STATUS_SIZE) {
>> +			pr_err("DP link status read failed, err: %d\n", len);
>> +			ret = len;
>> +			break;
> 
> Just return directly here. You can also just drop len and use ret (or 
> drop ret
> and use len).
> 
>> +		}
>> +
>> +		if (!(link_status[offset] & DP_LINK_STATUS_UPDATED))
>> +			break;
> 
> And return 0 directly here
> 
>> +	}
>> +
>> +	return ret;
> 
> Here you're returning successful in the timeout case :( Once you
> convert the above
> to direct returns, this can become return -ETIMEDOUT;
> 
> I think you should also drop the number of retries drastically.
> 
>> +}
>> +
>> +static int dp_ctrl_link_train_1(struct dp_ctrl_private *ctrl)
>> +{
>> +	int tries, old_v_level, ret = 0;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +	int const maximum_retries = 5;
>> +
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
>> +
>> +	ctrl->catalog->set_pattern(ctrl->catalog, 0x01);
> 
> #define that bit please
> 
>> +	dp_ctrl_train_pattern_set(ctrl, DP_TRAINING_PATTERN_1 |
>> +		DP_LINK_SCRAMBLING_DISABLE); /* train_1 */
> 
> the train_1 comment isn't needed.
> 
>> +	dp_ctrl_update_vx_px(ctrl);
>> +
>> +	tries = 0;
>> +	old_v_level = ctrl->link->phy_params.v_level;
>> +	while (1) {
> 
> Instead of unbounded, this should be:
>         for (tries = 0; tries < maximum_retries; tries++) {
> 
> You'll need to s/break/return ret/ in the rest of the loop and move the 
> timeout
> error to the bottom of the function
> 
>> +		drm_dp_link_train_clock_recovery_delay(ctrl->panel->dpcd);
>> +
>> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
>> +		if (ret)
>> +			break;
>> +
>> +		if (drm_dp_clock_recovery_ok(link_status,
>> +			ctrl->link->link_params.lane_count)) {
>> +			break;
>> +		}
>> +
>> +		if (ctrl->link->phy_params.v_level == DP_LINK_VOLTAGE_MAX) {
> 
> Since DP_LINK_VOLTAGE_MAX == DP_LINK_VOLTAGE_LEVEL_2, you'll end up not 
> retrying
> LEVEL_2 at all.
> 
>> +			pr_err_ratelimited("max v_level reached\n");
>> +			ret = -EAGAIN;
>> +			break;
>> +		}
>> +
>> +		if (old_v_level == ctrl->link->phy_params.v_level) {
>> +			tries++;
>> +			if (tries >= maximum_retries) {
>> +				pr_err("max tries reached\n");
>> +				ret = -ETIMEDOUT;
>> +				break;
>> +			}
>> +		} else {
>> +			tries = 0;
>> +			old_v_level = ctrl->link->phy_params.v_level;
>> +		}
>> +
>> +		pr_debug("clock recovery not done, adjusting vx px\n");
>> +
>> +		ctrl->link->adjust_levels(ctrl->link, link_status);
>> +		dp_ctrl_update_vx_px(ctrl);
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_link_rate_down_shift(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	if (!ctrl)
>> +		return -EINVAL;
>> +
>> +	switch (ctrl->link->link_params.bw_code) {
>> +	case DP_LINK_BW_8_1:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_5_4;
>> +		break;
>> +	case DP_LINK_BW_5_4:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_2_7;
>> +		break;
>> +	case DP_LINK_BW_2_7:
>> +	case DP_LINK_BW_1_62:
>> +	default:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_1_62;
>> +		break;
>> +	};
>> +
>> +	pr_debug("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
>> +
>> +	return ret;
>> +}
>> +
>> +static void dp_ctrl_clear_training_pattern(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	dp_ctrl_train_pattern_set(ctrl, 0);
> 
> 
> DP_TRAINING_PATTERN_DISABLE
> 
> 
>> +	drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
>> +}
>> +
>> +static int dp_ctrl_link_training_2(struct dp_ctrl_private *ctrl)
>> +{
>> +	int tries = 0, ret = 0;
>> +	char pattern;
>> +	int const maximum_retries = 5;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
>> +
>> +	if (drm_dp_tps3_supported(ctrl->panel->dpcd))
>> +		pattern = DP_TRAINING_PATTERN_3;
>> +	else
>> +		pattern = DP_TRAINING_PATTERN_2;
>> +
>> +	dp_ctrl_update_vx_px(ctrl);
>> +	ctrl->catalog->set_pattern(ctrl->catalog, pattern);
>> +	dp_ctrl_train_pattern_set(ctrl, pattern | 
>> DP_RECOVERED_CLOCK_OUT_EN);
>> +
>> +	do  {
> 
>         for (tries = 0; tries < maximum_retries; tries++)
> 
>> +		drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
>> +
>> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
>> +		if (ret)
>> +			break;
>> +
>> +		if (drm_dp_channel_eq_ok(link_status,
>> +			ctrl->link->link_params.lane_count))
>> +			break;
>> +
>> +		if (tries > maximum_retries) {
>> +			ret = -ETIMEDOUT;
>> +			break;
>> +		}
>> +		tries++;
>> +
>> +		ctrl->link->adjust_levels(ctrl->link, link_status);
>> +		dp_ctrl_update_vx_px(ctrl);
>> +	} while (1);
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +	u8 encoding = 0x1;
> 
> DP_SET_ANSI_8B10B
> 
>> +	struct drm_dp_link link_info = {0};
>> +
>> +	ctrl->link->phy_params.p_level = 0;
>> +	ctrl->link->phy_params.v_level = 0;
>> +
>> +	dp_ctrl_config_ctrl(ctrl);
>> +
>> +	link_info.num_lanes = ctrl->link->link_params.lane_count;
>> +	link_info.rate = drm_dp_bw_code_to_link_rate(
>> +		ctrl->link->link_params.bw_code);
>> +	link_info.capabilities = ctrl->panel->link_info.capabilities;
> 
> Drop the hand-rolled ctrl->panel->link_info and use drm_dp_link_probe 
> to fill in
> drm_dp_link.
> 
>> +
>> +	drm_dp_link_configure(ctrl->aux->drm_aux, &link_info);
>> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, 
>> DP_MAIN_LINK_CHANNEL_CODING_SET,
>> +				&encoding, 1);
>> +
>> +	ret = dp_ctrl_link_train_1(ctrl);
>> +	if (ret) {
>> +		pr_err("link training #1 failed\n");
> 
> print ret
> 
>> +		goto end;
>> +	}
>> +
>> +	/* print success info as this is a result of user initiated action 
>> */
>> +	pr_info("link training #1 successful\n");
> 
> this should be debug loglevel
> 
>> +
>> +	ret = dp_ctrl_link_training_2(ctrl);
>> +	if (ret) {
>> +		pr_err("link training #2 failed\n");
> 
> print ret
> 
>> +		goto end;
>> +	}
>> +
>> +	/* print success info as this is a result of user initiated action 
>> */
>> +	pr_info("link training #2 successful\n");
> 
> debug loglevel
> 
>> +
>> +end:
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
> 
> Same comments re: wmb
> 
>> +
>> +	dp_ctrl_clear_training_pattern(ctrl);
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_setup_main_link(struct dp_ctrl_private *ctrl, bool 
>> train)
>> +{
>> +	bool mainlink_ready = false;
>> +	int ret = 0;
>> +
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
>> +
>> +	ret = ctrl->link->psm_config(ctrl->link,
>> +		&ctrl->panel->link_info, false);
> 
> This can fit on one line
> 
>> +	if (ret)
>> +		goto end;
> 
> All of the "goto end"'s can be replaced with "return ret", then delete 
> the end
> label.
> 
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> 
> You should really protect sink_request with a lock, it's racy. I'm 
> trying
> to catch the race conditions while I review, but I'd urge you to audit 
> the
> driver for other places that need locking.
> 
>> +		goto end;
>> +
>> +	if (!train)
>> +		goto send_video;
> 
> Instead of adding the label, just wrap the reset and train calls in an
> if (train) {} block.
> 
> 
>> +
>> +	/*
>> +	 * As part of previous calls, DP controller state might have
>> +	 * transitioned to PUSH_IDLE. In order to start transmitting a link
>> +	 * training pattern, we have to first to a DP software reset.
> 
> "we have to first _do_ a..."
> 
>> +	 */
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +
>> +	ret = dp_ctrl_link_train(ctrl);
>> +	if (ret)
>> +		goto end;
>> +
>> +send_video:
>> +	/*
>> +	 * Set up transfer unit values and set controller state to send
>> +	 * video.
>> +	 */
>> +	dp_ctrl_setup_tr_unit(ctrl);
>> +	ctrl->catalog->state_ctrl(ctrl->catalog, ST_SEND_VIDEO);
>> +
>> +	dp_ctrl_wait4video_ready(ctrl);
> 
> Check return value please
> 
>> +	mainlink_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
>> +	pr_debug("mainlink %s\n", mainlink_ready ? "READY" : "NOT READY");
>> +end:
>> +	return ret;
>> +}
>> +
>> +static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
>> +				   char *name, u32 rate)
>> +{
>> +	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
>> +	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
>> +
>> +	while (num && strcmp(cfg->clk_name, name)) {
>> +		num--;
>> +		cfg++;
>> +	}
>> +
>> +	pr_debug("setting rate=%d on clk=%s\n", rate, name);
>> +
>> +	if (num)
>> +		cfg->rate = rate;
>> +	else
>> +		pr_err("%s clock could not be set with rate %d\n", name, rate);
>> +}
> 
> Instead of doing all of this work, just store pointers to the link and 
> pixel
> clock when you parse the dt. That way you can just access them directly 
> in
> dp_ctrl_enable_mainlink_clocks.
> 
>> +
>> +static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ctrl->power->set_pixel_clk_parent(ctrl->power);
>> +
>> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
>> +		drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code));
>> +
>> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_pixel_clk", ctrl->pixel_rate);
>> +
>> +	ret = ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, true);
>> +	if (ret) {
>> +		pr_err("Unabled to start link clocks\n");
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_disable_mainlink_clocks(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	return ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, false);
>> +}
> 
> This function isn't necesary (even less so when all of the catalog 
> abstractions
> are gone).
> 
>> +
>> +static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +	struct dp_catalog_ctrl *catalog;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->orientation = flip;
>> +	catalog = ctrl->catalog;
>> +
>> +	catalog->usb_reset(ctrl->catalog, flip);
>> +	catalog->phy_reset(ctrl->catalog);
>> +	catalog->enable_irq(ctrl->catalog, true);
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * dp_ctrl_host_deinit() - Uninitialize DP controller
>> + * @ctrl: Display Port Driver data
>> + *
>> + * Perform required steps to uninitialize DP controller
>> + * and its resources.
>> + */
>> +static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->enable_irq(ctrl->catalog, false);
>> +
>> +	pr_debug("Host deinitialized successfully\n");
>> +}
>> +
>> +static bool dp_ctrl_use_fixed_nvid(struct dp_ctrl_private *ctrl)
>> +{
>> +	u8 *dpcd = ctrl->panel->dpcd;
>> +
>> +	/*
>> +	 * For better interop experience, used a fixed NVID=0x8000
>> +	 * whenever connected to a VGA dongle downstream.
>> +	 */
>> +	if (dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) {
>> +		u8 type = dpcd[DP_DOWNSTREAMPORT_PRESENT] &
>> +			DP_DWN_STRM_PORT_TYPE_MASK;
>> +		if (type == DP_DWN_STRM_PORT_TYPE_ANALOG)
>> +			return true;
>> +	}
>> +
>> +	return false;
>> +}
> 
> For this, you should use the DP_DPCD_QUIRK_CONSTANT_N quirk and
> drm_dp_has_quirk() instead.
> 
> 
>> +
>> +static int dp_ctrl_link_maintenance(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
>> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
>> +
>> +	ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
>> +
>> +	do {
>> +		if (ret == -EAGAIN) {
>> +			/* try with lower link rate */
>> +			dp_ctrl_link_rate_down_shift(ctrl);
>> +
>> +			ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +		}
>> +
>> +		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
>> +			ctrl->orientation, ctrl->link->link_params.lane_count);
>> +
>> +		/*
>> +		 * Disable and re-enable the mainlink clock since the
>> +		 * link clock might have been adjusted as part of the
>> +		 * link maintenance.
>> +		 */
>> +		dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Return value should be checked
> 
> 
> Below you have:
> 
> +		/* hw recommended delay before re-enabling clocks */
> +		msleep(20);
> 
> Between the disable and enable, so you should probably have that here 
> too?
> 
>> +
>> +		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
>> +		if (ret)
>> +			continue;
> 
> Do you really want to continue here? Seems like you could get into an 
> infinite
> loop pretty easily in the -EINVAL case.
> 
>> +
>> +		dp_ctrl_configure_source_params(ctrl);
>> +
>> +		ctrl->catalog->config_msa(ctrl->catalog,
>> +			drm_dp_bw_code_to_link_rate(
>> +			ctrl->link->link_params.bw_code),
>> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
>> +
>> +		reinit_completion(&ctrl->idle_comp);
> 
> Are you guaranteed that this doesn't race with other idle_comp uses?
> 
>> +
>> +		ret = dp_ctrl_setup_main_link(ctrl, true);
>> +	} while (ret == -EAGAIN);
> 
> The do/while is a bit awkward, especially since it starts with a 
> conditional
> block that can't possibly be true on the first iteration. How about:
> 
> 	for (tries = 0; tries < max_tries; tries++) {
> 		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
> 			ctrl->orientation, ctrl->link->link_params.lane_count);
> 
> 		/*
> 		 * Disable and re-enable the mainlink clock since the
> 		 * link clock might have been adjusted as part of the
> 		 * link maintenance.
> 		 */
> 		ret = dp_ctrl_disable_mainlink_clocks(ctrl);
>                 if (ret)
>                         return ret;
> 
> 		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
> 		if (ret)
> 			return ret;
> 
> 		dp_ctrl_configure_source_params(ctrl);
> 
> 		ctrl->catalog->config_msa(ctrl->catalog,
> 			drm_dp_bw_code_to_link_rate(
> 			ctrl->link->link_params.bw_code),
> 			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
> 
> 		reinit_completion(&ctrl->idle_comp);
> 
> 		ret = dp_ctrl_setup_main_link(ctrl, true);
> 		if (ret != -EAGAIN)
>                         return ret;
> 
>                 /* try with lower link rate */
>                 dp_ctrl_link_rate_down_shift(ctrl);
> 
>                 ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
> 	}
> 
>         return -ETIMEDOUT;
> 
> 
> There's a lot of similarity between this code and dp_ctrl_on. If the 
> code were
> shared, we wouldn't have the missing 20ms delay above. So can you 
> please pull
> the common bits which [re-]initialize the link into a helper function 
> that you
> call from both functions?
> 
>> +
>> +	return ret;
> 
> It's nice that we return a value here, but it's never checked by our 
> callers :(
> 
>> +}
>> +
>> +static void dp_ctrl_process_phy_test_request(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	if (!ctrl->link->phy_params.phy_test_pattern_sel) {
>> +		pr_debug("no test pattern selected by sink\n");
>> +		return;
>> +	}
>> +
>> +	pr_debug("start\n");
> 
> This and the "end" debug statements should be removed
> 
>> +
>> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
>> +	/*
>> +	 * The global reset will need DP link ralated clocks to be
> 
> s/related/ralated/
> 
>> +	 * running. Add the global reset just before disabling the
>> +	 * link clocks and core clocks.
>> +	 */
>> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
>> +	ctrl->dp_ctrl.off(&ctrl->dp_ctrl);
>> +
>> +	ret = ctrl->dp_ctrl.on(&ctrl->dp_ctrl);
>> +	if (ret)
>> +		pr_err("failed to enable DP controller\n");
> 
> Please propagate errors instead of swallowing them.
> 
>> +
>> +	pr_debug("end\n");
>> +}
>> +
>> +static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	bool success = false;
>> +	u32 pattern_sent = 0x0;
>> +	u32 pattern_requested = ctrl->link->phy_params.phy_test_pattern_sel;
>> +
>> +	pr_debug("request: %s\n",
>> +			dp_link_get_phy_test_pattern(pattern_requested));
>> +
>> +	ctrl->catalog->update_vx_px(ctrl->catalog,
>> +			ctrl->link->phy_params.v_level,
>> +			ctrl->link->phy_params.p_level);
>> +	ctrl->catalog->send_phy_pattern(ctrl->catalog, pattern_requested);
>> +	ctrl->link->send_test_response(ctrl->link);
>> +
>> +	pattern_sent = ctrl->catalog->read_phy_pattern(ctrl->catalog);
>> +
>> +	switch (pattern_sent) {
>> +	case MR_LINK_TRAINING1:
>> +		if (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING)
>> +			success = true;
> 
> 
> success = pattern_requested == DP_LINK_QUAL_PATTERN_11_D10_2;
> 
> Same can be done below.
> 
> 
>> +		break;
>> +	case MR_LINK_SYMBOL_ERM:
>> +		if ((pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT)
>> +			|| (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN))
>> +			success = true;
>> +		break;
>> +	case MR_LINK_PRBS7:
>> +		if (pattern_requested == DP_TEST_PHY_PATTERN_PRBS7)
>> +			success = true;
>> +		break;
>> +	case MR_LINK_CUSTOM80:
>> +		if (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN)
>> +			success = true;
>> +		break;
>> +	default:
>> +		success = false;
>> +		return;
>> +	}
> 
> I feel like you should return success (or a ret). As it is, this
> doesn't do much.
> 
>> +
>> +	pr_debug("%s: %s\n", success ? "success" : "failed",
>> +			dp_link_get_phy_test_pattern(pattern_requested));
>> +}
>> +
>> +static void dp_ctrl_handle_sink_request(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +	u32 sink_request = 0x0;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +	sink_request = ctrl->link->sink_request;
>> +
>> +	if (sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		pr_info("PHY_TEST_PATTERN request\n");
> 
> Downgrade to DEBUG level please
> 
>> +		dp_ctrl_process_phy_test_request(ctrl);
>> +	}
>> +
>> +	if (sink_request & DP_LINK_STATUS_UPDATED)
>> +		dp_ctrl_link_maintenance(ctrl);
> 
> Check return value
> 
>> +
>> +	if (sink_request & DP_TEST_LINK_TRAINING) {
>> +		ctrl->link->send_test_response(ctrl->link);
>> +		dp_ctrl_link_maintenance(ctrl);
> 
> Check return value
> 
>> +	}
>> +}
>> +
>> +static void dp_ctrl_reset(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +}
> 
> I think this function goes away with all of the catalog stuff removed.
> 
>> +
>> +static int dp_ctrl_on(struct dp_ctrl *dp_ctrl)
>> +{
>> +	int rc = 0;
>> +	struct dp_ctrl_private *ctrl;
>> +	u32 rate = 0;
>> +	u32 link_train_max_retries = 100;
> 
> This amount is excessive, 5 times should suffice (unless you have data 
> that
> suggests otherwise).
> 
>> +	u32 const phy_cts_pixel_clk_khz = 148500;
> 
> Should this be a #define in drm_dp_helper?
> 
>> +
>> +	if (!dp_ctrl) {
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	atomic_set(&ctrl->aborted, 0);
> 
> Why is this needed over is_connected? It seems like if you had proper 
> locking
> around is_connected (which I think is necessary), you could just
> acquire the lock
> and try the training. If it fails b/c someone unplugged the cable, 
> that's quite
> Ok.
> 
>> +	rate = ctrl->panel->link_info.rate;
>> +
>> +	ctrl->power->clk_enable(ctrl->power, DP_CORE_PM, true);
>> +	ctrl->catalog->hpd_config(ctrl->catalog, true);
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		pr_debug("using phy test link parameters\n");
>> +		if (!ctrl->panel->pinfo.pixel_clk_khz)
>> +			ctrl->pixel_rate = phy_cts_pixel_clk_khz;
>> +	} else {
>> +		ctrl->link->link_params.bw_code =
>> +			drm_dp_link_rate_to_bw_code(rate);
>> +		ctrl->link->link_params.lane_count =
>> +			ctrl->panel->link_info.num_lanes;
>> +		ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
>> +	}
>> +
>> +	pr_debug("bw_code=%d, lane_count=%d, pixel_rate=%d\n",
>> +		ctrl->link->link_params.bw_code,
>> +		ctrl->link->link_params.lane_count, ctrl->pixel_rate);
>> +
>> +	ctrl->catalog->phy_lane_cfg(ctrl->catalog,
>> +			ctrl->orientation, ctrl->link->link_params.lane_count);
>> +
>> +	rc = dp_ctrl_enable_mainlink_clocks(ctrl);
>> +	if (rc)
>> +		goto end;
>> +
>> +	reinit_completion(&ctrl->idle_comp);
> 
> Are you guaranteed that this doesn't race with other idle_comp uses (or 
> other
> dp_ctrl_on callers)?
> 
>> +
>> +	dp_ctrl_configure_source_params(ctrl);
>> +
>> +	while (--link_train_max_retries && !atomic_read(&ctrl->aborted)) {
>> +		ctrl->catalog->config_msa(ctrl->catalog,
>> +			drm_dp_bw_code_to_link_rate(
>> +			ctrl->link->link_params.bw_code),
>> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
>> +
>> +		rc = dp_ctrl_setup_main_link(ctrl, true);
>> +		if (!rc)
>> +			break;
>> +
>> +		/* try with lower link rate */
>> +		dp_ctrl_link_rate_down_shift(ctrl);
>> +
>> +		ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +
>> +		dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Check return code
> 
>> +		/* hw recommended delay before re-enabling clocks */
>> +		msleep(20);
>> +
>> +		dp_ctrl_enable_mainlink_clocks(ctrl);
> 
> Check return code
> 
>> +	}
> 
> Same comment here as in dp_ctrl_link_maintenance(), we should pull out 
> the
> common code and put it in a helper.
> 
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> 
> This is racy, sink_request could change between the check above and 
> here.
> 
>> +		dp_ctrl_send_phy_test_pattern(ctrl);
>> +
>> +	pr_debug("End-\n");
> 
> Please remove
> 
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_ctrl_off(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +
>> +	/* Make sure DP is disabled before clk disable */
>> +	wmb();
> 
> readl/wmb nit
> 
>> +
>> +	dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Check and propagate return value
> 
>> +
>> +	pr_debug("DP off done\n");
>> +}
>> +
>> +static void dp_ctrl_isr(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->get_interrupt(ctrl->catalog);
> 
> This should return the isr instead of store it in ctrl->catalog->isr, 
> since that
> could potentially be overwritten after this function acks the current
> interrupts.
> 
> (Also, it's only used in this function, so there's no need to store 
> it). One you
> remove the catalog indirection, hopefully there will be a bunch of 
> these cases
> that become clear.
> 
> 
>> +
>> +	if (ctrl->catalog->isr & DP_CTRL_INTR_READY_FOR_VIDEO)
>> +		dp_ctrl_video_ready(ctrl);
>> +
>> +	if (ctrl->catalog->isr & DP_CTRL_INTR_IDLE_PATTERN_SENT)
>> +		dp_ctrl_idle_patterns_sent(ctrl);
> 
> As mentioned above, just call the completions directly.
> 
>> +}
>> +
>> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
>> +{
>> +	int rc = 0;
>> +	struct dp_ctrl_private *ctrl;
>> +	struct dp_ctrl *dp_ctrl;
>> +
>> +	if (!in->dev || !in->panel || !in->aux ||
>> +	    !in->link || !in->catalog) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	ctrl = devm_kzalloc(in->dev, sizeof(*ctrl), GFP_KERNEL);
>> +	if (!ctrl) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	init_completion(&ctrl->idle_comp);
>> +	init_completion(&ctrl->video_comp);
>> +
>> +	/* in parameters */
>> +	ctrl->parser   = in->parser;
>> +	ctrl->panel    = in->panel;
>> +	ctrl->power    = in->power;
>> +	ctrl->aux      = in->aux;
>> +	ctrl->link     = in->link;
>> +	ctrl->catalog  = in->catalog;
>> +	ctrl->dev      = in->dev;
>> +
>> +	dp_ctrl = &ctrl->dp_ctrl;
>> +
>> +	/* out parameters */
>> +	dp_ctrl->init      = dp_ctrl_host_init;
>> +	dp_ctrl->deinit    = dp_ctrl_host_deinit;
>> +	dp_ctrl->on        = dp_ctrl_on;
>> +	dp_ctrl->off       = dp_ctrl_off;
>> +	dp_ctrl->push_idle = dp_ctrl_push_idle;
>> +	dp_ctrl->abort     = dp_ctrl_abort;
>> +	dp_ctrl->isr       = dp_ctrl_isr;
>> +	dp_ctrl->reset	   = dp_ctrl_reset;
>> +	dp_ctrl->handle_sink_request = dp_ctrl_handle_sink_request;
>> +
>> +	return dp_ctrl;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	devm_kfree(ctrl->dev, ctrl);
>> +}
> 
> Once again, these functions can be deleted. Just store the _necessary_ 
> data in a
> central struct (with substructs as necessary) and call functions 
> directly.
> 
> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.h 
>> b/drivers/gpu/drm/msm/dp/dp_ctrl.h
>> new file mode 100644
>> index 0000000..6ab221a
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.h
>> @@ -0,0 +1,50 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_CTRL_H_
>> +#define _DP_CTRL_H_
>> +
>> +#include "dp_aux.h"
>> +#include "dp_panel.h"
>> +#include "dp_link.h"
>> +#include "dp_parser.h"
>> +#include "dp_power.h"
>> +#include "dp_catalog.h"
>> +
>> +struct dp_ctrl {
>> +	int (*init)(struct dp_ctrl *dp_ctrl, bool flip);
>> +	void (*deinit)(struct dp_ctrl *dp_ctrl);
>> +	int (*on)(struct dp_ctrl *dp_ctrl);
>> +	void (*off)(struct dp_ctrl *dp_ctrl);
>> +	void (*reset)(struct dp_ctrl *dp_ctrl);
>> +	void (*push_idle)(struct dp_ctrl *dp_ctrl);
>> +	void (*abort)(struct dp_ctrl *dp_ctrl);
>> +	void (*isr)(struct dp_ctrl *dp_ctrl);
>> +	void (*handle_sink_request)(struct dp_ctrl *dp_ctrl);
>> +};
> 
> Same comment as catalog, these should just be functions to be called 
> directly.
> 
>> +
>> +struct dp_ctrl_in {
>> +	struct device *dev;
>> +	struct dp_panel *panel;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_parser *parser;
>> +	struct dp_power *power;
>> +	struct dp_catalog_ctrl *catalog;
>> +};
> 
> This struct is not needed, function arguments work just as well.
> 
>> +
>> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in);
>> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl);
>> +
>> +#endif /* _DP_CTRL_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.c 
>> b/drivers/gpu/drm/msm/dp/dp_debug.c
>> new file mode 100644
>> index 0000000..5c0a8ce
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_debug.c
>> @@ -0,0 +1,507 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/debugfs.h>
>> +#include <drm/drm_connector.h>
>> +
>> +#include "dp_parser.h"
>> +#include "dp_power.h"
>> +#include "dp_catalog.h"
>> +#include "dp_aux.h"
>> +#include "dp_ctrl.h"
>> +#include "dp_debug.h"
>> +#include "dp_display.h"
>> +
>> +#define DEBUG_NAME "drm_dp"
>> +
>> +struct dp_debug_private {
>> +	struct dentry *root;
>> +
>> +	struct dp_usbpd *usbpd;
>> +	struct dp_link *link;
>> +	struct dp_panel *panel;
>> +	struct drm_connector **connector;
>> +	struct device *dev;
>> +
>> +	struct dp_debug dp_debug;
>> +};
>> +
>> +static ssize_t dp_debug_write_hpd(struct file *file,
>> +		const char __user *user_buff, size_t count, loff_t *ppos)
>> +{
>> +	struct dp_debug_private *debug = file->private_data;
>> +	char buf[SZ_8];
>> +	size_t len = 0;
>> +	int hpd;
>> +
>> +	if (!debug)
>> +		return -ENODEV;
>> +
>> +	if (*ppos)
>> +		return 0;
>> +
>> +	/* Leave room for termination char */
>> +	len = min_t(size_t, count, SZ_8 - 1);
>> +	if (copy_from_user(buf, user_buff, len))
>> +		goto end;
>> +
>> +	buf[len] = '\0';
>> +
>> +	if (kstrtoint(buf, 10, &hpd) != 0)
>> +		goto end;
>> +
>> +	if (debug->usbpd && debug->usbpd->connect)
>> +		debug->usbpd->connect(debug->usbpd, hpd);
>> +
>> +end:
>> +	return -len;
>> +}
>> +
>> +static ssize_t dp_debug_write_edid_modes(struct file *file,
>> +		const char __user *user_buff, size_t count, loff_t *ppos)
>> +{
>> +	struct dp_debug_private *debug = file->private_data;
>> +	char buf[SZ_32];
>> +	size_t len = 0;
>> +	int hdisplay = 0, vdisplay = 0, vrefresh = 0;
>> +
>> +	if (!debug)
>> +		return -ENODEV;
>> +
>> +	if (*ppos)
>> +		goto end;
>> +
>> +	/* Leave room for termination char */
>> +	len = min_t(size_t, count, SZ_32 - 1);
>> +	if (copy_from_user(buf, user_buff, len))
>> +		goto clear;
>> +
>> +	buf[len] = '\0';
>> +
>> +	if (sscanf(buf, "%d %d %d", &hdisplay, &vdisplay, &vrefresh) != 3)
>> +		goto clear;
>> +
>> +	if (!hdisplay || !vdisplay || !vrefresh)
>> +		goto clear;
>> +
>> +	debug->dp_debug.debug_en = true;
>> +	debug->dp_debug.hdisplay = hdisplay;
>> +	debug->dp_debug.vdisplay = vdisplay;
>> +	debug->dp_debug.vrefresh = vrefresh;
>> +	goto end;
>> +clear:
>> +	pr_debug("clearing debug modes\n");
>> +	debug->dp_debug.debug_en = false;
>> +end:
>> +	return len;
>> +}
>> +
>> +static ssize_t dp_debug_read_connected(struct file *file,
>> +		char __user *user_buff, size_t count, loff_t *ppos)
>> +{
>> +	struct dp_debug_private *debug = file->private_data;
>> +	char buf[SZ_8];
>> +	u32 len = 0;
>> +
>> +	if (!debug)
>> +		return -ENODEV;
>> +
>> +	if (*ppos)
>> +		return 0;
>> +
>> +	if (!debug->usbpd)
>> +		return -ENODEV;
>> +
>> +	len += snprintf(buf, SZ_8, "%d\n", debug->usbpd->hpd_high);
>> +
>> +	if (copy_to_user(user_buff, buf, len))
>> +		return -EFAULT;
>> +
>> +	*ppos += len;
>> +	return len;
>> +}
>> +
>> +static ssize_t dp_debug_read_edid_modes(struct file *file,
>> +		char __user *user_buff, size_t count, loff_t *ppos)
>> +{
>> +	struct dp_debug_private *debug = file->private_data;
>> +	char *buf;
>> +	u32 len = 0;
>> +	int rc = 0;
>> +	struct drm_connector *connector;
>> +	struct drm_display_mode *mode;
>> +
>> +	if (!debug) {
>> +		pr_err("invalid data\n");
>> +		rc = -ENODEV;
>> +		goto error;
>> +	}
>> +
>> +	connector = *debug->connector;
>> +
>> +	if (!connector) {
>> +		pr_err("connector is NULL\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	if (*ppos)
>> +		goto error;
>> +
>> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
>> +	if (!buf) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	list_for_each_entry(mode, &connector->modes, head) {
>> +		len += snprintf(buf + len, SZ_4K - len,
>> +		"%s %d %d %d %d %d %d %d %d %d 0x%x\n",
>> +		mode->name, mode->vrefresh, mode->hdisplay,
>> +		mode->hsync_start, mode->hsync_end, mode->htotal,
>> +		mode->vdisplay, mode->vsync_start, mode->vsync_end,
>> +		mode->vtotal, mode->flags);
>> +	}
>> +
>> +	if (copy_to_user(user_buff, buf, len)) {
>> +		kfree(buf);
>> +		rc = -EFAULT;
>> +		goto error;
>> +	}
>> +
>> +	*ppos += len;
>> +	kfree(buf);
>> +
>> +	return len;
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_debug_check_buffer_overflow(int rc, int *max_size, int 
>> *len)
>> +{
>> +	if (rc >= *max_size) {
>> +		pr_err("buffer overflow\n");
>> +		return -EINVAL;
>> +	}
>> +	*len += rc;
>> +	*max_size = SZ_4K - *len;
>> +
>> +	return 0;
>> +}
>> +
>> +static ssize_t dp_debug_read_info(struct file *file, char __user 
>> *user_buff,
>> +		size_t count, loff_t *ppos)
>> +{
>> +	struct dp_debug_private *debug = file->private_data;
>> +	char *buf;
>> +	u32 len = 0, rc = 0;
>> +	u64 lclk = 0;
>> +	u32 max_size = SZ_4K;
>> +
>> +	if (!debug)
>> +		return -ENODEV;
>> +
>> +	if (*ppos)
>> +		return 0;
>> +
>> +	buf = kzalloc(SZ_4K, GFP_KERNEL);
>> +	if (!buf)
>> +		return -ENOMEM;
>> +
>> +	rc = snprintf(buf + len, max_size, "\tname = %s\n", DEBUG_NAME);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\tdp_panel\n\t\tmax_pclk_khz = %d\n",
>> +		debug->panel->max_pclk_khz);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\tdrm_dp_link\n\t\trate = %u\n",
>> +		debug->panel->link_info.rate);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tnum_lanes = %u\n",
>> +		debug->panel->link_info.num_lanes);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tcapabilities = %lu\n",
>> +		debug->panel->link_info.capabilities);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\tdp_panel_info:\n\t\tactive = %dx%d\n",
>> +		debug->panel->pinfo.h_active,
>> +		debug->panel->pinfo.v_active);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tback_porch = %dx%d\n",
>> +		debug->panel->pinfo.h_back_porch,
>> +		debug->panel->pinfo.v_back_porch);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tfront_porch = %dx%d\n",
>> +		debug->panel->pinfo.h_front_porch,
>> +		debug->panel->pinfo.v_front_porch);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tsync_width = %dx%d\n",
>> +		debug->panel->pinfo.h_sync_width,
>> +		debug->panel->pinfo.v_sync_width);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tactive_low = %dx%d\n",
>> +		debug->panel->pinfo.h_active_low,
>> +		debug->panel->pinfo.v_active_low);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\th_skew = %d\n",
>> +		debug->panel->pinfo.h_skew);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\trefresh rate = %d\n",
>> +		debug->panel->pinfo.refresh_rate);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tpixel clock khz = %d\n",
>> +		debug->panel->pinfo.pixel_clk_khz);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tbpp = %d\n",
>> +		debug->panel->pinfo.bpp);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	/* Link Information */
>> +	rc = snprintf(buf + len, max_size,
>> +		"\tdp_link:\n\t\ttest_requested = %d\n",
>> +		debug->link->sink_request);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tlane_count = %d\n", debug->link->link_params.lane_count);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tbw_code = %d\n", debug->link->link_params.bw_code);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	lclk = drm_dp_bw_code_to_link_rate(
>> +			debug->link->link_params.bw_code) * 1000;
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tlclk = %lld\n", lclk);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tv_level = %d\n", debug->link->phy_params.v_level);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	rc = snprintf(buf + len, max_size,
>> +		"\t\tp_level = %d\n", debug->link->phy_params.p_level);
>> +	if (dp_debug_check_buffer_overflow(rc, &max_size, &len))
>> +		goto error;
>> +
>> +	if (copy_to_user(user_buff, buf, len))
>> +		goto error;
>> +
>> +	*ppos += len;
>> +
>> +	kfree(buf);
>> +	return len;
>> +error:
>> +	kfree(buf);
>> +	return -EINVAL;
>> +}
>> +
>> +static const struct file_operations dp_debug_fops = {
>> +	.open = simple_open,
>> +	.read = dp_debug_read_info,
>> +};
>> +
>> +static const struct file_operations edid_modes_fops = {
>> +	.open = simple_open,
>> +	.read = dp_debug_read_edid_modes,
>> +	.write = dp_debug_write_edid_modes,
>> +};
>> +
>> +static const struct file_operations hpd_fops = {
>> +	.open = simple_open,
>> +	.write = dp_debug_write_hpd,
>> +};
>> +
>> +static const struct file_operations connected_fops = {
>> +	.open = simple_open,
>> +	.read = dp_debug_read_connected,
>> +};
> 
> edid, hpd, and connected can all be deleted. They're provided by core.
> 
> AFAICT, you can also infer the information from dp_debug, so I think 
> you can
> just drop this entire file.
> 
>> +
>> +static int dp_debug_init(struct dp_debug *dp_debug)
>> +{
>> +	int rc = 0;
>> +	struct dp_debug_private *debug = container_of(dp_debug,
>> +		struct dp_debug_private, dp_debug);
>> +	struct dentry *dir, *file, *edid_modes;
>> +	struct dentry *hpd, *connected;
>> +
>> +	dir = debugfs_create_dir(DEBUG_NAME, NULL);
>> +	if (IS_ERR_OR_NULL(dir)) {
>> +		rc = PTR_ERR(dir);
>> +		pr_err("[%s] debugfs create dir failed, rc = %d\n",
>> +		       DEBUG_NAME, rc);
>> +		goto error;
>> +	}
>> +
>> +	file = debugfs_create_file("dp_debug", 0444, dir,
>> +				debug, &dp_debug_fops);
>> +	if (IS_ERR_OR_NULL(file)) {
>> +		rc = PTR_ERR(file);
>> +		pr_err("[%s] debugfs create file failed, rc=%d\n",
>> +		       DEBUG_NAME, rc);
>> +		goto error_remove_dir;
>> +	}
>> +
>> +	edid_modes = debugfs_create_file("edid_modes", 0644, dir,
>> +					debug, &edid_modes_fops);
>> +	if (IS_ERR_OR_NULL(edid_modes)) {
>> +		rc = PTR_ERR(edid_modes);
>> +		pr_err("[%s] debugfs create edid_modes failed, rc=%d\n",
>> +		       DEBUG_NAME, rc);
>> +		goto error_remove_dir;
>> +	}
>> +
>> +	hpd = debugfs_create_file("hpd", 0644, dir,
>> +					debug, &hpd_fops);
>> +	if (IS_ERR_OR_NULL(hpd)) {
>> +		rc = PTR_ERR(hpd);
>> +		pr_err("[%s] debugfs hpd failed, rc=%d\n",
>> +			DEBUG_NAME, rc);
>> +		goto error_remove_dir;
>> +	}
>> +
>> +	connected = debugfs_create_file("connected", 0444, dir,
>> +					debug, &connected_fops);
>> +	if (IS_ERR_OR_NULL(connected)) {
>> +		rc = PTR_ERR(connected);
>> +		pr_err("[%s] debugfs connected failed, rc=%d\n",
>> +			DEBUG_NAME, rc);
>> +		goto error_remove_dir;
>> +	}
>> +
>> +	debug->root = dir;
>> +	return rc;
>> +error_remove_dir:
>> +	debugfs_remove(dir);
>> +error:
>> +	return rc;
>> +}
>> +
>> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel 
>> *panel,
>> +			struct dp_usbpd *usbpd, struct dp_link *link,
>> +			struct drm_connector **connector)
>> +{
>> +	int rc = 0;
>> +	struct dp_debug_private *debug;
>> +	struct dp_debug *dp_debug;
>> +
>> +	if (!dev || !panel || !usbpd || !link) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	debug = devm_kzalloc(dev, sizeof(*debug), GFP_KERNEL);
>> +	if (!debug) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	debug->dp_debug.debug_en = false;
>> +	debug->usbpd = usbpd;
>> +	debug->link = link;
>> +	debug->panel = panel;
>> +	debug->dev = dev;
>> +	debug->connector = connector;
>> +
>> +	dp_debug = &debug->dp_debug;
>> +	dp_debug->vdisplay = 0;
>> +	dp_debug->hdisplay = 0;
>> +	dp_debug->vrefresh = 0;
>> +
>> +	rc = dp_debug_init(dp_debug);
>> +	if (rc) {
>> +		devm_kfree(dev, debug);
>> +		goto error;
>> +	}
>> +
>> +	return dp_debug;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +static int dp_debug_deinit(struct dp_debug *dp_debug)
>> +{
>> +	struct dp_debug_private *debug;
>> +
>> +	if (!dp_debug)
>> +		return -EINVAL;
>> +
>> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
>> +
>> +	debugfs_remove_recursive(debug->root);
>> +
>> +	return 0;
>> +}
>> +
>> +void dp_debug_put(struct dp_debug *dp_debug)
>> +{
>> +	struct dp_debug_private *debug;
>> +
>> +	if (!dp_debug)
>> +		return;
>> +
>> +	debug = container_of(dp_debug, struct dp_debug_private, dp_debug);
>> +
>> +	dp_debug_deinit(dp_debug);
>> +
>> +	devm_kfree(debug->dev, debug);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.h 
>> b/drivers/gpu/drm/msm/dp/dp_debug.h
>> new file mode 100644
>> index 0000000..a6480e1
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_debug.h
>> @@ -0,0 +1,81 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_DEBUG_H_
>> +#define _DP_DEBUG_H_
>> +
>> +#include "dp_panel.h"
>> +#include "dp_link.h"
>> +#include "dp_extcon.h"
>> +
>> +/**
>> + * struct dp_debug
>> + * @debug_en: specifies whether debug mode enabled
>> + * @vdisplay: used to filter out vdisplay value
>> + * @hdisplay: used to filter out hdisplay value
>> + * @vrefresh: used to filter out vrefresh value
>> + * @tpg_state: specifies whether tpg feature is enabled
>> + */
>> +struct dp_debug {
>> +	bool debug_en;
>> +	int aspect_ratio;
>> +	int vdisplay;
>> +	int hdisplay;
>> +	int vrefresh;
>> +};
>> +
>> +#if defined(CONFIG_DEBUG_FS)
>> +
>> +/**
>> + * dp_debug_get() - configure and get the DisplayPlot debug module 
>> data
>> + *
>> + * @dev: device instance of the caller
>> + * @panel: instance of panel module
>> + * @usbpd: instance of usbpd module
>> + * @link: instance of link module
>> + * @connector: double pointer to display connector
>> + * return: pointer to allocated debug module data
>> + *
>> + * This function sets up the debug module and provides a way
>> + * for debugfs input to be communicated with existing modules
>> + */
>> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel 
>> *panel,
>> +			struct dp_usbpd *usbpd, struct dp_link *link,
>> +			struct drm_connector **connector);
>> +/**
>> + * dp_debug_put()
>> + *
>> + * Cleans up dp_debug instance
>> + *
>> + * @dp_debug: instance of dp_debug
>> + */
>> +void dp_debug_put(struct dp_debug *dp_debug);
>> +
>> +#else
>> +
>> +static inline
>> +struct dp_debug *dp_debug_get(struct device *dev, struct dp_panel 
>> *panel,
>> +			struct dp_usbpd *usbpd, struct dp_link *link,
>> +			struct drm_connector **connector)
>> +{
>> +	return ERR_PTR(-EINVAL);
>> +}
>> +
>> +static inline void dp_debug_put(struct dp_debug *dp_debug)
>> +{
>> +}
>> +
>> +#endif /* defined(CONFIG_DEBUG_FS) */
> 
> Drop this too
> 
>> +
>> +#endif /* _DP_DEBUG_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c 
>> b/drivers/gpu/drm/msm/dp/dp_display.c
>> new file mode 100644
>> index 0000000..8c98399
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
>> @@ -0,0 +1,977 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/module.h>
>> +#include <linux/slab.h>
>> +#include <linux/uaccess.h>
>> +#include <linux/debugfs.h>
>> +#include <linux/component.h>
>> +#include <linux/of_irq.h>
>> +
>> +#include "msm_drv.h"
>> +#include "dp_extcon.h"
>> +#include "dp_parser.h"
>> +#include "dp_power.h"
>> +#include "dp_catalog.h"
>> +#include "dp_aux.h"
>> +#include "dp_link.h"
>> +#include "dp_panel.h"
>> +#include "dp_ctrl.h"
>> +#include "dp_display.h"
>> +#include "dp_drm.h"
>> +#include "dp_debug.h"
>> +
>> +static struct msm_dp *g_dp_display;
>> +#define HPD_STRING_SIZE 30
>> +
>> +struct dp_display_private {
>> +	char *name;
>> +	int irq;
>> +
>> +	/* state variables */
>> +	bool core_initialized;
>> +	bool power_on;
>> +	bool hpd_irq_on;
>> +	bool audio_supported;
>> +
>> +	struct platform_device *pdev;
>> +	struct dentry *root;
>> +	struct completion notification_comp;
>> +
>> +	struct dp_usbpd   *usbpd;
>> +	struct dp_parser  *parser;
>> +	struct dp_power   *power;
>> +	struct dp_catalog *catalog;
>> +	struct dp_aux     *aux;
>> +	struct dp_link    *link;
>> +	struct dp_panel   *panel;
>> +	struct dp_ctrl    *ctrl;
>> +	struct dp_debug   *debug;
>> +
>> +	struct dp_usbpd_cb usbpd_cb;
>> +	struct dp_display_mode mode;
>> +	struct msm_dp dp_display;
>> +
>> +};
>> +
>> +static const struct of_device_id dp_dt_match[] = {
>> +	{.compatible = "qcom,dp-display"},
>> +	{}
>> +};
>> +
>> +static irqreturn_t dp_display_irq(int irq, void *dev_id)
>> +{
>> +	struct dp_display_private *dp = dev_id;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid data\n");
>> +		return IRQ_NONE;
>> +	}
>> +
>> +	/* DP controller isr */
>> +	dp->ctrl->isr(dp->ctrl);
>> +
>> +	/* DP aux isr */
>> +	dp->aux->isr(dp->aux);
>> +
>> +	return IRQ_HANDLED;
>> +}
>> +
>> +static int dp_display_bind(struct device *dev, struct device *master,
>> +			   void *data)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +	struct drm_device *drm;
>> +	struct msm_drm_private *priv;
>> +	struct platform_device *pdev = to_platform_device(dev);
>> +
>> +	if (!dev || !pdev || !master) {
>> +		pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
>> +				dev, pdev, master);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	drm = dev_get_drvdata(master);
>> +	dp = platform_get_drvdata(pdev);
>> +	if (!drm || !dp) {
>> +		pr_err("invalid param(s), drm %pK, dp %pK\n",
>> +				drm, dp);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp->dp_display.drm_dev = drm;
>> +	priv = drm->dev_private;
>> +	priv->dp = &(dp->dp_display);
>> +
>> +	rc = dp->parser->parse(dp->parser);
>> +	if (rc) {
>> +		pr_err("device tree parsing failed\n");
>> +		goto end;
>> +	}
>> +
>> +	rc = dp->aux->drm_aux_register(dp->aux);
>> +	if (rc) {
>> +		pr_err("DRM DP AUX register failed\n");
>> +		goto end;
>> +	}
>> +
>> +	rc = dp->power->power_client_init(dp->power);
>> +	if (rc) {
>> +		pr_err("Power client create failed\n");
>> +		goto end;
>> +	}
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_unbind(struct device *dev, struct device 
>> *master,
>> +			      void *data)
>> +{
>> +	struct dp_display_private *dp;
>> +	struct platform_device *pdev = to_platform_device(dev);
>> +	struct drm_device *drm = dev_get_drvdata(master);
>> +	struct msm_drm_private *priv = drm->dev_private;
>> +
>> +	if (!dev || !pdev) {
>> +		pr_err("invalid param(s)\n");
>> +		return;
>> +	}
>> +
>> +	dp = platform_get_drvdata(pdev);
>> +	if (!dp) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	(void)dp->power->power_client_deinit(dp->power);
>> +	(void)dp->aux->drm_aux_deregister(dp->aux);
>> +	priv->dp = NULL;
>> +}
>> +
>> +static const struct component_ops dp_display_comp_ops = {
>> +	.bind = dp_display_bind,
>> +	.unbind = dp_display_unbind,
>> +};
>> +
>> +static bool dp_display_is_ds_bridge(struct dp_panel *panel)
>> +{
>> +	return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
>> +		DP_DWN_STRM_PORT_PRESENT);
>> +}
>> +
>> +static bool dp_display_is_sink_count_zero(struct dp_display_private 
>> *dp)
>> +{
>> +	return dp_display_is_ds_bridge(dp->panel) &&
>> +		(dp->link->sink_count.count == 0);
>> +}
>> +
>> +static void dp_display_send_hpd_event(struct msm_dp *dp_display)
>> +{
>> +	struct dp_display_private *dp;
>> +	struct drm_connector *connector;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	connector = dp->dp_display.connector;
>> +	drm_helper_hpd_irq_event(connector->dev);
>> +}
>> +
>> +static int dp_display_send_hpd_notification(struct dp_display_private 
>> *dp,
>> +					    bool hpd)
> 
> This function is called from a few different threads with no locking. 
> It seems
> like there's good opportunity for is_connected and notification_comp to 
> get out
> of sync.
> 
> Additionally, is_connected is set to true before the function returns 
> (and
> enable has been completed). So is that going to cause problems when we 
> call
> detect/get_modes where is_connected == true and the hw is not up?
> 
> Perhaps I'm misreading this function, but it seems like the plan is to 
> block
> until userspace has been notified and does a full modeset (ie: enable)? 
> If that
> is the case, we usually don't want to have the hardware lit up until 
> it's
> actually going to be used. In these cases, we'll wrap get_modes in
> enable/disable (with proper locking), and wait for modeset to leave it 
> on.
> 
>> +{
>> +	if ((hpd && dp->dp_display.is_connected) ||
>> +			(!hpd && !dp->dp_display.is_connected)) {
>> +		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
>> +		return 0;
>> +	}
>> +
>> +	/* reset video pattern flag on disconnect */
>> +	if (!hpd)
>> +		dp->panel->video_test = false;
>> +
>> +	dp->dp_display.is_connected = hpd;
>> +	reinit_completion(&dp->notification_comp);
>> +	dp_display_send_hpd_event(&dp->dp_display);
>> +
>> +	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
>> +		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
>> +		return -EINVAL;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_display_process_hpd_high(struct dp_display_private *dp)
>> +{
>> +	int rc = 0;
>> +	struct edid *edid;
>> +
>> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
>> +
>> +	if (dp->link->psm_enabled)
>> +		goto notify;
>> +
>> +	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);
>> +	if (rc)
>> +		goto notify;
>> +
>> +	dp->link->process_request(dp->link);
>> +
>> +	if (dp_display_is_sink_count_zero(dp)) {
>> +		pr_debug("no downstream devices connected\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	edid = dp->panel->edid;
>> +
>> +	dp->audio_supported = drm_detect_monitor_audio(edid);
>> +
>> +	dp->panel->handle_sink_request(dp->panel);
>> +
>> +	dp->dp_display.max_pclk_khz = dp->parser->max_pclk_khz;
>> +notify:
>> +	dp_display_send_hpd_notification(dp, true);
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_host_init(struct dp_display_private *dp)
>> +{
>> +	bool flip = false;
>> +
>> +	if (dp->core_initialized) {
>> +		pr_debug("DP core already initialized\n");
>> +		return;
>> +	}
>> +
>> +	if (dp->usbpd->orientation == ORIENTATION_CC2)
>> +		flip = true;
>> +
>> +	dp->power->init(dp->power, flip);
>> +	dp->ctrl->init(dp->ctrl, flip);
>> +	enable_irq(dp->irq);
>> +	dp->core_initialized = true;
>> +}
>> +
>> +static void dp_display_host_deinit(struct dp_display_private *dp)
>> +{
>> +	if (!dp->core_initialized) {
>> +		pr_debug("DP core already off\n");
>> +		return;
>> +	}
>> +
>> +	dp->ctrl->deinit(dp->ctrl);
>> +	dp->power->deinit(dp->power);
>> +	disable_irq(dp->irq);
>> +	dp->core_initialized = false;
>> +}
>> +
>> +static void dp_display_process_hpd_low(struct dp_display_private *dp)
>> +{
>> +	/* cancel any pending request */
>> +	dp->ctrl->abort(dp->ctrl);
>> +
>> +	dp_display_send_hpd_notification(dp, false);
>> +
>> +	dp->aux->deinit(dp->aux);
>> +}
>> +
>> +static int dp_display_usbpd_configure_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		rc = -ENODEV;
>> +		goto end;
>> +	}
>> +
>> +	dp_display_host_init(dp);
>> +
>> +	if (dp->usbpd->hpd_high)
>> +		dp_display_process_hpd_high(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_clean(struct dp_display_private *dp)
>> +{
>> +	dp->ctrl->push_idle(dp->ctrl);
>> +	dp->ctrl->off(dp->ctrl);
>> +}
>> +
>> +static int dp_display_usbpd_disconnect_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		rc = -ENODEV;
>> +		goto end;
>> +	}
>> +
>> +	/* cancel any pending request */
>> +	dp->ctrl->abort(dp->ctrl);
>> +
>> +	rc = dp_display_send_hpd_notification(dp, false);
>> +
>> +	/* if cable is disconnected, reset psm_enabled flag */
>> +	if (!dp->usbpd->alt_mode_cfg_done)
>> +		dp->link->psm_enabled = false;
>> +
>> +	if ((rc < 0) && dp->power_on)
>> +		dp_display_clean(dp);
>> +
>> +	dp_display_host_deinit(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_handle_video_request(struct dp_display_private 
>> *dp)
>> +{
>> +	if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
>> +		/* force disconnect followed by connect */
>> +		dp->usbpd->connect(dp->usbpd, false);
>> +		dp->panel->video_test = true;
>> +		dp->usbpd->connect(dp->usbpd, true);
>> +		dp->link->send_test_response(dp->link);
>> +	}
>> +}
>> +
>> +static int dp_display_handle_hpd_irq(struct dp_display_private *dp)
>> +{
>> +	if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) {
>> +		dp_display_send_hpd_notification(dp, false);
>> +
>> +		if (dp_display_is_sink_count_zero(dp)) {
>> +			pr_debug("sink count is zero, nothing to do\n");
>> +			return 0;
>> +		}
>> +
>> +		return dp_display_process_hpd_high(dp);
>> +	}
>> +
>> +	dp->ctrl->handle_sink_request(dp->ctrl);
>> +
>> +	dp_display_handle_video_request(dp);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_display_usbpd_attention_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	if (dp->usbpd->hpd_irq) {
>> +		dp->hpd_irq_on = true;
>> +
>> +		rc = dp->link->process_request(dp->link);
>> +		/* check for any test request issued by sink */
>> +		if (!rc)
>> +			dp_display_handle_hpd_irq(dp);
>> +
>> +		dp->hpd_irq_on = false;
>> +		goto end;
>> +	}
>> +
>> +	if (!dp->usbpd->hpd_high) {
>> +		dp_display_process_hpd_low(dp);
>> +		goto end;
>> +	}
>> +
>> +	if (dp->usbpd->alt_mode_cfg_done)
>> +		dp_display_process_hpd_high(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_deinit_sub_modules(struct dp_display_private 
>> *dp)
>> +{
>> +	dp_ctrl_put(dp->ctrl);
>> +	dp_link_put(dp->link);
>> +	dp_panel_put(dp->panel);
>> +	dp_aux_put(dp->aux);
>> +	dp_power_put(dp->power);
>> +	dp_catalog_put(dp->catalog);
>> +	dp_parser_put(dp->parser);
>> +	dp_debug_put(dp->debug);
>> +}
>> +
>> +static int dp_init_sub_modules(struct dp_display_private *dp)
>> +{
>> +	int rc = 0;
>> +	struct device *dev = &dp->pdev->dev;
>> +	struct dp_usbpd_cb *cb = &dp->usbpd_cb;
>> +	struct dp_ctrl_in ctrl_in = {
>> +		.dev = dev,
>> +	};
>> +	struct dp_panel_in panel_in = {
>> +		.dev = dev,
>> +	};
>> +
>> +	/* Callback APIs used for cable status change event */
>> +	cb->configure  = dp_display_usbpd_configure_cb;
>> +	cb->disconnect = dp_display_usbpd_disconnect_cb;
>> +	cb->attention  = dp_display_usbpd_attention_cb;
>> +
>> +	dp->parser = dp_parser_get(dp->pdev);
>> +	if (IS_ERR(dp->parser)) {
>> +		rc = PTR_ERR(dp->parser);
>> +		pr_err("failed to initialize parser, rc = %d\n", rc);
>> +		dp->parser = NULL;
>> +		goto error_parser;
>> +	}
>> +
>> +	dp->catalog = dp_catalog_get(dev, &dp->parser->io);
>> +	if (IS_ERR(dp->catalog)) {
>> +		rc = PTR_ERR(dp->catalog);
>> +		pr_err("failed to initialize catalog, rc = %d\n", rc);
>> +		dp->catalog = NULL;
>> +		goto error_catalog;
>> +	}
>> +
>> +	dp->power = dp_power_get(dp->parser);
>> +	if (IS_ERR(dp->power)) {
>> +		rc = PTR_ERR(dp->power);
>> +		pr_err("failed to initialize power, rc = %d\n", rc);
>> +		dp->power = NULL;
>> +		goto error_power;
>> +	}
>> +
>> +	dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser->aux_cfg);
>> +	if (IS_ERR(dp->aux)) {
>> +		rc = PTR_ERR(dp->aux);
>> +		pr_err("failed to initialize aux, rc = %d\n", rc);
>> +		dp->aux = NULL;
>> +		goto error_aux;
>> +	}
>> +
>> +	dp->link = dp_link_get(dev, dp->aux);
>> +	if (IS_ERR(dp->link)) {
>> +		rc = PTR_ERR(dp->link);
>> +		pr_err("failed to initialize link, rc = %d\n", rc);
>> +		dp->link = NULL;
>> +		goto error_link;
>> +	}
>> +
>> +	panel_in.aux = dp->aux;
>> +	panel_in.catalog = &dp->catalog->panel;
>> +	panel_in.link = dp->link;
>> +
>> +	dp->panel = dp_panel_get(&panel_in);
>> +	if (IS_ERR(dp->panel)) {
>> +		rc = PTR_ERR(dp->panel);
>> +		pr_err("failed to initialize panel, rc = %d\n", rc);
>> +		dp->panel = NULL;
>> +		goto error_panel;
>> +	}
>> +
>> +	ctrl_in.link = dp->link;
>> +	ctrl_in.panel = dp->panel;
>> +	ctrl_in.aux = dp->aux;
>> +	ctrl_in.power = dp->power;
>> +	ctrl_in.catalog = &dp->catalog->ctrl;
>> +	ctrl_in.parser = dp->parser;
>> +
>> +	dp->ctrl = dp_ctrl_get(&ctrl_in);
>> +	if (IS_ERR(dp->ctrl)) {
>> +		rc = PTR_ERR(dp->ctrl);
>> +		pr_err("failed to initialize ctrl, rc = %d\n", rc);
>> +		dp->ctrl = NULL;
>> +		goto error_ctrl;
>> +	}
>> +
>> +	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
>> +				dp->link, &dp->dp_display.connector);
>> +	if (IS_ERR(dp->debug)) {
>> +		rc = PTR_ERR(dp->debug);
>> +		pr_err("failed to initialize debug, rc = %d\n", rc);
>> +		dp->debug = NULL;
>> +		goto error_debug;
>> +	}
>> +
>> +	return rc;
>> +error_debug:
>> +	dp_ctrl_put(dp->ctrl);
>> +error_ctrl:
>> +	dp_panel_put(dp->panel);
>> +error_panel:
>> +	dp_link_put(dp->link);
>> +error_link:
>> +	dp_aux_put(dp->aux);
>> +error_aux:
>> +	dp_power_put(dp->power);
>> +error_power:
>> +	dp_catalog_put(dp->catalog);
>> +error_catalog:
>> +	dp_parser_put(dp->parser);
>> +error_parser:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_set_mode(struct msm_dp *dp_display,
>> +			       struct dp_display_mode *mode)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	dp->panel->pinfo = mode->timing;
>> +	dp->panel->init_info(dp->panel);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_prepare(struct msm_dp *dp)
>> +{
>> +	return 0;
>> +}
>> +
>> +static int dp_display_enable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp->power_on) {
>> +		pr_debug("Link already setup, return\n");
>> +		return 0;
>> +	}
>> +
>> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
>> +
>> +	rc = dp->ctrl->on(dp->ctrl);
>> +	if (!rc)
>> +		dp->power_on = true;
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_post_enable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	complete_all(&dp->notification_comp);
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_pre_disable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp->usbpd->alt_mode_cfg_done && (dp->usbpd->hpd_high ||
>> +		dp->usbpd->forced_disconnect))
>> +		dp->link->psm_config(dp->link, &dp->panel->link_info, true);
>> +
>> +	dp->ctrl->push_idle(dp->ctrl);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_disable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (!dp->power_on || !dp->core_initialized)
>> +		goto error;
>> +
>> +	dp->ctrl->off(dp->ctrl);
>> +
>> +	dp->power_on = false;
>> +
>> +	complete_all(&dp->notification_comp);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_request_irq(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
>> +	if (dp->irq < 0) {
>> +		rc = dp->irq;
>> +		pr_err("failed to get irq: %d\n", rc);
>> +		return rc;
>> +	}
>> +
>> +	rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq,
>> +		IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
>> +	if (rc < 0) {
>> +		pr_err("failed to request IRQ%u: %d\n",
>> +				dp->irq, rc);
>> +		return rc;
>> +	}
>> +	disable_irq(dp->irq);
>> +
>> +	return 0;
>> +}
>> +
>> +static struct dp_debug *dp_get_debug(struct msm_dp *dp_display)
>> +{
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return ERR_PTR(-EINVAL);
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	return dp->debug;
>> +}
>> +
>> +static int dp_display_unprepare(struct msm_dp *dp)
>> +{
>> +	return 0;
>> +}
>> +
>> +static int dp_display_validate_mode(struct msm_dp *dp, u32 
>> mode_pclk_khz)
>> +{
>> +	const u32 num_components = 3, default_bpp = 24;
>> +	struct dp_display_private *dp_display;
>> +	struct drm_dp_link *link_info;
>> +	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
>> +
>> +	if (!dp || !mode_pclk_khz || !dp->connector) {
>> +		pr_err("invalid params\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +	link_info = &dp_display->panel->link_info;
>> +
>> +	mode_bpp = dp->connector->display_info.bpc * num_components;
>> +	if (!mode_bpp)
>> +		mode_bpp = default_bpp;
>> +
>> +	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,
>> +			mode_bpp, mode_pclk_khz);
>> +
>> +	mode_rate_khz = mode_pclk_khz * mode_bpp;
>> +	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
>> +
>> +	if (mode_rate_khz > supported_rate_khz)
>> +		return MODE_BAD;
>> +
>> +	return MODE_OK;
>> +}
>> +
>> +static int dp_display_get_modes(struct msm_dp *dp,
>> +				struct dp_display_mode *dp_mode)
>> +{
>> +	struct dp_display_private *dp_display;
>> +	int ret = 0;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	ret = dp_display->panel->get_modes(dp_display->panel,
>> +		dp->connector, dp_mode);
>> +	if (dp_mode->timing.pixel_clk_khz)
>> +		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;
>> +	return ret;
>> +}
>> +
>> +static bool dp_display_check_video_test(struct msm_dp *dp)
>> +{
>> +	struct dp_display_private *dp_display;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return false;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp_display->panel->video_test)
>> +		return true;
>> +
>> +	return false;
>> +}
>> +
>> +static int dp_display_get_test_bpp(struct msm_dp *dp)
>> +{
>> +	struct dp_display_private *dp_display;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	return dp_link_bit_depth_to_bpp(
>> +		dp_display->link->test_video.test_bit_depth);
>> +}
>> +
>> +static int dp_display_probe(struct platform_device *pdev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!pdev || !pdev->dev.of_node) {
>> +		pr_err("pdev not found\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
>> +	if (!dp)
>> +		return -ENOMEM;
>> +
>> +	init_completion(&dp->notification_comp);
>> +
>> +	dp->pdev = pdev;
>> +	dp->name = "drm_dp";
>> +
>> +	rc = dp_init_sub_modules(dp);
>> +	if (rc) {
>> +		pr_err("init sub module failed\n");
>> +		devm_kfree(&pdev->dev, dp);
>> +		return -EPROBE_DEFER;
>> +	}
>> +
>> +	platform_set_drvdata(pdev, dp);
>> +
>> +	g_dp_display = &dp->dp_display;
>> +
>> +	g_dp_display->enable        = dp_display_enable;
>> +	g_dp_display->post_enable   = dp_display_post_enable;
>> +	g_dp_display->pre_disable   = dp_display_pre_disable;
>> +	g_dp_display->disable       = dp_display_disable;
>> +	g_dp_display->set_mode      = dp_display_set_mode;
>> +	g_dp_display->validate_mode = dp_display_validate_mode;
>> +	g_dp_display->get_modes     = dp_display_get_modes;
>> +	g_dp_display->prepare       = dp_display_prepare;
>> +	g_dp_display->unprepare     = dp_display_unprepare;
>> +	g_dp_display->request_irq   = dp_request_irq;
>> +	g_dp_display->get_debug     = dp_get_debug;
>> +	g_dp_display->send_hpd_event    = dp_display_send_hpd_event;
>> +	g_dp_display->is_video_test = dp_display_check_video_test;
>> +	g_dp_display->get_test_bpp = dp_display_get_test_bpp;
>> +
>> +	rc = component_add(&pdev->dev, &dp_display_comp_ops);
>> +	if (rc) {
>> +		pr_err("component add failed, rc=%d\n", rc);
>> +		dp_display_deinit_sub_modules(dp);
>> +		devm_kfree(&pdev->dev, dp);
>> +	}
>> +
>> +	return rc;
>> +}
>> +
>> +int dp_display_get_displays(void **displays, int count)
>> +{
>> +	if (!displays) {
>> +		pr_err("invalid data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (count != 1) {
>> +		pr_err("invalid number of displays\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	displays[0] = g_dp_display;
>> +	return count;
>> +}
>> +
>> +int dp_display_get_num_of_displays(void)
>> +{
>> +	return 1;
>> +}
> 
> These 2 functions are never used, and as such g_dp_display is never 
> used.
> AFAICT, the callback hooks linked from g_dp_display also aren't called 
> from
> anywhere else. So can you just dump these functions, the struct, and 
> all of the
> unused callback hooks?
> 
>> +
>> +static int dp_display_remove(struct platform_device *pdev)
>> +{
>> +	struct dp_display_private *dp;
>> +
>> +	if (!pdev)
>> +		return -EINVAL;
>> +
>> +	dp = platform_get_drvdata(pdev);
>> +
>> +	dp_display_deinit_sub_modules(dp);
>> +
>> +	platform_set_drvdata(pdev, NULL);
>> +	devm_kfree(&pdev->dev, dp);
>> +
>> +	return 0;
>> +}
>> +
>> +static struct platform_driver dp_display_driver = {
>> +	.probe  = dp_display_probe,
>> +	.remove = dp_display_remove,
>> +	.driver = {
>> +		.name = "msm-dp-display",
>> +		.of_match_table = dp_dt_match,
>> +	},
>> +};
>> +
>> +int __init msm_dp_register(void)
>> +{
>> +	int ret;
>> +
>> +	ret = platform_driver_register(&dp_display_driver);
>> +	if (ret) {
>> +		pr_err("driver register failed");
>> +		return ret;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +void __exit msm_dp_unregister(void)
>> +{
>> +	platform_driver_unregister(&dp_display_driver);
>> +}
>> +
>> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device 
>> *dev,
>> +			struct drm_encoder *encoder)
> 
> Where is this called?

This is called from dpu_kms.c. The changes from DPU will be dependent on 
these changes.

> 
>> +{
>> +	struct msm_drm_private *priv;
>> +	int ret;
>> +
>> +	if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
>> +		return -EINVAL;
>> +
>> +	priv = dev->dev_private;
>> +	dp_display->drm_dev = dev;
>> +
>> +	ret = dp_drm_bridge_init(dp_display, encoder);
>> +	if (ret) {
>> +		dev_err(dev->dev, "failed to create dp bridge: %d\n", ret);
>> +		dp_display->bridge = NULL;
>> +		return ret;
>> +	}
>> +	dp_display->encoder = encoder;
>> +
>> +	dp_display->connector = dp_drm_connector_init(dp_display);
>> +	if (IS_ERR(dp_display->connector)) {
>> +		ret = PTR_ERR(dp_display->connector);
>> +		dev_err(dev->dev,
>> +			"failed to create dp connector: %d\n", ret);
>> +		dp_display->connector = NULL;
>> +		goto conn_fail;
>> +	}
>> +
>> +	priv->bridges[priv->num_bridges++] = dp_display->bridge;
>> +	priv->connectors[priv->num_connectors++] = dp_display->connector;
>> +	return 0;
>> +
>> +conn_fail:
>> +	if (dp_display->bridge) {
>> +		dp_drm_bridge_deinit(dp_display);
>> +		dp_display->bridge = NULL;
>> +	}
>> +	return ret;
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h 
>> b/drivers/gpu/drm/msm/dp/dp_display.h
>> new file mode 100644
>> index 0000000..ca5eae5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
>> @@ -0,0 +1,55 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_DISPLAY_H_
>> +#define _DP_DISPLAY_H_
>> +
>> +#include <drm/drmP.h>
>> +
>> +#include "dp_panel.h"
>> +
>> +struct msm_dp {
>> +	struct drm_device *drm_dev;
>> +	struct dp_bridge *dp_bridge;
>> +	struct drm_connector *connector;
>> +	struct drm_bridge *bridge;
>> +
>> +	/* the encoder we are hooked to (outside of dsi block) */
>> +	struct drm_encoder *encoder;
>> +	bool is_connected;
>> +	u32 max_pclk_khz;
>> +
>> +	int (*enable)(struct msm_dp *dp_display);
>> +	int (*post_enable)(struct msm_dp *dp_display);
>> +
>> +	int (*pre_disable)(struct msm_dp *dp_display);
>> +	int (*disable)(struct msm_dp *dp_display);
>> +
>> +	int (*set_mode)(struct msm_dp *dp_display,
>> +			struct dp_display_mode *mode);
>> +	int (*validate_mode)(struct msm_dp *dp_display, u32 mode_pclk_khz);
>> +	int (*get_modes)(struct msm_dp *dp_display,
>> +		struct dp_display_mode *dp_mode);
>> +	int (*prepare)(struct msm_dp *dp_display);
>> +	int (*unprepare)(struct msm_dp *dp_display);
>> +	int (*request_irq)(struct msm_dp *dp_display);
>> +	struct dp_debug *(*get_debug)(struct msm_dp *dp_display);
>> +	void (*send_hpd_event)(struct msm_dp *dp_display);
>> +	bool (*is_video_test)(struct msm_dp *dp_display);
>> +	int (*get_test_bpp)(struct msm_dp *dp_display);
>> +};
>> +
>> +int dp_display_get_num_of_displays(void);
>> +int dp_display_get_displays(void **displays, int count);
>> +#endif /* _DP_DISPLAY_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.c 
>> b/drivers/gpu/drm/msm/dp/dp_drm.c
>> new file mode 100644
>> index 0000000..64d6449
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_drm.c
>> @@ -0,0 +1,542 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
>> +
>> +#include <drm/drm_atomic_helper.h>
>> +#include <drm/drm_atomic.h>
>> +#include <drm/drm_crtc.h>
>> +
>> +#include "msm_drv.h"
>> +#include "msm_kms.h"
>> +//#include "dpu_connector.h"
>> +#include "dp_drm.h"
>> +#include "dp_debug.h"
>> +
>> +struct dp_connector {
>> +	struct drm_connector base;
>> +	struct msm_dp *dp_display;
>> +};
>> +#define to_dp_connector(x) container_of(x, struct dp_connector, base)
>> +#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
>> +
>> +static void convert_to_dp_mode(const struct drm_display_mode 
>> *drm_mode,
>> +			struct dp_display_mode *dp_mode, struct msm_dp *dp)
>> +{
>> +	const u32 num_components = 3;
>> +
>> +	memset(dp_mode, 0, sizeof(*dp_mode));
>> +
>> +	dp_mode->timing.h_active = drm_mode->hdisplay;
>> +	dp_mode->timing.h_back_porch = drm_mode->htotal - 
>> drm_mode->hsync_end;
>> +	dp_mode->timing.h_sync_width = drm_mode->htotal -
>> +			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);
>> +	dp_mode->timing.h_front_porch = drm_mode->hsync_start -
>> +					 drm_mode->hdisplay;
>> +	dp_mode->timing.h_skew = drm_mode->hskew;
>> +
>> +	dp_mode->timing.v_active = drm_mode->vdisplay;
>> +	dp_mode->timing.v_back_porch = drm_mode->vtotal - 
>> drm_mode->vsync_end;
>> +	dp_mode->timing.v_sync_width = drm_mode->vtotal -
>> +		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);
>> +
>> +	dp_mode->timing.v_front_porch = drm_mode->vsync_start -
>> +					 drm_mode->vdisplay;
>> +
>> +	if (dp->is_video_test(dp))
>> +		dp_mode->timing.bpp = dp->get_test_bpp(dp);
>> +	else
>> +		dp_mode->timing.bpp = dp->connector->display_info.bpc *
>> +		num_components;
>> +
>> +	if (!dp_mode->timing.bpp)
>> +		dp_mode->timing.bpp = 24;
>> +
>> +	dp_mode->timing.refresh_rate = drm_mode->vrefresh;
>> +
>> +	dp_mode->timing.pixel_clk_khz = drm_mode->clock;
>> +
>> +	dp_mode->timing.v_active_low =
>> +		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);
>> +
>> +	dp_mode->timing.h_active_low =
>> +		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);
>> +}
>> +
>> +static void convert_to_drm_mode(const struct dp_display_mode 
>> *dp_mode,
>> +				struct drm_display_mode *drm_mode)
>> +{
>> +	u32 flags = 0;
>> +
>> +	memset(drm_mode, 0, sizeof(*drm_mode));
>> +
>> +	drm_mode->hdisplay = dp_mode->timing.h_active;
>> +	drm_mode->hsync_start = drm_mode->hdisplay +
>> +				dp_mode->timing.h_front_porch;
>> +	drm_mode->hsync_end = drm_mode->hsync_start +
>> +			      dp_mode->timing.h_sync_width;
>> +	drm_mode->htotal = drm_mode->hsync_end + 
>> dp_mode->timing.h_back_porch;
>> +	drm_mode->hskew = dp_mode->timing.h_skew;
>> +
>> +	drm_mode->vdisplay = dp_mode->timing.v_active;
>> +	drm_mode->vsync_start = drm_mode->vdisplay +
>> +				dp_mode->timing.v_front_porch;
>> +	drm_mode->vsync_end = drm_mode->vsync_start +
>> +			      dp_mode->timing.v_sync_width;
>> +	drm_mode->vtotal = drm_mode->vsync_end + 
>> dp_mode->timing.v_back_porch;
>> +
>> +	drm_mode->vrefresh = dp_mode->timing.refresh_rate;
>> +	drm_mode->clock = dp_mode->timing.pixel_clk_khz;
>> +
>> +	if (dp_mode->timing.h_active_low)
>> +		flags |= DRM_MODE_FLAG_NHSYNC;
>> +	else
>> +		flags |= DRM_MODE_FLAG_PHSYNC;
>> +
>> +	if (dp_mode->timing.v_active_low)
>> +		flags |= DRM_MODE_FLAG_NVSYNC;
>> +	else
>> +		flags |= DRM_MODE_FLAG_PVSYNC;
>> +
>> +	drm_mode->flags = flags;
>> +
>> +	drm_mode->type = 0x48;
>> +	drm_mode_set_name(drm_mode);
>> +}
> 
> Just use the drm modes directly and delete these functions.
> 
>> +
>> +static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	/* By this point mode should have been validated through mode_fixup 
>> */
>> +	rc = dp->set_mode(dp, &bridge->dp_mode);
>> +	if (rc) {
>> +		pr_err("[%d] failed to perform a mode set, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->prepare(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display prepare failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->enable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display enable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		dp->unprepare(dp);
>> +	}
>> +}
>> +
>> +static void dp_bridge_enable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->post_enable(dp);
>> +	if (rc)
>> +		pr_err("[%d] DP display post enable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +}
>> +
>> +static void dp_bridge_disable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->pre_disable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display pre disable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +	}
>> +}
>> +
>> +static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->disable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display disable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->unprepare(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display unprepare failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +}
>> +
>> +static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
>> +				struct drm_display_mode *mode,
>> +				struct drm_display_mode *adjusted_mode)
>> +{
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge || !mode || !adjusted_mode) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
>> +	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode, dp);
>> +}
>> +
>> +static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
>> +				  const struct drm_display_mode *mode,
>> +				  struct drm_display_mode *adjusted_mode)
>> +{
>> +	bool ret = true;
>> +	struct dp_display_mode dp_mode;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge || !mode || !adjusted_mode) {
>> +		pr_err("Invalid params\n");
>> +		ret = false;
>> +		goto end;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	convert_to_dp_mode(mode, &dp_mode, dp);
>> +	convert_to_drm_mode(&dp_mode, adjusted_mode);
>> +end:
>> +	return ret;
>> +}
>> +
>> +static const struct drm_bridge_funcs dp_bridge_ops = {
>> +	.mode_fixup   = dp_bridge_mode_fixup,
>> +	.pre_enable   = dp_bridge_pre_enable,
>> +	.enable       = dp_bridge_enable,
>> +	.disable      = dp_bridge_disable,
>> +	.post_disable = dp_bridge_post_disable,
>> +	.mode_set     = dp_bridge_mode_set,
>> +};
> 
> I'm not convinced you need any of this. The only advantage a bridge 
> gets you is
> to be involved in modeset. However the only thing you do in modeset is 
> save the
> mode (which is only used in enable). So why not just use the mode from 
> the
> crtc's state when encoder->enable is called?
> 
> That allows you to delete all of the bridge stuff here.
> 
Will keep enable, disable and mode_set func ops and remove the remaining 
ops.
Please let me know if you still have concerns with these func ops.

>> +
>> +int dp_connector_post_init(struct drm_connector *connector, void 
>> *display)
>> +{
>> +	struct msm_dp *dp_display = display;
>> +
>> +	if (!dp_display)
>> +		return -EINVAL;
>> +
>> +	dp_display->connector = connector;
>> +	return 0;
>> +}
> 
> This isn't called from anything?
> 
>> +
>> +/**
>> + * dp_connector_detect - callback to determine if connector is 
>> connected
>> + * @connector: Pointer to drm connector structure
>> + * @force: Force detect setting from drm framework
>> + * Returns: Connector 'is connected' status
>> + */
>> +static enum drm_connector_status dp_connector_detect(struct 
>> drm_connector *conn,
>> +		bool force)
>> +{
>> +	enum drm_connector_status status = connector_status_unknown;
>> +	static enum drm_connector_status current_status = 
>> connector_status_unknown;
>> +	struct msm_dp *dp;
>> +	struct dp_connector *dp_conn;
>> +	struct msm_drm_private *priv = conn->dev->dev_private;
>> +	struct msm_kms *kms = priv->kms;
>> +
>> +	dp_conn = to_dp_connector(conn);
>> +	dp = dp_conn->dp_display;
> 
> no need for dp_conn, just do
> 
>         dp = to_dp_connector(conn)->dp_display;
> 
>> +
>> +	pr_err("is_connected = %s\n",
>> +		(dp->is_connected) ? "true" : "false");
>> +
>> +	status = (dp->is_connected) ? connector_status_connected :
>> +					connector_status_disconnected;
>> +
>> +	if (dp->is_connected && dp->bridge->encoder
>> +				&& (current_status != status)
> 
> This is always true.
> 
>> +				&& kms->funcs->set_encoder_mode) {
>> +		kms->funcs->set_encoder_mode(kms,
>> +				dp->bridge->encoder, false);
>> +		pr_err("call set_encoder_mode\n");
> 
> detect() should never do work, please remove.
> 
>> +	}
>> +	current_status = status;
> 
> Why?
> 
>> +	return status;
>> +}
>> +
>> +static void dp_connector_destroy(struct drm_connector *connector)
>> +{
>> +	struct dp_connector *dp_conn = to_dp_connector(connector);
>> +
>> +	DBG("");
>> +
>> +	drm_connector_cleanup(connector);
>> +
>> +	kfree(dp_conn);
> 
> Once dp_conn is devm managed, you can just remove this function and set 
> .destroy
> to drm_connector_cleanup
> 
>> +}
>> +
>> +void dp_connector_send_hpd_event(void *display)
> 
> Where is this called?
> 
>> +{
>> +	struct msm_dp *dp;
>> +
>> +	if (!display) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp = display;
>> +
>> +	if (dp->send_hpd_event)
>> +		dp->send_hpd_event(dp);
>> +}
>> +
>> +/**
>> + * dp_connector_get_modes - callback to add drm modes via 
>> drm_mode_probed_add()
>> + * @connector: Pointer to drm connector structure
>> + * Returns: Number of modes added
>> + */
>> +static int dp_connector_get_modes(struct drm_connector *connector)
>> +{
>> +	int rc = 0;
>> +	struct msm_dp *dp;
>> +	struct dp_display_mode *dp_mode = NULL;
>> +	struct drm_display_mode *m, drm_mode;
>> +	struct dp_connector *dp_conn;
>> +
>> +	if (!connector)
>> +		return 0;
>> +
>> +	dp_conn = to_dp_connector(connector);
>> +	dp = dp_conn->dp_display;
>> +
>> +	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
>> +	if (!dp_mode)
>> +		return 0;
> 
> When you get rid of dp_display_mode, please use the stack for the new
> drm_display_mode
> 
>> +
>> +	/* pluggable case assumes EDID is read when HPD */
>> +	if (dp->is_connected) {
>> +		rc = dp->get_modes(dp, dp_mode);
> 
> Why is only one mode returned?
> 
>> +		if (!rc)
> 
> This can also return -errno, you should check for that too.
> 
>> +			pr_err("failed to get DP sink modes, rc=%d\n", rc);
> 
> Why continue if you know you failed?
> 
>> +
>> +		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
>> +			memset(&drm_mode, 0x0, sizeof(drm_mode));
>> +			convert_to_drm_mode(dp_mode, &drm_mode);
>> +			m = drm_mode_duplicate(connector->dev, &drm_mode);
>> +			if (!m) {
>> +				pr_err("failed to add mode %ux%u\n",
>> +				       drm_mode.hdisplay,
>> +				       drm_mode.vdisplay);
>> +				kfree(dp_mode);
>> +				return 0;
>> +			}
>> +			m->width_mm = connector->display_info.width_mm;
>> +			m->height_mm = connector->display_info.height_mm;
> 
> You shouldn't overwrite these.
> 
>> +			drm_mode_probed_add(connector, m);
>> +		}
>> +	} else {
>> +		pr_err("No sink connected\n");
> 
> This shouldn't be an error
> 
>> +	}
>> +	kfree(dp_mode);
>> +
>> +	return rc;
>> +}
>> +
>> +int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *dp_bridge;
>> +	struct drm_device *dev;
>> +	struct msm_dp *dp_display = data;
>> +	struct msm_drm_private *priv = NULL;
>> +
>> +	dp_bridge = kzalloc(sizeof(*dp_bridge), GFP_KERNEL);
>> +	if (!dp_bridge) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	dev = dp_display->drm_dev;
>> +	dp_bridge->display = dp_display;
>> +	dp_bridge->base.funcs = &dp_bridge_ops;
>> +	dp_bridge->base.encoder = encoder;
>> +
>> +	priv = dev->dev_private;
>> +
>> +	rc = drm_bridge_attach(encoder, &dp_bridge->base, NULL);
>> +	if (rc) {
>> +		pr_err("failed to attach bridge, rc=%d\n", rc);
>> +		goto error_free_bridge;
>> +	}
>> +
>> +	rc = dp_display->request_irq(dp_display);
>> +	if (rc) {
>> +		pr_err("request_irq failed, rc=%d\n", rc);
>> +		goto error_free_bridge;
>> +	}
>> +
>> +	encoder->bridge = &dp_bridge->base;
>> +	dp_display->dp_bridge = dp_bridge;
>> +	dp_display->bridge = &dp_bridge->base;
>> +
>> +	return 0;
>> +error_free_bridge:
>> +	kfree(dp_bridge);
>> +error:
>> +	return rc;
>> +}
>> +
>> +void dp_drm_bridge_deinit(void *data)
>> +{
>> +	struct msm_dp *display = data;
>> +	struct dp_bridge *bridge = display->dp_bridge;
>> +
>> +	if (bridge && bridge->base.encoder)
>> +		bridge->base.encoder->bridge = NULL;
>> +
>> +	kfree(bridge);
>> +}
>> +
>> +/**
>> + * dp_connector_mode_valid - callback to determine if specified mode 
>> is valid
>> + * @connector: Pointer to drm connector structure
>> + * @mode: Pointer to drm mode structure
>> + * Returns: Validity status for specified mode
>> + */
>> +static enum drm_mode_status dp_connector_mode_valid(struct 
>> drm_connector *connector,
>> +		struct drm_display_mode *mode)
>> +{
>> +	struct msm_dp *dp_disp;
>> +	struct dp_debug *debug;
>> +	struct dp_connector *dp_conn;
>> +
>> +	if (!mode || !connector) {
>> +		pr_err("invalid params\n");
>> +		return MODE_ERROR;
>> +	}
>> +
>> +	dp_conn = to_dp_connector(connector);
>> +	dp_disp = dp_conn->dp_display;
>> +	debug = dp_disp->get_debug(dp_disp);
>> +
>> +	mode->vrefresh = drm_mode_vrefresh(mode);
>> +
>> +	if (mode->clock > dp_disp->max_pclk_khz)
> 
> I think the value of max_pclk_khz is racy, you'll probably want to 
> audit its
> use.
> 
> 
>> +		return MODE_BAD;
>> +
>> +	if (debug->debug_en && (mode->hdisplay != debug->hdisplay ||
>> +			mode->vdisplay != debug->vdisplay ||
>> +			mode->vrefresh != debug->vrefresh ||
>> +			mode->picture_aspect_ratio != debug->aspect_ratio))
>> +		return MODE_BAD;
> 
> Please drop this.
> 
>> +
>> +	return dp_disp->validate_mode(dp_disp, mode->clock);
> 
> So I guess I was wrong when I said none of the g_dp_display functions 
> are being
> used. I'm still unsure where they're set, perhaps there's some missing 
> code. At
> any rate, what's the benefit of sticking all of that work into an 
> abstract
> callback hook when it only has one implementation and one callsite.
> 
> All of that code can move in here (and the same goes for the other 
> callbacks
> (move the code where it's used).
> 
>> +}
>> +
>> +static const struct drm_connector_funcs dp_connector_funcs = {
>> +	.detect = dp_connector_detect,
>> +	.fill_modes = drm_helper_probe_single_connector_modes,
>> +	.destroy = dp_connector_destroy,
>> +	.reset = drm_atomic_helper_connector_reset,
>> +	.atomic_duplicate_state = 
>> drm_atomic_helper_connector_duplicate_state,
>> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
>> +};
>> +
>> +static const struct drm_connector_helper_funcs 
>> dp_connector_helper_funcs = {
>> +	.get_modes = dp_connector_get_modes,
>> +	.mode_valid = dp_connector_mode_valid,
>> +};
>> +
>> +/* connector initialization */
>> +struct drm_connector *dp_drm_connector_init(struct msm_dp 
>> *dp_display)
>> +{
>> +	struct drm_connector *connector = NULL;
>> +	struct dp_connector *dp_connector;
>> +	int ret;
>> +
>> +	dp_connector = kzalloc(sizeof(*dp_connector), GFP_KERNEL);
> 
> Use devm_kzalloc (you've already got a memory leak if 
> drm_connector_init fails
> below).
> 
>> +	if (!dp_connector)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	dp_connector->dp_display = dp_display;
>> +
>> +	connector = &dp_connector->base;
>> +
>> +	ret = drm_connector_init(dp_display->drm_dev, connector, 
>> &dp_connector_funcs,
>> +			DRM_MODE_CONNECTOR_DisplayPort);
>> +	if (ret)
>> +		return ERR_PTR(ret);
>> +
>> +	drm_connector_helper_add(connector, &dp_connector_helper_funcs);
>> +
>> +	/*
>> +	 * Enable HPD to let hpd event is handled
>> +	 * when cable is attached to the host.
> 
> These lines don't extend to 80 chars
> 
>> +	 */
>> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
>> +
>> +	/* Display driver doesn't support interlace now. */
>> +	connector->interlace_allowed = false;
>> +	connector->doublescan_allowed = false;
> 
> These are already false by virtue of kzalloc
> 
>> +
>> +	drm_connector_attach_encoder(connector, dp_display->encoder);
>> +
>> +	return connector;
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.h 
>> b/drivers/gpu/drm/msm/dp/dp_drm.h
>> new file mode 100644
>> index 0000000..efbc1be
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_drm.h
>> @@ -0,0 +1,52 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_DRM_H_
>> +#define _DP_DRM_H_
>> +
>> +#include <linux/types.h>
>> +#include <drm/drmP.h>
>> +#include <drm/drm_crtc.h>
>> +#include <drm/drm_crtc_helper.h>
>> +
>> +#include "msm_drv.h"
>> +#include "dp_display.h"
>> +
>> +struct dp_bridge {
>> +	struct drm_bridge base;
>> +	u32 id;
>> +
>> +	struct msm_dp *display;
>> +	struct dp_display_mode dp_mode;
>> +};
>> +
>> +/**
>> + * dp_connector_post_init - callback to perform additional 
>> initialization steps
>> + * @connector: Pointer to drm connector structure
>> + * @display: Pointer to private display handle
>> + * Returns: Zero on success
>> + */
>> +int dp_connector_post_init(struct drm_connector *connector, void 
>> *display);
>> +
>> +void dp_connector_send_hpd_event(void *display);
>> +
>> +int dp_drm_bridge_init(void *display,
>> +	struct drm_encoder *encoder);
>> +
>> +void dp_drm_bridge_deinit(void *display);
>> +
>> +struct drm_connector *dp_drm_connector_init(struct msm_dp 
>> *dp_display);
>> +
>> +#endif /* _DP_DRM_H_ */
>> +
>> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.c 
>> b/drivers/gpu/drm/msm/dp/dp_extcon.c
>> new file mode 100644
>> index 0000000..635c13b
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.c
>> @@ -0,0 +1,400 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/slab.h>
>> +#include <linux/device.h>
>> +#include <linux/extcon.h>
>> +
>> +#include "dp_extcon.h"
>> +
>> +/* DP specific VDM commands */
>> +#define DP_USBPD_VDM_STATUS	0x10
>> +#define DP_USBPD_VDM_CONFIGURE	0x11
>> +
>> +/* USBPD-TypeC specific Macros */
>> +#define VDM_VERSION		0x0
>> +#define USB_C_DP_SID		0xFF01
>> +
>> +enum dp_usbpd_pin_assignment {
>> +	DP_USBPD_PIN_A,
>> +	DP_USBPD_PIN_B,
>> +	DP_USBPD_PIN_C,
>> +	DP_USBPD_PIN_D,
>> +	DP_USBPD_PIN_E,
>> +	DP_USBPD_PIN_F,
>> +	DP_USBPD_PIN_MAX,
>> +};
>> +
>> +struct dp_usbpd_capabilities {
>> +	enum dp_usbpd_port port;
>> +	bool receptacle_state;
>> +	u8 ulink_pin_config;
>> +	u8 dlink_pin_config;
>> +};
> 
> Where is this used?
> 
>> +
>> +struct dp_extcon_private {
>> +	u32 vdo;
>> +	struct device *dev;
>> +	struct notifier_block extcon_nb;
>> +	struct extcon_dev *extcon;
>> +	struct workqueue_struct *extcon_wq;
>> +	struct work_struct event_work;
>> +	struct usbpd *pd;
>> +	struct dp_usbpd_cb *dp_cb;
>> +	struct dp_usbpd_capabilities cap;
>> +	struct dp_usbpd dp_usbpd;
>> +};
>> +
>> +static const char *dp_usbpd_pin_name(u8 pin)
>> +{
>> +	switch (pin) {
>> +	case DP_USBPD_PIN_A: return "DP_USBPD_PIN_ASSIGNMENT_A";
>> +	case DP_USBPD_PIN_B: return "DP_USBPD_PIN_ASSIGNMENT_B";
>> +	case DP_USBPD_PIN_C: return "DP_USBPD_PIN_ASSIGNMENT_C";
>> +	case DP_USBPD_PIN_D: return "DP_USBPD_PIN_ASSIGNMENT_D";
>> +	case DP_USBPD_PIN_E: return "DP_USBPD_PIN_ASSIGNMENT_E";
>> +	case DP_USBPD_PIN_F: return "DP_USBPD_PIN_ASSIGNMENT_F";
>> +	default: return "UNKNOWN";
>> +	}
>> +}
> 
> No need to have this just for one debug statement, just print the enum 
> value
> with %d below.
> 
>> +
>> +static const char *dp_usbpd_port_name(enum dp_usbpd_port port)
>> +{
>> +	switch (port) {
>> +	case DP_USBPD_PORT_NONE: return "DP_USBPD_PORT_NONE";
>> +	case DP_USBPD_PORT_UFP_D: return "DP_USBPD_PORT_UFP_D";
>> +	case DP_USBPD_PORT_DFP_D: return "DP_USBPD_PORT_DFP_D";
>> +	case DP_USBPD_PORT_D_UFP_D: return "DP_USBPD_PORT_D_UFP_D";
>> +	default: return "DP_USBPD_PORT_NONE";
>> +	}
>> +}
> 
> Same here.
> 
>> +
>> +static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
>> +{
>> +	switch (in_port) {
>> +	case 0:
>> +		*port = DP_USBPD_PORT_NONE;
>> +		break;
>> +	case 1:
>> +		*port = DP_USBPD_PORT_UFP_D;
>> +		break;
>> +	case 2:
>> +		*port = DP_USBPD_PORT_DFP_D;
>> +		break;
>> +	case 3:
>> +		*port = DP_USBPD_PORT_D_UFP_D;
>> +		break;
>> +	default:
>> +		*port = DP_USBPD_PORT_NONE;
>> +	}
>> +	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
>> +}
>> +
>> +void dp_usbpd_get_capabilities(struct dp_extcon_private *pd)
> 
> Where is this called from?
> 
>> +{
>> +	struct dp_usbpd_capabilities *cap = &pd->cap;
>> +	u32 buf = pd->vdo;
>> +	int port = buf & 0x3;
>> +
>> +	cap->receptacle_state = (buf & BIT(6)) ? true : false;
>> +	cap->dlink_pin_config = (buf >> 8) & 0xff;
>> +	cap->ulink_pin_config = (buf >> 16) & 0xff;
> 
> Please #define hardcoded values
> 
>> +
>> +	dp_usbpd_init_port(&cap->port, port);
> 
> All of the values in cap->port seem to be hardcoded, so why not just 
> use the
> #define's directly where applicable?
> 
>> +}
>> +
>> +void dp_usbpd_get_status(struct dp_extcon_private *pd)
> 
> Where is this called?
> 
>> +{
>> +	struct dp_usbpd *status = &pd->dp_usbpd;
>> +	u32 buf = pd->vdo;
>> +	int port = buf & 0x3;
>> +
>> +	status->low_pow_st     = (buf & BIT(2)) ? true : false;
>> +	status->adaptor_dp_en  = (buf & BIT(3)) ? true : false;
>> +	status->multi_func     = (buf & BIT(4)) ? true : false;
>> +	status->usb_config_req = (buf & BIT(5)) ? true : false;
>> +	status->exit_dp_mode   = (buf & BIT(6)) ? true : false;
>> +	status->hpd_high       = (buf & BIT(7)) ? true : false;
>> +	status->hpd_irq        = (buf & BIT(8)) ? true : false;
>> +
>> +	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
>> +			status->low_pow_st, status->adaptor_dp_en,
>> +			status->multi_func);
>> +	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
>> +			status->usb_config_req,
>> +			status->exit_dp_mode, status->hpd_high);
>> +	pr_debug("hpd_irq = %d\n", status->hpd_irq);
>> +
>> +	dp_usbpd_init_port(&status->port, port);
> 
> Only multi_func, hpd_high, and hpd_irq are used out of this struct. Can 
> you cull
> the values down? hpd_irq is also only set to its hardcoded value, so 
> just use
> that value directly where applicable.
> 
> 
>> +}
>> +
>> +u32 dp_usbpd_gen_config_pkt(struct dp_extcon_private *pd)
> 
> This function is also unused
> 
>> +{
>> +	u8 pin_cfg, pin;
>> +	u32 config = 0;
>> +	const u32 ufp_d_config = 0x2, dp_ver = 0x1;
>> +
>> +	if (pd->cap.receptacle_state)
>> +		pin_cfg = pd->cap.ulink_pin_config;
>> +	else
>> +		pin_cfg = pd->cap.dlink_pin_config;
>> +
>> +	for (pin = DP_USBPD_PIN_A; pin < DP_USBPD_PIN_MAX; pin++) {
>> +		if (pin_cfg & BIT(pin)) {
>> +			if (pd->dp_usbpd.multi_func) {
>> +				if (pin == DP_USBPD_PIN_D)
>> +					break;
>> +			} else {
>> +				break;
>> +			}
>> +		}
>> +	}
>> +
>> +	if (pin == DP_USBPD_PIN_MAX)
>> +		pin = DP_USBPD_PIN_C;
>> +
>> +	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
>> +
>> +	config |= BIT(pin) << 8;
>> +
>> +	config |= (dp_ver << 2);
>> +	config |= ufp_d_config;
>> +
>> +	pr_debug("config = 0x%x\n", config);
>> +	return config;
>> +}
>> +
>> +static int dp_extcon_connect(struct dp_usbpd *dp_usbpd, bool hpd)
>> +{
>> +	int rc = 0;
>> +	struct dp_extcon_private *extcon;
>> +
>> +	if (!dp_usbpd) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
> 
> Just return -EINVAL and get rid of the error label and rc.
> 
>> +	}
>> +
>> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
>> +
>> +	dp_usbpd->hpd_high = hpd;
>> +	dp_usbpd->forced_disconnect = !hpd;
> 
> If forced_disconnect is always !dp_usbpd->hpd_high, why not just use
> !dp_usbpd->hpd_high directly?
> 
>> +
>> +	if (hpd)
>> +		extcon->dp_cb->configure(extcon->dev);
>> +	else
>> +		extcon->dp_cb->disconnect(extcon->dev);
> 
> Do you need locking in this function/file?
> 
>> +
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_extcon_get_lanes(struct dp_extcon_private *extcon_priv)
>> +{
>> +	union extcon_property_value property;
>> +	u8 lanes;
>> +
>> +	if (!extcon_priv || !extcon_priv->extcon) {
>> +		pr_err("Invalid input arguments\n");
>> +		return 0;
>> +	}
>> +
>> +	extcon_get_property(extcon_priv->extcon,
>> +					EXTCON_DISP_DP,
>> +					EXTCON_PROP_USB_SS,
>> +					&property);
>> +	lanes = ();
>> +
>> +	return lanes;
> 
>         return (property.intval) ? 2 : 4;
> 
> and delete lanes
> 
> 
>> +}
>> +
>> +
>> +static void dp_extcon_event_work(struct work_struct *work)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +	int dp_state, ret;
>> +	int lanes;
>> +	union extcon_property_value property;
>> +
>> +	extcon_priv = container_of(work,
>> +			struct dp_extcon_private, event_work);
>> +
>> +	if (!extcon_priv || !extcon_priv->extcon) {
>> +		pr_err("Invalid extcon device handler\n");
>> +		return;
>> +	}
>> +
>> +	dp_state = extcon_get_state(extcon_priv->extcon,
>> +						EXTCON_DISP_DP);
> 
> Can fit on 1 line
> 
>> +
>> +	if (dp_state > 0) {
>> +		ret = extcon_get_property(extcon_priv->extcon,
>> +					EXTCON_DISP_DP,
>> +					EXTCON_PROP_USB_TYPEC_POLARITY,
>> +					&property);
>> +		if (ret) {
>> +			pr_err("Get Polarity property failed\n");
>> +			return;
>> +		}
>> +		extcon_priv->dp_usbpd.orientation =
>> +			((property.intval) ?
> 
> Can fit on 1 line, plus remove all () from this, they're not needed.
> 
>> +				ORIENTATION_CC2 : ORIENTATION_CC1);
>> +
>> +		lanes = dp_extcon_get_lanes(extcon_priv);
>> +		if (!lanes)
>> +			return;
>> +		extcon_priv->dp_usbpd.multi_func =
>> +					((lanes == 2) ? false : true);
> 
> This part is a bit confusing, you add a helper function to get the 
> lanes, and
> interpret the USB_SS property to return 2 vs. 4, but then immediately 
> convert
> that back into what the USB_SS property returns. Instead, remove the 
> helper
> function and read USB_SS directly here.
> 
>> +
>> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->configure)
> 
> I feel like this can never be false anyways, but you're not using 
> either of
> these members in the conditional block. So why not just call 
> dp_extcon_connect
> unconditionally?
> 
>> +			dp_extcon_connect(&extcon_priv->dp_usbpd, true);
> 
> Check return value
> 
>> +	} else {
>> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->disconnect)
> 
> Same here.
> 
>> +			dp_extcon_connect(&extcon_priv->dp_usbpd, false);
> 
> Check return value
> 
>> +	}
>> +}
>> +
>> +static int dp_extcon_create_workqueue(struct dp_extcon_private 
>> *extcon_priv)
>> +{
>> +	extcon_priv->extcon_wq = 
>> create_singlethread_workqueue("drm_dp_extcon");
> 
> What's the benefit of using a dedicated workqueue instead of the system 
> wq?
> 
>> +	if (IS_ERR_OR_NULL(extcon_priv->extcon_wq)) {
>> +		pr_err("Error creating extcon wq\n");
>> +		return -EPERM;
>> +	}
>> +
>> +	INIT_WORK(&extcon_priv->event_work, dp_extcon_event_work);
>> +
>> +	return 0;
> 
> This function can't fail, so it should return void. In fact, this 
> really doesn't
> need to be a separate function, roll it into dp_extcon_register().
> 
>> +}
>> +
>> +static int dp_extcon_event_notify(struct notifier_block *nb,
>> +				  unsigned long event, void *priv)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +
>> +	extcon_priv = container_of(nb, struct dp_extcon_private,
>> +						extcon_nb);
>> +
>> +	queue_work(extcon_priv->extcon_wq, &extcon_priv->event_work);
>> +	return NOTIFY_DONE;
>> +}
>> +
>> +int dp_extcon_register(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +	int ret = 0;
>> +
>> +	if (!dp_usbpd)
>> +		return -EINVAL;
>> +
>> +	pr_err("Start++++");
> 
> Yikes, this doesn't look like an error!
> 
>> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, 
>> dp_usbpd);
>> +
>> +	extcon_priv->extcon_nb.notifier_call = dp_extcon_event_notify;
>> +	ret = devm_extcon_register_notifier(extcon_priv->dev, 
>> extcon_priv->extcon,
>> +					    EXTCON_DISP_DP,
>> +					    &extcon_priv->extcon_nb);
>> +	if (ret) {
>> +		dev_err(extcon_priv->dev,
>> +			"register EXTCON_DISP_DP notifier err\n");
>> +		ret = -EINVAL;
> 
> Why keep going and create the workqueue if we have no notifier? This 
> should
> probably be a return.
> 
>> +	}
>> +
>> +	ret = dp_extcon_create_workqueue(extcon_priv);
>> +	if (ret) {
>> +		pr_err("Failed to create workqueue\n");
>> +		dp_extcon_unregister(dp_usbpd);
> 
> return ret?
> 
>> +	}
>> +
>> +	pr_err("End----");
> 
> Same here
> 
>> +	return ret;
>> +}
>> +
>> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +
>> +	if (!dp_usbpd) {
>> +		pr_err("Invalid input\n");
>> +		return;
>> +	}
>> +
>> +	pr_err("Start++++");
> 
> remove.
> 
>> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, 
>> dp_usbpd);
>> +
>> +	devm_extcon_unregister_notifier(extcon_priv->dev, 
>> extcon_priv->extcon,
>> +					    EXTCON_DISP_DP,
>> +					    &extcon_priv->extcon_nb);
>> +
>> +	if (extcon_priv->extcon_wq)
>> +		destroy_workqueue(extcon_priv->extcon_wq);
>> +
>> +	pr_err("End----");
> 
> remove.
> 
>> +	return;
>> +}
>> +
>> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb 
>> *cb)
>> +{
>> +	int rc = 0;
>> +	struct dp_extcon_private *dp_extcon;
>> +	struct dp_usbpd *dp_usbpd;
>> +
>> +	if (!cb) {
>> +		pr_err("invalid cb data\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	pr_err("%s: Start", __func__);
> 
> remove.
> 
>> +	dp_extcon = devm_kzalloc(dev, sizeof(*dp_extcon), GFP_KERNEL);
>> +	if (!dp_extcon) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	dp_extcon->extcon = extcon_get_edev_by_phandle(dev, 0);
>> +	if (!dp_extcon->extcon) {
>> +		pr_err("invalid extcon data\n");
>> +		rc = -EINVAL;
>> +		devm_kfree(dev, dp_extcon);
>> +		goto error;
>> +        }
>> +
>> +	dp_extcon->dev = dev;
>> +	dp_extcon->dp_cb = cb;
>> +
>> +	dp_extcon->dp_usbpd.connect = dp_extcon_connect;
>> +	dp_usbpd = &dp_extcon->dp_usbpd;
>> +
>> +	pr_err("%s: end", __func__);
> 
> remove.
> 
>> +	return dp_usbpd;
>> +error:
> 
> This label isn't useful, return directly where applicable.
> 
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_extcon_put(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon;
>> +
>> +	if (!dp_usbpd)
>> +		return;
>> +
>> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
>> +
>> +	devm_kfree(extcon->dev, extcon);
>> +
>> +	pr_err("%s: end", __func__);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.h 
>> b/drivers/gpu/drm/msm/dp/dp_extcon.h
>> new file mode 100644
>> index 0000000..1f83a18
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.h
>> @@ -0,0 +1,111 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_EXTCON_H_
>> +#define _DP_EXTCON_H_
>> +
>> +//#include <linux/usb/usbpd.h>
>> +
>> +#include <linux/types.h>
>> +#include <linux/device.h>
>> +
>> +/**
>> + * enum dp_usbpd_port - usb/dp port type
>> + * @DP_USBPD_PORT_NONE: port not configured
>> + * @DP_USBPD_PORT_UFP_D: Upstream Facing Port - DisplayPort
>> + * @DP_USBPD_PORT_DFP_D: Downstream Facing Port - DisplayPort
>> + * @DP_USBPD_PORT_D_UFP_D: Both UFP & DFP - DisplayPort
>> + */
>> +
>> +enum dp_usbpd_port {
>> +	DP_USBPD_PORT_NONE,
>> +	DP_USBPD_PORT_UFP_D,
>> +	DP_USBPD_PORT_DFP_D,
>> +	DP_USBPD_PORT_D_UFP_D,
>> +};
>> +
>> +enum plug_orientation {
>> +	ORIENTATION_NONE,
>> +	ORIENTATION_CC1,
>> +	ORIENTATION_CC2,
>> +};
>> +
>> +/**
>> + * struct dp_usbpd - DisplayPort status
>> + *
>> + * @port: port configured
>> + * orientation: plug orientation configuration
>> + * @low_pow_st: low power state
>> + * @adaptor_dp_en: adaptor functionality enabled
>> + * @multi_func: multi-function preferred
>> + * @usb_config_req: request to switch to usb
>> + * @exit_dp_mode: request exit from displayport mode
>> + * @hpd_high: Hot Plug Detect signal is high.
>> + * @hpd_irq: Change in the status since last message
>> + * @alt_mode_cfg_done: bool to specify alt mode status
>> + * @debug_en: bool to specify debug mode
>> + * @connect: simulate disconnect or connect for debug mode
>> + */
>> +struct dp_usbpd {
>> +	enum dp_usbpd_port port;
>> +	enum plug_orientation orientation;
>> +	bool low_pow_st;
>> +	bool adaptor_dp_en;
>> +	bool multi_func;
>> +	bool usb_config_req;
>> +	bool exit_dp_mode;
>> +	bool hpd_high;
>> +	bool hpd_irq;
>> +	bool alt_mode_cfg_done;
>> +	bool debug_en;
>> +	bool forced_disconnect;
>> +
>> +	int (*connect)(struct dp_usbpd *dp_usbpd, bool hpd);
>> +};
>> +
>> +/**
>> + * struct dp_usbpd_cb - callback functions provided by the client
>> + *
>> + * @configure: called by usbpd module when PD communication has
>> + * been completed and the usb peripheral has been configured on
>> + * dp mode.
>> + * @disconnect: notify the cable disconnect issued by usb.
>> + * @attention: notify any attention message issued by usb.
>> + */
>> +struct dp_usbpd_cb {
>> +	int (*configure)(struct device *dev);
>> +	int (*disconnect)(struct device *dev);
>> +	int (*attention)(struct device *dev);
>> +};
>> +
>> +/**
>> + * dp_extcon_get() - setup usbpd module
>> + *
>> + * @dev: device instance of the caller
>> + * @cb: struct containing callback function pointers.
>> + *
>> + * This function allows the client to initialize the usbpd
>> + * module. The module will communicate with usb driver and
>> + * handles the power delivery (PD) communication with the
>> + * sink/usb device. This module will notify the client using
>> + * the callback functions about the connection and status.
>> + */
>> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb 
>> *cb);
>> +
>> +void dp_extcon_put(struct dp_usbpd *pd);
>> +
>> +int dp_extcon_register(struct dp_usbpd *dp_usbpd);
>> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd);
>> +
>> +#endif /* _DP_EXTCON_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_link.c 
>> b/drivers/gpu/drm/msm/dp/dp_link.c
>> new file mode 100644
>> index 0000000..5ab1efc
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_link.c
>> @@ -0,0 +1,1549 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include "dp_link.h"
>> +#include "dp_panel.h"
>> +
>> +enum dynamic_range {
>> +	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
>> +	DP_DYNAMIC_RANGE_RGB_CEA = 0x01,
>> +	DP_DYNAMIC_RANGE_UNKNOWN = 0xFFFFFFFF,
>> +};
> 
> These should be in drm_dp_helper.h
> 
>> +
>> +enum audio_sample_rate {
>> +	AUDIO_SAMPLE_RATE_32_KHZ	= 0x00,
>> +	AUDIO_SAMPLE_RATE_44_1_KHZ	= 0x01,
>> +	AUDIO_SAMPLE_RATE_48_KHZ	= 0x02,
>> +	AUDIO_SAMPLE_RATE_88_2_KHZ	= 0x03,
>> +	AUDIO_SAMPLE_RATE_96_KHZ	= 0x04,
>> +	AUDIO_SAMPLE_RATE_176_4_KHZ	= 0x05,
>> +	AUDIO_SAMPLE_RATE_192_KHZ	= 0x06,
>> +};
>> +
>> +enum audio_pattern_type {
>> +	AUDIO_TEST_PATTERN_OPERATOR_DEFINED	= 0x00,
>> +	AUDIO_TEST_PATTERN_SAWTOOTH		= 0x01,
>> +};
>> +
>> +struct dp_link_request {
>> +	u32 test_requested;
>> +	u32 test_link_rate;
>> +	u32 test_lane_count;
>> +};
>> +
>> +struct dp_link_private {
>> +	u32 prev_sink_count;
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_link dp_link;
>> +
>> +	struct dp_link_request request;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +};
>> +
>> +static char *dp_link_get_audio_test_pattern(u32 pattern)
>> +{
>> +	switch (pattern) {
>> +	case AUDIO_TEST_PATTERN_OPERATOR_DEFINED:
>> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_OPERATOR_DEFINED);
>> +	case AUDIO_TEST_PATTERN_SAWTOOTH:
>> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_SAWTOOTH);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static char *dp_link_get_audio_sample_rate(u32 rate)
>> +{
>> +	switch (rate) {
>> +	case AUDIO_SAMPLE_RATE_32_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_32_KHZ);
>> +	case AUDIO_SAMPLE_RATE_44_1_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_44_1_KHZ);
>> +	case AUDIO_SAMPLE_RATE_48_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_48_KHZ);
>> +	case AUDIO_SAMPLE_RATE_88_2_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_88_2_KHZ);
>> +	case AUDIO_SAMPLE_RATE_96_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_96_KHZ);
>> +	case AUDIO_SAMPLE_RATE_176_4_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_176_4_KHZ);
>> +	case AUDIO_SAMPLE_RATE_192_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_192_KHZ);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static int dp_link_get_period(struct dp_link_private *link, int const 
>> addr)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	u32 const param_len = 0x1;
>> +	u32 const max_audio_period = 0xA;
>> +
>> +	/* TEST_AUDIO_PERIOD_CH_XX */
>> +	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
>> +		param_len) < param_len) {
>> +		pr_err("failed to read test_audio_period (0x%x)\n", addr);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	/* Period - Bits 3:0 */
>> +	data = data & 0xF;
>> +	if ((int)data > max_audio_period) {
>> +		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	ret = data;
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_channel_period(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	struct dp_link_test_audio *req = &link->dp_link.test_audio;
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_1 = ret;
>> +	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_2 = ret;
>> +	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
>> +
>> +	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_3 = ret;
>> +	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_4 = ret;
>> +	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_5 = ret;
>> +	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_6 = ret;
>> +	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_7 = ret;
>> +	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_8 = ret;
>> +	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_pattern_type(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	int rlen;
>> +	int const param_len = 0x1;
>> +	int const max_audio_pattern_type = 0x1;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
>> +		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link audio mode data\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Audio Pattern Type - Bits 7:0 */
>> +	if ((int)data > max_audio_pattern_type) {
>> +		pr_err("invalid audio pattern type = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_audio.test_audio_pattern_type = data;
>> +	pr_debug("audio pattern type = %s\n",
>> +			dp_link_get_audio_test_pattern(data));
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_mode(struct dp_link_private *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	int rlen;
>> +	int const param_len = 0x1;
>> +	int const max_audio_sampling_rate = 0x6;
>> +	int const max_audio_channel_count = 0x8;
>> +	int sampling_rate = 0x0;
>> +	int channel_count = 0x0;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link audio mode data\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Sampling Rate - Bits 3:0 */
>> +	sampling_rate = data & 0xF;
>> +	if (sampling_rate > max_audio_sampling_rate) {
>> +		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
>> +				sampling_rate, max_audio_sampling_rate);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	/* Channel Count - Bits 7:4 */
>> +	channel_count = ((data & 0xF0) >> 4) + 1;
>> +	if (channel_count > max_audio_channel_count) {
>> +		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
>> +				channel_count, max_audio_channel_count);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
>> +	link->dp_link.test_audio.test_audio_channel_count = channel_count;
>> +	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
>> +		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
>> +exit:
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_parse_audio_pattern_params() - parses audio pattern parameters 
>> from DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the audio link pattern 
>> parameters.
>> + */
>> +static int dp_link_parse_audio_pattern_params(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +
>> +	ret = dp_link_parse_audio_mode(link);
>> +	if (ret)
>> +		goto exit;
>> +
>> +	ret = dp_link_parse_audio_pattern_type(link);
>> +	if (ret)
>> +		goto exit;
>> +
>> +	ret = dp_link_parse_audio_channel_period(link);
>> +
>> +exit:
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_is_video_pattern_valid() - validates the video pattern
>> + * @pattern: video pattern requested by the sink
>> + *
>> + * Returns true if the requested video pattern is supported.
>> + */
>> +static bool dp_link_is_video_pattern_valid(u32 pattern)
>> +{
>> +	switch (pattern) {
>> +	case DP_NO_TEST_PATTERN:
>> +	case DP_COLOR_RAMP:
>> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
>> +	case DP_COLOR_SQUARE:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_video_pattern_to_string(u32 test_video_pattern)
>> +{
>> +	switch (test_video_pattern) {
>> +	case DP_NO_TEST_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_NO_TEST_PATTERN);
>> +	case DP_COLOR_RAMP:
>> +		return DP_LINK_ENUM_STR(DP_COLOR_RAMP);
>> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
>> +		return DP_LINK_ENUM_STR(DP_BLACK_AND_WHITE_VERTICAL_LINES);
>> +	case DP_COLOR_SQUARE:
>> +		return DP_LINK_ENUM_STR(DP_COLOR_SQUARE);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +/**
>> + * dp_link_is_dynamic_range_valid() - validates the dynamic range
>> + * @bit_depth: the dynamic range value to be checked
>> + *
>> + * Returns true if the dynamic range value is supported.
>> + */
>> +static bool dp_link_is_dynamic_range_valid(u32 dr)
>> +{
>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_dynamic_range_to_string(u32 dr)
>> +{
>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_VESA);
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_CEA);
>> +	case DP_DYNAMIC_RANGE_UNKNOWN:
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> No need for this, just print the value in the debug statement.
> 
>> +
>> +/**
>> + * dp_link_is_bit_depth_valid() - validates the bit depth requested
>> + * @bit_depth: bit depth requested by the sink
>> + *
>> + * Returns true if the requested bit depth is supported.
>> + */
>> +static bool dp_link_is_bit_depth_valid(u32 tbd)
>> +{
>> +	/* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +	case DP_TEST_BIT_DEPTH_8:
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_bit_depth_to_string(u32 tbd)
>> +{
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_6);
>> +	case DP_TEST_BIT_DEPTH_8:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_8);
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_10);
>> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Same thing here, just remove this and print the enum value.
> 
>> +
>> +static int dp_link_parse_timing_params1(struct dp_link_private *link,
>> +					int const addr, int const len, u32 *val)
> 
> pass-by-value doesn't need const same comment applies elsewhere, please 
> sweep
> the code for other instances.
> 
>> +{
>> +	u8 bp[2];
>> +	int rlen;
>> +
>> +	if (len < 2)
> 
> If you're going to check len < 2, you should probably also check len > 
> 2 to
> prevent overflow. At this point, len can really only be 2, so you can
> just remove
> it entirely as an argument.
> 
>> +		return -EINVAL;
>> +
>> +	/* Read the requested video link pattern (Byte 0x221). */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
>> +	if (rlen < len) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +
>> +	*val = bp[1] | (bp[0] << 8);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_parse_timing_params2(struct dp_link_private *link,
>> +					int const addr, int const len,
>> +					u32 *val1, u32 *val2)
>> +{
>> +	u8 bp[2];
>> +	int rlen;
>> +
>> +	if (len < 2)
> 
> Same comment here rt bounds checking
> 
>> +		return -EINVAL;
>> +
>> +	/* Read the requested video link pattern (Byte 0x221). */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
>> +	if (rlen < len) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +
>> +	*val1 = (bp[0] & BIT(7)) >> 7;
>> +	*val2 = bp[1] | ((bp[0] & 0x7F) << 8);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_parse_timing_params3(struct dp_link_private *link,
>> +					int const addr, u32 *val)
>> +{
>> +	u8 bp;
>> +	u32 len = 1;
>> +	int rlen;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp, len);
>> +	if (rlen < 1) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +	*val = bp;
>> +
>> +	return 0;
>> +}
> 
> Putting aside the uninformative names, these 
> dp_link_parse_timing_params*
> can be combined into one pretty easily, like:
> 
> static int dp_link_read_u32(struct dp_link_private *link, unsigned int 
> offset,
> 		            u32 *val, int num_bytes)
> {
>         int i;
>         ssize_t ret;
>         __be32 tmp_val;
> 
>         for (i = 0; num_bytes > 0; i += sizeof(*val)) {
>                 int to_read = min(sizeof(tmp_val), num_bytes);
> 
>                 tmp_val = 0;
>                 ret = drm_dp_dpcd_read(link->aux->drm_aux, offset + i, 
> &tmp_val,
>                                        to_read);
>                 if (rlen < 0) {
>                         /* print error message here */
>                         return rlen;
>                 }
>                 val[i] = be32_to_cpu(tmp_val);
>                 num_bytes -= to_read;
>         }
>         return 0;
> }
> 
> If you need to strip off the first bit, do it from the caller.
> 
> I didn't compile or test this, so it might need tweaking, but you get 
> the idea.
> 
> 
>> +
>> +/**
>> + * dp_parse_video_pattern_params() - parses video pattern parameters 
>> from DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the video link pattern and the 
>> link
>> + * bit depth requested by the sink and, and if the values parsed are 
>> valid.
>> + */
>> +static int dp_link_parse_video_pattern_params(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	int rlen;
> 
> ssize_t
> 
>> +	u8 bp;
>> +	u8 data;
> 
> Why do you need data and bp? I think you only need one.
> 
>> +	u32 dyn_range;
>> +	int const param_len = 0x1;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PATTERN,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link video pattern\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	if (!dp_link_is_video_pattern_valid(data)) {
>> +		pr_err("invalid link video pattern = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_video.test_video_pattern = data;
>> +	pr_debug("link video pattern = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_video_pattern,
>> +		dp_link_video_pattern_to_string(
>> +			link->dp_link.test_video.test_video_pattern));
>> +
>> +	/* Read the requested color bit depth and dynamic range (Byte 0x232) 
>> */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_MISC0,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link bit depth\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Dynamic Range */
>> +	dyn_range = (data & DP_TEST_DYNAMIC_RANGE_CEA) >> 3;
> 
> This mask isolates one bit from data
> 
>> +	if (!dp_link_is_dynamic_range_valid(dyn_range)) {
> 
> and this function returns true if the input is 0 || 1
> 
> So remove this code, and remove dp_link_is_dynamic_range_valid.
> 
>> +		pr_err("invalid link dynamic range = 0x%x", dyn_range);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	link->dp_link.test_video.test_dyn_range = dyn_range;
> 
> And now you can just assign this directly. You should probably stay 
> consistent
> and store the value shifted like the other values you're storing.
> 
>> +	pr_debug("link dynamic range = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_dyn_range,
>> +		dp_link_dynamic_range_to_string(
>> +			link->dp_link.test_video.test_dyn_range));
>> +
>> +	/* Color bit depth */
>> +	data &= DP_TEST_BIT_DEPTH_MASK;
>> +	if (!dp_link_is_bit_depth_valid(data)) {
>> +		pr_err("invalid link bit depth = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_video.test_bit_depth = data;
>> +	pr_debug("link bit depth = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_bit_depth,
>> +		dp_link_bit_depth_to_string(
>> +		link->dp_link.test_video.test_bit_depth));
>> +
>> +	/* resolution timing params */
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
>> +			&link->dp_link.test_video.test_h_total);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_TOTAL = %d\n", 
>> link->dp_link.test_video.test_h_total);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
>> +			&link->dp_link.test_video.test_v_total);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_TOTAL = %d\n", 
>> link->dp_link.test_video.test_v_total);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
>> +			&link->dp_link.test_video.test_h_start);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_START = %d\n", 
>> link->dp_link.test_video.test_h_start);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
>> +			&link->dp_link.test_video.test_v_start);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_START = %d\n", 
>> link->dp_link.test_video.test_v_start);
>> +
>> +	ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
>> +			&link->dp_link.test_video.test_hsync_pol,
>> +			&link->dp_link.test_video.test_hsync_width);
>> +	if (ret) {
>> +		pr_err("failed to parse (DP_TEST_HSYNC_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_HSYNC_POL = %d\n",
>> +		link->dp_link.test_video.test_hsync_pol);
>> +	pr_debug("TEST_HSYNC_WIDTH = %d\n",
>> +		link->dp_link.test_video.test_hsync_width);
>> +
>> +	ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
>> +			&link->dp_link.test_video.test_vsync_pol,
>> +			&link->dp_link.test_video.test_vsync_width);
>> +	if (ret) {
>> +		pr_err("failed to parse (DP_TEST_VSYNC_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_VSYNC_POL = %d\n",
>> +		link->dp_link.test_video.test_vsync_pol);
>> +	pr_debug("TEST_VSYNC_WIDTH = %d\n",
>> +		link->dp_link.test_video.test_vsync_width);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
>> +			&link->dp_link.test_video.test_h_width);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_WIDTH = %d\n", 
>> link->dp_link.test_video.test_h_width);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
>> +			&link->dp_link.test_video.test_v_height);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_HEIGHT = %d\n",
>> +		link->dp_link.test_video.test_v_height);
>> +
>> +	ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
>> +		&link->dp_link.test_video.test_rr_d);
>> +	link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
>> +	if (ret) {
>> +		pr_err("failed to parse test_rr_d (DP_TEST_MISC1)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_REFRESH_DENOMINATOR = %d\n",
>> +		link->dp_link.test_video.test_rr_d);
>> +
>> +	ret = dp_link_parse_timing_params3(link, 
>> DP_TEST_REFRESH_RATE_NUMERATOR,
>> +		&link->dp_link.test_video.test_rr_n);
>> +	if (ret) {
>> +		pr_err("failed to parse test_rr_n 
>> (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_REFRESH_NUMERATOR = %d\n",
>> +		link->dp_link.test_video.test_rr_n);
> 
> Instead of sprinkling all of these pr_debug messages around, just have 
> one big
> debug at the end to print everything.
> 
>> +exit:
> 
> This label isn't useful, just return directly above
> 
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_parse_link_training_params() - parses link training 
>> parameters from
>> + * DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the link rate (Byte 0x219) and 
>> lane
>> + * count (Byte 0x220), and if these values parse are valid.
>> + */
>> +static int dp_link_parse_link_training_params(struct dp_link_private 
>> *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> You don't need both bp and data
> 
>> +	int ret = 0;
>> +	int rlen;
> 
> ssize_t
> 
>> +	int const param_len = 0x1;
> 
> Just use 1 directly below.
> 
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LINK_RATE,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link rate\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	if (!is_link_rate_valid(data)) {
>> +		pr_err("invalid link rate = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->request.test_link_rate = data;
>> +	pr_debug("link rate = 0x%x\n", link->request.test_link_rate);
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LANE_COUNT,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read lane count\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +	data &= 0x1F;
> 
> DP_MAX_LANE_COUNT_MASK
> 
>> +
>> +	if (!is_lane_count_valid(data)) {
> 
> You might also want to data against max lanes
> 
>> +		pr_err("invalid lane count = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->request.test_lane_count = data;
>> +	pr_debug("lane count = 0x%x\n", link->request.test_lane_count);
>> +exit:
>> +	return ret;
> 
> return directly above and remove exit + ret;
> 
>> +}
>> +
>> +static bool dp_link_is_phy_test_pattern_supported(u32 
>> phy_test_pattern_sel)
>> +{
>> +	switch (phy_test_pattern_sel) {
>> +	case DP_TEST_PHY_PATTERN_NONE:
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +/**
>> + * dp_parse_phy_test_params() - parses the phy link parameters
>> + * @link: Display Port Driver data
>> + *
>> + * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is 
>> being
>> + * requested.
>> + */
>> +static int dp_link_parse_phy_test_params(struct dp_link_private 
>> *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> Only need one of these.
> 
>> +	int rlen;
> 
> ssize_t
> 
>> +	int const param_len = 0x1;
> 
> Just use 1 below
> 
>> +	int ret = 0;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PHY_PATTERN,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
> 
> FWIW, drm_dp_dpcd_read will return either len or an -errno. Partial 
> reads return
> -EPROTO. So instead of checking that rlen < param_len, you can just do 
> rlen < 0.
> 
> Please also change all of the 1-byte reads over to using 
> drm_dp_dpcd_readb().
> 
> 
>> +		pr_err("failed to read phy link pattern\n");
> 
> print and return rlen.
> 
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	link->dp_link.phy_params.phy_test_pattern_sel = data;
>> +
>> +	pr_debug("phy_test_pattern_sel = %s\n",
>> +			dp_link_get_phy_test_pattern(data));
>> +
>> +	if (!dp_link_is_phy_test_pattern_supported(data))
> 
> Just embed that code here.
> 
>> +		ret = -EINVAL;
>> +end:
> 
> Remove label/ret and return directly
> 
>> +	return ret;
>> +}
>> +
>> +static char *dp_link_get_test_name(u32 test_requested)
>> +{
>> +	switch (test_requested) {
>> +	case DP_TEST_LINK_TRAINING:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_TRAINING);
>> +	case DP_TEST_LINK_VIDEO_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_VIDEO_PATTERN);
>> +	case DP_TEST_LINK_EDID_READ:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_EDID_READ);
>> +	case DP_TEST_LINK_PHY_TEST_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_PHY_TEST_PATTERN);
>> +	case DP_TEST_LINK_AUDIO_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_AUDIO_PATTERN);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Remove this and just print the enum.
> 
>> +
>> +/**
>> + * dp_link_is_video_audio_test_requested() - checks for audio/video 
>> link request
>> + * @link: link requested by the sink
>> + *
>> + * Returns true if the requested link is a permitted audio/video 
>> link.
>> + */
>> +static bool dp_link_is_video_audio_test_requested(u32 link)
>> +{
> 
> Should you be masking link to isolate these bits?
> 
>> +	return (link == DP_TEST_LINK_VIDEO_PATTERN) ||
>> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
>> +		DP_TEST_LINK_VIDEO_PATTERN)) ||
>> +		(link == DP_TEST_LINK_AUDIO_PATTERN) ||
>> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
>> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO));
> 
> And once you mask the value, just check if any of the bits are set 
> instead of
> enumerating all possible values.
> 
> 
>> +}
>> +
>> +/**
>> + * dp_link_supported() - checks if link requested by sink is 
>> supported
>> + * @test_requested: link requested by the sink
>> + *
>> + * Returns true if the requested link is supported.
>> + */
>> +static bool dp_link_is_test_supported(u32 test_requested)
>> +{
>> +	return (test_requested == DP_TEST_LINK_TRAINING) ||
>> +		(test_requested == DP_TEST_LINK_EDID_READ) ||
>> +		(test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) ||
>> +		dp_link_is_video_audio_test_requested(test_requested);
> 
> I think this all equates to:
> 
> 	return test_requested != DP_TEST_LINK_FAUX_PATTERN;
> 
> and in that case, you can just remove this function and insert that 
> condition in
> the if statement below.
> 
>> +}
>> +
>> +static bool dp_link_is_test_edid_read(struct dp_link_private *link)
>> +{
>> +	return (link->request.test_requested == DP_TEST_LINK_EDID_READ);
>> +}
> 
> This doesn't warrant its own function. Also, should this be & instead 
> of ==?
> 
>> +
>> +/**
>> + * dp_sink_parse_test_request() - parses link request parameters from 
>> sink
>> + * @link: Display Port Driver data
>> + *
>> + * Parses the DPCD to check if an automated link is requested (Byte 
>> 0x201),
>> + * and what type of link automation is being requested (Byte 0x218).
>> + */
>> +static int dp_link_parse_request(struct dp_link_private *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
> 
> Only need 1 of bp/data
> 
>> +	int rlen;
> 
> ssize_t
> 
>> +	u32 const param_len = 0x1;
> 
> Not needed, use drm_dp_dpcd_readb()
> 
>> +
>> +	/**
>> +	 * Read the device service IRQ vector (Byte 0x201) to determine
>> +	 * whether an automated link has been requested by the sink.
>> +	 */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
>> +		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("aux read failed\n");
> 
> Print error. This goes for other failure messages in this file.
> 
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("device service irq vector = 0x%x\n", data);
>> +
>> +	if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
>> +		pr_debug("no test requested\n");
>> +		return 0;
>> +	}
>> +
>> +	/**
>> +	 * Read the link request byte (Byte 0x218) to determine what type
>> +	 * of automated link has been requested by the sink.
>> +	 */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("aux read failed\n");
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	if (!dp_link_is_test_supported(data)) {
>> +		pr_debug("link 0x%x not supported\n", data);
>> +		goto end;
>> +	}
>> +
>> +	pr_debug("%s (0x%x) requested\n", dp_link_get_test_name(data), 
>> data);
>> +	link->request.test_requested = data;
> 
> If test_requested is only used in the scope of this function, just use 
> a local
> and pass it around. If test_requested is used outside the scope of this
> function, you need locking.
> 
>> +
>> +	if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		ret = dp_link_parse_phy_test_params(link);
>> +		if (ret)
>> +			goto end;
>> +		ret = dp_link_parse_link_training_params(link);
> 
> Check the return here or it could get stomped
> 
>> +	}
>> +
>> +	if (link->request.test_requested == DP_TEST_LINK_TRAINING)
>> +		ret = dp_link_parse_link_training_params(link);
> 
> Check the return here or it could get stomped
> 
>> +
>> +	if (dp_link_is_video_audio_test_requested(
>> +			link->request.test_requested)) {
> 
> Should fit on 1 line, I think
> 
>> +		ret = dp_link_parse_video_pattern_params(link);
>> +		if (ret)
>> +			goto end;
>> +
>> +		ret = dp_link_parse_audio_pattern_params(link);
> 
> Check the return here or it could get stomped
> 
>> +	}
>> +end:
>> +	/**
> 
> /*
> 
>> +	 * Send a DP_TEST_ACK if all link parameters are valid, otherwise 
>> send
>> +	 * a DP_TEST_NAK.
>> +	 */
>> +	if (ret) {
>> +		link->dp_link.test_response = DP_TEST_NAK;
>> +	} else {
>> +		if (!dp_link_is_test_edid_read(link))
>> +			link->dp_link.test_response = DP_TEST_ACK;
>> +		else
>> +			link->dp_link.test_response =
>> +				DP_TEST_EDID_CHECKSUM_WRITE;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_parse_sink_count() - parses the sink count
>> + *
>> + * Parses the DPCD to check if there is an update to the sink count
>> + * (Byte 0x200), and whether all the sink devices connected have 
>> Content
>> + * Protection enabled.
>> + */
>> +static int dp_link_parse_sink_count(struct dp_link *dp_link)
>> +{
>> +	int rlen;
>> +	int const param_len = 0x1;
> 
> drm_dp_dpcd_readb
> 
>> +	struct dp_link_private *link = container_of(dp_link,
>> +			struct dp_link_private, dp_link);
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_SINK_COUNT,
>> +			&link->dp_link.sink_count.count, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read sink count\n");
> 
> print ret
> 
>> +		return -EINVAL;
> 
> return ret
> 
>> +	}
>> +
>> +	link->dp_link.sink_count.cp_ready =
>> +		link->dp_link.sink_count.count & DP_SINK_CP_READY;
> 
> cp_ready is only used in this function, please don't store stuff like 
> this
> beyond its scope.
> 
>> +	/* BIT 7, BIT 5:0 */
> 
> Don't need this comment
> 
>> +	link->dp_link.sink_count.count =
>> +		DP_GET_SINK_COUNT(link->dp_link.sink_count.count);
>> +
>> +	pr_debug("sink_count = 0x%x, cp_ready = 0x%x\n",
>> +		link->dp_link.sink_count.count,
>> +		link->dp_link.sink_count.cp_ready);
>> +	return 0;
>> +}
>> +
>> +static void dp_link_parse_sink_status_field(struct dp_link_private 
>> *link)
>> +{
>> +	int len = 0;
>> +
>> +	link->prev_sink_count = link->dp_link.sink_count.count;
>> +	dp_link_parse_sink_count(&link->dp_link);
>> +
>> +	len = drm_dp_dpcd_read_link_status(link->aux->drm_aux,
>> +		link->link_status);
>> +	if (len < DP_LINK_STATUS_SIZE)
>> +		pr_err("DP link status read failed\n");
>> +	dp_link_parse_request(link);
>> +}
>> +
>> +static bool dp_link_is_link_training_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested == DP_TEST_LINK_TRAINING);
>> +}
> 
> No need for dedicated function
> 
>> +
>> +/**
>> + * dp_link_process_link_training_request() - processes new training 
>> requests
>> + * @link: Display Port link data
>> + *
>> + * This function will handle new link training requests that are 
>> initiated by
>> + * the sink. In particular, it will update the requested lane count 
>> and link
>> + * link rate, and then trigger the link retraining procedure.
>> + *
>> + * The function will return 0 if a link training request has been 
>> processed,
>> + * otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_link_training_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_link_training_requested(link))
>> +		return -EINVAL;
>> +
>> +	pr_debug("%s link rate = 0x%x, lane count = 0x%x\n",
>> +			dp_link_get_test_name(DP_TEST_LINK_TRAINING),
>> +			link->request.test_link_rate,
>> +			link->request.test_lane_count);
>> +
>> +	link->dp_link.link_params.lane_count = 
>> link->request.test_lane_count;
>> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;
> 
> Should be using dp helper structs for this stuff
> 
>> +
>> +	return 0;
>> +}
>> +
>> +static void dp_link_send_test_response(struct dp_link *dp_link)
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	u32 const response_len = 0x1;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
>> +			&dp_link->test_response, response_len);
> 
> I strongly suspect you should have locking protecting test_response.
> 
>> +}
>> +
>> +static int dp_link_psm_config(struct dp_link *dp_link,
>> +			      struct drm_dp_link *link_info, bool enable)
> 
> This is another racy function where you could be simultaneously 
> powering up and
> powering down the link. So you might want some locking.
> 
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	int ret = 0;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid params\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	if (enable)
>> +		ret = drm_dp_link_power_down(link->aux->drm_aux, link_info);
>> +	else
>> +		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
>> +
>> +	if (ret)
>> +		pr_err("Failed to %s low power mode\n",
>> +			(enable ? "enter" : "exit"));
> 
> unneeded (). You could probably reword to fit on one line too
> 
>> +	else
>> +		dp_link->psm_enabled = enable;
>> +
>> +	return ret;
>> +}
>> +
>> +static void dp_link_send_edid_checksum(struct dp_link *dp_link, u8 
>> checksum)
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	u32 const response_len = 0x1;
> 
> drm_dp_dpcd_readb. I'll stop commenting on these, just please go 
> through and
> convert all 1-byte reads/writes
> 
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_EDID_CHECKSUM,
>> +			&checksum, response_len);
> 
> Check and return the result
> 
>> +}
>> +
>> +static int dp_link_parse_vx_px(struct dp_link_private *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> Only need one of these
> 
>> +	int const param_len = 0x1;
> 
> drm_dp_dpcd_readb
> 
>> +	int ret = 0;
>> +	u32 v0, p0, v1, p1, v2, p2, v3, p3;
>> +	int rlen;
> 
> ssize_t
> 
>> +
>> +	pr_debug("\n");
> 
> remove
> 
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, 
>> DP_ADJUST_REQUEST_LANE0_1,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed reading lanes 0/1\n");
> 
> print error
> 
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("lanes 0/1 (Byte 0x206): 0x%x\n", data);
>> +
>> +	v0 = data & 0x3;
>> +	data = data >> 2;
>> +	p0 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	v1 = data & 0x3;
>> +	data = data >> 2;
>> +	p1 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, 
>> DP_ADJUST_REQUEST_LANE2_3,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed reading lanes 2/3\n");
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("lanes 2/3 (Byte 0x207): 0x%x\n", data);
>> +
>> +	v2 = data & 0x3;
>> +	data = data >> 2;
>> +	p2 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	v3 = data & 0x3;
>> +	data = data >> 2;
>> +	p3 = data & 0x3;
>> +	data = data >> 2;
> 
> I think you can use drm_dp_get_adjust_request_voltage() for all of 
> this.
> 
>> +
>> +	pr_debug("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
>> +	pr_debug("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
>> +
>> +	/**
>> +	 * Update the voltage and pre-emphasis levels as per DPCD request
>> +	 * vector.
>> +	 */
>> +	pr_debug("Current: v_level = 0x%x, p_level = 0x%x\n",
>> +			link->dp_link.phy_params.v_level,
>> +			link->dp_link.phy_params.p_level);
>> +	pr_debug("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
>> +	link->dp_link.phy_params.v_level = v0;
>> +	link->dp_link.phy_params.p_level = p0;
>> +
>> +	pr_debug("Success\n");
> 
> Remove
> 
>> +end:
> 
> return directly everywhere and remove end & ret
> 
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_process_phy_test_pattern_request() - process new phy link 
>> requests
>> + * @link: Display Port Driver data
>> + *
>> + * This function will handle new phy link pattern requests that are 
>> initiated
>> + * by the sink. The function will return 0 if a phy link pattern has 
>> been
>> + * processed, otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_phy_test_pattern_request(
>> +		struct dp_link_private *link)
>> +{
>> +	u32 test_link_rate = 0, test_lane_count = 0;
>> +
>> +	if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) 
>> {
> 
> Is test_requested always expected to have this value populated when
> dp_link_process_request()?
> 
>> +		pr_debug("no phy test\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	test_link_rate = link->request.test_link_rate;
>> +	test_lane_count = link->request.test_lane_count;
> 
> Just use these values directly instead of adding more locals.
> 
>> +
>> +	if (!is_link_rate_valid(test_link_rate) ||
>> +		!is_lane_count_valid(test_lane_count)) {
>> +		pr_err("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
>> +				test_link_rate, test_lane_count);
>> +		return -EINVAL;
>> +	}
>> +
>> +	pr_debug("start\n");
> 
> Remove
> 
>> +
>> +	pr_info("Current: bw_code = 0x%x, lane count = 0x%x\n",
>> +			link->dp_link.link_params.bw_code,
>> +			link->dp_link.link_params.lane_count);
>> +
>> +	pr_info("Requested: bw_code = 0x%x, lane count = 0x%x\n",
>> +			test_link_rate, test_lane_count);
> 
> These should be debug level prints
> 
>> +
>> +	link->dp_link.link_params.lane_count = 
>> link->request.test_lane_count;
>> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;
>> +
>> +	dp_link_parse_vx_px(link);
> 
> Check return value and propagate it.
> 
>> +
>> +	pr_debug("end\n");
> 
> Remove
> 
>> +
>> +	return 0;
>> +}
>> +
>> +static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], 
>> int r)
>> +{
>> +	return link_status[r - DP_LANE0_1_STATUS];
> 
> I don't think you're really supposed to reach into the link_status like 
> this.
> How about adding a new helper to check for DP_LINK_STATUS_UPDATED and 
> one for
> DP_DOWNSTREAM_PORT_STATUS_CHANGED?
> 
>> +}
>> +
>> +/**
>> + * dp_link_process_link_status_update() - processes link status 
>> updates
>> + * @link: Display Port link module data
>> + *
>> + * This function will check for changes in the link status, e.g. 
>> clock
>> + * recovery done on all lanes, and trigger link training if there is 
>> a
>> + * failure/error on the link.
>> + *
>> + * The function will return 0 if the a link status update has been 
>> processed,
>> + * otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_link_status_update(struct dp_link_private 
>> *link)
>> +{
>> +	if (!(get_link_status(link->link_status, 
>> DP_LANE_ALIGN_STATUS_UPDATED) &
>> +		DP_LINK_STATUS_UPDATED) || /* link status updated */
>> +		(drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count) &&
>> +	     drm_dp_channel_eq_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count)))
> 
> Can you please fix the alignment here, it's tough to read.
> 
>> +		return -EINVAL;
>> +
>> +	pr_debug("channel_eq_done = %d, clock_recovery_done = %d\n",
>> +			drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count),
>> +			drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count));
>> +
>> +	return 0;
>> +}
>> +
>> +static bool dp_link_is_ds_port_status_changed(struct dp_link_private 
>> *link)
>> +{
>> +	if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) 
>> &
>> +		DP_DOWNSTREAM_PORT_STATUS_CHANGED) /* port status changed */
>> +		return true;
>> +
>> +	if (link->prev_sink_count != link->dp_link.sink_count.count)
> 
> It seems like this is running in a separate thread from where 
> prev_sink_count is
> set, potential race here?
> 
>> +		return true;
>> +
>> +	return false;
> 
> 	return link->prev_sink_count != link->dp_link.sink_count.count;
> 
>> +}
>> +
>> +/**
>> + * dp_link_process_downstream_port_status_change() - process port 
>> status changes
>> + * @link: Display Port Driver data
>> + *
>> + * This function will handle downstream port updates that are 
>> initiated by
>> + * the sink. If the downstream port status has changed, the EDID is 
>> read via
>> + * AUX.
>> + *
>> + * The function will return 0 if a downstream port update has been
>> + * processed, otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_ds_port_status_change(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_ds_port_status_changed(link))
> 
> Just embed the contents of is_ds_port_status_changed here, no need for 
> 2 funcs
> 
>> +		return -EINVAL;
>> +
>> +	/* reset prev_sink_count */
>> +	link->prev_sink_count = link->dp_link.sink_count.count;
>> +
>> +	return 0;
>> +}
>> +
>> +static bool dp_link_is_video_pattern_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN)
>> +		&& !(link->request.test_requested &
>> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
>> +}
>> +
>> +static bool dp_link_is_audio_pattern_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN);
>> +}
>> +
>> +/**
>> + * dp_link_process_video_pattern_request() - process new video 
>> pattern request
>> + * @link: Display Port link module's data
>> + *
>> + * This function will handle a new video pattern request that are 
>> initiated by
>> + * the sink. This is acheieved by first sending a disconnect 
>> notification to
>> + * the sink followed by a subsequent connect notification to the user 
>> modules,
>> + * where it is expected that the user modules would draw the required 
>> link
>> + * pattern.
>> + */
>> +static int dp_link_process_video_pattern_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_video_pattern_requested(link))
> 
> Just do this directly in dp_link_process_request and get rid of this 
> function
> 
>> +		goto end;
>> +
>> +	pr_debug("%s: bit depth=%d(%d bpp) pattern=%s\n",
>> +		dp_link_get_test_name(DP_TEST_LINK_VIDEO_PATTERN),
>> +		link->dp_link.test_video.test_bit_depth,
>> +		dp_link_bit_depth_to_bpp(
>> +		link->dp_link.test_video.test_bit_depth),
>> +		dp_link_video_pattern_to_string(
>> +			link->dp_link.test_video.test_video_pattern));
>> +
>> +	return 0;
>> +end:
>> +	return -EINVAL;
>> +}
>> +
>> +/**
>> + * dp_link_process_audio_pattern_request() - process new audio 
>> pattern request
>> + * @link: Display Port link module data
>> + *
>> + * This function will handle a new audio pattern request that is 
>> initiated by
>> + * the sink. This is acheieved by sending the necessary secondary 
>> data packets
>> + * to the sink. It is expected that any simulatenous requests for 
>> video
>> + * patterns will be handled before the audio pattern is sent to the 
>> sink.
>> + */
>> +static int dp_link_process_audio_pattern_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_audio_pattern_requested(link))
> 
> Same here
> 
>> +		return -EINVAL;
>> +
>> +	pr_debug("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
>> +		dp_link_get_audio_sample_rate(
>> +			link->dp_link.test_audio.test_audio_sampling_rate),
>> +		link->dp_link.test_audio.test_audio_channel_count,
>> +		dp_link_get_audio_test_pattern(
>> +			link->dp_link.test_audio.test_audio_pattern_type));
>> +
>> +	pr_debug("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
>> +		link->dp_link.test_audio.test_audio_period_ch_1,
>> +		link->dp_link.test_audio.test_audio_period_ch_2,
>> +		link->dp_link.test_audio.test_audio_period_ch_3,
>> +		link->dp_link.test_audio.test_audio_period_ch_4);
>> +
>> +	pr_debug("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
>> +		link->dp_link.test_audio.test_audio_period_ch_5,
>> +		link->dp_link.test_audio.test_audio_period_ch_6,
>> +		link->dp_link.test_audio.test_audio_period_ch_7,
>> +		link->dp_link.test_audio.test_audio_period_ch_8);
>> +
>> +	return 0;
>> +}
>> +
>> +static void dp_link_reset_data(struct dp_link_private *link)
>> +{
>> +	link->request = (const struct dp_link_request){ 0 };
>> +	link->dp_link.test_video = (const struct dp_link_test_video){ 0 };
>> +	link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN;
>> +	link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 };
>> +	link->dp_link.phy_params.phy_test_pattern_sel = 0;
>> +	link->dp_link.sink_request = 0;
>> +	link->dp_link.test_response = 0;
> 
> 	memset?
> 
>> +}
>> +
>> +/**
>> + * dp_link_process_request() - handle HPD IRQ transition to HIGH
>> + * @link: pointer to link module data
>> + *
>> + * This function will handle the HPD IRQ state transitions from LOW 
>> to HIGH
>> + * (including cases when there are back to back HPD IRQ HIGH) 
>> indicating
>> + * the start of a new link training request or sink status update.
>> + */
>> +static int dp_link_process_request(struct dp_link *dp_link)
>> +{
>> +	int ret = 0;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	pr_debug("start\n");
>> +
>> +	dp_link_reset_data(link);
>> +
>> +	dp_link_parse_sink_status_field(link);
>> +
>> +	if (dp_link_is_test_edid_read(link)) {
>> +		dp_link->sink_request |= DP_TEST_LINK_EDID_READ;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_ds_port_status_change(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DS_PORT_STATUS_CHANGED;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_link_training_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_TRAINING;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_phy_test_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_link_status_update(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_LINK_STATUS_UPDATED;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_video_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_audio_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	pr_debug("done\n");
>> +exit:
> 
> remove exit & ret, just return values directly
> 
>> +	return ret;
>> +}
>> +
>> +static int dp_link_get_colorimetry_config(struct dp_link *dp_link)
>> +{
>> +	u32 cc;
>> +	enum dynamic_range dr;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	/* unless a video pattern CTS test is ongoing, use CEA_VESA */
> 
> s/CEA_VESA/RGB_VESA?
> 
>> +	if (dp_link_is_video_pattern_requested(link))
>> +		dr = link->dp_link.test_video.test_dyn_range;
>> +	else
>> +		dr = DP_DYNAMIC_RANGE_RGB_VESA;
>> +
>> +	/* Only RGB_VESA nd RGB_CEA supported for now */
> 
> s/nd/and/
> 
>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		cc = BIT(3);
>> +		break;
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +	default:
>> +		cc = 0;
>> +	}
> 
> If you store the value shifted like I suggested, you don't have to do 
> this
> switch (which really should be an if anyways since the range is 0:1).
> 
>> +
>> +	return cc;
>> +}
>> +
>> +static int dp_link_adjust_levels(struct dp_link *dp_link, u8 
>> *link_status)
>> +{
>> +	int i;
>> +	int max = 0;
>> +	u8 data;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	/* use the max level across lanes */
>> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
>> +		data = drm_dp_get_adjust_request_voltage(link_status, i);
>> +		pr_debug("lane=%d req_voltage_swing=%d\n", i, data);
>> +		if (max < data)
>> +			max = data;
>> +	}
>> +
>> +	dp_link->phy_params.v_level = max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
>> +
>> +	/* use the max level across lanes */
>> +	max = 0;
>> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
>> +		data = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
>> +		pr_debug("lane=%d req_pre_emphasis=%d\n", i, data);
>> +		if (max < data)
>> +			max = data;
>> +	}
> 
> You can combine these loops and do the work at once (check out
> intel_get_adjust_train)
> 
>> +
>> +	dp_link->phy_params.p_level = max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
>> +
>> +	/**
>> +	 * Adjust the voltage swing and pre-emphasis level combination to 
>> within
>> +	 * the allowable range.
>> +	 */
>> +	if (dp_link->phy_params.v_level > DP_LINK_VOLTAGE_MAX) {
>> +		pr_debug("Requested vSwingLevel=%d, change to %d\n",
>> +			dp_link->phy_params.v_level, DP_LINK_VOLTAGE_MAX);
>> +		dp_link->phy_params.v_level = DP_LINK_VOLTAGE_MAX;
>> +	}
>> +
>> +	if (dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_MAX) {
>> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
>> +			dp_link->phy_params.p_level, DP_LINK_PRE_EMPHASIS_MAX);
>> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_MAX;
>> +	}
>> +
>> +	if ((dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_LEVEL_1)
>> +		&& (dp_link->phy_params.v_level == DP_LINK_VOLTAGE_LEVEL_2)) {
>> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
>> +			dp_link->phy_params.p_level,
>> +			DP_LINK_PRE_EMPHASIS_LEVEL_1);
>> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_LEVEL_1;
>> +	}
>> +
>> +	pr_debug("adjusted: v_level=%d, p_level=%d\n",
>> +		dp_link->phy_params.v_level, dp_link->phy_params.p_level);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_send_psm_request(struct dp_link *dp_link, bool 
>> req)
>> +{
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> 
> This is a stub, why do this?
> 
>> +
>> +	return 0;
> 
> Further, why have a stub at all? The hook is never called, so delete it 
> all
> please.
> 
>> +}
>> +
>> +static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 
>> bpp)
>> +{
>> +	u32 tbd;
>> +
>> +	/*
>> +	 * Few simplistic rules and assumptions made here:
>> +	 *    1. Test bit depth is bit depth per color component
>> +	 *    2. Assume 3 color components
>> +	 */
>> +	switch (bpp) {
>> +	case 18:
>> +		tbd = DP_TEST_BIT_DEPTH_6;
>> +		break;
>> +	case 24:
>> +		tbd = DP_TEST_BIT_DEPTH_8;
>> +		break;
>> +	case 30:
>> +		tbd = DP_TEST_BIT_DEPTH_10;
>> +		break;
>> +	default:
>> +		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
>> +		break;
>> +	}
>> +
>> +	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
>> +		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
> 
> AFAICT tbd corresponds to a SoC register value, as opposed to the DPCD 
> value.
> It's a happy coincidence that they're the same, however I think you 
> should use a
> separate msm-specific #define instead of the drm_dp_helper values.
> 
>> +
>> +	return tbd;
>> +}
>> +
>> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_link_private *link;
>> +	struct dp_link *dp_link;
>> +
>> +	if (!dev || !aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
>> +	if (!link) {
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	link->dev   = dev;
>> +	link->aux   = aux;
>> +
>> +	dp_link = &link->dp_link;
>> +
>> +	dp_link->process_request        = dp_link_process_request;
>> +	dp_link->get_test_bits_depth    = dp_link_get_test_bits_depth;
>> +	dp_link->get_colorimetry_config = dp_link_get_colorimetry_config;
>> +	dp_link->adjust_levels          = dp_link_adjust_levels;
>> +	dp_link->send_psm_request       = dp_link_send_psm_request;
>> +	dp_link->send_test_response     = dp_link_send_test_response;
>> +	dp_link->psm_config             = dp_link_psm_config;
>> +	dp_link->send_edid_checksum     = dp_link_send_edid_checksum;
>> +
>> +	return dp_link;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_link_put(struct dp_link *dp_link)
>> +{
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link)
>> +		return;
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	devm_kfree(link->dev, link);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_link.h 
>> b/drivers/gpu/drm/msm/dp/dp_link.h
>> new file mode 100644
>> index 0000000..6d6ef43
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_link.h
>> @@ -0,0 +1,184 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_LINK_H_
>> +#define _DP_LINK_H_
>> +
>> +#include "dp_aux.h"
>> +
>> +#define DS_PORT_STATUS_CHANGED 0x200
>> +#define DP_TEST_BIT_DEPTH_UNKNOWN 0xFFFFFFFF
>> +#define DP_LINK_ENUM_STR(x)		#x
>> +
>> +enum dp_link_voltage_level {
>> +	DP_LINK_VOLTAGE_LEVEL_0	= 0,
>> +	DP_LINK_VOLTAGE_LEVEL_1	= 1,
>> +	DP_LINK_VOLTAGE_LEVEL_2	= 2,
>> +	DP_LINK_VOLTAGE_MAX	= DP_LINK_VOLTAGE_LEVEL_2,
>> +};
> 
> DP_TRAIN_VOLTAGE_SWING_*
> 
>> +
>> +enum dp_link_preemaphasis_level {
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_0	= 0,
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_1	= 1,
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_2	= 2,
>> +	DP_LINK_PRE_EMPHASIS_MAX	= DP_LINK_PRE_EMPHASIS_LEVEL_2,
>> +};
> 
> DP_TRAIN_PRE_EMPH*
> 
>> +
>> +struct dp_link_sink_count {
>> +	u32 count;
>> +	bool cp_ready;
>> +};
>> +
>> +struct dp_link_test_video {
>> +	u32 test_video_pattern;
>> +	u32 test_bit_depth;
>> +	u32 test_dyn_range;
>> +	u32 test_h_total;
>> +	u32 test_v_total;
>> +	u32 test_h_start;
>> +	u32 test_v_start;
>> +	u32 test_hsync_pol;
>> +	u32 test_hsync_width;
>> +	u32 test_vsync_pol;
>> +	u32 test_vsync_width;
>> +	u32 test_h_width;
>> +	u32 test_v_height;
>> +	u32 test_rr_d;
>> +	u32 test_rr_n;
>> +};
>> +
>> +struct dp_link_test_audio {
>> +	u32 test_audio_sampling_rate;
>> +	u32 test_audio_channel_count;
>> +	u32 test_audio_pattern_type;
>> +	u32 test_audio_period_ch_1;
>> +	u32 test_audio_period_ch_2;
>> +	u32 test_audio_period_ch_3;
>> +	u32 test_audio_period_ch_4;
>> +	u32 test_audio_period_ch_5;
>> +	u32 test_audio_period_ch_6;
>> +	u32 test_audio_period_ch_7;
>> +	u32 test_audio_period_ch_8;
>> +};
>> +
>> +struct dp_link_phy_params {
>> +	u32 phy_test_pattern_sel;
>> +	u8 v_level;
>> +	u8 p_level;
>> +};
>> +
>> +struct dp_link_params {
>> +	u32 lane_count;
>> +	u32 bw_code;
>> +};
> 
> Use drm_dp_link
> 
>> +
>> +struct dp_link {
>> +	u32 sink_request;
>> +	u32 test_response;
>> +	bool psm_enabled;
>> +
>> +	struct dp_link_sink_count sink_count;
>> +	struct dp_link_test_video test_video;
>> +	struct dp_link_test_audio test_audio;
>> +	struct dp_link_phy_params phy_params;
>> +	struct dp_link_params link_params;
>> +
>> +	u32 (*get_test_bits_depth)(struct dp_link *dp_link, u32 bpp);
>> +	int (*process_request)(struct dp_link *dp_link);
>> +	int (*get_colorimetry_config)(struct dp_link *dp_link);
>> +	int (*adjust_levels)(struct dp_link *dp_link, u8 *link_status);
>> +	int (*send_psm_request)(struct dp_link *dp_link, bool req);
>> +	void (*send_test_response)(struct dp_link *dp_link);
>> +	int (*psm_config)(struct dp_link *dp_link,
>> +		struct drm_dp_link *link_info, bool enable);
>> +	void (*send_edid_checksum)(struct dp_link *dp_link, u8 checksum);
>> +};
>> +
>> +static inline char *dp_link_get_phy_test_pattern(u32 
>> phy_test_pattern_sel)
>> +{
>> +	switch (phy_test_pattern_sel) {
>> +	case DP_TEST_PHY_PATTERN_NONE:
>> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_NONE);
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING);
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT);
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_PRBS7);
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN);
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> This is only used for debug statements, just remove it and print the 
> enum as an
> int. This will let you remove DP_LINK_ENUM_STR as well.
> 
>> +
>> +/**
>> + * mdss_dp_test_bit_depth_to_bpp() - convert test bit depth to bpp
>> + * @tbd: test bit depth
>> + *
>> + * Returns the bits per pixel (bpp) to be used corresponding to the
>> + * git bit depth value. This function assumes that bit depth has
>> + * already been validated.
>> + */
>> +static inline u32 dp_link_bit_depth_to_bpp(u32 tbd)
>> +{
>> +	u32 bpp;
>> +
>> +	/*
>> +	 * Few simplistic rules and assumptions made here:
>> +	 *    1. Bit depth is per color component
>> +	 *    2. If bit depth is unknown return 0
>> +	 *    3. Assume 3 color components
>> +	 */
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +		bpp = 18;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_8:
>> +		bpp = 24;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		bpp = 30;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
>> +	default:
>> +		bpp = 0;
>> +	}
>> +
>> +	return bpp;
> 
> Just return directly from each case.
> 
>> +}
>> +
>> +/**
>> + * dp_link_get() - get the functionalities of dp test module
>> + *
>> + *
>> + * return: a pointer to dp_link struct
>> + */
>> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux);
>> +
>> +/**
>> + * dp_link_put() - releases the dp test module's resources
>> + *
>> + * @dp_link: an instance of dp_link module
>> + *
>> + */
>> +void dp_link_put(struct dp_link *dp_link);
>> +
>> +#endif /* _DP_LINK_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.c 
>> b/drivers/gpu/drm/msm/dp/dp_panel.c
>> new file mode 100644
>> index 0000000..e497b44
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_panel.c
>> @@ -0,0 +1,624 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include "dp_panel.h"
>> +
>> +#include <drm/drm_connector.h>
>> +#include <drm/drm_edid.h>
>> +
>> +#define DP_PANEL_DEFAULT_BPP 24
> 
> unused
> 
>> +#define DP_MAX_DS_PORT_COUNT 1
>> +
>> +enum {
>> +	DP_LINK_RATE_MULTIPLIER = 27000000,
>> +};
> 
> unused
> 
>> +
>> +struct dp_panel_private {
>> +	struct device *dev;
>> +	struct dp_panel dp_panel;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_catalog_panel *catalog;
>> +	bool panel_on;
>> +	bool aux_cfg_update_done;
>> +};
>> +
>> +static const struct dp_panel_info fail_safe = {
>> +	.h_active = 640,
>> +	.v_active = 480,
>> +	.h_back_porch = 48,
>> +	.h_front_porch = 16,
>> +	.h_sync_width = 96,
>> +	.h_active_low = 0,
>> +	.v_back_porch = 33,
>> +	.v_front_porch = 10,
>> +	.v_sync_width = 2,
>> +	.v_active_low = 0,
>> +	.h_skew = 0,
>> +	.refresh_rate = 60,
>> +	.pixel_clk_khz = 25200,
>> +	.bpp = 24,
>> +};
> 
> Drop this, userspace can add a mode if appropriate
> 
>> +
>> +static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
>> +{
>> +	int rlen, rc = 0;
>> +	struct dp_panel_private *panel;
>> +	struct drm_dp_link *link_info;
>> +	u8 *dpcd, major = 0, minor = 0;
>> +	u32 dfp_count = 0;
>> +	unsigned long caps = DP_LINK_CAP_ENHANCED_FRAMING;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dpcd = dp_panel->dpcd;
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	link_info = &dp_panel->link_info;
>> +
>> +	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DPCD_REV,
>> +		dpcd, (DP_RECEIVER_CAP_SIZE + 1));
>> +	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
>> +		pr_err("dpcd read failed, rlen=%d\n", rlen);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	link_info->revision = dp_panel->dpcd[DP_DPCD_REV];
>> +
>> +	major = (link_info->revision >> 4) & 0x0f;
>> +	minor = link_info->revision & 0x0f;
>> +	pr_debug("version: %d.%d\n", major, minor);
>> +
>> +	link_info->rate =
>> +		drm_dp_bw_code_to_link_rate(dp_panel->dpcd[DP_MAX_LINK_RATE]);
>> +	pr_debug("link_rate=%d\n", link_info->rate);
>> +
>> +	link_info->num_lanes = dp_panel->dpcd[DP_MAX_LANE_COUNT] &
>> +				DP_MAX_LANE_COUNT_MASK;
>> +
>> +	pr_debug("lane_count=%d\n", link_info->num_lanes);
>> +
>> +	if (drm_dp_enhanced_frame_cap(dpcd))
>> +		link_info->capabilities |= caps;
> 
> All of the link_info initialization should be done by 
> drm_dp_link_probe().
> 
>> +
>> +	dfp_count = dpcd[DP_DOWN_STREAM_PORT_COUNT] &
>> +						DP_DOWN_STREAM_PORT_COUNT;
> 
> Move this down to where it's used
> 
>> +
>> +	if ((dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)
>> +		&& (dpcd[DP_DPCD_REV] > 0x10)) {
>> +		rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
>> +			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
>> +			DP_MAX_DOWNSTREAM_PORTS);
>> +		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
>> +			pr_err("ds port status failed, rlen=%d\n", rlen);
>> +			rc = -EINVAL;
>> +			goto end;
>> +		}
>> +	}
> 
> You don't use ds_ports anywhere, so remove this and remove ds_ports
> 
>> +
>> +	if (dfp_count > DP_MAX_DS_PORT_COUNT)
>> +		pr_debug("DS port count %d greater that max (%d) supported\n",
>> +			dfp_count, DP_MAX_DS_PORT_COUNT);
> 
> Should this be an error?
> 
>> +
>> +end:
>> +	return rc;
> 
> Same drill as before
> 
>> +}
>> +
>> +static int dp_panel_set_default_link_params(struct dp_panel 
>> *dp_panel)
>> +{
> 
> Let's just fail instead of doing this.
> 
>> +	struct drm_dp_link *link_info;
>> +	const int default_bw_code = 162000;
>> +	const int default_num_lanes = 1;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +	link_info = &dp_panel->link_info;
>> +	link_info->rate = default_bw_code;
>> +	link_info->num_lanes = default_num_lanes;
>> +	pr_debug("link_rate=%d num_lanes=%d\n",
>> +		link_info->rate, link_info->num_lanes);
>> +	return 0;
>> +}
>> +
>> +static int dp_panel_read_edid(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector)
>> +{
>> +	int retry_cnt = 0;
>> +	const int max_retry = 10;
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	do {
>> +		kfree(dp_panel->edid);
>> +		dp_panel->edid = drm_get_edid(connector,
>> +					      &panel->aux->drm_aux->ddc);
>> +		if (!dp_panel->edid) {
>> +			pr_err("EDID read failed\n");
>> +			retry_cnt++;
>> +			panel->aux->reconfig(panel->aux);
>> +			panel->aux_cfg_update_done = true;
>> +		} else {
>> +			return 0;
>> +		}
>> +	} while (retry_cnt < max_retry);
> 
> The core will do retrys when aux reads fail, so you don't need to. With 
> that,
> you can just remove this function and call drm_get_edid in 
> read_sink_caps
> 
>> +
>> +	return -EINVAL;
>> +}
>> +
>> +static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel || !connector) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	rc = dp_panel_read_dpcd(dp_panel);
>> +	if (rc || !is_link_rate_valid(drm_dp_link_rate_to_bw_code(
>> +		dp_panel->link_info.rate)) || !is_lane_count_valid(
>> +		dp_panel->link_info.num_lanes) ||
>> +		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
>> +		dp_panel->max_bw_code)) {
>> +		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
>> +			pr_err("DPCD read failed, return early\n");
>> +			return rc;
>> +		}
>> +		pr_err("panel dpcd read failed/incorrect, set default params\n");
>> +		dp_panel_set_default_link_params(dp_panel);
>> +	}
> 
> Since the defaults are going away, this gets simpler (and even simpler 
> if you
> stash bw_code):
> 
> 	bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate);
> 	if (rc || !is_link_rate_valid(bw_code) ||
>             !is_lane_count_valid(dp_panel->link_info.num_lanes) ||
> 	    bw_code > dp_panel->max_bw_code) {
> 		pr_err("read_dpcd failed %d\n", rc);
> 		return rc;
> 	}
> 
>> +
>> +	rc = dp_panel_read_edid(dp_panel, connector);
> 
> Why read the edid so early? Can't you wait until get_modes is called 
> (you'll
> have to re-read anyways).
> 
>> +	if (rc) {
>> +		pr_err("panel edid read failed, set failsafe mode\n");
>> +		return rc;
>> +	}
>> +
>> +	if (panel->aux_cfg_update_done) {
>> +		pr_debug("read DPCD with updated AUX config\n");
>> +		dp_panel_read_dpcd(dp_panel);
> 
> Check return value. Should you also check the rate/lane_count validity
> again too?
> 
>> +		panel->aux_cfg_update_done = false;
> 
> Should you have locking for aux_cfg_update_done?
> 
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>> +{
>> +	struct drm_dp_link *link_info;
>> +	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
>> +	u32 bpp = 0, data_rate_khz = 0;
>> +
>> +	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
>> +
>> +	link_info = &dp_panel->link_info;
>> +	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
>> +
>> +	while (bpp > min_supported_bpp) {
>> +		if (mode_pclk_khz * bpp <= data_rate_khz)
>> +			break;
>> +		bpp -= 6;
> 
> Watch out for underflow here.
> 
>> +	}
>> +
>> +	return bpp;
>> +}
>> +
>> +static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>> +{
>> +	struct dp_panel_private *panel;
>> +	u32 bpp = mode_edid_bpp;
>> +
>> +	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
>> +		pr_err("invalid input\n");
>> +		return 0;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (dp_panel->video_test)
>> +		bpp = dp_link_bit_depth_to_bpp(
>> +				panel->link->test_video.test_bit_depth);
>> +	else
>> +		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
>> +				mode_pclk_khz);
>> +
>> +	return bpp;
>> +}
>> +
>> +static void dp_panel_set_test_mode(struct dp_panel_private *panel,
>> +		struct dp_display_mode *mode)
>> +{
>> +	struct dp_panel_info *pinfo = NULL;
> 
> 
> As mentioned earlier, no need to duplicate drm_display_mode into
> dp_display_mode, same goes for dp_panel_info, please just use 
> drm_display_mode.
> 
>> +	struct dp_link_test_video *test_info = NULL;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	pinfo = &mode->timing;
>> +	test_info = &panel->link->test_video;
>> +
>> +	pinfo->h_active = test_info->test_h_width;
>> +	pinfo->h_sync_width = test_info->test_hsync_width;
>> +	pinfo->h_back_porch = test_info->test_h_start -
>> +		test_info->test_hsync_width;
>> +	pinfo->h_front_porch = test_info->test_h_total -
>> +		(test_info->test_h_start + test_info->test_h_width);
>> +
>> +	pinfo->v_active = test_info->test_v_height;
>> +	pinfo->v_sync_width = test_info->test_vsync_width;
>> +	pinfo->v_back_porch = test_info->test_v_start -
>> +		test_info->test_vsync_width;
>> +	pinfo->v_front_porch = test_info->test_v_total -
>> +		(test_info->test_v_start + test_info->test_v_height);
>> +
>> +	pinfo->bpp = dp_link_bit_depth_to_bpp(test_info->test_bit_depth);
>> +	pinfo->h_active_low = test_info->test_hsync_pol;
>> +	pinfo->v_active_low = test_info->test_vsync_pol;
>> +
>> +	pinfo->refresh_rate = test_info->test_rr_n;
>> +	pinfo->pixel_clk_khz = test_info->test_h_total *
>> +		test_info->test_v_total * pinfo->refresh_rate;
>> +
>> +	if (test_info->test_rr_d == 0)
>> +		pinfo->pixel_clk_khz /= 1000;
>> +	else
>> +		pinfo->pixel_clk_khz /= 1001;
>> +
>> +	if (test_info->test_h_width == 640)
>> +		pinfo->pixel_clk_khz = 25170;
>> +}
>> +
>> +static int dp_panel_update_modes(struct drm_connector *connector,
>> +	struct edid *edid)
>> +{
>> +	int rc = 0;
>> +
>> +	pr_debug("%s +", __func__);
> 
> remove
> 
> Ok, so this is where you should be reading edid.
> 
>> +	if (edid) {
>> +		drm_connector_update_edid_property(connector,
>> +			edid);
> 
> Join on one line and check return value
> 
>> +		rc = drm_add_edid_modes(connector, edid);
>> +		pr_debug("%s -", __func__);
>> +		return rc;
>> +	}
>> +
>> +	drm_connector_update_edid_property(connector, NULL);
> 
> Check return value
> 
>> +	pr_debug("%s null edid -", __func__);
>> +	return rc;
> 
> This is always 0
> 
>> +}
>> +
>> +static int dp_panel_get_modes(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector, struct dp_display_mode *mode)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (dp_panel->video_test) {
>> +		dp_panel_set_test_mode(panel, mode);
>> +		return 1;
>> +	} else if (dp_panel->edid) {
>> +	  return dp_panel_update_modes(connector, dp_panel->edid);
> 
> Indentation is wrong
> 
>> +	}
>> +
>> +	/* fail-safe mode */
>> +	memcpy(&mode->timing, &fail_safe,
>> +		sizeof(fail_safe));
>> +	return 1;
> 
> Delete fail safe and return 0;
> 
>> +}
>> +
>> +static u8 dp_panel_get_edid_checksum(struct edid *edid)
>> +{
>> +	struct edid *last_block = NULL;
>> +	u8 *raw_edid = NULL;
> 
> No need to initialize these.
> 
>> +
>> +	if (!edid) {
>> +		pr_err("invalid edid input\n");
>> +		return 0;
>> +	}
>> +
>> +	raw_edid = (u8 *)edid;
>> +	raw_edid += (edid->extensions * EDID_LENGTH);
>> +	last_block = (struct edid *)raw_edid;
>> +
>> +	if (last_block)
> 
> I doubt last_block will ever be NULL, so this check is kind of 
> pointless.
> Perhaps call drm_edid_block_valid() instead.
> 
>> +		return last_block->checksum;
>> +
>> +	pr_err("Invalid block, no checksum\n");
>> +	return 0;
>> +}
>> +
>> +static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
>> +		u8 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
>> +
>> +		panel->link->send_edid_checksum(panel->link, checksum);
>> +		panel->link->send_test_response(panel->link);
>> +	}
>> +}
>> +
>> +static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool 
>> enable)
>> +{
>> +	u32 hsync_start_x, hsync_end_x;
>> +	struct dp_catalog_panel *catalog;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	catalog = panel->catalog;
>> +	pinfo = &panel->dp_panel.pinfo;
>> +
>> +	if (!panel->panel_on) {
>> +		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
>> +		return;
>> +	}
>> +
>> +	if (!enable) {
>> +		panel->catalog->tpg_config(catalog, false);
>> +		return;
>> +	}
>> +
>> +	/* TPG config */
>> +	catalog->hsync_period = pinfo->h_sync_width + pinfo->h_back_porch +
>> +			pinfo->h_active + pinfo->h_front_porch;
>> +	catalog->vsync_period = pinfo->v_sync_width + pinfo->v_back_porch +
>> +			pinfo->v_active + pinfo->v_front_porch;
>> +
>> +	catalog->display_v_start = ((pinfo->v_sync_width +
>> +			pinfo->v_back_porch) * catalog->hsync_period);
>> +	catalog->display_v_end = ((catalog->vsync_period -
>> +			pinfo->v_front_porch) * catalog->hsync_period) - 1;
>> +
>> +	catalog->display_v_start += pinfo->h_sync_width + 
>> pinfo->h_back_porch;
>> +	catalog->display_v_end -= pinfo->h_front_porch;
>> +
>> +	hsync_start_x = pinfo->h_back_porch + pinfo->h_sync_width;
>> +	hsync_end_x = catalog->hsync_period - pinfo->h_front_porch - 1;
>> +
>> +	catalog->v_sync_width = pinfo->v_sync_width;
>> +
>> +	catalog->hsync_ctl = (catalog->hsync_period << 16) |
>> +			pinfo->h_sync_width;
>> +	catalog->display_hctl = (hsync_end_x << 16) | hsync_start_x;
> 
> More mode timing parameters to delete!
> 
>> +
>> +	pr_err("%s: calling catalog tpg_config\n", __func__);
>> +	panel->catalog->tpg_config(catalog, true);
>> +}
>> +
>> +static int dp_panel_timing_cfg(struct dp_panel *dp_panel)
>> +{
>> +	int rc = 0;
>> +	u32 data, total_ver, total_hor;
>> +	struct dp_catalog_panel *catalog;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
> This is called from 2 different places, do you need locking?
> 
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	catalog = panel->catalog;
>> +	pinfo = &panel->dp_panel.pinfo;
>> +
>> +	pr_debug("width=%d hporch= %d %d %d\n",
>> +		pinfo->h_active, pinfo->h_back_porch,
>> +		pinfo->h_front_porch, pinfo->h_sync_width);
>> +
>> +	pr_debug("height=%d vporch= %d %d %d\n",
>> +		pinfo->v_active, pinfo->v_back_porch,
>> +		pinfo->v_front_porch, pinfo->v_sync_width);
>> +
>> +	total_hor = pinfo->h_active + pinfo->h_back_porch +
>> +		pinfo->h_front_porch + pinfo->h_sync_width;
>> +
>> +	total_ver = pinfo->v_active + pinfo->v_back_porch +
>> +			pinfo->v_front_porch + pinfo->v_sync_width;
>> +
>> +	data = total_ver;
>> +	data <<= 16;
>> +	data |= total_hor;
>> +
>> +	catalog->total = data;
>> +
>> +	data = (pinfo->v_back_porch + pinfo->v_sync_width);
>> +	data <<= 16;
>> +	data |= (pinfo->h_back_porch + pinfo->h_sync_width);
>> +
>> +	catalog->sync_start = data;
>> +
>> +	data = pinfo->v_sync_width;
>> +	data <<= 16;
>> +	data |= (pinfo->v_active_low << 31);
>> +	data |= pinfo->h_sync_width;
>> +	data |= (pinfo->h_active_low << 15);
>> +
>> +	catalog->width_blanking = data;
>> +
>> +	data = pinfo->v_active;
>> +	data <<= 16;
>> +	data |= pinfo->h_active;
>> +
>> +	catalog->dp_active = data;
>> +
>> +	panel->catalog->timing_cfg(catalog);
>> +	panel->panel_on = true;
> 
> Again, all of this should be derived from a drm_display_mode at the 
> point where
> it is committed to hardware. No need to store it in another form in the 
> interim
> 
> 
>> +end:
>> +	return rc;
> 
> Remove end/rc and return directly
> 
>> +}
>> +
>> +static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	pinfo = &dp_panel->pinfo;
>> +
>> +	/*
>> +	 * print resolution info as this is a result
>> +	 * of user initiated action of cable connection
>> +	 */
>> +	pr_info("SET NEW RESOLUTION:\n");
>> +	pr_info("%dx%d@%dfps\n", pinfo->h_active,
>> +		pinfo->v_active, pinfo->refresh_rate);
>> +	pr_info("h_porches(back|front|width) = (%d|%d|%d)\n",
>> +			pinfo->h_back_porch,
>> +			pinfo->h_front_porch,
>> +			pinfo->h_sync_width);
>> +	pr_info("v_porches(back|front|width) = (%d|%d|%d)\n",
>> +			pinfo->v_back_porch,
>> +			pinfo->v_front_porch,
>> +			pinfo->v_sync_width);
>> +	pr_info("pixel clock (KHz)=(%d)\n", pinfo->pixel_clk_khz);
>> +	pr_info("bpp = %d\n", pinfo->bpp);
>> +	pr_info("active low (h|v)=(%d|%d)\n", pinfo->h_active_low,
>> +		pinfo->v_active_low);
>> +
>> +	pinfo->bpp = max_t(u32, 18, min_t(u32, pinfo->bpp, 30));
>> +	pr_info("updated bpp = %d\n", pinfo->bpp);
> 
> 
> No info level logs, please.
> 
>> +end:
>> +	return rc;
> 
> Remove end/rc and return directly
> 
>> +}
>> +
>> +static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
>> +{
>> +	const u32 encoding_factx10 = 8;
>> +	u32 min_link_rate_khz = 0, lane_cnt;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
> 
> The only way to call this function is through a dp_panel callback, and 
> yet we
> check if dp_panel is NULL :)
> 
> The same is true for most functions in this patch. Things will be a lot 
> simpler
> when all of these are removed. This function will no longer have an 
> error path
> and lane_cnt/pinfo can be initialized directly above.
> 
> 
>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	lane_cnt = dp_panel->link_info.num_lanes;
>> +	pinfo = &dp_panel->pinfo;
>> +
>> +	/* num_lanes * lane_count * 8 >= pclk * bpp * 10 */
>> +	min_link_rate_khz = pinfo->pixel_clk_khz /
>> +				(lane_cnt * encoding_factx10);
>> +	min_link_rate_khz *= pinfo->bpp;
>> +
>> +	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
>> +		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
>> +		pinfo->bpp);
>> +end:
>> +	return min_link_rate_khz;
> 
> Remove end and return directly above
> 
>> +}
>> +
>> +struct dp_panel *dp_panel_get(struct dp_panel_in *in)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel *dp_panel;
>> +
>> +	if (!in->dev || !in->catalog || !in->aux || !in->link) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
>> +	if (!panel) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	panel->dev = in->dev;
>> +	panel->aux = in->aux;
>> +	panel->catalog = in->catalog;
>> +	panel->link = in->link;
>> +
>> +	dp_panel = &panel->dp_panel;
>> +	dp_panel->max_bw_code = DP_LINK_BW_8_1;
>> +	panel->aux_cfg_update_done = false;
>> +
>> +	dp_panel->init_info = dp_panel_init_panel_info;
>> +	dp_panel->timing_cfg = dp_panel_timing_cfg;
>> +	dp_panel->read_sink_caps = dp_panel_read_sink_caps;
>> +	dp_panel->get_min_req_link_rate = dp_panel_get_min_req_link_rate;
>> +	dp_panel->get_mode_bpp = dp_panel_get_mode_bpp;
>> +	dp_panel->get_modes = dp_panel_get_modes;
>> +	dp_panel->handle_sink_request = dp_panel_handle_sink_request;
>> +	dp_panel->tpg_config = dp_panel_tpg_config;
>> +
>> +	return dp_panel;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_panel_put(struct dp_panel *dp_panel)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel)
>> +		return;
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	kfree(dp_panel->edid);
>> +	dp_panel->edid = NULL;
>> +	devm_kfree(panel->dev, panel);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.h 
>> b/drivers/gpu/drm/msm/dp/dp_panel.h
>> new file mode 100644
>> index 0000000..bf802df
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_panel.h
>> @@ -0,0 +1,121 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_PANEL_H_
>> +#define _DP_PANEL_H_
>> +
>> +#include <drm/msm_drm.h>
>> +
>> +#include "dp_aux.h"
>> +#include "dp_link.h"
>> +#include "dp_extcon.h"
>> +
>> +struct edid;
>> +
>> +enum dp_lane_count {
>> +	DP_LANE_COUNT_1	= 1,
>> +	DP_LANE_COUNT_2	= 2,
>> +	DP_LANE_COUNT_4	= 4,
>> +};
> 
> You don't need an enum for this, the value coming from dpcd is just an
> integer and
> can be used as such.
> 
>> +
>> +#define DP_MAX_DOWNSTREAM_PORTS 0x10
>> +
>> +struct dp_panel_info {
>> +	u32 h_active;
>> +	u32 v_active;
>> +	u32 h_back_porch;
>> +	u32 h_front_porch;
>> +	u32 h_sync_width;
>> +	u32 h_active_low;
>> +	u32 v_back_porch;
>> +	u32 v_front_porch;
>> +	u32 v_sync_width;
>> +	u32 v_active_low;
>> +	u32 h_skew;
>> +	u32 refresh_rate;
>> +	u32 pixel_clk_khz;
>> +	u32 bpp;
>> +};
> 
> Drop this struct and use drm_display_mode
> 
> 
>> +
>> +struct dp_display_mode {
>> +	struct dp_panel_info timing;
>> +	u32 capabilities;
>> +};
>> +
>> +struct dp_panel_in {
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_catalog_panel *catalog;
>> +};
>> +
>> +struct dp_panel {
>> +	/* dpcd raw data */
>> +	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];
> 
> Why + 1?
> 
>> +	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
>> +
>> +	struct drm_dp_link link_info;
>> +	struct edid *edid;
>> +	struct drm_connector *connector;
>> +	struct dp_panel_info pinfo;
>> +	bool video_test;
>> +
>> +	u32 vic;
>> +	u32 max_pclk_khz;
>> +
>> +	u32 max_bw_code;
>> +	int (*init_info)(struct dp_panel *dp_panel);
>> +	int (*deinit)(struct dp_panel *dp_panel);
>> +	int (*timing_cfg)(struct dp_panel *dp_panel);
>> +	int (*read_sink_caps)(struct dp_panel *dp_panel,
>> +		struct drm_connector *connector);
>> +	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);
> 
> This function isn't called anywhere
> 
>> +	u32 (*get_mode_bpp)(struct dp_panel *dp_panel, u32 mode_max_bpp,
>> +			u32 mode_pclk_khz);
>> +	int (*get_modes)(struct dp_panel *dp_panel,
>> +		struct drm_connector *connector, struct dp_display_mode *mode);
>> +	void (*handle_sink_request)(struct dp_panel *dp_panel);
>> +	void (*tpg_config)(struct dp_panel *dp_panel, bool enable);
>> +};
>> +
>> +/**
>> + * is_link_rate_valid() - validates the link rate
>> + * @lane_rate: link rate requested by the sink
>> + *
>> + * Returns true if the requested link rate is supported.
>> + */
>> +static inline bool is_link_rate_valid(u32 bw_code)
>> +{
>> +	return ((bw_code == DP_LINK_BW_1_62) ||
>> +		(bw_code == DP_LINK_BW_2_7) ||
>> +		(bw_code == DP_LINK_BW_5_4) ||
>> +		(bw_code == DP_LINK_BW_8_1));
> 
> Each of these conditions has unneeded ()
> 
>> +}
>> +
>> +/**
>> + * dp_link_is_lane_count_valid() - validates the lane count
>> + * @lane_count: lane count requested by the sink
>> + *
>> + * Returns true if the requested lane count is supported.
>> + */
>> +static inline bool is_lane_count_valid(u32 lane_count)
>> +{
>> +	return (lane_count == DP_LANE_COUNT_1) ||
>> +		(lane_count == DP_LANE_COUNT_2) ||
>> +		(lane_count == DP_LANE_COUNT_4);
>> +}
>> +
>> +struct dp_panel *dp_panel_get(struct dp_panel_in *in);
>> +void dp_panel_put(struct dp_panel *dp_panel);
>> +#endif /* _DP_PANEL_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.c 
>> b/drivers/gpu/drm/msm/dp/dp_parser.c
>> new file mode 100644
>> index 0000000..a366dc5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_parser.c
>> @@ -0,0 +1,679 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/of_gpio.h>
>> +
>> +#include "dp_parser.h"
>> +
>> +static void dp_parser_unmap_io_resources(struct dp_parser *parser)
>> +{
>> +	struct dp_io *io = &parser->io;
>> +
>> +	msm_dss_iounmap(&io->dp_ahb);
>> +	msm_dss_iounmap(&io->dp_aux);
>> +	msm_dss_iounmap(&io->dp_link);
>> +	msm_dss_iounmap(&io->dp_p0);
>> +	msm_dss_iounmap(&io->phy_io);
>> +	msm_dss_iounmap(&io->ln_tx0_io);
>> +	msm_dss_iounmap(&io->ln_tx0_io);
>> +	msm_dss_iounmap(&io->dp_pll_io);
>> +	msm_dss_iounmap(&io->dp_cc_io);
>> +	msm_dss_iounmap(&io->usb3_dp_com);
>> +	msm_dss_iounmap(&io->qfprom_io);
>> +}
>> +
>> +static int dp_parser_ctrl_res(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	u32 index;
>> +	struct platform_device *pdev = parser->pdev;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	struct dp_io *io = &parser->io;
>> +
>> +	rc = of_property_read_u32(of_node, "cell-index", &index);
>> +	if (rc) {
>> +		pr_err("cell-index not specified, rc=%d\n", rc);
>> +		goto err;
> 
> This can be a direct return of rc.
> 
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_ahb, "dp_ahb");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
> 
> Print rc here and below.
> 
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_aux, "dp_aux");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_link, "dp_link");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_p0, "dp_p0");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->phy_io, "dp_phy");
>> +	if (rc) {
>> +		pr_err("unable to remap dp PHY resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx0_io, "dp_ln_tx0");
>> +	if (rc) {
>> +		pr_err("unable to remap dp TX0 resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx1_io, "dp_ln_tx1");
>> +	if (rc) {
>> +		pr_err("unable to remap dp TX1 resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_pll_io, "dp_pll");
>> +	if (rc) {
>> +		pr_err("unable to remap DP PLL resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->usb3_dp_com, "usb3_dp_com");
>> +	if (rc) {
>> +		pr_err("unable to remap USB3 DP com resources\n");
>> +		goto err;
>> +	}
>> +
>> +	if (msm_dss_ioremap_byname(pdev, &io->dp_cc_io, "dp_mmss_cc")) {
>> +		pr_err("unable to remap dp MMSS_CC resources\n");
>> +		goto err;
>> +	}
>> +
>> +	if (msm_dss_ioremap_byname(pdev, &io->qfprom_io, "qfprom_physical"))
>> +		pr_warn("unable to remap dp qfprom resources\n");
>> +
>> +	return 0;
>> +err:
>> +	dp_parser_unmap_io_resources(parser);
>> +	return rc;
>> +}
>> +
>> +static const char *dp_get_phy_aux_config_property(u32 cfg_type)
>> +{
>> +	switch (cfg_type) {
>> +	case PHY_AUX_CFG0:
>> +		return "qcom,aux-cfg0-settings";
>> +	case PHY_AUX_CFG1:
>> +		return "qcom,aux-cfg1-settings";
>> +	case PHY_AUX_CFG2:
>> +		return "qcom,aux-cfg2-settings";
>> +	case PHY_AUX_CFG3:
>> +		return "qcom,aux-cfg3-settings";
>> +	case PHY_AUX_CFG4:
>> +		return "qcom,aux-cfg4-settings";
>> +	case PHY_AUX_CFG5:
>> +		return "qcom,aux-cfg5-settings";
>> +	case PHY_AUX_CFG6:
>> +		return "qcom,aux-cfg6-settings";
>> +	case PHY_AUX_CFG7:
>> +		return "qcom,aux-cfg7-settings";
>> +	case PHY_AUX_CFG8:
>> +		return "qcom,aux-cfg8-settings";
>> +	case PHY_AUX_CFG9:
>> +		return "qcom,aux-cfg9-settings";
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static void dp_parser_phy_aux_cfg_reset(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
>> +		parser->aux_cfg[i] = (const struct dp_aux_cfg){ 0 };
>> +}
> 
> No need for a separate function, just put the loop in the error label 
> below.
> 
>> +
>> +static int dp_parser_aux(struct dp_parser *parser)
>> +{
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	int len = 0, i = 0, j = 0, config_count = 0;
>> +	const char *data;
>> +	int const minimum_config_count = 1;
> 
> Just use 1 directly
> 
>> +
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
>> +		const char *property = dp_get_phy_aux_config_property(i);
>> +
>> +		data = of_get_property(of_node, property, &len);
>> +		if (!data) {
> 
> You should use of_property_read_u32() instead of reading as a string
> 
>> +			pr_err("Unable to read %s\n", property);
>> +			goto error;
>> +		}
>> +
>> +		config_count = len - 1;
>> +		if ((config_count < minimum_config_count) ||
>> +			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {
> 
> Remove extra ()
> 
>> +			pr_err("Invalid config count (%d) configs for %s\n",
>> +					config_count, property);
>> +			goto error;
>> +		}
>> +
>> +		parser->aux_cfg[i].offset = data[0];
>> +		parser->aux_cfg[i].cfg_cnt = config_count;
>> +		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
>> +				property,
>> +				parser->aux_cfg[i].offset,
>> +				parser->aux_cfg[i].cfg_cnt);
>> +		for (j = 1; j < len; j++) {
>> +			parser->aux_cfg[i].lut[j - 1] = data[j];
> 
> And this could use of_property_read_u32_array()
> 
>> +			pr_debug("%s lut[%d]=0x%x\n",
>> +					property,
>> +					i,
>> +					parser->aux_cfg[i].lut[j - 1]);
>> +		}
>> +	}
>> +		return 0;
>> +
>> +error:
>> +	dp_parser_phy_aux_cfg_reset(parser);
>> +	return -EINVAL;
>> +}
>> +
>> +static int dp_parser_misc(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +
>> +	rc = of_property_read_u32(of_node,
>> +		"qcom,max-pclk-frequency-khz", &parser->max_pclk_khz);
>> +	if (rc)
>> +		parser->max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_parser_pinctrl(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct dp_pinctrl *pinctrl = &parser->pinctrl;
>> +
>> +	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
>> +
>> +	if (IS_ERR_OR_NULL(pinctrl->pin)) {
>> +		rc = PTR_ERR(pinctrl->pin);
>> +		pr_err("failed to get pinctrl, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +
>> +	pinctrl->state_active = pinctrl_lookup_state(pinctrl->pin,
>> +					"mdss_dp_active");
>> +	if (IS_ERR_OR_NULL(pinctrl->state_active)) {
>> +		rc = PTR_ERR(pinctrl->state_active);
> 
> What if it's NULL?
> 
>> +		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +
>> +	pinctrl->state_suspend = pinctrl_lookup_state(pinctrl->pin,
>> +					"mdss_dp_sleep");
>> +	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
>> +		rc = PTR_ERR(pinctrl->state_suspend);
> 
> What if it's NULL?
> 
>> +		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_parser_gpio(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +	struct device *dev = &parser->pdev->dev;
>> +	struct device_node *of_node = dev->of_node;
>> +	struct dss_module_power *mp = &parser->mp[DP_CORE_PM];
>> +	static const char * const dp_gpios[] = {
>> +		"qcom,aux-en-gpio",
>> +		"qcom,aux-sel-gpio",
>> +		"qcom,usbplug-cc-gpio",
>> +	};
>> +
>> +	mp->gpio_config = devm_kzalloc(dev,
>> +		sizeof(struct dss_gpio) * ARRAY_SIZE(dp_gpios), GFP_KERNEL);
>> +	if (!mp->gpio_config)
>> +		return -ENOMEM;
>> +
>> +	mp->num_gpio = ARRAY_SIZE(dp_gpios);
> 
> If you do this first, you can s/ARRAY_SIZE(dp_gpios)/mp->num_gpio/ in 
> the rest
> of the function.
> 
>> +
>> +	for (i = 0; i < ARRAY_SIZE(dp_gpios); i++) {
>> +		mp->gpio_config[i].gpio = of_get_named_gpio(of_node,
>> +			dp_gpios[i], 0);
>> +
>> +		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
>> +			pr_err("%s gpio not specified\n", dp_gpios[i]);
>> +			return -EINVAL;
>> +		}
>> +
>> +		strlcpy(mp->gpio_config[i].gpio_name, dp_gpios[i],
>> +			sizeof(mp->gpio_config[i].gpio_name));
> 
> As mentioned earlier, please don't implement your own string 
> store/lookup, just
> provide access to the gpios in a more direct manner (pointer or 
> function).
> 
>> +
>> +		mp->gpio_config[i].value = 0;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static const char *dp_parser_supply_node_name(enum dp_pm_type module)
>> +{
>> +	switch (module) {
>> +	case DP_CORE_PM:	return "qcom,core-supply-entries";
>> +	case DP_CTRL_PM:	return "qcom,ctrl-supply-entries";
>> +	case DP_PHY_PM:		return "qcom,phy-supply-entries";
>> +	default:		return "???";
>> +	}
>> +}
>> +
>> +static int dp_parser_get_vreg(struct dp_parser *parser,
>> +		enum dp_pm_type module)
>> +{
>> +	int i = 0, rc = 0;
>> +	u32 tmp = 0;
>> +	const char *pm_supply_name = NULL;
>> +	struct device_node *supply_node = NULL;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	struct device_node *supply_root_node = NULL;
>> +	struct dss_module_power *mp = &parser->mp[module];
>> +
>> +	mp->num_vreg = 0;
>> +	pm_supply_name = dp_parser_supply_node_name(module);
>> +	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
>> +	if (!supply_root_node) {
>> +		pr_err("no supply entry present: %s\n", pm_supply_name);
>> +		goto novreg;
>> +	}
>> +
>> +	mp->num_vreg = of_get_available_child_count(supply_root_node);
>> +
>> +	if (mp->num_vreg == 0) {
>> +		pr_debug("no vreg\n");
>> +		goto novreg;
>> +	} else {
>> +		pr_debug("vreg found. count=%d\n", mp->num_vreg);
> 
> This doesn't need to be wrapped in an else
> 
>> +	}
>> +
>> +	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
>> +		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
>> +	if (!mp->vreg_config) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	for_each_child_of_node(supply_root_node, supply_node) {
>> +		const char *st = NULL;
>> +		/* vreg-name */
>> +		rc = of_property_read_string(supply_node,
>> +			"qcom,supply-name", &st);
>> +		if (rc) {
>> +			pr_err("error reading name. rc=%d\n",
>> +				 rc);
>> +			goto error;
>> +		}
>> +		snprintf(mp->vreg_config[i].vreg_name,
>> +			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);
> 
> Instead of storing the name just to get a regulator reference later, 
> why don't
> you just grab the reference now and avoid the string ops?
> 
>> +		/* vreg-min-voltage */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-min-voltage", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading min volt. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].min_voltage = tmp;
>> +
>> +		/* vreg-max-voltage */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-max-voltage", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading max volt. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].max_voltage = tmp;
>> +
>> +		/* enable-load */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-enable-load", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading enable load. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].enable_load = tmp;
>> +
>> +		/* disable-load */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-disable-load", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading disable load. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].disable_load = tmp;
>> +
>> +		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
>> +			mp->vreg_config[i].vreg_name,
>> +			mp->vreg_config[i].min_voltage,
>> +			mp->vreg_config[i].max_voltage,
>> +			mp->vreg_config[i].enable_load,
>> +			mp->vreg_config[i].disable_load
>> +			);
>> +		++i;
>> +	}
>> +
>> +	return rc;
>> +
>> +error:
>> +	if (mp->vreg_config) {
>> +		devm_kfree(&parser->pdev->dev, mp->vreg_config);
>> +		mp->vreg_config = NULL;
>> +	}
> 
> This shouldn't be necessary, that's the nice thing about device managed
> resources.
> 
>> +novreg:
>> +	mp->num_vreg = 0;
>> +
>> +	return rc;
>> +}
>> +
>> +static void dp_parser_put_vreg_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	if (mp->vreg_config) {
>> +		devm_kfree(dev, mp->vreg_config);
>> +		mp->vreg_config = NULL;
>> +	}
> 
> Same here, this function can go away once you take out the dp_parser
> abstraction layer.
> 
>> +	mp->num_vreg = 0;
>> +}
>> +
>> +static int dp_parser_regulator(struct dp_parser *parser)
>> +{
>> +	int i, rc = 0;
>> +	struct platform_device *pdev = parser->pdev;
>> +
>> +	/* Parse the regulator information */
>> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
>> +		rc = dp_parser_get_vreg(parser, i);
>> +		if (rc) {
>> +			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
>> +				dp_parser_pm_name(i), rc);
>> +			i--;
>> +			for (; i >= DP_CORE_PM; i--)
>> +				dp_parser_put_vreg_data(&pdev->dev,
>> +					&parser->mp[i]);
>> +			break;
> 
> And here you can just return the error directly and the resources will 
> be freed
> magically.
> 
>> +		}
>> +	}
>> +
>> +	return rc;
> 
> And this becomes return 0;
> 
>> +}
>> +
>> +static bool dp_parser_check_prefix(const char *clk_prefix, const char 
>> *clk_name)
>> +{
>> +	return !!strnstr(clk_name, clk_prefix, strlen(clk_name));
> 
> This is likely not what you want since this will look for prefix 
> _anywhere_ in
> clk name. An example of how this could go sideways:
> 
> 	dp_parser_check_prefix("core", "core-dp-power-ctrl");
> 	dp_parser_check_prefix("ctrl", "core-dp-power-ctrl");
> 
> Both return true.
> 
> Anyways, strncmp is a better choice here (if we must do string 
> operations).
> 
>> +}
>> +
>> +static void dp_parser_put_clk_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("%s: invalid input\n", __func__);
>> +		return;
>> +	}
>> +
>> +	if (mp->clk_config) {
>> +		devm_kfree(dev, mp->clk_config);
>> +		mp->clk_config = NULL;
>> +	}
>> +
>> +	mp->num_clk = 0;
>> +}
>> +
>> +static void dp_parser_put_gpio_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("%s: invalid input\n", __func__);
>> +		return;
>> +	}
>> +
>> +	if (mp->gpio_config) {
>> +		devm_kfree(dev, mp->gpio_config);
>> +		mp->gpio_config = NULL;
>> +	}
>> +
>> +	mp->num_gpio = 0;
>> +}
>> +
>> +static int dp_parser_init_clk_data(struct dp_parser *parser)
>> +{
>> +	int num_clk = 0, i = 0, rc = 0;
>> +	int core_clk_count = 0, ctrl_clk_count = 0;
>> +	const char *core_clk = "core";
>> +	const char *ctrl_clk = "ctrl";
>> +	const char *clk_name;
>> +	struct device *dev = &parser->pdev->dev;
>> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
>> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
>> +
>> +	num_clk = of_property_count_strings(dev->of_node, "clock-names");
>> +	if (num_clk <= 0) {
>> +		pr_err("no clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	for (i = 0; i < num_clk; i++) {
>> +		of_property_read_string_index(dev->of_node,
>> +				"clock-names", i, &clk_name);
> 
> Check return value
> 
>> +
>> +		if (dp_parser_check_prefix(core_clk, clk_name))
>> +			core_clk_count++;
>> +
>> +		if (dp_parser_check_prefix(ctrl_clk, clk_name))
>> +			ctrl_clk_count++;
> 
> Just use "core"/"ctrl" directly here.
> 
> Have you considered just having 2 clock lists? That would avoid having 
> to do
> this.
I am not clear on what you are suggesting? We currently have two 
clock-lists (core & ctrl).


> 
>> +	}
>> +
>> +	/* Initialize the CORE power module */
>> +	if (core_clk_count <= 0) {
> 
> How does this get below 0?
> 
>> +		pr_err("no core clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	core_power->num_clk = core_clk_count;
>> +	core_power->clk_config = devm_kzalloc(dev,
>> +			sizeof(struct dss_clk) * core_power->num_clk,
>> +			GFP_KERNEL);
>> +	if (!core_power->clk_config) {
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	/* Initialize the CTRL power module */
>> +	if (ctrl_clk_count <= 0) {
> 
> How does this get below 0?
> 
>> +		pr_err("no ctrl clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto ctrl_clock_error;
>> +	}
>> +
>> +	ctrl_power->num_clk = ctrl_clk_count;
>> +	ctrl_power->clk_config = devm_kzalloc(dev,
>> +			sizeof(struct dss_clk) * ctrl_power->num_clk,
>> +			GFP_KERNEL);
>> +	if (!ctrl_power->clk_config) {
>> +		ctrl_power->num_clk = 0;
>> +		rc = -EINVAL;
>> +		goto ctrl_clock_error;
>> +	}
>> +
>> +	return rc;
>> +
>> +ctrl_clock_error:
>> +	dp_parser_put_clk_data(dev, core_power);
>> +exit:
>> +	return rc;
> 
> Just return directly and delete exit
> 
>> +}
>> +
>> +static int dp_parser_clock(struct dp_parser *parser)
>> +{
>> +	int rc = 0, i = 0;
>> +	int num_clk = 0;
>> +	int core_clk_index = 0, ctrl_clk_index = 0;
>> +	int core_clk_count = 0, ctrl_clk_count = 0;
>> +	const char *clk_name;
>> +	const char *core_clk = "core";
>> +	const char *ctrl_clk = "ctrl";
>> +	struct device *dev = &parser->pdev->dev;
> 
> ---- START hmmmm
I didn't understand, can you please provide more details regarding 
"START" and "END".
> 
>> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
>> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
>> +
>> +	core_power = &parser->mp[DP_CORE_PM];
>> +	ctrl_power = &parser->mp[DP_CTRL_PM];
> 
> ---- END hmmmm
> 
>> +
>> +	rc =  dp_parser_init_clk_data(parser);
>> +	if (rc) {
>> +		pr_err("failed to initialize power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	core_clk_count = core_power->num_clk;
>> +	ctrl_clk_count = ctrl_power->num_clk;
>> +
>> +	num_clk = core_clk_count + ctrl_clk_count;
>> +
>> +	for (i = 0; i < num_clk; i++) {
>> +		of_property_read_string_index(dev->of_node, "clock-names",
>> +				i, &clk_name);
> 
> Check return value
> 
>> +
>> +		if (dp_parser_check_prefix(core_clk, clk_name) &&
>> +				core_clk_index < core_clk_count) {
>> +			struct dss_clk *clk =
>> +				&core_power->clk_config[core_clk_index];
>> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
>> +			clk->type = DSS_CLK_AHB;
>> +			core_clk_index++;
>> +		} else if (dp_parser_check_prefix(ctrl_clk, clk_name) &&
>> +			   ctrl_clk_index < ctrl_clk_count) {
>> +			struct dss_clk *clk =
>> +				&ctrl_power->clk_config[ctrl_clk_index];
>> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
>> +			ctrl_clk_index++;
>> +
>> +			if (!strcmp(clk_name, "ctrl_link_clk") ||
>> +			    !strcmp(clk_name, "ctrl_pixel_clk"))
> 
> strncmp
> 
>> +				clk->type = DSS_CLK_PCLK;
>> +			else
>> +				clk->type = DSS_CLK_AHB;
>> +		}
>> +	}
>> +
>> +	pr_debug("clock parsing successful\n");
>> +
>> +exit:
> 
> Delete the label and return directly
> 
>> +	return rc;
>> +}
>> +
>> +static int dp_parser_parse(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto err;
>> +	}
>> +
>> +	rc = dp_parser_ctrl_res(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_aux(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_misc(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_clock(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_regulator(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_gpio(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_pinctrl(parser);
>> +err:
> 
> Delete the label and return directly
> 
>> +	return rc;
>> +}
>> +
>> +struct dp_parser *dp_parser_get(struct platform_device *pdev)
>> +{
>> +	struct dp_parser *parser;
>> +
>> +	parser = devm_kzalloc(&pdev->dev, sizeof(*parser), GFP_KERNEL);
>> +	if (!parser)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	parser->parse = dp_parser_parse;
>> +	parser->pdev = pdev;
>> +
>> +	return parser;
>> +}
>> +
>> +void dp_parser_put(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +	struct dss_module_power *power = NULL;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid parser module\n");
>> +		return;
>> +	}
>> +
>> +	power = parser->mp;
>> +
>> +	for (i = 0; i < DP_MAX_PM; i++) {
>> +		dp_parser_put_clk_data(&parser->pdev->dev, &power[i]);
>> +		dp_parser_put_vreg_data(&parser->pdev->dev, &power[i]);
>> +		dp_parser_put_gpio_data(&parser->pdev->dev, &power[i]);
>> +	}
>> +
>> +	devm_kfree(&parser->pdev->dev, parser);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h 
>> b/drivers/gpu/drm/msm/dp/dp_parser.h
>> new file mode 100644
>> index 0000000..b39ea02
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_parser.h
>> @@ -0,0 +1,205 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_PARSER_H_
>> +#define _DP_PARSER_H_
>> +
>> +#include "dpu_io_util.h"
>> +
>> +#define DP_LABEL "MDSS DP DISPLAY"
>> +#define AUX_CFG_LEN	10
>> +#define DP_MAX_PIXEL_CLK_KHZ	675000
>> +
>> +enum dp_pm_type {
>> +	DP_CORE_PM,
>> +	DP_CTRL_PM,
>> +	DP_PHY_PM,
>> +	DP_MAX_PM
>> +};
>> +
>> +static inline const char *dp_parser_pm_name(enum dp_pm_type module)
>> +{
>> +	switch (module) {
>> +	case DP_CORE_PM:	return "DP_CORE_PM";
>> +	case DP_CTRL_PM:	return "DP_CTRL_PM";
>> +	case DP_PHY_PM:		return "DP_PHY_PM";
>> +	default:		return "???";
>> +	}
>> +}
> 
> Delete the function and just print the enum value
> 
>> +
>> +/**
>> + * struct dp_display_data  - display related device tree data.
>> + *
>> + * @ctrl_node: referece to controller device
>> + * @phy_node:  reference to phy device
>> + * @is_active: is the controller currently active
>> + * @name: name of the display
>> + * @display_type: type of the display
>> + */
>> +struct dp_display_data {
>> +	struct device_node *ctrl_node;
>> +	struct device_node *phy_node;
>> +	bool is_active;
>> +	const char *name;
>> +	const char *display_type;
>> +};
>> +
>> +/**
>> + * struct dp_ctrl_resource - controller's IO related data
>> + *
>> + * @dp_ahb: controller's ahb mapped memory address
>> + * @dp_aux: controller's aux mapped memory address
>> + * @dp_link: controller's link mapped memory address
>> + * @dp_p0: controller's p0 mapped memory address
>> + * @phy_io: phy's mapped memory address
>> + * @ln_tx0_io: USB-DP lane TX0's mapped memory address
>> + * @ln_tx1_io: USB-DP lane TX1's mapped memory address
>> + * @dp_cc_io: DP cc's mapped memory address
>> + * @qfprom_io: qfprom's mapped memory address
>> + * @dp_pll_io: DP PLL mapped memory address
>> + * @usb3_dp_com: USB3 DP PHY combo mapped memory address
>> + */
>> +struct dp_io {
>> +	struct dss_io_data ctrl_io;
>> +	struct dss_io_data dp_ahb;
>> +	struct dss_io_data dp_aux;
>> +	struct dss_io_data dp_link;
>> +	struct dss_io_data dp_p0;
>> +	struct dss_io_data phy_io;
>> +	struct dss_io_data ln_tx0_io;
>> +	struct dss_io_data ln_tx1_io;
>> +	struct dss_io_data dp_cc_io;
>> +	struct dss_io_data qfprom_io;
>> +	struct dss_io_data dp_pll_io;
>> +	struct dss_io_data usb3_dp_com;
>> +};
>> +
>> +/**
>> + * struct dp_pinctrl - DP's pin control
>> + *
>> + * @pin: pin-controller's instance
>> + * @state_active: active state pin control
>> + * @state_hpd_active: hpd active state pin control
>> + * @state_suspend: suspend state pin control
>> + */
>> +struct dp_pinctrl {
>> +	struct pinctrl *pin;
>> +	struct pinctrl_state *state_active;
>> +	struct pinctrl_state *state_hpd_active;
>> +	struct pinctrl_state *state_suspend;
>> +};
>> +
>> +#define DP_ENUM_STR(x)	#x
> 
> Once you get rid of all of the enum->string functions that are used for
> debugging, you can delete this.
> 
>> +#define DP_AUX_CFG_MAX_VALUE_CNT 3
>> +/**
>> + * struct dp_aux_cfg - DP's AUX configuration settings
>> + *
>> + * @cfg_cnt: count of the configurable settings for the AUX register
>> + * @current_index: current index of the AUX config lut
>> + * @offset: register offset of the AUX config register
>> + * @lut: look up table for the AUX config values for this register
>> + */
>> +struct dp_aux_cfg {
>> +	u32 cfg_cnt;
>> +	u32 current_index;
>> +	u32 offset;
>> +	u32 lut[DP_AUX_CFG_MAX_VALUE_CNT];
>> +};
>> +
>> +/* PHY AUX config registers */
>> +enum dp_phy_aux_config_type {
>> +	PHY_AUX_CFG0,
>> +	PHY_AUX_CFG1,
>> +	PHY_AUX_CFG2,
>> +	PHY_AUX_CFG3,
>> +	PHY_AUX_CFG4,
>> +	PHY_AUX_CFG5,
>> +	PHY_AUX_CFG6,
>> +	PHY_AUX_CFG7,
>> +	PHY_AUX_CFG8,
>> +	PHY_AUX_CFG9,
>> +	PHY_AUX_CFG_MAX,
>> +};
>> +
>> +static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type)
>> +{
>> +	switch (cfg_type) {
>> +	case PHY_AUX_CFG0:
>> +		return DP_ENUM_STR(PHY_AUX_CFG0);
>> +	case PHY_AUX_CFG1:
>> +		return DP_ENUM_STR(PHY_AUX_CFG1);
>> +	case PHY_AUX_CFG2:
>> +		return DP_ENUM_STR(PHY_AUX_CFG2);
>> +	case PHY_AUX_CFG3:
>> +		return DP_ENUM_STR(PHY_AUX_CFG3);
>> +	case PHY_AUX_CFG4:
>> +		return DP_ENUM_STR(PHY_AUX_CFG4);
>> +	case PHY_AUX_CFG5:
>> +		return DP_ENUM_STR(PHY_AUX_CFG5);
>> +	case PHY_AUX_CFG6:
>> +		return DP_ENUM_STR(PHY_AUX_CFG6);
>> +	case PHY_AUX_CFG7:
>> +		return DP_ENUM_STR(PHY_AUX_CFG7);
>> +	case PHY_AUX_CFG8:
>> +		return DP_ENUM_STR(PHY_AUX_CFG8);
>> +	case PHY_AUX_CFG9:
>> +		return DP_ENUM_STR(PHY_AUX_CFG9);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Same deal as the others, remove and print the enum value instead.
> 
>> +
>> +/**
>> + * struct dp_parser - DP parser's data exposed to clients
>> + *
>> + * @pdev: platform data of the client
>> + * @mp: gpio, regulator and clock related data
>> + * @pinctrl: pin-control related data
>> + * @disp_data: controller's display related data
>> + * @parse: function to be called by client to parse device tree.
>> + */
>> +struct dp_parser {
>> +	struct platform_device *pdev;
>> +	struct dss_module_power mp[DP_MAX_PM];
>> +	struct dp_pinctrl pinctrl;
>> +	struct dp_io io;
>> +	struct dp_display_data disp_data;
>> +
>> +	u8 l_map[4];
>> +	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
>> +	u32 max_pclk_khz;
>> +
>> +	int (*parse)(struct dp_parser *parser);
>> +};
>> +
>> +/**
>> + * dp_parser_get() - get the DP's device tree parser module
>> + *
>> + * @pdev: platform data of the client
>> + * return: pointer to dp_parser structure.
>> + *
>> + * This function provides client capability to parse the
>> + * device tree and populate the data structures. The data
>> + * related to clock, regulators, pin-control and other
>> + * can be parsed using this module.
>> + */
>> +struct dp_parser *dp_parser_get(struct platform_device *pdev);
>> +
>> +/**
>> + * dp_parser_put() - cleans the dp_parser module
>> + *
>> + * @parser: pointer to the parser's data.
>> + */
>> +void dp_parser_put(struct dp_parser *parser);
>> +#endif
>> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c 
>> b/drivers/gpu/drm/msm/dp/dp_power.c
>> new file mode 100644
>> index 0000000..1d58480
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
>> @@ -0,0 +1,599 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/clk.h>
>> +#include "dp_power.h"
>> +
>> +#define DP_CLIENT_NAME_SIZE	20
> 
> Unused
> 
>> +
>> +struct dp_power_private {
>> +	struct dp_parser *parser;
>> +	struct platform_device *pdev;
>> +	struct clk *pixel_clk_rcg;
>> +	struct clk *pixel_parent;
>> +
>> +	struct dp_power dp_power;
>> +
>> +	bool core_clks_on;
>> +	bool link_clks_on;
>> +};
>> +
>> +static int dp_power_regulator_init(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i = 0, j = 0;
>> +	struct platform_device *pdev;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +	pdev = power->pdev;
> 
> Move these initializations up to the declaration. Please apply this to 
> the rest
> of the code as well.
> 
> 
>> +
>> +	for (i = DP_CORE_PM; !rc && (i < DP_MAX_PM); i++) {
> 
> No need to check rc when the only place it can go non-zero is the place 
> that
> has a break;
> 
>> +		rc = msm_dss_config_vreg(&pdev->dev,
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, 1);
>> +		if (rc) {
>> +			pr_err("failed to init vregs for %s\n",
>> +				dp_parser_pm_name(i));
>> +			for (j = i - 1; j >= DP_CORE_PM; j--) {
>> +				msm_dss_config_vreg(&pdev->dev,
>> +				parser->mp[j].vreg_config,
>> +				parser->mp[j].num_vreg, 0);
>> +			}
> 
> Put this loop in the error label and return 0 above it. Better yet, 
> just call
> the dp_power_regulator_deinit in error.
> 
>> +
>> +			goto error;
>> +		}
>> +	}
>> +error:
>> +	return rc;
>> +}
>> +
>> +static void dp_power_regulator_deinit(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i = 0;
>> +	struct platform_device *pdev;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +	pdev = power->pdev;
>> +
>> +	for (i = DP_CORE_PM; (i < DP_MAX_PM); i++) {
> 
> Unnecessary (), applies elsewhere too, please make a pass
> 
>> +		rc = msm_dss_config_vreg(&pdev->dev,
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, 0);
>> +		if (rc)
>> +			pr_err("failed to deinit vregs for %s\n",
>> +				dp_parser_pm_name(i));
>> +	}
>> +}
>> +
>> +static int dp_power_regulator_ctrl(struct dp_power_private *power, 
>> bool enable)
>> +{
>> +	int rc = 0, i = 0, j = 0;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +
>> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
>> +		rc = msm_dss_enable_vreg(
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, enable);
>> +		if (rc) {
>> +			pr_err("failed to '%s' vregs for %s\n",
>> +					enable ? "enable" : "disable",
>> +					dp_parser_pm_name(i));
>> +			if (enable) {
>> +				for (j = i-1; j >= DP_CORE_PM; j--) {
>> +					msm_dss_enable_vreg(
>> +					parser->mp[j].vreg_config,
>> +					parser->mp[j].num_vreg, 0);
>> +				}
>> +			}
>> +			goto error;
>> +		}
>> +	}
>> +error:
>> +	return rc;
>> +}
> 
> This function is basically identical to dp_power_regulator_init(), 
> please
> delete this function and use dp_power_regulator_init().
> 

> 
>> +
>> +static int dp_power_pinctrl_set(struct dp_power_private *power, bool 
>> active)
>> +{
>> +	int rc = -EFAULT;
>> +	struct pinctrl_state *pin_state;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +
>> +	if (IS_ERR_OR_NULL(parser->pinctrl.pin))
>> +		return PTR_ERR(parser->pinctrl.pin);
>> +
>> +	pin_state = active ? parser->pinctrl.state_active
>> +				: parser->pinctrl.state_suspend;
>> +	if (!IS_ERR_OR_NULL(pin_state)) {
> 
> How is this not possible? You check these on initialization.
> 
>> +		rc = pinctrl_select_state(parser->pinctrl.pin,
>> +				pin_state);
> 
> Combine on 1 line
> 
>> +		if (rc)
>> +			pr_err("can not set %s pins\n",
>> +			       active ? "dp_active"
>> +			       : "dp_sleep");
> 
> 
> Combine on one line. Also return immediately if this is the case.
> 
>> +	} else {
>> +		pr_err("invalid '%s' pinstate\n",
>> +		       active ? "dp_active"
>> +		       : "dp_sleep");
>> +	}
>> +
>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_init(struct dp_power_private *power, bool 
>> enable)
> 
> Split this into init/deinit, the paths don't share code.
> 
>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *core, *ctrl;
>> +	struct device *dev;
>> +
>> +	core = &power->parser->mp[DP_CORE_PM];
>> +	ctrl = &power->parser->mp[DP_CTRL_PM];
>> +
>> +	dev = &power->pdev->dev;
>> +
>> +	if (!core || !ctrl) {
>> +		pr_err("invalid power_data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	if (enable) {
>> +		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to get %s clk. err=%d\n",
>> +				dp_parser_pm_name(DP_CORE_PM), rc);
>> +			goto exit;
>> +		}
>> +
>> +		rc = msm_dss_get_clk(dev, ctrl->clk_config, ctrl->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to get %s clk. err=%d\n",
>> +				dp_parser_pm_name(DP_CTRL_PM), rc);
>> +			goto ctrl_get_error;
>> +		}
>> +
>> +		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
>> +		if (IS_ERR(power->pixel_clk_rcg)) {
>> +			pr_debug("Unable to get DP pixel clk RCG\n");
>> +			power->pixel_clk_rcg = NULL;
>> +		}
>> +
>> +		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
>> +		if (IS_ERR(power->pixel_parent)) {
>> +			pr_debug("Unable to get DP pixel RCG parent\n");
>> +			power->pixel_parent = NULL;
>> +		}
>> +	} else {
>> +		if (power->pixel_parent)
>> +			devm_clk_put(dev, power->pixel_parent);
>> +
>> +		if (power->pixel_clk_rcg)
>> +			devm_clk_put(dev, power->pixel_clk_rcg);
> 
> device managed resources don't need to be freed
> 
>> +
>> +		msm_dss_put_clk(ctrl->clk_config, ctrl->num_clk);
>> +		msm_dss_put_clk(core->clk_config, core->num_clk);
>> +	}
>> +
>> +	return rc;
>> +
>> +ctrl_get_error:
>> +	msm_dss_put_clk(core->clk_config, core->num_clk);
> 
> Since this is only used in one place, just do it above and return 
> directly.
> 
>> +exit:
> 
> Delete exit label and return directly
> 
>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_set_rate(struct dp_power_private *power,
>> +		enum dp_pm_type module, bool enable)
>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *mp;
>> +
>> +	if (!power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	mp = &power->parser->mp[module];
>> +
>> +	if (enable) {
>> +		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to set clks rate.\n");
>> +			goto exit;
>> +		}
>> +
>> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
>> +		if (rc) {
>> +			pr_err("failed to enable clks\n");
>> +			goto exit;
>> +		}
>> +	} else {
>> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
>> +		if (rc) {
>> +			pr_err("failed to disable clks\n");
>> +				goto exit;
>> +		}
> 
> This function actually can share code, but it doesn't :( Please pull 
> this out
> for both paths
> 
>> +	}
>> +exit:
> 
> Delete exit label and return directly
> 
>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_enable(struct dp_power *dp_power,
>> +		enum dp_pm_type pm_type, bool enable)
>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *mp;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	mp = &power->parser->mp[pm_type];
>> +
>> +	if ((pm_type != DP_CORE_PM) && (pm_type != DP_CTRL_PM)) {
> 
> Strip out unnecessary ()
> 
>> +		pr_err("unsupported power module: %s\n",
>> +				dp_parser_pm_name(pm_type));
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (enable) {
>> +		if ((pm_type == DP_CORE_PM)
>> +			&& (power->core_clks_on)) {
> 
> Here too
> 
> Combine on one line as well
> 
>> +			pr_debug("core clks already enabled\n");
>> +			return 0;
>> +		}
>> +
>> +		if ((pm_type == DP_CTRL_PM)
>> +			&& (power->link_clks_on)) {
> 
> and here
> 
>> +			pr_debug("links clks already enabled\n");
>> +			return 0;
>> +		}
>> +
>> +		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {
> 
> and here
> 
>> +			pr_debug("Need to enable core clks before link clks\n");
>> +
>> +			rc = dp_power_clk_set_rate(power, DP_CORE_PM, enable);
>> +			if (rc) {
>> +				pr_err("failed to enable clks: %s. err=%d\n",
>> +					dp_parser_pm_name(DP_CORE_PM), rc);
>> +				goto error;
>> +			} else {
>> +				power->core_clks_on = true;
> 
> This doesn't need to be wrapped in the else
> 
>> +			}
>> +		}
>> +	}
>> +
>> +	rc = dp_power_clk_set_rate(power, pm_type, enable);
>> +	if (rc) {
>> +		pr_err("failed to '%s' clks for: %s. err=%d\n",
>> +			enable ? "enable" : "disable",
>> +			dp_parser_pm_name(pm_type), rc);
>> +			goto error;
>> +	}
>> +
>> +	if (pm_type == DP_CORE_PM)
>> +		power->core_clks_on = enable;
>> +	else
>> +		power->link_clks_on = enable;
>> +
>> +	pr_debug("%s clocks for %s\n",
>> +			enable ? "enable" : "disable",
>> +			dp_parser_pm_name(pm_type));
>> +	pr_debug("link_clks:%s core_clks:%s\n",
>> +		power->link_clks_on ? "on" : "off",
>> +		power->core_clks_on ? "on" : "off");
>> +error:
> 
> Delete error label and return directly
> 
>> +	return rc;
>> +}
>> +
>> +static int dp_power_request_gpios(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i;
>> +	struct device *dev;
>> +	struct dss_module_power *mp;
>> +	static const char * const gpio_names[] = {
>> +		"aux_enable", "aux_sel", "usbplug_cc",
>> +	};
>> +
>> +	if (!power) {
>> +		pr_err("invalid power data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dev = &power->pdev->dev;
>> +	mp = &power->parser->mp[DP_CORE_PM];
>> +
>> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
>> +		unsigned int gpio = mp->gpio_config[i].gpio;
>> +
>> +		if (gpio_is_valid(gpio)) {
> 
> if (!gpio_is_valid(gpio))
> 	continue;
> 
> and save yourself some indent space
> 
>> +			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
>> +			if (rc) {
>> +				pr_err("request %s gpio failed, rc=%d\n",
>> +					       gpio_names[i], rc);
>> +				goto error;
>> +			}
>> +		}
>> +	}
>> +	return 0;
>> +error:
>> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
>> +		unsigned int gpio = mp->gpio_config[i].gpio;
>> +
>> +		if (gpio_is_valid(gpio))
>> +			gpio_free(gpio);
>> +	}
> 
> gpios are device managed, so you shouldn't need this.
> 
>> +	return rc;
>> +}
>> +
>> +static bool dp_power_find_gpio(const char *gpio1, const char *gpio2)
>> +{
>> +	return !!strnstr(gpio1, gpio2, strlen(gpio1));
>> +}
>> +
>> +static void dp_power_set_gpio(struct dp_power_private *power, bool 
>> flip)
>> +{
>> +	int i;
>> +	struct dss_module_power *mp = &power->parser->mp[DP_CORE_PM];
>> +	struct dss_gpio *config = mp->gpio_config;
>> +
>> +	for (i = 0; i < mp->num_gpio; i++) {
>> +		if (dp_power_find_gpio(config->gpio_name, "aux-sel"))
>> +			config->value = flip;
>> +
>> +		if (gpio_is_valid(config->gpio)) {
>> +			pr_debug("gpio %s, value %d\n", config->gpio_name,
>> +				config->value);
>> +
>> +			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
>> +			    dp_power_find_gpio(config->gpio_name, "aux-sel"))
>> +				gpio_direction_output(config->gpio,
>> +					config->value);
>> +			else
>> +				gpio_set_value(config->gpio, config->value);
>> +
>> +		}
>> +		config++;
>> +	}
> 
> Instead of all of these string ops, please just make pointers 
> accessible so you
> can get at the gpio directly.
> 
>> +}
>> +
>> +static int dp_power_config_gpios(struct dp_power_private *power, bool 
>> flip,
>> +					bool enable)
> 
> Split into 2 functions
> 
>> +{
>> +	int rc = 0, i;
>> +	struct dss_module_power *mp;
>> +	struct dss_gpio *config;
>> +
>> +	mp = &power->parser->mp[DP_CORE_PM];
>> +	config = mp->gpio_config;
>> +
>> +	if (enable) {
>> +		rc = dp_power_request_gpios(power);
>> +		if (rc) {
>> +			pr_err("gpio request failed\n");
>> +			return rc;
>> +		}
>> +
>> +		dp_power_set_gpio(power, flip);
>> +	} else {
>> +		for (i = 0; i < mp->num_gpio; i++) {
>> +			gpio_set_value(config[i].gpio, 0);
>> +			gpio_free(config[i].gpio);
>> +		}
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_power_client_init(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	pm_runtime_enable(&power->pdev->dev);
>> +
>> +	rc = dp_power_regulator_init(power);
>> +	if (rc) {
>> +		pr_err("failed to init regulators\n");
> 
> Print rc
> 
>> +		goto error_power;
>> +	}
>> +
>> +	rc = dp_power_clk_init(power, true);
>> +	if (rc) {
>> +		pr_err("failed to init clocks\n");
> 
> Print rc
> 
>> +		goto error_clk;
>> +	}
>> +	return 0;
>> +
>> +error_clk:
>> +	dp_power_regulator_deinit(power);
>> +error_power:
>> +	pm_runtime_disable(&power->pdev->dev);
>> +	return rc;
>> +}
>> +
>> +static void dp_power_client_deinit(struct dp_power *dp_power)
>> +{
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		return;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	dp_power_clk_init(power, false);
>> +	dp_power_regulator_deinit(power);
>> +	pm_runtime_disable(&power->pdev->dev);
>> +
>> +}
>> +
>> +static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	if (power->pixel_clk_rcg && power->pixel_parent)
>> +		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
> 
> Check return value
> 
>> +exit:
> 
> Delete label/rc, return immediately.
> 
>> +	return rc;
>> +}
>> +
>> +static int dp_power_init(struct dp_power *dp_power, bool flip)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	pm_runtime_get_sync(&power->pdev->dev);
>> +	rc = dp_power_regulator_ctrl(power, true);
>> +	if (rc) {
>> +		pr_err("failed to enable regulators\n");
> 
> Print rc
> 
>> +		goto exit;
>> +	}
>> +
>> +	rc = dp_power_pinctrl_set(power, true);
>> +	if (rc) {
> 
> Print rc
> 
>> +		pr_err("failed to set pinctrl state\n");
>> +		goto err_pinctrl;
>> +	}
>> +
>> +	rc = dp_power_config_gpios(power, flip, true);
>> +	if (rc) {
> 
> Print rc
> 
>> +		pr_err("failed to enable gpios\n");
>> +		goto err_gpio;
>> +	}
>> +
>> +	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
>> +	if (rc) {
> 
> Print rc
> 
>> +		pr_err("failed to enable DP core clocks\n");
>> +		goto err_clk;
>> +	}
>> +
>> +	return 0;
>> +
>> +err_clk:
>> +	dp_power_config_gpios(power, flip, false);
>> +err_gpio:
>> +	dp_power_pinctrl_set(power, false);
>> +err_pinctrl:
>> +	dp_power_regulator_ctrl(power, false);
>> +exit:
>> +	pm_runtime_put_sync(&power->pdev->dev);
>> +	return rc;
>> +}
>> +
>> +static int dp_power_deinit(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	dp_power_clk_enable(dp_power, DP_CORE_PM, false);
>> +	dp_power_config_gpios(power, false, false);
>> +	dp_power_pinctrl_set(power, false);
>> +	dp_power_regulator_ctrl(power, false);
>> +	pm_runtime_put_sync(&power->pdev->dev);
>> +exit:
> 
> Delete exit label/rc and return directly
> 
>> +	return rc;
>> +}
>> +
>> +struct dp_power *dp_power_get(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +	struct dp_power *dp_power;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	power = devm_kzalloc(&parser->pdev->dev, sizeof(*power), 
>> GFP_KERNEL);
>> +	if (!power) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	power->parser = parser;
>> +	power->pdev = parser->pdev;
>> +
>> +	dp_power = &power->dp_power;
>> +
>> +	dp_power->init = dp_power_init;
>> +	dp_power->deinit = dp_power_deinit;
>> +	dp_power->clk_enable = dp_power_clk_enable;
>> +	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
>> +	dp_power->power_client_init = dp_power_client_init;
>> +	dp_power->power_client_deinit = dp_power_client_deinit;
>> +
>> +	return dp_power;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_power_put(struct dp_power *dp_power)
>> +{
>> +	struct dp_power_private *power = NULL;
>> +
>> +	if (!dp_power)
>> +		return;
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	devm_kfree(&power->pdev->dev, power);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h 
>> b/drivers/gpu/drm/msm/dp/dp_power.h
>> new file mode 100644
>> index 0000000..d1adaaf
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
>> @@ -0,0 +1,57 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_POWER_H_
>> +#define _DP_POWER_H_
>> +
>> +#include "dp_parser.h"
>> +#include "dpu_power_handle.h"
>> +
>> +/**
>> + * sruct dp_power - DisplayPort's power related data
>> + *
>> + * @init: initializes the regulators/core clocks/GPIOs/pinctrl
>> + * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
>> + * @clk_enable: enable/disable the DP clocks
>> + * @set_pixel_clk_parent: set the parent of DP pixel clock
>> + */
>> +struct dp_power {
>> +	int (*init)(struct dp_power *power, bool flip);
>> +	int (*deinit)(struct dp_power *power);
>> +	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
>> +				bool enable);
>> +	int (*set_pixel_clk_parent)(struct dp_power *power);
>> +	int (*power_client_init)(struct dp_power *power);
>> +	void (*power_client_deinit)(struct dp_power *power);
>> +};
>> +
>> +/**
>> + * dp_power_get() - configure and get the DisplayPort power module 
>> data
>> + *
>> + * @parser: instance of parser module
>> + * return: pointer to allocated power module data
>> + *
>> + * This API will configure the DisplayPort's power module and 
>> provides
>> + * methods to be called by the client to configure the power related
>> + * modueles.
>> + */
>> +struct dp_power *dp_power_get(struct dp_parser *parser);
>> +
>> +/**
>> + * dp_power_put() - release the power related resources
>> + *
>> + * @power: pointer to the power module's data
>> + */
>> +void dp_power_put(struct dp_power *power);
>> +#endif /* _DP_POWER_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_reg.h 
>> b/drivers/gpu/drm/msm/dp/dp_reg.h
>> new file mode 100644
>> index 0000000..77b5c0e
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_reg.h
>> @@ -0,0 +1,357 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_REG_H_
>> +#define _DP_REG_H_
>> +
>> +/* DP_TX Registers */
>> +#define DP_HW_VERSION				(0x00000000)
>> +#define DP_SW_RESET				(0x00000010)
>> +#define DP_PHY_CTRL				(0x00000014)
>> +#define DP_CLK_CTRL				(0x00000018)
>> +#define DP_CLK_ACTIVE				(0x0000001C)
>> +#define DP_INTR_STATUS				(0x00000020)
>> +#define DP_INTR_STATUS2				(0x00000024)
>> +#define DP_INTR_STATUS3				(0x00000028)
>> +
>> +#define DP_DP_HPD_CTRL				(0x00000000)
>> +#define DP_DP_HPD_INT_STATUS			(0x00000004)
>> +#define DP_DP_HPD_INT_ACK			(0x00000008)
>> +#define DP_DP_HPD_INT_MASK			(0x0000000C)
>> +#define DP_DP_HPD_REFTIMER			(0x00000018)
>> +#define DP_DP_HPD_EVENT_TIME_0			(0x0000001C)
>> +#define DP_DP_HPD_EVENT_TIME_1			(0x00000020)
>> +#define DP_AUX_CTRL				(0x00000030)
>> +#define DP_AUX_DATA				(0x00000034)
>> +#define DP_AUX_TRANS_CTRL			(0x00000038)
>> +#define DP_TIMEOUT_COUNT			(0x0000003C)
>> +#define DP_AUX_LIMITS				(0x00000040)
>> +#define DP_AUX_STATUS				(0x00000044)
>> +
>> +#define DP_DPCD_CP_IRQ				(0x201)
>> +#define DP_DPCD_RXSTATUS			(0x69493)
>> +
>> +#define DP_INTERRUPT_TRANS_NUM			(0x000000A0)
>> +
>> +#define DP_MAINLINK_CTRL			(0x00000000)
>> +#define DP_STATE_CTRL				(0x00000004)
>> +#define DP_CONFIGURATION_CTRL			(0x00000008)
>> +#define DP_SOFTWARE_MVID			(0x00000010)
>> +#define DP_SOFTWARE_NVID			(0x00000018)
>> +#define DP_TOTAL_HOR_VER			(0x0000001C)
>> +#define DP_START_HOR_VER_FROM_SYNC		(0x00000020)
>> +#define DP_HSYNC_VSYNC_WIDTH_POLARITY		(0x00000024)
>> +#define DP_ACTIVE_HOR_VER			(0x00000028)
>> +#define DP_MISC1_MISC0				(0x0000002C)
>> +#define DP_VALID_BOUNDARY			(0x00000030)
>> +#define DP_VALID_BOUNDARY_2			(0x00000034)
>> +#define DP_LOGICAL2PHYSICAL_LANE_MAPPING	(0x00000038)
>> +
>> +#define DP_MAINLINK_READY			(0x00000040)
>> +#define DP_MAINLINK_LEVELS			(0x00000044)
>> +#define DP_TU					(0x0000004C)
>> +
>> +#define DP_HBR2_COMPLIANCE_SCRAMBLER_RESET	(0x00000054)
>> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG0	(0x000000C0)
>> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG1	(0x000000C4)
>> +#define DP_TEST_80BIT_CUSTOM_PATTERN_REG2	(0x000000C8)
>> +
>> +#define MMSS_DP_MISC1_MISC0			(0x0000002C)
>> +#define MMSS_DP_AUDIO_TIMING_GEN		(0x00000080)
>> +#define MMSS_DP_AUDIO_TIMING_RBR_32		(0x00000084)
>> +#define MMSS_DP_AUDIO_TIMING_HBR_32		(0x00000088)
>> +#define MMSS_DP_AUDIO_TIMING_RBR_44		(0x0000008C)
>> +#define MMSS_DP_AUDIO_TIMING_HBR_44		(0x00000090)
>> +#define MMSS_DP_AUDIO_TIMING_RBR_48		(0x00000094)
>> +#define MMSS_DP_AUDIO_TIMING_HBR_48		(0x00000098)
>> +
>> +#define MMSS_DP_PSR_CRC_RG			(0x00000154)
>> +#define MMSS_DP_PSR_CRC_B			(0x00000158)
>> +
>> +#define DP_COMPRESSION_MODE_CTRL		(0x00000180)
>> +
>> +#define MMSS_DP_AUDIO_CFG			(0x00000200)
>> +#define MMSS_DP_AUDIO_STATUS			(0x00000204)
>> +#define MMSS_DP_AUDIO_PKT_CTRL			(0x00000208)
>> +#define MMSS_DP_AUDIO_PKT_CTRL2			(0x0000020C)
>> +#define MMSS_DP_AUDIO_ACR_CTRL			(0x00000210)
>> +#define MMSS_DP_AUDIO_CTRL_RESET		(0x00000214)
>> +
>> +#define MMSS_DP_SDP_CFG				(0x00000228)
>> +#define MMSS_DP_SDP_CFG2			(0x0000022C)
>> +#define MMSS_DP_AUDIO_TIMESTAMP_0		(0x00000230)
>> +#define MMSS_DP_AUDIO_TIMESTAMP_1		(0x00000234)
>> +
>> +#define MMSS_DP_AUDIO_STREAM_0			(0x00000240)
>> +#define MMSS_DP_AUDIO_STREAM_1			(0x00000244)
>> +
>> +#define MMSS_DP_EXTENSION_0			(0x00000250)
>> +#define MMSS_DP_EXTENSION_1			(0x00000254)
>> +#define MMSS_DP_EXTENSION_2			(0x00000258)
>> +#define MMSS_DP_EXTENSION_3			(0x0000025C)
>> +#define MMSS_DP_EXTENSION_4			(0x00000260)
>> +#define MMSS_DP_EXTENSION_5			(0x00000264)
>> +#define MMSS_DP_EXTENSION_6			(0x00000268)
>> +#define MMSS_DP_EXTENSION_7			(0x0000026C)
>> +#define MMSS_DP_EXTENSION_8			(0x00000270)
>> +#define MMSS_DP_EXTENSION_9			(0x00000274)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_0		(0x00000278)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_1		(0x0000027C)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_2		(0x00000280)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_3		(0x00000284)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_4		(0x00000288)
>> +#define MMSS_DP_AUDIO_COPYMANAGEMENT_5		(0x0000028C)
>> +#define MMSS_DP_AUDIO_ISRC_0			(0x00000290)
>> +#define MMSS_DP_AUDIO_ISRC_1			(0x00000294)
>> +#define MMSS_DP_AUDIO_ISRC_2			(0x00000298)
>> +#define MMSS_DP_AUDIO_ISRC_3			(0x0000029C)
>> +#define MMSS_DP_AUDIO_ISRC_4			(0x000002A0)
>> +#define MMSS_DP_AUDIO_ISRC_5			(0x000002A4)
>> +#define MMSS_DP_AUDIO_INFOFRAME_0		(0x000002A8)
>> +#define MMSS_DP_AUDIO_INFOFRAME_1		(0x000002AC)
>> +#define MMSS_DP_AUDIO_INFOFRAME_2		(0x000002B0)
>> +
>> +#define MMSS_DP_GENERIC0_0			(0x00000300)
>> +#define MMSS_DP_GENERIC0_1			(0x00000304)
>> +#define MMSS_DP_GENERIC0_2			(0x00000308)
>> +#define MMSS_DP_GENERIC0_3			(0x0000030C)
>> +#define MMSS_DP_GENERIC0_4			(0x00000310)
>> +#define MMSS_DP_GENERIC0_5			(0x00000314)
>> +#define MMSS_DP_GENERIC0_6			(0x00000318)
>> +#define MMSS_DP_GENERIC0_7			(0x0000031C)
>> +#define MMSS_DP_GENERIC0_8			(0x00000320)
>> +#define MMSS_DP_GENERIC0_9			(0x00000324)
>> +#define MMSS_DP_GENERIC1_0			(0x00000328)
>> +#define MMSS_DP_GENERIC1_1			(0x0000032C)
>> +#define MMSS_DP_GENERIC1_2			(0x00000330)
>> +#define MMSS_DP_GENERIC1_3			(0x00000334)
>> +#define MMSS_DP_GENERIC1_4			(0x00000338)
>> +#define MMSS_DP_GENERIC1_5			(0x0000033C)
>> +#define MMSS_DP_GENERIC1_6			(0x00000340)
>> +#define MMSS_DP_GENERIC1_7			(0x00000344)
>> +#define MMSS_DP_GENERIC1_8			(0x00000348)
>> +#define MMSS_DP_GENERIC1_9			(0x0000034C)
>> +
>> +#define MMSS_DP_VSCEXT_0			(0x000002D0)
>> +#define MMSS_DP_VSCEXT_1			(0x000002D4)
>> +#define MMSS_DP_VSCEXT_2			(0x000002D8)
>> +#define MMSS_DP_VSCEXT_3			(0x000002DC)
>> +#define MMSS_DP_VSCEXT_4			(0x000002E0)
>> +#define MMSS_DP_VSCEXT_5			(0x000002E4)
>> +#define MMSS_DP_VSCEXT_6			(0x000002E8)
>> +#define MMSS_DP_VSCEXT_7			(0x000002EC)
>> +#define MMSS_DP_VSCEXT_8			(0x000002F0)
>> +#define MMSS_DP_VSCEXT_9			(0x000002F4)
>> +
>> +#define MMSS_DP_BIST_ENABLE			(0x00000000)
>> +#define MMSS_DP_TIMING_ENGINE_EN		(0x00000010)
>> +#define MMSS_DP_INTF_CONFIG			(0x00000014)
>> +#define MMSS_DP_INTF_HSYNC_CTL			(0x00000018)
>> +#define MMSS_DP_INTF_VSYNC_PERIOD_F0		(0x0000001C)
>> +#define MMSS_DP_INTF_VSYNC_PERIOD_F1		(0x00000020)
>> +#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0	(0x00000024)
>> +#define MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1	(0x00000028)
>> +#define MMSS_INTF_DISPLAY_V_START_F0		(0x0000002C)
>> +#define MMSS_INTF_DISPLAY_V_START_F1		(0x00000030)
>> +#define MMSS_DP_INTF_DISPLAY_V_END_F0		(0x00000034)
>> +#define MMSS_DP_INTF_DISPLAY_V_END_F1		(0x00000038)
>> +#define MMSS_DP_INTF_ACTIVE_V_START_F0		(0x0000003C)
>> +#define MMSS_DP_INTF_ACTIVE_V_START_F1		(0x00000040)
>> +#define MMSS_DP_INTF_ACTIVE_V_END_F0		(0x00000044)
>> +#define MMSS_DP_INTF_ACTIVE_V_END_F1		(0x00000048)
>> +#define MMSS_DP_INTF_DISPLAY_HCTL		(0x0000004C)
>> +#define MMSS_DP_INTF_ACTIVE_HCTL		(0x00000050)
>> +#define MMSS_DP_INTF_POLARITY_CTL		(0x00000058)
>> +#define MMSS_DP_TPG_MAIN_CONTROL		(0x00000060)
>> +#define MMSS_DP_TPG_VIDEO_CONFIG		(0x00000064)
>> +#define MMSS_DP_ASYNC_FIFO_CONFIG		(0x00000088)
>> +
>> +/*DP PHY Register offsets */
>> +#define DP_PHY_REVISION_ID0                     (0x00000000)
>> +#define DP_PHY_REVISION_ID1                     (0x00000004)
>> +#define DP_PHY_REVISION_ID2                     (0x00000008)
>> +#define DP_PHY_REVISION_ID3                     (0x0000000C)
>> +
>> +#define DP_PHY_CFG                              (0x00000010)
>> +#define DP_PHY_PD_CTL                           (0x00000018)
>> +#define DP_PHY_MODE                             (0x0000001C)
>> +
>> +#define DP_PHY_AUX_CFG0                         (0x00000020)
>> +#define DP_PHY_AUX_CFG1                         (0x00000024)
>> +#define DP_PHY_AUX_CFG2                         (0x00000028)
>> +#define DP_PHY_AUX_CFG3                         (0x0000002C)
>> +#define DP_PHY_AUX_CFG4                         (0x00000030)
>> +#define DP_PHY_AUX_CFG5                         (0x00000034)
>> +#define DP_PHY_AUX_CFG6                         (0x00000038)
>> +#define DP_PHY_AUX_CFG7                         (0x0000003C)
>> +#define DP_PHY_AUX_CFG8                         (0x00000040)
>> +#define DP_PHY_AUX_CFG9                         (0x00000044)
>> +#define DP_PHY_AUX_INTERRUPT_MASK               (0x00000048)
>> +#define DP_PHY_AUX_INTERRUPT_CLEAR              (0x0000004C)
>> +#define DP_PHY_AUX_BIST_CFG			(0x00000050)
>> +
>> +#define DP_PHY_VCO_DIV				0x0064
>> +#define DP_PHY_TX0_TX1_LANE_CTL			0x006C
>> +#define DP_PHY_TX2_TX3_LANE_CTL			0x0088
>> +
>> +#define DP_PHY_SPARE0				(0x00AC)
>> +#define DP_PHY_STATUS				(0x00C0)
>> +
>> +/* Tx registers */
>> +#define TXn_BIST_MODE_LANENO			0x0000
>> +#define TXn_CLKBUF_ENABLE			0x0008
>> +#define TXn_TX_EMP_POST1_LVL			0x000C
>> +
>> +#define TXn_TX_DRV_LVL				0x001C
>> +
>> +#define TXn_RESET_TSYNC_EN			0x0024
>> +#define TXn_PRE_STALL_LDO_BOOST_EN		0x0028
>> +#define TXn_TX_BAND				0x002C
>> +#define TXn_SLEW_CNTL				0x0030
>> +#define TXn_INTERFACE_SELECT			0x0034
>> +
>> +#define TXn_RES_CODE_LANE_TX			0x003C
>> +#define TXn_RES_CODE_LANE_RX			0x0040
>> +#define TXn_RES_CODE_LANE_OFFSET_TX		0x0044
>> +#define TXn_RES_CODE_LANE_OFFSET_RX		0x0048
>> +
>> +#define TXn_DEBUG_BUS_SEL			0x0058
>> +#define TXn_TRANSCEIVER_BIAS_EN			0x005C
>> +#define TXn_HIGHZ_DRVR_EN			0x0060
>> +#define TXn_TX_POL_INV				0x0064
>> +#define TXn_PARRATE_REC_DETECT_IDLE_EN		0x0068
>> +
>> +#define TXn_LANE_MODE_1				0x008C
>> +
>> +#define TXn_TRAN_DRVR_EMP_EN			0x00C0
>> +#define TXn_TX_INTERFACE_MODE			0x00C4
>> +
>> +#define TXn_VMODE_CTRL1				0x00F0
>> +
>> +/* PLL register offset */
>> +#define QSERDES_COM_ATB_SEL1			0x0000
>> +#define QSERDES_COM_ATB_SEL2			0x0004
>> +#define QSERDES_COM_FREQ_UPDATE			0x0008
>> +#define QSERDES_COM_BG_TIMER			0x000C
>> +#define QSERDES_COM_SSC_EN_CENTER		0x0010
>> +#define QSERDES_COM_SSC_ADJ_PER1		0x0014
>> +#define QSERDES_COM_SSC_ADJ_PER2		0x0018
>> +#define QSERDES_COM_SSC_PER1			0x001C
>> +#define QSERDES_COM_SSC_PER2			0x0020
>> +#define QSERDES_COM_SSC_STEP_SIZE1		0x0024
>> +#define QSERDES_COM_SSC_STEP_SIZE2		0x0028
>> +#define QSERDES_COM_POST_DIV			0x002C
>> +#define QSERDES_COM_POST_DIV_MUX		0x0030
>> +#define QSERDES_COM_BIAS_EN_CLKBUFLR_EN		0x0034
>> +#define QSERDES_COM_CLK_ENABLE1			0x0038
>> +#define QSERDES_COM_SYS_CLK_CTRL		0x003C
>> +#define QSERDES_COM_SYSCLK_BUF_ENABLE		0x0040
>> +#define QSERDES_COM_PLL_EN			0x0044
>> +#define QSERDES_COM_PLL_IVCO			0x0048
>> +#define QSERDES_COM_CMN_IETRIM			0x004C
>> +#define QSERDES_COM_CMN_IPTRIM			0x0050
>> +
>> +#define QSERDES_COM_CP_CTRL_MODE0		0x0060
>> +#define QSERDES_COM_CP_CTRL_MODE1		0x0064
>> +#define QSERDES_COM_PLL_RCTRL_MODE0		0x0068
>> +#define QSERDES_COM_PLL_RCTRL_MODE1		0x006C
>> +#define QSERDES_COM_PLL_CCTRL_MODE0		0x0070
>> +#define QSERDES_COM_PLL_CCTRL_MODE1		0x0074
>> +#define QSERDES_COM_PLL_CNTRL			0x0078
>> +#define QSERDES_COM_BIAS_EN_CTRL_BY_PSM		0x007C
>> +#define QSERDES_COM_SYSCLK_EN_SEL		0x0080
>> +#define QSERDES_COM_CML_SYSCLK_SEL		0x0084
>> +#define QSERDES_COM_RESETSM_CNTRL		0x0088
>> +#define QSERDES_COM_RESETSM_CNTRL2		0x008C
>> +#define QSERDES_COM_LOCK_CMP_EN			0x0090
>> +#define QSERDES_COM_LOCK_CMP_CFG		0x0094
>> +#define QSERDES_COM_LOCK_CMP1_MODE0		0x0098
>> +#define QSERDES_COM_LOCK_CMP2_MODE0		0x009C
>> +#define QSERDES_COM_LOCK_CMP3_MODE0		0x00A0
>> +
>> +#define QSERDES_COM_DEC_START_MODE0		0x00B0
>> +#define QSERDES_COM_DEC_START_MODE1		0x00B4
>> +#define QSERDES_COM_DIV_FRAC_START1_MODE0	0x00B8
>> +#define QSERDES_COM_DIV_FRAC_START2_MODE0	0x00BC
>> +#define QSERDES_COM_DIV_FRAC_START3_MODE0	0x00C0
>> +#define QSERDES_COM_DIV_FRAC_START1_MODE1	0x00C4
>> +#define QSERDES_COM_DIV_FRAC_START2_MODE1	0x00C8
>> +#define QSERDES_COM_DIV_FRAC_START3_MODE1	0x00CC
>> +#define QSERDES_COM_INTEGLOOP_INITVAL		0x00D0
>> +#define QSERDES_COM_INTEGLOOP_EN		0x00D4
>> +#define QSERDES_COM_INTEGLOOP_GAIN0_MODE0	0x00D8
>> +#define QSERDES_COM_INTEGLOOP_GAIN1_MODE0	0x00DC
>> +#define QSERDES_COM_INTEGLOOP_GAIN0_MODE1	0x00E0
>> +#define QSERDES_COM_INTEGLOOP_GAIN1_MODE1	0x00E4
>> +#define QSERDES_COM_VCOCAL_DEADMAN_CTRL		0x00E8
>> +#define QSERDES_COM_VCO_TUNE_CTRL		0x00EC
>> +#define QSERDES_COM_VCO_TUNE_MAP		0x00F0
>> +
>> +#define QSERDES_COM_CMN_STATUS			0x0124
>> +#define QSERDES_COM_RESET_SM_STATUS		0x0128
>> +
>> +#define QSERDES_COM_CLK_SEL			0x0138
>> +#define QSERDES_COM_HSCLK_SEL			0x013C
>> +
>> +#define QSERDES_COM_CORECLK_DIV_MODE0		0x0148
>> +
>> +#define QSERDES_COM_SW_RESET			0x0150
>> +#define QSERDES_COM_CORE_CLK_EN			0x0154
>> +#define QSERDES_COM_C_READY_STATUS		0x0158
>> +#define QSERDES_COM_CMN_CONFIG			0x015C
>> +
>> +#define QSERDES_COM_SVS_MODE_CLK_SEL		0x0164
>> +
>> +/* DP MMSS_CC registers */
>> +#define MMSS_DP_LINK_CMD_RCGR			(0x0138)
>> +#define MMSS_DP_LINK_CFG_RCGR			(0x013C)
>> +#define MMSS_DP_PIXEL_M				(0x0174)
>> +#define MMSS_DP_PIXEL_N				(0x0178)
>> +
>> +/* DP HDCP 1.3 registers */
>> +#define DP_HDCP_CTRL                                   (0x0A0)
>> +#define DP_HDCP_STATUS                                 (0x0A4)
>> +#define DP_HDCP_SW_UPPER_AKSV                          (0x098)
>> +#define DP_HDCP_SW_LOWER_AKSV                          (0x09C)
>> +#define DP_HDCP_ENTROPY_CTRL0                          (0x350)
>> +#define DP_HDCP_ENTROPY_CTRL1                          (0x35C)
>> +#define DP_HDCP_SHA_STATUS                             (0x0C8)
>> +#define DP_HDCP_RCVPORT_DATA2_0                        (0x0B0)
>> +#define DP_HDCP_RCVPORT_DATA3                          (0x0A4)
>> +#define DP_HDCP_RCVPORT_DATA4                          (0x0A8)
>> +#define DP_HDCP_RCVPORT_DATA5                          (0x0C0)
>> +#define DP_HDCP_RCVPORT_DATA6                          (0x0C4)
>> +
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_CTRL           (0x024)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_SHA_DATA           (0x028)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA0      (0x004)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA1      (0x008)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA7      (0x00C)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA8      (0x010)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA9      (0x014)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA10     (0x018)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA11     (0x01C)
>> +#define HDCP_SEC_DP_TZ_HV_HLOS_HDCP_RCVPORT_DATA12     (0x020)
>> +
>> +/* USB3 DP COM registers */
>> +#define USB3_DP_COM_RESET_OVRD_CTRL (0x1C)
>> +#define USB3_DP_COM_PHY_MODE_CTRL   (0x00)
>> +#define USB3_DP_COM_SW_RESET        (0x04)
>> +#define USB3_DP_COM_TYPEC_CTRL      (0x10)
>> +#define USB3_DP_COM_SWI_CTRL        (0x0c)
>> +#define USB3_DP_COM_POWER_DOWN_CTRL (0x08)
>> +
>> +
>> +
>> +#endif /* _DP_REG_H_ */
>> diff --git a/drivers/gpu/drm/msm/msm_drv.c 
>> b/drivers/gpu/drm/msm/msm_drv.c
>> index f5cd7f6..be801be 100644
>> --- a/drivers/gpu/drm/msm/msm_drv.c
>> +++ b/drivers/gpu/drm/msm/msm_drv.c
>> @@ -1367,6 +1367,7 @@ static int __init msm_drm_register(void)
>>  	msm_dsi_register();
>>  	msm_edp_register();
>>  	msm_hdmi_register();
>> +	msm_dp_register();
>>  	adreno_register();
>>  	return platform_driver_register(&msm_platform_driver);
>>  }
>> @@ -1375,6 +1376,7 @@ static void __exit msm_drm_unregister(void)
>>  {
>>  	DBG("fini");
>>  	platform_driver_unregister(&msm_platform_driver);
>> +	msm_dp_unregister();
>>  	msm_hdmi_unregister();
>>  	adreno_unregister();
>>  	msm_edp_unregister();
>> diff --git a/drivers/gpu/drm/msm/msm_drv.h 
>> b/drivers/gpu/drm/msm/msm_drv.h
>> index 9d11f32..fb1e6f4 100644
>> --- a/drivers/gpu/drm/msm/msm_drv.h
>> +++ b/drivers/gpu/drm/msm/msm_drv.h
>> @@ -176,6 +176,7 @@ struct msm_drm_private {
>>  	/* DSI is shared by mdp4 and mdp5 */
>>  	struct msm_dsi *dsi[2];
>> 
>> +	struct msm_dp *dp;
> 
> Can you please add an extra line here?
> 
>>  	/* when we have more than one 'msm_gpu' these need to be an array: 
>> */
>>  	struct msm_gpu *gpu;
>>  	struct msm_file_private *lastctx;
>> @@ -364,6 +365,27 @@ static inline int msm_dsi_modeset_init(struct 
>> msm_dsi *msm_dsi,
>>  }
>>  #endif
>> 
>> +#ifdef CONFIG_DRM_MSM_DP
>> +int __init msm_dp_register(void);
>> +void __exit msm_dp_unregister(void);
>> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device 
>> *dev,
>> +			 struct drm_encoder *encoder);
>> +#else
>> +static inline int __init msm_dp_register(void)
>> +{
>> +	return -EINVAL;
>> +}
>> +static inline void __exit msm_dp_unregister(void)
>> +{
>> +}
>> +static inline int msm_dp_modeset_init(struct msm_dp *dp_display,
>> +				       struct drm_device *dev,
>> +				       struct drm_encoder *encoder)
>> +{
>> +	return -EINVAL;
>> +}
>> +#endif
>> +
>>  void __init msm_mdp_register(void);
>>  void __exit msm_mdp_unregister(void);
>>  void __init msm_dpu_register(void);
>> diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
>> index 2a3843f..b0816f5 100644
>> --- a/include/drm/drm_dp_helper.h
>> +++ b/include/drm/drm_dp_helper.h
> 
> Split these changes out into a separate patch, please
> 
>> @@ -551,6 +551,8 @@
>>  # define DP_TEST_LINK_EDID_READ		    (1 << 2)
>>  # define DP_TEST_LINK_PHY_TEST_PATTERN	    (1 << 3) /* DPCD >= 1.1 */
>>  # define DP_TEST_LINK_FAUX_PATTERN	    (1 << 4) /* DPCD >= 1.2 */
>> +# define DP_TEST_LINK_AUDIO_PATTERN     (1 << 5)
>> +# define DP_TEST_LINK_AUDIO_DISABLED_VIDEO (1 << 6)
> 
> Add DPCD version in comments for these like above.
> 
>> 
>>  #define DP_TEST_LINK_RATE		    0x219
>>  # define DP_LINK_RATE_162		    (0x6)
>> @@ -639,6 +641,13 @@
>>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_71_64  0x258
>>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_79_72  0x259
>> 
>> +#define DP_TEST_PHY_PATTERN_NONE			0x0
>> +#define DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING	0x1
>> +#define DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT 0x2
>> +#define DP_TEST_PHY_PATTERN_PRBS7			0x3
>> +#define DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN	0x4
>> +#define DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN	0x5
> 
> These are already in drm_dp_helper under DP_LINK_QUAL_PATTERN_*
> 
>> +
>>  #define DP_TEST_RESPONSE		    0x260
>>  # define DP_TEST_ACK			    (1 << 0)
>>  # define DP_TEST_NAK			    (1 << 1)
>> @@ -648,6 +657,16 @@
>> 
>>  #define DP_TEST_SINK			    0x270
>>  # define DP_TEST_SINK_START		    (1 << 0)
>> +#define DP_TEST_AUDIO_MODE		    0x271
>> +#define DP_TEST_AUDIO_PATTERN_TYPE	    0x272
>> +#define DP_TEST_AUDIO_PERIOD_CH1	    0x273
>> +#define DP_TEST_AUDIO_PERIOD_CH2	    0x274
>> +#define DP_TEST_AUDIO_PERIOD_CH3	    0x275
>> +#define DP_TEST_AUDIO_PERIOD_CH4	    0x276
>> +#define DP_TEST_AUDIO_PERIOD_CH5	    0x277
>> +#define DP_TEST_AUDIO_PERIOD_CH6	    0x278
>> +#define DP_TEST_AUDIO_PERIOD_CH7	    0x279
>> +#define DP_TEST_AUDIO_PERIOD_CH8	    0x27A
>> 
>>  #define DP_FEC_STATUS			    0x280    /* 1.4 */
>>  # define DP_FEC_DECODE_EN_DETECTED	    (1 << 0)
>> --
>> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora 
>> Forum,
>> a Linux Foundation Collaborative Project
>> 
>> _______________________________________________
>> Freedreno mailing list
>> Freedreno@lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/freedreno
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Sean Paul]

On Mon, Nov 19, 2018 at 02:34:53PM -0800, chandanu@codeaurora.org wrote:
> On 2018-10-23 09:28, Sean Paul wrote:
> > On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> > > Add the needed displayPort files to enable DP driver
> > > on msm target.
> > > 
> > > "dp_display" module is the main module that calls into
> > > other sub-modules. "dp_drm" file represents the interface
> > > between DRM framework and DP driver.
> > > 
> > 
> 
> Hello Sean,
> I had few queries regarding your comments. Shared my queries below. Please
> share your feedback.

/snip

> > > diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c
> > > b/drivers/gpu/drm/msm/dp/dp_aux.c
> > > new file mode 100644
> > > index 0000000..00b82c2
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/msm/dp/dp_aux.c
> > > @@ -0,0 +1,570 @@
> > 
> > /snip
> > 
> > > diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h
> > > b/drivers/gpu/drm/msm/dp/dp_aux.h
> > > new file mode 100644
> > > index 0000000..0c300ed
> > > --- /dev/null
> > > +++ b/drivers/gpu/drm/msm/dp/dp_aux.h
> > 
> > /snip
> > 
> > I didn't really review the dp_aux.* files as-is. Please convert to using
> > drm_dp_aux and I'll take another look.
> > 
> 
> Please correct me if I am wrong. Looks like you are suggesting to use most
> of the drm_dp_aux struct variable
> instead of what we have defined locally.
> 

Correct


/snip


> > > +	struct dp_catalog_ctrl ctrl = {
> > > +		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
> > > +		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
> > > +		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
> > > +		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
> > > +		.config_misc    = dp_catalog_ctrl_config_misc,
> > > +		.config_msa     = dp_catalog_ctrl_config_msa,
> > > +		.set_pattern    = dp_catalog_ctrl_set_pattern,
> > > +		.reset          = dp_catalog_ctrl_reset,
> > > +		.usb_reset      = dp_catalog_ctrl_usb_reset,
> > > +		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
> > > +		.enable_irq     = dp_catalog_ctrl_enable_irq,
> > > +		.hpd_config     = dp_catalog_ctrl_hpd_config,
> > > +		.phy_reset      = dp_catalog_ctrl_phy_reset,
> > > +		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
> > > +		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
> > > +		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
> > > +		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
> > > +		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
> > > +		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,
> > 
> > So, what's the benefit of adding the catalog abstractions? Do you ever
> > have
> > multiple/alternate implementations of a catalog? It doesn't seem like
> > it. You
> > should just remove all of the catalog overhead and call the functions
> > directly.
> 
> We use catalog abstractions for two different reasons:
> 1. To support multiple hardware since these implementations are hardware
> specific.
> 2. To virtualize DP hardware.
> 
> Our internal hardware already supports multiple chips. We want to keep these
> abstractions to
> make the code consistent between upstream and internal implementation.
> 

I'm not sure how this differs from having a common header/function declarations
and multiple definitions in a .c gated by CONFIG_*? Ideally even this wouldn't be
necessary since hw changes are either incremental and can be done more precisely
than wholesale changing the implementation.

If you want to virtualize, you can do the CONFIG_* thing. However since that's
not going upstream, you can carry the Kconfig/Makefile change in your
downstream.

All of these abstractions add thousands of lines of code, extra files, and multiple
levels of indirection. IMO, I don't think the benefits outweigh the costs.

/snip

> > > +static void dp_ctrl_calc_tu_parameters(struct dp_ctrl_private *ctrl,
> > > +				       struct dp_vc_tu_mapping_table *tu_table)
> > > +{
> > > +	u32 multiplier = 1000000;
> > > +	u64 pclk, lclk;
> > > +	u8 bpp, ln_cnt;
> > > +	int run_idx = 0;
> > > +	u32 lwidth, h_blank;
> > > +	u32 fifo_empty = 0;
> > > +	u32 ratio_scale = 1001;
> > > +	u64 temp, ratio, original_ratio;
> > > +	u64 temp2, reminder;
> > > +	u64 temp3, temp4, result = 0;
> > > +
> > > +	u64 err = multiplier;
> > > +	u64 n_err = 0, n_n_err = 0;
> > > +	bool n_err_neg, nn_err_neg;
> > > +	u8 hblank_margin = 16;
> > > +
> > > +	u8 tu_size, tu_size_desired = 0, tu_size_minus1;
> > > +	int valid_boundary_link;
> > > +	u64 resulting_valid;
> > > +	u64 total_valid;
> > > +	u64 effective_valid;
> > > +	u64 effective_valid_recorded;
> > > +	int n_tus;
> > > +	int n_tus_per_lane;
> > > +	int paired_tus;
> > > +	int remainder_tus;
> > > +	int remainder_tus_upper, remainder_tus_lower;
> > > +	int extra_bytes;
> > > +	int filler_size;
> > > +	int delay_start_link;
> > > +	int boundary_moderation_en = 0;
> > > +	int upper_bdry_cnt = 0;
> > > +	int lower_bdry_cnt = 0;
> > > +	int i_upper_bdry_cnt = 0;
> > > +	int i_lower_bdry_cnt = 0;
> > > +	int valid_lower_boundary_link = 0;
> > > +	int even_distribution_bf = 0;
> > > +	int even_distribution_legacy = 0;
> > > +	int even_distribution = 0;
> > > +	int min_hblank = 0;
> > > +	int extra_pclk_cycles;
> > > +	u8 extra_pclk_cycle_delay = 4;
> > > +	int extra_pclk_cycles_in_link_clk;
> > > +	u64 ratio_by_tu;
> > > +	u64 average_valid2;
> > > +	u64 extra_buffer_margin;
> > > +	int new_valid_boundary_link;
> > > +
> > > +	u64 resulting_valid_tmp;
> > > +	u64 ratio_by_tu_tmp;
> > > +	int n_tus_tmp;
> > > +	int extra_pclk_cycles_tmp;
> > > +	int extra_pclk_cycles_in_lclk_tmp;
> > > +	int extra_req_bytes_new_tmp;
> > > +	int filler_size_tmp;
> > > +	int lower_filler_size_tmp;
> > > +	int delay_start_link_tmp;
> > > +	int min_hblank_tmp = 0;
> > > +	bool extra_req_bytes_is_neg = false;
> > > +	struct dp_panel_info *pinfo = &ctrl->panel->pinfo;
> > > +
> > > +	u8 dp_brute_force = 1;
> > > +	u64 brute_force_threshold = 10;
> > > +	u64 diff_abs;
> > 
> > 
> > 76 stack vars and ~450 lines must be a new record somewhere :)
> > 
> > I'm going to skip reviewing this function and let you
> > split/simplify/reduce it.
> > Please just make it more readable (comments, docs, helper functions,
> > etc).
> 
> Yes, will try to split this function as modular as possible.
> JFYI, this function is IP/hardware specific implementation. It might not be
> possible
> to provide lot of comments to make is understandable.


Ok, please do what you can to simplify/split and add a comment that this is
magic from the HW team.


/snip

> > > +int msm_dp_modeset_init(struct msm_dp *dp_display, struct
> > > drm_device *dev,
> > > +			struct drm_encoder *encoder)
> > 
> > Where is this called?
> 
> This is called from dpu_kms.c. The changes from DPU will be dependent on
> these changes.
> 

Hmm, is that code missing? I don't see this function being called anywhere in
this patch.


/snip

> > > +static const struct drm_bridge_funcs dp_bridge_ops = {
> > > +	.mode_fixup   = dp_bridge_mode_fixup,
> > > +	.pre_enable   = dp_bridge_pre_enable,
> > > +	.enable       = dp_bridge_enable,
> > > +	.disable      = dp_bridge_disable,
> > > +	.post_disable = dp_bridge_post_disable,
> > > +	.mode_set     = dp_bridge_mode_set,
> > > +};
> > 
> > I'm not convinced you need any of this. The only advantage a bridge gets
> > you is
> > to be involved in modeset. However the only thing you do in modeset is
> > save the
> > mode (which is only used in enable). So why not just use the mode from
> > the
> > crtc's state when encoder->enable is called?
> > 
> > That allows you to delete all of the bridge stuff here.
> > 
> Will keep enable, disable and mode_set func ops and remove the remaining
> ops.
> Please let me know if you still have concerns with these func ops.
> 

Why not remove all of it and call this code from the encoder's enable function?
You shouldn't need a bridge at all.


/snip

> > > +static int dp_parser_init_clk_data(struct dp_parser *parser)
> > > +{
> > > +	int num_clk = 0, i = 0, rc = 0;
> > > +	int core_clk_count = 0, ctrl_clk_count = 0;
> > > +	const char *core_clk = "core";
> > > +	const char *ctrl_clk = "ctrl";
> > > +	const char *clk_name;
> > > +	struct device *dev = &parser->pdev->dev;
> > > +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> > > +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> > > +
> > > +	num_clk = of_property_count_strings(dev->of_node, "clock-names");
> > > +	if (num_clk <= 0) {
> > > +		pr_err("no clocks are defined\n");
> > > +		rc = -EINVAL;
> > > +		goto exit;
> > > +	}
> > > +
> > > +	for (i = 0; i < num_clk; i++) {
> > > +		of_property_read_string_index(dev->of_node,
> > > +				"clock-names", i, &clk_name);
> > 
> > Check return value
> > 
> > > +
> > > +		if (dp_parser_check_prefix(core_clk, clk_name))
> > > +			core_clk_count++;
> > > +
> > > +		if (dp_parser_check_prefix(ctrl_clk, clk_name))
> > > +			ctrl_clk_count++;
> > 
> > Just use "core"/"ctrl" directly here.
> > 
> > Have you considered just having 2 clock lists? That would avoid having
> > to do
> > this.
> I am not clear on what you are suggesting? We currently have two clock-lists
> (core & ctrl).
> 
> 

I meant in the dt bindings. Instead of one clocks list, could you split into
core and ctrl? That way you wouldn't have to parse based on name.

/snip

> > 
> > ---- START hmmmm
> I didn't understand, can you please provide more details regarding "START"
> and "END".
> > 
> > > +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
> > > +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
> > > +
> > > +	core_power = &parser->mp[DP_CORE_PM];
> > > +	ctrl_power = &parser->mp[DP_CTRL_PM];
> > 
> > ---- END hmmmm
> > 

You assign core_power and ctrl_power in the declaration and then immediately
assign the value again.

/snip

-- 
Sean Paul, Software Engineer, Google / Chromium OS
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[chandanu-sgV2jX0FEOL9JmXXK+q4OQ]

On 2018-10-23 09:28, Sean Paul wrote:
> On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
>> Add the needed displayPort files to enable DP driver
>> on msm target.
>> 
>> "dp_display" module is the main module that calls into
>> other sub-modules. "dp_drm" file represents the interface
>> between DRM framework and DP driver.
>> 
> 

Hello Sean,
I have responded to all of your comments and queries. I have specified 
the comments addressed
in V2 patch series and what I have missed that will be fixed in V3.


> Hi Chandan,
> A few themes which I've pointed out below, but want to call out at the 
> top so
> it's obvious.
> 
> - Please remove all superfluous NULL checks at the beginning of 
> functions.
>   Included in this is reflowing initialization of variables and 
> checking that
>   return types still make sense (ie: if a function's only error path is 
> the NULL
>   check, make it void).
> - Please remove all of the new callbacks and just call functions 
> directly. This
>   should also get rid of the _get/_put functions that allocate/set them 
> up
> - Please consolidate state structs into one struct with a few 
> substructs,
>   there's too much state right now.
> - Please #define hardcoded values
> - Instead of sprinkling wmb() everywhere, use readl/writel instead of 
> *_relaxed
> - There are a bunch of races that I found, please audit the code and 
> remove
>   races with locks as necessary
> - I tried to catch as much dead code as possible, please audit the rest 
> for
>   unused structs/variables/functions/etc
> - Use drm dp helper structs for link parameter storage
> 
> 
>> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
>> ---
>>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>>  drivers/gpu/drm/msm/Makefile                |   15 +-
>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 
>> ++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 
>> +++++++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 
>> +++++++++++++++++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>>  include/drm/drm_dp_helper.h                 |   19 +
>>  30 files changed, 10887 insertions(+), 1 deletion(-)
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
>> 
>> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
>> index 843a9d4..c363f24 100644
>> --- a/drivers/gpu/drm/msm/Kconfig
>> +++ b/drivers/gpu/drm/msm/Kconfig
>> @@ -49,6 +49,15 @@ config DRM_MSM_HDMI_HDCP
>>  	help
>>  	  Choose this option to enable HDCP state machine
>> 
>> +config DRM_MSM_DP
>> +	bool "Enable DP support in MSM DRM driver"
>> +	depends on DRM_MSM
>> +	default n
>> +	help
>> +	  Compile in support for DP driver in msm drm
>> +	  driver. DP external display support is enabled
>> +	  through this config option. It can be primary or
>> +	  secondary display on device.
> 
> Why are these line lengths so short? You can go to 80 columns. Please 
> also add
> an empty line here.
Fixed this in V2.

> 
>>  config DRM_MSM_DSI
>>  	bool "Enable DSI support in MSM DRM driver"
>>  	depends on DRM_MSM
>> diff --git a/drivers/gpu/drm/msm/Makefile 
>> b/drivers/gpu/drm/msm/Makefile
>> index 19ab521..765a8d8 100644
>> --- a/drivers/gpu/drm/msm/Makefile
>> +++ b/drivers/gpu/drm/msm/Makefile
>> @@ -2,6 +2,7 @@
>>  ccflags-y := -Idrivers/gpu/drm/msm
>>  ccflags-y += -Idrivers/gpu/drm/msm/disp/dpu1
>>  ccflags-$(CONFIG_DRM_MSM_DSI) += -Idrivers/gpu/drm/msm/dsi
>> +ccflags-$(CONFIG_DRM_MSM_DP) += -Idrivers/gpu/drm/msm/dp
>> 
>>  msm-y := \
>>  	adreno/adreno_device.o \
>> @@ -93,7 +94,19 @@ msm-y := \
>>  	msm_submitqueue.o
>> 
>>  msm-$(CONFIG_DEBUG_FS) += adreno/a5xx_debugfs.o \
>> -			  disp/dpu1/dpu_dbg.o
>> +			  disp/dpu1/dpu_dbg.o \
>> +			  dp/dp_debug.o
> 
> Does this compile if CONFIG_DEBUG_FS is selected, but not 
> CONFIG_DRM_MSM_DP?
> 
Fixed this in V2. DEBUG file is removed in V2.

>> +
>> +msm-$(CONFIG_DRM_MSM_DP)+= dp/dp_extcon.o \
>> +	dp/dp_parser.o \
>> +	dp/dp_power.o \
>> +	dp/dp_catalog.o \
>> +	dp/dp_aux.o \
>> +	dp/dp_panel.o \
>> +	dp/dp_link.o \
>> +	dp/dp_ctrl.o \
>> +	dp/dp_display.o \
>> +	dp/dp_drm.o
> 
> The rest of the file has files in alphabetical order, this should too.
> 
Fixed this in V2.

>> 
>>  msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
>>  msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c 
>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> index 790d39f..0f53a15 100644
>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c
>> @@ -14,10 +14,216 @@
>>  #include <linux/clk.h>
>>  #include <linux/clk/clk-conf.h>
>>  #include <linux/err.h>
>> +#include <linux/io.h>
>> +#include <linux/regulator/consumer.h>
>>  #include <linux/delay.h>
>> 
>>  #include "dpu_io_util.h"
>> 
>> +static struct resource *msm_dss_get_res_byname(struct platform_device 
>> *pdev,
>> +					       unsigned int type,
>> +					       const char *name)
>> +{
>> +	struct resource *res = NULL;
>> +
>> +	res = platform_get_resource_byname(pdev, type, name);
>> +	if (!res)
>> +		DEV_ERR("%s: '%s' resource not found\n", __func__, name);
>> +
>> +	return res;
>> +} /* msm_dss_get_res_byname */
> 
> Why don't you just call platform_get_resource_byname directly?
> 
Fixed this in V2.

>> +
>> +int msm_dss_ioremap_byname(struct platform_device *pdev,
>> +			   struct dss_io_data *io_data, const char *name)
>> +{
>> +	struct resource *res = NULL;
>> +
>> +	if (!pdev || !io_data) {
> 
> Given that we've been aggressively trying to get rid of these 
> superfluous
> checks, I'm not thrilled that they're being re-introduced. Can you 
> please go
> through the patch and remove all of the unnecessary checks?
> 
Most of them have been removed in V2 patch. Only kept the checks where 
necessary.
Will go through the files again and see if I have missed anything. (For 
V3)

>> +		DEV_ERR("%pS->%s: invalid input\n",
>> +			__builtin_return_address(0), __func__);
>> +		return -EINVAL;
>> +	}
>> +
>> +	res = msm_dss_get_res_byname(pdev, IORESOURCE_MEM, name);
>> +	if (!res) {
>> +		DEV_ERR("%pS->%s: '%s' msm_dss_get_res_byname failed\n",
>> +			__builtin_return_address(0), __func__, name);
> 
> Yet another error format :) Could we please stick with one of 
> DPU_ERROR,
> DRM_ERROR, or DRM_DEV_ERROR?
> 
All of the error formats has been move to DRM_ERROR in v2.

>> +		return -ENODEV;
>> +	}
>> +
>> +	io_data->len = (u32)resource_size(res);
>> +	io_data->base = ioremap(res->start, io_data->len);
>> +	if (!io_data->base) {
>> +		DEV_ERR("%pS->%s: '%s' ioremap failed\n",
>> +			__builtin_return_address(0), __func__, name);
>> +		return -EIO;
>> +	}
>> +
>> +	return 0;
>> +} /* msm_dss_ioremap_byname */
>> +
>> +void msm_dss_iounmap(struct dss_io_data *io_data)
>> +{
>> +	if (!io_data) {
>> +		DEV_ERR("%pS->%s: invalid input\n",
>> +			__builtin_return_address(0), __func__);
>> +		return;
>> +	}
>> +
>> +	if (io_data->base) {
>> +		iounmap(io_data->base);
>> +		io_data->base = NULL;
>> +	}
>> +	io_data->len = 0;
>> +} /* msm_dss_iounmap */
> 
> These two functions are only used in dp_parser.c, why not just make 
> them static
> functions there?
> 
These two functions are moved to dp_parser.c in V2.


>> +
>> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
>> +			int num_vreg, int config)
> 
> This should be 2 functions, one for initialization and one for 
> deinitializing,
> the 2 paths don't share any code, so there's no need to combine them.
> 
Added 2 functions in V2 patch. (The functions are moved to dp_power.c 
file)
>> +{
>> +	int i = 0, rc = 0;
>> +	struct dss_vreg *curr_vreg = NULL;
>> +	enum dss_vreg_type type;
>> +
>> +	if (!in_vreg || !num_vreg)
>> +		return rc;
>> +
>> +	if (config) {
>> +		for (i = 0; i < num_vreg; i++) {
>> +			curr_vreg = &in_vreg[i];
>> +			curr_vreg->vreg = regulator_get(dev,
> 
> Use devm_* please

Fixed in V2.

> 
>> +				curr_vreg->vreg_name);
>> +			rc = PTR_RET(curr_vreg->vreg);
> 
> PTR_RET is deprecated. The pattern for this is usually:
> 
>                         ptr = some_func();
>                         if (IS_ERR_OR_NULL(ptr)) {
>                                 ...
>                                 rc = PTR_ERR(ptr);
>                                 goto fail_label:
>                         }
> 
Didn't address this comment. Will fix this in V3 patch.



>> +			if (rc) {
>> +				DEV_ERR("%pS->%s: %s get failed. rc=%d\n",
>> +					 __builtin_return_address(0), __func__,
>> +					 curr_vreg->vreg_name, rc);
>> +				curr_vreg->vreg = NULL;
>> +				goto vreg_get_fail;
>> +			}
>> +			type = (regulator_count_voltages(curr_vreg->vreg) > 0)
>> +					? DSS_REG_LDO : DSS_REG_VS;
>> +			if (type == DSS_REG_LDO) {
>> +				rc = regulator_set_voltage(
>> +					curr_vreg->vreg,
>> +					curr_vreg->min_voltage,
>> +					curr_vreg->max_voltage);
>> +				if (rc < 0) {
>> +					DEV_ERR("%pS->%s: %s set vltg fail\n",
>> +						__builtin_return_address(0),
>> +						__func__,
>> +						curr_vreg->vreg_name);
>> +					goto vreg_set_voltage_fail;
>> +				}
>> +			}
>> +		}
>> +	} else {
>> +		for (i = num_vreg-1; i >= 0; i--) {
>> +			curr_vreg = &in_vreg[i];
>> +			if (curr_vreg->vreg) {
>> +				type = (regulator_count_voltages(
>> +					curr_vreg->vreg) > 0)
>> +					? DSS_REG_LDO : DSS_REG_VS;
>> +				if (type == DSS_REG_LDO) {
>> +					regulator_set_voltage(curr_vreg->vreg,
>> +						0, curr_vreg->max_voltage);
>> +				}
>> +				regulator_put(curr_vreg->vreg);
>> +				curr_vreg->vreg = NULL;
>> +			}
>> +		}
>> +	}
>> +	return 0;
>> +
>> +vreg_unconfig:
>> +if (type == DSS_REG_LDO)
>> +	regulator_set_load(curr_vreg->vreg, 0);
>> +
>> +vreg_set_voltage_fail:
>> +	regulator_put(curr_vreg->vreg);
>> +	curr_vreg->vreg = NULL;
>> +
>> +vreg_get_fail:
>> +	for (i--; i >= 0; i--) {
>> +		curr_vreg = &in_vreg[i];
>> +		type = (regulator_count_voltages(curr_vreg->vreg) > 0)
>> +			? DSS_REG_LDO : DSS_REG_VS;
>> +		goto vreg_unconfig;
>> +	}
>> +	return rc;
>> +} /* msm_dss_config_vreg */
>> +
>> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg, int 
>> enable)
>> +{
>> +	int i = 0, rc = 0;
>> +	bool need_sleep;
>> +
>> +	if (enable) {
>> +		for (i = 0; i < num_vreg; i++) {
>> +			rc = PTR_RET(in_vreg[i].vreg);
>> +			if (rc) {
>> +				DEV_ERR("%pS->%s: %s regulator error. rc=%d\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name, rc);
>> +				goto vreg_set_opt_mode_fail;
>> +			}
>> +			need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
>> +			if (in_vreg[i].pre_on_sleep && need_sleep)
>> +				usleep_range(in_vreg[i].pre_on_sleep * 1000,
>> +					in_vreg[i].pre_on_sleep * 1000);
>> +			rc = regulator_set_load(in_vreg[i].vreg,
>> +				in_vreg[i].enable_load);
>> +			if (rc < 0) {
>> +				DEV_ERR("%pS->%s: %s set opt m fail\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name);
>> +				goto vreg_set_opt_mode_fail;
>> +			}
>> +			rc = regulator_enable(in_vreg[i].vreg);
>> +			if (in_vreg[i].post_on_sleep && need_sleep)
>> +				usleep_range(in_vreg[i].post_on_sleep * 1000,
>> +					in_vreg[i].post_on_sleep * 1000);
>> +			if (rc < 0) {
>> +				DEV_ERR("%pS->%s: %s enable failed\n",
>> +					__builtin_return_address(0), __func__,
>> +					in_vreg[i].vreg_name);
>> +				goto disable_vreg;
>> +			}
>> +		}
>> +	} else {
>> +		for (i = num_vreg-1; i >= 0; i--) {
>> +			if (in_vreg[i].pre_off_sleep)
>> +				usleep_range(in_vreg[i].pre_off_sleep * 1000,
>> +					in_vreg[i].pre_off_sleep * 1000);
>> +			regulator_set_load(in_vreg[i].vreg,
>> +				in_vreg[i].disable_load);
>> +			regulator_disable(in_vreg[i].vreg);
>> +			if (in_vreg[i].post_off_sleep)
>> +				usleep_range(in_vreg[i].post_off_sleep * 1000,
>> +					in_vreg[i].post_off_sleep * 1000);
>> +		}
>> +	}
>> +	return rc;
>> +
>> +disable_vreg:
>> +	regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
>> +
>> +vreg_set_opt_mode_fail:
>> +	for (i--; i >= 0; i--) {
>> +		if (in_vreg[i].pre_off_sleep)
>> +			usleep_range(in_vreg[i].pre_off_sleep * 1000,
>> +				in_vreg[i].pre_off_sleep * 1000);
>> +		regulator_set_load(in_vreg[i].vreg,
>> +			in_vreg[i].disable_load);
>> +		regulator_disable(in_vreg[i].vreg);
>> +		if (in_vreg[i].post_off_sleep)
>> +			usleep_range(in_vreg[i].post_off_sleep * 1000,
>> +				in_vreg[i].post_off_sleep * 1000);
>> +	}
>> +
>> +	return rc;
>> +} /* msm_dss_enable_vreg */
>> +
> 
> Same question here, but with dp_power.
> 

Fixed this in V2.


>> +
>>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk)
>>  {
>>  	int i;
>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h 
>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> index bc07381..524b394 100644
>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h
>> @@ -15,6 +15,7 @@
>> 
>>  #include <linux/gpio.h>
>>  #include <linux/platform_device.h>
>> +#include <linux/regulator/consumer.h>
>>  #include <linux/types.h>
>> 
>>  #define DEV_DBG(fmt, args...)   pr_debug(fmt, ##args)
>> @@ -22,6 +23,39 @@
>>  #define DEV_WARN(fmt, args...)  pr_warn(fmt, ##args)
>>  #define DEV_ERR(fmt, args...)   pr_err(fmt, ##args)
>> 
>> +struct dss_io_data {
>> +	u32 len;
>> +	void __iomem *base;
>> +};
> 
> len isn't used anywhere, so this struct can go away. If the struct goes 
> away,
> you can really simplify (or eliminate msm_dss_ioremap_byname())
> 

We want to keep this since we use len for our internal unit level 
testing and in simulation mode.


>> +
>> +/*
>> +void dss_reg_w(struct dss_io_data *io, u32 offset, u32 value, u32 
>> debug);
>> +u32 dss_reg_r(struct dss_io_data *io, u32 offset, u32 debug);
>> +void dss_reg_dump(void __iomem *base, u32 len, const char *prefix, 
>> u32 debug);
>> +
>> +#define DSS_REG_W_ND(io, offset, val)  dss_reg_w(io, offset, val, 
>> false)
>> +#define DSS_REG_W(io, offset, val)     dss_reg_w(io, offset, val, 
>> true)
>> +#define DSS_REG_R_ND(io, offset)       dss_reg_r(io, offset, false)
>> +#define DSS_REG_R(io, offset)          dss_reg_r(io, offset, true)
>> +*/
> 
> None of the dss_reg_*/DSS_REG_* functions/macros are used. Please 
> remove.
> 

Removed this in V2.

> 
>> +enum dss_vreg_type {
>> +	DSS_REG_LDO,
>> +	DSS_REG_VS,
>> +};
> 
> These are only used in msm_dss_config_vreg(). Please remove.
> 
Will fix this in V3.

>> +
>> +struct dss_vreg {
>> +	struct regulator *vreg; /* vreg handle */
>> +	char vreg_name[32];
>> +	int min_voltage;
>> +	int max_voltage;
> 
> Can't we deduce these from the regulator subsystem with
> regulator_list_voltage()?
> 
>> +	int enable_load;
>> +	int disable_load;
> 
> These are really a function of the dp device than the regulator.
> 
>> +	int pre_on_sleep;
>> +	int post_on_sleep;
>> +	int pre_off_sleep;
>> +	int post_off_sleep;
> 
> None of these sleep values are set? Also, shouldn't these constraints 
> usually
> expressed/acted upon in the regulator driver?
> 
>> +};

Will remove them in V3. These were added as a generic implementation for 
io_utils. Since we
are not going to use them, will remove them for now.

> 
> So if we can remove all of the extra goop around the regulator, then we 
> can get
> rid of dss_vreg.
> 
Will follow up on vreg APIs and fix them in V3.

>> +
>>  struct dss_gpio {
>>  	unsigned int gpio;
>>  	unsigned int value;
>> @@ -42,12 +76,22 @@ struct dss_clk {
>>  };
>> 
>>  struct dss_module_power {
>> +	unsigned int num_vreg;
>> +	struct dss_vreg *vreg_config;
>>  	unsigned int num_gpio;
>>  	struct dss_gpio *gpio_config;
>>  	unsigned int num_clk;
>>  	struct dss_clk *clk_config;
>>  };
>> 
>> +int msm_dss_ioremap_byname(struct platform_device *pdev,
>> +			   struct dss_io_data *io_data, const char *name);
>> +void msm_dss_iounmap(struct dss_io_data *io_data);
>> +
>> +int msm_dss_config_vreg(struct device *dev, struct dss_vreg *in_vreg,
>> +			int num_vreg, int config);
>> +int msm_dss_enable_vreg(struct dss_vreg *in_vreg, int num_vreg,	int 
>> enable);
>> +
>>  int msm_dss_get_clk(struct device *dev, struct dss_clk *clk_arry, int 
>> num_clk);
>>  void msm_dss_put_clk(struct dss_clk *clk_arry, int num_clk);
> 
> 
> Why are these msm_dss* functions in dpu_io_util.h?

These functions are moved to specific files in V2.

> 
>>  int msm_dss_clk_set_rate(struct dss_clk *clk_arry, int num_clk);
>> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.c 
>> b/drivers/gpu/drm/msm/dp/dp_aux.c
>> new file mode 100644
>> index 0000000..00b82c2
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_aux.c
>> @@ -0,0 +1,570 @@
> 
> /snip
> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_aux.h 
>> b/drivers/gpu/drm/msm/dp/dp_aux.h
>> new file mode 100644
>> index 0000000..0c300ed
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_aux.h
> 
> /snip
> 
> I didn't really review the dp_aux.* files as-is. Please convert to 
> using
> drm_dp_aux and I'll take another look.
> 

Most of the aux interface already uses drm_dp_aux. We register with drm 
framework for aux traffic and
transfer->call back gets called.

I see that I have missed fixing the hard coded values for register 
operations for aux transfers. Will fix that in V3.

> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c 
>> b/drivers/gpu/drm/msm/dp/dp_catalog.c
>> new file mode 100644
>> index 0000000..5818612
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
>> @@ -0,0 +1,1188 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/delay.h>
>> +#include <drm/drm_dp_helper.h>
>> +
>> +#include "dp_catalog.h"
>> +#include "dp_reg.h"
>> +
>> +#define DP_GET_MSB(x)	(x >> 8)
>> +#define DP_GET_LSB(x)	(x & 0xff)
> 
> These aren't used anywhere
> 
Fixed in V2.

>> +
>> +#define dp_read(offset) readl_relaxed((offset))
>> +#define dp_write(offset, data) writel_relaxed((data), (offset))
> 
> These macros aren't useful. I think you'd be much better having a 
> read_/write_
> for the different io types, ie:
> 
> static inline u32 dp_read_audio(struct dp_catalog *catalog, u32 offset)
> {
>         return readl_relaxed(catalog->io->dp_link.base + offset);
> }
> 
> Then you can remove a ton of boilerplate code below getting base;

Fixed in V2.

> 
>> +
>> +#define dp_catalog_get_priv(x) { \
> 
> static inline struct dp_catalog_private *dp_catalog_get_priv(...)
> {
>         ...
> }
> 
For inline, we have to use 3 different functions (one each for aux, ctrl 
and panel).
Looking at "type-checking" w.r.t macro, container_of will through an 
error if its not valid pointer.
Please let me know if you still want to change this macro to inline 
func.

>> +	struct dp_catalog *dp_catalog; \
>> +	dp_catalog = container_of(x, struct dp_catalog, x); \
>> +	catalog = container_of(dp_catalog, struct dp_catalog_private, \
>> +				dp_catalog); \
>> +}
>> +
>> +#define DP_INTERRUPT_STATUS1 \
>> +	(DP_INTR_AUX_I2C_DONE| \
>> +	DP_INTR_WRONG_ADDR | DP_INTR_TIMEOUT | \
>> +	DP_INTR_NACK_DEFER | DP_INTR_WRONG_DATA_CNT | \
>> +	DP_INTR_I2C_NACK | DP_INTR_I2C_DEFER | \
>> +	DP_INTR_PLL_UNLOCKED | DP_INTR_AUX_ERROR)
>> +
>> +#define DP_INTR_MASK1		(DP_INTERRUPT_STATUS1 << 2)
>> +
>> +#define DP_INTERRUPT_STATUS2 \
>> +	(DP_INTR_READY_FOR_VIDEO | DP_INTR_IDLE_PATTERN_SENT | \
>> +	DP_INTR_FRAME_END | DP_INTR_CRC_UPDATED)
>> +
>> +#define DP_INTR_MASK2		(DP_INTERRUPT_STATUS2 << 2)
> 
> Can you please rename these to be consistent with each other?
> DP_INTERRUPT_STATUS2_MASK perhaps?

Fixed in V2.

> 
>> +
>> +static u8 const vm_pre_emphasis[4][4] = {
>> +	{0x00, 0x0B, 0x12, 0xFF},       /* pe0, 0 db */
>> +	{0x00, 0x0A, 0x12, 0xFF},       /* pe1, 3.5 db */
>> +	{0x00, 0x0C, 0xFF, 0xFF},       /* pe2, 6.0 db */
>> +	{0xFF, 0xFF, 0xFF, 0xFF}        /* pe3, 9.5 db */
>> +};
>> +
>> +/* voltage swing, 0.2v and 1.0v are not support */
>> +static u8 const vm_voltage_swing[4][4] = {
>> +	{0x07, 0x0F, 0x14, 0xFF}, /* sw0, 0.4v  */
>> +	{0x11, 0x1D, 0x1F, 0xFF}, /* sw1, 0.6 v */
>> +	{0x18, 0x1F, 0xFF, 0xFF}, /* sw1, 0.8 v */
>> +	{0xFF, 0xFF, 0xFF, 0xFF}  /* sw1, 1.2 v, optional */
>> +};
>> +
>> +/* audio related catalog functions */
>> +struct dp_catalog_private {
>> +	struct device *dev;
>> +	struct dp_io *io;
>> +
>> +	u32 (*audio_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	struct dp_catalog dp_catalog;
>> +};
>> +
>> +/* aux related catalog functions */
>> +static u32 dp_catalog_aux_read_data(struct dp_catalog_aux *aux)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
> 
> And another logging type, please remove pr_* and use a 
> DPU_/DRM_/DRM_DEV_
> variant.
> 
Fixed in V2.

>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	return dp_read(base + DP_AUX_DATA);
>> +end:
>> +	return 0;
> 
> ... or you could just return directly in the if above and remove the 
> label :)
> Same comment applies below.
> 
> Also, probably shouldn't return 0 in an error case.

Forgot to fix this. Will fix in V3.
> 
> Then again, I'm guessing hitting the NULL case is likely impossible, so 
> you can
> probably remove all of the machinery around checking !aux.
> 

Removed most of the arg null checks except few APIs where 
unit-testing/simulator-mode is used.

>> +}
>> +
>> +static int dp_catalog_aux_write_data(struct dp_catalog_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	dp_write(base + DP_AUX_DATA, aux->data);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_catalog_aux_write_trans(struct dp_catalog_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	dp_write(base + DP_AUX_TRANS_CTRL, aux->data);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_catalog_aux_clear_trans(struct dp_catalog_aux *aux, 
>> bool read)
>> +{
>> +	int rc = 0;
>> +	u32 data = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	if (read) {
>> +		data = dp_read(base + DP_AUX_TRANS_CTRL);
>> +		data &= ~BIT(9);
>> +		dp_write(base + DP_AUX_TRANS_CTRL, data);
>> +	} else {
>> +		dp_write(base + DP_AUX_TRANS_CTRL, 0);
>> +	}
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_catalog_aux_reset(struct dp_catalog_aux *aux)
>> +{
>> +	u32 aux_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
>> +
>> +	aux_ctrl |= BIT(1);
> 
> What's BIT(1)? Can you please #define it?
> 
Fixed in V2. Most of the hardcoded values are fixed in V2.

>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> 10us diff is right on the line of enough delay to make usleep_range 
> worth it.
> I'd recommend increasing to 100us to increase the chance of the 
> scheduler being
> able to batch this wakeup with another.
> 
Fixed in V2.

>> +
>> +	aux_ctrl &= ~BIT(1);
>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +	wmb();
> 
> Can you just use writel for these cases instead of using _relaxed and 
> then
> wmb()? This applies elsewhere too.
> 
Fixed in V2.

>> +}
>> +
>> +static void dp_catalog_aux_enable(struct dp_catalog_aux *aux, bool 
>> enable)
>> +{
>> +	u32 aux_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	aux_ctrl = dp_read(base + DP_AUX_CTRL);
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_TIMEOUT_COUNT, 0xffff);
>> +		dp_write(base + DP_AUX_LIMITS, 0xffff);
>> +		aux_ctrl |= BIT(0);
> 
> Please #define BIT(0)

Fixed in V2.

> 
>> +	} else {
>> +		aux_ctrl &= ~BIT(0);
>> +	}
>> +
>> +	dp_write(base + DP_AUX_CTRL, aux_ctrl);
>> +}
>> +
>> +static void dp_catalog_aux_update_cfg(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 new_index = 0, current_index = 0;
>> +
>> +	if (!aux || !cfg || (type >= PHY_AUX_CFG_MAX)) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +
>> +	current_index = cfg[type].current_index;
>> +	new_index = (current_index + 1) % cfg[type].cfg_cnt;
>> +	pr_debug("Updating %s from 0x%08x to 0x%08x\n",
>> +		dp_phy_aux_config_type_to_string(type),
>> +	cfg[type].lut[current_index], cfg[type].lut[new_index]);
>> +
>> +	dp_write(catalog->io->phy_io.base + cfg[type].offset,
>> +			cfg[type].lut[new_index]);
>> +	cfg[type].current_index = new_index;
>> +}
>> +
>> +static void dp_catalog_aux_setup(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	int i = 0;
>> +
>> +	if (!aux || !cfg) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_PD_CTL, 0x65);
> 
> What's 0x65? Please #define
> 
Fixed in V2.

>> +	wmb(); /* make sure PD programming happened */
>> +
>> +	/* Turn on BIAS current for PHY/PLL */
>> +	dp_write(catalog->io->dp_pll_io.base +
>> +		QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x1b);
> 
> Same here for 0x1b. I'm going to stop mentioning this, please audit the 
> driver
> for other instances of hardcoded values (like this and the one at the 
> end of
> this function) and break them out into meaningful #defines.
> 
Fixed in V2.

>> +
>> +	/* DP AUX CFG register programming */
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
>> +		pr_debug("%s: offset=0x%08x, value=0x%08x\n",
>> +			dp_phy_aux_config_type_to_string(i),
>> +			cfg[i].offset, cfg[i].lut[cfg[i].current_index]);
>> +		dp_write(catalog->io->phy_io.base + cfg[i].offset,
>> +			cfg[i].lut[cfg[i].current_index]);
>> +	}
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_AUX_INTERRUPT_MASK, 
>> 0x1F);
>> +}
>> +
>> +static void dp_catalog_aux_get_irq(struct dp_catalog_aux *aux, bool 
>> cmd_busy)
>> +{
>> +	u32 ack;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *ahb_base;
>> +
>> +	if (!aux) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(aux);
>> +	ahb_base = catalog->io->dp_ahb.base;
>> +
>> +	aux->isr = dp_read(ahb_base + DP_INTR_STATUS);
>> +	aux->isr &= ~DP_INTR_MASK1;
>> +	ack = aux->isr & DP_INTERRUPT_STATUS1;
>> +	ack <<= 1;
>> +	ack |= DP_INTR_MASK1;
>> +	dp_write(ahb_base + DP_INTR_STATUS, ack);
>> +}
>> +
>> +/* controller related catalog functions */
>> +static void dp_catalog_ctrl_update_transfer_unit(struct 
>> dp_catalog_ctrl *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_VALID_BOUNDARY, ctrl->valid_boundary);
>> +	dp_write(base + DP_TU, ctrl->dp_tu);
>> +	dp_write(base + DP_VALID_BOUNDARY_2, ctrl->valid_boundary2);
>> +}
>> +
>> +static void dp_catalog_ctrl_state_ctrl(struct dp_catalog_ctrl *ctrl, 
>> u32 state)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_STATE_CTRL, state);
>> +}
>> +
>> +static void dp_catalog_ctrl_config_ctrl(struct dp_catalog_ctrl *ctrl, 
>> u32 cfg)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *link_base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	link_base = catalog->io->dp_link.base;
>> +
>> +	pr_debug("DP_CONFIGURATION_CTRL=0x%x\n", cfg);
>> +
>> +	dp_write(link_base + DP_CONFIGURATION_CTRL, cfg);
>> +}
>> +
>> +static void dp_catalog_ctrl_lane_mapping(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_LOGICAL2PHYSICAL_LANE_MAPPING, 0xe4);
>> +}
>> +
>> +static void dp_catalog_ctrl_mainlink_ctrl(struct dp_catalog_ctrl 
>> *ctrl,
>> +						bool enable)
>> +{
>> +	u32 mainlink_ctrl;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
>> +		wmb(); /* make sure mainlink is turned off before reset */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000002);
>> +		wmb(); /* make sure mainlink entered reset */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000000);
>> +		wmb(); /* make sure mainlink reset done */
>> +		dp_write(base + DP_MAINLINK_CTRL, 0x02000001);
>> +		wmb(); /* make sure mainlink turned on */
> 
> Same comments here re: readl vs readl_relaxed + wmb
> 
> Please #define the bits you're setting.
> 

Fixed in V2.

> 
>> +	} else {
>> +		mainlink_ctrl = dp_read(base + DP_MAINLINK_CTRL);
>> +		mainlink_ctrl &= ~BIT(0);
>> +		dp_write(base + DP_MAINLINK_CTRL, mainlink_ctrl);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_config_misc(struct dp_catalog_ctrl *ctrl,
>> +					u32 cc, u32 tb)
>> +{
>> +	u32 misc_val;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	misc_val = dp_read(base + DP_MISC1_MISC0);
>> +	misc_val |= cc;
> 
> Should you mask this so it doesn't stomp areas it shouldn't?
> 
>> +	misc_val |= (tb << 5);
> 
> Parentheses are unnecessary
> 

Fixed in V2.


>> +	misc_val |= BIT(0); /* Configure clock to synchronous mode */
>> +
>> +	pr_debug("misc settings = 0x%x\n", misc_val);
>> +	dp_write(base + DP_MISC1_MISC0, misc_val);
>> +}
>> +
>> +static void dp_catalog_ctrl_config_msa(struct dp_catalog_ctrl *ctrl,
>> +					u32 rate, u32 stream_rate_khz,
>> +					bool fixed_nvid)
>> +{
>> +	u32 pixel_m, pixel_n;
>> +	u32 mvid, nvid;
>> +	u64 mvid_calc;
>> +	u32 const nvid_fixed = 0x8000;
> 
> You should pull this out into a #define in drm_dp_helper.h and use the 
> new
> define in the i915 driver (in a separate patch) as well as here.
> 
>> +	u32 const link_rate_hbr2 = 540000;
>> +	u32 const link_rate_hbr3 = 810000;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base_cc, *base_ctrl;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	if (fixed_nvid) {
>> +		pr_debug("use fixed NVID=0x%x\n", nvid_fixed);
>> +		nvid = nvid_fixed;
>> +
>> +		pr_debug("link rate=%dkbps, stream_rate_khz=%uKhz",
>> +			rate, stream_rate_khz);
>> +
>> +		/*
>> +		 * For intermediate results, use 64 bit arithmetic to avoid
>> +		 * loss of precision.
>> +		 */
>> +		mvid_calc = (u64) stream_rate_khz * nvid;
>> +		mvid_calc = div_u64(mvid_calc, rate);
>> +
>> +		/*
>> +		 * truncate back to 32 bits as this final divided value will
>> +		 * always be within the range of a 32 bit unsigned int.
>> +		 */
>> +		mvid = (u32) mvid_calc;
>> +	} else {
>> +		base_cc = catalog->io->dp_cc_io.base;
>> +
>> +		pixel_m = dp_read(base_cc + MMSS_DP_PIXEL_M);
>> +		pixel_n = dp_read(base_cc + MMSS_DP_PIXEL_N);
>> +		pr_debug("pixel_m=0x%x, pixel_n=0x%x\n", pixel_m, pixel_n);
>> +
>> +		mvid = (pixel_m & 0xFFFF) * 5;
>> +		nvid = (0xFFFF & (~pixel_n)) + (pixel_m & 0xFFFF);
>> +
>> +		pr_debug("rate = %d\n", rate);
>> +
>> +		if (link_rate_hbr2 == rate)
>> +			nvid *= 2;
>> +
>> +		if (link_rate_hbr3 == rate)
>> +			nvid *= 3;
> 
>                 switch (drm_dp_bw_code_to_link_rate(rate)) {
>                 case DP_LINK_BW_5_4:
>                         nvid *= 2;
>                         break;
>                 case DP_LINK_BW_8_1:
>                         nvid *= 3;
>                         break;
>                 default:
>                         break;
>                 }
> 
> And remove link_rate_hbr* above.
> 

Somehow missed this function. Will fix this function in V3.
> 
>> +	}
>> +
>> +	base_ctrl = catalog->io->dp_link.base;
>> +	pr_debug("mvid=0x%x, nvid=0x%x\n", mvid, nvid);
>> +	dp_write(base_ctrl + DP_SOFTWARE_MVID, mvid);
>> +	dp_write(base_ctrl + DP_SOFTWARE_NVID, nvid);
>> +}
>> +
>> +static void dp_catalog_ctrl_set_pattern(struct dp_catalog_ctrl *ctrl,
>> +					u32 pattern)
>> +{
>> +	int bit, cnt = 10;
>> +	u32 data;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	bit = 1;
>> +	bit <<= (pattern - 1);
> 
>         bit = BIT(pattern - 1);
> 
>> +	pr_debug("hw: bit=%d train=%d\n", bit, pattern);
>> +	dp_write(base + DP_STATE_CTRL, bit);
>> +
>> +	bit = 8;
>> +	bit <<= (pattern - 1);
> 
>         bit = BIT(pattern - 1) << 3;

Fixed in V2.

>> +
>> +	while (cnt--) {
>> +		data = dp_read(base + DP_MAINLINK_READY);
>> +		if (data & bit)
>> +			break;
> 
> Should there be a sleep in here? Also, consider using 
> readx_poll_timeout instead
> of rolling your own polling.
> 
Fixed in V2.

>> +	}
>> +
>> +	if (cnt == 0)
>> +		pr_err("set link_train=%d failed\n", pattern);
> 
> This function should return an int and report this failure instead of 
> ignoring
> it.
> 
Fixed in V2.

>> +}
>> +
>> +static void dp_catalog_ctrl_usb_reset(struct dp_catalog_ctrl *ctrl, 
>> bool flip)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->usb3_dp_com.base;
>> +
>> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x0a);
> 
> Again, all of these magic values need to be pulled out into #defines so 
> we know
> what the values mean.
> 
Fixed in V2.
>> +	dp_write(base + USB3_DP_COM_PHY_MODE_CTRL, 0x02);
>> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x01);
>> +	/* make sure usb3 com phy software reset is done */
>> +	wmb();
> 
> Same comments here wrt wmb()
> 
Fixed in V2.

>> +
>> +	if (!flip) /* CC1 */
>> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x02);
>> +	else /* CC2 */
>> +		dp_write(base + USB3_DP_COM_TYPEC_CTRL, 0x03);
> 
> 
>         u32 val;
>         ...
>         val = SOME_DEFINE_THAT_MAKES_SENSE;
>         if (flip)
>                 val |= ANOTHER_DEFINE_THAT_MEANS_FLIP;
> 
>         dp_io_write(USB3_DP_COM_TYPEC_CTRL, val);
> 
Forgot to fix the if/else case. Will fix it in V3.

>> +
>> +	dp_write(base + USB3_DP_COM_SWI_CTRL, 0x00);
>> +	dp_write(base + USB3_DP_COM_SW_RESET, 0x00);
>> +	/* make sure the software reset is done */
>> +	wmb();
>> +
>> +	dp_write(base + USB3_DP_COM_POWER_DOWN_CTRL, 0x01);
>> +	dp_write(base + USB3_DP_COM_RESET_OVRD_CTRL, 0x00);
>> +	/* make sure phy is brought out of reset */
>> +	wmb();
>> +
>> +}
>> +
>> +static void dp_catalog_panel_tpg_cfg(struct dp_catalog_panel *panel,
>> +	bool enable)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(panel);
>> +	base = catalog->io->dp_p0.base;
>> +
>> +	if (!enable) {
>> +		dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x0);
>> +		dp_write(base + MMSS_DP_BIST_ENABLE, 0x0);
>> +		dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x0);
>> +		wmb(); /* ensure Timing generator is turned off */
>> +		return;
>> +	}
> 
> There's really no reason to have both the enable + disable path in the 
> same
> function, they don't share any code (aside from writing a few different 
> values
> to the same registers). Could you please split this function into a
> timing_generator_disable and timing_generator_enable?
> 
Fixed in V2.

>> +
>> +	dp_write(base + MMSS_DP_INTF_CONFIG, 0x0);
>> +	dp_write(base + MMSS_DP_INTF_HSYNC_CTL, panel->hsync_ctl);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F0, panel->vsync_period *
>> +			panel->hsync_period);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F0, 
>> panel->v_sync_width *
>> +			panel->hsync_period);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PERIOD_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_VSYNC_PULSE_WIDTH_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_HCTL, panel->display_hctl);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_HCTL, 0);
>> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F0, 
>> panel->display_v_start);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F0, 
>> panel->display_v_end);
>> +	dp_write(base + MMSS_INTF_DISPLAY_V_START_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_DISPLAY_V_END_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F0, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F0, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_START_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_ACTIVE_V_END_F1, 0);
>> +	dp_write(base + MMSS_DP_INTF_POLARITY_CTL, 0);
>> +	wmb(); /* ensure TPG registers are programmed */
>> +
>> +	dp_write(base + MMSS_DP_TPG_MAIN_CONTROL, 0x100);
>> +	dp_write(base + MMSS_DP_TPG_VIDEO_CONFIG, 0x5);
>> +	wmb(); /* ensure TPG config is programmed */
>> +	dp_write(base + MMSS_DP_BIST_ENABLE, 0x1);
>> +	dp_write(base + MMSS_DP_TIMING_ENGINE_EN, 0x1);
>> +	wmb(); /* ensure Timing generator is turned on */
>> +	pr_debug("%s: enabled tpg\n", __func__);
>> +}
>> +
>> +static void dp_catalog_ctrl_reset(struct dp_catalog_ctrl *ctrl)
>> +{
>> +	u32 sw_reset;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	sw_reset = dp_read(base + DP_SW_RESET);
>> +
>> +	sw_reset |= BIT(0);
> 
> Should be a #define
> 
>> +	dp_write(base + DP_SW_RESET, sw_reset);
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> Same comment here regarding the 10us range
> 
Addressed both the above comments in V2.

>> +
>> +	sw_reset &= ~BIT(0);
>> +	dp_write(base + DP_SW_RESET, sw_reset);
>> +}
>> +
>> +static bool dp_catalog_ctrl_mainlink_ready(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	u32 data;
>> +	int cnt = 10;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	while (--cnt) {
>> +		/* DP_MAINLINK_READY */
>> +		data = dp_read(base + DP_MAINLINK_READY);
>> +		if (data & BIT(0))
>> +			return true;
>> +
>> +		usleep_range(1000, 1010); /* 1ms wait before next reg read */
> 
> Same comment here regarding using readx_poll_timeout wrapped in a 
> helper, also
> 10us comment.
> 
Fixed in V2.

>> +	}
>> +	pr_err("mainlink not ready\n");
>> +end:
>> +	return false;
>> +}
>> +
>> +static void dp_catalog_ctrl_enable_irq(struct dp_catalog_ctrl *ctrl,
>> +						bool enable)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	if (enable) {
>> +		dp_write(base + DP_INTR_STATUS, DP_INTR_MASK1);
>> +		dp_write(base + DP_INTR_STATUS2, DP_INTR_MASK2);
>> +	} else {
>> +		dp_write(base + DP_INTR_STATUS, 0x00);
>> +		dp_write(base + DP_INTR_STATUS2, 0x00);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_hpd_config(struct dp_catalog_ctrl *ctrl, 
>> bool en)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_aux.base;
>> +
>> +	if (en) {
>> +		u32 reftimer = dp_read(base + DP_DP_HPD_REFTIMER);
>> +
>> +		dp_write(base + DP_DP_HPD_INT_ACK, 0xF);
>> +		dp_write(base + DP_DP_HPD_INT_MASK, 0xF);
>> +
>> +		/* Enabling REFTIMER */
>> +		reftimer |= BIT(16);
> 
> You don't use this anywhere?

Removed in V2.
> 
>> +		dp_write(base + DP_DP_HPD_REFTIMER, 0xF);
>> +		/* Enable HPD */
>> +		dp_write(base + DP_DP_HPD_CTRL, 0x1);
>> +	} else {
>> +		/*Disable HPD */
> 
> Space after *
> 
Fixed in v2.
>> +		dp_write(base + DP_DP_HPD_CTRL, 0x0);
>> +	}
>> +}
>> +
>> +static void dp_catalog_ctrl_get_interrupt(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	u32 ack = 0;
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	ctrl->isr = dp_read(base + DP_INTR_STATUS2);
> 
> This value should just get returned instead of being stored.
> 
>> +	ctrl->isr &= ~DP_INTR_MASK2;
> 
> Unmasking the interrupts should not be returned from this function, it 
> should
> be part of the ack below.
> 
>> +	ack = ctrl->isr & DP_INTERRUPT_STATUS2;
> 
> And this does the above unmask already, so you can just turf it.
> 
>> +	ack <<= 1;
>> +	ack |= DP_INTR_MASK2;
> 
> Instead of rolling the ack code yourself, I'd prefer what you did with 
> _MASK,
> where you define DP_INTERRUPT_STATUS2_ACK above and just do a 
> bitwise-OR to add
> the acks here. Without the register map in front of me, it would take a 
> while
> to figure out what you're trying to accomplish.
> 
Didn't address your comments in get_interrupt function. Will fix this in 
V3.

>> +	dp_write(base + DP_INTR_STATUS2, ack);
>> +}
>> +
>> +static void dp_catalog_ctrl_phy_reset(struct dp_catalog_ctrl *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base = catalog->io->dp_ahb.base;
>> +
>> +	dp_write(base + DP_PHY_CTRL, 0x5); /* bit 0 & 2 */
> 
> The comment doesn't help here, please #define these bits
> 
>> +	usleep_range(1000, 1010); /* h/w recommended delay */
> 
> Same comment re: delay range
> 
Fixed in V2.

>> +	dp_write(base + DP_PHY_CTRL, 0x0);
>> +	wmb(); /* make sure PHY reset done */
> 
> Same comment re: wmb
> 
Fixed in V2.

>> +}
>> +
>> +static void dp_catalog_ctrl_phy_lane_cfg(struct dp_catalog_ctrl 
>> *ctrl,
>> +		bool flipped, u8 ln_cnt)
>> +{
>> +	u32 info = 0x0;
>> +	struct dp_catalog_private *catalog;
>> +	u8 orientation = BIT(!!flipped);
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	info |= (ln_cnt & 0x0F);
> 
> Remove the | and just make this an assignment (and you can remove the
> initialization to 0 above)
> 
Will remove the initialization to zero in V3. The other comments are 
addressed.

>> +	info |= ((orientation & 0x0F) << 4);
>> +	pr_debug("Shared Info = 0x%x\n", info);
>> +
>> +	dp_write(catalog->io->phy_io.base + DP_PHY_SPARE0, info);
>> +}
>> +
>> +static void dp_catalog_ctrl_update_vx_px(struct dp_catalog_ctrl 
>> *ctrl,
>> +		u8 v_level, u8 p_level)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base0, *base1;
>> +	u8 value0, value1;
> 
> Can we please pick better names for these?!
> 
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +	base0 = catalog->io->ln_tx0_io.base;
>> +	base1 = catalog->io->ln_tx1_io.base;
>> +
>> +	pr_debug("hw: v=%d p=%d\n", v_level, p_level);
>> +
>> +	value0 = vm_voltage_swing[v_level][p_level];
>> +	value1 = vm_pre_emphasis[v_level][p_level];
>> +
>> +	/* program default setting first */
> 
> Why do you need to do this?
> 
>> +	dp_write(base0 + TXn_TX_DRV_LVL, 0x2A);
>> +	dp_write(base1 + TXn_TX_DRV_LVL, 0x2A);
>> +	dp_write(base0 + TXn_TX_EMP_POST1_LVL, 0x20);
>> +	dp_write(base1 + TXn_TX_EMP_POST1_LVL, 0x20);
> 
> #define these magic values
> 
>> +
>> +	/* Enable MUX to use Cursor values from these registers */
>> +	value0 |= BIT(5);
>> +	value1 |= BIT(5);
> 
> #define these bits please
> 
>> +
>> +	/* Configure host and panel only if both values are allowed */
>> +	if (value0 != 0xFF && value1 != 0xFF) {
> 
> You can check this a lot earlier in the function.
> 
>> +		dp_write(base0 + TXn_TX_DRV_LVL, value0);
>> +		dp_write(base1 + TXn_TX_DRV_LVL, value0);
>> +		dp_write(base0 + TXn_TX_EMP_POST1_LVL, value1);
>> +		dp_write(base1 + TXn_TX_EMP_POST1_LVL, value1);
>> +
>> +		pr_debug("hw: vx_value=0x%x px_value=0x%x\n",
>> +			value0, value1);
>> +	} else {
>> +		pr_err("invalid vx (0x%x=0x%x), px (0x%x=0x%x\n",
>> +			v_level, value0, p_level, value1);
> 
> Seems like returning an error in this case would be useful
> 
>> +	}
>> +}

Will address comments in *update_vx_px() function in V3.

>> +
>> +static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl 
>> *ctrl,
>> +			u32 pattern)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 value = 0x0;
>> +	void __iomem *base = NULL;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_STATE_CTRL, 0x0);
> 
> Do you really need to do this?
> 
Yes, to make sure no other pattern is set/enabled in hardware before any 
new pattern is configured.

>> +
>> +	switch (pattern) {
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +		dp_write(base + DP_STATE_CTRL, 0x1);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +		value &= ~(1 << 16);
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		value |= 0xFC;
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
>> +		dp_write(base + DP_STATE_CTRL, 0x10);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +		dp_write(base + DP_STATE_CTRL, 0x20);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +		dp_write(base + DP_STATE_CTRL, 0x40);
>> +		/* 00111110000011111000001111100000 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG0, 0x3E0F83E0);
>> +		/* 00001111100000111110000011111000 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG1, 0x0F83E0F8);
>> +		/* 1111100000111110 */
>> +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG2, 0x0000F83E);
>> +		break;
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		value = BIT(16);
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		value |= 0xFC;
>> +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
>> +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
>> +		dp_write(base + DP_STATE_CTRL, 0x10);
> 
> This code is the exact same as the case for
> DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT, aside from BIT(16) vs
> ~BIT(16). Can you please combine these cases
> and share code?

Will fix this in V3.

> 
>> +		break;
>> +	default:
>> +		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
>> +		return;
>> +	}
> 
> All of the DP_STATE_CTRL values should be #defined, and you can move 
> the write
> down here instead of duplicating it everywhere (with
> DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN writing a 0).
> 
All the DP_STATE_CTRL values are defines in V2.

I am not clear on moving the write operations after the switch cases. 
Can you please provide
some more details?

>> +
>> +	/* Make sure the test pattern is programmed in the hardware */
>> +	wmb();
>> +}
>> +
>> +static u32 dp_catalog_ctrl_read_phy_pattern(struct dp_catalog_ctrl 
>> *ctrl)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base = NULL;
>> +
>> +	if (!ctrl) {
>> +		pr_err("invalid input\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_catalog_get_priv(ctrl);
>> +
>> +	base = catalog->io->dp_link.base;
>> +
>> +	return dp_read(base + DP_MAINLINK_READY);
>> +}
>> +
>> +/* panel related catalog functions */
>> +static int dp_catalog_panel_timing_cfg(struct dp_catalog_panel 
>> *panel)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	dp_catalog_get_priv(panel);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	dp_write(base + DP_TOTAL_HOR_VER, panel->total);
>> +	dp_write(base + DP_START_HOR_VER_FROM_SYNC, panel->sync_start);
>> +	dp_write(base + DP_HSYNC_VSYNC_WIDTH_POLARITY, 
>> panel->width_blanking);
>> +	dp_write(base + DP_ACTIVE_HOR_VER, panel->dp_active);
>> +end:
> 
> useless label, but it'll probably go away when you strip out all of the
> unnecessary NULL checks from the driver.
> 
Fixed in V2.

>> +	return 0;
>> +}
>> +
>> +static void dp_catalog_audio_init(struct dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	static u32 sdp_map[][DP_AUDIO_SDP_HEADER_MAX] = {
>> +		{
>> +			MMSS_DP_AUDIO_STREAM_0,
>> +			MMSS_DP_AUDIO_STREAM_1,
>> +			MMSS_DP_AUDIO_STREAM_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_TIMESTAMP_0,
>> +			MMSS_DP_AUDIO_TIMESTAMP_1,
>> +			MMSS_DP_AUDIO_TIMESTAMP_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_INFOFRAME_0,
>> +			MMSS_DP_AUDIO_INFOFRAME_1,
>> +			MMSS_DP_AUDIO_INFOFRAME_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_0,
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
>> +			MMSS_DP_AUDIO_COPYMANAGEMENT_1,
>> +		},
>> +		{
>> +			MMSS_DP_AUDIO_ISRC_0,
>> +			MMSS_DP_AUDIO_ISRC_1,
>> +			MMSS_DP_AUDIO_ISRC_1,
>> +		},
>> +	};
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	catalog->audio_map = sdp_map;
> 
> Hmm, this is a bit spooky, we're storing a (non-const) pointer to a 
> static
> stack variable. Fortunately this looks like it'll be easy to fix since 
> this
> data is only accessed in this file. So move the map into a static const 
> global
> and reference it directly when needed (and drop audio_map).
> 
All the Audio related configs/APIs are removed in this patch. Will be 
adding these changes in
a separate patch.

>> +}
>> +
>> +static void dp_catalog_audio_config_sdp(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 sdp_cfg = 0;
>> +	u32 sdp_cfg2 = 0;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +	base = catalog->io->dp_link.base;
>> +
>> +	sdp_cfg = dp_read(base + MMSS_DP_SDP_CFG);
>> +
>> +	/* AUDIO_TIMESTAMP_SDP_EN */
>> +	sdp_cfg |= BIT(1);
>> +	/* AUDIO_STREAM_SDP_EN */
>> +	sdp_cfg |= BIT(2);
>> +	/* AUDIO_COPY_MANAGEMENT_SDP_EN */
>> +	sdp_cfg |= BIT(5);
>> +	/* AUDIO_ISRC_SDP_EN  */
>> +	sdp_cfg |= BIT(6);
>> +	/* AUDIO_INFOFRAME_SDP_EN  */
>> +	sdp_cfg |= BIT(20);
> 
> #define the values and combine the assignment
> 
>> +
>> +	pr_debug("sdp_cfg = 0x%x\n", sdp_cfg);
>> +	dp_write(base + MMSS_DP_SDP_CFG, sdp_cfg);
>> +
>> +	sdp_cfg2 = dp_read(base + MMSS_DP_SDP_CFG2);
>> +	/* IFRM_REGSRC -> Do not use reg values */
>> +	sdp_cfg2 &= ~BIT(0);
>> +	/* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
>> +	sdp_cfg2 &= ~BIT(1);
> 
> The reset value of this register is 0x4, so how can the bits in 
> position 0/1
> get flipped? We shouldn't need this code, afaict.
> 
> If we do, the same comments regarding #define and combination as above.
> 
All the audio functions are removed in V2.
>> +
>> +	pr_debug("sdp_cfg2 = 0x%x\n", sdp_cfg2);
>> +	dp_write(base + MMSS_DP_SDP_CFG2, sdp_cfg2);
>> +}
>> +
>> +static void dp_catalog_audio_get_header(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	void __iomem *base;
>> +	enum dp_catalog_audio_sdp_type sdp;
>> +	enum dp_catalog_audio_header_type header;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base    = catalog->io->dp_link.base;
>> +	sdp_map = catalog->audio_map;
>> +	sdp     = audio->sdp_type;
>> +	header  = audio->sdp_header;
>> +
>> +	audio->data = dp_read(base + sdp_map[sdp][header]);
>> +}
> 
> This function is unused, please remove.
> 
Removed in V2.
>> +
>> +static void dp_catalog_audio_set_header(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	u32 (*sdp_map)[DP_AUDIO_SDP_HEADER_MAX];
>> +	void __iomem *base;
>> +	enum dp_catalog_audio_sdp_type sdp;
>> +	enum dp_catalog_audio_header_type header;
>> +	u32 data;
>> +
>> +	if (!audio)
>> +		return;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base    = catalog->io->dp_link.base;
>> +	sdp_map = catalog->audio_map;
>> +	sdp     = audio->sdp_type;
>> +	header  = audio->sdp_header;
>> +	data    = audio->data;
>> +
>> +	dp_write(base + sdp_map[sdp][header], data);
>> +}
> 
> This function is unused, please remove.
> 
All the audio functions are removed in V2.

>> +
>> +static void dp_catalog_audio_config_acr(struct dp_catalog_audio 
>> *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 acr_ctrl, select;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	select = audio->data;
>> +	base   = catalog->io->dp_link.base;
>> +
>> +	acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
>> +
>> +	pr_debug("select = 0x%x, acr_ctrl = 0x%x\n", select, acr_ctrl);
>> +
>> +	dp_write(base + MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
>> +}
> 
> This function is unused, please remove.
> 
All the audio functions are removed in V2.

>> +
>> +static void dp_catalog_audio_safe_to_exit_level(struct 
>> dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	u32 mainlink_levels, safe_to_exit_level;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base   = catalog->io->dp_link.base;
>> +	safe_to_exit_level = audio->data;
>> +
>> +	mainlink_levels = dp_read(base + DP_MAINLINK_LEVELS);
>> +	mainlink_levels &= 0xFE0;
>> +	mainlink_levels |= safe_to_exit_level;
>> +
>> +	pr_debug("mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
>> +			mainlink_levels, safe_to_exit_level);
>> +
>> +	dp_write(base + DP_MAINLINK_LEVELS, mainlink_levels);
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +static void dp_catalog_audio_enable(struct dp_catalog_audio *audio)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +	void __iomem *base;
>> +	bool enable;
>> +	u32 audio_ctrl;
>> +
>> +	dp_catalog_get_priv(audio);
>> +
>> +	base   = catalog->io->dp_link.base;
>> +	enable = !!audio->data;
>> +
>> +	audio_ctrl = dp_read(base + MMSS_DP_AUDIO_CFG);
>> +
>> +	if (enable)
>> +		audio_ctrl |= BIT(0);
>> +	else
>> +		audio_ctrl &= ~BIT(0);
>> +
>> +	pr_debug("dp_audio_cfg = 0x%x\n", audio_ctrl);
>> +	dp_write(base + MMSS_DP_AUDIO_CFG, audio_ctrl);
>> +
>> +	/* make sure audio engine is disabled */
>> +	wmb();
>> +}
> 
> This function is unused, please remove.
> 
>> +
>> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io 
>> *io)
>> +{
>> +	int rc = 0;
>> +	struct dp_catalog *dp_catalog;
>> +	struct dp_catalog_private *catalog;
>> +	struct dp_catalog_aux aux = {
>> +		.read_data     = dp_catalog_aux_read_data,
>> +		.write_data    = dp_catalog_aux_write_data,
>> +		.write_trans   = dp_catalog_aux_write_trans,
>> +		.clear_trans   = dp_catalog_aux_clear_trans,
>> +		.reset         = dp_catalog_aux_reset,
>> +		.update_aux_cfg = dp_catalog_aux_update_cfg,
>> +		.enable        = dp_catalog_aux_enable,
>> +		.setup         = dp_catalog_aux_setup,
>> +		.get_irq       = dp_catalog_aux_get_irq,
> 
> Out of these, it seems like write_trans, clear_trans, update_aux_cfg, 
> setup and
> get_irq are all unused. Please remove them.
> 
> Please also check the other functions to ensure they're used.
> 
Fixed in V2.

>> +	};
>> +	struct dp_catalog_ctrl ctrl = {
>> +		.state_ctrl     = dp_catalog_ctrl_state_ctrl,
>> +		.config_ctrl    = dp_catalog_ctrl_config_ctrl,
>> +		.lane_mapping   = dp_catalog_ctrl_lane_mapping,
>> +		.mainlink_ctrl  = dp_catalog_ctrl_mainlink_ctrl,
>> +		.config_misc    = dp_catalog_ctrl_config_misc,
>> +		.config_msa     = dp_catalog_ctrl_config_msa,
>> +		.set_pattern    = dp_catalog_ctrl_set_pattern,
>> +		.reset          = dp_catalog_ctrl_reset,
>> +		.usb_reset      = dp_catalog_ctrl_usb_reset,
>> +		.mainlink_ready = dp_catalog_ctrl_mainlink_ready,
>> +		.enable_irq     = dp_catalog_ctrl_enable_irq,
>> +		.hpd_config     = dp_catalog_ctrl_hpd_config,
>> +		.phy_reset      = dp_catalog_ctrl_phy_reset,
>> +		.phy_lane_cfg   = dp_catalog_ctrl_phy_lane_cfg,
>> +		.update_vx_px   = dp_catalog_ctrl_update_vx_px,
>> +		.get_interrupt  = dp_catalog_ctrl_get_interrupt,
>> +		.update_transfer_unit = dp_catalog_ctrl_update_transfer_unit,
>> +		.send_phy_pattern    = dp_catalog_ctrl_send_phy_pattern,
>> +		.read_phy_pattern = dp_catalog_ctrl_read_phy_pattern,
> 
> So, what's the benefit of adding the catalog abstractions? Do you ever 
> have
> multiple/alternate implementations of a catalog? It doesn't seem like 
> it. You
> should just remove all of the catalog overhead and call the functions 
> directly.
> 
Fixed in V2.

>> +	};
>> +	struct dp_catalog_audio audio = {
>> +		.init       = dp_catalog_audio_init,
>> +		.config_acr = dp_catalog_audio_config_acr,
>> +		.enable     = dp_catalog_audio_enable,
>> +		.config_sdp = dp_catalog_audio_config_sdp,
>> +		.set_header = dp_catalog_audio_set_header,
>> +		.get_header = dp_catalog_audio_get_header,
>> +		.safe_to_exit_level = dp_catalog_audio_safe_to_exit_level,
>> +	};
>> +	struct dp_catalog_panel panel = {
>> +		.timing_cfg = dp_catalog_panel_timing_cfg,
>> +		.tpg_config = dp_catalog_panel_tpg_cfg,
>> +	};
>> +
>> +	if (!io) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	catalog  = devm_kzalloc(dev, sizeof(*catalog), GFP_KERNEL);
>> +	if (!catalog) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	catalog->dev = dev;
>> +	catalog->io = io;
>> +
>> +	dp_catalog = &catalog->dp_catalog;
>> +
>> +	dp_catalog->aux   = aux;
>> +	dp_catalog->ctrl  = ctrl;
>> +	dp_catalog->audio = audio;
>> +	dp_catalog->panel = panel;
>> +
>> +	return dp_catalog;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_catalog_put(struct dp_catalog *dp_catalog)
>> +{
>> +	struct dp_catalog_private *catalog;
>> +
>> +	if (!dp_catalog)
>> +		return;
>> +
>> +	catalog = container_of(dp_catalog, struct dp_catalog_private,
>> +				dp_catalog);
>> +
>> +	devm_kfree(catalog->dev, catalog);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h 
>> b/drivers/gpu/drm/msm/dp/dp_catalog.h
>> new file mode 100644
>> index 0000000..58951df
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
>> @@ -0,0 +1,144 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_CATALOG_H_
>> +#define _DP_CATALOG_H_
>> +
>> +#include "dp_parser.h"
>> +
>> +/* interrupts */
>> +#define DP_INTR_HPD		BIT(0)
>> +#define DP_INTR_AUX_I2C_DONE	BIT(3)
>> +#define DP_INTR_WRONG_ADDR	BIT(6)
>> +#define DP_INTR_TIMEOUT		BIT(9)
>> +#define DP_INTR_NACK_DEFER	BIT(12)
>> +#define DP_INTR_WRONG_DATA_CNT	BIT(15)
>> +#define DP_INTR_I2C_NACK	BIT(18)
>> +#define DP_INTR_I2C_DEFER	BIT(21)
>> +#define DP_INTR_PLL_UNLOCKED	BIT(24)
>> +#define DP_INTR_AUX_ERROR	BIT(27)
>> +
>> +#define DP_INTR_READY_FOR_VIDEO		BIT(0)
>> +#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
>> +#define DP_INTR_FRAME_END		BIT(6)
>> +#define DP_INTR_CRC_UPDATED		BIT(9)
>> +
>> +struct dp_catalog_aux {
>> +	u32 data;
>> +	u32 isr;
>> +
>> +	u32 (*read_data)(struct dp_catalog_aux *aux);
>> +	int (*write_data)(struct dp_catalog_aux *aux);
>> +	int (*write_trans)(struct dp_catalog_aux *aux);
>> +	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
>> +	void (*reset)(struct dp_catalog_aux *aux);
>> +	void (*enable)(struct dp_catalog_aux *aux, bool enable);
>> +	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
>> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
>> +	void (*setup)(struct dp_catalog_aux *aux,
>> +			struct dp_aux_cfg *aux_cfg);
>> +	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
>> +};
>> +
>> +struct dp_catalog_ctrl {
>> +	u32 dp_tu;
>> +	u32 valid_boundary;
>> +	u32 valid_boundary2;
>> +	u32 isr;
>> +
>> +	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
>> +	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
>> +	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
>> +	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
>> +	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
>> +				u32 stream_rate_khz, bool fixed_nvid);
>> +	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
>> +	void (*reset)(struct dp_catalog_ctrl *ctrl);
>> +	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
>> +	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
>> +	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
>> +	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
>> +	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
>> +				u8 lane_cnt);
>> +	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
>> +				u8 p_level);
>> +	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
>> +	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
>> +	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
>> +			u32 pattern);
>> +	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
>> +};
>> +
>> +enum dp_catalog_audio_sdp_type {
>> +	DP_AUDIO_SDP_STREAM,
>> +	DP_AUDIO_SDP_TIMESTAMP,
>> +	DP_AUDIO_SDP_INFOFRAME,
>> +	DP_AUDIO_SDP_COPYMANAGEMENT,
>> +	DP_AUDIO_SDP_ISRC,
>> +	DP_AUDIO_SDP_MAX,
>> +};
>> +
>> +enum dp_catalog_audio_header_type {
>> +	DP_AUDIO_SDP_HEADER_1,
>> +	DP_AUDIO_SDP_HEADER_2,
>> +	DP_AUDIO_SDP_HEADER_3,
>> +	DP_AUDIO_SDP_HEADER_MAX,
>> +};
>> +
>> +struct dp_catalog_audio {
>> +	enum dp_catalog_audio_sdp_type sdp_type;
>> +	enum dp_catalog_audio_header_type sdp_header;
>> +	u32 data;
>> +
>> +	void (*init)(struct dp_catalog_audio *audio);
>> +	void (*enable)(struct dp_catalog_audio *audio);
>> +	void (*config_acr)(struct dp_catalog_audio *audio);
>> +	void (*config_sdp)(struct dp_catalog_audio *audio);
>> +	void (*set_header)(struct dp_catalog_audio *audio);
>> +	void (*get_header)(struct dp_catalog_audio *audio);
>> +	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);
> 
> None of these are called? So get rid of this entire structure, the 
> functions
> that aren't called, and the audio enums above.
> 
Removed all the Audio related APIs in V2.

>> +};
>> +
>> +struct dp_catalog_panel {
>> +	u32 total;
>> +	u32 sync_start;
>> +	u32 width_blanking;
>> +	u32 dp_active;
>> +
>> +	/* TPG */
>> +	u32 hsync_period;
>> +	u32 vsync_period;
>> +	u32 display_v_start;
>> +	u32 display_v_end;
>> +	u32 v_sync_width;
>> +	u32 hsync_ctl;
>> +	u32 display_hctl;
> 
> All of this information is already available from drm core, so it can 
> go.

Will address this in V3.

> 
>> +
>> +	int (*timing_cfg)(struct dp_catalog_panel *panel);
>> +	void (*tpg_config)(struct dp_catalog_panel *panel, bool enable);
> 
> As suggested elsewhere, these functions should just be called directly 
> wherever
> applicable. So we can get rid of this struct.
> 
>> +};
>> +
>> +struct dp_catalog {
>> +	struct dp_catalog_aux aux;
>> +	struct dp_catalog_ctrl ctrl;
>> +	struct dp_catalog_audio audio;
>> +	struct dp_catalog_panel panel;
>> +};
>> +
>> +struct dp_catalog *dp_catalog_get(struct device *dev, struct dp_io 
>> *io);
>> +void dp_catalog_put(struct dp_catalog *catalog);
> 
> As mentioned above, all of this should be removed. We can just call the
> functions directly.
> 
Removed the func ptrs in V2.

>> +
>> +#endif /* _DP_CATALOG_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c 
>> b/drivers/gpu/drm/msm/dp/dp_ctrl.c
>> new file mode 100644
>> index 0000000..08a52f5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
>> @@ -0,0 +1,1475 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/types.h>
>> +#include <linux/completion.h>
>> +#include <linux/delay.h>
>> +
>> +#include "dp_ctrl.h"
>> +
>> +#define DP_KHZ_TO_HZ 1000
>> +
>> +#define DP_CTRL_INTR_READY_FOR_VIDEO     BIT(0)
>> +#define DP_CTRL_INTR_IDLE_PATTERN_SENT  BIT(3)
>> +
>> +/* dp state ctrl */
>> +#define ST_TRAIN_PATTERN_1		BIT(0)
>> +#define ST_TRAIN_PATTERN_2		BIT(1)
>> +#define ST_TRAIN_PATTERN_3		BIT(2)
>> +#define ST_TRAIN_PATTERN_4		BIT(3)
>> +#define ST_SYMBOL_ERR_RATE_MEASUREMENT	BIT(4)
>> +#define ST_PRBS7			BIT(5)
>> +#define ST_CUSTOM_80_BIT_PATTERN	BIT(6)
>> +#define ST_SEND_VIDEO			BIT(7)
>> +#define ST_PUSH_IDLE			BIT(8)
> 
> I'd like to see these defined with DP_STATE_CTRL (and 
> s/ST/DP_STATE_CTRL/).
> 
Fixed in V2.

>> +
>> +#define MR_LINK_TRAINING1  0x8
>> +#define MR_LINK_SYMBOL_ERM 0x80
>> +#define MR_LINK_PRBS7 0x100
>> +#define MR_LINK_CUSTOM80 0x200
>> +
>> +struct dp_vc_tu_mapping_table {
>> +	u32 vic;
>> +	u8 lanes;
>> +	u8 lrate; /* DP_LINK_RATE -> 162(6), 270(10), 540(20), 810 (30) */
>> +	u8 bpp;
>> +	u8 valid_boundary_link;
>> +	u16 delay_start_link;
>> +	bool boundary_moderation_en;
>> +	u8 valid_lower_boundary_link;
>> +	u8 upper_boundary_count;
>> +	u8 lower_boundary_count;
>> +	u8 tu_size_minus1;
> 
> Please check this struct for unused members, there are at least a 
> couple.

Updated the TU calculator in V2.
> 
>> +};
>> +
>> +struct dp_ctrl_private {
>> +	struct dp_ctrl dp_ctrl;
>> +
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_panel *panel;
>> +	struct dp_link *link;
>> +	struct dp_power *power;
>> +	struct dp_parser *parser;
>> +	struct dp_catalog_ctrl *catalog;
> 
> Once you remove struct dp_ctrl and call the functions directly, I 
> suspect you
> can get rid of all of these.
> 
Even though we call the functions directly, we still need variables 
present in each module.
For example, we need to access link parameters, panel parameters etc

Unnecessary stuff is removed but we still need other variables in the 
structure. All have been
updated in V2.
>> +
>> +	struct completion idle_comp;
>> +	struct completion video_comp;
>> +
>> +	bool orientation;
>> +	atomic_t aborted;
>> +
>> +	u32 pixel_rate;
>> +	u32 vic;
> 
> 'u32 vic' shows up in 3 places in this driver, but there is not one use 
> of any
> vic :) Please remove from here and elsewhere.
Fixed in V2.

> 
>> +};
>> +
>> +enum notification_status {
>> +	NOTIFY_UNKNOWN,
>> +	NOTIFY_CONNECT,
>> +	NOTIFY_DISCONNECT,
>> +	NOTIFY_CONNECT_IRQ_HPD,
>> +	NOTIFY_DISCONNECT_IRQ_HPD,
>> +};
> 
> Unused, please remove.
> 
Fixed in V2.

>> +
>> +static void dp_ctrl_idle_patterns_sent(struct dp_ctrl_private *ctrl)
>> +{
>> +	pr_debug("idle_patterns_sent\n");
>> +	complete(&ctrl->idle_comp);
>> +}
>> +
>> +static void dp_ctrl_video_ready(struct dp_ctrl_private *ctrl)
>> +{
>> +	pr_debug("dp_video_ready\n");
>> +	complete(&ctrl->video_comp);
>> +}
> 
> These functions don't provide value, please remove and just call 
> complete()
> directly.
> 
Fixed in V2.

>> +
>> +static void dp_ctrl_abort(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> 
> JFYI, this is sprinkled everywhere, would be a good candidate for an 
> inline
> function. Since dp_ctrl can be removed, it's kind of a moot point now.
> 
I didn't see any major advantage with moving to inline. So, kept it as 
is.
We still want to have private and public (dp_ctrl_private and dp_ctrl) 
structures
for each module (Ctrl, link, etc) so that we don't expose unnecessary 
info to other modules.

>> +
>> +	atomic_set(&ctrl->aborted, 1);
>> +}
>> +
>> +static void dp_ctrl_state_ctrl(struct dp_ctrl_private *ctrl, u32 
>> state)
>> +{
>> +	ctrl->catalog->state_ctrl(ctrl->catalog, state);
> 
> No need to wrap this in a function

Fixed in V2.

> 
>> +}
>> +
>> +static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
>> +{
>> +	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;
> 
> This should be #define'd outside of the functioninstead. Also, why the 
> '_ms_'
> suffix? The units are in jiffies.
> 
> I think something like
> 
> #define IDLE_PATTERN_COMPLETION_TIMEOUT_JIFFIES (30 * HZ / 1000) /* 30 
> ms */
> 
> would be clearer.
> 
Fixed in V2.

>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	reinit_completion(&ctrl->idle_comp);
> 
> This function is called from a bunch of places, and idle_comp is also 
> used in a
> bunch of places. Are you certain this is thread-safe if you have 
> concurrent
> callers or users of idle_comp?
> 
I don't think we need any synchronization logic for idle_comp since it 
is reinitialized only
when the complete core is reset. Only place where it is needed is in 
push_idle which already has
a mutex.

>> +	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
>> +
>> +	if (!wait_for_completion_timeout(&ctrl->idle_comp,
>> +			idle_pattern_completion_timeout_ms))
>> +		pr_warn("PUSH_IDLE pattern timedout\n");
> 
> Return an error?
> 
Its not fatal error since we are going to reset the controller and we 
are going to recover from
this timeout.

>> +
>> +	pr_debug("mainlink off done\n");
>> +}
>> +
>> +static void dp_ctrl_config_ctrl(struct dp_ctrl_private *ctrl)
>> +{
>> +	u32 config = 0, tbd;
>> +	u8 *dpcd = ctrl->panel->dpcd;
>> +
>> +	config |= (2 << 13); /* Default-> LSCLK DIV: 1/4 LCLK  */
> 
> #define value
> 
Fixed in V2.

>> +	config |= (0 << 11); /* RGB */
> 
> This is a no-op, can be removed
> 
Fixed in V2.

>> +
>> +	/* Scrambler reset enable */
>> +	if (dpcd[DP_EDP_CONFIGURATION_CAP] & 
>> DP_ALTERNATE_SCRAMBLER_RESET_CAP)
>> +		config |= (1 << 10);
>> +
>> +	tbd = ctrl->link->get_test_bits_depth(ctrl->link,
>> +			ctrl->panel->pinfo.bpp);
>> +
>> +	if (tbd == DP_TEST_BIT_DEPTH_UNKNOWN)
> 
> Should we print a debug message here?
> 
Fixed in V2.

>> +		tbd = DP_TEST_BIT_DEPTH_8;
>> +
>> +	config |= tbd << 8;
>> +
>> +	/* Num of Lanes */
>> +	config |= ((ctrl->link->link_params.lane_count - 1) << 4);
> 
> These shift values should be #defined
> 
Fixed in V2.

>> +
>> +	if (drm_dp_enhanced_frame_cap(dpcd))
>> +		config |= 0x40;
> 
> #define 0x40
> 
Fixed in V2.
>> +
>> +	config |= 0x04; /* progressive video */
>> +
>> +	config |= 0x03;	/* sycn clock & static Mvid */
> 
> And these, plus s/sycn/sync/
> 
Fixed in V2.

>> +
>> +	ctrl->catalog->config_ctrl(ctrl->catalog, config);
>> +}
>> +
>> +/**
>> + * dp_ctrl_configure_source_params() - configures DP transmitter 
>> source params
>> + * @ctrl: Display Port Driver data
>> + *
>> + * Configures the DP transmitter source params including details such 
>> as lane
>> + * configuration, output format and sink/panel timing information.
>> + */
>> +static void dp_ctrl_configure_source_params(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	u32 cc, tb;
>> +
>> +	ctrl->catalog->lane_mapping(ctrl->catalog);
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
> 
> We go through ctrl->catalog->callback_hook to call a function that is 
> specific
> to ctrl and only called in this file. It could easily just be a static 
> function
> without having to go through 2 structs and a callback hook.
> 
Removed the function ptr. We are calling the catalog APIs directly in 
V2.

>> +
>> +	dp_ctrl_config_ctrl(ctrl);
>> +
>> +	tb = ctrl->link->get_test_bits_depth(ctrl->link,
>> +		ctrl->panel->pinfo.bpp);
>> +	cc = ctrl->link->get_colorimetry_config(ctrl->link);
>> +	ctrl->catalog->config_misc(ctrl->catalog, cc, tb);
> 
> Same comments with these hooks, they're only called from this file. 
> I'll stop
> harping on this, but could we please remove the layers of indirection 
> and just
> embed and call functions as appropriate?
> 
Fixed in V2.

>> +	ctrl->panel->timing_cfg(ctrl->panel);
>> +}
>> +
>> +static void dp_ctrl_get_extra_req_bytes(u64 result_valid,
>> +					int valid_bdary_link,
>> +					u64 value1, u64 value2,
>> +					bool *negative, u64 *result,
>> +					u64 compare)
>> +{
>> +	*negative = false;
>> +	if (result_valid >= compare) {
>> +		if (valid_bdary_link
>> +				>= compare)
>> +			*result = value1 + value2;
>> +		else {
>> +			if (value1 < value2)
>> +				*negative = true;
>> +			*result = (value1 >= value2) ?
>> +				(value1 - value2) : (value2 - value1);
>> +		}
>> +	} else {
>> +		if (valid_bdary_link
>> +				>= compare) {
>> +			if (value1 >= value2)
>> +				*negative = true;
>> +			*result = (value1 >= value2) ?
>> +				(value1 - value2) : (value2 - value1);
>> +		} else {
>> +			*result = value1 + value2;
>> +			*negative = true;
>> +		}
>> +	}
> 
> I think this can be simplified to the following, it's still super hard 
> to
> follow, but I'm not sure if that can be helped.
> 
>         bool result_bigger = result_valid >= compare;
>         bool valid_bdary_bigger = valid_bdary_link >= compare;
> 
> 	if (result_bigger && valid_bdary_bigger ||
>             !result_bigger && !valid_bdary_bigger) {
>                 *negative = !valid_bdary_bigger;
>                 return value1 + value2;
>         }
> 
>         *negative = (result_bigger && !valid_bdary_bigger && value1 < 
> value2) ||
>                     (!result_bigger && valid_bdary_bigger && value1 >= 
> value2);
>         return max(value1, value2) - min(value1, value2);
> 
> I don't know. The more I stare at this the less convinced I become that 
> it's
> better. So take it or leave it. At the very least you can collapse the
> 
> if (cond)
>         *negative = true;
> 
> to
> 
> *negative = cond;
> 
> and do the max(v,v) - min(v,v) trick to shave off some of the 
> conditionals in
> the original.
> 
> 

Most of the code related to tu_calculator has been updated in V2.

>> +}
>> +
>> +static u64 roundup_u64(u64 x, u64 y)
>> +{
>> +	x += (y - 1);
>> +	return (div64_ul(x, y) * y);
>> +}
> 
> Please replace all usage with DIV_ROUND_UP_ULL
> 
>> +
>> +static u64 rounddown_u64(u64 x, u64 y)
>> +{
>> +	u64 rem;
>> +
>> +	div64_u64_rem(x, y, &rem);
>> +	return (x - rem);
>> +}
> 
> Please replace all usage with DIV_ROUND_DOWN_ULL
> 
>> +
>> +static void dp_ctrl_calc_tu_parameters(struct dp_ctrl_private *ctrl,
>> +				       struct dp_vc_tu_mapping_table *tu_table)
>> +{
>> +	u32 multiplier = 1000000;
>> +	u64 pclk, lclk;
>> +	u8 bpp, ln_cnt;
>> +	int run_idx = 0;
>> +	u32 lwidth, h_blank;
>> +	u32 fifo_empty = 0;
>> +	u32 ratio_scale = 1001;
>> +	u64 temp, ratio, original_ratio;
>> +	u64 temp2, reminder;
>> +	u64 temp3, temp4, result = 0;
>> +
>> +	u64 err = multiplier;
>> +	u64 n_err = 0, n_n_err = 0;
>> +	bool n_err_neg, nn_err_neg;
>> +	u8 hblank_margin = 16;
>> +
>> +	u8 tu_size, tu_size_desired = 0, tu_size_minus1;
>> +	int valid_boundary_link;
>> +	u64 resulting_valid;
>> +	u64 total_valid;
>> +	u64 effective_valid;
>> +	u64 effective_valid_recorded;
>> +	int n_tus;
>> +	int n_tus_per_lane;
>> +	int paired_tus;
>> +	int remainder_tus;
>> +	int remainder_tus_upper, remainder_tus_lower;
>> +	int extra_bytes;
>> +	int filler_size;
>> +	int delay_start_link;
>> +	int boundary_moderation_en = 0;
>> +	int upper_bdry_cnt = 0;
>> +	int lower_bdry_cnt = 0;
>> +	int i_upper_bdry_cnt = 0;
>> +	int i_lower_bdry_cnt = 0;
>> +	int valid_lower_boundary_link = 0;
>> +	int even_distribution_bf = 0;
>> +	int even_distribution_legacy = 0;
>> +	int even_distribution = 0;
>> +	int min_hblank = 0;
>> +	int extra_pclk_cycles;
>> +	u8 extra_pclk_cycle_delay = 4;
>> +	int extra_pclk_cycles_in_link_clk;
>> +	u64 ratio_by_tu;
>> +	u64 average_valid2;
>> +	u64 extra_buffer_margin;
>> +	int new_valid_boundary_link;
>> +
>> +	u64 resulting_valid_tmp;
>> +	u64 ratio_by_tu_tmp;
>> +	int n_tus_tmp;
>> +	int extra_pclk_cycles_tmp;
>> +	int extra_pclk_cycles_in_lclk_tmp;
>> +	int extra_req_bytes_new_tmp;
>> +	int filler_size_tmp;
>> +	int lower_filler_size_tmp;
>> +	int delay_start_link_tmp;
>> +	int min_hblank_tmp = 0;
>> +	bool extra_req_bytes_is_neg = false;
>> +	struct dp_panel_info *pinfo = &ctrl->panel->pinfo;
>> +
>> +	u8 dp_brute_force = 1;
>> +	u64 brute_force_threshold = 10;
>> +	u64 diff_abs;
> 
> 
> 76 stack vars and ~450 lines must be a new record somewhere :)
> 
> I'm going to skip reviewing this function and let you 
> split/simplify/reduce it.
> Please just make it more readable (comments, docs, helper functions, 
> etc).
> 
Most of the code related to tu_calculator has been updated in V2. As per 
our discussion, we won't
be able to modify much of the function since its hardware/IP specific.

>> +
>> +	ln_cnt =  ctrl->link->link_params.lane_count;
>> +
>> +	bpp = pinfo->bpp;
>> +	lwidth = pinfo->h_active;
>> +	h_blank = pinfo->h_back_porch + pinfo->h_front_porch +
>> +				pinfo->h_sync_width;
>> +	pclk = pinfo->pixel_clk_khz * 1000;
>> +
>> +	boundary_moderation_en = 0;
>> +	upper_bdry_cnt = 0;
>> +	lower_bdry_cnt = 0;
>> +	i_upper_bdry_cnt = 0;
>> +	i_lower_bdry_cnt = 0;
>> +	valid_lower_boundary_link = 0;
>> +	even_distribution_bf = 0;
>> +	even_distribution_legacy = 0;
>> +	even_distribution = 0;
>> +	min_hblank = 0;
>> +
>> +	lclk = drm_dp_bw_code_to_link_rate(
>> +		ctrl->link->link_params.bw_code) * DP_KHZ_TO_HZ;
>> +
>> +	pr_debug("pclk=%lld, active_width=%d, h_blank=%d\n",
>> +						pclk, lwidth, h_blank);
>> +	pr_debug("lclk = %lld, ln_cnt = %d\n", lclk, ln_cnt);
>> +	ratio = div64_u64_rem(pclk * bpp * multiplier,
>> +				8 * ln_cnt * lclk, &reminder);
>> +	ratio = div64_u64((pclk * bpp * multiplier), (8 * ln_cnt * lclk));
>> +	original_ratio = ratio;
>> +
>> +	extra_buffer_margin = roundup_u64(div64_u64(extra_pclk_cycle_delay
>> +				* lclk * multiplier, pclk), multiplier);
>> +	extra_buffer_margin = div64_u64(extra_buffer_margin, multiplier);
>> +
>> +	/* To deal with cases where lines are not distributable */
>> +	if (((lwidth % ln_cnt) != 0) && ratio < multiplier) {
>> +		ratio = ratio * ratio_scale;
>> +		ratio = ratio < (1000 * multiplier)
>> +				? ratio : (1000 * multiplier);
>> +	}
>> +	pr_debug("ratio = %lld\n", ratio);
>> +
>> +	for (tu_size = 32; tu_size <= 64; tu_size++) {
>> +		temp = ratio * tu_size;
>> +		temp2 = ((temp / multiplier) + 1) * multiplier;
>> +		n_err = roundup_u64(temp, multiplier) - temp;
>> +
>> +		if (n_err < err) {
>> +			err = n_err;
>> +			tu_size_desired = tu_size;
>> +		}
>> +	}
>> +	pr_debug("Info: tu_size_desired = %d\n", tu_size_desired);
>> +
>> +	tu_size_minus1 = tu_size_desired - 1;
>> +
>> +	valid_boundary_link = roundup_u64(ratio * tu_size_desired, 
>> multiplier);
>> +	valid_boundary_link /= multiplier;
>> +	n_tus = rounddown((lwidth * bpp * multiplier)
>> +			/ (8 * valid_boundary_link), multiplier) / multiplier;
>> +	even_distribution_legacy = n_tus % ln_cnt == 0 ? 1 : 0;
>> +	pr_debug("Info: n_symbol_per_tu=%d, number_of_tus=%d\n",
>> +					valid_boundary_link, n_tus);
>> +
>> +	extra_bytes = roundup_u64((n_tus + 1)
>> +			* ((valid_boundary_link * multiplier)
>> +			- (original_ratio * tu_size_desired)), multiplier);
>> +	extra_bytes /= multiplier;
>> +	extra_pclk_cycles = roundup(extra_bytes * 8 * multiplier / bpp,
>> +			multiplier);
>> +	extra_pclk_cycles /= multiplier;
>> +	extra_pclk_cycles_in_link_clk = 
>> roundup_u64(div64_u64(extra_pclk_cycles
>> +				* lclk * multiplier, pclk), multiplier);
>> +	extra_pclk_cycles_in_link_clk /= multiplier;
>> +	filler_size = roundup_u64((tu_size_desired - valid_boundary_link)
>> +						* multiplier, multiplier);
>> +	filler_size /= multiplier;
>> +	ratio_by_tu = div64_u64(ratio * tu_size_desired, multiplier);
>> +
>> +	pr_debug("extra_pclk_cycles_in_link_clk=%d, extra_bytes=%d\n",
>> +				extra_pclk_cycles_in_link_clk, extra_bytes);
>> +	pr_debug("extra_pclk_cycles_in_link_clk=%d\n",
>> +				extra_pclk_cycles_in_link_clk);
>> +	pr_debug("filler_size=%d, extra_buffer_margin=%lld\n",
>> +				filler_size, extra_buffer_margin);
>> +
>> +	delay_start_link = ((extra_bytes > extra_pclk_cycles_in_link_clk)
>> +			? extra_bytes
>> +			: extra_pclk_cycles_in_link_clk)
>> +				+ filler_size + extra_buffer_margin;
>> +	resulting_valid = valid_boundary_link;
>> +	pr_debug("Info: delay_start_link=%d, filler_size=%d\n",
>> +				delay_start_link, filler_size);
>> +	pr_debug("valid_boundary_link=%d ratio_by_tu=%lld\n",
>> +				valid_boundary_link, ratio_by_tu);
>> +
>> +	diff_abs = (resulting_valid >= ratio_by_tu)
>> +				? (resulting_valid - ratio_by_tu)
>> +				: (ratio_by_tu - resulting_valid);
>> +
>> +	if (err != 0 && ((diff_abs > brute_force_threshold)
>> +			|| (even_distribution_legacy == 0)
>> +			|| (dp_brute_force == 1))) {
>> +		err = multiplier;
>> +		for (tu_size = 32; tu_size <= 64; tu_size++) {
>> +			for (i_upper_bdry_cnt = 1; i_upper_bdry_cnt <= 15;
>> +						i_upper_bdry_cnt++) {
>> +				for (i_lower_bdry_cnt = 1;
>> +					i_lower_bdry_cnt <= 15;
>> +					i_lower_bdry_cnt++) {
>> +					new_valid_boundary_link =
>> +						roundup_u64(ratio
>> +						* tu_size, multiplier);
>> +					average_valid2 = (i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +						+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier))
>> +						/ (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt);
>> +					n_tus = rounddown_u64(div64_u64(lwidth
>> +						* multiplier * multiplier
>> +						* (bpp / 8), average_valid2),
>> +							multiplier);
>> +					n_tus /= multiplier;
>> +					n_tus_per_lane
>> +						= rounddown(n_tus
>> +							* multiplier
>> +							/ ln_cnt, multiplier);
>> +					n_tus_per_lane /= multiplier;
>> +					paired_tus =
>> +						rounddown((n_tus_per_lane)
>> +							* multiplier
>> +							/ (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt),
>> +							multiplier);
>> +					paired_tus /= multiplier;
>> +					remainder_tus = n_tus_per_lane
>> +							- paired_tus
>> +						* (i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt);
>> +					if ((remainder_tus
>> +						- i_upper_bdry_cnt) > 0) {
>> +						remainder_tus_upper
>> +							= i_upper_bdry_cnt;
>> +						remainder_tus_lower =
>> +							remainder_tus
>> +							- i_upper_bdry_cnt;
>> +					} else {
>> +						remainder_tus_upper
>> +							= remainder_tus;
>> +						remainder_tus_lower = 0;
>> +					}
>> +					total_valid = paired_tus
>> +						* (i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +							+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier))
>> +						+ (remainder_tus_upper
>> +						* new_valid_boundary_link)
>> +						+ (remainder_tus_lower
>> +						* (new_valid_boundary_link
>> +							- multiplier));
>> +					n_err_neg = nn_err_neg = false;
>> +					effective_valid
>> +						= div_u64(total_valid,
>> +							n_tus_per_lane);
>> +					n_n_err = (effective_valid
>> +							>= (ratio * tu_size))
>> +						? (effective_valid
>> +							- (ratio * tu_size))
>> +						: ((ratio * tu_size)
>> +							- effective_valid);
>> +					if (effective_valid < (ratio * tu_size))
>> +						nn_err_neg = true;
>> +					n_err = (average_valid2
>> +						>= (ratio * tu_size))
>> +						? (average_valid2
>> +							- (ratio * tu_size))
>> +						: ((ratio * tu_size)
>> +							- average_valid2);
>> +					if (average_valid2 < (ratio * tu_size))
>> +						n_err_neg = true;
>> +					even_distribution =
>> +						n_tus % ln_cnt == 0 ? 1 : 0;
>> +					diff_abs =
>> +						resulting_valid >= ratio_by_tu
>> +						? (resulting_valid
>> +							- ratio_by_tu)
>> +						: (ratio_by_tu
>> +							- resulting_valid);
>> +
>> +					resulting_valid_tmp = div64_u64(
>> +						(i_upper_bdry_cnt
>> +						* new_valid_boundary_link
>> +						+ i_lower_bdry_cnt
>> +						* (new_valid_boundary_link
>> +							- multiplier)),
>> +						(i_upper_bdry_cnt
>> +							+ i_lower_bdry_cnt));
>> +					ratio_by_tu_tmp =
>> +						original_ratio * tu_size;
>> +					ratio_by_tu_tmp /= multiplier;
>> +					n_tus_tmp = rounddown_u64(
>> +						div64_u64(lwidth
>> +						* multiplier * multiplier
>> +						* bpp / 8,
>> +						resulting_valid_tmp),
>> +						multiplier);
>> +					n_tus_tmp /= multiplier;
>> +
>> +					temp3 = (resulting_valid_tmp
>> +						>= (original_ratio * tu_size))
>> +						? (resulting_valid_tmp
>> +						- original_ratio * tu_size)
>> +						: (original_ratio * tu_size)
>> +						- resulting_valid_tmp;
>> +					temp3 = (n_tus_tmp + 1) * temp3;
>> +					temp4 = (new_valid_boundary_link
>> +						>= (original_ratio * tu_size))
>> +						? (new_valid_boundary_link
>> +							- original_ratio
>> +							* tu_size)
>> +						: (original_ratio * tu_size)
>> +						- new_valid_boundary_link;
>> +					temp4 = (i_upper_bdry_cnt
>> +							* ln_cnt * temp4);
>> +
>> +					temp3 = roundup_u64(temp3, multiplier);
>> +					temp4 = roundup_u64(temp4, multiplier);
>> +					dp_ctrl_get_extra_req_bytes
>> +						(resulting_valid_tmp,
>> +						new_valid_boundary_link,
>> +						temp3, temp4,
>> +						&extra_req_bytes_is_neg,
>> +						&result,
>> +						(original_ratio * tu_size));
>> +					extra_req_bytes_new_tmp
>> +						= div64_ul(result, multiplier);
>> +					if ((extra_req_bytes_is_neg)
>> +						&& (extra_req_bytes_new_tmp
>> +							> 1))
>> +						extra_req_bytes_new_tmp
>> +						= extra_req_bytes_new_tmp - 1;
>> +					if (extra_req_bytes_new_tmp == 0)
>> +						extra_req_bytes_new_tmp = 1;
>> +					extra_pclk_cycles_tmp =
>> +						(u64)(extra_req_bytes_new_tmp
>> +						      * 8 * multiplier) / bpp;
>> +					extra_pclk_cycles_tmp /= multiplier;
>> +
>> +					if (extra_pclk_cycles_tmp <= 0)
>> +						extra_pclk_cycles_tmp = 1;
>> +					extra_pclk_cycles_in_lclk_tmp =
>> +						roundup_u64(div64_u64(
>> +							extra_pclk_cycles_tmp
>> +							* lclk * multiplier,
>> +							pclk), multiplier);
>> +					extra_pclk_cycles_in_lclk_tmp
>> +						/= multiplier;
>> +					filler_size_tmp = roundup_u64(
>> +						(tu_size * multiplier *
>> +						new_valid_boundary_link),
>> +						multiplier);
>> +					filler_size_tmp /= multiplier;
>> +					lower_filler_size_tmp =
>> +						filler_size_tmp + 1;
>> +					if (extra_req_bytes_is_neg)
>> +						temp3 = (extra_req_bytes_new_tmp
>> +						> extra_pclk_cycles_in_lclk_tmp
>> +						? extra_pclk_cycles_in_lclk_tmp
>> +						: extra_req_bytes_new_tmp);
>> +					else
>> +						temp3 = (extra_req_bytes_new_tmp
>> +						> extra_pclk_cycles_in_lclk_tmp
>> +						? extra_req_bytes_new_tmp :
>> +						extra_pclk_cycles_in_lclk_tmp);
>> +
>> +					temp4 = lower_filler_size_tmp
>> +						+ extra_buffer_margin;
>> +					if (extra_req_bytes_is_neg)
>> +						delay_start_link_tmp
>> +							= (temp3 >= temp4)
>> +							? (temp3 - temp4)
>> +							: (temp4 - temp3);
>> +					else
>> +						delay_start_link_tmp
>> +							= temp3 + temp4;
>> +
>> +					min_hblank_tmp = (int)div64_u64(
>> +						roundup_u64(
>> +						div64_u64(delay_start_link_tmp
>> +						* pclk * multiplier, lclk),
>> +						multiplier), multiplier)
>> +						+ hblank_margin;
>> +
>> +					if (((even_distribution == 1)
>> +						|| ((even_distribution_bf == 0)
>> +						&& (even_distribution_legacy
>> +								== 0)))
>> +						&& !n_err_neg && !nn_err_neg
>> +						&& n_n_err < err
>> +						&& (n_n_err < diff_abs
>> +						|| (dp_brute_force == 1))
>> +						&& (new_valid_boundary_link
>> +									- 1) > 0
>> +						&& (h_blank >=
>> +							(u32)min_hblank_tmp)) {
>> +						upper_bdry_cnt =
>> +							i_upper_bdry_cnt;
>> +						lower_bdry_cnt =
>> +							i_lower_bdry_cnt;
>> +						err = n_n_err;
>> +						boundary_moderation_en = 1;
>> +						tu_size_desired = tu_size;
>> +						valid_boundary_link =
>> +							new_valid_boundary_link;
>> +						effective_valid_recorded
>> +							= effective_valid;
>> +						delay_start_link
>> +							= delay_start_link_tmp;
>> +						filler_size = filler_size_tmp;
>> +						min_hblank = min_hblank_tmp;
>> +						n_tus = n_tus_tmp;
>> +						even_distribution_bf = 1;
>> +
>> +						pr_debug("upper_bdry_cnt=%d, lower_boundary_cnt=%d, err=%lld, 
>> tu_size_desired=%d, valid_boundary_link=%d, effective_valid=%lld\n",
>> +							upper_bdry_cnt,
>> +							lower_bdry_cnt, err,
>> +							tu_size_desired,
>> +							valid_boundary_link,
>> +							effective_valid);
>> +					}
>> +				}
>> +			}
>> +		}
>> +
>> +		if (boundary_moderation_en == 1) {
>> +			resulting_valid = (u64)(upper_bdry_cnt
>> +					*valid_boundary_link + lower_bdry_cnt
>> +					* (valid_boundary_link - 1))
>> +					/ (upper_bdry_cnt + lower_bdry_cnt);
>> +			ratio_by_tu = original_ratio * tu_size_desired;
>> +			valid_lower_boundary_link =
>> +				(valid_boundary_link / multiplier) - 1;
>> +
>> +			tu_size_minus1 = tu_size_desired - 1;
>> +			even_distribution_bf = 1;
>> +			valid_boundary_link /= multiplier;
>> +			pr_debug("Info: Boundary_moderation enabled\n");
>> +		}
>> +	}
>> +
>> +	min_hblank = ((int) roundup_u64(div64_u64(delay_start_link * pclk
>> +			* multiplier, lclk), multiplier))
>> +			/ multiplier + hblank_margin;
>> +	if (h_blank < (u32)min_hblank) {
>> +		pr_debug(" WARNING: run_idx=%d Programmed h_blank %d is smaller 
>> than the min_hblank %d supported.\n",
>> +					run_idx, h_blank, min_hblank);
>> +	}
>> +
>> +	if (fifo_empty)	{
>> +		tu_size_minus1 = 31;
>> +		valid_boundary_link = 32;
>> +		delay_start_link = 0;
>> +		boundary_moderation_en = 0;
>> +	}
>> +
>> +	pr_debug("tu_size_minus1=%d valid_boundary_link=%d 
>> delay_start_link=%d boundary_moderation_en=%d\n upper_boundary_cnt=%d 
>> lower_boundary_cnt=%d valid_lower_boundary_link=%d min_hblank=%d\n",
>> +		tu_size_minus1, valid_boundary_link, delay_start_link,
>> +		boundary_moderation_en, upper_bdry_cnt, lower_bdry_cnt,
>> +		valid_lower_boundary_link, min_hblank);
>> +
>> +	tu_table->valid_boundary_link = valid_boundary_link;
>> +	tu_table->delay_start_link = delay_start_link;
>> +	tu_table->boundary_moderation_en = boundary_moderation_en;
>> +	tu_table->valid_lower_boundary_link = valid_lower_boundary_link;
>> +	tu_table->upper_boundary_count = upper_bdry_cnt;
>> +	tu_table->lower_boundary_count = lower_bdry_cnt;
>> +	tu_table->tu_size_minus1 = tu_size_minus1;
>> +}
>> +
>> +static void dp_ctrl_setup_tr_unit(struct dp_ctrl_private *ctrl)
>> +{
>> +	u32 dp_tu = 0x0;
>> +	u32 valid_boundary = 0x0;
>> +	u32 valid_boundary2 = 0x0;
>> +	struct dp_vc_tu_mapping_table tu_calc_table;
>> +
>> +	dp_ctrl_calc_tu_parameters(ctrl, &tu_calc_table);
>> +
>> +	dp_tu |= tu_calc_table.tu_size_minus1;
>> +	valid_boundary |= tu_calc_table.valid_boundary_link;
>> +	valid_boundary |= (tu_calc_table.delay_start_link << 16);
>> +
>> +	valid_boundary2 |= (tu_calc_table.valid_lower_boundary_link << 1);
>> +	valid_boundary2 |= (tu_calc_table.upper_boundary_count << 16);
>> +	valid_boundary2 |= (tu_calc_table.lower_boundary_count << 20);
>> +
>> +	if (tu_calc_table.boundary_moderation_en)
>> +		valid_boundary2 |= BIT(0);
>> +
>> +	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
>> +			dp_tu, valid_boundary, valid_boundary2);
>> +
>> +	ctrl->catalog->dp_tu = dp_tu;
>> +	ctrl->catalog->valid_boundary = valid_boundary;
>> +	ctrl->catalog->valid_boundary2 = valid_boundary2;
>> +
>> +	ctrl->catalog->update_transfer_unit(ctrl->catalog);
> 
> Again here, if you just call the function directly, you can avoid the 
> callback.
> If you add function arguments, you can avoid having to store
> dp_tu/valid_boundary/
> valid_boundary2 entirely.
> 
Will remove the dp_tu/valid_boundary/valid_boundary2 in V3.
>> +}
>> +
>> +static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);
> 
> Break out the timeout into a #define

Fixed in V2.

> 
>> +	if (ret <= 0) {
>> +		pr_err("Link Train timedout\n");
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
> 
> You're not checking the return value at the callsite.
> 
Fixed in V2.

>> +}
>> +
>> +static int dp_ctrl_update_sink_vx_px(struct dp_ctrl_private *ctrl,
>> +				     u32 voltage_level, u32 pre_emphasis_level)
> 
> I don't think this needs to be a function, just move it all into
> dp_ctrl_update_vx_px.
> 
Fixed in V2.

>> +{
>> +	int i;
>> +	u8 buf[4];
>> +	u32 max_level_reached = 0;
>> +
>> +	if (voltage_level == DP_LINK_VOLTAGE_MAX) {
>> +		pr_debug("max. voltage swing level reached %d\n",
>> +				voltage_level);
>> +		max_level_reached |= BIT(2);
> 
>         DP_TRAIN_MAX_SWING_REACHED
> 
>> +	}
>> +
>> +	if (pre_emphasis_level == DP_LINK_PRE_EMPHASIS_MAX) {
>> +		pr_debug("max. pre-emphasis level reached %d\n",
>> +				pre_emphasis_level);
>> +		max_level_reached  |= BIT(5);
> 
>         DP_TRAIN_MAX_PRE_EMPHASIS_REACHED
> 
>> +	}
>> +
>> +	pre_emphasis_level <<= 3;
> 
> This is DP_TRAIN_PRE_EMPHASIS_SHIFT, but I'm guessing you aren't using 
> the
> DP_TRAIN_PRE_EMPH_LEVEL_* values when you set p_level. So the right way 
> to fix
> this is to use those #defines and get rid of this shift.
> 
>> +
>> +	for (i = 0; i < 4; i++)
> 
> You shouldn't assume 4 lanes here, use drm_dp_link->num_lanes
> 
>> +		buf[i] = voltage_level | pre_emphasis_level | max_level_reached;
>> +
>> +	pr_debug("sink: p|v=0x%x\n", voltage_level | pre_emphasis_level);
>> +	return drm_dp_dpcd_write(ctrl->aux->drm_aux, 0x103, buf, 4);
> 
> s/0x103/DP_TRAINING_LANE0_SET/ and s/4/drm_dp_link->num_lanes/
> 
Forgot to fix s/4/drm_dp_link->num_lanes/. Will fix this in V3.

> Also, this will return number of bytes transmitted, not (0 || -errno).
> 
> 
>> +}
>> +
>> +static void dp_ctrl_update_vx_px(struct dp_ctrl_private *ctrl)
>> +{
>> +	struct dp_link *link = ctrl->link;
>> +
>> +	ctrl->catalog->update_vx_px(ctrl->catalog,
>> +		link->phy_params.v_level, link->phy_params.p_level);
>> +
>> +	dp_ctrl_update_sink_vx_px(ctrl, link->phy_params.v_level,
>> +		link->phy_params.p_level);
> 
> Fortunately (or unfortunately), the return value isn't checked. So 
> please check
> the return value.
> 
Fixed in V2.
>> +}
>> +
>> +static void dp_ctrl_train_pattern_set(struct dp_ctrl_private *ctrl,
>> +		u8 pattern)
>> +{
>> +	u8 buf[4];
> 
> Why 4?
> 
Will fix this in V3.

>> +
>> +	pr_debug("sink: pattern=%x\n", pattern);
>> +
>> +	buf[0] = pattern;
>> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, DP_TRAINING_PATTERN_SET, buf, 
>> 1);
> 
> Check the return value of this and alll drm_dp_dpcd_(read|write) calls.
> 
>> +}
>> +
>> +static int dp_ctrl_read_link_status(struct dp_ctrl_private *ctrl,
>> +				    u8 *link_status)
>> +{
>> +	int ret = 0, len;
>> +	u32 const offset = DP_LANE_ALIGN_STATUS_UPDATED - DP_LANE0_1_STATUS;
>> +	u32 link_status_read_max_retries = 100;
>> +
>> +	while (--link_status_read_max_retries) {
>> +		len = drm_dp_dpcd_read_link_status(ctrl->aux->drm_aux,
>> +			link_status);
>> +		if (len != DP_LINK_STATUS_SIZE) {
>> +			pr_err("DP link status read failed, err: %d\n", len);
>> +			ret = len;
>> +			break;
> 
> Just return directly here. You can also just drop len and use ret (or 
> drop ret
> and use len).
> 
>> +		}
>> +
>> +		if (!(link_status[offset] & DP_LINK_STATUS_UPDATED))
>> +			break;
> 
> And return 0 directly here
> 
Fixed in V2.

>> +	}
>> +
>> +	return ret;
> 
> Here you're returning successful in the timeout case :( Once you
> convert the above
> to direct returns, this can become return -ETIMEDOUT;
> 
Fixed in V2.
> I think you should also drop the number of retries drastically.
> 
>> +}
>> +
>> +static int dp_ctrl_link_train_1(struct dp_ctrl_private *ctrl)
>> +{
>> +	int tries, old_v_level, ret = 0;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +	int const maximum_retries = 5;
>> +
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
>> +
>> +	ctrl->catalog->set_pattern(ctrl->catalog, 0x01);
> 
> #define that bit please
> 
Fixed in V2.

>> +	dp_ctrl_train_pattern_set(ctrl, DP_TRAINING_PATTERN_1 |
>> +		DP_LINK_SCRAMBLING_DISABLE); /* train_1 */
> 
> the train_1 comment isn't needed.
> 
Fixed in V2.

>> +	dp_ctrl_update_vx_px(ctrl);
>> +
>> +	tries = 0;
>> +	old_v_level = ctrl->link->phy_params.v_level;
>> +	while (1) {
> 
> Instead of unbounded, this should be:
>         for (tries = 0; tries < maximum_retries; tries++) {
> 
Fixed in v2.

> You'll need to s/break/return ret/ in the rest of the loop and move the 
> timeout
> error to the bottom of the function
> 
>> +		drm_dp_link_train_clock_recovery_delay(ctrl->panel->dpcd);
>> +
>> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
>> +		if (ret)
>> +			break;
>> +
>> +		if (drm_dp_clock_recovery_ok(link_status,
>> +			ctrl->link->link_params.lane_count)) {
>> +			break;
>> +		}
>> +
>> +		if (ctrl->link->phy_params.v_level == DP_LINK_VOLTAGE_MAX) {
> 
> Since DP_LINK_VOLTAGE_MAX == DP_LINK_VOLTAGE_LEVEL_2, you'll end up not 
> retrying
> LEVEL_2 at all.
> 
Will follow up on this and fix it in V3.

>> +			pr_err_ratelimited("max v_level reached\n");
>> +			ret = -EAGAIN;
>> +			break;
>> +		}
>> +
>> +		if (old_v_level == ctrl->link->phy_params.v_level) {
>> +			tries++;
>> +			if (tries >= maximum_retries) {
>> +				pr_err("max tries reached\n");
>> +				ret = -ETIMEDOUT;
>> +				break;
>> +			}
>> +		} else {
>> +			tries = 0;
>> +			old_v_level = ctrl->link->phy_params.v_level;
>> +		}
>> +
>> +		pr_debug("clock recovery not done, adjusting vx px\n");
>> +
>> +		ctrl->link->adjust_levels(ctrl->link, link_status);
>> +		dp_ctrl_update_vx_px(ctrl);
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_link_rate_down_shift(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	if (!ctrl)
>> +		return -EINVAL;
>> +
>> +	switch (ctrl->link->link_params.bw_code) {
>> +	case DP_LINK_BW_8_1:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_5_4;
>> +		break;
>> +	case DP_LINK_BW_5_4:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_2_7;
>> +		break;
>> +	case DP_LINK_BW_2_7:
>> +	case DP_LINK_BW_1_62:
>> +	default:
>> +		ctrl->link->link_params.bw_code = DP_LINK_BW_1_62;
>> +		break;
>> +	};
>> +
>> +	pr_debug("new bw code=0x%x\n", ctrl->link->link_params.bw_code);
>> +
>> +	return ret;
>> +}
>> +
>> +static void dp_ctrl_clear_training_pattern(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	dp_ctrl_train_pattern_set(ctrl, 0);
> 
> 
> DP_TRAINING_PATTERN_DISABLE
> 
> 
Fixed in V2.

>> +	drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
>> +}
>> +
>> +static int dp_ctrl_link_training_2(struct dp_ctrl_private *ctrl)
>> +{
>> +	int tries = 0, ret = 0;
>> +	char pattern;
>> +	int const maximum_retries = 5;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
>> +
>> +	if (drm_dp_tps3_supported(ctrl->panel->dpcd))
>> +		pattern = DP_TRAINING_PATTERN_3;
>> +	else
>> +		pattern = DP_TRAINING_PATTERN_2;
>> +
>> +	dp_ctrl_update_vx_px(ctrl);
>> +	ctrl->catalog->set_pattern(ctrl->catalog, pattern);
>> +	dp_ctrl_train_pattern_set(ctrl, pattern | 
>> DP_RECOVERED_CLOCK_OUT_EN);
>> +
>> +	do  {
> 
>         for (tries = 0; tries < maximum_retries; tries++)
> 
Fixed in V2.

>> +		drm_dp_link_train_channel_eq_delay(ctrl->panel->dpcd);
>> +
>> +		ret = dp_ctrl_read_link_status(ctrl, link_status);
>> +		if (ret)
>> +			break;
>> +
>> +		if (drm_dp_channel_eq_ok(link_status,
>> +			ctrl->link->link_params.lane_count))
>> +			break;
>> +
>> +		if (tries > maximum_retries) {
>> +			ret = -ETIMEDOUT;
>> +			break;
>> +		}
>> +		tries++;
>> +
>> +		ctrl->link->adjust_levels(ctrl->link, link_status);
>> +		dp_ctrl_update_vx_px(ctrl);
>> +	} while (1);
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_link_train(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +	u8 encoding = 0x1;
> 
> DP_SET_ANSI_8B10B
> 
Fixed in V2.

>> +	struct drm_dp_link link_info = {0};
>> +
>> +	ctrl->link->phy_params.p_level = 0;
>> +	ctrl->link->phy_params.v_level = 0;
>> +
>> +	dp_ctrl_config_ctrl(ctrl);
>> +
>> +	link_info.num_lanes = ctrl->link->link_params.lane_count;
>> +	link_info.rate = drm_dp_bw_code_to_link_rate(
>> +		ctrl->link->link_params.bw_code);
>> +	link_info.capabilities = ctrl->panel->link_info.capabilities;
> 
> Drop the hand-rolled ctrl->panel->link_info and use drm_dp_link_probe 
> to fill in
> drm_dp_link.
> 
Fixed in V2.

>> +
>> +	drm_dp_link_configure(ctrl->aux->drm_aux, &link_info);
>> +	drm_dp_dpcd_write(ctrl->aux->drm_aux, 
>> DP_MAIN_LINK_CHANNEL_CODING_SET,
>> +				&encoding, 1);
>> +
>> +	ret = dp_ctrl_link_train_1(ctrl);
>> +	if (ret) {
>> +		pr_err("link training #1 failed\n");
> 
> print ret
> 
Fixed in V2.

>> +		goto end;
>> +	}
>> +
>> +	/* print success info as this is a result of user initiated action 
>> */
>> +	pr_info("link training #1 successful\n");
> 
> this should be debug loglevel
> 
Fixed in V2.

>> +
>> +	ret = dp_ctrl_link_training_2(ctrl);
>> +	if (ret) {
>> +		pr_err("link training #2 failed\n");
> 
> print ret
> 
Fixed in v2.

>> +		goto end;
>> +	}
>> +
>> +	/* print success info as this is a result of user initiated action 
>> */
>> +	pr_info("link training #2 successful\n");
> 
> debug loglevel
> 
Fixed in V2.

>> +
>> +end:
>> +	dp_ctrl_state_ctrl(ctrl, 0);
>> +	/* Make sure to clear the current pattern before starting a new one 
>> */
>> +	wmb();
> 
> Same comments re: wmb
> 
Fixed in V2.

>> +
>> +	dp_ctrl_clear_training_pattern(ctrl);
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_setup_main_link(struct dp_ctrl_private *ctrl, bool 
>> train)
>> +{
>> +	bool mainlink_ready = false;
>> +	int ret = 0;
>> +
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, true);
>> +
>> +	ret = ctrl->link->psm_config(ctrl->link,
>> +		&ctrl->panel->link_info, false);
> 
> This can fit on one line
> 
Fixed in V2.

>> +	if (ret)
>> +		goto end;
> 
> All of the "goto end"'s can be replaced with "return ret", then delete 
> the end
> label.
> 
Fixed in V2.
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> 
> You should really protect sink_request with a lock, it's racy. I'm 
> trying
> to catch the race conditions while I review, but I'd urge you to audit 
> the
> driver for other places that need locking.
> 
sink_request will be running in a single-threaded work queue. 
("drm_dp_extcon" work queue).
We might not need locking for sink_request.

>> +		goto end;
>> +
>> +	if (!train)
>> +		goto send_video;
> 
> Instead of adding the label, just wrap the reset and train calls in an
> if (train) {} block.
> 
Will fix this in V3.

> 
>> +
>> +	/*
>> +	 * As part of previous calls, DP controller state might have
>> +	 * transitioned to PUSH_IDLE. In order to start transmitting a link
>> +	 * training pattern, we have to first to a DP software reset.
> 
> "we have to first _do_ a..."
> 
Fixed in V2.

>> +	 */
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +
>> +	ret = dp_ctrl_link_train(ctrl);
>> +	if (ret)
>> +		goto end;
>> +
>> +send_video:
>> +	/*
>> +	 * Set up transfer unit values and set controller state to send
>> +	 * video.
>> +	 */
>> +	dp_ctrl_setup_tr_unit(ctrl);
>> +	ctrl->catalog->state_ctrl(ctrl->catalog, ST_SEND_VIDEO);
>> +
>> +	dp_ctrl_wait4video_ready(ctrl);
> 
> Check return value please
> 
Fixed in v2.

>> +	mainlink_ready = ctrl->catalog->mainlink_ready(ctrl->catalog);
>> +	pr_debug("mainlink %s\n", mainlink_ready ? "READY" : "NOT READY");
>> +end:
>> +	return ret;
>> +}
>> +
>> +static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
>> +				   char *name, u32 rate)
>> +{
>> +	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
>> +	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
>> +
>> +	while (num && strcmp(cfg->clk_name, name)) {
>> +		num--;
>> +		cfg++;
>> +	}
>> +
>> +	pr_debug("setting rate=%d on clk=%s\n", rate, name);
>> +
>> +	if (num)
>> +		cfg->rate = rate;
>> +	else
>> +		pr_err("%s clock could not be set with rate %d\n", name, rate);
>> +}
> 
> Instead of doing all of this work, just store pointers to the link and 
> pixel
> clock when you parse the dt. That way you can just access them directly 
> in
> dp_ctrl_enable_mainlink_clocks.
> 
These are generic implementation for DP_CORE and DP_CTRL clocks. This 
will help
for any future upgrades where the only change will be done dtsi and 
maybe minor
changes in Driver when we add/remove any clocks.

>> +
>> +static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ctrl->power->set_pixel_clk_parent(ctrl->power);
>> +
>> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
>> +		drm_dp_bw_code_to_link_rate(ctrl->link->link_params.bw_code));
>> +
>> +	dp_ctrl_set_clock_rate(ctrl, "ctrl_pixel_clk", ctrl->pixel_rate);
>> +
>> +	ret = ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, true);
>> +	if (ret) {
>> +		pr_err("Unabled to start link clocks\n");
>> +		ret = -EINVAL;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int dp_ctrl_disable_mainlink_clocks(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	return ctrl->power->clk_enable(ctrl->power, DP_CTRL_PM, false);
>> +}
> 
> This function isn't necesary (even less so when all of the catalog 
> abstractions
> are gone).
> 
Fixed in V2.

>> +
>> +static int dp_ctrl_host_init(struct dp_ctrl *dp_ctrl, bool flip)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +	struct dp_catalog_ctrl *catalog;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->orientation = flip;
>> +	catalog = ctrl->catalog;
>> +
>> +	catalog->usb_reset(ctrl->catalog, flip);
>> +	catalog->phy_reset(ctrl->catalog);
>> +	catalog->enable_irq(ctrl->catalog, true);
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * dp_ctrl_host_deinit() - Uninitialize DP controller
>> + * @ctrl: Display Port Driver data
>> + *
>> + * Perform required steps to uninitialize DP controller
>> + * and its resources.
>> + */
>> +static void dp_ctrl_host_deinit(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("Invalid input data\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->enable_irq(ctrl->catalog, false);
>> +
>> +	pr_debug("Host deinitialized successfully\n");
>> +}
>> +
>> +static bool dp_ctrl_use_fixed_nvid(struct dp_ctrl_private *ctrl)
>> +{
>> +	u8 *dpcd = ctrl->panel->dpcd;
>> +
>> +	/*
>> +	 * For better interop experience, used a fixed NVID=0x8000
>> +	 * whenever connected to a VGA dongle downstream.
>> +	 */
>> +	if (dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT) {
>> +		u8 type = dpcd[DP_DOWNSTREAMPORT_PRESENT] &
>> +			DP_DWN_STRM_PORT_TYPE_MASK;
>> +		if (type == DP_DWN_STRM_PORT_TYPE_ANALOG)
>> +			return true;
>> +	}
>> +
>> +	return false;
>> +}
> 
> For this, you should use the DP_DPCD_QUIRK_CONSTANT_N quirk and
> drm_dp_has_quirk() instead.
> 
> 
Will follow up on this in V3.

>> +
>> +static int dp_ctrl_link_maintenance(struct dp_ctrl_private *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
>> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
>> +
>> +	ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
>> +
>> +	do {
>> +		if (ret == -EAGAIN) {
>> +			/* try with lower link rate */
>> +			dp_ctrl_link_rate_down_shift(ctrl);
>> +
>> +			ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +		}
>> +
>> +		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
>> +			ctrl->orientation, ctrl->link->link_params.lane_count);
>> +
>> +		/*
>> +		 * Disable and re-enable the mainlink clock since the
>> +		 * link clock might have been adjusted as part of the
>> +		 * link maintenance.
>> +		 */
>> +		dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Return value should be checked
> 
> 
Fixed in V2.

> Below you have:
> 
> +		/* hw recommended delay before re-enabling clocks */
> +		msleep(20);
> 
> Between the disable and enable, so you should probably have that here 
> too?
> 
>> +
>> +		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
>> +		if (ret)
>> +			continue;
> 
> Do you really want to continue here? Seems like you could get into an 
> infinite
> loop pretty easily in the -EINVAL case.
> 
>> +
>> +		dp_ctrl_configure_source_params(ctrl);
>> +
>> +		ctrl->catalog->config_msa(ctrl->catalog,
>> +			drm_dp_bw_code_to_link_rate(
>> +			ctrl->link->link_params.bw_code),
>> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
>> +
>> +		reinit_completion(&ctrl->idle_comp);
> 
> Are you guaranteed that this doesn't race with other idle_comp uses?
> 
>> +
>> +		ret = dp_ctrl_setup_main_link(ctrl, true);
>> +	} while (ret == -EAGAIN);
> 
> The do/while is a bit awkward, especially since it starts with a 
> conditional
> block that can't possibly be true on the first iteration. How about:
> 
> 	for (tries = 0; tries < max_tries; tries++) {
> 		ctrl->catalog->phy_lane_cfg(ctrl->catalog,
> 			ctrl->orientation, ctrl->link->link_params.lane_count);
> 
> 		/*
> 		 * Disable and re-enable the mainlink clock since the
> 		 * link clock might have been adjusted as part of the
> 		 * link maintenance.
> 		 */
> 		ret = dp_ctrl_disable_mainlink_clocks(ctrl);
>                 if (ret)
>                         return ret;
> 
> 		ret = dp_ctrl_enable_mainlink_clocks(ctrl);
> 		if (ret)
> 			return ret;
> 
> 		dp_ctrl_configure_source_params(ctrl);
> 
> 		ctrl->catalog->config_msa(ctrl->catalog,
> 			drm_dp_bw_code_to_link_rate(
> 			ctrl->link->link_params.bw_code),
> 			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
> 
> 		reinit_completion(&ctrl->idle_comp);
> 
> 		ret = dp_ctrl_setup_main_link(ctrl, true);
> 		if (ret != -EAGAIN)
>                         return ret;
> 
>                 /* try with lower link rate */
>                 dp_ctrl_link_rate_down_shift(ctrl);
> 
>                 ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
> 	}
> 
>         return -ETIMEDOUT;
> 
Implemented the above functionality in V2.

> 
> There's a lot of similarity between this code and dp_ctrl_on. If the 
> code were
> shared, we wouldn't have the missing 20ms delay above. So can you 
> please pull
> the common bits which [re-]initialize the link into a helper function 
> that you
> call from both functions?
> 
Will follow up and see if we can have common helper function. Will 
update in V3.
>> +
>> +	return ret;
> 
> It's nice that we return a value here, but it's never checked by our 
> callers :(
> 
Will fix this in V3.
>> +}
>> +
>> +static void dp_ctrl_process_phy_test_request(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	int ret = 0;
>> +
>> +	if (!ctrl->link->phy_params.phy_test_pattern_sel) {
>> +		pr_debug("no test pattern selected by sink\n");
>> +		return;
>> +	}
>> +
>> +	pr_debug("start\n");
> 
> This and the "end" debug statements should be removed
> 
Fixed in v2.

>> +
>> +	ctrl->dp_ctrl.push_idle(&ctrl->dp_ctrl);
>> +	/*
>> +	 * The global reset will need DP link ralated clocks to be
> 
> s/related/ralated/
> 
>> +	 * running. Add the global reset just before disabling the
>> +	 * link clocks and core clocks.
>> +	 */
>> +	ctrl->dp_ctrl.reset(&ctrl->dp_ctrl);
>> +	ctrl->dp_ctrl.off(&ctrl->dp_ctrl);
>> +
>> +	ret = ctrl->dp_ctrl.on(&ctrl->dp_ctrl);
>> +	if (ret)
>> +		pr_err("failed to enable DP controller\n");
> 
> Please propagate errors instead of swallowing them.
> 
Will fix this in V3.

>> +
>> +	pr_debug("end\n");
>> +}
>> +
>> +static void dp_ctrl_send_phy_test_pattern(struct dp_ctrl_private 
>> *ctrl)
>> +{
>> +	bool success = false;
>> +	u32 pattern_sent = 0x0;
>> +	u32 pattern_requested = ctrl->link->phy_params.phy_test_pattern_sel;
>> +
>> +	pr_debug("request: %s\n",
>> +			dp_link_get_phy_test_pattern(pattern_requested));
>> +
>> +	ctrl->catalog->update_vx_px(ctrl->catalog,
>> +			ctrl->link->phy_params.v_level,
>> +			ctrl->link->phy_params.p_level);
>> +	ctrl->catalog->send_phy_pattern(ctrl->catalog, pattern_requested);
>> +	ctrl->link->send_test_response(ctrl->link);
>> +
>> +	pattern_sent = ctrl->catalog->read_phy_pattern(ctrl->catalog);
>> +
>> +	switch (pattern_sent) {
>> +	case MR_LINK_TRAINING1:
>> +		if (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING)
>> +			success = true;
> 
> 
> success = pattern_requested == DP_LINK_QUAL_PATTERN_11_D10_2;
> 
> Same can be done below.
> 
> 
Fixed in v2.

>> +		break;
>> +	case MR_LINK_SYMBOL_ERM:
>> +		if ((pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT)
>> +			|| (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN))
>> +			success = true;
>> +		break;
>> +	case MR_LINK_PRBS7:
>> +		if (pattern_requested == DP_TEST_PHY_PATTERN_PRBS7)
>> +			success = true;
>> +		break;
>> +	case MR_LINK_CUSTOM80:
>> +		if (pattern_requested ==
>> +				DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN)
>> +			success = true;
>> +		break;
>> +	default:
>> +		success = false;
>> +		return;
>> +	}
> 
> I feel like you should return success (or a ret). As it is, this
> doesn't do much.
> 
Fixed in V2.

>> +
>> +	pr_debug("%s: %s\n", success ? "success" : "failed",
>> +			dp_link_get_phy_test_pattern(pattern_requested));
>> +}
>> +
>> +static void dp_ctrl_handle_sink_request(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +	u32 sink_request = 0x0;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +	sink_request = ctrl->link->sink_request;
>> +
>> +	if (sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		pr_info("PHY_TEST_PATTERN request\n");
> 
> Downgrade to DEBUG level please
> 
Fixed in v2.

>> +		dp_ctrl_process_phy_test_request(ctrl);
>> +	}
>> +
>> +	if (sink_request & DP_LINK_STATUS_UPDATED)
>> +		dp_ctrl_link_maintenance(ctrl);
> 
> Check return value
> 
>> +
>> +	if (sink_request & DP_TEST_LINK_TRAINING) {
>> +		ctrl->link->send_test_response(ctrl->link);
>> +		dp_ctrl_link_maintenance(ctrl);
> 
> Check return value
> 
>> +	}
>> +}
>> +
>> +static void dp_ctrl_reset(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +}
> 
> I think this function goes away with all of the catalog stuff removed.
> 
Will fix this in V3.

>> +
>> +static int dp_ctrl_on(struct dp_ctrl *dp_ctrl)
>> +{
>> +	int rc = 0;
>> +	struct dp_ctrl_private *ctrl;
>> +	u32 rate = 0;
>> +	u32 link_train_max_retries = 100;
> 
> This amount is excessive, 5 times should suffice (unless you have data 
> that
> suggests otherwise).
> 
>> +	u32 const phy_cts_pixel_clk_khz = 148500;
> 
> Should this be a #define in drm_dp_helper?
> 
>> +
>> +	if (!dp_ctrl) {
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	atomic_set(&ctrl->aborted, 0);
> 
> Why is this needed over is_connected? It seems like if you had proper 
> locking
> around is_connected (which I think is necessary), you could just
> acquire the lock
> and try the training. If it fails b/c someone unplugged the cable, 
> that's quite
> Ok.
> 
>> +	rate = ctrl->panel->link_info.rate;
>> +
>> +	ctrl->power->clk_enable(ctrl->power, DP_CORE_PM, true);
>> +	ctrl->catalog->hpd_config(ctrl->catalog, true);
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		pr_debug("using phy test link parameters\n");
>> +		if (!ctrl->panel->pinfo.pixel_clk_khz)
>> +			ctrl->pixel_rate = phy_cts_pixel_clk_khz;
>> +	} else {
>> +		ctrl->link->link_params.bw_code =
>> +			drm_dp_link_rate_to_bw_code(rate);
>> +		ctrl->link->link_params.lane_count =
>> +			ctrl->panel->link_info.num_lanes;
>> +		ctrl->pixel_rate = ctrl->panel->pinfo.pixel_clk_khz;
>> +	}
>> +
>> +	pr_debug("bw_code=%d, lane_count=%d, pixel_rate=%d\n",
>> +		ctrl->link->link_params.bw_code,
>> +		ctrl->link->link_params.lane_count, ctrl->pixel_rate);
>> +
>> +	ctrl->catalog->phy_lane_cfg(ctrl->catalog,
>> +			ctrl->orientation, ctrl->link->link_params.lane_count);
>> +
>> +	rc = dp_ctrl_enable_mainlink_clocks(ctrl);
>> +	if (rc)
>> +		goto end;
>> +
>> +	reinit_completion(&ctrl->idle_comp);
> 
> Are you guaranteed that this doesn't race with other idle_comp uses (or 
> other
> dp_ctrl_on callers)?
> 
I don't think we need to lock for idle_comp. Mentioned more details in 
dp_ctrl_push_idle().

>> +
>> +	dp_ctrl_configure_source_params(ctrl);
>> +
>> +	while (--link_train_max_retries && !atomic_read(&ctrl->aborted)) {
>> +		ctrl->catalog->config_msa(ctrl->catalog,
>> +			drm_dp_bw_code_to_link_rate(
>> +			ctrl->link->link_params.bw_code),
>> +			ctrl->pixel_rate, dp_ctrl_use_fixed_nvid(ctrl));
>> +
>> +		rc = dp_ctrl_setup_main_link(ctrl, true);
>> +		if (!rc)
>> +			break;
>> +
>> +		/* try with lower link rate */
>> +		dp_ctrl_link_rate_down_shift(ctrl);
>> +
>> +		ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +
>> +		dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Check return code
> 
>> +		/* hw recommended delay before re-enabling clocks */
>> +		msleep(20);
>> +
>> +		dp_ctrl_enable_mainlink_clocks(ctrl);
> 
> Check return code
> 
Will fix this in V3.

>> +	}
> 
> Same comment here as in dp_ctrl_link_maintenance(), we should pull out 
> the
> common code and put it in a helper.
> 
>> +
>> +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> 
> This is racy, sink_request could change between the check above and 
> here.
> 
Sink_request is accessed in single thread context.

>> +		dp_ctrl_send_phy_test_pattern(ctrl);
>> +
>> +	pr_debug("End-\n");
> 
> Please remove
> 
Fixed in V2.

>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_ctrl_off(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->mainlink_ctrl(ctrl->catalog, false);
>> +	ctrl->catalog->reset(ctrl->catalog);
>> +
>> +	/* Make sure DP is disabled before clk disable */
>> +	wmb();
> 
> readl/wmb nit
> 
Fixed in V2.

>> +
>> +	dp_ctrl_disable_mainlink_clocks(ctrl);
> 
> Check and propagate return value
> 
>> +
>> +	pr_debug("DP off done\n");
>> +}
>> +
>> +static void dp_ctrl_isr(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	ctrl->catalog->get_interrupt(ctrl->catalog);
> 
> This should return the isr instead of store it in ctrl->catalog->isr, 
> since that
> could potentially be overwritten after this function acks the current
> interrupts.
> 
Will fix this in V3.

> (Also, it's only used in this function, so there's no need to store 
> it). One you
> remove the catalog indirection, hopefully there will be a bunch of 
> these cases
> that become clear.
> 
> 
>> +
>> +	if (ctrl->catalog->isr & DP_CTRL_INTR_READY_FOR_VIDEO)
>> +		dp_ctrl_video_ready(ctrl);
>> +
>> +	if (ctrl->catalog->isr & DP_CTRL_INTR_IDLE_PATTERN_SENT)
>> +		dp_ctrl_idle_patterns_sent(ctrl);
> 
> As mentioned above, just call the completions directly.
> 
Fixed in v2.

>> +}
>> +
>> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in)
>> +{
>> +	int rc = 0;
>> +	struct dp_ctrl_private *ctrl;
>> +	struct dp_ctrl *dp_ctrl;
>> +
>> +	if (!in->dev || !in->panel || !in->aux ||
>> +	    !in->link || !in->catalog) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	ctrl = devm_kzalloc(in->dev, sizeof(*ctrl), GFP_KERNEL);
>> +	if (!ctrl) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	init_completion(&ctrl->idle_comp);
>> +	init_completion(&ctrl->video_comp);
>> +
>> +	/* in parameters */
>> +	ctrl->parser   = in->parser;
>> +	ctrl->panel    = in->panel;
>> +	ctrl->power    = in->power;
>> +	ctrl->aux      = in->aux;
>> +	ctrl->link     = in->link;
>> +	ctrl->catalog  = in->catalog;
>> +	ctrl->dev      = in->dev;
>> +
>> +	dp_ctrl = &ctrl->dp_ctrl;
>> +
>> +	/* out parameters */
>> +	dp_ctrl->init      = dp_ctrl_host_init;
>> +	dp_ctrl->deinit    = dp_ctrl_host_deinit;
>> +	dp_ctrl->on        = dp_ctrl_on;
>> +	dp_ctrl->off       = dp_ctrl_off;
>> +	dp_ctrl->push_idle = dp_ctrl_push_idle;
>> +	dp_ctrl->abort     = dp_ctrl_abort;
>> +	dp_ctrl->isr       = dp_ctrl_isr;
>> +	dp_ctrl->reset	   = dp_ctrl_reset;
>> +	dp_ctrl->handle_sink_request = dp_ctrl_handle_sink_request;
>> +
>> +	return dp_ctrl;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl)
>> +{
>> +	struct dp_ctrl_private *ctrl;
>> +
>> +	if (!dp_ctrl)
>> +		return;
>> +
>> +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
>> +
>> +	devm_kfree(ctrl->dev, ctrl);
>> +}
> 
> Once again, these functions can be deleted. Just store the _necessary_ 
> data in a
> central struct (with substructs as necessary) and call functions 
> directly.
> 
Removed all the functions/func_ptrs in V2 and calling the functions 
directly.

> 
>> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.h 
>> b/drivers/gpu/drm/msm/dp/dp_ctrl.h
>> new file mode 100644
>> index 0000000..6ab221a
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.h
>> @@ -0,0 +1,50 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_CTRL_H_
>> +#define _DP_CTRL_H_
>> +
>> +#include "dp_aux.h"
>> +#include "dp_panel.h"
>> +#include "dp_link.h"
>> +#include "dp_parser.h"
>> +#include "dp_power.h"
>> +#include "dp_catalog.h"
>> +
>> +struct dp_ctrl {
>> +	int (*init)(struct dp_ctrl *dp_ctrl, bool flip);
>> +	void (*deinit)(struct dp_ctrl *dp_ctrl);
>> +	int (*on)(struct dp_ctrl *dp_ctrl);
>> +	void (*off)(struct dp_ctrl *dp_ctrl);
>> +	void (*reset)(struct dp_ctrl *dp_ctrl);
>> +	void (*push_idle)(struct dp_ctrl *dp_ctrl);
>> +	void (*abort)(struct dp_ctrl *dp_ctrl);
>> +	void (*isr)(struct dp_ctrl *dp_ctrl);
>> +	void (*handle_sink_request)(struct dp_ctrl *dp_ctrl);
>> +};
> 
> Same comment as catalog, these should just be functions to be called 
> directly.
> 
Removed these function ptrs in V2.

>> +
>> +struct dp_ctrl_in {
>> +	struct device *dev;
>> +	struct dp_panel *panel;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_parser *parser;
>> +	struct dp_power *power;
>> +	struct dp_catalog_ctrl *catalog;
>> +};
> 
> This struct is not needed, function arguments work just as well.
> 
removed in V2.

>> +
>> +struct dp_ctrl *dp_ctrl_get(struct dp_ctrl_in *in);
>> +void dp_ctrl_put(struct dp_ctrl *dp_ctrl);
>> +
>> +#endif /* _DP_CTRL_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_debug.c 
>> b/drivers/gpu/drm/msm/dp/dp_debug.c
>> new file mode 100644
>> index 0000000..5c0a8ce
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_debug.c
>> @@ -0,0 +1,507 @@

/snip

> 
> edid, hpd, and connected can all be deleted. They're provided by core.
> 
> AFAICT, you can also infer the information from dp_debug, so I think 
> you can
> just drop this entire file.
> 
Removed dp_debug.[ch] in V2.

/snip

> 
> Drop this too
> 
>> +
>> +#endif /* _DP_DEBUG_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c 
>> b/drivers/gpu/drm/msm/dp/dp_display.c
>> new file mode 100644
>> index 0000000..8c98399
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
>> @@ -0,0 +1,977 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/module.h>
>> +#include <linux/slab.h>
>> +#include <linux/uaccess.h>
>> +#include <linux/debugfs.h>
>> +#include <linux/component.h>
>> +#include <linux/of_irq.h>
>> +
>> +#include "msm_drv.h"
>> +#include "dp_extcon.h"
>> +#include "dp_parser.h"
>> +#include "dp_power.h"
>> +#include "dp_catalog.h"
>> +#include "dp_aux.h"
>> +#include "dp_link.h"
>> +#include "dp_panel.h"
>> +#include "dp_ctrl.h"
>> +#include "dp_display.h"
>> +#include "dp_drm.h"
>> +#include "dp_debug.h"
>> +
>> +static struct msm_dp *g_dp_display;
>> +#define HPD_STRING_SIZE 30
>> +
>> +struct dp_display_private {
>> +	char *name;
>> +	int irq;
>> +
>> +	/* state variables */
>> +	bool core_initialized;
>> +	bool power_on;
>> +	bool hpd_irq_on;
>> +	bool audio_supported;
>> +
>> +	struct platform_device *pdev;
>> +	struct dentry *root;
>> +	struct completion notification_comp;
>> +
>> +	struct dp_usbpd   *usbpd;
>> +	struct dp_parser  *parser;
>> +	struct dp_power   *power;
>> +	struct dp_catalog *catalog;
>> +	struct dp_aux     *aux;
>> +	struct dp_link    *link;
>> +	struct dp_panel   *panel;
>> +	struct dp_ctrl    *ctrl;
>> +	struct dp_debug   *debug;
>> +
>> +	struct dp_usbpd_cb usbpd_cb;
>> +	struct dp_display_mode mode;
>> +	struct msm_dp dp_display;
>> +
>> +};
>> +
>> +static const struct of_device_id dp_dt_match[] = {
>> +	{.compatible = "qcom,dp-display"},
>> +	{}
>> +};
>> +
>> +static irqreturn_t dp_display_irq(int irq, void *dev_id)
>> +{
>> +	struct dp_display_private *dp = dev_id;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid data\n");
>> +		return IRQ_NONE;
>> +	}
>> +
>> +	/* DP controller isr */
>> +	dp->ctrl->isr(dp->ctrl);
>> +
>> +	/* DP aux isr */
>> +	dp->aux->isr(dp->aux);
>> +
>> +	return IRQ_HANDLED;
>> +}
>> +
>> +static int dp_display_bind(struct device *dev, struct device *master,
>> +			   void *data)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +	struct drm_device *drm;
>> +	struct msm_drm_private *priv;
>> +	struct platform_device *pdev = to_platform_device(dev);
>> +
>> +	if (!dev || !pdev || !master) {
>> +		pr_err("invalid param(s), dev %pK, pdev %pK, master %pK\n",
>> +				dev, pdev, master);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	drm = dev_get_drvdata(master);
>> +	dp = platform_get_drvdata(pdev);
>> +	if (!drm || !dp) {
>> +		pr_err("invalid param(s), drm %pK, dp %pK\n",
>> +				drm, dp);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp->dp_display.drm_dev = drm;
>> +	priv = drm->dev_private;
>> +	priv->dp = &(dp->dp_display);
>> +
>> +	rc = dp->parser->parse(dp->parser);
>> +	if (rc) {
>> +		pr_err("device tree parsing failed\n");
>> +		goto end;
>> +	}
>> +
>> +	rc = dp->aux->drm_aux_register(dp->aux);
>> +	if (rc) {
>> +		pr_err("DRM DP AUX register failed\n");
>> +		goto end;
>> +	}
>> +
>> +	rc = dp->power->power_client_init(dp->power);
>> +	if (rc) {
>> +		pr_err("Power client create failed\n");
>> +		goto end;
>> +	}
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_unbind(struct device *dev, struct device 
>> *master,
>> +			      void *data)
>> +{
>> +	struct dp_display_private *dp;
>> +	struct platform_device *pdev = to_platform_device(dev);
>> +	struct drm_device *drm = dev_get_drvdata(master);
>> +	struct msm_drm_private *priv = drm->dev_private;
>> +
>> +	if (!dev || !pdev) {
>> +		pr_err("invalid param(s)\n");
>> +		return;
>> +	}
>> +
>> +	dp = platform_get_drvdata(pdev);
>> +	if (!dp) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	(void)dp->power->power_client_deinit(dp->power);
>> +	(void)dp->aux->drm_aux_deregister(dp->aux);
>> +	priv->dp = NULL;
>> +}
>> +
>> +static const struct component_ops dp_display_comp_ops = {
>> +	.bind = dp_display_bind,
>> +	.unbind = dp_display_unbind,
>> +};
>> +
>> +static bool dp_display_is_ds_bridge(struct dp_panel *panel)
>> +{
>> +	return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
>> +		DP_DWN_STRM_PORT_PRESENT);
>> +}
>> +
>> +static bool dp_display_is_sink_count_zero(struct dp_display_private 
>> *dp)
>> +{
>> +	return dp_display_is_ds_bridge(dp->panel) &&
>> +		(dp->link->sink_count.count == 0);
>> +}
>> +
>> +static void dp_display_send_hpd_event(struct msm_dp *dp_display)
>> +{
>> +	struct dp_display_private *dp;
>> +	struct drm_connector *connector;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	connector = dp->dp_display.connector;
>> +	drm_helper_hpd_irq_event(connector->dev);
>> +}
>> +
>> +static int dp_display_send_hpd_notification(struct dp_display_private 
>> *dp,
>> +					    bool hpd)
> 
> This function is called from a few different threads with no locking. 
> It seems
> like there's good opportunity for is_connected and notification_comp to 
> get out
> of sync.
> 
> Additionally, is_connected is set to true before the function returns 
> (and
> enable has been completed). So is that going to cause problems when we 
> call
> detect/get_modes where is_connected == true and the hw is not up?
> 
Will fix this in V3.


> Perhaps I'm misreading this function, but it seems like the plan is to 
> block
> until userspace has been notified and does a full modeset (ie: enable)? 
> If that
> is the case, we usually don't want to have the hardware lit up until 
> it's
> actually going to be used. In these cases, we'll wrap get_modes in
> enable/disable (with proper locking), and wait for modeset to leave it 
> on.
> 
When HPD goes high, we do dpcd reads to get the sink capabilities and 
then inform the framework so that "enable"
gets called by drm framework.

>> +{
>> +	if ((hpd && dp->dp_display.is_connected) ||
>> +			(!hpd && !dp->dp_display.is_connected)) {
>> +		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
>> +		return 0;
>> +	}
>> +
>> +	/* reset video pattern flag on disconnect */
>> +	if (!hpd)
>> +		dp->panel->video_test = false;
>> +
>> +	dp->dp_display.is_connected = hpd;
>> +	reinit_completion(&dp->notification_comp);
>> +	dp_display_send_hpd_event(&dp->dp_display);
>> +
>> +	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
>> +		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
>> +		return -EINVAL;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_display_process_hpd_high(struct dp_display_private *dp)
>> +{
>> +	int rc = 0;
>> +	struct edid *edid;
>> +
>> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
>> +
>> +	if (dp->link->psm_enabled)
>> +		goto notify;
>> +
>> +	rc = dp->panel->read_sink_caps(dp->panel, dp->dp_display.connector);
>> +	if (rc)
>> +		goto notify;
>> +
>> +	dp->link->process_request(dp->link);
>> +
>> +	if (dp_display_is_sink_count_zero(dp)) {
>> +		pr_debug("no downstream devices connected\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	edid = dp->panel->edid;
>> +
>> +	dp->audio_supported = drm_detect_monitor_audio(edid);
>> +
>> +	dp->panel->handle_sink_request(dp->panel);
>> +
>> +	dp->dp_display.max_pclk_khz = dp->parser->max_pclk_khz;
>> +notify:
>> +	dp_display_send_hpd_notification(dp, true);
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_host_init(struct dp_display_private *dp)
>> +{
>> +	bool flip = false;
>> +
>> +	if (dp->core_initialized) {
>> +		pr_debug("DP core already initialized\n");
>> +		return;
>> +	}
>> +
>> +	if (dp->usbpd->orientation == ORIENTATION_CC2)
>> +		flip = true;
>> +
>> +	dp->power->init(dp->power, flip);
>> +	dp->ctrl->init(dp->ctrl, flip);
>> +	enable_irq(dp->irq);
>> +	dp->core_initialized = true;
>> +}
>> +
>> +static void dp_display_host_deinit(struct dp_display_private *dp)
>> +{
>> +	if (!dp->core_initialized) {
>> +		pr_debug("DP core already off\n");
>> +		return;
>> +	}
>> +
>> +	dp->ctrl->deinit(dp->ctrl);
>> +	dp->power->deinit(dp->power);
>> +	disable_irq(dp->irq);
>> +	dp->core_initialized = false;
>> +}
>> +
>> +static void dp_display_process_hpd_low(struct dp_display_private *dp)
>> +{
>> +	/* cancel any pending request */
>> +	dp->ctrl->abort(dp->ctrl);
>> +
>> +	dp_display_send_hpd_notification(dp, false);
>> +
>> +	dp->aux->deinit(dp->aux);
>> +}
>> +
>> +static int dp_display_usbpd_configure_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		rc = -ENODEV;
>> +		goto end;
>> +	}
>> +
>> +	dp_display_host_init(dp);
>> +
>> +	if (dp->usbpd->hpd_high)
>> +		dp_display_process_hpd_high(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_clean(struct dp_display_private *dp)
>> +{
>> +	dp->ctrl->push_idle(dp->ctrl);
>> +	dp->ctrl->off(dp->ctrl);
>> +}
>> +
>> +static int dp_display_usbpd_disconnect_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		rc = -ENODEV;
>> +		goto end;
>> +	}
>> +
>> +	/* cancel any pending request */
>> +	dp->ctrl->abort(dp->ctrl);
>> +
>> +	rc = dp_display_send_hpd_notification(dp, false);
>> +
>> +	/* if cable is disconnected, reset psm_enabled flag */
>> +	if (!dp->usbpd->alt_mode_cfg_done)
>> +		dp->link->psm_enabled = false;
>> +
>> +	if ((rc < 0) && dp->power_on)
>> +		dp_display_clean(dp);
>> +
>> +	dp_display_host_deinit(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_handle_video_request(struct dp_display_private 
>> *dp)
>> +{
>> +	if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) {
>> +		/* force disconnect followed by connect */
>> +		dp->usbpd->connect(dp->usbpd, false);
>> +		dp->panel->video_test = true;
>> +		dp->usbpd->connect(dp->usbpd, true);
>> +		dp->link->send_test_response(dp->link);
>> +	}
>> +}
>> +
>> +static int dp_display_handle_hpd_irq(struct dp_display_private *dp)
>> +{
>> +	if (dp->link->sink_request & DS_PORT_STATUS_CHANGED) {
>> +		dp_display_send_hpd_notification(dp, false);
>> +
>> +		if (dp_display_is_sink_count_zero(dp)) {
>> +			pr_debug("sink count is zero, nothing to do\n");
>> +			return 0;
>> +		}
>> +
>> +		return dp_display_process_hpd_high(dp);
>> +	}
>> +
>> +	dp->ctrl->handle_sink_request(dp->ctrl);
>> +
>> +	dp_display_handle_video_request(dp);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_display_usbpd_attention_cb(struct device *dev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dev) {
>> +		pr_err("invalid dev\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp = dev_get_drvdata(dev);
>> +	if (!dp) {
>> +		pr_err("no driver data found\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	if (dp->usbpd->hpd_irq) {
>> +		dp->hpd_irq_on = true;
>> +
>> +		rc = dp->link->process_request(dp->link);
>> +		/* check for any test request issued by sink */
>> +		if (!rc)
>> +			dp_display_handle_hpd_irq(dp);
>> +
>> +		dp->hpd_irq_on = false;
>> +		goto end;
>> +	}
>> +
>> +	if (!dp->usbpd->hpd_high) {
>> +		dp_display_process_hpd_low(dp);
>> +		goto end;
>> +	}
>> +
>> +	if (dp->usbpd->alt_mode_cfg_done)
>> +		dp_display_process_hpd_high(dp);
>> +end:
>> +	return rc;
>> +}
>> +
>> +static void dp_display_deinit_sub_modules(struct dp_display_private 
>> *dp)
>> +{
>> +	dp_ctrl_put(dp->ctrl);
>> +	dp_link_put(dp->link);
>> +	dp_panel_put(dp->panel);
>> +	dp_aux_put(dp->aux);
>> +	dp_power_put(dp->power);
>> +	dp_catalog_put(dp->catalog);
>> +	dp_parser_put(dp->parser);
>> +	dp_debug_put(dp->debug);
>> +}
>> +
>> +static int dp_init_sub_modules(struct dp_display_private *dp)
>> +{
>> +	int rc = 0;
>> +	struct device *dev = &dp->pdev->dev;
>> +	struct dp_usbpd_cb *cb = &dp->usbpd_cb;
>> +	struct dp_ctrl_in ctrl_in = {
>> +		.dev = dev,
>> +	};
>> +	struct dp_panel_in panel_in = {
>> +		.dev = dev,
>> +	};
>> +
>> +	/* Callback APIs used for cable status change event */
>> +	cb->configure  = dp_display_usbpd_configure_cb;
>> +	cb->disconnect = dp_display_usbpd_disconnect_cb;
>> +	cb->attention  = dp_display_usbpd_attention_cb;
>> +
>> +	dp->parser = dp_parser_get(dp->pdev);
>> +	if (IS_ERR(dp->parser)) {
>> +		rc = PTR_ERR(dp->parser);
>> +		pr_err("failed to initialize parser, rc = %d\n", rc);
>> +		dp->parser = NULL;
>> +		goto error_parser;
>> +	}
>> +
>> +	dp->catalog = dp_catalog_get(dev, &dp->parser->io);
>> +	if (IS_ERR(dp->catalog)) {
>> +		rc = PTR_ERR(dp->catalog);
>> +		pr_err("failed to initialize catalog, rc = %d\n", rc);
>> +		dp->catalog = NULL;
>> +		goto error_catalog;
>> +	}
>> +
>> +	dp->power = dp_power_get(dp->parser);
>> +	if (IS_ERR(dp->power)) {
>> +		rc = PTR_ERR(dp->power);
>> +		pr_err("failed to initialize power, rc = %d\n", rc);
>> +		dp->power = NULL;
>> +		goto error_power;
>> +	}
>> +
>> +	dp->aux = dp_aux_get(dev, &dp->catalog->aux, dp->parser->aux_cfg);
>> +	if (IS_ERR(dp->aux)) {
>> +		rc = PTR_ERR(dp->aux);
>> +		pr_err("failed to initialize aux, rc = %d\n", rc);
>> +		dp->aux = NULL;
>> +		goto error_aux;
>> +	}
>> +
>> +	dp->link = dp_link_get(dev, dp->aux);
>> +	if (IS_ERR(dp->link)) {
>> +		rc = PTR_ERR(dp->link);
>> +		pr_err("failed to initialize link, rc = %d\n", rc);
>> +		dp->link = NULL;
>> +		goto error_link;
>> +	}
>> +
>> +	panel_in.aux = dp->aux;
>> +	panel_in.catalog = &dp->catalog->panel;
>> +	panel_in.link = dp->link;
>> +
>> +	dp->panel = dp_panel_get(&panel_in);
>> +	if (IS_ERR(dp->panel)) {
>> +		rc = PTR_ERR(dp->panel);
>> +		pr_err("failed to initialize panel, rc = %d\n", rc);
>> +		dp->panel = NULL;
>> +		goto error_panel;
>> +	}
>> +
>> +	ctrl_in.link = dp->link;
>> +	ctrl_in.panel = dp->panel;
>> +	ctrl_in.aux = dp->aux;
>> +	ctrl_in.power = dp->power;
>> +	ctrl_in.catalog = &dp->catalog->ctrl;
>> +	ctrl_in.parser = dp->parser;
>> +
>> +	dp->ctrl = dp_ctrl_get(&ctrl_in);
>> +	if (IS_ERR(dp->ctrl)) {
>> +		rc = PTR_ERR(dp->ctrl);
>> +		pr_err("failed to initialize ctrl, rc = %d\n", rc);
>> +		dp->ctrl = NULL;
>> +		goto error_ctrl;
>> +	}
>> +
>> +	dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd,
>> +				dp->link, &dp->dp_display.connector);
>> +	if (IS_ERR(dp->debug)) {
>> +		rc = PTR_ERR(dp->debug);
>> +		pr_err("failed to initialize debug, rc = %d\n", rc);
>> +		dp->debug = NULL;
>> +		goto error_debug;
>> +	}
>> +
>> +	return rc;
>> +error_debug:
>> +	dp_ctrl_put(dp->ctrl);
>> +error_ctrl:
>> +	dp_panel_put(dp->panel);
>> +error_panel:
>> +	dp_link_put(dp->link);
>> +error_link:
>> +	dp_aux_put(dp->aux);
>> +error_aux:
>> +	dp_power_put(dp->power);
>> +error_power:
>> +	dp_catalog_put(dp->catalog);
>> +error_catalog:
>> +	dp_parser_put(dp->parser);
>> +error_parser:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_set_mode(struct msm_dp *dp_display,
>> +			       struct dp_display_mode *mode)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	dp->panel->pinfo = mode->timing;
>> +	dp->panel->init_info(dp->panel);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_prepare(struct msm_dp *dp)
>> +{
>> +	return 0;
>> +}
>> +
>> +static int dp_display_enable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp->power_on) {
>> +		pr_debug("Link already setup, return\n");
>> +		return 0;
>> +	}
>> +
>> +	dp->aux->init(dp->aux, dp->parser->aux_cfg);
>> +
>> +	rc = dp->ctrl->on(dp->ctrl);
>> +	if (!rc)
>> +		dp->power_on = true;
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_post_enable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	complete_all(&dp->notification_comp);
>> +
>> +end:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_pre_disable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp->usbpd->alt_mode_cfg_done && (dp->usbpd->hpd_high ||
>> +		dp->usbpd->forced_disconnect))
>> +		dp->link->psm_config(dp->link, &dp->panel->link_info, true);
>> +
>> +	dp->ctrl->push_idle(dp->ctrl);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_display_disable(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (!dp->power_on || !dp->core_initialized)
>> +		goto error;
>> +
>> +	dp->ctrl->off(dp->ctrl);
>> +
>> +	dp->power_on = false;
>> +
>> +	complete_all(&dp->notification_comp);
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_request_irq(struct msm_dp *dp_display)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0);
>> +	if (dp->irq < 0) {
>> +		rc = dp->irq;
>> +		pr_err("failed to get irq: %d\n", rc);
>> +		return rc;
>> +	}
>> +
>> +	rc = devm_request_irq(&dp->pdev->dev, dp->irq, dp_display_irq,
>> +		IRQF_TRIGGER_HIGH, "dp_display_isr", dp);
>> +	if (rc < 0) {
>> +		pr_err("failed to request IRQ%u: %d\n",
>> +				dp->irq, rc);
>> +		return rc;
>> +	}
>> +	disable_irq(dp->irq);
>> +
>> +	return 0;
>> +}
>> +
>> +static struct dp_debug *dp_get_debug(struct msm_dp *dp_display)
>> +{
>> +	struct dp_display_private *dp;
>> +
>> +	if (!dp_display) {
>> +		pr_err("invalid input\n");
>> +		return ERR_PTR(-EINVAL);
>> +	}
>> +
>> +	dp = container_of(dp_display, struct dp_display_private, 
>> dp_display);
>> +
>> +	return dp->debug;
>> +}
>> +
>> +static int dp_display_unprepare(struct msm_dp *dp)
>> +{
>> +	return 0;
>> +}
>> +
>> +static int dp_display_validate_mode(struct msm_dp *dp, u32 
>> mode_pclk_khz)
>> +{
>> +	const u32 num_components = 3, default_bpp = 24;
>> +	struct dp_display_private *dp_display;
>> +	struct drm_dp_link *link_info;
>> +	u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0;
>> +
>> +	if (!dp || !mode_pclk_khz || !dp->connector) {
>> +		pr_err("invalid params\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +	link_info = &dp_display->panel->link_info;
>> +
>> +	mode_bpp = dp->connector->display_info.bpc * num_components;
>> +	if (!mode_bpp)
>> +		mode_bpp = default_bpp;
>> +
>> +	mode_bpp = dp_display->panel->get_mode_bpp(dp_display->panel,
>> +			mode_bpp, mode_pclk_khz);
>> +
>> +	mode_rate_khz = mode_pclk_khz * mode_bpp;
>> +	supported_rate_khz = link_info->num_lanes * link_info->rate * 8;
>> +
>> +	if (mode_rate_khz > supported_rate_khz)
>> +		return MODE_BAD;
>> +
>> +	return MODE_OK;
>> +}
>> +
>> +static int dp_display_get_modes(struct msm_dp *dp,
>> +				struct dp_display_mode *dp_mode)
>> +{
>> +	struct dp_display_private *dp_display;
>> +	int ret = 0;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	ret = dp_display->panel->get_modes(dp_display->panel,
>> +		dp->connector, dp_mode);
>> +	if (dp_mode->timing.pixel_clk_khz)
>> +		dp->max_pclk_khz = dp_mode->timing.pixel_clk_khz;
>> +	return ret;
>> +}
>> +
>> +static bool dp_display_check_video_test(struct msm_dp *dp)
>> +{
>> +	struct dp_display_private *dp_display;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return false;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	if (dp_display->panel->video_test)
>> +		return true;
>> +
>> +	return false;
>> +}
>> +
>> +static int dp_display_get_test_bpp(struct msm_dp *dp)
>> +{
>> +	struct dp_display_private *dp_display;
>> +
>> +	if (!dp) {
>> +		pr_err("invalid params\n");
>> +		return 0;
>> +	}
>> +
>> +	dp_display = container_of(dp, struct dp_display_private, 
>> dp_display);
>> +
>> +	return dp_link_bit_depth_to_bpp(
>> +		dp_display->link->test_video.test_bit_depth);
>> +}
>> +
>> +static int dp_display_probe(struct platform_device *pdev)
>> +{
>> +	int rc = 0;
>> +	struct dp_display_private *dp;
>> +
>> +	if (!pdev || !pdev->dev.of_node) {
>> +		pr_err("pdev not found\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL);
>> +	if (!dp)
>> +		return -ENOMEM;
>> +
>> +	init_completion(&dp->notification_comp);
>> +
>> +	dp->pdev = pdev;
>> +	dp->name = "drm_dp";
>> +
>> +	rc = dp_init_sub_modules(dp);
>> +	if (rc) {
>> +		pr_err("init sub module failed\n");
>> +		devm_kfree(&pdev->dev, dp);
>> +		return -EPROBE_DEFER;
>> +	}
>> +
>> +	platform_set_drvdata(pdev, dp);
>> +
>> +	g_dp_display = &dp->dp_display;
>> +
>> +	g_dp_display->enable        = dp_display_enable;
>> +	g_dp_display->post_enable   = dp_display_post_enable;
>> +	g_dp_display->pre_disable   = dp_display_pre_disable;
>> +	g_dp_display->disable       = dp_display_disable;
>> +	g_dp_display->set_mode      = dp_display_set_mode;
>> +	g_dp_display->validate_mode = dp_display_validate_mode;
>> +	g_dp_display->get_modes     = dp_display_get_modes;
>> +	g_dp_display->prepare       = dp_display_prepare;
>> +	g_dp_display->unprepare     = dp_display_unprepare;
>> +	g_dp_display->request_irq   = dp_request_irq;
>> +	g_dp_display->get_debug     = dp_get_debug;
>> +	g_dp_display->send_hpd_event    = dp_display_send_hpd_event;
>> +	g_dp_display->is_video_test = dp_display_check_video_test;
>> +	g_dp_display->get_test_bpp = dp_display_get_test_bpp;
>> +
>> +	rc = component_add(&pdev->dev, &dp_display_comp_ops);
>> +	if (rc) {
>> +		pr_err("component add failed, rc=%d\n", rc);
>> +		dp_display_deinit_sub_modules(dp);
>> +		devm_kfree(&pdev->dev, dp);
>> +	}
>> +
>> +	return rc;
>> +}
>> +
>> +int dp_display_get_displays(void **displays, int count)
>> +{
>> +	if (!displays) {
>> +		pr_err("invalid data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (count != 1) {
>> +		pr_err("invalid number of displays\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	displays[0] = g_dp_display;
>> +	return count;
>> +}
>> +
>> +int dp_display_get_num_of_displays(void)
>> +{
>> +	return 1;
>> +}
> 
> These 2 functions are never used, and as such g_dp_display is never 
> used.
> AFAICT, the callback hooks linked from g_dp_display also aren't called 
> from
> anywhere else. So can you just dump these functions, the struct, and 
> all of the
> unused callback hooks?
> 
Fixed in V2.

>> +
>> +static int dp_display_remove(struct platform_device *pdev)
>> +{
>> +	struct dp_display_private *dp;
>> +
>> +	if (!pdev)
>> +		return -EINVAL;
>> +
>> +	dp = platform_get_drvdata(pdev);
>> +
>> +	dp_display_deinit_sub_modules(dp);
>> +
>> +	platform_set_drvdata(pdev, NULL);
>> +	devm_kfree(&pdev->dev, dp);
>> +
>> +	return 0;
>> +}
>> +
>> +static struct platform_driver dp_display_driver = {
>> +	.probe  = dp_display_probe,
>> +	.remove = dp_display_remove,
>> +	.driver = {
>> +		.name = "msm-dp-display",
>> +		.of_match_table = dp_dt_match,
>> +	},
>> +};
>> +
>> +int __init msm_dp_register(void)
>> +{
>> +	int ret;
>> +
>> +	ret = platform_driver_register(&dp_display_driver);
>> +	if (ret) {
>> +		pr_err("driver register failed");
>> +		return ret;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +void __exit msm_dp_unregister(void)
>> +{
>> +	platform_driver_unregister(&dp_display_driver);
>> +}
>> +
>> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device 
>> *dev,
>> +			struct drm_encoder *encoder)
> 
> Where is this called?
> 
this is called from dpu_kms.c.
https://patchwork.kernel.org/patch/10686905/
Will be adding the DPU specific change in this V3 patch series.

>> +{
>> +	struct msm_drm_private *priv;
>> +	int ret;
>> +
>> +	if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev))
>> +		return -EINVAL;
>> +
>> +	priv = dev->dev_private;
>> +	dp_display->drm_dev = dev;
>> +
>> +	ret = dp_drm_bridge_init(dp_display, encoder);
>> +	if (ret) {
>> +		dev_err(dev->dev, "failed to create dp bridge: %d\n", ret);
>> +		dp_display->bridge = NULL;
>> +		return ret;
>> +	}
>> +	dp_display->encoder = encoder;
>> +
>> +	dp_display->connector = dp_drm_connector_init(dp_display);
>> +	if (IS_ERR(dp_display->connector)) {
>> +		ret = PTR_ERR(dp_display->connector);
>> +		dev_err(dev->dev,
>> +			"failed to create dp connector: %d\n", ret);
>> +		dp_display->connector = NULL;
>> +		goto conn_fail;
>> +	}
>> +
>> +	priv->bridges[priv->num_bridges++] = dp_display->bridge;
>> +	priv->connectors[priv->num_connectors++] = dp_display->connector;
>> +	return 0;
>> +
>> +conn_fail:
>> +	if (dp_display->bridge) {
>> +		dp_drm_bridge_deinit(dp_display);
>> +		dp_display->bridge = NULL;
>> +	}
>> +	return ret;
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h 
>> b/drivers/gpu/drm/msm/dp/dp_display.h
>> new file mode 100644
>> index 0000000..ca5eae5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
>> @@ -0,0 +1,55 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_DISPLAY_H_
>> +#define _DP_DISPLAY_H_
>> +
>> +#include <drm/drmP.h>
>> +
>> +#include "dp_panel.h"
>> +
>> +struct msm_dp {
>> +	struct drm_device *drm_dev;
>> +	struct dp_bridge *dp_bridge;
>> +	struct drm_connector *connector;
>> +	struct drm_bridge *bridge;
>> +
>> +	/* the encoder we are hooked to (outside of dsi block) */
>> +	struct drm_encoder *encoder;
>> +	bool is_connected;
>> +	u32 max_pclk_khz;
>> +
>> +	int (*enable)(struct msm_dp *dp_display);
>> +	int (*post_enable)(struct msm_dp *dp_display);
>> +
>> +	int (*pre_disable)(struct msm_dp *dp_display);
>> +	int (*disable)(struct msm_dp *dp_display);
>> +
>> +	int (*set_mode)(struct msm_dp *dp_display,
>> +			struct dp_display_mode *mode);
>> +	int (*validate_mode)(struct msm_dp *dp_display, u32 mode_pclk_khz);
>> +	int (*get_modes)(struct msm_dp *dp_display,
>> +		struct dp_display_mode *dp_mode);
>> +	int (*prepare)(struct msm_dp *dp_display);
>> +	int (*unprepare)(struct msm_dp *dp_display);
>> +	int (*request_irq)(struct msm_dp *dp_display);
>> +	struct dp_debug *(*get_debug)(struct msm_dp *dp_display);
>> +	void (*send_hpd_event)(struct msm_dp *dp_display);
>> +	bool (*is_video_test)(struct msm_dp *dp_display);
>> +	int (*get_test_bpp)(struct msm_dp *dp_display);
>> +};
>> +
>> +int dp_display_get_num_of_displays(void);
>> +int dp_display_get_displays(void **displays, int count);
>> +#endif /* _DP_DISPLAY_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.c 
>> b/drivers/gpu/drm/msm/dp/dp_drm.c
>> new file mode 100644
>> index 0000000..64d6449
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_drm.c
>> @@ -0,0 +1,542 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp]: %s: " fmt, __func__
>> +
>> +#include <drm/drm_atomic_helper.h>
>> +#include <drm/drm_atomic.h>
>> +#include <drm/drm_crtc.h>
>> +
>> +#include "msm_drv.h"
>> +#include "msm_kms.h"
>> +//#include "dpu_connector.h"
>> +#include "dp_drm.h"
>> +#include "dp_debug.h"
>> +
>> +struct dp_connector {
>> +	struct drm_connector base;
>> +	struct msm_dp *dp_display;
>> +};
>> +#define to_dp_connector(x) container_of(x, struct dp_connector, base)
>> +#define to_dp_bridge(x)     container_of((x), struct dp_bridge, base)
>> +
>> +static void convert_to_dp_mode(const struct drm_display_mode 
>> *drm_mode,
>> +			struct dp_display_mode *dp_mode, struct msm_dp *dp)
>> +{
>> +	const u32 num_components = 3;
>> +
>> +	memset(dp_mode, 0, sizeof(*dp_mode));
>> +
>> +	dp_mode->timing.h_active = drm_mode->hdisplay;
>> +	dp_mode->timing.h_back_porch = drm_mode->htotal - 
>> drm_mode->hsync_end;
>> +	dp_mode->timing.h_sync_width = drm_mode->htotal -
>> +			(drm_mode->hsync_start + dp_mode->timing.h_back_porch);
>> +	dp_mode->timing.h_front_porch = drm_mode->hsync_start -
>> +					 drm_mode->hdisplay;
>> +	dp_mode->timing.h_skew = drm_mode->hskew;
>> +
>> +	dp_mode->timing.v_active = drm_mode->vdisplay;
>> +	dp_mode->timing.v_back_porch = drm_mode->vtotal - 
>> drm_mode->vsync_end;
>> +	dp_mode->timing.v_sync_width = drm_mode->vtotal -
>> +		(drm_mode->vsync_start + dp_mode->timing.v_back_porch);
>> +
>> +	dp_mode->timing.v_front_porch = drm_mode->vsync_start -
>> +					 drm_mode->vdisplay;
>> +
>> +	if (dp->is_video_test(dp))
>> +		dp_mode->timing.bpp = dp->get_test_bpp(dp);
>> +	else
>> +		dp_mode->timing.bpp = dp->connector->display_info.bpc *
>> +		num_components;
>> +
>> +	if (!dp_mode->timing.bpp)
>> +		dp_mode->timing.bpp = 24;
>> +
>> +	dp_mode->timing.refresh_rate = drm_mode->vrefresh;
>> +
>> +	dp_mode->timing.pixel_clk_khz = drm_mode->clock;
>> +
>> +	dp_mode->timing.v_active_low =
>> +		!!(drm_mode->flags & DRM_MODE_FLAG_NVSYNC);
>> +
>> +	dp_mode->timing.h_active_low =
>> +		!!(drm_mode->flags & DRM_MODE_FLAG_NHSYNC);
>> +}
>> +
>> +static void convert_to_drm_mode(const struct dp_display_mode 
>> *dp_mode,
>> +				struct drm_display_mode *drm_mode)
>> +{
>> +	u32 flags = 0;
>> +
>> +	memset(drm_mode, 0, sizeof(*drm_mode));
>> +
>> +	drm_mode->hdisplay = dp_mode->timing.h_active;
>> +	drm_mode->hsync_start = drm_mode->hdisplay +
>> +				dp_mode->timing.h_front_porch;
>> +	drm_mode->hsync_end = drm_mode->hsync_start +
>> +			      dp_mode->timing.h_sync_width;
>> +	drm_mode->htotal = drm_mode->hsync_end + 
>> dp_mode->timing.h_back_porch;
>> +	drm_mode->hskew = dp_mode->timing.h_skew;
>> +
>> +	drm_mode->vdisplay = dp_mode->timing.v_active;
>> +	drm_mode->vsync_start = drm_mode->vdisplay +
>> +				dp_mode->timing.v_front_porch;
>> +	drm_mode->vsync_end = drm_mode->vsync_start +
>> +			      dp_mode->timing.v_sync_width;
>> +	drm_mode->vtotal = drm_mode->vsync_end + 
>> dp_mode->timing.v_back_porch;
>> +
>> +	drm_mode->vrefresh = dp_mode->timing.refresh_rate;
>> +	drm_mode->clock = dp_mode->timing.pixel_clk_khz;
>> +
>> +	if (dp_mode->timing.h_active_low)
>> +		flags |= DRM_MODE_FLAG_NHSYNC;
>> +	else
>> +		flags |= DRM_MODE_FLAG_PHSYNC;
>> +
>> +	if (dp_mode->timing.v_active_low)
>> +		flags |= DRM_MODE_FLAG_NVSYNC;
>> +	else
>> +		flags |= DRM_MODE_FLAG_PVSYNC;
>> +
>> +	drm_mode->flags = flags;
>> +
>> +	drm_mode->type = 0x48;
>> +	drm_mode_set_name(drm_mode);
>> +}
> 
> Just use the drm modes directly and delete these functions.
> 
Fixed in V2.

>> +
>> +static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	/* By this point mode should have been validated through mode_fixup 
>> */
>> +	rc = dp->set_mode(dp, &bridge->dp_mode);
>> +	if (rc) {
>> +		pr_err("[%d] failed to perform a mode set, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->prepare(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display prepare failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->enable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display enable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		dp->unprepare(dp);
>> +	}
>> +}
>> +
>> +static void dp_bridge_enable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->post_enable(dp);
>> +	if (rc)
>> +		pr_err("[%d] DP display post enable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +}
>> +
>> +static void dp_bridge_disable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->pre_disable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display pre disable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +	}
>> +}
>> +
>> +static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	rc = dp->disable(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display disable failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +
>> +	rc = dp->unprepare(dp);
>> +	if (rc) {
>> +		pr_err("[%d] DP display unprepare failed, rc=%d\n",
>> +		       bridge->id, rc);
>> +		return;
>> +	}
>> +}
>> +
>> +static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
>> +				struct drm_display_mode *mode,
>> +				struct drm_display_mode *adjusted_mode)
>> +{
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge || !mode || !adjusted_mode) {
>> +		pr_err("Invalid params\n");
>> +		return;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
>> +	convert_to_dp_mode(adjusted_mode, &bridge->dp_mode, dp);
>> +}
>> +
>> +static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
>> +				  const struct drm_display_mode *mode,
>> +				  struct drm_display_mode *adjusted_mode)
>> +{
>> +	bool ret = true;
>> +	struct dp_display_mode dp_mode;
>> +	struct dp_bridge *bridge;
>> +	struct msm_dp *dp;
>> +
>> +	if (!drm_bridge || !mode || !adjusted_mode) {
>> +		pr_err("Invalid params\n");
>> +		ret = false;
>> +		goto end;
>> +	}
>> +
>> +	bridge = to_dp_bridge(drm_bridge);
>> +	dp = bridge->display;
>> +
>> +	convert_to_dp_mode(mode, &dp_mode, dp);
>> +	convert_to_drm_mode(&dp_mode, adjusted_mode);
>> +end:
>> +	return ret;
>> +}
>> +
>> +static const struct drm_bridge_funcs dp_bridge_ops = {
>> +	.mode_fixup   = dp_bridge_mode_fixup,
>> +	.pre_enable   = dp_bridge_pre_enable,
>> +	.enable       = dp_bridge_enable,
>> +	.disable      = dp_bridge_disable,
>> +	.post_disable = dp_bridge_post_disable,
>> +	.mode_set     = dp_bridge_mode_set,
>> +};
> 
> I'm not convinced you need any of this. The only advantage a bridge 
> gets you is
> to be involved in modeset. However the only thing you do in modeset is 
> save the
> mode (which is only used in enable). So why not just use the mode from 
> the
> crtc's state when encoder->enable is called?
> 
> That allows you to delete all of the bridge stuff here.
> 
Fixed in V2.

>> +
>> +int dp_connector_post_init(struct drm_connector *connector, void 
>> *display)
>> +{
>> +	struct msm_dp *dp_display = display;
>> +
>> +	if (!dp_display)
>> +		return -EINVAL;
>> +
>> +	dp_display->connector = connector;
>> +	return 0;
>> +}
> 
> This isn't called from anything?
> 
Fixed in V2.

>> +
>> +/**
>> + * dp_connector_detect - callback to determine if connector is 
>> connected
>> + * @connector: Pointer to drm connector structure
>> + * @force: Force detect setting from drm framework
>> + * Returns: Connector 'is connected' status
>> + */
>> +static enum drm_connector_status dp_connector_detect(struct 
>> drm_connector *conn,
>> +		bool force)
>> +{
>> +	enum drm_connector_status status = connector_status_unknown;
>> +	static enum drm_connector_status current_status = 
>> connector_status_unknown;
>> +	struct msm_dp *dp;
>> +	struct dp_connector *dp_conn;
>> +	struct msm_drm_private *priv = conn->dev->dev_private;
>> +	struct msm_kms *kms = priv->kms;
>> +
>> +	dp_conn = to_dp_connector(conn);
>> +	dp = dp_conn->dp_display;
> 
> no need for dp_conn, just do
> 
>         dp = to_dp_connector(conn)->dp_display;
> 
Will fix this in V3.

>> +
>> +	pr_err("is_connected = %s\n",
>> +		(dp->is_connected) ? "true" : "false");
>> +
>> +	status = (dp->is_connected) ? connector_status_connected :
>> +					connector_status_disconnected;
>> +
>> +	if (dp->is_connected && dp->bridge->encoder
>> +				&& (current_status != status)
> 
> This is always true.
> 
removed the bridge->encoder check in V2.

>> +				&& kms->funcs->set_encoder_mode) {
>> +		kms->funcs->set_encoder_mode(kms,
>> +				dp->bridge->encoder, false);
>> +		pr_err("call set_encoder_mode\n");
> 
> detect() should never do work, please remove.
> 
Had this fixed locally but some how missed these fixes in V2. Will add 
the missing fixes
in V3. Same think with current_status.

>> +	}
>> +	current_status = status;
> 
> Why?
> 
>> +	return status;
>> +}
>> +
>> +static void dp_connector_destroy(struct drm_connector *connector)
>> +{
>> +	struct dp_connector *dp_conn = to_dp_connector(connector);
>> +
>> +	DBG("");
>> +
>> +	drm_connector_cleanup(connector);
>> +
>> +	kfree(dp_conn);
> 
> Once dp_conn is devm managed, you can just remove this function and set 
> .destroy
> to drm_connector_cleanup
> 
Fixed in V2.

>> +}
>> +
>> +void dp_connector_send_hpd_event(void *display)
> 
> Where is this called?
> 
Fixed in V2.

>> +{
>> +	struct msm_dp *dp;
>> +
>> +	if (!display) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	dp = display;
>> +
>> +	if (dp->send_hpd_event)
>> +		dp->send_hpd_event(dp);
>> +}
>> +
>> +/**
>> + * dp_connector_get_modes - callback to add drm modes via 
>> drm_mode_probed_add()
>> + * @connector: Pointer to drm connector structure
>> + * Returns: Number of modes added
>> + */
>> +static int dp_connector_get_modes(struct drm_connector *connector)
>> +{
>> +	int rc = 0;
>> +	struct msm_dp *dp;
>> +	struct dp_display_mode *dp_mode = NULL;
>> +	struct drm_display_mode *m, drm_mode;
>> +	struct dp_connector *dp_conn;
>> +
>> +	if (!connector)
>> +		return 0;
>> +
>> +	dp_conn = to_dp_connector(connector);
>> +	dp = dp_conn->dp_display;
>> +
>> +	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
>> +	if (!dp_mode)
>> +		return 0;
> 
> When you get rid of dp_display_mode, please use the stack for the new
> drm_display_mode
> 
Fixed in V2.

>> +
>> +	/* pluggable case assumes EDID is read when HPD */
>> +	if (dp->is_connected) {
>> +		rc = dp->get_modes(dp, dp_mode);
> 
> Why is only one mode returned?
> 
The get_modes() function might return one mode that is stored
in dp_mode when compliance test is in progress. If not, the
return value is equal to the total number of modes supported
by the sink

>> +		if (!rc)
> 
> This can also return -errno, you should check for that too.
> 
Fixed in V2.

>> +			pr_err("failed to get DP sink modes, rc=%d\n", rc);
> 
> Why continue if you know you failed?
> 
>> +
>> +		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
>> +			memset(&drm_mode, 0x0, sizeof(drm_mode));
>> +			convert_to_drm_mode(dp_mode, &drm_mode);
>> +			m = drm_mode_duplicate(connector->dev, &drm_mode);
>> +			if (!m) {
>> +				pr_err("failed to add mode %ux%u\n",
>> +				       drm_mode.hdisplay,
>> +				       drm_mode.vdisplay);
>> +				kfree(dp_mode);
>> +				return 0;
>> +			}
>> +			m->width_mm = connector->display_info.width_mm;
>> +			m->height_mm = connector->display_info.height_mm;
> 
> You shouldn't overwrite these.
> 
Fixed in V2.

>> +			drm_mode_probed_add(connector, m);
>> +		}
>> +	} else {
>> +		pr_err("No sink connected\n");
> 
> This shouldn't be an error
> 
Fixed in V2.

>> +	}
>> +	kfree(dp_mode);
>> +
>> +	return rc;
>> +}
>> +
>> +int dp_drm_bridge_init(void *data, struct drm_encoder *encoder)
>> +{
>> +	int rc = 0;
>> +	struct dp_bridge *dp_bridge;
>> +	struct drm_device *dev;
>> +	struct msm_dp *dp_display = data;
>> +	struct msm_drm_private *priv = NULL;
>> +
>> +	dp_bridge = kzalloc(sizeof(*dp_bridge), GFP_KERNEL);
>> +	if (!dp_bridge) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	dev = dp_display->drm_dev;
>> +	dp_bridge->display = dp_display;
>> +	dp_bridge->base.funcs = &dp_bridge_ops;
>> +	dp_bridge->base.encoder = encoder;
>> +
>> +	priv = dev->dev_private;
>> +
>> +	rc = drm_bridge_attach(encoder, &dp_bridge->base, NULL);
>> +	if (rc) {
>> +		pr_err("failed to attach bridge, rc=%d\n", rc);
>> +		goto error_free_bridge;
>> +	}
>> +
>> +	rc = dp_display->request_irq(dp_display);
>> +	if (rc) {
>> +		pr_err("request_irq failed, rc=%d\n", rc);
>> +		goto error_free_bridge;
>> +	}
>> +
>> +	encoder->bridge = &dp_bridge->base;
>> +	dp_display->dp_bridge = dp_bridge;
>> +	dp_display->bridge = &dp_bridge->base;
>> +
>> +	return 0;
>> +error_free_bridge:
>> +	kfree(dp_bridge);
>> +error:
>> +	return rc;
>> +}
>> +
>> +void dp_drm_bridge_deinit(void *data)
>> +{
>> +	struct msm_dp *display = data;
>> +	struct dp_bridge *bridge = display->dp_bridge;
>> +
>> +	if (bridge && bridge->base.encoder)
>> +		bridge->base.encoder->bridge = NULL;
>> +
>> +	kfree(bridge);
>> +}
>> +
>> +/**
>> + * dp_connector_mode_valid - callback to determine if specified mode 
>> is valid
>> + * @connector: Pointer to drm connector structure
>> + * @mode: Pointer to drm mode structure
>> + * Returns: Validity status for specified mode
>> + */
>> +static enum drm_mode_status dp_connector_mode_valid(struct 
>> drm_connector *connector,
>> +		struct drm_display_mode *mode)
>> +{
>> +	struct msm_dp *dp_disp;
>> +	struct dp_debug *debug;
>> +	struct dp_connector *dp_conn;
>> +
>> +	if (!mode || !connector) {
>> +		pr_err("invalid params\n");
>> +		return MODE_ERROR;
>> +	}
>> +
>> +	dp_conn = to_dp_connector(connector);
>> +	dp_disp = dp_conn->dp_display;
>> +	debug = dp_disp->get_debug(dp_disp);
>> +
>> +	mode->vrefresh = drm_mode_vrefresh(mode);
>> +
>> +	if (mode->clock > dp_disp->max_pclk_khz)
> 
> I think the value of max_pclk_khz is racy, you'll probably want to 
> audit its
> use.
> 
> 
Fixed in V2.
>> +		return MODE_BAD;
>> +
>> +	if (debug->debug_en && (mode->hdisplay != debug->hdisplay ||
>> +			mode->vdisplay != debug->vdisplay ||
>> +			mode->vrefresh != debug->vrefresh ||
>> +			mode->picture_aspect_ratio != debug->aspect_ratio))
>> +		return MODE_BAD;
> 
> Please drop this.
> 
Fixed in v2.
>> +
>> +	return dp_disp->validate_mode(dp_disp, mode->clock);
> 
> So I guess I was wrong when I said none of the g_dp_display functions 
> are being
> used. I'm still unsure where they're set, perhaps there's some missing 
> code. At
> any rate, what's the benefit of sticking all of that work into an 
> abstract
> callback hook when it only has one implementation and one callsite.
> 
g_dp_display is initialized in dp_display.c
We are calling the APIs directly in V2.

> All of that code can move in here (and the same goes for the other 
> callbacks
> (move the code where it's used).
> 
>> +}
>> +
>> +static const struct drm_connector_funcs dp_connector_funcs = {
>> +	.detect = dp_connector_detect,
>> +	.fill_modes = drm_helper_probe_single_connector_modes,
>> +	.destroy = dp_connector_destroy,
>> +	.reset = drm_atomic_helper_connector_reset,
>> +	.atomic_duplicate_state = 
>> drm_atomic_helper_connector_duplicate_state,
>> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
>> +};
>> +
>> +static const struct drm_connector_helper_funcs 
>> dp_connector_helper_funcs = {
>> +	.get_modes = dp_connector_get_modes,
>> +	.mode_valid = dp_connector_mode_valid,
>> +};
>> +
>> +/* connector initialization */
>> +struct drm_connector *dp_drm_connector_init(struct msm_dp 
>> *dp_display)
>> +{
>> +	struct drm_connector *connector = NULL;
>> +	struct dp_connector *dp_connector;
>> +	int ret;
>> +
>> +	dp_connector = kzalloc(sizeof(*dp_connector), GFP_KERNEL);
> 
> Use devm_kzalloc (you've already got a memory leak if 
> drm_connector_init fails
> below).
> 
Fixed in V2.

>> +	if (!dp_connector)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	dp_connector->dp_display = dp_display;
>> +
>> +	connector = &dp_connector->base;
>> +
>> +	ret = drm_connector_init(dp_display->drm_dev, connector, 
>> &dp_connector_funcs,
>> +			DRM_MODE_CONNECTOR_DisplayPort);
>> +	if (ret)
>> +		return ERR_PTR(ret);
>> +
>> +	drm_connector_helper_add(connector, &dp_connector_helper_funcs);
>> +
>> +	/*
>> +	 * Enable HPD to let hpd event is handled
>> +	 * when cable is attached to the host.
> 
> These lines don't extend to 80 chars
> 
>> +	 */
>> +	connector->polled = DRM_CONNECTOR_POLL_HPD;
>> +
>> +	/* Display driver doesn't support interlace now. */
>> +	connector->interlace_allowed = false;
>> +	connector->doublescan_allowed = false;
> 
> These are already false by virtue of kzalloc
> 
Fixed in V2.

>> +
>> +	drm_connector_attach_encoder(connector, dp_display->encoder);
>> +
>> +	return connector;
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_drm.h 
>> b/drivers/gpu/drm/msm/dp/dp_drm.h
>> new file mode 100644
>> index 0000000..efbc1be
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_drm.h
>> @@ -0,0 +1,52 @@
>> +/*
>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_DRM_H_
>> +#define _DP_DRM_H_
>> +
>> +#include <linux/types.h>
>> +#include <drm/drmP.h>
>> +#include <drm/drm_crtc.h>
>> +#include <drm/drm_crtc_helper.h>
>> +
>> +#include "msm_drv.h"
>> +#include "dp_display.h"
>> +
>> +struct dp_bridge {
>> +	struct drm_bridge base;
>> +	u32 id;
>> +
>> +	struct msm_dp *display;
>> +	struct dp_display_mode dp_mode;
>> +};
>> +
>> +/**
>> + * dp_connector_post_init - callback to perform additional 
>> initialization steps
>> + * @connector: Pointer to drm connector structure
>> + * @display: Pointer to private display handle
>> + * Returns: Zero on success
>> + */
>> +int dp_connector_post_init(struct drm_connector *connector, void 
>> *display);
>> +
>> +void dp_connector_send_hpd_event(void *display);
>> +
>> +int dp_drm_bridge_init(void *display,
>> +	struct drm_encoder *encoder);
>> +
>> +void dp_drm_bridge_deinit(void *display);
>> +
>> +struct drm_connector *dp_drm_connector_init(struct msm_dp 
>> *dp_display);
>> +
>> +#endif /* _DP_DRM_H_ */
>> +
>> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.c 
>> b/drivers/gpu/drm/msm/dp/dp_extcon.c
>> new file mode 100644
>> index 0000000..635c13b
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.c
>> @@ -0,0 +1,400 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/slab.h>
>> +#include <linux/device.h>
>> +#include <linux/extcon.h>
>> +
>> +#include "dp_extcon.h"
>> +
>> +/* DP specific VDM commands */
>> +#define DP_USBPD_VDM_STATUS	0x10
>> +#define DP_USBPD_VDM_CONFIGURE	0x11
>> +
>> +/* USBPD-TypeC specific Macros */
>> +#define VDM_VERSION		0x0
>> +#define USB_C_DP_SID		0xFF01
>> +
>> +enum dp_usbpd_pin_assignment {
>> +	DP_USBPD_PIN_A,
>> +	DP_USBPD_PIN_B,
>> +	DP_USBPD_PIN_C,
>> +	DP_USBPD_PIN_D,
>> +	DP_USBPD_PIN_E,
>> +	DP_USBPD_PIN_F,
>> +	DP_USBPD_PIN_MAX,
>> +};
>> +
>> +struct dp_usbpd_capabilities {
>> +	enum dp_usbpd_port port;
>> +	bool receptacle_state;
>> +	u8 ulink_pin_config;
>> +	u8 dlink_pin_config;
>> +};
> 
> Where is this used?
> 
Fixed in V2.
>> +
>> +struct dp_extcon_private {
>> +	u32 vdo;
>> +	struct device *dev;
>> +	struct notifier_block extcon_nb;
>> +	struct extcon_dev *extcon;
>> +	struct workqueue_struct *extcon_wq;
>> +	struct work_struct event_work;
>> +	struct usbpd *pd;
>> +	struct dp_usbpd_cb *dp_cb;
>> +	struct dp_usbpd_capabilities cap;
>> +	struct dp_usbpd dp_usbpd;
>> +};
>> +
>> +static const char *dp_usbpd_pin_name(u8 pin)
>> +{
>> +	switch (pin) {
>> +	case DP_USBPD_PIN_A: return "DP_USBPD_PIN_ASSIGNMENT_A";
>> +	case DP_USBPD_PIN_B: return "DP_USBPD_PIN_ASSIGNMENT_B";
>> +	case DP_USBPD_PIN_C: return "DP_USBPD_PIN_ASSIGNMENT_C";
>> +	case DP_USBPD_PIN_D: return "DP_USBPD_PIN_ASSIGNMENT_D";
>> +	case DP_USBPD_PIN_E: return "DP_USBPD_PIN_ASSIGNMENT_E";
>> +	case DP_USBPD_PIN_F: return "DP_USBPD_PIN_ASSIGNMENT_F";
>> +	default: return "UNKNOWN";
>> +	}
>> +}
> 
> No need to have this just for one debug statement, just print the enum 
> value
> with %d below.
> 
Removed them in V2.
>> +
>> +static const char *dp_usbpd_port_name(enum dp_usbpd_port port)
>> +{
>> +	switch (port) {
>> +	case DP_USBPD_PORT_NONE: return "DP_USBPD_PORT_NONE";
>> +	case DP_USBPD_PORT_UFP_D: return "DP_USBPD_PORT_UFP_D";
>> +	case DP_USBPD_PORT_DFP_D: return "DP_USBPD_PORT_DFP_D";
>> +	case DP_USBPD_PORT_D_UFP_D: return "DP_USBPD_PORT_D_UFP_D";
>> +	default: return "DP_USBPD_PORT_NONE";
>> +	}
>> +}
> 
> Same here.
> 
Most of these static functions (usbpd)have been removed in V2.

>> +
>> +static void dp_usbpd_init_port(enum dp_usbpd_port *port, u32 in_port)
>> +{
>> +	switch (in_port) {
>> +	case 0:
>> +		*port = DP_USBPD_PORT_NONE;
>> +		break;
>> +	case 1:
>> +		*port = DP_USBPD_PORT_UFP_D;
>> +		break;
>> +	case 2:
>> +		*port = DP_USBPD_PORT_DFP_D;
>> +		break;
>> +	case 3:
>> +		*port = DP_USBPD_PORT_D_UFP_D;
>> +		break;
>> +	default:
>> +		*port = DP_USBPD_PORT_NONE;
>> +	}
>> +	pr_debug("port:%s\n", dp_usbpd_port_name(*port));
>> +}
>> +
>> +void dp_usbpd_get_capabilities(struct dp_extcon_private *pd)
> 
> Where is this called from?
> 
Removed in V2.

>> +{
>> +	struct dp_usbpd_capabilities *cap = &pd->cap;
>> +	u32 buf = pd->vdo;
>> +	int port = buf & 0x3;
>> +
>> +	cap->receptacle_state = (buf & BIT(6)) ? true : false;
>> +	cap->dlink_pin_config = (buf >> 8) & 0xff;
>> +	cap->ulink_pin_config = (buf >> 16) & 0xff;
> 
> Please #define hardcoded values
> 
>> +
>> +	dp_usbpd_init_port(&cap->port, port);
> 
> All of the values in cap->port seem to be hardcoded, so why not just 
> use the
> #define's directly where applicable?
> 
>> +}
>> +
>> +void dp_usbpd_get_status(struct dp_extcon_private *pd)
> 
> Where is this called?
> 
Removed in v2.
>> +{
>> +	struct dp_usbpd *status = &pd->dp_usbpd;
>> +	u32 buf = pd->vdo;
>> +	int port = buf & 0x3;
>> +
>> +	status->low_pow_st     = (buf & BIT(2)) ? true : false;
>> +	status->adaptor_dp_en  = (buf & BIT(3)) ? true : false;
>> +	status->multi_func     = (buf & BIT(4)) ? true : false;
>> +	status->usb_config_req = (buf & BIT(5)) ? true : false;
>> +	status->exit_dp_mode   = (buf & BIT(6)) ? true : false;
>> +	status->hpd_high       = (buf & BIT(7)) ? true : false;
>> +	status->hpd_irq        = (buf & BIT(8)) ? true : false;
>> +
>> +	pr_debug("low_pow_st = %d, adaptor_dp_en = %d, multi_func = %d\n",
>> +			status->low_pow_st, status->adaptor_dp_en,
>> +			status->multi_func);
>> +	pr_debug("usb_config_req = %d, exit_dp_mode = %d, hpd_high =%d\n",
>> +			status->usb_config_req,
>> +			status->exit_dp_mode, status->hpd_high);
>> +	pr_debug("hpd_irq = %d\n", status->hpd_irq);
>> +
>> +	dp_usbpd_init_port(&status->port, port);
> 
> Only multi_func, hpd_high, and hpd_irq are used out of this struct. Can 
> you cull
> the values down? hpd_irq is also only set to its hardcoded value, so 
> just use
> that value directly where applicable.
> 
> 
>> +}
>> +
>> +u32 dp_usbpd_gen_config_pkt(struct dp_extcon_private *pd)
> 
> This function is also unused
> 
Removed in V2.
>> +{
>> +	u8 pin_cfg, pin;
>> +	u32 config = 0;
>> +	const u32 ufp_d_config = 0x2, dp_ver = 0x1;
>> +
>> +	if (pd->cap.receptacle_state)
>> +		pin_cfg = pd->cap.ulink_pin_config;
>> +	else
>> +		pin_cfg = pd->cap.dlink_pin_config;
>> +
>> +	for (pin = DP_USBPD_PIN_A; pin < DP_USBPD_PIN_MAX; pin++) {
>> +		if (pin_cfg & BIT(pin)) {
>> +			if (pd->dp_usbpd.multi_func) {
>> +				if (pin == DP_USBPD_PIN_D)
>> +					break;
>> +			} else {
>> +				break;
>> +			}
>> +		}
>> +	}
>> +
>> +	if (pin == DP_USBPD_PIN_MAX)
>> +		pin = DP_USBPD_PIN_C;
>> +
>> +	pr_debug("pin assignment: %s\n", dp_usbpd_pin_name(pin));
>> +
>> +	config |= BIT(pin) << 8;
>> +
>> +	config |= (dp_ver << 2);
>> +	config |= ufp_d_config;
>> +
>> +	pr_debug("config = 0x%x\n", config);
>> +	return config;
>> +}
>> +
>> +static int dp_extcon_connect(struct dp_usbpd *dp_usbpd, bool hpd)
>> +{
>> +	int rc = 0;
>> +	struct dp_extcon_private *extcon;
>> +
>> +	if (!dp_usbpd) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
> 
> Just return -EINVAL and get rid of the error label and rc.
> 
fixed in V2.

>> +	}
>> +
>> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
>> +
>> +	dp_usbpd->hpd_high = hpd;
>> +	dp_usbpd->forced_disconnect = !hpd;
> 
> If forced_disconnect is always !dp_usbpd->hpd_high, why not just use
> !dp_usbpd->hpd_high directly?
> 
Will fix this in V3.
>> +
>> +	if (hpd)
>> +		extcon->dp_cb->configure(extcon->dev);
>> +	else
>> +		extcon->dp_cb->disconnect(extcon->dev);
> 
> Do you need locking in this function/file?
> 
I don't think so, This function is called by single threaded work queue.
>> +
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_extcon_get_lanes(struct dp_extcon_private *extcon_priv)
>> +{
>> +	union extcon_property_value property;
>> +	u8 lanes;
>> +
>> +	if (!extcon_priv || !extcon_priv->extcon) {
>> +		pr_err("Invalid input arguments\n");
>> +		return 0;
>> +	}
>> +
>> +	extcon_get_property(extcon_priv->extcon,
>> +					EXTCON_DISP_DP,
>> +					EXTCON_PROP_USB_SS,
>> +					&property);
>> +	lanes = ();
>> +
>> +	return lanes;
> 
>         return (property.intval) ? 2 : 4;
> 
> and delete lanes
> 
> 
Fixed in V2.

>> +}
>> +
>> +
>> +static void dp_extcon_event_work(struct work_struct *work)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +	int dp_state, ret;
>> +	int lanes;
>> +	union extcon_property_value property;
>> +
>> +	extcon_priv = container_of(work,
>> +			struct dp_extcon_private, event_work);
>> +
>> +	if (!extcon_priv || !extcon_priv->extcon) {
>> +		pr_err("Invalid extcon device handler\n");
>> +		return;
>> +	}
>> +
>> +	dp_state = extcon_get_state(extcon_priv->extcon,
>> +						EXTCON_DISP_DP);
> 
> Can fit on 1 line
> 
Fixed in V2.

>> +
>> +	if (dp_state > 0) {
>> +		ret = extcon_get_property(extcon_priv->extcon,
>> +					EXTCON_DISP_DP,
>> +					EXTCON_PROP_USB_TYPEC_POLARITY,
>> +					&property);
>> +		if (ret) {
>> +			pr_err("Get Polarity property failed\n");
>> +			return;
>> +		}
>> +		extcon_priv->dp_usbpd.orientation =
>> +			((property.intval) ?
> 
> Can fit on 1 line, plus remove all () from this, they're not needed.
> 
Fixed in V2.

>> +				ORIENTATION_CC2 : ORIENTATION_CC1);
>> +
>> +		lanes = dp_extcon_get_lanes(extcon_priv);
>> +		if (!lanes)
>> +			return;
>> +		extcon_priv->dp_usbpd.multi_func =
>> +					((lanes == 2) ? false : true);
> 
> This part is a bit confusing, you add a helper function to get the 
> lanes, and
> interpret the USB_SS property to return 2 vs. 4, but then immediately 
> convert
> that back into what the USB_SS property returns. Instead, remove the 
> helper
> function and read USB_SS directly here.
> 
Will implement this in V3.


>> +
>> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->configure)
> 
> I feel like this can never be false anyways, but you're not using 
> either of
> these members in the conditional block. So why not just call 
> dp_extcon_connect
> unconditionally?
> 
Will implement this in V3.

>> +			dp_extcon_connect(&extcon_priv->dp_usbpd, true);
> 
> Check return value
> 
Fixed in v2.
>> +	} else {
>> +		if (extcon_priv->dp_cb && extcon_priv->dp_cb->disconnect)
> 
> Same here.
> 
>> +			dp_extcon_connect(&extcon_priv->dp_usbpd, false);
> 
> Check return value
> 
Fixed in V2.

>> +	}
>> +}
>> +
>> +static int dp_extcon_create_workqueue(struct dp_extcon_private 
>> *extcon_priv)
>> +{
>> +	extcon_priv->extcon_wq = 
>> create_singlethread_workqueue("drm_dp_extcon");
> 
> What's the benefit of using a dedicated workqueue instead of the system 
> wq?
> 
We wanted to have a single-threaded workqueue to avoid any 
synchronization issues.
Also, following the existing implementation in upstream drivers for 
extcon events.

>> +	if (IS_ERR_OR_NULL(extcon_priv->extcon_wq)) {
>> +		pr_err("Error creating extcon wq\n");
>> +		return -EPERM;
>> +	}
>> +
>> +	INIT_WORK(&extcon_priv->event_work, dp_extcon_event_work);
>> +
>> +	return 0;
> 
> This function can't fail, so it should return void. In fact, this 
> really doesn't
> need to be a separate function, roll it into dp_extcon_register().
> 
Fixed in V2.

>> +}
>> +
>> +static int dp_extcon_event_notify(struct notifier_block *nb,
>> +				  unsigned long event, void *priv)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +
>> +	extcon_priv = container_of(nb, struct dp_extcon_private,
>> +						extcon_nb);
>> +
>> +	queue_work(extcon_priv->extcon_wq, &extcon_priv->event_work);
>> +	return NOTIFY_DONE;
>> +}
>> +
>> +int dp_extcon_register(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +	int ret = 0;
>> +
>> +	if (!dp_usbpd)
>> +		return -EINVAL;
>> +
>> +	pr_err("Start++++");
> 
> Yikes, this doesn't look like an error!
> 
Fixed in V2.

>> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, 
>> dp_usbpd);
>> +
>> +	extcon_priv->extcon_nb.notifier_call = dp_extcon_event_notify;
>> +	ret = devm_extcon_register_notifier(extcon_priv->dev, 
>> extcon_priv->extcon,
>> +					    EXTCON_DISP_DP,
>> +					    &extcon_priv->extcon_nb);
>> +	if (ret) {
>> +		dev_err(extcon_priv->dev,
>> +			"register EXTCON_DISP_DP notifier err\n");
>> +		ret = -EINVAL;
> 
> Why keep going and create the workqueue if we have no notifier? This 
> should
> probably be a return.
> 
Fixed in V2.

>> +	}
>> +
>> +	ret = dp_extcon_create_workqueue(extcon_priv);
>> +	if (ret) {
>> +		pr_err("Failed to create workqueue\n");
>> +		dp_extcon_unregister(dp_usbpd);
> 
> return ret?
> 
Fixed in V2.
>> +	}
>> +
>> +	pr_err("End----");
> 
> Same here
> 
Fixed in V2.
>> +	return ret;
>> +}
>> +
>> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon_priv;
>> +
>> +	if (!dp_usbpd) {
>> +		pr_err("Invalid input\n");
>> +		return;
>> +	}
>> +
>> +	pr_err("Start++++");
> 
> remove.
> 
Fixed in V2.

>> +	extcon_priv = container_of(dp_usbpd, struct dp_extcon_private, 
>> dp_usbpd);
>> +
>> +	devm_extcon_unregister_notifier(extcon_priv->dev, 
>> extcon_priv->extcon,
>> +					    EXTCON_DISP_DP,
>> +					    &extcon_priv->extcon_nb);
>> +
>> +	if (extcon_priv->extcon_wq)
>> +		destroy_workqueue(extcon_priv->extcon_wq);
>> +
>> +	pr_err("End----");
> 
> remove.
> 
Fixed in V2.

>> +	return;
>> +}
>> +
>> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb 
>> *cb)
>> +{
>> +	int rc = 0;
>> +	struct dp_extcon_private *dp_extcon;
>> +	struct dp_usbpd *dp_usbpd;
>> +
>> +	if (!cb) {
>> +		pr_err("invalid cb data\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	pr_err("%s: Start", __func__);
> 
> remove.
> 
All the unnecessary printed added for debugging are removed in V2.

>> +	dp_extcon = devm_kzalloc(dev, sizeof(*dp_extcon), GFP_KERNEL);
>> +	if (!dp_extcon) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	dp_extcon->extcon = extcon_get_edev_by_phandle(dev, 0);
>> +	if (!dp_extcon->extcon) {
>> +		pr_err("invalid extcon data\n");
>> +		rc = -EINVAL;
>> +		devm_kfree(dev, dp_extcon);
>> +		goto error;
>> +        }
>> +
>> +	dp_extcon->dev = dev;
>> +	dp_extcon->dp_cb = cb;
>> +
>> +	dp_extcon->dp_usbpd.connect = dp_extcon_connect;
>> +	dp_usbpd = &dp_extcon->dp_usbpd;
>> +
>> +	pr_err("%s: end", __func__);
> 
> remove.
> 
>> +	return dp_usbpd;
>> +error:
> 
> This label isn't useful, return directly where applicable.
> 
Removed in V2.

>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_extcon_put(struct dp_usbpd *dp_usbpd)
>> +{
>> +	struct dp_extcon_private *extcon;
>> +
>> +	if (!dp_usbpd)
>> +		return;
>> +
>> +	extcon = container_of(dp_usbpd, struct dp_extcon_private, dp_usbpd);
>> +
>> +	devm_kfree(extcon->dev, extcon);
>> +
>> +	pr_err("%s: end", __func__);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_extcon.h 
>> b/drivers/gpu/drm/msm/dp/dp_extcon.h
>> new file mode 100644
>> index 0000000..1f83a18
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_extcon.h
>> @@ -0,0 +1,111 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_EXTCON_H_
>> +#define _DP_EXTCON_H_
>> +
>> +//#include <linux/usb/usbpd.h>
>> +
>> +#include <linux/types.h>
>> +#include <linux/device.h>
>> +
>> +/**
>> + * enum dp_usbpd_port - usb/dp port type
>> + * @DP_USBPD_PORT_NONE: port not configured
>> + * @DP_USBPD_PORT_UFP_D: Upstream Facing Port - DisplayPort
>> + * @DP_USBPD_PORT_DFP_D: Downstream Facing Port - DisplayPort
>> + * @DP_USBPD_PORT_D_UFP_D: Both UFP & DFP - DisplayPort
>> + */
>> +
>> +enum dp_usbpd_port {
>> +	DP_USBPD_PORT_NONE,
>> +	DP_USBPD_PORT_UFP_D,
>> +	DP_USBPD_PORT_DFP_D,
>> +	DP_USBPD_PORT_D_UFP_D,
>> +};
>> +
>> +enum plug_orientation {
>> +	ORIENTATION_NONE,
>> +	ORIENTATION_CC1,
>> +	ORIENTATION_CC2,
>> +};
>> +
>> +/**
>> + * struct dp_usbpd - DisplayPort status
>> + *
>> + * @port: port configured
>> + * orientation: plug orientation configuration
>> + * @low_pow_st: low power state
>> + * @adaptor_dp_en: adaptor functionality enabled
>> + * @multi_func: multi-function preferred
>> + * @usb_config_req: request to switch to usb
>> + * @exit_dp_mode: request exit from displayport mode
>> + * @hpd_high: Hot Plug Detect signal is high.
>> + * @hpd_irq: Change in the status since last message
>> + * @alt_mode_cfg_done: bool to specify alt mode status
>> + * @debug_en: bool to specify debug mode
>> + * @connect: simulate disconnect or connect for debug mode
>> + */
>> +struct dp_usbpd {
>> +	enum dp_usbpd_port port;
>> +	enum plug_orientation orientation;
>> +	bool low_pow_st;
>> +	bool adaptor_dp_en;
>> +	bool multi_func;
>> +	bool usb_config_req;
>> +	bool exit_dp_mode;
>> +	bool hpd_high;
>> +	bool hpd_irq;
>> +	bool alt_mode_cfg_done;
>> +	bool debug_en;
>> +	bool forced_disconnect;
>> +
>> +	int (*connect)(struct dp_usbpd *dp_usbpd, bool hpd);
>> +};
>> +
>> +/**
>> + * struct dp_usbpd_cb - callback functions provided by the client
>> + *
>> + * @configure: called by usbpd module when PD communication has
>> + * been completed and the usb peripheral has been configured on
>> + * dp mode.
>> + * @disconnect: notify the cable disconnect issued by usb.
>> + * @attention: notify any attention message issued by usb.
>> + */
>> +struct dp_usbpd_cb {
>> +	int (*configure)(struct device *dev);
>> +	int (*disconnect)(struct device *dev);
>> +	int (*attention)(struct device *dev);
>> +};
>> +
>> +/**
>> + * dp_extcon_get() - setup usbpd module
>> + *
>> + * @dev: device instance of the caller
>> + * @cb: struct containing callback function pointers.
>> + *
>> + * This function allows the client to initialize the usbpd
>> + * module. The module will communicate with usb driver and
>> + * handles the power delivery (PD) communication with the
>> + * sink/usb device. This module will notify the client using
>> + * the callback functions about the connection and status.
>> + */
>> +struct dp_usbpd *dp_extcon_get(struct device *dev, struct dp_usbpd_cb 
>> *cb);
>> +
>> +void dp_extcon_put(struct dp_usbpd *pd);
>> +
>> +int dp_extcon_register(struct dp_usbpd *dp_usbpd);
>> +void dp_extcon_unregister(struct dp_usbpd *dp_usbpd);
>> +
>> +#endif /* _DP_EXTCON_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_link.c 
>> b/drivers/gpu/drm/msm/dp/dp_link.c
>> new file mode 100644
>> index 0000000..5ab1efc
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_link.c
>> @@ -0,0 +1,1549 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include "dp_link.h"
>> +#include "dp_panel.h"
>> +
>> +enum dynamic_range {
>> +	DP_DYNAMIC_RANGE_RGB_VESA = 0x00,
>> +	DP_DYNAMIC_RANGE_RGB_CEA = 0x01,
>> +	DP_DYNAMIC_RANGE_UNKNOWN = 0xFFFFFFFF,
>> +};
> 
> These should be in drm_dp_helper.h
> 
Fixed in V2.

>> +
>> +enum audio_sample_rate {
>> +	AUDIO_SAMPLE_RATE_32_KHZ	= 0x00,
>> +	AUDIO_SAMPLE_RATE_44_1_KHZ	= 0x01,
>> +	AUDIO_SAMPLE_RATE_48_KHZ	= 0x02,
>> +	AUDIO_SAMPLE_RATE_88_2_KHZ	= 0x03,
>> +	AUDIO_SAMPLE_RATE_96_KHZ	= 0x04,
>> +	AUDIO_SAMPLE_RATE_176_4_KHZ	= 0x05,
>> +	AUDIO_SAMPLE_RATE_192_KHZ	= 0x06,
>> +};
>> +
>> +enum audio_pattern_type {
>> +	AUDIO_TEST_PATTERN_OPERATOR_DEFINED	= 0x00,
>> +	AUDIO_TEST_PATTERN_SAWTOOTH		= 0x01,
>> +};
>> +
>> +struct dp_link_request {
>> +	u32 test_requested;
>> +	u32 test_link_rate;
>> +	u32 test_lane_count;
>> +};
>> +
>> +struct dp_link_private {
>> +	u32 prev_sink_count;
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_link dp_link;
>> +
>> +	struct dp_link_request request;
>> +	u8 link_status[DP_LINK_STATUS_SIZE];
>> +};
>> +
>> +static char *dp_link_get_audio_test_pattern(u32 pattern)
>> +{
>> +	switch (pattern) {
>> +	case AUDIO_TEST_PATTERN_OPERATOR_DEFINED:
>> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_OPERATOR_DEFINED);
>> +	case AUDIO_TEST_PATTERN_SAWTOOTH:
>> +		return DP_LINK_ENUM_STR(AUDIO_TEST_PATTERN_SAWTOOTH);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static char *dp_link_get_audio_sample_rate(u32 rate)
>> +{
>> +	switch (rate) {
>> +	case AUDIO_SAMPLE_RATE_32_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_32_KHZ);
>> +	case AUDIO_SAMPLE_RATE_44_1_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_44_1_KHZ);
>> +	case AUDIO_SAMPLE_RATE_48_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_48_KHZ);
>> +	case AUDIO_SAMPLE_RATE_88_2_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_88_2_KHZ);
>> +	case AUDIO_SAMPLE_RATE_96_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_96_KHZ);
>> +	case AUDIO_SAMPLE_RATE_176_4_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_176_4_KHZ);
>> +	case AUDIO_SAMPLE_RATE_192_KHZ:
>> +		return DP_LINK_ENUM_STR(AUDIO_SAMPLE_RATE_192_KHZ);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static int dp_link_get_period(struct dp_link_private *link, int const 
>> addr)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	u32 const param_len = 0x1;
>> +	u32 const max_audio_period = 0xA;
>> +
>> +	/* TEST_AUDIO_PERIOD_CH_XX */
>> +	if (drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp,
>> +		param_len) < param_len) {
>> +		pr_err("failed to read test_audio_period (0x%x)\n", addr);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	/* Period - Bits 3:0 */
>> +	data = data & 0xF;
>> +	if ((int)data > max_audio_period) {
>> +		pr_err("invalid test_audio_period_ch_1 = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	ret = data;
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_channel_period(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	struct dp_link_test_audio *req = &link->dp_link.test_audio;
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_1 = ret;
>> +	pr_debug("test_audio_period_ch_1 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_2 = ret;
>> +	pr_debug("test_audio_period_ch_2 = 0x%x\n", ret);
>> +
>> +	/* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_3 = ret;
>> +	pr_debug("test_audio_period_ch_3 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_4 = ret;
>> +	pr_debug("test_audio_period_ch_4 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_5 = ret;
>> +	pr_debug("test_audio_period_ch_5 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_6 = ret;
>> +	pr_debug("test_audio_period_ch_6 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_7 = ret;
>> +	pr_debug("test_audio_period_ch_7 = 0x%x\n", ret);
>> +
>> +	ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8);
>> +	if (ret == -EINVAL)
>> +		goto exit;
>> +
>> +	req->test_audio_period_ch_8 = ret;
>> +	pr_debug("test_audio_period_ch_8 = 0x%x\n", ret);
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_pattern_type(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	int rlen;
>> +	int const param_len = 0x1;
>> +	int const max_audio_pattern_type = 0x1;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
>> +		DP_TEST_AUDIO_PATTERN_TYPE, &bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link audio mode data\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Audio Pattern Type - Bits 7:0 */
>> +	if ((int)data > max_audio_pattern_type) {
>> +		pr_err("invalid audio pattern type = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_audio.test_audio_pattern_type = data;
>> +	pr_debug("audio pattern type = %s\n",
>> +			dp_link_get_audio_test_pattern(data));
>> +exit:
>> +	return ret;
>> +}
>> +
>> +static int dp_link_parse_audio_mode(struct dp_link_private *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
>> +	int rlen;
>> +	int const param_len = 0x1;
>> +	int const max_audio_sampling_rate = 0x6;
>> +	int const max_audio_channel_count = 0x8;
>> +	int sampling_rate = 0x0;
>> +	int channel_count = 0x0;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_AUDIO_MODE,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link audio mode data\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Sampling Rate - Bits 3:0 */
>> +	sampling_rate = data & 0xF;
>> +	if (sampling_rate > max_audio_sampling_rate) {
>> +		pr_err("sampling rate (0x%x) greater than max (0x%x)\n",
>> +				sampling_rate, max_audio_sampling_rate);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	/* Channel Count - Bits 7:4 */
>> +	channel_count = ((data & 0xF0) >> 4) + 1;
>> +	if (channel_count > max_audio_channel_count) {
>> +		pr_err("channel_count (0x%x) greater than max (0x%x)\n",
>> +				channel_count, max_audio_channel_count);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate;
>> +	link->dp_link.test_audio.test_audio_channel_count = channel_count;
>> +	pr_debug("sampling_rate = %s, channel_count = 0x%x\n",
>> +		dp_link_get_audio_sample_rate(sampling_rate), channel_count);
>> +exit:
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_parse_audio_pattern_params() - parses audio pattern parameters 
>> from DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the audio link pattern 
>> parameters.
>> + */
>> +static int dp_link_parse_audio_pattern_params(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +
>> +	ret = dp_link_parse_audio_mode(link);
>> +	if (ret)
>> +		goto exit;
>> +
>> +	ret = dp_link_parse_audio_pattern_type(link);
>> +	if (ret)
>> +		goto exit;
>> +
>> +	ret = dp_link_parse_audio_channel_period(link);
>> +
>> +exit:
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_is_video_pattern_valid() - validates the video pattern
>> + * @pattern: video pattern requested by the sink
>> + *
>> + * Returns true if the requested video pattern is supported.
>> + */
>> +static bool dp_link_is_video_pattern_valid(u32 pattern)
>> +{
>> +	switch (pattern) {
>> +	case DP_NO_TEST_PATTERN:
>> +	case DP_COLOR_RAMP:
>> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
>> +	case DP_COLOR_SQUARE:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_video_pattern_to_string(u32 test_video_pattern)
>> +{
>> +	switch (test_video_pattern) {
>> +	case DP_NO_TEST_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_NO_TEST_PATTERN);
>> +	case DP_COLOR_RAMP:
>> +		return DP_LINK_ENUM_STR(DP_COLOR_RAMP);
>> +	case DP_BLACK_AND_WHITE_VERTICAL_LINES:
>> +		return DP_LINK_ENUM_STR(DP_BLACK_AND_WHITE_VERTICAL_LINES);
>> +	case DP_COLOR_SQUARE:
>> +		return DP_LINK_ENUM_STR(DP_COLOR_SQUARE);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +/**
>> + * dp_link_is_dynamic_range_valid() - validates the dynamic range
>> + * @bit_depth: the dynamic range value to be checked
>> + *
>> + * Returns true if the dynamic range value is supported.
>> + */
>> +static bool dp_link_is_dynamic_range_valid(u32 dr)
>> +{
>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_dynamic_range_to_string(u32 dr)
>> +{
>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_VESA);
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		return DP_LINK_ENUM_STR(DP_DYNAMIC_RANGE_RGB_CEA);
>> +	case DP_DYNAMIC_RANGE_UNKNOWN:
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> No need for this, just print the value in the debug statement.
> 
Removed in V2.

>> +
>> +/**
>> + * dp_link_is_bit_depth_valid() - validates the bit depth requested
>> + * @bit_depth: bit depth requested by the sink
>> + *
>> + * Returns true if the requested bit depth is supported.
>> + */
>> +static bool dp_link_is_bit_depth_valid(u32 tbd)
>> +{
>> +	/* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +	case DP_TEST_BIT_DEPTH_8:
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +static char *dp_link_bit_depth_to_string(u32 tbd)
>> +{
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_6);
>> +	case DP_TEST_BIT_DEPTH_8:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_8);
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		return DP_LINK_ENUM_STR(DP_TEST_BIT_DEPTH_10);
>> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Same thing here, just remove this and print the enum value.
> 
Removed in V2.

>> +
>> +static int dp_link_parse_timing_params1(struct dp_link_private *link,
>> +					int const addr, int const len, u32 *val)
> 
> pass-by-value doesn't need const same comment applies elsewhere, please 
> sweep
> the code for other instances.
> 
>> +{
>> +	u8 bp[2];
>> +	int rlen;
>> +
>> +	if (len < 2)
> 
> If you're going to check len < 2, you should probably also check len > 
> 2 to
> prevent overflow. At this point, len can really only be 2, so you can
> just remove
> it entirely as an argument.
> 
Fixed in v2. (checking for len != 2)

>> +		return -EINVAL;
>> +
>> +	/* Read the requested video link pattern (Byte 0x221). */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
>> +	if (rlen < len) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +
>> +	*val = bp[1] | (bp[0] << 8);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_parse_timing_params2(struct dp_link_private *link,
>> +					int const addr, int const len,
>> +					u32 *val1, u32 *val2)
>> +{
>> +	u8 bp[2];
>> +	int rlen;
>> +
>> +	if (len < 2)
> 
> Same comment here rt bounds checking
> 
Fixed in V2.

>> +		return -EINVAL;
>> +
>> +	/* Read the requested video link pattern (Byte 0x221). */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, bp, len);
>> +	if (rlen < len) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +
>> +	*val1 = (bp[0] & BIT(7)) >> 7;
>> +	*val2 = bp[1] | ((bp[0] & 0x7F) << 8);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_parse_timing_params3(struct dp_link_private *link,
>> +					int const addr, u32 *val)
>> +{
>> +	u8 bp;
>> +	u32 len = 1;
>> +	int rlen;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, addr, &bp, len);
>> +	if (rlen < 1) {
>> +		pr_err("failed to read 0x%x\n", addr);
>> +		return -EINVAL;
>> +	}
>> +	*val = bp;
>> +
>> +	return 0;
>> +}
> 
> Putting aside the uninformative names, these 
> dp_link_parse_timing_params*
> can be combined into one pretty easily, like:
> 
> static int dp_link_read_u32(struct dp_link_private *link, unsigned int 
> offset,
> 		            u32 *val, int num_bytes)
> {
>         int i;
>         ssize_t ret;
>         __be32 tmp_val;
> 
>         for (i = 0; num_bytes > 0; i += sizeof(*val)) {
>                 int to_read = min(sizeof(tmp_val), num_bytes);
> 
>                 tmp_val = 0;
>                 ret = drm_dp_dpcd_read(link->aux->drm_aux, offset + i, 
> &tmp_val,
>                                        to_read);
>                 if (rlen < 0) {
>                         /* print error message here */
>                         return rlen;
>                 }
>                 val[i] = be32_to_cpu(tmp_val);
>                 num_bytes -= to_read;
>         }
>         return 0;
> }
> 
> If you need to strip off the first bit, do it from the caller.
> 
> I didn't compile or test this, so it might need tweaking, but you get 
> the idea.
> 
> 
Will follow up on this implementation and fix the params* APIs in V3.
>> +
>> +/**
>> + * dp_parse_video_pattern_params() - parses video pattern parameters 
>> from DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the video link pattern and the 
>> link
>> + * bit depth requested by the sink and, and if the values parsed are 
>> valid.
>> + */
>> +static int dp_link_parse_video_pattern_params(struct dp_link_private 
>> *link)
>> +{
>> +	int ret = 0;
>> +	int rlen;
> 
> ssize_t
> 
All the rlen in each function have been changed to ssize_t V2.

>> +	u8 bp;
>> +	u8 data;
> 
> Why do you need data and bp? I think you only need one.
> 
Fixed in V2.

>> +	u32 dyn_range;
>> +	int const param_len = 0x1;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PATTERN,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link video pattern\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	if (!dp_link_is_video_pattern_valid(data)) {
>> +		pr_err("invalid link video pattern = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_video.test_video_pattern = data;
>> +	pr_debug("link video pattern = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_video_pattern,
>> +		dp_link_video_pattern_to_string(
>> +			link->dp_link.test_video.test_video_pattern));
>> +
>> +	/* Read the requested color bit depth and dynamic range (Byte 0x232) 
>> */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_MISC0,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link bit depth\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	/* Dynamic Range */
>> +	dyn_range = (data & DP_TEST_DYNAMIC_RANGE_CEA) >> 3;
> 
> This mask isolates one bit from data
> 
>> +	if (!dp_link_is_dynamic_range_valid(dyn_range)) {
> 
> and this function returns true if the input is 0 || 1
> 
> So remove this code, and remove dp_link_is_dynamic_range_valid.
> 
Fixed in V2.

>> +		pr_err("invalid link dynamic range = 0x%x", dyn_range);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	link->dp_link.test_video.test_dyn_range = dyn_range;
> 
> And now you can just assign this directly. You should probably stay 
> consistent
> and store the value shifted like the other values you're storing.
> 
Fixed in V2.

>> +	pr_debug("link dynamic range = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_dyn_range,
>> +		dp_link_dynamic_range_to_string(
>> +			link->dp_link.test_video.test_dyn_range));
>> +
>> +	/* Color bit depth */
>> +	data &= DP_TEST_BIT_DEPTH_MASK;
>> +	if (!dp_link_is_bit_depth_valid(data)) {
>> +		pr_err("invalid link bit depth = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->dp_link.test_video.test_bit_depth = data;
>> +	pr_debug("link bit depth = 0x%x (%s)\n",
>> +		link->dp_link.test_video.test_bit_depth,
>> +		dp_link_bit_depth_to_string(
>> +		link->dp_link.test_video.test_bit_depth));
>> +
>> +	/* resolution timing params */
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2,
>> +			&link->dp_link.test_video.test_h_total);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_total (DP_TEST_H_TOTAL_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_TOTAL = %d\n", 
>> link->dp_link.test_video.test_h_total);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2,
>> +			&link->dp_link.test_video.test_v_total);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_total (DP_TEST_V_TOTAL_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_TOTAL = %d\n", 
>> link->dp_link.test_video.test_v_total);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2,
>> +			&link->dp_link.test_video.test_h_start);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_start (DP_TEST_H_START_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_START = %d\n", 
>> link->dp_link.test_video.test_h_start);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2,
>> +			&link->dp_link.test_video.test_v_start);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_start (DP_TEST_V_START_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_START = %d\n", 
>> link->dp_link.test_video.test_v_start);
>> +
>> +	ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2,
>> +			&link->dp_link.test_video.test_hsync_pol,
>> +			&link->dp_link.test_video.test_hsync_width);
>> +	if (ret) {
>> +		pr_err("failed to parse (DP_TEST_HSYNC_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_HSYNC_POL = %d\n",
>> +		link->dp_link.test_video.test_hsync_pol);
>> +	pr_debug("TEST_HSYNC_WIDTH = %d\n",
>> +		link->dp_link.test_video.test_hsync_width);
>> +
>> +	ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2,
>> +			&link->dp_link.test_video.test_vsync_pol,
>> +			&link->dp_link.test_video.test_vsync_width);
>> +	if (ret) {
>> +		pr_err("failed to parse (DP_TEST_VSYNC_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_VSYNC_POL = %d\n",
>> +		link->dp_link.test_video.test_vsync_pol);
>> +	pr_debug("TEST_VSYNC_WIDTH = %d\n",
>> +		link->dp_link.test_video.test_vsync_width);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2,
>> +			&link->dp_link.test_video.test_h_width);
>> +	if (ret) {
>> +		pr_err("failed to parse test_h_width (DP_TEST_H_WIDTH_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_H_WIDTH = %d\n", 
>> link->dp_link.test_video.test_h_width);
>> +
>> +	ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2,
>> +			&link->dp_link.test_video.test_v_height);
>> +	if (ret) {
>> +		pr_err("failed to parse test_v_height (DP_TEST_V_HEIGHT_HI)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_V_HEIGHT = %d\n",
>> +		link->dp_link.test_video.test_v_height);
>> +
>> +	ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1,
>> +		&link->dp_link.test_video.test_rr_d);
>> +	link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR;
>> +	if (ret) {
>> +		pr_err("failed to parse test_rr_d (DP_TEST_MISC1)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_REFRESH_DENOMINATOR = %d\n",
>> +		link->dp_link.test_video.test_rr_d);
>> +
>> +	ret = dp_link_parse_timing_params3(link, 
>> DP_TEST_REFRESH_RATE_NUMERATOR,
>> +		&link->dp_link.test_video.test_rr_n);
>> +	if (ret) {
>> +		pr_err("failed to parse test_rr_n 
>> (DP_TEST_REFRESH_RATE_NUMERATOR)\n");
>> +		goto exit;
>> +	}
>> +	pr_debug("TEST_REFRESH_NUMERATOR = %d\n",
>> +		link->dp_link.test_video.test_rr_n);
> 
> Instead of sprinkling all of these pr_debug messages around, just have 
> one big
> debug at the end to print everything.
> 
Fixed in V2.

>> +exit:
> 
> This label isn't useful, just return directly above
> 
Fixed in V2.

>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_parse_link_training_params() - parses link training 
>> parameters from
>> + * DPCD
>> + * @link: Display Port Driver data
>> + *
>> + * Returns 0 if it successfully parses the link rate (Byte 0x219) and 
>> lane
>> + * count (Byte 0x220), and if these values parse are valid.
>> + */
>> +static int dp_link_parse_link_training_params(struct dp_link_private 
>> *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> You don't need both bp and data
> 
Fixed in v2.

>> +	int ret = 0;
>> +	int rlen;
> 
> ssize_t
> 
>> +	int const param_len = 0x1;
> 
> Just use 1 directly below.
> 
All the one byte reads have been changed to drm_dp_dpcd_readb in V2.

>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LINK_RATE,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read link rate\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +
>> +	if (!is_link_rate_valid(data)) {
>> +		pr_err("invalid link rate = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->request.test_link_rate = data;
>> +	pr_debug("link rate = 0x%x\n", link->request.test_link_rate);
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_LANE_COUNT,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read lane count\n");
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +	data = bp;
>> +	data &= 0x1F;
> 
> DP_MAX_LANE_COUNT_MASK
> 
Fixed in V2.
>> +
>> +	if (!is_lane_count_valid(data)) {
> 
> You might also want to data against max lanes
> 
>> +		pr_err("invalid lane count = 0x%x\n", data);
>> +		ret = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	link->request.test_lane_count = data;
>> +	pr_debug("lane count = 0x%x\n", link->request.test_lane_count);
>> +exit:
>> +	return ret;
> 
> return directly above and remove exit + ret;
> 
>> +}
>> +
>> +static bool dp_link_is_phy_test_pattern_supported(u32 
>> phy_test_pattern_sel)
>> +{
>> +	switch (phy_test_pattern_sel) {
>> +	case DP_TEST_PHY_PATTERN_NONE:
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		return true;
>> +	default:
>> +		return false;
>> +	}
>> +}
>> +
>> +/**
>> + * dp_parse_phy_test_params() - parses the phy link parameters
>> + * @link: Display Port Driver data
>> + *
>> + * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is 
>> being
>> + * requested.
>> + */
>> +static int dp_link_parse_phy_test_params(struct dp_link_private 
>> *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> Only need one of these.
> 
>> +	int rlen;
> 
> ssize_t
> 
>> +	int const param_len = 0x1;
> 
> Just use 1 below
> 
All the above comments in this function are fixed in V2.
>> +	int ret = 0;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_PHY_PATTERN,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
> 
> FWIW, drm_dp_dpcd_read will return either len or an -errno. Partial 
> reads return
> -EPROTO. So instead of checking that rlen < param_len, you can just do 
> rlen < 0.

Fixed in V2.

> 
> Please also change all of the 1-byte reads over to using 
> drm_dp_dpcd_readb().
> 

Fixed in V2.
> 
>> +		pr_err("failed to read phy link pattern\n");
> 
> print and return rlen.
> 
Fixed in V2.
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	link->dp_link.phy_params.phy_test_pattern_sel = data;
>> +
>> +	pr_debug("phy_test_pattern_sel = %s\n",
>> +			dp_link_get_phy_test_pattern(data));
>> +
>> +	if (!dp_link_is_phy_test_pattern_supported(data))
> 
> Just embed that code here.
> 
Will fix this in V3.

>> +		ret = -EINVAL;
>> +end:
> 
> Remove label/ret and return directly
> 
Fixed in v2.

>> +	return ret;
>> +}
>> +
>> +static char *dp_link_get_test_name(u32 test_requested)
>> +{
>> +	switch (test_requested) {
>> +	case DP_TEST_LINK_TRAINING:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_TRAINING);
>> +	case DP_TEST_LINK_VIDEO_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_VIDEO_PATTERN);
>> +	case DP_TEST_LINK_EDID_READ:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_EDID_READ);
>> +	case DP_TEST_LINK_PHY_TEST_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_PHY_TEST_PATTERN);
>> +	case DP_TEST_LINK_AUDIO_PATTERN:
>> +		return DP_LINK_ENUM_STR(DP_TEST_LINK_AUDIO_PATTERN);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Remove this and just print the enum.
> 
Fixed in V2.

>> +
>> +/**
>> + * dp_link_is_video_audio_test_requested() - checks for audio/video 
>> link request
>> + * @link: link requested by the sink
>> + *
>> + * Returns true if the requested link is a permitted audio/video 
>> link.
>> + */
>> +static bool dp_link_is_video_audio_test_requested(u32 link)
>> +{
> 
> Should you be masking link to isolate these bits?
> 
>> +	return (link == DP_TEST_LINK_VIDEO_PATTERN) ||
>> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
>> +		DP_TEST_LINK_VIDEO_PATTERN)) ||
>> +		(link == DP_TEST_LINK_AUDIO_PATTERN) ||
>> +		(link == (DP_TEST_LINK_AUDIO_PATTERN |
>> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO));
> 
> And once you mask the value, just check if any of the bits are set 
> instead of
> enumerating all possible values.
> 
> 
Updated the function in V2.
>> +}
>> +
>> +/**
>> + * dp_link_supported() - checks if link requested by sink is 
>> supported
>> + * @test_requested: link requested by the sink
>> + *
>> + * Returns true if the requested link is supported.
>> + */
>> +static bool dp_link_is_test_supported(u32 test_requested)
>> +{
>> +	return (test_requested == DP_TEST_LINK_TRAINING) ||
>> +		(test_requested == DP_TEST_LINK_EDID_READ) ||
>> +		(test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) ||
>> +		dp_link_is_video_audio_test_requested(test_requested);
> 
> I think this all equates to:
> 
> 	return test_requested != DP_TEST_LINK_FAUX_PATTERN;
> 
> and in that case, you can just remove this function and insert that 
> condition in
> the if statement below.
> 
Removed this function and implemented at the caller in V2 patch.

>> +}
>> +
>> +static bool dp_link_is_test_edid_read(struct dp_link_private *link)
>> +{
>> +	return (link->request.test_requested == DP_TEST_LINK_EDID_READ);
>> +}
> 
> This doesn't warrant its own function. Also, should this be & instead 
> of ==?
> 
Fixed in V2.
>> +
>> +/**
>> + * dp_sink_parse_test_request() - parses link request parameters from 
>> sink
>> + * @link: Display Port Driver data
>> + *
>> + * Parses the DPCD to check if an automated link is requested (Byte 
>> 0x201),
>> + * and what type of link automation is being requested (Byte 0x218).
>> + */
>> +static int dp_link_parse_request(struct dp_link_private *link)
>> +{
>> +	int ret = 0;
>> +	u8 bp;
>> +	u8 data;
> 
> Only need 1 of bp/data
> 
>> +	int rlen;
> 
> ssize_t
> 
>> +	u32 const param_len = 0x1;
> 
> Not needed, use drm_dp_dpcd_readb()
> 
>> +
>> +	/**
>> +	 * Read the device service IRQ vector (Byte 0x201) to determine
>> +	 * whether an automated link has been requested by the sink.
>> +	 */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
>> +		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("aux read failed\n");
> 
> Print error. This goes for other failure messages in this file.
> 
Addressed all the comments above in this function in V2.

>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("device service irq vector = 0x%x\n", data);
>> +
>> +	if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
>> +		pr_debug("no test requested\n");
>> +		return 0;
>> +	}
>> +
>> +	/**
>> +	 * Read the link request byte (Byte 0x218) to determine what type
>> +	 * of automated link has been requested by the sink.
>> +	 */
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("aux read failed\n");
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	if (!dp_link_is_test_supported(data)) {
>> +		pr_debug("link 0x%x not supported\n", data);
>> +		goto end;
>> +	}
>> +
>> +	pr_debug("%s (0x%x) requested\n", dp_link_get_test_name(data), 
>> data);
>> +	link->request.test_requested = data;
> 
> If test_requested is only used in the scope of this function, just use 
> a local
> and pass it around. If test_requested is used outside the scope of this
> function, you need locking.

test_requested in only used in dp_link.c. But we use this in dp_debug 
for debugging. We also
use this in unit testing. This is one of main reason we have it in 
dp_link structure.

> 
>> +
>> +	if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) {
>> +		ret = dp_link_parse_phy_test_params(link);
>> +		if (ret)
>> +			goto end;
>> +		ret = dp_link_parse_link_training_params(link);
> 
> Check the return here or it could get stomped
> 
>> +	}
>> +
>> +	if (link->request.test_requested == DP_TEST_LINK_TRAINING)
>> +		ret = dp_link_parse_link_training_params(link);
> 
> Check the return here or it could get stomped
> 
Added checks for return value in V2 patch.
>> +
>> +	if (dp_link_is_video_audio_test_requested(
>> +			link->request.test_requested)) {
> 
> Should fit on 1 line, I think
> 
It goes beyond 80 Chars..


>> +		ret = dp_link_parse_video_pattern_params(link);
>> +		if (ret)
>> +			goto end;
>> +
>> +		ret = dp_link_parse_audio_pattern_params(link);
> 
> Check the return here or it could get stomped
> 
Fixed in V2.
>> +	}
>> +end:
>> +	/**
> 
> /*
> 
Multi-line comments, we use "/**"

>> +	 * Send a DP_TEST_ACK if all link parameters are valid, otherwise 
>> send
>> +	 * a DP_TEST_NAK.
>> +	 */
>> +	if (ret) {
>> +		link->dp_link.test_response = DP_TEST_NAK;
>> +	} else {
>> +		if (!dp_link_is_test_edid_read(link))
>> +			link->dp_link.test_response = DP_TEST_ACK;
>> +		else
>> +			link->dp_link.test_response =
>> +				DP_TEST_EDID_CHECKSUM_WRITE;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_parse_sink_count() - parses the sink count
>> + *
>> + * Parses the DPCD to check if there is an update to the sink count
>> + * (Byte 0x200), and whether all the sink devices connected have 
>> Content
>> + * Protection enabled.
>> + */
>> +static int dp_link_parse_sink_count(struct dp_link *dp_link)
>> +{
>> +	int rlen;
>> +	int const param_len = 0x1;
> 
> drm_dp_dpcd_readb
> 
Fixed in V2.

>> +	struct dp_link_private *link = container_of(dp_link,
>> +			struct dp_link_private, dp_link);
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_SINK_COUNT,
>> +			&link->dp_link.sink_count.count, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed to read sink count\n");
> 
> print ret
> 
>> +		return -EINVAL;
> 
> return ret
> 
Fixed in V2.

>> +	}
>> +
>> +	link->dp_link.sink_count.cp_ready =
>> +		link->dp_link.sink_count.count & DP_SINK_CP_READY;
> 
> cp_ready is only used in this function, please don't store stuff like 
> this
> beyond its scope.
> 
Fixed in V2.

>> +	/* BIT 7, BIT 5:0 */
> 
> Don't need this comment
> 
Fixed in V2.

>> +	link->dp_link.sink_count.count =
>> +		DP_GET_SINK_COUNT(link->dp_link.sink_count.count);
>> +
>> +	pr_debug("sink_count = 0x%x, cp_ready = 0x%x\n",
>> +		link->dp_link.sink_count.count,
>> +		link->dp_link.sink_count.cp_ready);
>> +	return 0;
>> +}
>> +
>> +static void dp_link_parse_sink_status_field(struct dp_link_private 
>> *link)
>> +{
>> +	int len = 0;
>> +
>> +	link->prev_sink_count = link->dp_link.sink_count.count;
>> +	dp_link_parse_sink_count(&link->dp_link);
>> +
>> +	len = drm_dp_dpcd_read_link_status(link->aux->drm_aux,
>> +		link->link_status);
>> +	if (len < DP_LINK_STATUS_SIZE)
>> +		pr_err("DP link status read failed\n");
>> +	dp_link_parse_request(link);
>> +}
>> +
>> +static bool dp_link_is_link_training_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested == DP_TEST_LINK_TRAINING);
>> +}
> 
> No need for dedicated function
> 
Addressed in V2.

>> +
>> +/**
>> + * dp_link_process_link_training_request() - processes new training 
>> requests
>> + * @link: Display Port link data
>> + *
>> + * This function will handle new link training requests that are 
>> initiated by
>> + * the sink. In particular, it will update the requested lane count 
>> and link
>> + * link rate, and then trigger the link retraining procedure.
>> + *
>> + * The function will return 0 if a link training request has been 
>> processed,
>> + * otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_link_training_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_link_training_requested(link))
>> +		return -EINVAL;
>> +
>> +	pr_debug("%s link rate = 0x%x, lane count = 0x%x\n",
>> +			dp_link_get_test_name(DP_TEST_LINK_TRAINING),
>> +			link->request.test_link_rate,
>> +			link->request.test_lane_count);
>> +
>> +	link->dp_link.link_params.lane_count = 
>> link->request.test_lane_count;
>> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;
> 
> Should be using dp helper structs for this stuff
> 
Fixed in V2.

>> +
>> +	return 0;
>> +}
>> +
>> +static void dp_link_send_test_response(struct dp_link *dp_link)
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	u32 const response_len = 0x1;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
>> +			&dp_link->test_response, response_len);
> 
> I strongly suspect you should have locking protecting test_response.
> 
Will cross-check whether we need locking and fix it in V3. Just curious, 
do you still think
we need locking even though we handle this in a single thread?
>> +}
>> +
>> +static int dp_link_psm_config(struct dp_link *dp_link,
>> +			      struct drm_dp_link *link_info, bool enable)
> 
> This is another racy function where you could be simultaneously 
> powering up and
> powering down the link. So you might want some locking.
> 
Same response as above.
This might need locking since it is called from multiple modules.
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	int ret = 0;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid params\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	if (enable)
>> +		ret = drm_dp_link_power_down(link->aux->drm_aux, link_info);
>> +	else
>> +		ret = drm_dp_link_power_up(link->aux->drm_aux, link_info);
>> +
>> +	if (ret)
>> +		pr_err("Failed to %s low power mode\n",
>> +			(enable ? "enter" : "exit"));
> 
> unneeded (). You could probably reword to fit on one line too
> 
Fixed in v2.

>> +	else
>> +		dp_link->psm_enabled = enable;
>> +
>> +	return ret;
>> +}
>> +
>> +static void dp_link_send_edid_checksum(struct dp_link *dp_link, u8 
>> checksum)
>> +{
>> +	struct dp_link_private *link = NULL;
>> +	u32 const response_len = 0x1;
> 
> drm_dp_dpcd_readb. I'll stop commenting on these, just please go 
> through and
> convert all 1-byte reads/writes
> 
Addressed all of them in V2.
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_EDID_CHECKSUM,
>> +			&checksum, response_len);
> 
> Check and return the result
> 
Fixed in V2.

>> +}
>> +
>> +static int dp_link_parse_vx_px(struct dp_link_private *link)
>> +{
>> +	u8 bp;
>> +	u8 data;
> 
> Only need one of these
> 
>> +	int const param_len = 0x1;
> 
> drm_dp_dpcd_readb
> 
>> +	int ret = 0;
>> +	u32 v0, p0, v1, p1, v2, p2, v3, p3;
>> +	int rlen;
> 
> ssize_t
> 
>> +
>> +	pr_debug("\n");
> 
> remove
> 
Addressed all the comments above in V2 patch series.

>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, 
>> DP_ADJUST_REQUEST_LANE0_1,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed reading lanes 0/1\n");
> 
> print error
> 
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("lanes 0/1 (Byte 0x206): 0x%x\n", data);
>> +
>> +	v0 = data & 0x3;
>> +	data = data >> 2;
>> +	p0 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	v1 = data & 0x3;
>> +	data = data >> 2;
>> +	p1 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, 
>> DP_ADJUST_REQUEST_LANE2_3,
>> +			&bp, param_len);
>> +	if (rlen < param_len) {
>> +		pr_err("failed reading lanes 2/3\n");
>> +		ret = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	data = bp;
>> +
>> +	pr_debug("lanes 2/3 (Byte 0x207): 0x%x\n", data);
>> +
>> +	v2 = data & 0x3;
>> +	data = data >> 2;
>> +	p2 = data & 0x3;
>> +	data = data >> 2;
>> +
>> +	v3 = data & 0x3;
>> +	data = data >> 2;
>> +	p3 = data & 0x3;
>> +	data = data >> 2;
> 
> I think you can use drm_dp_get_adjust_request_voltage() for all of 
> this.
> 
Will fix this in V3.


>> +
>> +	pr_debug("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", v0, v1, v2, v3);
>> +	pr_debug("px: 0=%d, 1=%d, 2=%d, 3=%d\n", p0, p1, p2, p3);
>> +
>> +	/**
>> +	 * Update the voltage and pre-emphasis levels as per DPCD request
>> +	 * vector.
>> +	 */
>> +	pr_debug("Current: v_level = 0x%x, p_level = 0x%x\n",
>> +			link->dp_link.phy_params.v_level,
>> +			link->dp_link.phy_params.p_level);
>> +	pr_debug("Requested: v_level = 0x%x, p_level = 0x%x\n", v0, p0);
>> +	link->dp_link.phy_params.v_level = v0;
>> +	link->dp_link.phy_params.p_level = p0;
>> +
>> +	pr_debug("Success\n");
> 
> Remove
> 
Fixed in V2.

>> +end:
> 
> return directly everywhere and remove end & ret
> 
>> +	return ret;
>> +}
>> +
>> +/**
>> + * dp_link_process_phy_test_pattern_request() - process new phy link 
>> requests
>> + * @link: Display Port Driver data
>> + *
>> + * This function will handle new phy link pattern requests that are 
>> initiated
>> + * by the sink. The function will return 0 if a phy link pattern has 
>> been
>> + * processed, otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_phy_test_pattern_request(
>> +		struct dp_link_private *link)
>> +{
>> +	u32 test_link_rate = 0, test_lane_count = 0;
>> +
>> +	if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) 
>> {
> 
> Is test_requested always expected to have this value populated when
> dp_link_process_request()?
> 
Yes, test_requested is updated in dp_link_parse_sink_status_field() 
which is called before
this function is called.

>> +		pr_debug("no phy test\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	test_link_rate = link->request.test_link_rate;
>> +	test_lane_count = link->request.test_lane_count;
> 
> Just use these values directly instead of adding more locals.
> 
Fixed in V2.

>> +
>> +	if (!is_link_rate_valid(test_link_rate) ||
>> +		!is_lane_count_valid(test_lane_count)) {
>> +		pr_err("Invalid params: link rate = 0x%x, lane count = 0x%x\n",
>> +				test_link_rate, test_lane_count);
>> +		return -EINVAL;
>> +	}
>> +
>> +	pr_debug("start\n");
> 
> Remove
> 
Fixed in V2.
>> +
>> +	pr_info("Current: bw_code = 0x%x, lane count = 0x%x\n",
>> +			link->dp_link.link_params.bw_code,
>> +			link->dp_link.link_params.lane_count);
>> +
>> +	pr_info("Requested: bw_code = 0x%x, lane count = 0x%x\n",
>> +			test_link_rate, test_lane_count);
> 
> These should be debug level prints
> 
Fixed in V2.

>> +
>> +	link->dp_link.link_params.lane_count = 
>> link->request.test_lane_count;
>> +	link->dp_link.link_params.bw_code = link->request.test_link_rate;
>> +
>> +	dp_link_parse_vx_px(link);
> 
> Check return value and propagate it.
> 
>> +
>> +	pr_debug("end\n");
> 
> Remove
> 
fixed in V2.

>> +
>> +	return 0;
>> +}
>> +
>> +static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], 
>> int r)
>> +{
>> +	return link_status[r - DP_LANE0_1_STATUS];
> 
> I don't think you're really supposed to reach into the link_status like 
> this.
> How about adding a new helper to check for DP_LINK_STATUS_UPDATED and 
> one for
> DP_DOWNSTREAM_PORT_STATUS_CHANGED?
> 
This function is similar to function in upstream drm_dp_helper.c file.
https://chromium.googlesource.com/chromiumos/third_party/kernel/+/chromeos-3.18/drivers/gpu/drm/drm_dp_helper.c#259

>> +}
>> +
>> +/**
>> + * dp_link_process_link_status_update() - processes link status 
>> updates
>> + * @link: Display Port link module data
>> + *
>> + * This function will check for changes in the link status, e.g. 
>> clock
>> + * recovery done on all lanes, and trigger link training if there is 
>> a
>> + * failure/error on the link.
>> + *
>> + * The function will return 0 if the a link status update has been 
>> processed,
>> + * otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_link_status_update(struct dp_link_private 
>> *link)
>> +{
>> +	if (!(get_link_status(link->link_status, 
>> DP_LANE_ALIGN_STATUS_UPDATED) &
>> +		DP_LINK_STATUS_UPDATED) || /* link status updated */
>> +		(drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count) &&
>> +	     drm_dp_channel_eq_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count)))
> 
> Can you please fix the alignment here, it's tough to read.
> 
Fixed in V2.

>> +		return -EINVAL;
>> +
>> +	pr_debug("channel_eq_done = %d, clock_recovery_done = %d\n",
>> +			drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count),
>> +			drm_dp_clock_recovery_ok(link->link_status,
>> +			link->dp_link.link_params.lane_count));
>> +
>> +	return 0;
>> +}
>> +
>> +static bool dp_link_is_ds_port_status_changed(struct dp_link_private 
>> *link)
>> +{
>> +	if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) 
>> &
>> +		DP_DOWNSTREAM_PORT_STATUS_CHANGED) /* port status changed */
>> +		return true;
>> +
>> +	if (link->prev_sink_count != link->dp_link.sink_count.count)
> 
> It seems like this is running in a separate thread from where 
> prev_sink_count is
> set, potential race here?
> 
I don't think we might need locking here. All the updates/checks related 
to prev_sink_count are done
in dp_link_process_request() which will run in single threaded work 
queue.

>> +		return true;
>> +
>> +	return false;
> 
> 	return link->prev_sink_count != link->dp_link.sink_count.count;
> 
This function removed and embed in port_status_change.

>> +}
>> +
>> +/**
>> + * dp_link_process_downstream_port_status_change() - process port 
>> status changes
>> + * @link: Display Port Driver data
>> + *
>> + * This function will handle downstream port updates that are 
>> initiated by
>> + * the sink. If the downstream port status has changed, the EDID is 
>> read via
>> + * AUX.
>> + *
>> + * The function will return 0 if a downstream port update has been
>> + * processed, otherwise it will return -EINVAL.
>> + */
>> +static int dp_link_process_ds_port_status_change(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_ds_port_status_changed(link))
> 
> Just embed the contents of is_ds_port_status_changed here, no need for 
> 2 funcs
> 
Fixed in v2.

>> +		return -EINVAL;
>> +
>> +	/* reset prev_sink_count */
>> +	link->prev_sink_count = link->dp_link.sink_count.count;
>> +
>> +	return 0;
>> +}
>> +
>> +static bool dp_link_is_video_pattern_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN)
>> +		&& !(link->request.test_requested &
>> +		DP_TEST_LINK_AUDIO_DISABLED_VIDEO);
>> +}
>> +
>> +static bool dp_link_is_audio_pattern_requested(struct dp_link_private 
>> *link)
>> +{
>> +	return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN);
>> +}
>> +
>> +/**
>> + * dp_link_process_video_pattern_request() - process new video 
>> pattern request
>> + * @link: Display Port link module's data
>> + *
>> + * This function will handle a new video pattern request that are 
>> initiated by
>> + * the sink. This is acheieved by first sending a disconnect 
>> notification to
>> + * the sink followed by a subsequent connect notification to the user 
>> modules,
>> + * where it is expected that the user modules would draw the required 
>> link
>> + * pattern.
>> + */
>> +static int dp_link_process_video_pattern_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_video_pattern_requested(link))
> 
> Just do this directly in dp_link_process_request and get rid of this 
> function
> 
Updated in V2.
>> +		goto end;
>> +
>> +	pr_debug("%s: bit depth=%d(%d bpp) pattern=%s\n",
>> +		dp_link_get_test_name(DP_TEST_LINK_VIDEO_PATTERN),
>> +		link->dp_link.test_video.test_bit_depth,
>> +		dp_link_bit_depth_to_bpp(
>> +		link->dp_link.test_video.test_bit_depth),
>> +		dp_link_video_pattern_to_string(
>> +			link->dp_link.test_video.test_video_pattern));
>> +
>> +	return 0;
>> +end:
>> +	return -EINVAL;
>> +}
>> +
>> +/**
>> + * dp_link_process_audio_pattern_request() - process new audio 
>> pattern request
>> + * @link: Display Port link module data
>> + *
>> + * This function will handle a new audio pattern request that is 
>> initiated by
>> + * the sink. This is acheieved by sending the necessary secondary 
>> data packets
>> + * to the sink. It is expected that any simulatenous requests for 
>> video
>> + * patterns will be handled before the audio pattern is sent to the 
>> sink.
>> + */
>> +static int dp_link_process_audio_pattern_request(struct 
>> dp_link_private *link)
>> +{
>> +	if (!dp_link_is_audio_pattern_requested(link))
> 
> Same here
> 
Updated in V2.

>> +		return -EINVAL;
>> +
>> +	pr_debug("sampling_rate=%s, channel_count=%d, pattern_type=%s\n",
>> +		dp_link_get_audio_sample_rate(
>> +			link->dp_link.test_audio.test_audio_sampling_rate),
>> +		link->dp_link.test_audio.test_audio_channel_count,
>> +		dp_link_get_audio_test_pattern(
>> +			link->dp_link.test_audio.test_audio_pattern_type));
>> +
>> +	pr_debug("audio_period: ch1=0x%x, ch2=0x%x, ch3=0x%x, ch4=0x%x\n",
>> +		link->dp_link.test_audio.test_audio_period_ch_1,
>> +		link->dp_link.test_audio.test_audio_period_ch_2,
>> +		link->dp_link.test_audio.test_audio_period_ch_3,
>> +		link->dp_link.test_audio.test_audio_period_ch_4);
>> +
>> +	pr_debug("audio_period: ch5=0x%x, ch6=0x%x, ch7=0x%x, ch8=0x%x\n",
>> +		link->dp_link.test_audio.test_audio_period_ch_5,
>> +		link->dp_link.test_audio.test_audio_period_ch_6,
>> +		link->dp_link.test_audio.test_audio_period_ch_7,
>> +		link->dp_link.test_audio.test_audio_period_ch_8);
>> +
>> +	return 0;
>> +}
>> +
>> +static void dp_link_reset_data(struct dp_link_private *link)
>> +{
>> +	link->request = (const struct dp_link_request){ 0 };
>> +	link->dp_link.test_video = (const struct dp_link_test_video){ 0 };
>> +	link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN;
>> +	link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 };
>> +	link->dp_link.phy_params.phy_test_pattern_sel = 0;
>> +	link->dp_link.sink_request = 0;
>> +	link->dp_link.test_response = 0;
> 
> 	memset?
> 

We are resetting only the test parameters. We will retain all other info 
in dp_link structure.

>> +}
>> +
>> +/**
>> + * dp_link_process_request() - handle HPD IRQ transition to HIGH
>> + * @link: pointer to link module data
>> + *
>> + * This function will handle the HPD IRQ state transitions from LOW 
>> to HIGH
>> + * (including cases when there are back to back HPD IRQ HIGH) 
>> indicating
>> + * the start of a new link training request or sink status update.
>> + */
>> +static int dp_link_process_request(struct dp_link *dp_link)
>> +{
>> +	int ret = 0;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	pr_debug("start\n");
>> +
>> +	dp_link_reset_data(link);
>> +
>> +	dp_link_parse_sink_status_field(link);
>> +
>> +	if (dp_link_is_test_edid_read(link)) {
>> +		dp_link->sink_request |= DP_TEST_LINK_EDID_READ;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_ds_port_status_change(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DS_PORT_STATUS_CHANGED;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_link_training_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_TRAINING;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_phy_test_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_link_status_update(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_LINK_STATUS_UPDATED;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_video_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	ret = dp_link_process_audio_pattern_request(link);
>> +	if (!ret) {
>> +		dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN;
>> +		goto exit;
>> +	}
>> +
>> +	pr_debug("done\n");
>> +exit:
> 
> remove exit & ret, just return values directly
> 
Fixed in V2.

>> +	return ret;
>> +}
>> +
>> +static int dp_link_get_colorimetry_config(struct dp_link *dp_link)
>> +{
>> +	u32 cc;
>> +	enum dynamic_range dr;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	/* unless a video pattern CTS test is ongoing, use CEA_VESA */
> 
> s/CEA_VESA/RGB_VESA?
> 
Fixed in V2.

>> +	if (dp_link_is_video_pattern_requested(link))
>> +		dr = link->dp_link.test_video.test_dyn_range;
>> +	else
>> +		dr = DP_DYNAMIC_RANGE_RGB_VESA;
>> +
>> +	/* Only RGB_VESA nd RGB_CEA supported for now */
> 
> s/nd/and/
> 
Fixed in v2.

>> +	switch (dr) {
>> +	case DP_DYNAMIC_RANGE_RGB_CEA:
>> +		cc = BIT(3);
>> +		break;
>> +	case DP_DYNAMIC_RANGE_RGB_VESA:
>> +	default:
>> +		cc = 0;
>> +	}
> 
> If you store the value shifted like I suggested, you don't have to do 
> this
> switch (which really should be an if anyways since the range is 0:1).
> 
Addressed in v2.

>> +
>> +	return cc;
>> +}
>> +
>> +static int dp_link_adjust_levels(struct dp_link *dp_link, u8 
>> *link_status)
>> +{
>> +	int i;
>> +	int max = 0;
>> +	u8 data;
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	/* use the max level across lanes */
>> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
>> +		data = drm_dp_get_adjust_request_voltage(link_status, i);
>> +		pr_debug("lane=%d req_voltage_swing=%d\n", i, data);
>> +		if (max < data)
>> +			max = data;
>> +	}
>> +
>> +	dp_link->phy_params.v_level = max >> DP_TRAIN_VOLTAGE_SWING_SHIFT;
>> +
>> +	/* use the max level across lanes */
>> +	max = 0;
>> +	for (i = 0; i < dp_link->link_params.lane_count; i++) {
>> +		data = drm_dp_get_adjust_request_pre_emphasis(link_status, i);
>> +		pr_debug("lane=%d req_pre_emphasis=%d\n", i, data);
>> +		if (max < data)
>> +			max = data;
>> +	}
> 
> You can combine these loops and do the work at once (check out
> intel_get_adjust_train)
> 
Will follow up in V3.
>> +
>> +	dp_link->phy_params.p_level = max >> DP_TRAIN_PRE_EMPHASIS_SHIFT;
>> +
>> +	/**
>> +	 * Adjust the voltage swing and pre-emphasis level combination to 
>> within
>> +	 * the allowable range.
>> +	 */
>> +	if (dp_link->phy_params.v_level > DP_LINK_VOLTAGE_MAX) {
>> +		pr_debug("Requested vSwingLevel=%d, change to %d\n",
>> +			dp_link->phy_params.v_level, DP_LINK_VOLTAGE_MAX);
>> +		dp_link->phy_params.v_level = DP_LINK_VOLTAGE_MAX;
>> +	}
>> +
>> +	if (dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_MAX) {
>> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
>> +			dp_link->phy_params.p_level, DP_LINK_PRE_EMPHASIS_MAX);
>> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_MAX;
>> +	}
>> +
>> +	if ((dp_link->phy_params.p_level > DP_LINK_PRE_EMPHASIS_LEVEL_1)
>> +		&& (dp_link->phy_params.v_level == DP_LINK_VOLTAGE_LEVEL_2)) {
>> +		pr_debug("Requested preEmphasisLevel=%d, change to %d\n",
>> +			dp_link->phy_params.p_level,
>> +			DP_LINK_PRE_EMPHASIS_LEVEL_1);
>> +		dp_link->phy_params.p_level = DP_LINK_PRE_EMPHASIS_LEVEL_1;
>> +	}
>> +
>> +	pr_debug("adjusted: v_level=%d, p_level=%d\n",
>> +		dp_link->phy_params.v_level, dp_link->phy_params.p_level);
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_link_send_psm_request(struct dp_link *dp_link, bool 
>> req)
>> +{
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
> 
> This is a stub, why do this?
> 
>> +
>> +	return 0;
> 
> Further, why have a stub at all? The hook is never called, so delete it 
> all
> please.
> 
Removed this function in V2.
>> +}
>> +
>> +static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 
>> bpp)
>> +{
>> +	u32 tbd;
>> +
>> +	/*
>> +	 * Few simplistic rules and assumptions made here:
>> +	 *    1. Test bit depth is bit depth per color component
>> +	 *    2. Assume 3 color components
>> +	 */
>> +	switch (bpp) {
>> +	case 18:
>> +		tbd = DP_TEST_BIT_DEPTH_6;
>> +		break;
>> +	case 24:
>> +		tbd = DP_TEST_BIT_DEPTH_8;
>> +		break;
>> +	case 30:
>> +		tbd = DP_TEST_BIT_DEPTH_10;
>> +		break;
>> +	default:
>> +		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
>> +		break;
>> +	}
>> +
>> +	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
>> +		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
> 
> AFAICT tbd corresponds to a SoC register value, as opposed to the DPCD 
> value.
> It's a happy coincidence that they're the same, however I think you 
> should use a
> separate msm-specific #define instead of the drm_dp_helper values.
> 
These are standard bpp values and will match to the DPCD values. For the 
same reason
we are using existing standard macros.

>> +
>> +	return tbd;
>> +}
>> +
>> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux)
>> +{
>> +	int rc = 0;
>> +	struct dp_link_private *link;
>> +	struct dp_link *dp_link;
>> +
>> +	if (!dev || !aux) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL);
>> +	if (!link) {
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	link->dev   = dev;
>> +	link->aux   = aux;
>> +
>> +	dp_link = &link->dp_link;
>> +
>> +	dp_link->process_request        = dp_link_process_request;
>> +	dp_link->get_test_bits_depth    = dp_link_get_test_bits_depth;
>> +	dp_link->get_colorimetry_config = dp_link_get_colorimetry_config;
>> +	dp_link->adjust_levels          = dp_link_adjust_levels;
>> +	dp_link->send_psm_request       = dp_link_send_psm_request;
>> +	dp_link->send_test_response     = dp_link_send_test_response;
>> +	dp_link->psm_config             = dp_link_psm_config;
>> +	dp_link->send_edid_checksum     = dp_link_send_edid_checksum;
>> +
>> +	return dp_link;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_link_put(struct dp_link *dp_link)
>> +{
>> +	struct dp_link_private *link;
>> +
>> +	if (!dp_link)
>> +		return;
>> +
>> +	link = container_of(dp_link, struct dp_link_private, dp_link);
>> +
>> +	devm_kfree(link->dev, link);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_link.h 
>> b/drivers/gpu/drm/msm/dp/dp_link.h
>> new file mode 100644
>> index 0000000..6d6ef43
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_link.h
>> @@ -0,0 +1,184 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_LINK_H_
>> +#define _DP_LINK_H_
>> +
>> +#include "dp_aux.h"
>> +
>> +#define DS_PORT_STATUS_CHANGED 0x200
>> +#define DP_TEST_BIT_DEPTH_UNKNOWN 0xFFFFFFFF
>> +#define DP_LINK_ENUM_STR(x)		#x
>> +
>> +enum dp_link_voltage_level {
>> +	DP_LINK_VOLTAGE_LEVEL_0	= 0,
>> +	DP_LINK_VOLTAGE_LEVEL_1	= 1,
>> +	DP_LINK_VOLTAGE_LEVEL_2	= 2,
>> +	DP_LINK_VOLTAGE_MAX	= DP_LINK_VOLTAGE_LEVEL_2,
>> +};
> 
> DP_TRAIN_VOLTAGE_SWING_*
> 
Fixed in V2.
>> +
>> +enum dp_link_preemaphasis_level {
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_0	= 0,
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_1	= 1,
>> +	DP_LINK_PRE_EMPHASIS_LEVEL_2	= 2,
>> +	DP_LINK_PRE_EMPHASIS_MAX	= DP_LINK_PRE_EMPHASIS_LEVEL_2,
>> +};
> 
> DP_TRAIN_PRE_EMPH*
> 
Fixed in V2.

>> +
>> +struct dp_link_sink_count {
>> +	u32 count;
>> +	bool cp_ready;
>> +};
>> +
>> +struct dp_link_test_video {
>> +	u32 test_video_pattern;
>> +	u32 test_bit_depth;
>> +	u32 test_dyn_range;
>> +	u32 test_h_total;
>> +	u32 test_v_total;
>> +	u32 test_h_start;
>> +	u32 test_v_start;
>> +	u32 test_hsync_pol;
>> +	u32 test_hsync_width;
>> +	u32 test_vsync_pol;
>> +	u32 test_vsync_width;
>> +	u32 test_h_width;
>> +	u32 test_v_height;
>> +	u32 test_rr_d;
>> +	u32 test_rr_n;
>> +};
>> +
>> +struct dp_link_test_audio {
>> +	u32 test_audio_sampling_rate;
>> +	u32 test_audio_channel_count;
>> +	u32 test_audio_pattern_type;
>> +	u32 test_audio_period_ch_1;
>> +	u32 test_audio_period_ch_2;
>> +	u32 test_audio_period_ch_3;
>> +	u32 test_audio_period_ch_4;
>> +	u32 test_audio_period_ch_5;
>> +	u32 test_audio_period_ch_6;
>> +	u32 test_audio_period_ch_7;
>> +	u32 test_audio_period_ch_8;
>> +};
>> +
>> +struct dp_link_phy_params {
>> +	u32 phy_test_pattern_sel;
>> +	u8 v_level;
>> +	u8 p_level;
>> +};
>> +
>> +struct dp_link_params {
>> +	u32 lane_count;
>> +	u32 bw_code;
>> +};
> 
> Use drm_dp_link
> 
Fixed in V2.

>> +
>> +struct dp_link {
>> +	u32 sink_request;
>> +	u32 test_response;
>> +	bool psm_enabled;
>> +
>> +	struct dp_link_sink_count sink_count;
>> +	struct dp_link_test_video test_video;
>> +	struct dp_link_test_audio test_audio;
>> +	struct dp_link_phy_params phy_params;
>> +	struct dp_link_params link_params;
>> +
>> +	u32 (*get_test_bits_depth)(struct dp_link *dp_link, u32 bpp);
>> +	int (*process_request)(struct dp_link *dp_link);
>> +	int (*get_colorimetry_config)(struct dp_link *dp_link);
>> +	int (*adjust_levels)(struct dp_link *dp_link, u8 *link_status);
>> +	int (*send_psm_request)(struct dp_link *dp_link, bool req);
>> +	void (*send_test_response)(struct dp_link *dp_link);
>> +	int (*psm_config)(struct dp_link *dp_link,
>> +		struct drm_dp_link *link_info, bool enable);
>> +	void (*send_edid_checksum)(struct dp_link *dp_link, u8 checksum);
>> +};
>> +
>> +static inline char *dp_link_get_phy_test_pattern(u32 
>> phy_test_pattern_sel)
>> +{
>> +	switch (phy_test_pattern_sel) {
>> +	case DP_TEST_PHY_PATTERN_NONE:
>> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_NONE);
>> +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING);
>> +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT);
>> +	case DP_TEST_PHY_PATTERN_PRBS7:
>> +		return DP_LINK_ENUM_STR(DP_TEST_PHY_PATTERN_PRBS7);
>> +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN);
>> +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
>> +		return DP_LINK_ENUM_STR(
>> +			DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> This is only used for debug statements, just remove it and print the 
> enum as an
> int. This will let you remove DP_LINK_ENUM_STR as well.
> 
Fixed in V2.

>> +
>> +/**
>> + * mdss_dp_test_bit_depth_to_bpp() - convert test bit depth to bpp
>> + * @tbd: test bit depth
>> + *
>> + * Returns the bits per pixel (bpp) to be used corresponding to the
>> + * git bit depth value. This function assumes that bit depth has
>> + * already been validated.
>> + */
>> +static inline u32 dp_link_bit_depth_to_bpp(u32 tbd)
>> +{
>> +	u32 bpp;
>> +
>> +	/*
>> +	 * Few simplistic rules and assumptions made here:
>> +	 *    1. Bit depth is per color component
>> +	 *    2. If bit depth is unknown return 0
>> +	 *    3. Assume 3 color components
>> +	 */
>> +	switch (tbd) {
>> +	case DP_TEST_BIT_DEPTH_6:
>> +		bpp = 18;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_8:
>> +		bpp = 24;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_10:
>> +		bpp = 30;
>> +		break;
>> +	case DP_TEST_BIT_DEPTH_UNKNOWN:
>> +	default:
>> +		bpp = 0;
>> +	}
>> +
>> +	return bpp;
> 
> Just return directly from each case.
> 
Fixed in V2.

>> +}
>> +
>> +/**
>> + * dp_link_get() - get the functionalities of dp test module
>> + *
>> + *
>> + * return: a pointer to dp_link struct
>> + */
>> +struct dp_link *dp_link_get(struct device *dev, struct dp_aux *aux);
>> +
>> +/**
>> + * dp_link_put() - releases the dp test module's resources
>> + *
>> + * @dp_link: an instance of dp_link module
>> + *
>> + */
>> +void dp_link_put(struct dp_link *dp_link);
>> +
>> +#endif /* _DP_LINK_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.c 
>> b/drivers/gpu/drm/msm/dp/dp_panel.c
>> new file mode 100644
>> index 0000000..e497b44
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_panel.c
>> @@ -0,0 +1,624 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include "dp_panel.h"
>> +
>> +#include <drm/drm_connector.h>
>> +#include <drm/drm_edid.h>
>> +
>> +#define DP_PANEL_DEFAULT_BPP 24
> 
> unused
> 
Removed in V2.

>> +#define DP_MAX_DS_PORT_COUNT 1
>> +
>> +enum {
>> +	DP_LINK_RATE_MULTIPLIER = 27000000,
>> +};
> 
> unused
> 
Removed in V2.

>> +
>> +struct dp_panel_private {
>> +	struct device *dev;
>> +	struct dp_panel dp_panel;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_catalog_panel *catalog;
>> +	bool panel_on;
>> +	bool aux_cfg_update_done;
>> +};
>> +
>> +static const struct dp_panel_info fail_safe = {
>> +	.h_active = 640,
>> +	.v_active = 480,
>> +	.h_back_porch = 48,
>> +	.h_front_porch = 16,
>> +	.h_sync_width = 96,
>> +	.h_active_low = 0,
>> +	.v_back_porch = 33,
>> +	.v_front_porch = 10,
>> +	.v_sync_width = 2,
>> +	.v_active_low = 0,
>> +	.h_skew = 0,
>> +	.refresh_rate = 60,
>> +	.pixel_clk_khz = 25200,
>> +	.bpp = 24,
>> +};
> 
> Drop this, userspace can add a mode if appropriate
> 
Removed fail_safe logic completely in V2.

>> +
>> +static int dp_panel_read_dpcd(struct dp_panel *dp_panel)
>> +{
>> +	int rlen, rc = 0;
>> +	struct dp_panel_private *panel;
>> +	struct drm_dp_link *link_info;
>> +	u8 *dpcd, major = 0, minor = 0;
>> +	u32 dfp_count = 0;
>> +	unsigned long caps = DP_LINK_CAP_ENHANCED_FRAMING;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	dpcd = dp_panel->dpcd;
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	link_info = &dp_panel->link_info;
>> +
>> +	rlen = drm_dp_dpcd_read(panel->aux->drm_aux, DP_DPCD_REV,
>> +		dpcd, (DP_RECEIVER_CAP_SIZE + 1));
>> +	if (rlen < (DP_RECEIVER_CAP_SIZE + 1)) {
>> +		pr_err("dpcd read failed, rlen=%d\n", rlen);
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	link_info->revision = dp_panel->dpcd[DP_DPCD_REV];
>> +
>> +	major = (link_info->revision >> 4) & 0x0f;
>> +	minor = link_info->revision & 0x0f;
>> +	pr_debug("version: %d.%d\n", major, minor);
>> +
>> +	link_info->rate =
>> +		drm_dp_bw_code_to_link_rate(dp_panel->dpcd[DP_MAX_LINK_RATE]);
>> +	pr_debug("link_rate=%d\n", link_info->rate);
>> +
>> +	link_info->num_lanes = dp_panel->dpcd[DP_MAX_LANE_COUNT] &
>> +				DP_MAX_LANE_COUNT_MASK;
>> +
>> +	pr_debug("lane_count=%d\n", link_info->num_lanes);
>> +
>> +	if (drm_dp_enhanced_frame_cap(dpcd))
>> +		link_info->capabilities |= caps;
> 
> All of the link_info initialization should be done by 
> drm_dp_link_probe().
> 
Will address this in V3.


>> +
>> +	dfp_count = dpcd[DP_DOWN_STREAM_PORT_COUNT] &
>> +						DP_DOWN_STREAM_PORT_COUNT;
> 
> Move this down to where it's used
> 
Fixed in V2.

>> +
>> +	if ((dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)
>> +		&& (dpcd[DP_DPCD_REV] > 0x10)) {
>> +		rlen = drm_dp_dpcd_read(panel->aux->drm_aux,
>> +			DP_DOWNSTREAM_PORT_0, dp_panel->ds_ports,
>> +			DP_MAX_DOWNSTREAM_PORTS);
>> +		if (rlen < DP_MAX_DOWNSTREAM_PORTS) {
>> +			pr_err("ds port status failed, rlen=%d\n", rlen);
>> +			rc = -EINVAL;
>> +			goto end;
>> +		}
>> +	}
> 
> You don't use ds_ports anywhere, so remove this and remove ds_ports
> 
Fixed in V2.
>> +
>> +	if (dfp_count > DP_MAX_DS_PORT_COUNT)
>> +		pr_debug("DS port count %d greater that max (%d) supported\n",
>> +			dfp_count, DP_MAX_DS_PORT_COUNT);
> 
> Should this be an error?
> 
>> +
>> +end:
>> +	return rc;
> 
> Same drill as before
> 
Fixed in V2.
>> +}
>> +
>> +static int dp_panel_set_default_link_params(struct dp_panel 
>> *dp_panel)
>> +{
> 
> Let's just fail instead of doing this.
> 
Removed this func in V2.

>> +	struct drm_dp_link *link_info;
>> +	const int default_bw_code = 162000;
>> +	const int default_num_lanes = 1;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +	link_info = &dp_panel->link_info;
>> +	link_info->rate = default_bw_code;
>> +	link_info->num_lanes = default_num_lanes;
>> +	pr_debug("link_rate=%d num_lanes=%d\n",
>> +		link_info->rate, link_info->num_lanes);
>> +	return 0;
>> +}
>> +
>> +static int dp_panel_read_edid(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector)
>> +{
>> +	int retry_cnt = 0;
>> +	const int max_retry = 10;
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	do {
>> +		kfree(dp_panel->edid);
>> +		dp_panel->edid = drm_get_edid(connector,
>> +					      &panel->aux->drm_aux->ddc);
>> +		if (!dp_panel->edid) {
>> +			pr_err("EDID read failed\n");
>> +			retry_cnt++;
>> +			panel->aux->reconfig(panel->aux);
>> +			panel->aux_cfg_update_done = true;
>> +		} else {
>> +			return 0;
>> +		}
>> +	} while (retry_cnt < max_retry);
> 
> The core will do retrys when aux reads fail, so you don't need to. With 
> that,
> you can just remove this function and call drm_get_edid in 
> read_sink_caps
> 
Will address this in V3.

>> +
>> +	return -EINVAL;
>> +}
>> +
>> +static int dp_panel_read_sink_caps(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel || !connector) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	rc = dp_panel_read_dpcd(dp_panel);
>> +	if (rc || !is_link_rate_valid(drm_dp_link_rate_to_bw_code(
>> +		dp_panel->link_info.rate)) || !is_lane_count_valid(
>> +		dp_panel->link_info.num_lanes) ||
>> +		((drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate)) >
>> +		dp_panel->max_bw_code)) {
>> +		if ((rc == -ETIMEDOUT) || (rc == -ENODEV)) {
>> +			pr_err("DPCD read failed, return early\n");
>> +			return rc;
>> +		}
>> +		pr_err("panel dpcd read failed/incorrect, set default params\n");
>> +		dp_panel_set_default_link_params(dp_panel);
>> +	}
> 
> Since the defaults are going away, this gets simpler (and even simpler 
> if you
> stash bw_code):
> 
> 	bw_code = drm_dp_link_rate_to_bw_code(dp_panel->link_info.rate);
> 	if (rc || !is_link_rate_valid(bw_code) ||
>             !is_lane_count_valid(dp_panel->link_info.num_lanes) ||
> 	    bw_code > dp_panel->max_bw_code) {
> 		pr_err("read_dpcd failed %d\n", rc);
> 		return rc;
> 	}
> 
Updated in V2.

>> +
>> +	rc = dp_panel_read_edid(dp_panel, connector);
> 
> Why read the edid so early? Can't you wait until get_modes is called 
> (you'll
> have to re-read anyways).
> 
We won't do re-read again when get_modes is called.

>> +	if (rc) {
>> +		pr_err("panel edid read failed, set failsafe mode\n");
>> +		return rc;
>> +	}
>> +
>> +	if (panel->aux_cfg_update_done) {
>> +		pr_debug("read DPCD with updated AUX config\n");
>> +		dp_panel_read_dpcd(dp_panel);
> 
> Check return value. Should you also check the rate/lane_count validity
> again too?
> 
Fixed in V2.

>> +		panel->aux_cfg_update_done = false;
> 
> Should you have locking for aux_cfg_update_done?
> 
panel_read_edid() and aux_cfg_update_done = false is done one after the 
other in this function. I don't think
we locking for this.

>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>> +{
>> +	struct drm_dp_link *link_info;
>> +	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
>> +	u32 bpp = 0, data_rate_khz = 0;
>> +
>> +	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
>> +
>> +	link_info = &dp_panel->link_info;
>> +	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
>> +
>> +	while (bpp > min_supported_bpp) {
>> +		if (mode_pclk_khz * bpp <= data_rate_khz)
>> +			break;
>> +		bpp -= 6;
> 
> Watch out for underflow here.
> 
Will add check in V3 patch series.

>> +	}
>> +
>> +	return bpp;
>> +}
>> +
>> +static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>> +{
>> +	struct dp_panel_private *panel;
>> +	u32 bpp = mode_edid_bpp;
>> +
>> +	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
>> +		pr_err("invalid input\n");
>> +		return 0;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (dp_panel->video_test)
>> +		bpp = dp_link_bit_depth_to_bpp(
>> +				panel->link->test_video.test_bit_depth);
>> +	else
>> +		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
>> +				mode_pclk_khz);
>> +
>> +	return bpp;
>> +}
>> +
>> +static void dp_panel_set_test_mode(struct dp_panel_private *panel,
>> +		struct dp_display_mode *mode)
>> +{
>> +	struct dp_panel_info *pinfo = NULL;
> 
> 
> As mentioned earlier, no need to duplicate drm_display_mode into
> dp_display_mode, same goes for dp_panel_info, please just use 
> drm_display_mode.
> 
Fixed in V2.

>> +	struct dp_link_test_video *test_info = NULL;
>> +
>> +	if (!panel) {
>> +		pr_err("invalid params\n");
>> +		return;
>> +	}
>> +
>> +	pinfo = &mode->timing;
>> +	test_info = &panel->link->test_video;
>> +
>> +	pinfo->h_active = test_info->test_h_width;
>> +	pinfo->h_sync_width = test_info->test_hsync_width;
>> +	pinfo->h_back_porch = test_info->test_h_start -
>> +		test_info->test_hsync_width;
>> +	pinfo->h_front_porch = test_info->test_h_total -
>> +		(test_info->test_h_start + test_info->test_h_width);
>> +
>> +	pinfo->v_active = test_info->test_v_height;
>> +	pinfo->v_sync_width = test_info->test_vsync_width;
>> +	pinfo->v_back_porch = test_info->test_v_start -
>> +		test_info->test_vsync_width;
>> +	pinfo->v_front_porch = test_info->test_v_total -
>> +		(test_info->test_v_start + test_info->test_v_height);
>> +
>> +	pinfo->bpp = dp_link_bit_depth_to_bpp(test_info->test_bit_depth);
>> +	pinfo->h_active_low = test_info->test_hsync_pol;
>> +	pinfo->v_active_low = test_info->test_vsync_pol;
>> +
>> +	pinfo->refresh_rate = test_info->test_rr_n;
>> +	pinfo->pixel_clk_khz = test_info->test_h_total *
>> +		test_info->test_v_total * pinfo->refresh_rate;
>> +
>> +	if (test_info->test_rr_d == 0)
>> +		pinfo->pixel_clk_khz /= 1000;
>> +	else
>> +		pinfo->pixel_clk_khz /= 1001;
>> +
>> +	if (test_info->test_h_width == 640)
>> +		pinfo->pixel_clk_khz = 25170;
>> +}
>> +
>> +static int dp_panel_update_modes(struct drm_connector *connector,
>> +	struct edid *edid)
>> +{
>> +	int rc = 0;
>> +
>> +	pr_debug("%s +", __func__);
> 
> remove
> 
Fixed in V2.

> Ok, so this is where you should be reading edid.
> 
>> +	if (edid) {
>> +		drm_connector_update_edid_property(connector,
>> +			edid);
> 
> Join on one line and check return value
> 
Fixed in v2.

>> +		rc = drm_add_edid_modes(connector, edid);
>> +		pr_debug("%s -", __func__);
>> +		return rc;
>> +	}
>> +
>> +	drm_connector_update_edid_property(connector, NULL);
> 
> Check return value
> 
Fixed in V2.

>> +	pr_debug("%s null edid -", __func__);
>> +	return rc;
> 
> This is always 0
> 
Fixed it in V2.

>> +}
>> +
>> +static int dp_panel_get_modes(struct dp_panel *dp_panel,
>> +	struct drm_connector *connector, struct dp_display_mode *mode)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (dp_panel->video_test) {
>> +		dp_panel_set_test_mode(panel, mode);
>> +		return 1;
>> +	} else if (dp_panel->edid) {
>> +	  return dp_panel_update_modes(connector, dp_panel->edid);
> 
> Indentation is wrong
> 
Fixed in v2.

>> +	}
>> +
>> +	/* fail-safe mode */
>> +	memcpy(&mode->timing, &fail_safe,
>> +		sizeof(fail_safe));
>> +	return 1;
> 
> Delete fail safe and return 0;
> 
Removed fail_safe in V2.

>> +}
>> +
>> +static u8 dp_panel_get_edid_checksum(struct edid *edid)
>> +{
>> +	struct edid *last_block = NULL;
>> +	u8 *raw_edid = NULL;
> 
> No need to initialize these.
> 
Fixed in V2.

>> +
>> +	if (!edid) {
>> +		pr_err("invalid edid input\n");
>> +		return 0;
>> +	}
>> +
>> +	raw_edid = (u8 *)edid;
>> +	raw_edid += (edid->extensions * EDID_LENGTH);
>> +	last_block = (struct edid *)raw_edid;
>> +
>> +	if (last_block)
> 
> I doubt last_block will ever be NULL, so this check is kind of 
> pointless.
> Perhaps call drm_edid_block_valid() instead.
> 
Addressed in V2.

>> +		return last_block->checksum;
>> +
>> +	pr_err("Invalid block, no checksum\n");
>> +	return 0;
>> +}
>> +
>> +static void dp_panel_handle_sink_request(struct dp_panel *dp_panel)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	if (panel->link->sink_request & DP_TEST_LINK_EDID_READ) {
>> +		u8 checksum = dp_panel_get_edid_checksum(dp_panel->edid);
>> +
>> +		panel->link->send_edid_checksum(panel->link, checksum);
>> +		panel->link->send_test_response(panel->link);
>> +	}
>> +}
>> +
>> +static void dp_panel_tpg_config(struct dp_panel *dp_panel, bool 
>> enable)
>> +{
>> +	u32 hsync_start_x, hsync_end_x;
>> +	struct dp_catalog_panel *catalog;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	catalog = panel->catalog;
>> +	pinfo = &panel->dp_panel.pinfo;
>> +
>> +	if (!panel->panel_on) {
>> +		pr_debug("DP panel not enabled, handle TPG on next panel on\n");
>> +		return;
>> +	}
>> +
>> +	if (!enable) {
>> +		panel->catalog->tpg_config(catalog, false);
>> +		return;
>> +	}
>> +
>> +	/* TPG config */
>> +	catalog->hsync_period = pinfo->h_sync_width + pinfo->h_back_porch +
>> +			pinfo->h_active + pinfo->h_front_porch;
>> +	catalog->vsync_period = pinfo->v_sync_width + pinfo->v_back_porch +
>> +			pinfo->v_active + pinfo->v_front_porch;
>> +
>> +	catalog->display_v_start = ((pinfo->v_sync_width +
>> +			pinfo->v_back_porch) * catalog->hsync_period);
>> +	catalog->display_v_end = ((catalog->vsync_period -
>> +			pinfo->v_front_porch) * catalog->hsync_period) - 1;
>> +
>> +	catalog->display_v_start += pinfo->h_sync_width + 
>> pinfo->h_back_porch;
>> +	catalog->display_v_end -= pinfo->h_front_porch;
>> +
>> +	hsync_start_x = pinfo->h_back_porch + pinfo->h_sync_width;
>> +	hsync_end_x = catalog->hsync_period - pinfo->h_front_porch - 1;
>> +
>> +	catalog->v_sync_width = pinfo->v_sync_width;
>> +
>> +	catalog->hsync_ctl = (catalog->hsync_period << 16) |
>> +			pinfo->h_sync_width;
>> +	catalog->display_hctl = (hsync_end_x << 16) | hsync_start_x;
> 
> More mode timing parameters to delete!
> 
Fixed in V2.

>> +
>> +	pr_err("%s: calling catalog tpg_config\n", __func__);
>> +	panel->catalog->tpg_config(catalog, true);
>> +}
>> +
>> +static int dp_panel_timing_cfg(struct dp_panel *dp_panel)
>> +{
>> +	int rc = 0;
>> +	u32 data, total_ver, total_hor;
>> +	struct dp_catalog_panel *catalog;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
> This is called from 2 different places, do you need locking?
> 
This is called only from dp_ctrl.c file (Called from one place only)

>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +	catalog = panel->catalog;
>> +	pinfo = &panel->dp_panel.pinfo;
>> +
>> +	pr_debug("width=%d hporch= %d %d %d\n",
>> +		pinfo->h_active, pinfo->h_back_porch,
>> +		pinfo->h_front_porch, pinfo->h_sync_width);
>> +
>> +	pr_debug("height=%d vporch= %d %d %d\n",
>> +		pinfo->v_active, pinfo->v_back_porch,
>> +		pinfo->v_front_porch, pinfo->v_sync_width);
>> +
>> +	total_hor = pinfo->h_active + pinfo->h_back_porch +
>> +		pinfo->h_front_porch + pinfo->h_sync_width;
>> +
>> +	total_ver = pinfo->v_active + pinfo->v_back_porch +
>> +			pinfo->v_front_porch + pinfo->v_sync_width;
>> +
>> +	data = total_ver;
>> +	data <<= 16;
>> +	data |= total_hor;
>> +
>> +	catalog->total = data;
>> +
>> +	data = (pinfo->v_back_porch + pinfo->v_sync_width);
>> +	data <<= 16;
>> +	data |= (pinfo->h_back_porch + pinfo->h_sync_width);
>> +
>> +	catalog->sync_start = data;
>> +
>> +	data = pinfo->v_sync_width;
>> +	data <<= 16;
>> +	data |= (pinfo->v_active_low << 31);
>> +	data |= pinfo->h_sync_width;
>> +	data |= (pinfo->h_active_low << 15);
>> +
>> +	catalog->width_blanking = data;
>> +
>> +	data = pinfo->v_active;
>> +	data <<= 16;
>> +	data |= pinfo->h_active;
>> +
>> +	catalog->dp_active = data;
>> +
>> +	panel->catalog->timing_cfg(catalog);
>> +	panel->panel_on = true;
> 
> Again, all of this should be derived from a drm_display_mode at the 
> point where
> it is committed to hardware. No need to store it in another form in the 
> interim
> 
Fixed in v2.

> 
>> +end:
>> +	return rc;
> 
> Remove end/rc and return directly
> 
Fixed in V2.

>> +}
>> +
>> +static int dp_panel_init_panel_info(struct dp_panel *dp_panel)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto end;
>> +	}
>> +
>> +	pinfo = &dp_panel->pinfo;
>> +
>> +	/*
>> +	 * print resolution info as this is a result
>> +	 * of user initiated action of cable connection
>> +	 */
>> +	pr_info("SET NEW RESOLUTION:\n");
>> +	pr_info("%dx%d@%dfps\n", pinfo->h_active,
>> +		pinfo->v_active, pinfo->refresh_rate);
>> +	pr_info("h_porches(back|front|width) = (%d|%d|%d)\n",
>> +			pinfo->h_back_porch,
>> +			pinfo->h_front_porch,
>> +			pinfo->h_sync_width);
>> +	pr_info("v_porches(back|front|width) = (%d|%d|%d)\n",
>> +			pinfo->v_back_porch,
>> +			pinfo->v_front_porch,
>> +			pinfo->v_sync_width);
>> +	pr_info("pixel clock (KHz)=(%d)\n", pinfo->pixel_clk_khz);
>> +	pr_info("bpp = %d\n", pinfo->bpp);
>> +	pr_info("active low (h|v)=(%d|%d)\n", pinfo->h_active_low,
>> +		pinfo->v_active_low);
>> +
>> +	pinfo->bpp = max_t(u32, 18, min_t(u32, pinfo->bpp, 30));
>> +	pr_info("updated bpp = %d\n", pinfo->bpp);
> 
> 
> No info level logs, please.
> 
Changed them to DRM_DEBUG_DP in V2.

>> +end:
>> +	return rc;
> 
> Remove end/rc and return directly
> 
Fixed in V2.

>> +}
>> +
>> +static u32 dp_panel_get_min_req_link_rate(struct dp_panel *dp_panel)
>> +{
>> +	const u32 encoding_factx10 = 8;
>> +	u32 min_link_rate_khz = 0, lane_cnt;
>> +	struct dp_panel_info *pinfo;
>> +
>> +	if (!dp_panel) {
> 
> The only way to call this function is through a dp_panel callback, and 
> yet we
> check if dp_panel is NULL :)
> 
> The same is true for most functions in this patch. Things will be a lot 
> simpler
> when all of these are removed. This function will no longer have an 
> error path
> and lane_cnt/pinfo can be initialized directly above.
> 
> 
Fixed in v2.

>> +		pr_err("invalid input\n");
>> +		goto end;
>> +	}
>> +
>> +	lane_cnt = dp_panel->link_info.num_lanes;
>> +	pinfo = &dp_panel->pinfo;
>> +
>> +	/* num_lanes * lane_count * 8 >= pclk * bpp * 10 */
>> +	min_link_rate_khz = pinfo->pixel_clk_khz /
>> +				(lane_cnt * encoding_factx10);
>> +	min_link_rate_khz *= pinfo->bpp;
>> +
>> +	pr_debug("min lclk req=%d khz for pclk=%d khz, lanes=%d, bpp=%d\n",
>> +		min_link_rate_khz, pinfo->pixel_clk_khz, lane_cnt,
>> +		pinfo->bpp);
>> +end:
>> +	return min_link_rate_khz;
> 
> Remove end and return directly above
> 
>> +}
>> +
>> +struct dp_panel *dp_panel_get(struct dp_panel_in *in)
>> +{
>> +	int rc = 0;
>> +	struct dp_panel_private *panel;
>> +	struct dp_panel *dp_panel;
>> +
>> +	if (!in->dev || !in->catalog || !in->aux || !in->link) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	panel = devm_kzalloc(in->dev, sizeof(*panel), GFP_KERNEL);
>> +	if (!panel) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	panel->dev = in->dev;
>> +	panel->aux = in->aux;
>> +	panel->catalog = in->catalog;
>> +	panel->link = in->link;
>> +
>> +	dp_panel = &panel->dp_panel;
>> +	dp_panel->max_bw_code = DP_LINK_BW_8_1;
>> +	panel->aux_cfg_update_done = false;
>> +
>> +	dp_panel->init_info = dp_panel_init_panel_info;
>> +	dp_panel->timing_cfg = dp_panel_timing_cfg;
>> +	dp_panel->read_sink_caps = dp_panel_read_sink_caps;
>> +	dp_panel->get_min_req_link_rate = dp_panel_get_min_req_link_rate;
>> +	dp_panel->get_mode_bpp = dp_panel_get_mode_bpp;
>> +	dp_panel->get_modes = dp_panel_get_modes;
>> +	dp_panel->handle_sink_request = dp_panel_handle_sink_request;
>> +	dp_panel->tpg_config = dp_panel_tpg_config;
>> +
>> +	return dp_panel;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_panel_put(struct dp_panel *dp_panel)
>> +{
>> +	struct dp_panel_private *panel;
>> +
>> +	if (!dp_panel)
>> +		return;
>> +
>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>> +
>> +	kfree(dp_panel->edid);
>> +	dp_panel->edid = NULL;
>> +	devm_kfree(panel->dev, panel);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_panel.h 
>> b/drivers/gpu/drm/msm/dp/dp_panel.h
>> new file mode 100644
>> index 0000000..bf802df
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_panel.h
>> @@ -0,0 +1,121 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_PANEL_H_
>> +#define _DP_PANEL_H_
>> +
>> +#include <drm/msm_drm.h>
>> +
>> +#include "dp_aux.h"
>> +#include "dp_link.h"
>> +#include "dp_extcon.h"
>> +
>> +struct edid;
>> +
>> +enum dp_lane_count {
>> +	DP_LANE_COUNT_1	= 1,
>> +	DP_LANE_COUNT_2	= 2,
>> +	DP_LANE_COUNT_4	= 4,
>> +};
> 
> You don't need an enum for this, the value coming from dpcd is just an
> integer and
> can be used as such.
> 
Removed in v2.

>> +
>> +#define DP_MAX_DOWNSTREAM_PORTS 0x10
>> +
>> +struct dp_panel_info {
>> +	u32 h_active;
>> +	u32 v_active;
>> +	u32 h_back_porch;
>> +	u32 h_front_porch;
>> +	u32 h_sync_width;
>> +	u32 h_active_low;
>> +	u32 v_back_porch;
>> +	u32 v_front_porch;
>> +	u32 v_sync_width;
>> +	u32 v_active_low;
>> +	u32 h_skew;
>> +	u32 refresh_rate;
>> +	u32 pixel_clk_khz;
>> +	u32 bpp;
>> +};
> 
> Drop this struct and use drm_display_mode
> 
> 
Fixed in V2. removed this structure.
>> +
>> +struct dp_display_mode {
>> +	struct dp_panel_info timing;
>> +	u32 capabilities;
>> +};
>> +
>> +struct dp_panel_in {
>> +	struct device *dev;
>> +	struct dp_aux *aux;
>> +	struct dp_link *link;
>> +	struct dp_catalog_panel *catalog;
>> +};
>> +
>> +struct dp_panel {
>> +	/* dpcd raw data */
>> +	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];
> 
> Why + 1?
> 
Will follow up on this in V3.

>> +	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
>> +
>> +	struct drm_dp_link link_info;
>> +	struct edid *edid;
>> +	struct drm_connector *connector;
>> +	struct dp_panel_info pinfo;
>> +	bool video_test;
>> +
>> +	u32 vic;
>> +	u32 max_pclk_khz;
>> +
>> +	u32 max_bw_code;
>> +	int (*init_info)(struct dp_panel *dp_panel);
>> +	int (*deinit)(struct dp_panel *dp_panel);
>> +	int (*timing_cfg)(struct dp_panel *dp_panel);
>> +	int (*read_sink_caps)(struct dp_panel *dp_panel,
>> +		struct drm_connector *connector);
>> +	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);
> 
> This function isn't called anywhere
> 
Removed in V2.

>> +	u32 (*get_mode_bpp)(struct dp_panel *dp_panel, u32 mode_max_bpp,
>> +			u32 mode_pclk_khz);
>> +	int (*get_modes)(struct dp_panel *dp_panel,
>> +		struct drm_connector *connector, struct dp_display_mode *mode);
>> +	void (*handle_sink_request)(struct dp_panel *dp_panel);
>> +	void (*tpg_config)(struct dp_panel *dp_panel, bool enable);
>> +};
>> +
>> +/**
>> + * is_link_rate_valid() - validates the link rate
>> + * @lane_rate: link rate requested by the sink
>> + *
>> + * Returns true if the requested link rate is supported.
>> + */
>> +static inline bool is_link_rate_valid(u32 bw_code)
>> +{
>> +	return ((bw_code == DP_LINK_BW_1_62) ||
>> +		(bw_code == DP_LINK_BW_2_7) ||
>> +		(bw_code == DP_LINK_BW_5_4) ||
>> +		(bw_code == DP_LINK_BW_8_1));
> 
> Each of these conditions has unneeded ()
> 
Fixed in V2.

>> +}
>> +
>> +/**
>> + * dp_link_is_lane_count_valid() - validates the lane count
>> + * @lane_count: lane count requested by the sink
>> + *
>> + * Returns true if the requested lane count is supported.
>> + */
>> +static inline bool is_lane_count_valid(u32 lane_count)
>> +{
>> +	return (lane_count == DP_LANE_COUNT_1) ||
>> +		(lane_count == DP_LANE_COUNT_2) ||
>> +		(lane_count == DP_LANE_COUNT_4);
>> +}
>> +
>> +struct dp_panel *dp_panel_get(struct dp_panel_in *in);
>> +void dp_panel_put(struct dp_panel *dp_panel);
>> +#endif /* _DP_PANEL_H_ */
>> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.c 
>> b/drivers/gpu/drm/msm/dp/dp_parser.c
>> new file mode 100644
>> index 0000000..a366dc5
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_parser.c
>> @@ -0,0 +1,679 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/of_gpio.h>
>> +
>> +#include "dp_parser.h"
>> +
>> +static void dp_parser_unmap_io_resources(struct dp_parser *parser)
>> +{
>> +	struct dp_io *io = &parser->io;
>> +
>> +	msm_dss_iounmap(&io->dp_ahb);
>> +	msm_dss_iounmap(&io->dp_aux);
>> +	msm_dss_iounmap(&io->dp_link);
>> +	msm_dss_iounmap(&io->dp_p0);
>> +	msm_dss_iounmap(&io->phy_io);
>> +	msm_dss_iounmap(&io->ln_tx0_io);
>> +	msm_dss_iounmap(&io->ln_tx0_io);
>> +	msm_dss_iounmap(&io->dp_pll_io);
>> +	msm_dss_iounmap(&io->dp_cc_io);
>> +	msm_dss_iounmap(&io->usb3_dp_com);
>> +	msm_dss_iounmap(&io->qfprom_io);
>> +}
>> +
>> +static int dp_parser_ctrl_res(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	u32 index;
>> +	struct platform_device *pdev = parser->pdev;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	struct dp_io *io = &parser->io;
>> +
>> +	rc = of_property_read_u32(of_node, "cell-index", &index);
>> +	if (rc) {
>> +		pr_err("cell-index not specified, rc=%d\n", rc);
>> +		goto err;
> 
> This can be a direct return of rc.
> 
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_ahb, "dp_ahb");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
> 
> Print rc here and below.
> 
Will address the comments in this function in V3.

>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_aux, "dp_aux");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_link, "dp_link");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_p0, "dp_p0");
>> +	if (rc) {
>> +		pr_err("unable to remap dp io resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->phy_io, "dp_phy");
>> +	if (rc) {
>> +		pr_err("unable to remap dp PHY resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx0_io, "dp_ln_tx0");
>> +	if (rc) {
>> +		pr_err("unable to remap dp TX0 resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->ln_tx1_io, "dp_ln_tx1");
>> +	if (rc) {
>> +		pr_err("unable to remap dp TX1 resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->dp_pll_io, "dp_pll");
>> +	if (rc) {
>> +		pr_err("unable to remap DP PLL resources\n");
>> +		goto err;
>> +	}
>> +
>> +	rc = msm_dss_ioremap_byname(pdev, &io->usb3_dp_com, "usb3_dp_com");
>> +	if (rc) {
>> +		pr_err("unable to remap USB3 DP com resources\n");
>> +		goto err;
>> +	}
>> +
>> +	if (msm_dss_ioremap_byname(pdev, &io->dp_cc_io, "dp_mmss_cc")) {
>> +		pr_err("unable to remap dp MMSS_CC resources\n");
>> +		goto err;
>> +	}
>> +
>> +	if (msm_dss_ioremap_byname(pdev, &io->qfprom_io, "qfprom_physical"))
>> +		pr_warn("unable to remap dp qfprom resources\n");
>> +
>> +	return 0;
>> +err:
>> +	dp_parser_unmap_io_resources(parser);
>> +	return rc;
>> +}
>> +
>> +static const char *dp_get_phy_aux_config_property(u32 cfg_type)
>> +{
>> +	switch (cfg_type) {
>> +	case PHY_AUX_CFG0:
>> +		return "qcom,aux-cfg0-settings";
>> +	case PHY_AUX_CFG1:
>> +		return "qcom,aux-cfg1-settings";
>> +	case PHY_AUX_CFG2:
>> +		return "qcom,aux-cfg2-settings";
>> +	case PHY_AUX_CFG3:
>> +		return "qcom,aux-cfg3-settings";
>> +	case PHY_AUX_CFG4:
>> +		return "qcom,aux-cfg4-settings";
>> +	case PHY_AUX_CFG5:
>> +		return "qcom,aux-cfg5-settings";
>> +	case PHY_AUX_CFG6:
>> +		return "qcom,aux-cfg6-settings";
>> +	case PHY_AUX_CFG7:
>> +		return "qcom,aux-cfg7-settings";
>> +	case PHY_AUX_CFG8:
>> +		return "qcom,aux-cfg8-settings";
>> +	case PHY_AUX_CFG9:
>> +		return "qcom,aux-cfg9-settings";
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
>> +
>> +static void dp_parser_phy_aux_cfg_reset(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++)
>> +		parser->aux_cfg[i] = (const struct dp_aux_cfg){ 0 };
>> +}
> 
> No need for a separate function, just put the loop in the error label 
> below.
> 
Fixed in V2.

>> +
>> +static int dp_parser_aux(struct dp_parser *parser)
>> +{
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	int len = 0, i = 0, j = 0, config_count = 0;
>> +	const char *data;
>> +	int const minimum_config_count = 1;
> 
> Just use 1 directly
> 
Removed in V2.

>> +
>> +	for (i = 0; i < PHY_AUX_CFG_MAX; i++) {
>> +		const char *property = dp_get_phy_aux_config_property(i);
>> +
>> +		data = of_get_property(of_node, property, &len);
>> +		if (!data) {
> 
> You should use of_property_read_u32() instead of reading as a string
> 
Using the string for debug logs.

>> +			pr_err("Unable to read %s\n", property);
>> +			goto error;
>> +		}
>> +
>> +		config_count = len - 1;
>> +		if ((config_count < minimum_config_count) ||
>> +			(config_count > DP_AUX_CFG_MAX_VALUE_CNT)) {
> 
> Remove extra ()
> 
Address in V2.

>> +			pr_err("Invalid config count (%d) configs for %s\n",
>> +					config_count, property);
>> +			goto error;
>> +		}
>> +
>> +		parser->aux_cfg[i].offset = data[0];
>> +		parser->aux_cfg[i].cfg_cnt = config_count;
>> +		pr_debug("%s offset=0x%x, cfg_cnt=%d\n",
>> +				property,
>> +				parser->aux_cfg[i].offset,
>> +				parser->aux_cfg[i].cfg_cnt);
>> +		for (j = 1; j < len; j++) {
>> +			parser->aux_cfg[i].lut[j - 1] = data[j];
> 
> And this could use of_property_read_u32_array()
> 
>> +			pr_debug("%s lut[%d]=0x%x\n",
>> +					property,
>> +					i,
>> +					parser->aux_cfg[i].lut[j - 1]);
>> +		}
>> +	}
>> +		return 0;
>> +
>> +error:
>> +	dp_parser_phy_aux_cfg_reset(parser);
>> +	return -EINVAL;
>> +}
>> +
>> +static int dp_parser_misc(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +
>> +	rc = of_property_read_u32(of_node,
>> +		"qcom,max-pclk-frequency-khz", &parser->max_pclk_khz);
>> +	if (rc)
>> +		parser->max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ;
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_parser_pinctrl(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct dp_pinctrl *pinctrl = &parser->pinctrl;
>> +
>> +	pinctrl->pin = devm_pinctrl_get(&parser->pdev->dev);
>> +
>> +	if (IS_ERR_OR_NULL(pinctrl->pin)) {
>> +		rc = PTR_ERR(pinctrl->pin);
>> +		pr_err("failed to get pinctrl, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +
>> +	pinctrl->state_active = pinctrl_lookup_state(pinctrl->pin,
>> +					"mdss_dp_active");
>> +	if (IS_ERR_OR_NULL(pinctrl->state_active)) {
>> +		rc = PTR_ERR(pinctrl->state_active);
> 
> What if it's NULL?
> 
>> +		pr_err("failed to get pinctrl active state, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +
>> +	pinctrl->state_suspend = pinctrl_lookup_state(pinctrl->pin,
>> +					"mdss_dp_sleep");
>> +	if (IS_ERR_OR_NULL(pinctrl->state_suspend)) {
>> +		rc = PTR_ERR(pinctrl->state_suspend);
> 
> What if it's NULL?
> 
Will follow up and fix them in v3.

>> +		pr_err("failed to get pinctrl suspend state, rc=%d\n", rc);
>> +		goto error;
>> +	}
>> +error:
>> +	return rc;
>> +}
>> +
>> +static int dp_parser_gpio(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +	struct device *dev = &parser->pdev->dev;
>> +	struct device_node *of_node = dev->of_node;
>> +	struct dss_module_power *mp = &parser->mp[DP_CORE_PM];
>> +	static const char * const dp_gpios[] = {
>> +		"qcom,aux-en-gpio",
>> +		"qcom,aux-sel-gpio",
>> +		"qcom,usbplug-cc-gpio",
>> +	};
>> +
>> +	mp->gpio_config = devm_kzalloc(dev,
>> +		sizeof(struct dss_gpio) * ARRAY_SIZE(dp_gpios), GFP_KERNEL);
>> +	if (!mp->gpio_config)
>> +		return -ENOMEM;
>> +
>> +	mp->num_gpio = ARRAY_SIZE(dp_gpios);
> 
> If you do this first, you can s/ARRAY_SIZE(dp_gpios)/mp->num_gpio/ in 
> the rest
> of the function.
> 
Fixed in V2.

>> +
>> +	for (i = 0; i < ARRAY_SIZE(dp_gpios); i++) {
>> +		mp->gpio_config[i].gpio = of_get_named_gpio(of_node,
>> +			dp_gpios[i], 0);
>> +
>> +		if (!gpio_is_valid(mp->gpio_config[i].gpio)) {
>> +			pr_err("%s gpio not specified\n", dp_gpios[i]);
>> +			return -EINVAL;
>> +		}
>> +
>> +		strlcpy(mp->gpio_config[i].gpio_name, dp_gpios[i],
>> +			sizeof(mp->gpio_config[i].gpio_name));
> 
> As mentioned earlier, please don't implement your own string 
> store/lookup, just
> provide access to the gpios in a more direct manner (pointer or 
> function).
> 
Will fix this in V3.
>> +
>> +		mp->gpio_config[i].value = 0;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static const char *dp_parser_supply_node_name(enum dp_pm_type module)
>> +{
>> +	switch (module) {
>> +	case DP_CORE_PM:	return "qcom,core-supply-entries";
>> +	case DP_CTRL_PM:	return "qcom,ctrl-supply-entries";
>> +	case DP_PHY_PM:		return "qcom,phy-supply-entries";
>> +	default:		return "???";
>> +	}
>> +}
>> +
>> +static int dp_parser_get_vreg(struct dp_parser *parser,
>> +		enum dp_pm_type module)
>> +{
>> +	int i = 0, rc = 0;
>> +	u32 tmp = 0;
>> +	const char *pm_supply_name = NULL;
>> +	struct device_node *supply_node = NULL;
>> +	struct device_node *of_node = parser->pdev->dev.of_node;
>> +	struct device_node *supply_root_node = NULL;
>> +	struct dss_module_power *mp = &parser->mp[module];
>> +
>> +	mp->num_vreg = 0;
>> +	pm_supply_name = dp_parser_supply_node_name(module);
>> +	supply_root_node = of_get_child_by_name(of_node, pm_supply_name);
>> +	if (!supply_root_node) {
>> +		pr_err("no supply entry present: %s\n", pm_supply_name);
>> +		goto novreg;
>> +	}
>> +
>> +	mp->num_vreg = of_get_available_child_count(supply_root_node);
>> +
>> +	if (mp->num_vreg == 0) {
>> +		pr_debug("no vreg\n");
>> +		goto novreg;
>> +	} else {
>> +		pr_debug("vreg found. count=%d\n", mp->num_vreg);
> 
> This doesn't need to be wrapped in an else
> 
Fixed in V2.

>> +	}
>> +
>> +	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
>> +		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
>> +	if (!mp->vreg_config) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	for_each_child_of_node(supply_root_node, supply_node) {
>> +		const char *st = NULL;
>> +		/* vreg-name */
>> +		rc = of_property_read_string(supply_node,
>> +			"qcom,supply-name", &st);
>> +		if (rc) {
>> +			pr_err("error reading name. rc=%d\n",
>> +				 rc);
>> +			goto error;
>> +		}
>> +		snprintf(mp->vreg_config[i].vreg_name,
>> +			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);
> 
> Instead of storing the name just to get a regulator reference later, 
> why don't
> you just grab the reference now and avoid the string ops?
> 
Vreg keep changing for each chip. This is more generic implementation 
that avoids doing changes to the code.
Updating the dtsi-platform specific changes will have access to the 
vregs.
>> +		/* vreg-min-voltage */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-min-voltage", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading min volt. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].min_voltage = tmp;
>> +
>> +		/* vreg-max-voltage */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-max-voltage", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading max volt. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].max_voltage = tmp;
>> +
>> +		/* enable-load */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-enable-load", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading enable load. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].enable_load = tmp;
>> +
>> +		/* disable-load */
>> +		rc = of_property_read_u32(supply_node,
>> +			"qcom,supply-disable-load", &tmp);
>> +		if (rc) {
>> +			pr_err("error reading disable load. rc=%d\n",
>> +				rc);
>> +			goto error;
>> +		}
>> +		mp->vreg_config[i].disable_load = tmp;
>> +
>> +		pr_debug("%s min=%d, max=%d, enable=%d, disable=%d\n",
>> +			mp->vreg_config[i].vreg_name,
>> +			mp->vreg_config[i].min_voltage,
>> +			mp->vreg_config[i].max_voltage,
>> +			mp->vreg_config[i].enable_load,
>> +			mp->vreg_config[i].disable_load
>> +			);
>> +		++i;
>> +	}
>> +
>> +	return rc;
>> +
>> +error:
>> +	if (mp->vreg_config) {
>> +		devm_kfree(&parser->pdev->dev, mp->vreg_config);
>> +		mp->vreg_config = NULL;
>> +	}
> 
> This shouldn't be necessary, that's the nice thing about device managed
> resources.
> 
Addressed in V2.

>> +novreg:
>> +	mp->num_vreg = 0;
>> +
>> +	return rc;
>> +}
>> +
>> +static void dp_parser_put_vreg_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("invalid input\n");
>> +		return;
>> +	}
>> +
>> +	if (mp->vreg_config) {
>> +		devm_kfree(dev, mp->vreg_config);
>> +		mp->vreg_config = NULL;
>> +	}
> 
> Same here, this function can go away once you take out the dp_parser
> abstraction layer.
> 
Fixed in V2.

>> +	mp->num_vreg = 0;
>> +}
>> +
>> +static int dp_parser_regulator(struct dp_parser *parser)
>> +{
>> +	int i, rc = 0;
>> +	struct platform_device *pdev = parser->pdev;
>> +
>> +	/* Parse the regulator information */
>> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
>> +		rc = dp_parser_get_vreg(parser, i);
>> +		if (rc) {
>> +			pr_err("get_dt_vreg_data failed for %s. rc=%d\n",
>> +				dp_parser_pm_name(i), rc);
>> +			i--;
>> +			for (; i >= DP_CORE_PM; i--)
>> +				dp_parser_put_vreg_data(&pdev->dev,
>> +					&parser->mp[i]);
>> +			break;
> 
> And here you can just return the error directly and the resources will 
> be freed
> magically.
> 
Fixed in V2.

>> +		}
>> +	}
>> +
>> +	return rc;
> 
> And this becomes return 0;
> 
>> +}
>> +
>> +static bool dp_parser_check_prefix(const char *clk_prefix, const char 
>> *clk_name)
>> +{
>> +	return !!strnstr(clk_name, clk_prefix, strlen(clk_name));
> 
> This is likely not what you want since this will look for prefix 
> _anywhere_ in
> clk name. An example of how this could go sideways:
> 
> 	dp_parser_check_prefix("core", "core-dp-power-ctrl");
> 	dp_parser_check_prefix("ctrl", "core-dp-power-ctrl");
> 
> Both return true.
> 
> Anyways, strncmp is a better choice here (if we must do string 
> operations).
> 
Updated in V2. Used strncmp.


>> +}
>> +
>> +static void dp_parser_put_clk_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("%s: invalid input\n", __func__);
>> +		return;
>> +	}
>> +
>> +	if (mp->clk_config) {
>> +		devm_kfree(dev, mp->clk_config);
>> +		mp->clk_config = NULL;
>> +	}
>> +
>> +	mp->num_clk = 0;
>> +}
>> +
>> +static void dp_parser_put_gpio_data(struct device *dev,
>> +	struct dss_module_power *mp)
>> +{
>> +	if (!mp) {
>> +		DEV_ERR("%s: invalid input\n", __func__);
>> +		return;
>> +	}
>> +
>> +	if (mp->gpio_config) {
>> +		devm_kfree(dev, mp->gpio_config);
>> +		mp->gpio_config = NULL;
>> +	}
>> +
>> +	mp->num_gpio = 0;
>> +}
>> +
>> +static int dp_parser_init_clk_data(struct dp_parser *parser)
>> +{
>> +	int num_clk = 0, i = 0, rc = 0;
>> +	int core_clk_count = 0, ctrl_clk_count = 0;
>> +	const char *core_clk = "core";
>> +	const char *ctrl_clk = "ctrl";
>> +	const char *clk_name;
>> +	struct device *dev = &parser->pdev->dev;
>> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
>> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
>> +
>> +	num_clk = of_property_count_strings(dev->of_node, "clock-names");
>> +	if (num_clk <= 0) {
>> +		pr_err("no clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	for (i = 0; i < num_clk; i++) {
>> +		of_property_read_string_index(dev->of_node,
>> +				"clock-names", i, &clk_name);
> 
> Check return value
> 
Fixed in V2.

>> +
>> +		if (dp_parser_check_prefix(core_clk, clk_name))
>> +			core_clk_count++;
>> +
>> +		if (dp_parser_check_prefix(ctrl_clk, clk_name))
>> +			ctrl_clk_count++;
> 
> Just use "core"/"ctrl" directly here.
> 
> Have you considered just having 2 clock lists? That would avoid having 
> to do
> this.
> 
I didn't get what you meant by two clock lists. We currently have two 
clock list to store them locally.
You mean having two clock lists in dtsi?

>> +	}
>> +
>> +	/* Initialize the CORE power module */
>> +	if (core_clk_count <= 0) {
> 
> How does this get below 0?
> 
Will fix them in V3.


>> +		pr_err("no core clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	core_power->num_clk = core_clk_count;
>> +	core_power->clk_config = devm_kzalloc(dev,
>> +			sizeof(struct dss_clk) * core_power->num_clk,
>> +			GFP_KERNEL);
>> +	if (!core_power->clk_config) {
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	/* Initialize the CTRL power module */
>> +	if (ctrl_clk_count <= 0) {
> 
> How does this get below 0?
> 
>> +		pr_err("no ctrl clocks are defined\n");
>> +		rc = -EINVAL;
>> +		goto ctrl_clock_error;
>> +	}
>> +
>> +	ctrl_power->num_clk = ctrl_clk_count;
>> +	ctrl_power->clk_config = devm_kzalloc(dev,
>> +			sizeof(struct dss_clk) * ctrl_power->num_clk,
>> +			GFP_KERNEL);
>> +	if (!ctrl_power->clk_config) {
>> +		ctrl_power->num_clk = 0;
>> +		rc = -EINVAL;
>> +		goto ctrl_clock_error;
>> +	}
>> +
>> +	return rc;
>> +
>> +ctrl_clock_error:
>> +	dp_parser_put_clk_data(dev, core_power);
>> +exit:
>> +	return rc;
> 
> Just return directly and delete exit
> 
Fixed in v2.

>> +}
>> +
>> +static int dp_parser_clock(struct dp_parser *parser)
>> +{
>> +	int rc = 0, i = 0;
>> +	int num_clk = 0;
>> +	int core_clk_index = 0, ctrl_clk_index = 0;
>> +	int core_clk_count = 0, ctrl_clk_count = 0;
>> +	const char *clk_name;
>> +	const char *core_clk = "core";
>> +	const char *ctrl_clk = "ctrl";
>> +	struct device *dev = &parser->pdev->dev;
> 
> ---- START hmmmm
> 
>> +	struct dss_module_power *core_power = &parser->mp[DP_CORE_PM];
>> +	struct dss_module_power *ctrl_power = &parser->mp[DP_CTRL_PM];
>> +
>> +	core_power = &parser->mp[DP_CORE_PM];
>> +	ctrl_power = &parser->mp[DP_CTRL_PM];
> 
> ---- END hmmmm
> 
Fixed in V2.

>> +
>> +	rc =  dp_parser_init_clk_data(parser);
>> +	if (rc) {
>> +		pr_err("failed to initialize power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	core_clk_count = core_power->num_clk;
>> +	ctrl_clk_count = ctrl_power->num_clk;
>> +
>> +	num_clk = core_clk_count + ctrl_clk_count;
>> +
>> +	for (i = 0; i < num_clk; i++) {
>> +		of_property_read_string_index(dev->of_node, "clock-names",
>> +				i, &clk_name);
> 
> Check return value
> 
Fixed in v2.

>> +
>> +		if (dp_parser_check_prefix(core_clk, clk_name) &&
>> +				core_clk_index < core_clk_count) {
>> +			struct dss_clk *clk =
>> +				&core_power->clk_config[core_clk_index];
>> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
>> +			clk->type = DSS_CLK_AHB;
>> +			core_clk_index++;
>> +		} else if (dp_parser_check_prefix(ctrl_clk, clk_name) &&
>> +			   ctrl_clk_index < ctrl_clk_count) {
>> +			struct dss_clk *clk =
>> +				&ctrl_power->clk_config[ctrl_clk_index];
>> +			strlcpy(clk->clk_name, clk_name, sizeof(clk->clk_name));
>> +			ctrl_clk_index++;
>> +
>> +			if (!strcmp(clk_name, "ctrl_link_clk") ||
>> +			    !strcmp(clk_name, "ctrl_pixel_clk"))
> 
> strncmp
> 
Fixed in V2.

>> +				clk->type = DSS_CLK_PCLK;
>> +			else
>> +				clk->type = DSS_CLK_AHB;
>> +		}
>> +	}
>> +
>> +	pr_debug("clock parsing successful\n");
>> +
>> +exit:
> 
> Delete the label and return directly
> 
Fixed in v2.

>> +	return rc;
>> +}
>> +
>> +static int dp_parser_parse(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto err;
>> +	}
>> +
>> +	rc = dp_parser_ctrl_res(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_aux(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_misc(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_clock(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_regulator(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_gpio(parser);
>> +	if (rc)
>> +		goto err;
>> +
>> +	rc = dp_parser_pinctrl(parser);
>> +err:
> 
> Delete the label and return directly
> 
Fixed in V2.

>> +	return rc;
>> +}
>> +
>> +struct dp_parser *dp_parser_get(struct platform_device *pdev)
>> +{
>> +	struct dp_parser *parser;
>> +
>> +	parser = devm_kzalloc(&pdev->dev, sizeof(*parser), GFP_KERNEL);
>> +	if (!parser)
>> +		return ERR_PTR(-ENOMEM);
>> +
>> +	parser->parse = dp_parser_parse;
>> +	parser->pdev = pdev;
>> +
>> +	return parser;
>> +}
>> +
>> +void dp_parser_put(struct dp_parser *parser)
>> +{
>> +	int i = 0;
>> +	struct dss_module_power *power = NULL;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid parser module\n");
>> +		return;
>> +	}
>> +
>> +	power = parser->mp;
>> +
>> +	for (i = 0; i < DP_MAX_PM; i++) {
>> +		dp_parser_put_clk_data(&parser->pdev->dev, &power[i]);
>> +		dp_parser_put_vreg_data(&parser->pdev->dev, &power[i]);
>> +		dp_parser_put_gpio_data(&parser->pdev->dev, &power[i]);
>> +	}
>> +
>> +	devm_kfree(&parser->pdev->dev, parser);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h 
>> b/drivers/gpu/drm/msm/dp/dp_parser.h
>> new file mode 100644
>> index 0000000..b39ea02
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_parser.h
>> @@ -0,0 +1,205 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#ifndef _DP_PARSER_H_
>> +#define _DP_PARSER_H_
>> +
>> +#include "dpu_io_util.h"
>> +
>> +#define DP_LABEL "MDSS DP DISPLAY"
>> +#define AUX_CFG_LEN	10
>> +#define DP_MAX_PIXEL_CLK_KHZ	675000
>> +
>> +enum dp_pm_type {
>> +	DP_CORE_PM,
>> +	DP_CTRL_PM,
>> +	DP_PHY_PM,
>> +	DP_MAX_PM
>> +};
>> +
>> +static inline const char *dp_parser_pm_name(enum dp_pm_type module)
>> +{
>> +	switch (module) {
>> +	case DP_CORE_PM:	return "DP_CORE_PM";
>> +	case DP_CTRL_PM:	return "DP_CTRL_PM";
>> +	case DP_PHY_PM:		return "DP_PHY_PM";
>> +	default:		return "???";
>> +	}
>> +}
> 
> Delete the function and just print the enum value
> 
>> +
>> +/**
>> + * struct dp_display_data  - display related device tree data.
>> + *
>> + * @ctrl_node: referece to controller device
>> + * @phy_node:  reference to phy device
>> + * @is_active: is the controller currently active
>> + * @name: name of the display
>> + * @display_type: type of the display
>> + */
>> +struct dp_display_data {
>> +	struct device_node *ctrl_node;
>> +	struct device_node *phy_node;
>> +	bool is_active;
>> +	const char *name;
>> +	const char *display_type;
>> +};
>> +
>> +/**
>> + * struct dp_ctrl_resource - controller's IO related data
>> + *
>> + * @dp_ahb: controller's ahb mapped memory address
>> + * @dp_aux: controller's aux mapped memory address
>> + * @dp_link: controller's link mapped memory address
>> + * @dp_p0: controller's p0 mapped memory address
>> + * @phy_io: phy's mapped memory address
>> + * @ln_tx0_io: USB-DP lane TX0's mapped memory address
>> + * @ln_tx1_io: USB-DP lane TX1's mapped memory address
>> + * @dp_cc_io: DP cc's mapped memory address
>> + * @qfprom_io: qfprom's mapped memory address
>> + * @dp_pll_io: DP PLL mapped memory address
>> + * @usb3_dp_com: USB3 DP PHY combo mapped memory address
>> + */
>> +struct dp_io {
>> +	struct dss_io_data ctrl_io;
>> +	struct dss_io_data dp_ahb;
>> +	struct dss_io_data dp_aux;
>> +	struct dss_io_data dp_link;
>> +	struct dss_io_data dp_p0;
>> +	struct dss_io_data phy_io;
>> +	struct dss_io_data ln_tx0_io;
>> +	struct dss_io_data ln_tx1_io;
>> +	struct dss_io_data dp_cc_io;
>> +	struct dss_io_data qfprom_io;
>> +	struct dss_io_data dp_pll_io;
>> +	struct dss_io_data usb3_dp_com;
>> +};
>> +
>> +/**
>> + * struct dp_pinctrl - DP's pin control
>> + *
>> + * @pin: pin-controller's instance
>> + * @state_active: active state pin control
>> + * @state_hpd_active: hpd active state pin control
>> + * @state_suspend: suspend state pin control
>> + */
>> +struct dp_pinctrl {
>> +	struct pinctrl *pin;
>> +	struct pinctrl_state *state_active;
>> +	struct pinctrl_state *state_hpd_active;
>> +	struct pinctrl_state *state_suspend;
>> +};
>> +
>> +#define DP_ENUM_STR(x)	#x
> 
> Once you get rid of all of the enum->string functions that are used for
> debugging, you can delete this.
> 
>> +#define DP_AUX_CFG_MAX_VALUE_CNT 3
>> +/**
>> + * struct dp_aux_cfg - DP's AUX configuration settings
>> + *
>> + * @cfg_cnt: count of the configurable settings for the AUX register
>> + * @current_index: current index of the AUX config lut
>> + * @offset: register offset of the AUX config register
>> + * @lut: look up table for the AUX config values for this register
>> + */
>> +struct dp_aux_cfg {
>> +	u32 cfg_cnt;
>> +	u32 current_index;
>> +	u32 offset;
>> +	u32 lut[DP_AUX_CFG_MAX_VALUE_CNT];
>> +};
>> +
>> +/* PHY AUX config registers */
>> +enum dp_phy_aux_config_type {
>> +	PHY_AUX_CFG0,
>> +	PHY_AUX_CFG1,
>> +	PHY_AUX_CFG2,
>> +	PHY_AUX_CFG3,
>> +	PHY_AUX_CFG4,
>> +	PHY_AUX_CFG5,
>> +	PHY_AUX_CFG6,
>> +	PHY_AUX_CFG7,
>> +	PHY_AUX_CFG8,
>> +	PHY_AUX_CFG9,
>> +	PHY_AUX_CFG_MAX,
>> +};
>> +
>> +static inline char *dp_phy_aux_config_type_to_string(u32 cfg_type)
>> +{
>> +	switch (cfg_type) {
>> +	case PHY_AUX_CFG0:
>> +		return DP_ENUM_STR(PHY_AUX_CFG0);
>> +	case PHY_AUX_CFG1:
>> +		return DP_ENUM_STR(PHY_AUX_CFG1);
>> +	case PHY_AUX_CFG2:
>> +		return DP_ENUM_STR(PHY_AUX_CFG2);
>> +	case PHY_AUX_CFG3:
>> +		return DP_ENUM_STR(PHY_AUX_CFG3);
>> +	case PHY_AUX_CFG4:
>> +		return DP_ENUM_STR(PHY_AUX_CFG4);
>> +	case PHY_AUX_CFG5:
>> +		return DP_ENUM_STR(PHY_AUX_CFG5);
>> +	case PHY_AUX_CFG6:
>> +		return DP_ENUM_STR(PHY_AUX_CFG6);
>> +	case PHY_AUX_CFG7:
>> +		return DP_ENUM_STR(PHY_AUX_CFG7);
>> +	case PHY_AUX_CFG8:
>> +		return DP_ENUM_STR(PHY_AUX_CFG8);
>> +	case PHY_AUX_CFG9:
>> +		return DP_ENUM_STR(PHY_AUX_CFG9);
>> +	default:
>> +		return "unknown";
>> +	}
>> +}
> 
> Same deal as the others, remove and print the enum value instead.
> 
Fixed in V2.

>> +
>> +/**
>> + * struct dp_parser - DP parser's data exposed to clients
>> + *
>> + * @pdev: platform data of the client
>> + * @mp: gpio, regulator and clock related data
>> + * @pinctrl: pin-control related data
>> + * @disp_data: controller's display related data
>> + * @parse: function to be called by client to parse device tree.
>> + */
>> +struct dp_parser {
>> +	struct platform_device *pdev;
>> +	struct dss_module_power mp[DP_MAX_PM];
>> +	struct dp_pinctrl pinctrl;
>> +	struct dp_io io;
>> +	struct dp_display_data disp_data;
>> +
>> +	u8 l_map[4];
>> +	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
>> +	u32 max_pclk_khz;
>> +
>> +	int (*parse)(struct dp_parser *parser);
>> +};
>> +
>> +/**
>> + * dp_parser_get() - get the DP's device tree parser module
>> + *
>> + * @pdev: platform data of the client
>> + * return: pointer to dp_parser structure.
>> + *
>> + * This function provides client capability to parse the
>> + * device tree and populate the data structures. The data
>> + * related to clock, regulators, pin-control and other
>> + * can be parsed using this module.
>> + */
>> +struct dp_parser *dp_parser_get(struct platform_device *pdev);
>> +
>> +/**
>> + * dp_parser_put() - cleans the dp_parser module
>> + *
>> + * @parser: pointer to the parser's data.
>> + */
>> +void dp_parser_put(struct dp_parser *parser);
>> +#endif
>> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c 
>> b/drivers/gpu/drm/msm/dp/dp_power.c
>> new file mode 100644
>> index 0000000..1d58480
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
>> @@ -0,0 +1,599 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.
>> + *
>> + * This program is free software; you can redistribute it and/or 
>> modify
>> + * it under the terms of the GNU General Public License version 2 and
>> + * only version 2 as published by the Free Software Foundation.
>> + *
>> + * This program is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>> + * GNU General Public License for more details.
>> + *
>> + */
>> +
>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>> +
>> +#include <linux/clk.h>
>> +#include "dp_power.h"
>> +
>> +#define DP_CLIENT_NAME_SIZE	20
> 
> Unused
> 
Will fix this in V3.

>> +
>> +struct dp_power_private {
>> +	struct dp_parser *parser;
>> +	struct platform_device *pdev;
>> +	struct clk *pixel_clk_rcg;
>> +	struct clk *pixel_parent;
>> +
>> +	struct dp_power dp_power;
>> +
>> +	bool core_clks_on;
>> +	bool link_clks_on;
>> +};
>> +
>> +static int dp_power_regulator_init(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i = 0, j = 0;
>> +	struct platform_device *pdev;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +	pdev = power->pdev;
> 
> Move these initializations up to the declaration. Please apply this to 
> the rest
> of the code as well.
> 
Will fix this in V3.

> 
>> +
>> +	for (i = DP_CORE_PM; !rc && (i < DP_MAX_PM); i++) {
> 
> No need to check rc when the only place it can go non-zero is the place 
> that
> has a break;
> 
>> +		rc = msm_dss_config_vreg(&pdev->dev,
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, 1);
>> +		if (rc) {
>> +			pr_err("failed to init vregs for %s\n",
>> +				dp_parser_pm_name(i));
>> +			for (j = i - 1; j >= DP_CORE_PM; j--) {
>> +				msm_dss_config_vreg(&pdev->dev,
>> +				parser->mp[j].vreg_config,
>> +				parser->mp[j].num_vreg, 0);
>> +			}
> 
> Put this loop in the error label and return 0 above it. Better yet, 
> just call
> the dp_power_regulator_deinit in error.
> 
Will fix this function in V3.

>> +
>> +			goto error;
>> +		}
>> +	}
>> +error:
>> +	return rc;
>> +}
>> +
>> +static void dp_power_regulator_deinit(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i = 0;
>> +	struct platform_device *pdev;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +	pdev = power->pdev;
>> +
>> +	for (i = DP_CORE_PM; (i < DP_MAX_PM); i++) {
> 
> Unnecessary (), applies elsewhere too, please make a pass
> 
Will fix this in V3.

>> +		rc = msm_dss_config_vreg(&pdev->dev,
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, 0);
>> +		if (rc)
>> +			pr_err("failed to deinit vregs for %s\n",
>> +				dp_parser_pm_name(i));
>> +	}
>> +}
>> +
>> +static int dp_power_regulator_ctrl(struct dp_power_private *power, 
>> bool enable)
>> +{
>> +	int rc = 0, i = 0, j = 0;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +
>> +	for (i = DP_CORE_PM; i < DP_MAX_PM; i++) {
>> +		rc = msm_dss_enable_vreg(
>> +			parser->mp[i].vreg_config,
>> +			parser->mp[i].num_vreg, enable);
>> +		if (rc) {
>> +			pr_err("failed to '%s' vregs for %s\n",
>> +					enable ? "enable" : "disable",
>> +					dp_parser_pm_name(i));
>> +			if (enable) {
>> +				for (j = i-1; j >= DP_CORE_PM; j--) {
>> +					msm_dss_enable_vreg(
>> +					parser->mp[j].vreg_config,
>> +					parser->mp[j].num_vreg, 0);
>> +				}
>> +			}
>> +			goto error;
>> +		}
>> +	}
>> +error:
>> +	return rc;
>> +}
> 
> This function is basically identical to dp_power_regulator_init(), 
> please
> delete this function and use dp_power_regulator_init().
> 
Though its identical, we don't want to combine them since we have to 
have individual for loops for init and enable/disable.

> 
>> +
>> +static int dp_power_pinctrl_set(struct dp_power_private *power, bool 
>> active)
>> +{
>> +	int rc = -EFAULT;
>> +	struct pinctrl_state *pin_state;
>> +	struct dp_parser *parser;
>> +
>> +	parser = power->parser;
>> +
>> +	if (IS_ERR_OR_NULL(parser->pinctrl.pin))
>> +		return PTR_ERR(parser->pinctrl.pin);
>> +
>> +	pin_state = active ? parser->pinctrl.state_active
>> +				: parser->pinctrl.state_suspend;
>> +	if (!IS_ERR_OR_NULL(pin_state)) {
> 
> How is this not possible? You check these on initialization.
> 
Will remove this in V3.
>> +		rc = pinctrl_select_state(parser->pinctrl.pin,
>> +				pin_state);
> 
> Combine on 1 line
> 
Fixed in V2.

>> +		if (rc)
>> +			pr_err("can not set %s pins\n",
>> +			       active ? "dp_active"
>> +			       : "dp_sleep");
> 
> 
> Combine on one line. Also return immediately if this is the case.
> 
Fixed in V2.

>> +	} else {
>> +		pr_err("invalid '%s' pinstate\n",
>> +		       active ? "dp_active"
>> +		       : "dp_sleep");
>> +	}
>> +
>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_init(struct dp_power_private *power, bool 
>> enable)
> 
> Split this into init/deinit, the paths don't share code.
> 
Fixed in V2.

>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *core, *ctrl;
>> +	struct device *dev;
>> +
>> +	core = &power->parser->mp[DP_CORE_PM];
>> +	ctrl = &power->parser->mp[DP_CTRL_PM];
>> +
>> +	dev = &power->pdev->dev;
>> +
>> +	if (!core || !ctrl) {
>> +		pr_err("invalid power_data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	if (enable) {
>> +		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to get %s clk. err=%d\n",
>> +				dp_parser_pm_name(DP_CORE_PM), rc);
>> +			goto exit;
>> +		}
>> +
>> +		rc = msm_dss_get_clk(dev, ctrl->clk_config, ctrl->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to get %s clk. err=%d\n",
>> +				dp_parser_pm_name(DP_CTRL_PM), rc);
>> +			goto ctrl_get_error;
>> +		}
>> +
>> +		power->pixel_clk_rcg = devm_clk_get(dev, "pixel_clk_rcg");
>> +		if (IS_ERR(power->pixel_clk_rcg)) {
>> +			pr_debug("Unable to get DP pixel clk RCG\n");
>> +			power->pixel_clk_rcg = NULL;
>> +		}
>> +
>> +		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
>> +		if (IS_ERR(power->pixel_parent)) {
>> +			pr_debug("Unable to get DP pixel RCG parent\n");
>> +			power->pixel_parent = NULL;
>> +		}
>> +	} else {
>> +		if (power->pixel_parent)
>> +			devm_clk_put(dev, power->pixel_parent);
>> +
>> +		if (power->pixel_clk_rcg)
>> +			devm_clk_put(dev, power->pixel_clk_rcg);
> 
> device managed resources don't need to be freed
> 
Fixed in v2.

>> +
>> +		msm_dss_put_clk(ctrl->clk_config, ctrl->num_clk);
>> +		msm_dss_put_clk(core->clk_config, core->num_clk);
>> +	}
>> +
>> +	return rc;
>> +
>> +ctrl_get_error:
>> +	msm_dss_put_clk(core->clk_config, core->num_clk);
> 
> Since this is only used in one place, just do it above and return 
> directly.
> 
>> +exit:
> 
> Delete exit label and return directly
> 
Fixed in V2.

>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_set_rate(struct dp_power_private *power,
>> +		enum dp_pm_type module, bool enable)
>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *mp;
>> +
>> +	if (!power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	mp = &power->parser->mp[module];
>> +
>> +	if (enable) {
>> +		rc = msm_dss_clk_set_rate(mp->clk_config, mp->num_clk);
>> +		if (rc) {
>> +			pr_err("failed to set clks rate.\n");
>> +			goto exit;
>> +		}
>> +
>> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 1);
>> +		if (rc) {
>> +			pr_err("failed to enable clks\n");
>> +			goto exit;
>> +		}
>> +	} else {
>> +		rc = msm_dss_enable_clk(mp->clk_config, mp->num_clk, 0);
>> +		if (rc) {
>> +			pr_err("failed to disable clks\n");
>> +				goto exit;
>> +		}
> 
> This function actually can share code, but it doesn't :( Please pull 
> this out
> for both paths
> 
Updated in V2.

>> +	}
>> +exit:
> 
> Delete exit label and return directly
> 
Fixed in V2.
>> +	return rc;
>> +}
>> +
>> +static int dp_power_clk_enable(struct dp_power *dp_power,
>> +		enum dp_pm_type pm_type, bool enable)
>> +{
>> +	int rc = 0;
>> +	struct dss_module_power *mp;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	mp = &power->parser->mp[pm_type];
>> +
>> +	if ((pm_type != DP_CORE_PM) && (pm_type != DP_CTRL_PM)) {
> 
> Strip out unnecessary ()
> Fixed in V2.

>> +		pr_err("unsupported power module: %s\n",
>> +				dp_parser_pm_name(pm_type));
>> +		return -EINVAL;
>> +	}
>> +
>> +	if (enable) {
>> +		if ((pm_type == DP_CORE_PM)
>> +			&& (power->core_clks_on)) {
> 
> Here too
> 
> Combine on one line as well
> 
Fixed in v2.

>> +			pr_debug("core clks already enabled\n");
>> +			return 0;
>> +		}
>> +
>> +		if ((pm_type == DP_CTRL_PM)
>> +			&& (power->link_clks_on)) {
> 
> and here
> 
>> +			pr_debug("links clks already enabled\n");
>> +			return 0;
>> +		}
>> +
>> +		if ((pm_type == DP_CTRL_PM) && (!power->core_clks_on)) {
> 
> and here
> Missed one correct. All others are fixed in V2. Will fix the missing in 
> V3.

>> +			pr_debug("Need to enable core clks before link clks\n");
>> +
>> +			rc = dp_power_clk_set_rate(power, DP_CORE_PM, enable);
>> +			if (rc) {
>> +				pr_err("failed to enable clks: %s. err=%d\n",
>> +					dp_parser_pm_name(DP_CORE_PM), rc);
>> +				goto error;
>> +			} else {
>> +				power->core_clks_on = true;
> 
> This doesn't need to be wrapped in the else
> 
Fixed in V2.
>> +			}
>> +		}
>> +	}
>> +
>> +	rc = dp_power_clk_set_rate(power, pm_type, enable);
>> +	if (rc) {
>> +		pr_err("failed to '%s' clks for: %s. err=%d\n",
>> +			enable ? "enable" : "disable",
>> +			dp_parser_pm_name(pm_type), rc);
>> +			goto error;
>> +	}
>> +
>> +	if (pm_type == DP_CORE_PM)
>> +		power->core_clks_on = enable;
>> +	else
>> +		power->link_clks_on = enable;
>> +
>> +	pr_debug("%s clocks for %s\n",
>> +			enable ? "enable" : "disable",
>> +			dp_parser_pm_name(pm_type));
>> +	pr_debug("link_clks:%s core_clks:%s\n",
>> +		power->link_clks_on ? "on" : "off",
>> +		power->core_clks_on ? "on" : "off");
>> +error:
> 
> Delete error label and return directly
> 
Fixed in V2.

>> +	return rc;
>> +}
>> +
>> +static int dp_power_request_gpios(struct dp_power_private *power)
>> +{
>> +	int rc = 0, i;
>> +	struct device *dev;
>> +	struct dss_module_power *mp;
>> +	static const char * const gpio_names[] = {
>> +		"aux_enable", "aux_sel", "usbplug_cc",
>> +	};
>> +
>> +	if (!power) {
>> +		pr_err("invalid power data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	dev = &power->pdev->dev;
>> +	mp = &power->parser->mp[DP_CORE_PM];
>> +
>> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
>> +		unsigned int gpio = mp->gpio_config[i].gpio;
>> +
>> +		if (gpio_is_valid(gpio)) {
> 
> if (!gpio_is_valid(gpio))
> 	continue;
> 
Updated in V2.

> and save yourself some indent space
> 
>> +			rc = devm_gpio_request(dev, gpio, gpio_names[i]);
>> +			if (rc) {
>> +				pr_err("request %s gpio failed, rc=%d\n",
>> +					       gpio_names[i], rc);
>> +				goto error;
>> +			}
>> +		}
>> +	}
>> +	return 0;
>> +error:
>> +	for (i = 0; i < ARRAY_SIZE(gpio_names); i++) {
>> +		unsigned int gpio = mp->gpio_config[i].gpio;
>> +
>> +		if (gpio_is_valid(gpio))
>> +			gpio_free(gpio);
>> +	}
> 
> gpios are device managed, so you shouldn't need this.
> 
>> +	return rc;
>> +}
>> +
>> +static bool dp_power_find_gpio(const char *gpio1, const char *gpio2)
>> +{
>> +	return !!strnstr(gpio1, gpio2, strlen(gpio1));
>> +}
>> +
>> +static void dp_power_set_gpio(struct dp_power_private *power, bool 
>> flip)
>> +{
>> +	int i;
>> +	struct dss_module_power *mp = &power->parser->mp[DP_CORE_PM];
>> +	struct dss_gpio *config = mp->gpio_config;
>> +
>> +	for (i = 0; i < mp->num_gpio; i++) {
>> +		if (dp_power_find_gpio(config->gpio_name, "aux-sel"))
>> +			config->value = flip;
>> +
>> +		if (gpio_is_valid(config->gpio)) {
>> +			pr_debug("gpio %s, value %d\n", config->gpio_name,
>> +				config->value);
>> +
>> +			if (dp_power_find_gpio(config->gpio_name, "aux-en") ||
>> +			    dp_power_find_gpio(config->gpio_name, "aux-sel"))
>> +				gpio_direction_output(config->gpio,
>> +					config->value);
>> +			else
>> +				gpio_set_value(config->gpio, config->value);
>> +
>> +		}
>> +		config++;
>> +	}
> 
> Instead of all of these string ops, please just make pointers 
> accessible so you
> can get at the gpio directly.
> 
Will follow up on this in V3.
>> +}
>> +
>> +static int dp_power_config_gpios(struct dp_power_private *power, bool 
>> flip,
>> +					bool enable)
> 
> Split into 2 functions
> 
Will fix this in V3.
>> +{
>> +	int rc = 0, i;
>> +	struct dss_module_power *mp;
>> +	struct dss_gpio *config;
>> +
>> +	mp = &power->parser->mp[DP_CORE_PM];
>> +	config = mp->gpio_config;
>> +
>> +	if (enable) {
>> +		rc = dp_power_request_gpios(power);
>> +		if (rc) {
>> +			pr_err("gpio request failed\n");
>> +			return rc;
>> +		}
>> +
>> +		dp_power_set_gpio(power, flip);
>> +	} else {
>> +		for (i = 0; i < mp->num_gpio; i++) {
>> +			gpio_set_value(config[i].gpio, 0);
>> +			gpio_free(config[i].gpio);
>> +		}
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int dp_power_client_init(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		return -EINVAL;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	pm_runtime_enable(&power->pdev->dev);
>> +
>> +	rc = dp_power_regulator_init(power);
>> +	if (rc) {
>> +		pr_err("failed to init regulators\n");
> 
> Print rc
> 
>> +		goto error_power;
>> +	}
>> +
>> +	rc = dp_power_clk_init(power, true);
>> +	if (rc) {
>> +		pr_err("failed to init clocks\n");
> 
> Print rc
> 
fixed in V2.
>> +		goto error_clk;
>> +	}
>> +	return 0;
>> +
>> +error_clk:
>> +	dp_power_regulator_deinit(power);
>> +error_power:
>> +	pm_runtime_disable(&power->pdev->dev);
>> +	return rc;
>> +}
>> +
>> +static void dp_power_client_deinit(struct dp_power *dp_power)
>> +{
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		return;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	dp_power_clk_init(power, false);
>> +	dp_power_regulator_deinit(power);
>> +	pm_runtime_disable(&power->pdev->dev);
>> +
>> +}
>> +
>> +static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	if (power->pixel_clk_rcg && power->pixel_parent)
>> +		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
> 
> Check return value
> 
Fixed in V2.
>> +exit:
> 
> Delete label/rc, return immediately.
> 
Fixed in V2.

>> +	return rc;
>> +}
>> +
>> +static int dp_power_init(struct dp_power *dp_power, bool flip)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	pm_runtime_get_sync(&power->pdev->dev);
>> +	rc = dp_power_regulator_ctrl(power, true);
>> +	if (rc) {
>> +		pr_err("failed to enable regulators\n");
> 
> Print rc
> 
>> +		goto exit;
>> +	}
>> +
>> +	rc = dp_power_pinctrl_set(power, true);
>> +	if (rc) {
> 
> Print rc
> 
Fixed in V2.

>> +		pr_err("failed to set pinctrl state\n");
>> +		goto err_pinctrl;
>> +	}
>> +
>> +	rc = dp_power_config_gpios(power, flip, true);
>> +	if (rc) {
> 
> Print rc
> 
Fixed in V2.

>> +		pr_err("failed to enable gpios\n");
>> +		goto err_gpio;
>> +	}
>> +
>> +	rc = dp_power_clk_enable(dp_power, DP_CORE_PM, true);
>> +	if (rc) {
> 
> Print rc
> 
>> +		pr_err("failed to enable DP core clocks\n");
>> +		goto err_clk;
>> +	}
>> +
>> +	return 0;
>> +
>> +err_clk:
>> +	dp_power_config_gpios(power, flip, false);
>> +err_gpio:
>> +	dp_power_pinctrl_set(power, false);
>> +err_pinctrl:
>> +	dp_power_regulator_ctrl(power, false);
>> +exit:
>> +	pm_runtime_put_sync(&power->pdev->dev);
>> +	return rc;
>> +}
>> +
>> +static int dp_power_deinit(struct dp_power *dp_power)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +
>> +	if (!dp_power) {
>> +		pr_err("invalid power data\n");
>> +		rc = -EINVAL;
>> +		goto exit;
>> +	}
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	dp_power_clk_enable(dp_power, DP_CORE_PM, false);
>> +	dp_power_config_gpios(power, false, false);
>> +	dp_power_pinctrl_set(power, false);
>> +	dp_power_regulator_ctrl(power, false);
>> +	pm_runtime_put_sync(&power->pdev->dev);
>> +exit:
> 
> Delete exit label/rc and return directly
> 
Fixed in V2.

>> +	return rc;
>> +}
>> +
>> +struct dp_power *dp_power_get(struct dp_parser *parser)
>> +{
>> +	int rc = 0;
>> +	struct dp_power_private *power;
>> +	struct dp_power *dp_power;
>> +
>> +	if (!parser) {
>> +		pr_err("invalid input\n");
>> +		rc = -EINVAL;
>> +		goto error;
>> +	}
>> +
>> +	power = devm_kzalloc(&parser->pdev->dev, sizeof(*power), 
>> GFP_KERNEL);
>> +	if (!power) {
>> +		rc = -ENOMEM;
>> +		goto error;
>> +	}
>> +
>> +	power->parser = parser;
>> +	power->pdev = parser->pdev;
>> +
>> +	dp_power = &power->dp_power;
>> +
>> +	dp_power->init = dp_power_init;
>> +	dp_power->deinit = dp_power_deinit;
>> +	dp_power->clk_enable = dp_power_clk_enable;
>> +	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
>> +	dp_power->power_client_init = dp_power_client_init;
>> +	dp_power->power_client_deinit = dp_power_client_deinit;
>> +
>> +	return dp_power;
>> +error:
>> +	return ERR_PTR(rc);
>> +}
>> +
>> +void dp_power_put(struct dp_power *dp_power)
>> +{
>> +	struct dp_power_private *power = NULL;
>> +
>> +	if (!dp_power)
>> +		return;
>> +
>> +	power = container_of(dp_power, struct dp_power_private, dp_power);
>> +
>> +	devm_kfree(&power->pdev->dev, power);
>> +}
>> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h 
>> b/drivers/gpu/drm/msm/dp/dp_power.h
>> new file mode 100644
>> index 0000000..d1adaaf
>> --- /dev/null
>> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
>> @@ -0,0 +1,57 @@
>> +/*
>> + * Copyright (c) 2012-2018, The Linux Foundation. All rights 
>> reserved.


/snip


>> +
>> +/* USB3 DP COM registers */
>> +#define USB3_DP_COM_RESET_OVRD_CTRL (0x1C)
>> +#define USB3_DP_COM_PHY_MODE_CTRL   (0x00)
>> +#define USB3_DP_COM_SW_RESET        (0x04)
>> +#define USB3_DP_COM_TYPEC_CTRL      (0x10)
>> +#define USB3_DP_COM_SWI_CTRL        (0x0c)
>> +#define USB3_DP_COM_POWER_DOWN_CTRL (0x08)
>> +
>> +
>> +
>> +#endif /* _DP_REG_H_ */
>> diff --git a/drivers/gpu/drm/msm/msm_drv.c 
>> b/drivers/gpu/drm/msm/msm_drv.c
>> index f5cd7f6..be801be 100644
>> --- a/drivers/gpu/drm/msm/msm_drv.c
>> +++ b/drivers/gpu/drm/msm/msm_drv.c
>> @@ -1367,6 +1367,7 @@ static int __init msm_drm_register(void)
>>  	msm_dsi_register();
>>  	msm_edp_register();
>>  	msm_hdmi_register();
>> +	msm_dp_register();
>>  	adreno_register();
>>  	return platform_driver_register(&msm_platform_driver);
>>  }
>> @@ -1375,6 +1376,7 @@ static void __exit msm_drm_unregister(void)
>>  {
>>  	DBG("fini");
>>  	platform_driver_unregister(&msm_platform_driver);
>> +	msm_dp_unregister();
>>  	msm_hdmi_unregister();
>>  	adreno_unregister();
>>  	msm_edp_unregister();
>> diff --git a/drivers/gpu/drm/msm/msm_drv.h 
>> b/drivers/gpu/drm/msm/msm_drv.h
>> index 9d11f32..fb1e6f4 100644
>> --- a/drivers/gpu/drm/msm/msm_drv.h
>> +++ b/drivers/gpu/drm/msm/msm_drv.h
>> @@ -176,6 +176,7 @@ struct msm_drm_private {
>>  	/* DSI is shared by mdp4 and mdp5 */
>>  	struct msm_dsi *dsi[2];
>> 
>> +	struct msm_dp *dp;
> 
> Can you please add an extra line here?
> 
Will fix this in V3.
>>  	/* when we have more than one 'msm_gpu' these need to be an array: 
>> */
>>  	struct msm_gpu *gpu;
>>  	struct msm_file_private *lastctx;
>> @@ -364,6 +365,27 @@ static inline int msm_dsi_modeset_init(struct 
>> msm_dsi *msm_dsi,
>>  }
>>  #endif
>> 
>> +#ifdef CONFIG_DRM_MSM_DP
>> +int __init msm_dp_register(void);
>> +void __exit msm_dp_unregister(void);
>> +int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device 
>> *dev,
>> +			 struct drm_encoder *encoder);
>> +#else
>> +static inline int __init msm_dp_register(void)
>> +{
>> +	return -EINVAL;
>> +}
>> +static inline void __exit msm_dp_unregister(void)
>> +{
>> +}
>> +static inline int msm_dp_modeset_init(struct msm_dp *dp_display,
>> +				       struct drm_device *dev,
>> +				       struct drm_encoder *encoder)
>> +{
>> +	return -EINVAL;
>> +}
>> +#endif
>> +
>>  void __init msm_mdp_register(void);
>>  void __exit msm_mdp_unregister(void);
>>  void __init msm_dpu_register(void);
>> diff --git a/include/drm/drm_dp_helper.h b/include/drm/drm_dp_helper.h
>> index 2a3843f..b0816f5 100644
>> --- a/include/drm/drm_dp_helper.h
>> +++ b/include/drm/drm_dp_helper.h
> 
> Split these changes out into a separate patch, please
> 
This is already handled as a separate patch and is ready to merge.

>> @@ -551,6 +551,8 @@
>>  # define DP_TEST_LINK_EDID_READ		    (1 << 2)
>>  # define DP_TEST_LINK_PHY_TEST_PATTERN	    (1 << 3) /* DPCD >= 1.1 */
>>  # define DP_TEST_LINK_FAUX_PATTERN	    (1 << 4) /* DPCD >= 1.2 */
>> +# define DP_TEST_LINK_AUDIO_PATTERN     (1 << 5)
>> +# define DP_TEST_LINK_AUDIO_DISABLED_VIDEO (1 << 6)
> 
> Add DPCD version in comments for these like above.
> 
>> 
>>  #define DP_TEST_LINK_RATE		    0x219
>>  # define DP_LINK_RATE_162		    (0x6)
>> @@ -639,6 +641,13 @@
>>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_71_64  0x258
>>  #define	DP_TEST_80BIT_CUSTOM_PATTERN_79_72  0x259
>> 
>> +#define DP_TEST_PHY_PATTERN_NONE			0x0
>> +#define DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING	0x1
>> +#define DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT 0x2
>> +#define DP_TEST_PHY_PATTERN_PRBS7			0x3
>> +#define DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN	0x4
>> +#define DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN	0x5
> 
> These are already in drm_dp_helper under DP_LINK_QUAL_PATTERN_*
> 
>> +
>>  #define DP_TEST_RESPONSE		    0x260
>>  # define DP_TEST_ACK			    (1 << 0)
>>  # define DP_TEST_NAK			    (1 << 1)
>> @@ -648,6 +657,16 @@
>> 
>>  #define DP_TEST_SINK			    0x270
>>  # define DP_TEST_SINK_START		    (1 << 0)
>> +#define DP_TEST_AUDIO_MODE		    0x271
>> +#define DP_TEST_AUDIO_PATTERN_TYPE	    0x272
>> +#define DP_TEST_AUDIO_PERIOD_CH1	    0x273
>> +#define DP_TEST_AUDIO_PERIOD_CH2	    0x274
>> +#define DP_TEST_AUDIO_PERIOD_CH3	    0x275
>> +#define DP_TEST_AUDIO_PERIOD_CH4	    0x276
>> +#define DP_TEST_AUDIO_PERIOD_CH5	    0x277
>> +#define DP_TEST_AUDIO_PERIOD_CH6	    0x278
>> +#define DP_TEST_AUDIO_PERIOD_CH7	    0x279
>> +#define DP_TEST_AUDIO_PERIOD_CH8	    0x27A
>> 
>>  #define DP_FEC_STATUS			    0x280    /* 1.4 */
>>  # define DP_FEC_DECODE_EN_DETECTED	    (1 << 0)
>> --
>> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora 
>> Forum,
>> a Linux Foundation Collaborative Project
>> 
>> _______________________________________________
>> Freedreno mailing list
>> Freedreno@lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/freedreno
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [Freedreno] [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[Sean Paul]

On Thu, Feb 14, 2019 at 04:28:33AM -0800, chandanu@codeaurora.org wrote:
> On 2018-10-23 09:28, Sean Paul wrote:
> > On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
> > > Add the needed displayPort files to enable DP driver
> > > on msm target.
> > > 
> > > "dp_display" module is the main module that calls into
> > > other sub-modules. "dp_drm" file represents the interface
> > > between DRM framework and DP driver.
> > > 
> > 
> 
> Hello Sean,
> I have responded to all of your comments and queries. I have specified the
> comments addressed
> in V2 patch series and what I have missed that will be fixed in V3.
> 
> 

/snip

> > > 
> > > +struct dss_io_data {
> > > +	u32 len;
> > > +	void __iomem *base;
> > > +};
> > 
> > len isn't used anywhere, so this struct can go away. If the struct goes
> > away,
> > you can really simplify (or eliminate msm_dss_ioremap_byname())
> > 
> 
> We want to keep this since we use len for our internal unit level testing
> and in simulation mode.
> 

That's not really a valid reason to keep unused code around. We can't reasonably
expect upstream developers to know which structs and unused fields are used for
Qualcomm's downstream testing, and afaict, those results aren't published so
there's no benefit to the upsteam community.

So you can either opensource the unit tests along with the driver, or keep the
downstream code in the downstream kernel.

/snip

> > > +
> > > +#define dp_catalog_get_priv(x) { \
> > 
> > static inline struct dp_catalog_private *dp_catalog_get_priv(...)
> > {
> >         ...
> > }
> > 
> For inline, we have to use 3 different functions (one each for aux, ctrl and
> panel).
> Looking at "type-checking" w.r.t macro, container_of will through an error
> if its not valid pointer.
> Please let me know if you still want to change this macro to inline func.
> 

Yeah, I think it's worth it to have the 3.

> > > +	struct dp_catalog *dp_catalog; \
> > > +	dp_catalog = container_of(x, struct dp_catalog, x); \
> > > +	catalog = container_of(dp_catalog, struct dp_catalog_private, \
> > > +				dp_catalog); \
> > > +}

/snip

> > 
> > Then again, I'm guessing hitting the NULL case is likely impossible, so
> > you can
> > probably remove all of the machinery around checking !aux.
> > 
> 
> Removed most of the arg null checks except few APIs where
> unit-testing/simulator-mode is used.
> 

There should only be null checks if null is a possibility. If you have
pathelogical unit tests injecting bogus values in your function, you should
probably just fix/delete those unit tests. If upstream doesn't have
visibility into your internal testing, we can't distinguish between
test-pleasing vs unused code.

> > > +static void dp_catalog_ctrl_send_phy_pattern(struct dp_catalog_ctrl
> > > *ctrl,
> > > +			u32 pattern)
> > > +{
> > > +	struct dp_catalog_private *catalog;
> > > +	u32 value = 0x0;
> > > +	void __iomem *base = NULL;
> > > +
> > > +	if (!ctrl) {
> > > +		pr_err("invalid input\n");
> > > +		return;
> > > +	}
> > > +
> > > +	dp_catalog_get_priv(ctrl);
> > > +
> > > +	base = catalog->io->dp_link.base;
> > > +
> > > +	dp_write(base + DP_STATE_CTRL, 0x0);
> > 
> > Do you really need to do this?
> > 
> Yes, to make sure no other pattern is set/enabled in hardware before any new
> pattern is configured.
> 
> > > +
> > > +	switch (pattern) {
> > > +	case DP_TEST_PHY_PATTERN_D10_2_NO_SCRAMBLING:
> > > +		dp_write(base + DP_STATE_CTRL, 0x1);
> > > +		break;
> > > +	case DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT:
> > > +		value &= ~(1 << 16);
> > > +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> > > +		value |= 0xFC;
> > > +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> > > +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
> > > +		dp_write(base + DP_STATE_CTRL, 0x10);
> > > +		break;
> > > +	case DP_TEST_PHY_PATTERN_PRBS7:
> > > +		dp_write(base + DP_STATE_CTRL, 0x20);
> > > +		break;
> > > +	case DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN:
> > > +		dp_write(base + DP_STATE_CTRL, 0x40);
> > > +		/* 00111110000011111000001111100000 */
> > > +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG0, 0x3E0F83E0);
> > > +		/* 00001111100000111110000011111000 */
> > > +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG1, 0x0F83E0F8);
> > > +		/* 1111100000111110 */
> > > +		dp_write(base + DP_TEST_80BIT_CUSTOM_PATTERN_REG2, 0x0000F83E);
> > > +		break;
> > > +	case DP_TEST_PHY_PATTERN_HBR2_CTS_EYE_PATTERN:
> > > +		value = BIT(16);
> > > +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> > > +		value |= 0xFC;
> > > +		dp_write(base + DP_HBR2_COMPLIANCE_SCRAMBLER_RESET, value);
> > > +		dp_write(base + DP_MAINLINK_LEVELS, 0x2);
> > > +		dp_write(base + DP_STATE_CTRL, 0x10);
> > 
> > This code is the exact same as the case for
> > DP_TEST_PHY_PATTERN_SYMBOL_ERR_MEASUREMENT_CNT, aside from BIT(16) vs
> > ~BIT(16). Can you please combine these cases
> > and share code?
> 
> Will fix this in V3.
> 
> > 
> > > +		break;
> > > +	default:
> > > +		pr_debug("No valid test pattern requested: 0x%x\n", pattern);
> > > +		return;
> > > +	}
> > 
> > All of the DP_STATE_CTRL values should be #defined, and you can move the
> > write
> > down here instead of duplicating it everywhere (with
> > DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN writing a 0).
> > 
> All the DP_STATE_CTRL values are defines in V2.
> 
> I am not clear on moving the write operations after the switch cases. Can
> you please provide
> some more details?

I think what I meant was that since all cases finish with a write to
DP_STATE_CTRL, you can move that write out of each case and put it at the
bottom. But I think I missed that DP_STATE_CTRL is set at the beginning of
DP_TEST_PHY_PATTERN_80_BIT_CUSTOM_PATTERN, so I don't think that'll work.

/snip

> > > +struct dp_ctrl_private {
> > > +	struct dp_ctrl dp_ctrl;
> > > +
> > > +	struct device *dev;
> > > +	struct dp_aux *aux;
> > > +	struct dp_panel *panel;
> > > +	struct dp_link *link;
> > > +	struct dp_power *power;
> > > +	struct dp_parser *parser;
> > > +	struct dp_catalog_ctrl *catalog;
> > 
> > Once you remove struct dp_ctrl and call the functions directly, I
> > suspect you
> > can get rid of all of these.
> > 
> Even though we call the functions directly, we still need variables present
> in each module.
> For example, we need to access link parameters, panel parameters etc
> 
> Unnecessary stuff is removed but we still need other variables in the
> structure. All have been
> updated in V2.

Ok, I'll re-evaluate in v3

/snip

> > > +static void dp_ctrl_push_idle(struct dp_ctrl *dp_ctrl)
> > > +{
> > > +	int const idle_pattern_completion_timeout_ms = 3 * HZ / 100;
> > 
> > This should be #define'd outside of the functioninstead. Also, why the
> > '_ms_'
> > suffix? The units are in jiffies.
> > 
> > I think something like
> > 
> > #define IDLE_PATTERN_COMPLETION_TIMEOUT_JIFFIES (30 * HZ / 1000) /* 30
> > ms */
> > 
> > would be clearer.
> > 
> Fixed in V2.
> 
> > > +	struct dp_ctrl_private *ctrl;
> > > +
> > > +	if (!dp_ctrl) {
> > > +		pr_err("Invalid input data\n");
> > > +		return;
> > > +	}
> > > +
> > > +	ctrl = container_of(dp_ctrl, struct dp_ctrl_private, dp_ctrl);
> > > +
> > > +	reinit_completion(&ctrl->idle_comp);
> > 
> > This function is called from a bunch of places, and idle_comp is also
> > used in a
> > bunch of places. Are you certain this is thread-safe if you have
> > concurrent
> > callers or users of idle_comp?
> > 
> I don't think we need any synchronization logic for idle_comp since it is
> reinitialized only
> when the complete core is reset. Only place where it is needed is in
> push_idle which already has
> a mutex.

So here are the callsites for push_idle():
- dp_display_clean- called on extcon event thread, unlocked
- dp_display_pre_disable- called on drm thread, locked with modeset locks
- dp_ctrl_link_maintenance- called in hpd handler, unlocked

It _seems_ like there could be races here, and I don't know which mutex you're
referring to above. Mind walking me through it in more detail?

> 
> > > +	dp_ctrl_state_ctrl(ctrl, ST_PUSH_IDLE);
> > > +
> > > +	if (!wait_for_completion_timeout(&ctrl->idle_comp,
> > > +			idle_pattern_completion_timeout_ms))
> > > +		pr_warn("PUSH_IDLE pattern timedout\n");
> > 
> > Return an error?
> > 
> Its not fatal error since we are going to reset the controller and we are
> going to recover from
> this timeout.

In that case, can you please downgrade the log level to debug or info?

/snip

> > > +
> > > +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> > 
> > You should really protect sink_request with a lock, it's racy. I'm
> > trying
> > to catch the race conditions while I review, but I'd urge you to audit
> > the
> > driver for other places that need locking.
> > 
> sink_request will be running in a single-threaded work queue.
> ("drm_dp_extcon" work queue).
> We might not need locking for sink_request.
> 

It seems like sink_request could change in between reads in dp_ctrl_on?
dp_ctrl_on reads the value twice, and calls dp_ctrl_setup_main_link which also
reads the value.

/snip

> > > +static void dp_ctrl_set_clock_rate(struct dp_ctrl_private *ctrl,
> > > +				   char *name, u32 rate)
> > > +{
> > > +	u32 num = ctrl->parser->mp[DP_CTRL_PM].num_clk;
> > > +	struct dss_clk *cfg = ctrl->parser->mp[DP_CTRL_PM].clk_config;
> > > +
> > > +	while (num && strcmp(cfg->clk_name, name)) {
> > > +		num--;
> > > +		cfg++;
> > > +	}
> > > +
> > > +	pr_debug("setting rate=%d on clk=%s\n", rate, name);
> > > +
> > > +	if (num)
> > > +		cfg->rate = rate;
> > > +	else
> > > +		pr_err("%s clock could not be set with rate %d\n", name, rate);
> > > +}
> > 
> > Instead of doing all of this work, just store pointers to the link and
> > pixel
> > clock when you parse the dt. That way you can just access them directly
> > in
> > dp_ctrl_enable_mainlink_clocks.
> > 
> These are generic implementation for DP_CORE and DP_CTRL clocks. This will
> help
> for any future upgrades where the only change will be done dtsi and maybe
> minor
> changes in Driver when we add/remove any clocks.

Just add new pointers and NULL checks in the future if/when this is needed.

/snip

> > > +
> > > +	if (ctrl->link->sink_request & DP_TEST_LINK_PHY_TEST_PATTERN)
> > 
> > This is racy, sink_request could change between the check above and
> > here.
> > 
> Sink_request is accessed in single thread context.
> 

Ah, so I mentioned that in the earlier review. I guess I'm not seeing what
prevents that single thread from modifying the value twice? This code will be
run in a different thread, so it really seems like there could be a race here.

/snip

> > > +static void dp_display_send_hpd_event(struct msm_dp *dp_display)
> > > +{
> > > +	struct dp_display_private *dp;
> > > +	struct drm_connector *connector;
> > > +
> > > +	if (!dp_display) {
> > > +		pr_err("invalid input\n");
> > > +		return;
> > > +	}
> > > +
> > > +	dp = container_of(dp_display, struct dp_display_private,
> > > dp_display);
> > > +	if (!dp) {
> > > +		pr_err("invalid params\n");
> > > +		return;
> > > +	}
> > > +
> > > +	connector = dp->dp_display.connector;
> > > +	drm_helper_hpd_irq_event(connector->dev);
> > > +}
> > > +
> > > +static int dp_display_send_hpd_notification(struct
> > > dp_display_private *dp,
> > > +					    bool hpd)
> > 
> > This function is called from a few different threads with no locking. It
> > seems
> > like there's good opportunity for is_connected and notification_comp to
> > get out
> > of sync.
> > 
> > Additionally, is_connected is set to true before the function returns
> > (and
> > enable has been completed). So is that going to cause problems when we
> > call
> > detect/get_modes where is_connected == true and the hw is not up?
> > 
> Will fix this in V3.
> 
> 
> > Perhaps I'm misreading this function, but it seems like the plan is to
> > block
> > until userspace has been notified and does a full modeset (ie: enable)?
> > If that
> > is the case, we usually don't want to have the hardware lit up until
> > it's
> > actually going to be used. In these cases, we'll wrap get_modes in
> > enable/disable (with proper locking), and wait for modeset to leave it
> > on.
> > 
> When HPD goes high, we do dpcd reads to get the sink capabilities and then
> inform the framework so that "enable"
> gets called by drm framework.
> 

I'm not sure I follow what you're saying. Is notification_comp meant to
ratelimit/debounce hpd notifications? I don't think it's needed, and if it is,
it would be interesting to know why.

> > > +{
> > > +	if ((hpd && dp->dp_display.is_connected) ||
> > > +			(!hpd && !dp->dp_display.is_connected)) {
> > > +		pr_info("HPD already %s\n", (hpd ? "on" : "off"));
> > > +		return 0;
> > > +	}
> > > +
> > > +	/* reset video pattern flag on disconnect */
> > > +	if (!hpd)
> > > +		dp->panel->video_test = false;
> > > +
> > > +	dp->dp_display.is_connected = hpd;
> > > +	reinit_completion(&dp->notification_comp);
> > > +	dp_display_send_hpd_event(&dp->dp_display);
> > > +
> > > +	if (!wait_for_completion_timeout(&dp->notification_comp, HZ * 2)) {
> > > +		pr_warn("%s timeout\n", hpd ? "connect" : "disconnect");
> > > +		return -EINVAL;
> > > +	}
> > > +
> > > +	return 0;
> > > +}

/snip

> > > +/**
> > > + * dp_connector_get_modes - callback to add drm modes via
> > > drm_mode_probed_add()
> > > + * @connector: Pointer to drm connector structure
> > > + * Returns: Number of modes added
> > > + */
> > > +static int dp_connector_get_modes(struct drm_connector *connector)
> > > +{
> > > +	int rc = 0;
> > > +	struct msm_dp *dp;
> > > +	struct dp_display_mode *dp_mode = NULL;
> > > +	struct drm_display_mode *m, drm_mode;
> > > +	struct dp_connector *dp_conn;
> > > +
> > > +	if (!connector)
> > > +		return 0;
> > > +
> > > +	dp_conn = to_dp_connector(connector);
> > > +	dp = dp_conn->dp_display;
> > > +
> > > +	dp_mode = kzalloc(sizeof(*dp_mode),  GFP_KERNEL);
> > > +	if (!dp_mode)
> > > +		return 0;
> > 
> > When you get rid of dp_display_mode, please use the stack for the new
> > drm_display_mode
> > 
> Fixed in V2.
> 
> > > +
> > > +	/* pluggable case assumes EDID is read when HPD */
> > > +	if (dp->is_connected) {
> > > +		rc = dp->get_modes(dp, dp_mode);
> > 
> > Why is only one mode returned?
> > 
> The get_modes() function might return one mode that is stored
> in dp_mode when compliance test is in progress. If not, the
> return value is equal to the total number of modes supported
> by the sink

Ah. I think this would be better to do this work in dp_panel_get_modes and
return 1 from there. Then you can remove all of the special handling from this
function.

> 
> > > +		if (!rc)
> > 
> > This can also return -errno, you should check for that too.
> > 
> Fixed in V2.
> 
> > > +			pr_err("failed to get DP sink modes, rc=%d\n", rc);
> > 
> > Why continue if you know you failed?
> > 
> > > +
> > > +		if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
> > > +			memset(&drm_mode, 0x0, sizeof(drm_mode));
> > > +			convert_to_drm_mode(dp_mode, &drm_mode);
> > > +			m = drm_mode_duplicate(connector->dev, &drm_mode);
> > > +			if (!m) {
> > > +				pr_err("failed to add mode %ux%u\n",
> > > +				       drm_mode.hdisplay,
> > > +				       drm_mode.vdisplay);
> > > +				kfree(dp_mode);
> > > +				return 0;
> > > +			}
> > > +			m->width_mm = connector->display_info.width_mm;
> > > +			m->height_mm = connector->display_info.height_mm;
> > 
> > You shouldn't overwrite these.
> > 
> Fixed in V2.
> 
> > > +			drm_mode_probed_add(connector, m);
> > > +		}
> > > +	} else {
> > > +		pr_err("No sink connected\n");
> > 
> > This shouldn't be an error
> > 
> Fixed in V2.
> 
> > > +	}
> > > +	kfree(dp_mode);
> > > +
> > > +	return rc;
> > > +}

/snip

> > > + * @link: Display Port Driver data
> > > + *
> > > + * Parses the DPCD to check if an automated link is requested (Byte
> > > 0x201),
> > > + * and what type of link automation is being requested (Byte 0x218).
> > > + */
> > > +static int dp_link_parse_request(struct dp_link_private *link)
> > > +{
> > > +	int ret = 0;
> > > +	u8 bp;
> > > +	u8 data;
> > 
> > Only need 1 of bp/data
> > 
> > > +	int rlen;
> > 
> > ssize_t
> > 
> > > +	u32 const param_len = 0x1;
> > 
> > Not needed, use drm_dp_dpcd_readb()
> > 
> > > +
> > > +	/**
> > > +	 * Read the device service IRQ vector (Byte 0x201) to determine
> > > +	 * whether an automated link has been requested by the sink.
> > > +	 */
> > > +	rlen = drm_dp_dpcd_read(link->aux->drm_aux,
> > > +		DP_DEVICE_SERVICE_IRQ_VECTOR, &bp, param_len);
> > > +	if (rlen < param_len) {
> > > +		pr_err("aux read failed\n");
> > 
> > Print error. This goes for other failure messages in this file.
> > 
> Addressed all the comments above in this function in V2.
> 
> > > +		ret = -EINVAL;
> > > +		goto end;
> > > +	}
> > > +
> > > +	data = bp;
> > > +
> > > +	pr_debug("device service irq vector = 0x%x\n", data);
> > > +
> > > +	if (!(data & DP_AUTOMATED_TEST_REQUEST)) {
> > > +		pr_debug("no test requested\n");
> > > +		return 0;
> > > +	}
> > > +
> > > +	/**
> > > +	 * Read the link request byte (Byte 0x218) to determine what type
> > > +	 * of automated link has been requested by the sink.
> > > +	 */
> > > +	rlen = drm_dp_dpcd_read(link->aux->drm_aux, DP_TEST_REQUEST,
> > > +			&bp, param_len);
> > > +	if (rlen < param_len) {
> > > +		pr_err("aux read failed\n");
> > > +		ret = -EINVAL;
> > > +		goto end;
> > > +	}
> > > +
> > > +	data = bp;
> > > +
> > > +	if (!dp_link_is_test_supported(data)) {
> > > +		pr_debug("link 0x%x not supported\n", data);
> > > +		goto end;
> > > +	}
> > > +
> > > +	pr_debug("%s (0x%x) requested\n", dp_link_get_test_name(data),
> > > data);
> > > +	link->request.test_requested = data;
> > 
> > If test_requested is only used in the scope of this function, just use a
> > local
> > and pass it around. If test_requested is used outside the scope of this
> > function, you need locking.
> 
> test_requested in only used in dp_link.c. But we use this in dp_debug for
> debugging. We also
> use this in unit testing. This is one of main reason we have it in dp_link
> structure.
> 

Ok, same comment regarding unit testing as above. Please change this to a local
in the upstream version.

/snip

> > > +	/**
> > 
> > /*
> > 
> Multi-line comments, we use "/**"
> 

This will cause warnings in the htmldocs build. See
https://www.kernel.org/doc/html/latest/process/coding-style.html#commenting

/snip

> > > +static void dp_link_send_test_response(struct dp_link *dp_link)
> > > +{
> > > +	struct dp_link_private *link = NULL;
> > > +	u32 const response_len = 0x1;
> > > +
> > > +	if (!dp_link) {
> > > +		pr_err("invalid input\n");
> > > +		return;
> > > +	}
> > > +
> > > +	link = container_of(dp_link, struct dp_link_private, dp_link);
> > > +
> > > +	drm_dp_dpcd_write(link->aux->drm_aux, DP_TEST_RESPONSE,
> > > +			&dp_link->test_response, response_len);
> > 
> > I strongly suspect you should have locking protecting test_response.
> > 
> Will cross-check whether we need locking and fix it in V3. Just curious, do
> you still think
> we need locking even though we handle this in a single thread?

AFAICT, this is called from the drm thread (via 
dp_ctrl_on->dp_ctrl_send_phy_test_pattern), and extcon hpd thread?

/snip

> > > +static u8 get_link_status(const u8
> > > link_status[DP_LINK_STATUS_SIZE], int r)
> > > +{
> > > +	return link_status[r - DP_LANE0_1_STATUS];
> > 
> > I don't think you're really supposed to reach into the link_status like
> > this.
> > How about adding a new helper to check for DP_LINK_STATUS_UPDATED and
> > one for
> > DP_DOWNSTREAM_PORT_STATUS_CHANGED?
> > 
> This function is similar to function in upstream drm_dp_helper.c file.
> https://chromium.googlesource.com/chromiumos/third_party/kernel/+/chromeos-3.18/drivers/gpu/drm/drm_dp_helper.c#259
> 

Yeah, that's my point, it's something that's done internally to the helper.
Adding a couple helpers to drm_dp_helper will clean up this code and also
benefit others who need to do the same thing (I don't see anyone else checking
those bits yet).

> > > +}

/snip

> > > +static bool dp_link_is_ds_port_status_changed(struct
> > > dp_link_private *link)
> > > +{
> > > +	if (get_link_status(link->link_status,
> > > DP_LANE_ALIGN_STATUS_UPDATED) &
> > > +		DP_DOWNSTREAM_PORT_STATUS_CHANGED) /* port status changed */
> > > +		return true;
> > > +
> > > +	if (link->prev_sink_count != link->dp_link.sink_count.count)
> > 
> > It seems like this is running in a separate thread from where
> > prev_sink_count is
> > set, potential race here?
> > 
> I don't think we might need locking here. All the updates/checks related to
> prev_sink_count are done
> in dp_link_process_request() which will run in single threaded work queue.
>

Hmm, didn't realize it's only set/accessed in dp_link_process_request. Can you
change this to a local var and just pass it via arguments so 1- the code is more
clear, and 2- there's no chance it gets stomped by another thread.

/snip

> > > +static u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32
> > > bpp)
> > > +{
> > > +	u32 tbd;
> > > +
> > > +	/*
> > > +	 * Few simplistic rules and assumptions made here:
> > > +	 *    1. Test bit depth is bit depth per color component
> > > +	 *    2. Assume 3 color components
> > > +	 */
> > > +	switch (bpp) {
> > > +	case 18:
> > > +		tbd = DP_TEST_BIT_DEPTH_6;
> > > +		break;
> > > +	case 24:
> > > +		tbd = DP_TEST_BIT_DEPTH_8;
> > > +		break;
> > > +	case 30:
> > > +		tbd = DP_TEST_BIT_DEPTH_10;
> > > +		break;
> > > +	default:
> > > +		tbd = DP_TEST_BIT_DEPTH_UNKNOWN;
> > > +		break;
> > > +	}
> > > +
> > > +	if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN)
> > > +		tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT);
> > 
> > AFAICT tbd corresponds to a SoC register value, as opposed to the DPCD
> > value.
> > It's a happy coincidence that they're the same, however I think you
> > should use a
> > separate msm-specific #define instead of the drm_dp_helper values.
> > 
> These are standard bpp values and will match to the DPCD values. For the
> same reason
> we are using existing standard macros.

Hmm, Ok. Mind adding a comment then? It's a bit confusing to mix the values.

/snip

> > > +	rc = dp_panel_read_edid(dp_panel, connector);
> > 
> > Why read the edid so early? Can't you wait until get_modes is called
> > (you'll
> > have to re-read anyways).
> > 
> We won't do re-read again when get_modes is called.
> 

You really should be, userspace should determine when/whether to limit it. With
that change, you can remove the read from here.


> > > +	if (rc) {
> > > +		pr_err("panel edid read failed, set failsafe mode\n");
> > > +		return rc;
> > > +	}
> > > +
> > > +	if (panel->aux_cfg_update_done) {
> > > +		pr_debug("read DPCD with updated AUX config\n");
> > > +		dp_panel_read_dpcd(dp_panel);
> > 
> > Check return value. Should you also check the rate/lane_count validity
> > again too?
> > 
> Fixed in V2.
> 
> > > +		panel->aux_cfg_update_done = false;
> > 
> > Should you have locking for aux_cfg_update_done?
> > 
> panel_read_edid() and aux_cfg_update_done = false is done one after the
> other in this function. I don't think
> we locking for this.

Another good case of not needing to store this in a central place. Just make
this a local in dp_panel_read_sink_caps().

/snip

> > > +	mp->vreg_config = devm_kzalloc(&parser->pdev->dev,
> > > +		sizeof(struct dss_vreg) * mp->num_vreg, GFP_KERNEL);
> > > +	if (!mp->vreg_config) {
> > > +		rc = -ENOMEM;
> > > +		goto error;
> > > +	}
> > > +
> > > +	for_each_child_of_node(supply_root_node, supply_node) {
> > > +		const char *st = NULL;
> > > +		/* vreg-name */
> > > +		rc = of_property_read_string(supply_node,
> > > +			"qcom,supply-name", &st);
> > > +		if (rc) {
> > > +			pr_err("error reading name. rc=%d\n",
> > > +				 rc);
> > > +			goto error;
> > > +		}
> > > +		snprintf(mp->vreg_config[i].vreg_name,
> > > +			ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st);
> > 
> > Instead of storing the name just to get a regulator reference later, why
> > don't
> > you just grab the reference now and avoid the string ops?
> > 
> Vreg keep changing for each chip. This is more generic implementation that
> avoids doing changes to the code.
> Updating the dtsi-platform specific changes will have access to the vregs.

Changing the code is fun, string operations are not fun. In order to maximize
fun, can we please change these?

More seriously, trying to come up with generic solutions is super tricky and
more often than not, incorrect. The only thing we know for certain about
designing code is that it will eventually be obsolete :)

/snip

> > > +
> > > +		if (dp_parser_check_prefix(core_clk, clk_name))
> > > +			core_clk_count++;
> > > +
> > > +		if (dp_parser_check_prefix(ctrl_clk, clk_name))
> > > +			ctrl_clk_count++;
> > 
> > Just use "core"/"ctrl" directly here.
> > 
> > Have you considered just having 2 clock lists? That would avoid having
> > to do
> > this.
> > 
> I didn't get what you meant by two clock lists. We currently have two clock
> list to store them locally.
> You mean having two clock lists in dtsi?
> 

Yes, I believe that's what I meant.

/snip

> > > --
> > > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
> > > Forum,
> > > a Linux Foundation Collaborative Project
> > > 
> > > _______________________________________________
> > > Freedreno mailing list
> > > Freedreno@lists.freedesktop.org
> > > https://lists.freedesktop.org/mailman/listinfo/freedreno

-- 
Sean Paul, Software Engineer, Google / Chromium OS
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

Re: [DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

[chandanu-sgV2jX0FEOL9JmXXK+q4OQ]

On 2019-02-14 04:28, chandanu@codeaurora.org wrote:
Hello Sean
I had few more queries regarding your comments. Can you please provide 
your feedback? (Queries/responses are present below)

thanks
Chandan

> On 2018-10-23 09:28, Sean Paul wrote:
>> On Wed, Oct 10, 2018 at 10:15:58AM -0700, Chandan Uddaraju wrote:
>>> Add the needed displayPort files to enable DP driver
>>> on msm target.
>>> 
>>> "dp_display" module is the main module that calls into
>>> other sub-modules. "dp_drm" file represents the interface
>>> between DRM framework and DP driver.
>>> 
>> 
> 
> Hello Sean,
> I have responded to all of your comments and queries. I have specified
> the comments addressed
> in V2 patch series and what I have missed that will be fixed in V3.
> 
> 
>> Hi Chandan,
>> A few themes which I've pointed out below, but want to call out at the 
>> top so
>> it's obvious.
>> 
>> - Please remove all superfluous NULL checks at the beginning of 
>> functions.
>>   Included in this is reflowing initialization of variables and 
>> checking that
>>   return types still make sense (ie: if a function's only error path 
>> is the NULL
>>   check, make it void).
>> - Please remove all of the new callbacks and just call functions 
>> directly. This
>>   should also get rid of the _get/_put functions that allocate/set 
>> them up
>> - Please consolidate state structs into one struct with a few 
>> substructs,
>>   there's too much state right now.
>> - Please #define hardcoded values
>> - Instead of sprinkling wmb() everywhere, use readl/writel instead of 
>> *_relaxed
>> - There are a bunch of races that I found, please audit the code and 
>> remove
>>   races with locks as necessary
>> - I tried to catch as much dead code as possible, please audit the 
>> rest for
>>   unused structs/variables/functions/etc
>> - Use drm dp helper structs for link parameter storage
>> 
>> 
>>> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
>>> ---
>>>  drivers/gpu/drm/msm/Kconfig                 |    9 +
>>>  drivers/gpu/drm/msm/Makefile                |   15 +-
>>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c |  206 ++++
>>>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h |   44 +
>>>  drivers/gpu/drm/msm/dp/dp_aux.c             |  570 ++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_aux.h             |   44 +
>>>  drivers/gpu/drm/msm/dp/dp_catalog.c         | 1188 
>>> ++++++++++++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_catalog.h         |  144 +++
>>>  drivers/gpu/drm/msm/dp/dp_ctrl.c            | 1475 
>>> +++++++++++++++++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_ctrl.h            |   50 +
>>>  drivers/gpu/drm/msm/dp/dp_debug.c           |  507 +++++++++
>>>  drivers/gpu/drm/msm/dp/dp_debug.h           |   81 ++
>>>  drivers/gpu/drm/msm/dp/dp_display.c         |  977 +++++++++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_display.h         |   55 +
>>>  drivers/gpu/drm/msm/dp/dp_drm.c             |  542 ++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_drm.h             |   52 +
>>>  drivers/gpu/drm/msm/dp/dp_extcon.c          |  400 +++++++
>>>  drivers/gpu/drm/msm/dp/dp_extcon.h          |  111 ++
>>>  drivers/gpu/drm/msm/dp/dp_link.c            | 1549 
>>> +++++++++++++++++++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_link.h            |  184 ++++
>>>  drivers/gpu/drm/msm/dp/dp_panel.c           |  624 +++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_panel.h           |  121 +++
>>>  drivers/gpu/drm/msm/dp/dp_parser.c          |  679 ++++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_parser.h          |  205 ++++
>>>  drivers/gpu/drm/msm/dp/dp_power.c           |  599 +++++++++++
>>>  drivers/gpu/drm/msm/dp/dp_power.h           |   57 +
>>>  drivers/gpu/drm/msm/dp/dp_reg.h             |  357 ++++++
>>>  drivers/gpu/drm/msm/msm_drv.c               |    2 +
>>>  drivers/gpu/drm/msm/msm_drv.h               |   22 +
>>>  include/drm/drm_dp_helper.h                 |   19 +
>>>  30 files changed, 10887 insertions(+), 1 deletion(-)
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>>>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
>>> 

>> 
>>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.c 
>>> b/drivers/gpu/drm/msm/dp/dp_catalog.c
>>> new file mode 100644
>>> index 0000000..5818612
>>> --- /dev/null
>>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.c
>>> @@ -0,0 +1,1188 @@
>>> +/*
>>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>>> reserved.
>>> + *
>>> + * This program is free software; you can redistribute it and/or 
>>> modify
>>> + * it under the terms of the GNU General Public License version 2 
>>> and
>>> + * only version 2 as published by the Free Software Foundation.
>>> + *
>>> + * This program is distributed in the hope that it will be useful,
>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>>> + * GNU General Public License for more details.
>>> + *
>>> + */
>>> +
>>> +#define pr_fmt(fmt)	"[drm-dp] %s: " fmt, __func__
>>> +
>>> +#include <linux/delay.h>
>>> +#include <drm/drm_dp_helper.h>
>>> +
>>> +#include "dp_catalog.h"
>>> +#include "dp_reg.h"
>>> +
>>> +#define DP_GET_MSB(x)	(x >> 8)
>>> +#define DP_GET_LSB(x)	(x & 0xff)
>> 
>> These aren't used anywhere
>> 
> Fixed in V2.
> 
>>> +
>>> +#define dp_read(offset) readl_relaxed((offset))
>>> +#define dp_write(offset, data) writel_relaxed((data), (offset))
>> 
>> These macros aren't useful. I think you'd be much better having a 
>> read_/write_
>> for the different io types, ie:
>> 
>> static inline u32 dp_read_audio(struct dp_catalog *catalog, u32 
>> offset)
>> {
>>         return readl_relaxed(catalog->io->dp_link.base + offset);
>> }
>> 
>> Then you can remove a ton of boilerplate code below getting base;
> 
> Fixed in V2.
> 
>> 
>>> +
>>> +#define dp_catalog_get_priv(x) { \
>> 
>> static inline struct dp_catalog_private *dp_catalog_get_priv(...)
>> {
>>         ...
>> }
>> 
> For inline, we have to use 3 different functions (one each for aux,
> ctrl and panel).
> Looking at "type-checking" w.r.t macro, container_of will through an
> error if its not valid pointer.
> Please let me know if you still want to change this macro to inline 
> func.
> 


/snip


>>> diff --git a/drivers/gpu/drm/msm/dp/dp_catalog.h 
>>> b/drivers/gpu/drm/msm/dp/dp_catalog.h
>>> new file mode 100644
>>> index 0000000..58951df
>>> --- /dev/null
>>> +++ b/drivers/gpu/drm/msm/dp/dp_catalog.h
>>> @@ -0,0 +1,144 @@
>>> +/*
>>> + * Copyright (c) 2017-2018, The Linux Foundation. All rights 
>>> reserved.
>>> + *
>>> + * This program is free software; you can redistribute it and/or 
>>> modify
>>> + * it under the terms of the GNU General Public License version 2 
>>> and
>>> + * only version 2 as published by the Free Software Foundation.
>>> + *
>>> + * This program is distributed in the hope that it will be useful,
>>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>>> + * GNU General Public License for more details.
>>> + *
>>> + */
>>> +
>>> +#ifndef _DP_CATALOG_H_
>>> +#define _DP_CATALOG_H_
>>> +
>>> +#include "dp_parser.h"
>>> +
>>> +/* interrupts */
>>> +#define DP_INTR_HPD		BIT(0)
>>> +#define DP_INTR_AUX_I2C_DONE	BIT(3)
>>> +#define DP_INTR_WRONG_ADDR	BIT(6)
>>> +#define DP_INTR_TIMEOUT		BIT(9)
>>> +#define DP_INTR_NACK_DEFER	BIT(12)
>>> +#define DP_INTR_WRONG_DATA_CNT	BIT(15)
>>> +#define DP_INTR_I2C_NACK	BIT(18)
>>> +#define DP_INTR_I2C_DEFER	BIT(21)
>>> +#define DP_INTR_PLL_UNLOCKED	BIT(24)
>>> +#define DP_INTR_AUX_ERROR	BIT(27)
>>> +
>>> +#define DP_INTR_READY_FOR_VIDEO		BIT(0)
>>> +#define DP_INTR_IDLE_PATTERN_SENT	BIT(3)
>>> +#define DP_INTR_FRAME_END		BIT(6)
>>> +#define DP_INTR_CRC_UPDATED		BIT(9)
>>> +
>>> +struct dp_catalog_aux {
>>> +	u32 data;
>>> +	u32 isr;
>>> +
>>> +	u32 (*read_data)(struct dp_catalog_aux *aux);
>>> +	int (*write_data)(struct dp_catalog_aux *aux);
>>> +	int (*write_trans)(struct dp_catalog_aux *aux);
>>> +	int (*clear_trans)(struct dp_catalog_aux *aux, bool read);
>>> +	void (*reset)(struct dp_catalog_aux *aux);
>>> +	void (*enable)(struct dp_catalog_aux *aux, bool enable);
>>> +	void (*update_aux_cfg)(struct dp_catalog_aux *aux,
>>> +		struct dp_aux_cfg *cfg, enum dp_phy_aux_config_type type);
>>> +	void (*setup)(struct dp_catalog_aux *aux,
>>> +			struct dp_aux_cfg *aux_cfg);
>>> +	void (*get_irq)(struct dp_catalog_aux *aux, bool cmd_busy);
>>> +};
>>> +
>>> +struct dp_catalog_ctrl {
>>> +	u32 dp_tu;
>>> +	u32 valid_boundary;
>>> +	u32 valid_boundary2;
>>> +	u32 isr;
>>> +
>>> +	void (*state_ctrl)(struct dp_catalog_ctrl *ctrl, u32 state);
>>> +	void (*config_ctrl)(struct dp_catalog_ctrl *ctrl, u32 config);
>>> +	void (*lane_mapping)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*mainlink_ctrl)(struct dp_catalog_ctrl *ctrl, bool enable);
>>> +	void (*config_misc)(struct dp_catalog_ctrl *ctrl, u32 cc, u32 tb);
>>> +	void (*config_msa)(struct dp_catalog_ctrl *ctrl, u32 rate,
>>> +				u32 stream_rate_khz, bool fixed_nvid);
>>> +	void (*set_pattern)(struct dp_catalog_ctrl *ctrl, u32 pattern);
>>> +	void (*reset)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*usb_reset)(struct dp_catalog_ctrl *ctrl, bool flip);
>>> +	bool (*mainlink_ready)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*enable_irq)(struct dp_catalog_ctrl *ctrl, bool enable);
>>> +	void (*hpd_config)(struct dp_catalog_ctrl *ctrl, bool enable);
>>> +	void (*phy_reset)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*phy_lane_cfg)(struct dp_catalog_ctrl *ctrl, bool flipped,
>>> +				u8 lane_cnt);
>>> +	void (*update_vx_px)(struct dp_catalog_ctrl *ctrl, u8 v_level,
>>> +				u8 p_level);
>>> +	void (*get_interrupt)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*update_transfer_unit)(struct dp_catalog_ctrl *ctrl);
>>> +	void (*send_phy_pattern)(struct dp_catalog_ctrl *ctrl,
>>> +			u32 pattern);
>>> +	u32 (*read_phy_pattern)(struct dp_catalog_ctrl *ctrl);
>>> +};
>>> +
>>> +enum dp_catalog_audio_sdp_type {
>>> +	DP_AUDIO_SDP_STREAM,
>>> +	DP_AUDIO_SDP_TIMESTAMP,
>>> +	DP_AUDIO_SDP_INFOFRAME,
>>> +	DP_AUDIO_SDP_COPYMANAGEMENT,
>>> +	DP_AUDIO_SDP_ISRC,
>>> +	DP_AUDIO_SDP_MAX,
>>> +};
>>> +
>>> +enum dp_catalog_audio_header_type {
>>> +	DP_AUDIO_SDP_HEADER_1,
>>> +	DP_AUDIO_SDP_HEADER_2,
>>> +	DP_AUDIO_SDP_HEADER_3,
>>> +	DP_AUDIO_SDP_HEADER_MAX,
>>> +};
>>> +
>>> +struct dp_catalog_audio {
>>> +	enum dp_catalog_audio_sdp_type sdp_type;
>>> +	enum dp_catalog_audio_header_type sdp_header;
>>> +	u32 data;
>>> +
>>> +	void (*init)(struct dp_catalog_audio *audio);
>>> +	void (*enable)(struct dp_catalog_audio *audio);
>>> +	void (*config_acr)(struct dp_catalog_audio *audio);
>>> +	void (*config_sdp)(struct dp_catalog_audio *audio);
>>> +	void (*set_header)(struct dp_catalog_audio *audio);
>>> +	void (*get_header)(struct dp_catalog_audio *audio);
>>> +	void (*safe_to_exit_level)(struct dp_catalog_audio *audio);
>> 
>> None of these are called? So get rid of this entire structure, the 
>> functions
>> that aren't called, and the audio enums above.
>> 
> Removed all the Audio related APIs in V2.
> 
>>> +};
>>> +
>>> +struct dp_catalog_panel {
>>> +	u32 total;
>>> +	u32 sync_start;
>>> +	u32 width_blanking;
>>> +	u32 dp_active;
>>> +
>>> +	/* TPG */
>>> +	u32 hsync_period;
>>> +	u32 vsync_period;
>>> +	u32 display_v_start;
>>> +	u32 display_v_end;
>>> +	u32 v_sync_width;
>>> +	u32 hsync_ctl;
>>> +	u32 display_hctl;
>> 
>> All of this information is already available from drm core, so it can 
>> go.
> 
> Will address this in V3.
> 


/snip

>>> +
>>> +static void dp_ctrl_setup_tr_unit(struct dp_ctrl_private *ctrl)
>>> +{
>>> +	u32 dp_tu = 0x0;
>>> +	u32 valid_boundary = 0x0;
>>> +	u32 valid_boundary2 = 0x0;
>>> +	struct dp_vc_tu_mapping_table tu_calc_table;
>>> +
>>> +	dp_ctrl_calc_tu_parameters(ctrl, &tu_calc_table);
>>> +
>>> +	dp_tu |= tu_calc_table.tu_size_minus1;
>>> +	valid_boundary |= tu_calc_table.valid_boundary_link;
>>> +	valid_boundary |= (tu_calc_table.delay_start_link << 16);
>>> +
>>> +	valid_boundary2 |= (tu_calc_table.valid_lower_boundary_link << 1);
>>> +	valid_boundary2 |= (tu_calc_table.upper_boundary_count << 16);
>>> +	valid_boundary2 |= (tu_calc_table.lower_boundary_count << 20);
>>> +
>>> +	if (tu_calc_table.boundary_moderation_en)
>>> +		valid_boundary2 |= BIT(0);
>>> +
>>> +	pr_debug("dp_tu=0x%x, valid_boundary=0x%x, valid_boundary2=0x%x\n",
>>> +			dp_tu, valid_boundary, valid_boundary2);
>>> +
>>> +	ctrl->catalog->dp_tu = dp_tu;
>>> +	ctrl->catalog->valid_boundary = valid_boundary;
>>> +	ctrl->catalog->valid_boundary2 = valid_boundary2;
>>> +
>>> +	ctrl->catalog->update_transfer_unit(ctrl->catalog);
>> 
>> Again here, if you just call the function directly, you can avoid the 
>> callback.
>> If you add function arguments, you can avoid having to store
>> dp_tu/valid_boundary/
>> valid_boundary2 entirely.
>> 
> Will remove the dp_tu/valid_boundary/valid_boundary2 in V3.
>>> +}

After removing all the function ptrs in each structure and removing 
dp_tu/valid_boundary/valid_boundary2 for dp_catalog_ctrl structure,
we can get rid of dp_catalog_ctrl structure. Similarly, even the other 
aux and panel structures have minimal data that can be removed.
If we remove these structures and get read of dp_catalog structure, we 
have to find a different way to access dp_catalog_private structure
present in dp_catalog.c file. Having "static dp_catalog_private 
*dp_catalog_private_ptr" is acceptable in upstream? Please share if you 
have
any better suggestion?

>>> +
>>> +static int dp_ctrl_wait4video_ready(struct dp_ctrl_private *ctrl)
>>> +{
>>> +	int ret = 0;
>>> +
>>> +	ret = wait_for_completion_timeout(&ctrl->video_comp, HZ / 2);
>> 
>> Break out the timeout into a #define
> 
> Fixed in V2.
> 
>> 
>>> +	if (ret <= 0) {
>>> +		pr_err("Link Train timedout\n");
>>> +		ret = -EINVAL;
>>> +	}
>>> +
>>> +	return ret;
>> 
>> You're not checking the return value at the callsite.
>> 
> Fixed in V2.
> 
>>> +}

/snip


>>> +
>>> +static u32 dp_panel_get_supported_bpp(struct dp_panel *dp_panel,
>>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>>> +{
>>> +	struct drm_dp_link *link_info;
>>> +	const u32 max_supported_bpp = 30, min_supported_bpp = 18;
>>> +	u32 bpp = 0, data_rate_khz = 0;
>>> +
>>> +	bpp = min_t(u32, mode_edid_bpp, max_supported_bpp);
>>> +
>>> +	link_info = &dp_panel->link_info;
>>> +	data_rate_khz = link_info->num_lanes * link_info->rate * 8;
>>> +
>>> +	while (bpp > min_supported_bpp) {
>>> +		if (mode_pclk_khz * bpp <= data_rate_khz)
>>> +			break;
>>> +		bpp -= 6;
>> 
>> Watch out for underflow here.
>> 
> Will add check in V3 patch series.
> 

Since min_supported_bpp is 18, bpp can never go below 12. I don't think 
we need to check underflow here.


>>> +	}
>>> +
>>> +	return bpp;
>>> +}
>>> +
>>> +static u32 dp_panel_get_mode_bpp(struct dp_panel *dp_panel,
>>> +		u32 mode_edid_bpp, u32 mode_pclk_khz)
>>> +{
>>> +	struct dp_panel_private *panel;
>>> +	u32 bpp = mode_edid_bpp;
>>> +
>>> +	if (!dp_panel || !mode_edid_bpp || !mode_pclk_khz) {
>>> +		pr_err("invalid input\n");
>>> +		return 0;
>>> +	}
>>> +
>>> +	panel = container_of(dp_panel, struct dp_panel_private, dp_panel);
>>> +
>>> +	if (dp_panel->video_test)
>>> +		bpp = dp_link_bit_depth_to_bpp(
>>> +				panel->link->test_video.test_bit_depth);
>>> +	else
>>> +		bpp = dp_panel_get_supported_bpp(dp_panel, mode_edid_bpp,
>>> +				mode_pclk_khz);
>>> +
>>> +	return bpp;
>>> +}
>>> +
>>> +static void dp_panel_set_test_mode(struct dp_panel_private *panel,
>>> +		struct dp_display_mode *mode)
>>> +{
>>> +	struct dp_panel_info *pinfo = NULL;
>> 

/snip

>>> +
>>> +struct dp_display_mode {
>>> +	struct dp_panel_info timing;
>>> +	u32 capabilities;
>>> +};
>>> +
>>> +struct dp_panel_in {
>>> +	struct device *dev;
>>> +	struct dp_aux *aux;
>>> +	struct dp_link *link;
>>> +	struct dp_catalog_panel *catalog;
>>> +};
>>> +
>>> +struct dp_panel {
>>> +	/* dpcd raw data */
>>> +	u8 dpcd[DP_RECEIVER_CAP_SIZE + 1];
>> 
>> Why + 1?
>> 
> Will follow up on this in V3.

DP_RECIEVER_CAP_SIZE is 0xf. We need 16 bytes for dpcd read.



> 
>>> +	u8 ds_ports[DP_MAX_DOWNSTREAM_PORTS];
>>> +
>>> +	struct drm_dp_link link_info;
>>> +	struct edid *edid;
>>> +	struct drm_connector *connector;
>>> +	struct dp_panel_info pinfo;
>>> +	bool video_test;
>>> +
>>> +	u32 vic;
>>> +	u32 max_pclk_khz;
>>> +
>>> +	u32 max_bw_code;
>>> +	int (*init_info)(struct dp_panel *dp_panel);
>>> +	int (*deinit)(struct dp_panel *dp_panel);
>>> +	int (*timing_cfg)(struct dp_panel *dp_panel);
>>> +	int (*read_sink_caps)(struct dp_panel *dp_panel,
>>> +		struct drm_connector *connector);
>>> +	u32 (*get_min_req_link_rate)(struct dp_panel *dp_panel);
>> 
>> This function isn't called anywhere
>> 
> Removed in V2.
> 

/Snip

> 
>> 
>>> +
>>> +static int dp_power_pinctrl_set(struct dp_power_private *power, bool 
>>> active)
>>> +{
>>> +	int rc = -EFAULT;
>>> +	struct pinctrl_state *pin_state;
>>> +	struct dp_parser *parser;
>>> +
>>> +	parser = power->parser;
>>> +
>>> +	if (IS_ERR_OR_NULL(parser->pinctrl.pin))
>>> +		return PTR_ERR(parser->pinctrl.pin);
>>> +
>>> +	pin_state = active ? parser->pinctrl.state_active
>>> +				: parser->pinctrl.state_suspend;
>>> +	if (!IS_ERR_OR_NULL(pin_state)) {
>> 
>> How is this not possible? You check these on initialization.
>> 
> Will remove this in V3.

GPIO/pin_ctrl entries are optional entries in dtsi for DP since we don't 
need them for specific target. During init, we allow
the probe to go through even though we initialize pin_state or not. So, 
we have to check this again here.


>>> +		rc = pinctrl_select_state(parser->pinctrl.pin,
>>> +				pin_state);
>> 
>> Combine on 1 line
>> 
> Fixed in V2.
> 
>>> +		if (rc)
>>> +			pr_err("can not set %s pins\n",
>>> +			       active ? "dp_active"
>>> +			       : "dp_sleep");
>> 
>> 
>> Combine on one line. Also return immediately if this is the case.
>> 
> Fixed in V2.
> 
>>> +	} else {
>>> +		pr_err("invalid '%s' pinstate\n",
>>> +		       active ? "dp_active"
>>> +		       : "dp_sleep");
>>> +	}
>>> +
>>> +	return rc;
>>> +}
>>> +
>>> +static int dp_power_clk_init(struct dp_power_private *power, bool 
>>> enable)
>> 
>> Split this into init/deinit, the paths don't share code.
>> 
> Fixed in V2.
> 


/snip



>>>  #define DP_TEST_SINK			    0x270
>>>  # define DP_TEST_SINK_START		    (1 << 0)
>>> +#define DP_TEST_AUDIO_MODE		    0x271
>>> +#define DP_TEST_AUDIO_PATTERN_TYPE	    0x272
>>> +#define DP_TEST_AUDIO_PERIOD_CH1	    0x273
>>> +#define DP_TEST_AUDIO_PERIOD_CH2	    0x274
>>> +#define DP_TEST_AUDIO_PERIOD_CH3	    0x275
>>> +#define DP_TEST_AUDIO_PERIOD_CH4	    0x276
>>> +#define DP_TEST_AUDIO_PERIOD_CH5	    0x277
>>> +#define DP_TEST_AUDIO_PERIOD_CH6	    0x278
>>> +#define DP_TEST_AUDIO_PERIOD_CH7	    0x279
>>> +#define DP_TEST_AUDIO_PERIOD_CH8	    0x27A
>>> 
>>>  #define DP_FEC_STATUS			    0x280    /* 1.4 */
>>>  # define DP_FEC_DECODE_EN_DETECTED	    (1 << 0)
>>> --
>>> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora 
>>> Forum,
>>> a Linux Foundation Collaborative Project
>>> 
>>> _______________________________________________
>>> Freedreno mailing list
>>> Freedreno@lists.freedesktop.org
>>> https://lists.freedesktop.org/mailman/listinfo/freedreno
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

[DPU PATCH 3/3] drm/msm/dp: add support for DP PLL driver

[Chandan Uddaraju]

Add the needed DP PLL specific files to support
display port interface on msm targets.

The DP driver calls the DP PLL driver registration.
The DP driver sets the link and pixel clock sources.

Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
---
 drivers/gpu/drm/msm/Kconfig                   |  16 +
 drivers/gpu/drm/msm/Makefile                  |   6 +
 drivers/gpu/drm/msm/dp/dp_ctrl.c              |   1 +
 drivers/gpu/drm/msm/dp/dp_display.c           |  50 +++
 drivers/gpu/drm/msm/dp/dp_display.h           |   3 +
 drivers/gpu/drm/msm/dp/dp_parser.h            |   3 +
 drivers/gpu/drm/msm/dp/dp_power.c             |  77 +++-
 drivers/gpu/drm/msm/dp/dp_power.h             |   2 +
 drivers/gpu/drm/msm/dp/pll/dp_pll.c           | 153 ++++++++
 drivers/gpu/drm/msm/dp/pll/dp_pll.h           |  64 ++++
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c      | 401 +++++++++++++++++++
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h      |  94 +++++
 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c | 531 ++++++++++++++++++++++++++
 13 files changed, 1389 insertions(+), 12 deletions(-)
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.c
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.h
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
 create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c

diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
index c363f24..1e0b9158 100644
--- a/drivers/gpu/drm/msm/Kconfig
+++ b/drivers/gpu/drm/msm/Kconfig
@@ -58,6 +58,22 @@ config DRM_MSM_DP
 	  driver. DP external display support is enabled
 	  through this config option. It can be primary or
 	  secondary display on device.
+
+config DRM_MSM_DP_PLL
+	bool "Enable DP PLL driver in MSM DRM"
+	depends on DRM_MSM_DP && COMMON_CLK
+	default y
+	help
+	  Choose this option to enable DP PLL driver which provides DP
+	  source clocks under common clock framework.
+
+config DRM_MSM_DP_10NM_PLL
+	bool "Enable DP 10nm PLL driver in MSM DRM (used by SDM845)"
+	depends on DRM_MSM_DP
+	default y
+	help
+	  Choose this option if DP PLL on SDM845 is used on the platform.
+
 config DRM_MSM_DSI
 	bool "Enable DSI support in MSM DRM driver"
 	depends on DRM_MSM
diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
index 765a8d8..8d18353 100644
--- a/drivers/gpu/drm/msm/Makefile
+++ b/drivers/gpu/drm/msm/Makefile
@@ -137,4 +137,10 @@ msm-$(CONFIG_DRM_MSM_DSI_14NM_PHY) += dsi/pll/dsi_pll_14nm.o
 msm-$(CONFIG_DRM_MSM_DSI_10NM_PHY) += dsi/pll/dsi_pll_10nm.o
 endif
 
+ifeq ($(CONFIG_DRM_MSM_DP_PLL),y)
+msm-y += dp/pll/dp_pll.o
+msm-y += dp/pll/dp_pll_10nm.o
+msm-y += dp/pll/dp_pll_10nm_util.o
+endif
+
 obj-$(CONFIG_DRM_MSM)	+= msm.o
diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
index 08a52f5..e23beee 100644
--- a/drivers/gpu/drm/msm/dp/dp_ctrl.c
+++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
@@ -1051,6 +1051,7 @@ static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
 {
 	int ret = 0;
 
+	ctrl->power->set_link_clk_parent(ctrl->power);
 	ctrl->power->set_pixel_clk_parent(ctrl->power);
 
 	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
index 8c98399..2bf6635 100644
--- a/drivers/gpu/drm/msm/dp/dp_display.c
+++ b/drivers/gpu/drm/msm/dp/dp_display.c
@@ -72,6 +72,48 @@ struct dp_display_private {
 	{}
 };
 
+static int dp_get_pll(struct dp_display_private *dp_priv)
+{
+	struct platform_device *pdev = NULL;
+	struct platform_device *pll_pdev;
+	struct device_node *pll_node;
+	struct dp_parser *dp_parser = NULL;
+
+	if (!dp_priv) {
+		pr_err("Invalid Arguments\n");
+		return -EINVAL;
+	}
+
+	pdev = dp_priv->pdev;
+	dp_parser = dp_priv->parser;
+
+	if (!dp_parser) {
+		pr_err("Parser not initialized.\n");
+		return -EINVAL;
+	}
+
+	pll_node = of_parse_phandle(pdev->dev.of_node, "pll-node", 0);
+	if (!pll_node) {
+		dev_err(&pdev->dev, "cannot find pll device\n");
+		return -ENXIO;
+	}
+
+	pll_pdev = of_find_device_by_node(pll_node);
+	if (pll_pdev)
+		dp_parser->pll = platform_get_drvdata(pll_pdev);
+
+	of_node_put(pll_node);
+
+	if (!pll_pdev || !dp_parser->pll) {
+		dev_err(&pdev->dev, "%s: pll driver is not ready\n", __func__);
+		return -EPROBE_DEFER;
+	}
+
+	dp_parser->pll_dev = get_device(&pll_pdev->dev);
+
+	return 0;
+}
+
 static irqreturn_t dp_display_irq(int irq, void *dev_id)
 {
 	struct dp_display_private *dp = dev_id;
@@ -125,6 +167,12 @@ static int dp_display_bind(struct device *dev, struct device *master,
 		goto end;
 	}
 
+	rc = dp_get_pll(dp);
+	if (rc) {
+		pr_err(" DP get PLL instance failed\n");
+		goto end;
+	}
+
 	rc = dp->aux->drm_aux_register(dp->aux);
 	if (rc) {
 		pr_err("DRM DP AUX register failed\n");
@@ -921,6 +969,7 @@ int __init msm_dp_register(void)
 {
 	int ret;
 
+	msm_dp_pll_driver_register();
 	ret = platform_driver_register(&dp_display_driver);
 	if (ret) {
 		pr_err("driver register failed");
@@ -932,6 +981,7 @@ int __init msm_dp_register(void)
 
 void __exit msm_dp_unregister(void)
 {
+	msm_dp_pll_driver_unregister();
 	platform_driver_unregister(&dp_display_driver);
 }
 
diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
index ca5eae5..9cd6a6b 100644
--- a/drivers/gpu/drm/msm/dp/dp_display.h
+++ b/drivers/gpu/drm/msm/dp/dp_display.h
@@ -52,4 +52,7 @@ struct msm_dp {
 
 int dp_display_get_num_of_displays(void);
 int dp_display_get_displays(void **displays, int count);
+void __init msm_dp_pll_driver_register(void);
+void __exit msm_dp_pll_driver_unregister(void);
+
 #endif /* _DP_DISPLAY_H_ */
diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h b/drivers/gpu/drm/msm/dp/dp_parser.h
index b39ea02..372997e 100644
--- a/drivers/gpu/drm/msm/dp/dp_parser.h
+++ b/drivers/gpu/drm/msm/dp/dp_parser.h
@@ -16,6 +16,7 @@
 #define _DP_PARSER_H_
 
 #include "dpu_io_util.h"
+#include "pll/dp_pll.h"
 
 #define DP_LABEL "MDSS DP DISPLAY"
 #define AUX_CFG_LEN	10
@@ -175,6 +176,8 @@ struct dp_parser {
 	struct dp_pinctrl pinctrl;
 	struct dp_io io;
 	struct dp_display_data disp_data;
+	struct msm_dp_pll *pll;
+	struct device *pll_dev;
 
 	u8 l_map[4];
 	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
index 1d58480..3a1679c 100644
--- a/drivers/gpu/drm/msm/dp/dp_power.c
+++ b/drivers/gpu/drm/msm/dp/dp_power.c
@@ -23,7 +23,9 @@ struct dp_power_private {
 	struct dp_parser *parser;
 	struct platform_device *pdev;
 	struct clk *pixel_clk_rcg;
-	struct clk *pixel_parent;
+	struct clk *link_clk_src;
+	struct clk *pixel_provider;
+	struct clk *link_provider;
 
 	struct dp_power dp_power;
 
@@ -154,6 +156,16 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
 		goto exit;
 	}
 
+	if (power->parser->pll && power->parser->pll->get_provider) {
+		rc = power->parser->pll->get_provider(power->parser->pll,
+				&power->link_provider, &power->pixel_provider);
+		if (rc) {
+			pr_info("%s: can't get provider from pll, don't set parent\n",
+				__func__);
+			return 0;
+		}
+	}
+
 	if (enable) {
 		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
 		if (rc) {
@@ -173,17 +185,10 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
 		if (IS_ERR(power->pixel_clk_rcg)) {
 			pr_debug("Unable to get DP pixel clk RCG\n");
 			power->pixel_clk_rcg = NULL;
-		}
-
-		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
-		if (IS_ERR(power->pixel_parent)) {
-			pr_debug("Unable to get DP pixel RCG parent\n");
-			power->pixel_parent = NULL;
+			rc = -ENODEV;
+			goto ctrl_get_error;
 		}
 	} else {
-		if (power->pixel_parent)
-			devm_clk_put(dev, power->pixel_parent);
-
 		if (power->pixel_clk_rcg)
 			devm_clk_put(dev, power->pixel_clk_rcg);
 
@@ -459,6 +464,49 @@ static void dp_power_client_deinit(struct dp_power *dp_power)
 
 }
 
+static int dp_power_set_link_clk_parent(struct dp_power *dp_power)
+{
+	int rc = 0;
+	struct dp_power_private *power;
+	u32 num;
+	struct dss_clk *cfg;
+	char *name = "ctrl_link_clk";
+
+	if (!dp_power) {
+		pr_err("invalid power data\n");
+		rc = -EINVAL;
+		goto exit;
+	}
+
+	power = container_of(dp_power, struct dp_power_private, dp_power);
+
+	num = power->parser->mp[DP_CTRL_PM].num_clk;
+	cfg = power->parser->mp[DP_CTRL_PM].clk_config;
+
+	while (num && strcmp(cfg->clk_name, name)) {
+		num--;
+		cfg++;
+	}
+
+	if (num && power->link_provider) {
+		power->link_clk_src = clk_get_parent(cfg->clk);
+			if (power->link_clk_src) {
+				clk_set_parent(power->link_clk_src, power->link_provider);
+				pr_debug("%s: is the parent of clk=%s\n",
+						__clk_get_name(power->link_provider),
+						__clk_get_name(power->link_clk_src));
+			} else {
+				pr_err("couldn't get parent for clk=%s\n", name);
+				rc = -EINVAL;
+			}
+	} else {
+		pr_err("%s clock could not be set parent\n", name);
+		rc = -EINVAL;
+	}
+exit:
+	return rc;
+}
+
 static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
 {
 	int rc = 0;
@@ -472,8 +520,12 @@ static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
 
 	power = container_of(dp_power, struct dp_power_private, dp_power);
 
-	if (power->pixel_clk_rcg && power->pixel_parent)
-		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
+	if (power->pixel_clk_rcg && power->pixel_provider) {
+		clk_set_parent(power->pixel_clk_rcg, power->pixel_provider);
+		pr_debug("%s: is the parent of clk=%s\n",
+					__clk_get_name(power->pixel_provider),
+					__clk_get_name(power->pixel_clk_rcg));
+	}
 exit:
 	return rc;
 }
@@ -577,6 +629,7 @@ struct dp_power *dp_power_get(struct dp_parser *parser)
 	dp_power->init = dp_power_init;
 	dp_power->deinit = dp_power_deinit;
 	dp_power->clk_enable = dp_power_clk_enable;
+	dp_power->set_link_clk_parent = dp_power_set_link_clk_parent;
 	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
 	dp_power->power_client_init = dp_power_client_init;
 	dp_power->power_client_deinit = dp_power_client_deinit;
diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
index d1adaaf..5effd32 100644
--- a/drivers/gpu/drm/msm/dp/dp_power.h
+++ b/drivers/gpu/drm/msm/dp/dp_power.h
@@ -24,6 +24,7 @@
  * @init: initializes the regulators/core clocks/GPIOs/pinctrl
  * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
  * @clk_enable: enable/disable the DP clocks
+ * @set_link_clk_parent: set the parent of DP link clock
  * @set_pixel_clk_parent: set the parent of DP pixel clock
  */
 struct dp_power {
@@ -31,6 +32,7 @@ struct dp_power {
 	int (*deinit)(struct dp_power *power);
 	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
 				bool enable);
+	int (*set_link_clk_parent)(struct dp_power *power);
 	int (*set_pixel_clk_parent)(struct dp_power *power);
 	int (*power_client_init)(struct dp_power *power);
 	void (*power_client_deinit)(struct dp_power *power);
diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.c b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
new file mode 100644
index 0000000..a8612b5
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
@@ -0,0 +1,153 @@
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include "dp_pll.h"
+
+int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
+					struct msm_dp_pll *pll)
+{
+	u32 i = 0, rc = 0;
+	struct dss_module_power *mp = &pll->mp;
+	const char *clock_name;
+	u32 clock_rate;
+
+	mp->num_clk = of_property_count_strings(pdev->dev.of_node,
+							"clock-names");
+	if (mp->num_clk <= 0) {
+		pr_err("clocks are not defined\n");
+		goto clk_err;
+	}
+
+	mp->clk_config = devm_kzalloc(&pdev->dev,
+			sizeof(struct dss_clk) * mp->num_clk, GFP_KERNEL);
+	if (!mp->clk_config) {
+		rc = -ENOMEM;
+		mp->num_clk = 0;
+		goto clk_err;
+	}
+
+	for (i = 0; i < mp->num_clk; i++) {
+		of_property_read_string_index(pdev->dev.of_node, "clock-names",
+							i, &clock_name);
+		strlcpy(mp->clk_config[i].clk_name, clock_name,
+				sizeof(mp->clk_config[i].clk_name));
+
+		of_property_read_u32_index(pdev->dev.of_node, "clock-rate",
+							i, &clock_rate);
+		mp->clk_config[i].rate = clock_rate;
+
+		if (!clock_rate)
+			mp->clk_config[i].type = DSS_CLK_AHB;
+		else
+			mp->clk_config[i].type = DSS_CLK_PCLK;
+	}
+
+clk_err:
+	return rc;
+}
+
+struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,
+			enum msm_dp_pll_type type, int id)
+{
+	struct device *dev = &pdev->dev;
+	struct msm_dp_pll *pll;
+
+	switch (type) {
+	case MSM_DP_PLL_10NM:
+		pll = msm_dp_pll_10nm_init(pdev, id);
+		break;
+	default:
+		pll = ERR_PTR(-ENXIO);
+		break;
+	}
+
+	if (IS_ERR(pll)) {
+		dev_err(dev, "%s: failed to init DP PLL\n", __func__);
+		return pll;
+	}
+
+	pll->type = type;
+
+	DBG("DP:%d PLL registered", id);
+
+	return pll;
+}
+
+static const struct of_device_id dp_pll_dt_match[] = {
+#ifdef CONFIG_DRM_MSM_DP_10NM_PLL
+	{ .compatible = "qcom,dp-pll-10nm" },
+#endif
+	{}
+};
+
+static int dp_pll_driver_probe(struct platform_device *pdev)
+{
+	struct msm_dp_pll *pll;
+	struct device *dev = &pdev->dev;
+	const struct of_device_id *match;
+	enum msm_dp_pll_type type;
+
+	match = of_match_node(dp_pll_dt_match, dev->of_node);
+	if (!match)
+		return -ENODEV;
+
+	if (!strcmp(match->compatible, "qcom,dp-pll-10nm"))
+		type = MSM_DP_PLL_10NM;
+	else
+		type = MSM_DP_PLL_MAX;
+
+	pll = msm_dp_pll_init(pdev, type, 0);
+	if (IS_ERR_OR_NULL(pll)) {
+		dev_info(dev,
+			"%s: pll init failed: %ld, need separate pll clk driver\n",
+			__func__, PTR_ERR(pll));
+		return -ENODEV;
+	}
+
+	platform_set_drvdata(pdev, pll);
+
+	return 0;
+}
+
+static int dp_pll_driver_remove(struct platform_device *pdev)
+{
+	struct msm_dp_pll *pll = platform_get_drvdata(pdev);
+
+	if (pll) {
+		//msm_dsi_pll_destroy(pll);
+		pll = NULL;
+	}
+
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+static struct platform_driver dp_pll_platform_driver = {
+	.probe      = dp_pll_driver_probe,
+	.remove     = dp_pll_driver_remove,
+	.driver     = {
+		.name   = "msm_dp_pll",
+		.of_match_table = dp_pll_dt_match,
+	},
+};
+
+void __init msm_dp_pll_driver_register(void)
+{
+	platform_driver_register(&dp_pll_platform_driver);
+}
+
+void __exit msm_dp_pll_driver_unregister(void)
+{
+	platform_driver_unregister(&dp_pll_platform_driver);
+}
diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.h b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
new file mode 100644
index 0000000..d52a81a
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
@@ -0,0 +1,64 @@
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __DP_PLL_H
+#define __DP_PLL_H
+
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/platform_device.h>
+
+#include "dpu_io_util.h"
+#include "msm_drv.h"
+
+#define PLL_REG_W(base, offset, data)	\
+				writel_relaxed((data), (base) + (offset))
+#define PLL_REG_R(base, offset)	readl_relaxed((base) + (offset))
+
+enum msm_dp_pll_type {
+	MSM_DP_PLL_10NM,
+	MSM_DP_PLL_MAX
+};
+
+struct msm_dp_pll {
+	enum msm_dp_pll_type type;
+	struct clk_hw clk_hw;
+	unsigned long	rate;		/* current vco rate */
+	u64		min_rate;	/* min vco rate */
+	u64		max_rate;	/* max vco rate */
+	bool		pll_on;
+	void		*priv;
+	/* Pll specific resources like GPIO, power supply, clocks, etc*/
+	struct dss_module_power mp;
+	int (*get_provider)(struct msm_dp_pll *pll,
+			struct clk **link_clk_provider,
+			struct clk **pixel_clk_provider);
+};
+
+#define hw_clk_to_pll(x) container_of(x, struct msm_dp_pll, clk_hw)
+
+struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,
+			enum msm_dp_pll_type type, int id);
+
+int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
+					struct msm_dp_pll *pll);
+
+#ifdef CONFIG_DRM_MSM_DP_10NM_PLL
+struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id);
+#else
+struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
+{
+	return ERR_PTR(-ENODEV);
+}
+#endif
+#endif /* __DP_PLL_H */
diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
new file mode 100644
index 0000000..a180413
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
@@ -0,0 +1,401 @@
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+/*
+ * Display Port PLL driver block diagram for branch clocks
+ *
+ *		+------------------------------+
+ *		|         DP_VCO_CLK           |
+ *		|                              |
+ *		|    +-------------------+     |
+ *		|    |   (DP PLL/VCO)    |     |
+ *		|    +---------+---------+     |
+ *		|              v               |
+ *		|   +----------+-----------+   |
+ *		|   | hsclk_divsel_clk_src |   |
+ *		|   +----------+-----------+   |
+ *		+------------------------------+
+ *				|
+ *	 +------------<---------v------------>----------+
+ *	 |                                              |
+ * +-----v------------+                                 |
+ * | dp_link_clk_src  |                                 |
+ * |    divsel_ten    |                                 |
+ * +---------+--------+                                 |
+ *	|                                               |
+ *	|                                               |
+ *	v                                               v
+ * Input to DISPCC block                                |
+ * for link clk, crypto clk                             |
+ * and interface clock                                  |
+ *							|
+ *							|
+ *	+--------<------------+-----------------+---<---+
+ *	|                     |                 |
+ * +-------v------+  +--------v-----+  +--------v------+
+ * | vco_divided  |  | vco_divided  |  | vco_divided   |
+ * |    _clk_src  |  |    _clk_src  |  |    _clk_src   |
+ * |              |  |              |  |               |
+ * |divsel_six    |  |  divsel_two  |  |  divsel_four  |
+ * +-------+------+  +-----+--------+  +--------+------+
+ *         |	           |		        |
+ *	v------->----------v-------------<------v
+ *                         |
+ *		+----------+---------+
+ *		|   vco_divided_clk  |
+ *		|       _src_mux     |
+ *		+---------+----------+
+ *                        |
+ *                        v
+ *              Input to DISPCC block
+ *              for DP pixel clock
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/regmap.h>
+#include <linux/clk.h>
+
+#include "dp_pll_10nm.h"
+
+#define NUM_PROVIDED_CLKS		2
+
+#define DP_LINK_CLK_SRC			0
+#define DP_PIXEL_CLK_SRC		1
+
+static struct dp_pll_10nm *dp_pdb;
+
+/* Op structures */
+static const struct clk_ops dp_10nm_vco_clk_ops = {
+	.recalc_rate = dp_vco_recalc_rate_10nm,
+	.set_rate = dp_vco_set_rate_10nm,
+	.round_rate = dp_vco_round_rate_10nm,
+	.prepare = dp_vco_prepare_10nm,
+	.unprepare = dp_vco_unprepare_10nm,
+};
+
+struct dp_pll_10nm_pclksel {
+	struct clk_hw hw;
+
+	/* divider params */
+	u8 shift;
+	u8 width;
+	u8 flags; /* same flags as used by clk_divider struct */
+
+	struct dp_pll_10nm *pll;
+};
+#define to_pll_10nm_pclksel(_hw) container_of(_hw, struct dp_pll_10nm_pclksel, hw)
+
+static int dp_mux_set_parent_10nm(struct clk_hw *hw, u8 val)
+{
+	struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
+	struct dp_pll_10nm *dp_res = pclksel->pll;
+	u32 auxclk_div;
+
+	auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
+	auxclk_div &= ~0x03;	/* bits 0 to 1 */
+
+	if (val == 0) /* mux parent index = 0 */
+		auxclk_div |= 1;
+	else if (val == 1) /* mux parent index = 1 */
+		auxclk_div |= 2;
+	else if (val == 2) /* mux parent index = 2 */
+		auxclk_div |= 0;
+
+	PLL_REG_W(dp_res->phy_base,
+			DP_PHY_VCO_DIV, auxclk_div);
+	/* Make sure the PHY registers writes are done */
+	wmb();
+	pr_debug("%s: mux=%d auxclk_div=%x\n", __func__, val, auxclk_div);
+
+	return 0;
+}
+
+static u8 dp_mux_get_parent_10nm(struct clk_hw *hw)
+{
+	u32 auxclk_div = 0;
+	struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
+	struct dp_pll_10nm *dp_res = pclksel->pll;
+	u8 val = 0;
+
+	pr_err("clk_hw->init->name = %s\n", hw->init->name);
+	auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
+	auxclk_div &= 0x03;
+
+	if (auxclk_div == 1) /* Default divider */
+		val = 0;
+	else if (auxclk_div == 2)
+		val = 1;
+	else if (auxclk_div == 0)
+		val = 2;
+
+	pr_debug("%s: auxclk_div=%d, val=%d\n", __func__, auxclk_div, val);
+
+	return val;
+}
+
+static int clk_mux_determine_rate(struct clk_hw *hw,
+				     struct clk_rate_request *req)
+{
+	int ret = 0;
+
+	ret = __clk_mux_determine_rate_closest(hw, req);
+	if (ret)
+		return ret;
+
+	/* Set the new parent of mux if there is a new valid parent */
+	if (hw->clk && req->best_parent_hw->clk)
+		clk_set_parent(hw->clk, req->best_parent_hw->clk);
+
+	return 0;
+}
+
+static unsigned long mux_recalc_rate(struct clk_hw *hw,
+					unsigned long parent_rate)
+{
+	struct clk *div_clk = NULL, *vco_clk = NULL;
+	struct msm_dp_pll *vco = NULL;
+
+	div_clk = clk_get_parent(hw->clk);
+	if (!div_clk)
+		return 0;
+
+	vco_clk = clk_get_parent(div_clk);
+	if (!vco_clk)
+		return 0;
+
+	vco = hw_clk_to_pll(__clk_get_hw(vco_clk));
+	if (!vco)
+		return 0;
+
+	if (vco->rate == DP_VCO_HSCLK_RATE_8100MHZDIV1000)
+		return (vco->rate / 6);
+	else if (vco->rate == DP_VCO_HSCLK_RATE_5400MHZDIV1000)
+		return (vco->rate / 4);
+	else
+		return (vco->rate / 2);
+}
+
+static int dp_pll_10nm_get_provider(struct msm_dp_pll *pll,
+				     struct clk **link_clk_provider,
+				     struct clk **pixel_clk_provider)
+{
+	struct dp_pll_10nm *pll_10nm = to_dp_pll_10nm(pll);
+	struct clk_hw_onecell_data *hw_data = pll_10nm->hw_data;
+
+	if (link_clk_provider)
+		*link_clk_provider = hw_data->hws[DP_LINK_CLK_SRC]->clk;
+	if (pixel_clk_provider)
+		*pixel_clk_provider = hw_data->hws[DP_PIXEL_CLK_SRC]->clk;
+
+	return 0;
+}
+
+static const struct clk_ops dp_10nm_pclksel_clk_ops = {
+	.get_parent = dp_mux_get_parent_10nm,
+	.set_parent = dp_mux_set_parent_10nm,
+	.recalc_rate = mux_recalc_rate,
+	.determine_rate = clk_mux_determine_rate,
+};
+
+static struct clk_hw *dp_pll_10nm_pixel_clk_sel(struct dp_pll_10nm *pll_10nm)
+{
+	struct device *dev = &pll_10nm->pdev->dev;
+	struct dp_pll_10nm_pclksel *pll_pclksel;
+	struct clk_init_data pclksel_init = {
+		.parent_names = (const char *[]){
+				"dp_vco_divsel_two_clk_src",
+				"dp_vco_divsel_four_clk_src",
+				"dp_vco_divsel_six_clk_src" },
+		.num_parents = 3,
+		.name = "dp_vco_divided_clk_src_mux",
+		.flags = CLK_IGNORE_UNUSED,
+		.ops = &dp_10nm_pclksel_clk_ops,
+	};
+	int ret;
+
+	pll_pclksel = devm_kzalloc(dev, sizeof(*pll_pclksel), GFP_KERNEL);
+	if (!pll_pclksel)
+		return ERR_PTR(-ENOMEM);
+
+	pll_pclksel->pll = pll_10nm;
+	pll_pclksel->shift = 0;
+	pll_pclksel->width = 4;
+	pll_pclksel->flags = CLK_DIVIDER_ONE_BASED;
+	pll_pclksel->hw.init = &pclksel_init;
+
+	ret = clk_hw_register(dev, &pll_pclksel->hw);
+	if (ret)
+		return ERR_PTR(ret);
+
+	return &pll_pclksel->hw;
+}
+
+static int dp_pll_10nm_register(struct dp_pll_10nm *pll_10nm)
+{
+	char clk_name[32], parent[32], vco_name[32];
+	struct clk_init_data vco_init = {
+		.parent_names = (const char *[]){ "bi_tcxo" },
+		.num_parents = 1,
+		.name = vco_name,
+		.flags = CLK_IGNORE_UNUSED,
+		.ops = &dp_10nm_vco_clk_ops,
+	};
+	struct device *dev = &pll_10nm->pdev->dev;
+	struct clk_hw **hws = pll_10nm->hws;
+	struct clk_hw_onecell_data *hw_data;
+	struct clk_hw *hw;
+	int num = 0;
+	int ret;
+
+	DBG("DP->id = %d", pll_10nm->id);
+
+	hw_data = devm_kzalloc(dev, sizeof(*hw_data) +
+			       NUM_PROVIDED_CLKS * sizeof(struct clk_hw *),
+			       GFP_KERNEL);
+	if (!hw_data)
+		return -ENOMEM;
+
+	snprintf(vco_name, 32, "dp_vco_clk");
+	pll_10nm->base.clk_hw.init = &vco_init;
+	ret = clk_hw_register(dev, &pll_10nm->base.clk_hw);
+	if (ret)
+		return ret;
+	hws[num++] = &pll_10nm->base.clk_hw;
+
+	snprintf(clk_name, 32, "dp_link_clk_divsel_ten");
+	snprintf(parent, 32, "dp_vco_clk");
+	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
+					  CLK_SET_RATE_PARENT, 1, 10);
+	if (IS_ERR(hw))
+		return PTR_ERR(hw);
+	hws[num++] = hw;
+	hw_data->hws[DP_LINK_CLK_SRC] = hw;
+
+	snprintf(clk_name, 32, "dp_vco_divsel_two_clk_src");
+	snprintf(parent, 32, "dp_vco_clk");
+	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
+					  0, 1, 2);
+	if (IS_ERR(hw))
+		return PTR_ERR(hw);
+	hws[num++] = hw;
+
+	snprintf(clk_name, 32, "dp_vco_divsel_four_clk_src");
+	snprintf(parent, 32, "dp_vco_clk");
+	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
+					  0, 1, 4);
+	if (IS_ERR(hw))
+		return PTR_ERR(hw);
+	hws[num++] = hw;
+
+	snprintf(clk_name, 32, "dp_vco_divsel_six_clk_src");
+	snprintf(parent, 32, "dp_vco_clk");
+	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
+					  0, 1, 6);
+	if (IS_ERR(hw))
+		return PTR_ERR(hw);
+	hws[num++] = hw;
+
+	hw = dp_pll_10nm_pixel_clk_sel(pll_10nm);
+	if (IS_ERR(hw))
+		return PTR_ERR(hw);
+
+	hws[num++] = hw;
+	hw_data->hws[DP_PIXEL_CLK_SRC] = hw;
+
+	pll_10nm->num_hws = num;
+
+	hw_data->num = NUM_PROVIDED_CLKS;
+	pll_10nm->hw_data = hw_data;
+
+	ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
+				     pll_10nm->hw_data);
+	if (ret) {
+		dev_err(dev, "failed to register clk provider: %d\n", ret);
+		return ret;
+	}
+
+	return ret;
+}
+
+struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
+{
+	struct dp_pll_10nm *dp_10nm_pll;
+	struct msm_dp_pll *pll;
+	int ret;
+
+	if (!pdev)
+		return ERR_PTR(-ENODEV);
+
+	dp_10nm_pll = devm_kzalloc(&pdev->dev, sizeof(*dp_10nm_pll), GFP_KERNEL);
+	if (!dp_10nm_pll)
+		return ERR_PTR(-ENOMEM);
+
+	DBG("DP PLL%d", id);
+
+	dp_10nm_pll->pdev = pdev;
+	dp_10nm_pll->id = id;
+	dp_pdb = dp_10nm_pll;
+
+	dp_10nm_pll->pll_base = msm_ioremap(pdev, "pll_base", "DP_PLL");
+	if (IS_ERR_OR_NULL(dp_10nm_pll->pll_base)) {
+		dev_err(&pdev->dev, "failed to map CMN PLL base\n");
+		return ERR_PTR(-ENOMEM);
+	}
+
+	dp_10nm_pll->phy_base = msm_ioremap(pdev, "phy_base", "DP_PHY");
+	if (IS_ERR_OR_NULL(dp_10nm_pll->phy_base)) {
+		dev_err(&pdev->dev, "failed to map CMN PHY base\n");
+		return ERR_PTR(-ENOMEM);
+	}
+
+	dp_10nm_pll->ln_tx0_base = msm_ioremap(pdev, "ln_tx0_base", "DP_LN_TX0");
+	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx0_base)) {
+		dev_err(&pdev->dev, "failed to map CMN LN_TX0 base\n");
+		return ERR_PTR(-ENOMEM);
+	}
+
+	dp_10nm_pll->ln_tx1_base = msm_ioremap(pdev, "ln_tx1_base", "DP_LN_TX1");
+	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx1_base)) {
+		dev_err(&pdev->dev, "failed to map CMN LN_TX1 base\n");
+		return ERR_PTR(-ENOMEM);
+	}
+
+	ret = of_property_read_u32(pdev->dev.of_node, "cell-index",
+				&dp_10nm_pll->index);
+	if (ret) {
+		pr_err("Unable to get the cell-index ret=%d\n", ret);
+		dp_10nm_pll->index = 0;
+	}
+
+	ret = msm_dp_pll_util_parse_dt_clock(pdev, &dp_10nm_pll->base);
+	if (ret) {
+		pr_err("Unable to parse dt clocks ret=%d\n", ret);
+		return ERR_PTR(ret);
+	}
+
+	ret = dp_pll_10nm_register(dp_10nm_pll);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to register PLL: %d\n", ret);
+		return ERR_PTR(ret);
+	}
+
+	pll = &dp_10nm_pll->base;
+	pll->min_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
+	pll->max_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;
+	pll->get_provider = dp_pll_10nm_get_provider;
+
+	return pll;
+}
diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
new file mode 100644
index 0000000..f966beb
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
@@ -0,0 +1,94 @@
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __DP_PLL_10NM_H
+#define __DP_PLL_10NM_H
+
+#include "dp_pll.h"
+#include "dp_reg.h"
+
+#define DP_VCO_HSCLK_RATE_1620MHZDIV1000	1620000UL
+#define DP_VCO_HSCLK_RATE_2700MHZDIV1000	2700000UL
+#define DP_VCO_HSCLK_RATE_5400MHZDIV1000	5400000UL
+#define DP_VCO_HSCLK_RATE_8100MHZDIV1000	8100000UL
+
+#define NUM_DP_CLOCKS_MAX			6
+
+#define DP_PHY_PLL_POLL_SLEEP_US		500
+#define DP_PHY_PLL_POLL_TIMEOUT_US		10000
+
+#define DP_VCO_RATE_8100MHZDIV1000		8100000UL
+#define DP_VCO_RATE_9720MHZDIV1000		9720000UL
+#define DP_VCO_RATE_10800MHZDIV1000		10800000UL
+
+struct dp_pll_10nm {
+	struct msm_dp_pll base;
+
+	int id;
+	struct platform_device *pdev;
+
+	void __iomem *pll_base;
+	void __iomem *phy_base;
+	void __iomem *ln_tx0_base;
+	void __iomem *ln_tx1_base;
+
+	/* private clocks: */
+	struct clk_hw *hws[NUM_DP_CLOCKS_MAX];
+	u32 num_hws;
+
+	/* clock-provider: */
+	struct clk_hw_onecell_data *hw_data;
+
+	/* lane and orientation settings */
+	u8 lane_cnt;
+	u8 orientation;
+
+	/* COM PHY settings */
+	u32 hsclk_sel;
+	u32 dec_start_mode0;
+	u32 div_frac_start1_mode0;
+	u32 div_frac_start2_mode0;
+	u32 div_frac_start3_mode0;
+	u32 integloop_gain0_mode0;
+	u32 integloop_gain1_mode0;
+	u32 vco_tune_map;
+	u32 lock_cmp1_mode0;
+	u32 lock_cmp2_mode0;
+	u32 lock_cmp3_mode0;
+	u32 lock_cmp_en;
+
+	/* PHY vco divider */
+	u32 phy_vco_div;
+	/*
+	 * Certain pll's needs to update the same vco rate after resume in
+	 * suspend/resume scenario. Cached the vco rate for such plls.
+	 */
+	unsigned long	vco_cached_rate;
+	u32		cached_cfg0;
+	u32		cached_cfg1;
+	u32		cached_outdiv;
+
+	uint32_t index;
+};
+
+#define to_dp_pll_10nm(x)	container_of(x, struct dp_pll_10nm, base)
+
+int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
+				unsigned long parent_rate);
+unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
+				unsigned long parent_rate);
+long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
+				unsigned long *parent_rate);
+int dp_vco_prepare_10nm(struct clk_hw *hw);
+void dp_vco_unprepare_10nm(struct clk_hw *hw);
+#endif /* __DP_PLL_10NM_H */
diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
new file mode 100644
index 0000000..9eb6881
--- /dev/null
+++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
@@ -0,0 +1,531 @@
+/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#define pr_fmt(fmt)	"%s: " fmt, __func__
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/iopoll.h>
+#include <linux/delay.h>
+
+#include "dp_pll.h"
+#include "dp_pll_10nm.h"
+#include "dp_extcon.h"
+
+static int dp_vco_pll_init_db_10nm(struct msm_dp_pll *pll,
+		unsigned long rate)
+{
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+	u32 spare_value = 0;
+
+	spare_value = PLL_REG_R(dp_res->phy_base, DP_PHY_SPARE0);
+	dp_res->lane_cnt = spare_value & 0x0F;
+	dp_res->orientation = (spare_value & 0xF0) >> 4;
+
+	pr_debug("%s: spare_value=0x%x, ln_cnt=0x%x, orientation=0x%x\n",
+			__func__, spare_value, dp_res->lane_cnt, dp_res->orientation);
+
+	switch (rate) {
+	case DP_VCO_HSCLK_RATE_1620MHZDIV1000:
+		pr_debug("%s: VCO rate: %ld\n", __func__,
+				DP_VCO_RATE_9720MHZDIV1000);
+		dp_res->hsclk_sel = 0x0c;
+		dp_res->dec_start_mode0 = 0x69;
+		dp_res->div_frac_start1_mode0 = 0x00;
+		dp_res->div_frac_start2_mode0 = 0x80;
+		dp_res->div_frac_start3_mode0 = 0x07;
+		dp_res->integloop_gain0_mode0 = 0x3f;
+		dp_res->integloop_gain1_mode0 = 0x00;
+		dp_res->vco_tune_map = 0x00;
+		dp_res->lock_cmp1_mode0 = 0x6f;
+		dp_res->lock_cmp2_mode0 = 0x08;
+		dp_res->lock_cmp3_mode0 = 0x00;
+		dp_res->phy_vco_div = 0x1;
+		dp_res->lock_cmp_en = 0x00;
+		break;
+	case DP_VCO_HSCLK_RATE_2700MHZDIV1000:
+		pr_debug("%s: VCO rate: %ld\n", __func__,
+				DP_VCO_RATE_10800MHZDIV1000);
+		dp_res->hsclk_sel = 0x04;
+		dp_res->dec_start_mode0 = 0x69;
+		dp_res->div_frac_start1_mode0 = 0x00;
+		dp_res->div_frac_start2_mode0 = 0x80;
+		dp_res->div_frac_start3_mode0 = 0x07;
+		dp_res->integloop_gain0_mode0 = 0x3f;
+		dp_res->integloop_gain1_mode0 = 0x00;
+		dp_res->vco_tune_map = 0x00;
+		dp_res->lock_cmp1_mode0 = 0x0f;
+		dp_res->lock_cmp2_mode0 = 0x0e;
+		dp_res->lock_cmp3_mode0 = 0x00;
+		dp_res->phy_vco_div = 0x1;
+		dp_res->lock_cmp_en = 0x00;
+		break;
+	case DP_VCO_HSCLK_RATE_5400MHZDIV1000:
+		pr_debug("%s: VCO rate: %ld\n", __func__,
+				DP_VCO_RATE_10800MHZDIV1000);
+		dp_res->hsclk_sel = 0x00;
+		dp_res->dec_start_mode0 = 0x8c;
+		dp_res->div_frac_start1_mode0 = 0x00;
+		dp_res->div_frac_start2_mode0 = 0x00;
+		dp_res->div_frac_start3_mode0 = 0x0a;
+		dp_res->integloop_gain0_mode0 = 0x3f;
+		dp_res->integloop_gain1_mode0 = 0x00;
+		dp_res->vco_tune_map = 0x00;
+		dp_res->lock_cmp1_mode0 = 0x1f;
+		dp_res->lock_cmp2_mode0 = 0x1c;
+		dp_res->lock_cmp3_mode0 = 0x00;
+		dp_res->phy_vco_div = 0x2;
+		dp_res->lock_cmp_en = 0x00;
+		break;
+	case DP_VCO_HSCLK_RATE_8100MHZDIV1000:
+		pr_debug("%s: VCO rate: %ld\n", __func__,
+				DP_VCO_RATE_8100MHZDIV1000);
+		dp_res->hsclk_sel = 0x03;
+		dp_res->dec_start_mode0 = 0x69;
+		dp_res->div_frac_start1_mode0 = 0x00;
+		dp_res->div_frac_start2_mode0 = 0x80;
+		dp_res->div_frac_start3_mode0 = 0x07;
+		dp_res->integloop_gain0_mode0 = 0x3f;
+		dp_res->integloop_gain1_mode0 = 0x00;
+		dp_res->vco_tune_map = 0x00;
+		dp_res->lock_cmp1_mode0 = 0x2f;
+		dp_res->lock_cmp2_mode0 = 0x2a;
+		dp_res->lock_cmp3_mode0 = 0x00;
+		dp_res->phy_vco_div = 0x0;
+		dp_res->lock_cmp_en = 0x08;
+		break;
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int dp_config_vco_rate_10nm(struct msm_dp_pll *pll,
+		unsigned long rate)
+{
+	u32 res = 0;
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+
+	res = dp_vco_pll_init_db_10nm(pll, rate);
+	if (res) {
+		pr_err("VCO Init DB failed\n");
+		return res;
+	}
+
+	if (dp_res->lane_cnt != 4) {
+		if (dp_res->orientation == ORIENTATION_CC2)
+			PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x6d);
+		else
+			PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x75);
+	} else {
+		PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x7d);
+	}
+
+	/* Make sure the PHY register writes are done */
+	wmb();
+
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SVS_MODE_CLK_SEL, 0x01);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_EN_SEL, 0x37);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYS_CLK_CTRL, 0x02);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_ENABLE1, 0x0e);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_BUF_ENABLE, 0x06);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_SEL, 0x30);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CMN_CONFIG, 0x02);
+
+	/* Different for each clock rates */
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_HSCLK_SEL, dp_res->hsclk_sel);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_DEC_START_MODE0, dp_res->dec_start_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_DIV_FRAC_START1_MODE0, dp_res->div_frac_start1_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_DIV_FRAC_START2_MODE0, dp_res->div_frac_start2_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_DIV_FRAC_START3_MODE0, dp_res->div_frac_start3_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_INTEGLOOP_GAIN0_MODE0, dp_res->integloop_gain0_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_INTEGLOOP_GAIN1_MODE0, dp_res->integloop_gain1_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_VCO_TUNE_MAP, dp_res->vco_tune_map);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_LOCK_CMP1_MODE0, dp_res->lock_cmp1_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_LOCK_CMP2_MODE0, dp_res->lock_cmp2_mode0);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_LOCK_CMP3_MODE0, dp_res->lock_cmp3_mode0);
+	/* Make sure the PLL register writes are done */
+	wmb();
+
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_BG_TIMER, 0x0a);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORECLK_DIV_MODE0, 0x0a);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_VCO_TUNE_CTRL, 0x00);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x3f);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORE_CLK_EN, 0x1f);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_IVCO, 0x07);
+	PLL_REG_W(dp_res->pll_base,
+		QSERDES_COM_LOCK_CMP_EN, dp_res->lock_cmp_en);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_CCTRL_MODE0, 0x36);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_RCTRL_MODE0, 0x16);
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CP_CTRL_MODE0, 0x06);
+	/* Make sure the PHY register writes are done */
+	wmb();
+
+	if (dp_res->orientation == ORIENTATION_CC2)
+		PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x4c);
+	else
+		PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x5c);
+	/* Make sure the PLL register writes are done */
+	wmb();
+
+	/* TX Lane configuration */
+	PLL_REG_W(dp_res->phy_base,
+			DP_PHY_TX0_TX1_LANE_CTL, 0x05);
+	PLL_REG_W(dp_res->phy_base,
+			DP_PHY_TX2_TX3_LANE_CTL, 0x05);
+
+	/* TX-0 register configuration */
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_VMODE_CTRL1, 0x40);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_INTERFACE_SELECT, 0x3d);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_CLKBUF_ENABLE, 0x0f);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_RESET_TSYNC_EN, 0x03);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
+	PLL_REG_W(dp_res->ln_tx0_base,
+		TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_INTERFACE_MODE, 0x00);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_BAND, 0x4);
+
+	/* TX-1 register configuration */
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_VMODE_CTRL1, 0x40);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_INTERFACE_SELECT, 0x3d);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_CLKBUF_ENABLE, 0x0f);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_RESET_TSYNC_EN, 0x03);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
+	PLL_REG_W(dp_res->ln_tx1_base,
+		TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_INTERFACE_MODE, 0x00);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_BAND, 0x4);
+	/* Make sure the PHY register writes are done */
+	wmb();
+
+	/* dependent on the vco frequency */
+	PLL_REG_W(dp_res->phy_base, DP_PHY_VCO_DIV, dp_res->phy_vco_div);
+
+	return res;
+}
+
+static bool dp_10nm_pll_lock_status(struct dp_pll_10nm *dp_res)
+{
+	u32 status;
+	bool pll_locked;
+
+	/* poll for PLL lock status */
+	if (readl_poll_timeout_atomic((dp_res->pll_base +
+			QSERDES_COM_C_READY_STATUS),
+			status,
+			((status & BIT(0)) > 0),
+			DP_PHY_PLL_POLL_SLEEP_US,
+			DP_PHY_PLL_POLL_TIMEOUT_US)) {
+		pr_err("%s: C_READY status is not high. Status=%x\n",
+				__func__, status);
+		pll_locked = false;
+	} else {
+		pll_locked = true;
+	}
+
+	return pll_locked;
+}
+
+static bool dp_10nm_phy_rdy_status(struct dp_pll_10nm *dp_res)
+{
+	u32 status;
+	bool phy_ready = true;
+
+	/* poll for PHY ready status */
+	if (readl_poll_timeout_atomic((dp_res->phy_base +
+			DP_PHY_STATUS),
+			status,
+			((status & (BIT(1))) > 0),
+			DP_PHY_PLL_POLL_SLEEP_US,
+			DP_PHY_PLL_POLL_TIMEOUT_US)) {
+		pr_err("%s: Phy_ready is not high. Status=%x\n",
+				__func__, status);
+		phy_ready = false;
+	}
+
+	return phy_ready;
+}
+
+static int dp_pll_enable_10nm(struct clk_hw *hw)
+{
+	int rc = 0;
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+	u32 bias_en, drvr_en;
+
+	PLL_REG_W(dp_res->phy_base, DP_PHY_AUX_CFG2, 0x04);
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x05);
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x09);
+	wmb(); /* Make sure the PHY register writes are done */
+
+	PLL_REG_W(dp_res->pll_base, QSERDES_COM_RESETSM_CNTRL, 0x20);
+	wmb();	/* Make sure the PLL register writes are done */
+
+	if (!dp_10nm_pll_lock_status(dp_res)) {
+		rc = -EINVAL;
+		goto lock_err;
+	}
+
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
+	/* Make sure the PHY register writes are done */
+	wmb();
+	/* poll for PHY ready status */
+	if (!dp_10nm_phy_rdy_status(dp_res)) {
+		rc = -EINVAL;
+		goto lock_err;
+	}
+
+	pr_debug("%s: PLL is locked\n", __func__);
+
+	if (dp_res->lane_cnt == 1) {
+		bias_en = 0x3e;
+		drvr_en = 0x13;
+	} else {
+		bias_en = 0x3f;
+		drvr_en = 0x10;
+	}
+
+	if (dp_res->lane_cnt != 4) {
+		if (dp_res->orientation == ORIENTATION_CC1) {
+			PLL_REG_W(dp_res->ln_tx1_base,
+				TXn_HIGHZ_DRVR_EN, drvr_en);
+			PLL_REG_W(dp_res->ln_tx1_base,
+				TXn_TRANSCEIVER_BIAS_EN, bias_en);
+		} else {
+			PLL_REG_W(dp_res->ln_tx0_base,
+				TXn_HIGHZ_DRVR_EN, drvr_en);
+			PLL_REG_W(dp_res->ln_tx0_base,
+				TXn_TRANSCEIVER_BIAS_EN, bias_en);
+		}
+	} else {
+		PLL_REG_W(dp_res->ln_tx0_base, TXn_HIGHZ_DRVR_EN, drvr_en);
+		PLL_REG_W(dp_res->ln_tx0_base,
+			TXn_TRANSCEIVER_BIAS_EN, bias_en);
+		PLL_REG_W(dp_res->ln_tx1_base, TXn_HIGHZ_DRVR_EN, drvr_en);
+		PLL_REG_W(dp_res->ln_tx1_base,
+			TXn_TRANSCEIVER_BIAS_EN, bias_en);
+	}
+
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_POL_INV, 0x0a);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_POL_INV, 0x0a);
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x18);
+	udelay(2000);
+
+	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
+
+	/*
+	 * Make sure all the register writes are completed before
+	 * doing any other operation
+	 */
+	wmb();
+
+	/* poll for PHY ready status */
+	if (!dp_10nm_phy_rdy_status(dp_res)) {
+		rc = -EINVAL;
+		goto lock_err;
+	}
+
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_DRV_LVL, 0x38);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_DRV_LVL, 0x38);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_EMP_POST1_LVL, 0x20);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_EMP_POST1_LVL, 0x20);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
+	PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
+	PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
+	/* Make sure the PHY register writes are done */
+	wmb();
+
+lock_err:
+	return rc;
+}
+
+static int dp_pll_disable_10nm(struct clk_hw *hw)
+{
+	int rc = 0;
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+
+	/* Assert DP PHY power down */
+	PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x2);
+	/*
+	 * Make sure all the register writes to disable PLL are
+	 * completed before doing any other operation
+	 */
+	wmb();
+
+	return rc;
+}
+
+
+int dp_vco_prepare_10nm(struct clk_hw *hw)
+{
+	int rc = 0;
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+
+	pr_debug("rate=%ld\n", pll->rate);
+	if ((dp_res->vco_cached_rate != 0)
+		&& (dp_res->vco_cached_rate == pll->rate)) {
+		rc = pll->clk_hw.init->ops->set_rate(hw,
+			dp_res->vco_cached_rate, dp_res->vco_cached_rate);
+		if (rc) {
+			pr_err("index=%d vco_set_rate failed. rc=%d\n",
+				rc, dp_res->index);
+			goto error;
+		}
+	}
+
+	rc = dp_pll_enable_10nm(hw);
+	if (rc) {
+		pr_err("ndx=%d failed to enable dp pll\n",
+					dp_res->index);
+		goto error;
+	}
+
+	pll->pll_on = true;
+error:
+	return rc;
+}
+
+void dp_vco_unprepare_10nm(struct clk_hw *hw)
+{
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+
+	if (!dp_res) {
+		pr_err("Invalid input parameter\n");
+		return;
+	}
+
+	if (!pll->pll_on) {
+		pr_err("pll resource can't be enabled\n");
+		return;
+	}
+	dp_res->vco_cached_rate = pll->rate;
+	dp_pll_disable_10nm(hw);
+
+	//dp_res->handoff_resources = false;
+	pll->pll_on = false;
+}
+
+int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
+					unsigned long parent_rate)
+{
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	int rc;
+
+	pr_debug("DP lane CLK rate=%ld\n", rate);
+
+	rc = dp_config_vco_rate_10nm(pll, rate);
+	if (rc)
+		pr_err("%s: Failed to set clk rate\n", __func__);
+
+	pll->rate = rate;
+
+	return 0;
+}
+
+unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
+					unsigned long parent_rate)
+{
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
+	u32 div, hsclk_div, link_clk_div = 0;
+	u64 vco_rate;
+
+	div = PLL_REG_R(dp_res->pll_base, QSERDES_COM_HSCLK_SEL);
+	div &= 0x0f;
+
+	if (div == 12)
+		hsclk_div = 6; /* Default */
+	else if (div == 4)
+		hsclk_div = 4;
+	else if (div == 0)
+		hsclk_div = 2;
+	else if (div == 3)
+		hsclk_div = 1;
+	else {
+		pr_debug("unknown divider. forcing to default\n");
+		hsclk_div = 5;
+	}
+
+	div = PLL_REG_R(dp_res->phy_base, DP_PHY_AUX_CFG2);
+	div >>= 2;
+
+	if ((div & 0x3) == 0)
+		link_clk_div = 5;
+	else if ((div & 0x3) == 1)
+		link_clk_div = 10;
+	else if ((div & 0x3) == 2)
+		link_clk_div = 20;
+	else
+		pr_err("%s: unsupported div. Phy_mode: %d\n", __func__, div);
+
+	if (link_clk_div == 20) {
+		vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
+	} else {
+		if (hsclk_div == 6)
+			vco_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
+		else if (hsclk_div == 4)
+			vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
+		else if (hsclk_div == 2)
+			vco_rate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
+		else
+			vco_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;
+	}
+
+	pr_debug("returning vco rate = %lu\n", (unsigned long)vco_rate);
+
+	dp_res->vco_cached_rate = pll->rate = vco_rate;
+	return (unsigned long)vco_rate;
+}
+
+long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
+			unsigned long *parent_rate)
+{
+	unsigned long rrate = rate;
+	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
+
+	if (rate <= pll->min_rate)
+		rrate = pll->min_rate;
+	else if (rate <= DP_VCO_HSCLK_RATE_2700MHZDIV1000)
+		rrate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
+	else if (rate <= DP_VCO_HSCLK_RATE_5400MHZDIV1000)
+		rrate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
+	else
+		rrate = pll->max_rate;
+
+	pr_debug("%s: rrate=%ld\n", __func__, rrate);
+
+	*parent_rate = rrate;
+	return rrate;
+}
+
-- 
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project

_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 3/3] drm/msm/dp: add support for DP PLL driver

[Sean Paul]

On Wed, Oct 10, 2018 at 10:15:59AM -0700, Chandan Uddaraju wrote:
> Add the needed DP PLL specific files to support
> display port interface on msm targets.
> 
> The DP driver calls the DP PLL driver registration.
> The DP driver sets the link and pixel clock sources.
> 
> Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> ---
>  drivers/gpu/drm/msm/Kconfig                   |  16 +
>  drivers/gpu/drm/msm/Makefile                  |   6 +
>  drivers/gpu/drm/msm/dp/dp_ctrl.c              |   1 +
>  drivers/gpu/drm/msm/dp/dp_display.c           |  50 +++
>  drivers/gpu/drm/msm/dp/dp_display.h           |   3 +
>  drivers/gpu/drm/msm/dp/dp_parser.h            |   3 +
>  drivers/gpu/drm/msm/dp/dp_power.c             |  77 +++-
>  drivers/gpu/drm/msm/dp/dp_power.h             |   2 +
>  drivers/gpu/drm/msm/dp/pll/dp_pll.c           | 153 ++++++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll.h           |  64 ++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c      | 401 +++++++++++++++++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h      |  94 +++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c | 531 ++++++++++++++++++++++++++
>  13 files changed, 1389 insertions(+), 12 deletions(-)
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.c
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.h
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
> 
> diff --git a/drivers/gpu/drm/msm/Kconfig b/drivers/gpu/drm/msm/Kconfig
> index c363f24..1e0b9158 100644
> --- a/drivers/gpu/drm/msm/Kconfig
> +++ b/drivers/gpu/drm/msm/Kconfig
> @@ -58,6 +58,22 @@ config DRM_MSM_DP
>  	  driver. DP external display support is enabled
>  	  through this config option. It can be primary or
>  	  secondary display on device.
> +
> +config DRM_MSM_DP_PLL
> +	bool "Enable DP PLL driver in MSM DRM"
> +	depends on DRM_MSM_DP && COMMON_CLK
> +	default y

The default should be n

> +	help
> +	  Choose this option to enable DP PLL driver which provides DP
> +	  source clocks under common clock framework.
> +
> +config DRM_MSM_DP_10NM_PLL
> +	bool "Enable DP 10nm PLL driver in MSM DRM (used by SDM845)"
> +	depends on DRM_MSM_DP

Should this be DRM_MSM_DP_PLL instead?


> +	default y

The default should be n

> +	help
> +	  Choose this option if DP PLL on SDM845 is used on the platform.
> +
>  config DRM_MSM_DSI
>  	bool "Enable DSI support in MSM DRM driver"
>  	depends on DRM_MSM
> diff --git a/drivers/gpu/drm/msm/Makefile b/drivers/gpu/drm/msm/Makefile
> index 765a8d8..8d18353 100644
> --- a/drivers/gpu/drm/msm/Makefile
> +++ b/drivers/gpu/drm/msm/Makefile
> @@ -137,4 +137,10 @@ msm-$(CONFIG_DRM_MSM_DSI_14NM_PHY) += dsi/pll/dsi_pll_14nm.o
>  msm-$(CONFIG_DRM_MSM_DSI_10NM_PHY) += dsi/pll/dsi_pll_10nm.o
>  endif
>  
> +ifeq ($(CONFIG_DRM_MSM_DP_PLL),y)
> +msm-y += dp/pll/dp_pll.o
> +msm-y += dp/pll/dp_pll_10nm.o
> +msm-y += dp/pll/dp_pll_10nm_util.o

Instead of the ifeq, these should follow the form:

msm-$(CONFIG_BLAH) +=

> +endif
> +
>  obj-$(CONFIG_DRM_MSM)	+= msm.o
> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> index 08a52f5..e23beee 100644
> --- a/drivers/gpu/drm/msm/dp/dp_ctrl.c
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> @@ -1051,6 +1051,7 @@ static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
>  {
>  	int ret = 0;
>  
> +	ctrl->power->set_link_clk_parent(ctrl->power);
>  	ctrl->power->set_pixel_clk_parent(ctrl->power);
>  
>  	dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
> index 8c98399..2bf6635 100644
> --- a/drivers/gpu/drm/msm/dp/dp_display.c
> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
> @@ -72,6 +72,48 @@ struct dp_display_private {
>  	{}
>  };
>  
> +static int dp_get_pll(struct dp_display_private *dp_priv)
> +{
> +	struct platform_device *pdev = NULL;
> +	struct platform_device *pll_pdev;
> +	struct device_node *pll_node;
> +	struct dp_parser *dp_parser = NULL;
> +
> +	if (!dp_priv) {
> +		pr_err("Invalid Arguments\n");
> +		return -EINVAL;
> +	}
> +
> +	pdev = dp_priv->pdev;
> +	dp_parser = dp_priv->parser;
> +
> +	if (!dp_parser) {
> +		pr_err("Parser not initialized.\n");
> +		return -EINVAL;
> +	}

Can we please remove the unnecessary null checks from this patch too?

> +
> +	pll_node = of_parse_phandle(pdev->dev.of_node, "pll-node", 0);
> +	if (!pll_node) {
> +		dev_err(&pdev->dev, "cannot find pll device\n");
> +		return -ENXIO;
> +	}
> +
> +	pll_pdev = of_find_device_by_node(pll_node);
> +	if (pll_pdev)
> +		dp_parser->pll = platform_get_drvdata(pll_pdev);

What if the pll driver goes away before the dp driver?

> +
> +	of_node_put(pll_node);
> +
> +	if (!pll_pdev || !dp_parser->pll) {
> +		dev_err(&pdev->dev, "%s: pll driver is not ready\n", __func__);

This patch (and even just this function) has both pr_err and dev_err, oy!

Please convert everything to one logging medium. The msm driver was recently
converted to DRM_DEV_*, so let's go with that for all of msm/dp/*


> +		return -EPROBE_DEFER;
> +	}
> +
> +	dp_parser->pll_dev = get_device(&pll_pdev->dev);
> +
> +	return 0;
> +}
> +
>  static irqreturn_t dp_display_irq(int irq, void *dev_id)
>  {
>  	struct dp_display_private *dp = dev_id;
> @@ -125,6 +167,12 @@ static int dp_display_bind(struct device *dev, struct device *master,
>  		goto end;
>  	}
>  
> +	rc = dp_get_pll(dp);
> +	if (rc) {
> +		pr_err(" DP get PLL instance failed\n");

Print rc, here and everywhere else.

> +		goto end;
> +	}
> +
>  	rc = dp->aux->drm_aux_register(dp->aux);
>  	if (rc) {
>  		pr_err("DRM DP AUX register failed\n");
> @@ -921,6 +969,7 @@ int __init msm_dp_register(void)
>  {
>  	int ret;
>  
> +	msm_dp_pll_driver_register();
>  	ret = platform_driver_register(&dp_display_driver);
>  	if (ret) {
>  		pr_err("driver register failed");
> @@ -932,6 +981,7 @@ int __init msm_dp_register(void)
>  
>  void __exit msm_dp_unregister(void)
>  {
> +	msm_dp_pll_driver_unregister();
>  	platform_driver_unregister(&dp_display_driver);
>  }
>  
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
> index ca5eae5..9cd6a6b 100644
> --- a/drivers/gpu/drm/msm/dp/dp_display.h
> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
> @@ -52,4 +52,7 @@ struct msm_dp {
>  
>  int dp_display_get_num_of_displays(void);
>  int dp_display_get_displays(void **displays, int count);
> +void __init msm_dp_pll_driver_register(void);
> +void __exit msm_dp_pll_driver_unregister(void);
> +
>  #endif /* _DP_DISPLAY_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_parser.h b/drivers/gpu/drm/msm/dp/dp_parser.h
> index b39ea02..372997e 100644
> --- a/drivers/gpu/drm/msm/dp/dp_parser.h
> +++ b/drivers/gpu/drm/msm/dp/dp_parser.h
> @@ -16,6 +16,7 @@
>  #define _DP_PARSER_H_
>  
>  #include "dpu_io_util.h"
> +#include "pll/dp_pll.h"
>  
>  #define DP_LABEL "MDSS DP DISPLAY"
>  #define AUX_CFG_LEN	10
> @@ -175,6 +176,8 @@ struct dp_parser {
>  	struct dp_pinctrl pinctrl;
>  	struct dp_io io;
>  	struct dp_display_data disp_data;
> +	struct msm_dp_pll *pll;
> +	struct device *pll_dev;

Store pll_dev in msm_dp_pll as 'dev' and remove this?

>  
>  	u8 l_map[4];
>  	struct dp_aux_cfg aux_cfg[AUX_CFG_LEN];
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
> index 1d58480..3a1679c 100644
> --- a/drivers/gpu/drm/msm/dp/dp_power.c
> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
> @@ -23,7 +23,9 @@ struct dp_power_private {
>  	struct dp_parser *parser;
>  	struct platform_device *pdev;
>  	struct clk *pixel_clk_rcg;
> -	struct clk *pixel_parent;
> +	struct clk *link_clk_src;
> +	struct clk *pixel_provider;
> +	struct clk *link_provider;
>  
>  	struct dp_power dp_power;
>  
> @@ -154,6 +156,16 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
>  		goto exit;
>  	}
>  
> +	if (power->parser->pll && power->parser->pll->get_provider) {
> +		rc = power->parser->pll->get_provider(power->parser->pll,
> +				&power->link_provider, &power->pixel_provider);

Hopefully this gets simplified when you de-abstract the rest of the dp driver.

> +		if (rc) {
> +			pr_info("%s: can't get provider from pll, don't set parent\n",
> +				__func__);
> +			return 0;
> +		}
> +	}
> +
>  	if (enable) {
>  		rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
>  		if (rc) {
> @@ -173,17 +185,10 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
>  		if (IS_ERR(power->pixel_clk_rcg)) {
>  			pr_debug("Unable to get DP pixel clk RCG\n");
>  			power->pixel_clk_rcg = NULL;
> -		}
> -
> -		power->pixel_parent = devm_clk_get(dev, "pixel_parent");
> -		if (IS_ERR(power->pixel_parent)) {
> -			pr_debug("Unable to get DP pixel RCG parent\n");
> -			power->pixel_parent = NULL;
> +			rc = -ENODEV;
> +			goto ctrl_get_error;
>  		}
>  	} else {
> -		if (power->pixel_parent)
> -			devm_clk_put(dev, power->pixel_parent);
> -
>  		if (power->pixel_clk_rcg)
>  			devm_clk_put(dev, power->pixel_clk_rcg);
>  
> @@ -459,6 +464,49 @@ static void dp_power_client_deinit(struct dp_power *dp_power)
>  
>  }
>  
> +static int dp_power_set_link_clk_parent(struct dp_power *dp_power)
> +{
> +	int rc = 0;
> +	struct dp_power_private *power;
> +	u32 num;
> +	struct dss_clk *cfg;
> +	char *name = "ctrl_link_clk";
> +
> +	if (!dp_power) {
> +		pr_err("invalid power data\n");
> +		rc = -EINVAL;
> +		goto exit;
> +	}
> +
> +	power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +	num = power->parser->mp[DP_CTRL_PM].num_clk;
> +	cfg = power->parser->mp[DP_CTRL_PM].clk_config;
> +
> +	while (num && strcmp(cfg->clk_name, name)) {

I think I commented on this in the other patch, but don't use strings to do
lookups, please just store the pointer directly if you need a reference.

> +		num--;
> +		cfg++;
> +	}
> +
> +	if (num && power->link_provider) {
> +		power->link_clk_src = clk_get_parent(cfg->clk);

Check return for ERR_PTR

> +			if (power->link_clk_src) {

Indenting is wrong on this block

> +				clk_set_parent(power->link_clk_src, power->link_provider);
> +				pr_debug("%s: is the parent of clk=%s\n",
> +						__clk_get_name(power->link_provider),
> +						__clk_get_name(power->link_clk_src));
> +			} else {
> +				pr_err("couldn't get parent for clk=%s\n", name);
> +				rc = -EINVAL;

Make thi:

        if (!power->link_clk_src) {
                DRM_DEV_ERROR(...)
                return -EINVAL;
        }

        ret = clk_set_parent(power->link_clk_src, power->link_provider);
        if (ret) {
                /* propertly handle error */
        }
        pr_debug("%s: is the parent of clk=%s\n",
                 __clk_get_name(power->link_provider),
                 __clk_get_name(power->link_clk_src));


> +			}
> +	} else {
> +		pr_err("%s clock could not be set parent\n", name);
> +		rc = -EINVAL;
> +	}

Same thing here, flip the if condition to check for error and return early, thus
saving yourself a level of indentation for the successful case.

> +exit:
> +	return rc;

Remove exit label and return directly above

> +}
> +
>  static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
>  {
>  	int rc = 0;
> @@ -472,8 +520,12 @@ static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
>  
>  	power = container_of(dp_power, struct dp_power_private, dp_power);
>  
> -	if (power->pixel_clk_rcg && power->pixel_parent)
> -		clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
> +	if (power->pixel_clk_rcg && power->pixel_provider) {
> +		clk_set_parent(power->pixel_clk_rcg, power->pixel_provider);

s/pixel_parent/pixel_provider/ isn't related to this change, can you please use
the final name in the main dp patch so it's correct in this one?

> +		pr_debug("%s: is the parent of clk=%s\n",
> +					__clk_get_name(power->pixel_provider),
> +					__clk_get_name(power->pixel_clk_rcg));

Same comment here, this debug can go in the main patch.

> +	}
>  exit:
>  	return rc;
>  }
> @@ -577,6 +629,7 @@ struct dp_power *dp_power_get(struct dp_parser *parser)
>  	dp_power->init = dp_power_init;
>  	dp_power->deinit = dp_power_deinit;
>  	dp_power->clk_enable = dp_power_clk_enable;
> +	dp_power->set_link_clk_parent = dp_power_set_link_clk_parent;

Same comment here regarding the unnecessary indirection, just call this thing
directly where applicable.

>  	dp_power->set_pixel_clk_parent = dp_power_set_pixel_clk_parent;
>  	dp_power->power_client_init = dp_power_client_init;
>  	dp_power->power_client_deinit = dp_power_client_deinit;
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
> index d1adaaf..5effd32 100644
> --- a/drivers/gpu/drm/msm/dp/dp_power.h
> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
> @@ -24,6 +24,7 @@
>   * @init: initializes the regulators/core clocks/GPIOs/pinctrl
>   * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
>   * @clk_enable: enable/disable the DP clocks
> + * @set_link_clk_parent: set the parent of DP link clock
>   * @set_pixel_clk_parent: set the parent of DP pixel clock
>   */
>  struct dp_power {
> @@ -31,6 +32,7 @@ struct dp_power {
>  	int (*deinit)(struct dp_power *power);
>  	int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
>  				bool enable);
> +	int (*set_link_clk_parent)(struct dp_power *power);
>  	int (*set_pixel_clk_parent)(struct dp_power *power);
>  	int (*power_client_init)(struct dp_power *power);
>  	void (*power_client_deinit)(struct dp_power *power);
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.c b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
> new file mode 100644
> index 0000000..a8612b5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
> @@ -0,0 +1,153 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */

SPDX please (and elsewhere).

> +
> +#include "dp_pll.h"
> +
> +int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
> +					struct msm_dp_pll *pll)
> +{
> +	u32 i = 0, rc = 0;
> +	struct dss_module_power *mp = &pll->mp;
> +	const char *clock_name;
> +	u32 clock_rate;
> +
> +	mp->num_clk = of_property_count_strings(pdev->dev.of_node,
> +							"clock-names");
> +	if (mp->num_clk <= 0) {
> +		pr_err("clocks are not defined\n");
> +		goto clk_err;
> +	}
> +
> +	mp->clk_config = devm_kzalloc(&pdev->dev,
> +			sizeof(struct dss_clk) * mp->num_clk, GFP_KERNEL);
> +	if (!mp->clk_config) {
> +		rc = -ENOMEM;
> +		mp->num_clk = 0;
> +		goto clk_err;
> +	}
> +
> +	for (i = 0; i < mp->num_clk; i++) {
> +		of_property_read_string_index(pdev->dev.of_node, "clock-names",
> +							i, &clock_name);
> +		strlcpy(mp->clk_config[i].clk_name, clock_name,
> +				sizeof(mp->clk_config[i].clk_name));
> +
> +		of_property_read_u32_index(pdev->dev.of_node, "clock-rate",
> +							i, &clock_rate);
> +		mp->clk_config[i].rate = clock_rate;
> +
> +		if (!clock_rate)
> +			mp->clk_config[i].type = DSS_CLK_AHB;
> +		else
> +			mp->clk_config[i].type = DSS_CLK_PCLK;
> +	}
> +
> +clk_err:

remove clk_err and return directly above

> +	return rc;
> +}
> +
> +struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,

static please

> +			enum msm_dp_pll_type type, int id)
> +{
> +	struct device *dev = &pdev->dev;
> +	struct msm_dp_pll *pll;
> +
> +	switch (type) {
> +	case MSM_DP_PLL_10NM:
> +		pll = msm_dp_pll_10nm_init(pdev, id);
> +		break;
> +	default:
> +		pll = ERR_PTR(-ENXIO);
> +		break;
> +	}
> +
> +	if (IS_ERR(pll)) {
> +		dev_err(dev, "%s: failed to init DP PLL\n", __func__);
> +		return pll;
> +	}
> +
> +	pll->type = type;

This should be set in the type-specific init function (ie:
msm_dp_pll_10nm_init()). That will let you simplify this entire function to:

{
        switch (type) {
        case MSM_DP_PLL_10NM:
                return msm_dp_pll_10nm_init(pdev, id);
	default:
                DRM_DEV_ERROR(&pdev->dev, "Invalid pll type: %d\n", type);
                return ERR_PTR(-ENXIO);
	}
}

> +
> +	DBG("DP:%d PLL registered", id);
> +
> +	return pll;
> +}
> +
> +static const struct of_device_id dp_pll_dt_match[] = {
> +#ifdef CONFIG_DRM_MSM_DP_10NM_PLL

I don't think you need this ifdef check, you've already provided a stub for the
init function

> +	{ .compatible = "qcom,dp-pll-10nm" },
> +#endif
> +	{}
> +};
> +
> +static int dp_pll_driver_probe(struct platform_device *pdev)
> +{
> +	struct msm_dp_pll *pll;
> +	struct device *dev = &pdev->dev;
> +	const struct of_device_id *match;
> +	enum msm_dp_pll_type type;
> +
> +	match = of_match_node(dp_pll_dt_match, dev->of_node);
> +	if (!match)
> +		return -ENODEV;
> +
> +	if (!strcmp(match->compatible, "qcom,dp-pll-10nm"))
> +		type = MSM_DP_PLL_10NM;

This is what of_device_id->data is for, use it to store the type. Can you also
check the rest of the driver and do the same there?

> +	else
> +		type = MSM_DP_PLL_MAX;
> +
> +	pll = msm_dp_pll_init(pdev, type, 0);
> +	if (IS_ERR_OR_NULL(pll)) {
> +		dev_info(dev,

Why info level?

> +			"%s: pll init failed: %ld, need separate pll clk driver\n",
> +			__func__, PTR_ERR(pll));
> +		return -ENODEV;
> +	}
> +
> +	platform_set_drvdata(pdev, pll);
> +
> +	return 0;
> +}
> +
> +static int dp_pll_driver_remove(struct platform_device *pdev)
> +{
> +	struct msm_dp_pll *pll = platform_get_drvdata(pdev);
> +
> +	if (pll) {
> +		//msm_dsi_pll_destroy(pll);

Hmm.

> +		pll = NULL;

No need to clear a local variable

> +	}
> +
> +	platform_set_drvdata(pdev, NULL);

You don't need to clear this either

> +
> +	return 0;
> +}
> +
> +static struct platform_driver dp_pll_platform_driver = {
> +	.probe      = dp_pll_driver_probe,
> +	.remove     = dp_pll_driver_remove,
> +	.driver     = {
> +		.name   = "msm_dp_pll",
> +		.of_match_table = dp_pll_dt_match,
> +	},
> +};
> +
> +void __init msm_dp_pll_driver_register(void)
> +{
> +	platform_driver_register(&dp_pll_platform_driver);
> +}
> +
> +void __exit msm_dp_pll_driver_unregister(void)
> +{
> +	platform_driver_unregister(&dp_pll_platform_driver);
> +}
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.h b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
> new file mode 100644
> index 0000000..d52a81a
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
> @@ -0,0 +1,64 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef __DP_PLL_H
> +#define __DP_PLL_H
> +
> +#include <linux/clk.h>
> +#include <linux/clk-provider.h>
> +#include <linux/platform_device.h>
> +
> +#include "dpu_io_util.h"
> +#include "msm_drv.h"
> +
> +#define PLL_REG_W(base, offset, data)	\
> +				writel_relaxed((data), (base) + (offset))
> +#define PLL_REG_R(base, offset)	readl_relaxed((base) + (offset))

These macros aren't really useful, tbh. It'd be better to have a function that
takes a msm_dp_pll, offset and data.

> +
> +enum msm_dp_pll_type {
> +	MSM_DP_PLL_10NM,
> +	MSM_DP_PLL_MAX
> +};
> +
> +struct msm_dp_pll {
> +	enum msm_dp_pll_type type;

Storing this doesn't seem to gain you anything. So move the dp_pll_type enum
into msm_dp_pll.c, turf the _MAX and make embed it in the .data element of the
of_device_id structs. Then you can use it when you're initializing and promptly
throw it away.

> +	struct clk_hw clk_hw;
> +	unsigned long	rate;		/* current vco rate */
> +	u64		min_rate;	/* min vco rate */
> +	u64		max_rate;	/* max vco rate */
> +	bool		pll_on;

The clk_hw/etc part of this patch should be reviewed by swboyd (cc'd). It's not
really in my wheelhouse, tbh.

> +	void		*priv;

Was going to comment on using an opaque pointer, but it not used anywhere \o/

Please remove

> +	/* Pll specific resources like GPIO, power supply, clocks, etc*/
> +	struct dss_module_power mp;
> +	int (*get_provider)(struct msm_dp_pll *pll,
> +			struct clk **link_clk_provider,
> +			struct clk **pixel_clk_provider);
> +};
> +
> +#define hw_clk_to_pll(x) container_of(x, struct msm_dp_pll, clk_hw)

Please make this a type-safe inline function.

> +
> +struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,
> +			enum msm_dp_pll_type type, int id);

Remove this and make that func static

> +
> +int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
> +					struct msm_dp_pll *pll);
> +
> +#ifdef CONFIG_DRM_MSM_DP_10NM_PLL
> +struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id);
> +#else
> +struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
> +{
> +	return ERR_PTR(-ENODEV);
> +}
> +#endif
> +#endif /* __DP_PLL_H */
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
> new file mode 100644
> index 0000000..a180413
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
> @@ -0,0 +1,401 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +/*
> + * Display Port PLL driver block diagram for branch clocks
> + *
> + *		+------------------------------+
> + *		|         DP_VCO_CLK           |
> + *		|                              |
> + *		|    +-------------------+     |
> + *		|    |   (DP PLL/VCO)    |     |
> + *		|    +---------+---------+     |
> + *		|              v               |
> + *		|   +----------+-----------+   |
> + *		|   | hsclk_divsel_clk_src |   |
> + *		|   +----------+-----------+   |
> + *		+------------------------------+
> + *				|
> + *	 +------------<---------v------------>----------+
> + *	 |                                              |
> + * +-----v------------+                                 |
> + * | dp_link_clk_src  |                                 |
> + * |    divsel_ten    |                                 |
> + * +---------+--------+                                 |
> + *	|                                               |
> + *	|                                               |
> + *	v                                               v
> + * Input to DISPCC block                                |
> + * for link clk, crypto clk                             |
> + * and interface clock                                  |
> + *							|
> + *							|
> + *	+--------<------------+-----------------+---<---+
> + *	|                     |                 |
> + * +-------v------+  +--------v-----+  +--------v------+
> + * | vco_divided  |  | vco_divided  |  | vco_divided   |
> + * |    _clk_src  |  |    _clk_src  |  |    _clk_src   |
> + * |              |  |              |  |               |
> + * |divsel_six    |  |  divsel_two  |  |  divsel_four  |
> + * +-------+------+  +-----+--------+  +--------+------+
> + *         |	           |		        |
> + *	v------->----------v-------------<------v
> + *                         |
> + *		+----------+---------+
> + *		|   vco_divided_clk  |
> + *		|       _src_mux     |
> + *		+---------+----------+
> + *                        |
> + *                        v
> + *              Input to DISPCC block
> + *              for DP pixel clock

Some of your vertical lines seem misaligned here, can you please fix this up?

> + *
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/err.h>
> +#include <linux/delay.h>
> +#include <linux/regmap.h>
> +#include <linux/clk.h>
> +
> +#include "dp_pll_10nm.h"
> +
> +#define NUM_PROVIDED_CLKS		2
> +
> +#define DP_LINK_CLK_SRC			0
> +#define DP_PIXEL_CLK_SRC		1

Instead of using an array to store the clocks in one place, why not just store a
pointer for each clk? Then you can get rid of these and just use the clk
directly.

> +
> +static struct dp_pll_10nm *dp_pdb;

This isn't used (nor should it be).

> +
> +/* Op structures */
> +static const struct clk_ops dp_10nm_vco_clk_ops = {
> +	.recalc_rate = dp_vco_recalc_rate_10nm,
> +	.set_rate = dp_vco_set_rate_10nm,
> +	.round_rate = dp_vco_round_rate_10nm,
> +	.prepare = dp_vco_prepare_10nm,
> +	.unprepare = dp_vco_unprepare_10nm,
> +};
> +
> +struct dp_pll_10nm_pclksel {
> +	struct clk_hw hw;
> +
> +	/* divider params */
> +	u8 shift;
> +	u8 width;
> +	u8 flags; /* same flags as used by clk_divider struct */
> +
> +	struct dp_pll_10nm *pll;
> +};
> +#define to_pll_10nm_pclksel(_hw) container_of(_hw, struct dp_pll_10nm_pclksel, hw)

typesafe static inline please. Everywhere you use pclksel, you just grab ->pll
from the result and never use pclksel again. So make the function return
dp_pll_10nm * directly and save yourself the local var.

> +
> +static int dp_mux_set_parent_10nm(struct clk_hw *hw, u8 val)
> +{
> +	struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
> +	struct dp_pll_10nm *dp_res = pclksel->pll;
> +	u32 auxclk_div;
> +
> +	auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
> +	auxclk_div &= ~0x03;	/* bits 0 to 1 */

This comment isn't really useful :) Could you please #define all of the
hardcoded values in the patch?

> +
> +	if (val == 0) /* mux parent index = 0 */
> +		auxclk_div |= 1;
> +	else if (val == 1) /* mux parent index = 1 */
> +		auxclk_div |= 2;
> +	else if (val == 2) /* mux parent index = 2 */
> +		auxclk_div |= 0;
> +
> +	PLL_REG_W(dp_res->phy_base,
> +			DP_PHY_VCO_DIV, auxclk_div);
> +	/* Make sure the PHY registers writes are done */
> +	wmb();

Same comments about needing wmb to work around using _relaxed

> +	pr_debug("%s: mux=%d auxclk_div=%x\n", __func__, val, auxclk_div);
> +
> +	return 0;
> +}
> +
> +static u8 dp_mux_get_parent_10nm(struct clk_hw *hw)
> +{
> +	u32 auxclk_div = 0;
> +	struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
> +	struct dp_pll_10nm *dp_res = pclksel->pll;
> +	u8 val = 0;
> +
> +	pr_err("clk_hw->init->name = %s\n", hw->init->name);
> +	auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
> +	auxclk_div &= 0x03;
> +
> +	if (auxclk_div == 1) /* Default divider */
> +		val = 0;
> +	else if (auxclk_div == 2)
> +		val = 1;
> +	else if (auxclk_div == 0)
> +		val = 2;
> +
> +	pr_debug("%s: auxclk_div=%d, val=%d\n", __func__, auxclk_div, val);
> +
> +	return val;
> +}
> +
> +static int clk_mux_determine_rate(struct clk_hw *hw,
> +				     struct clk_rate_request *req)
> +{
> +	int ret = 0;

no need to init this to 0

> +
> +	ret = __clk_mux_determine_rate_closest(hw, req);
> +	if (ret)
> +		return ret;
> +
> +	/* Set the new parent of mux if there is a new valid parent */
> +	if (hw->clk && req->best_parent_hw->clk)
> +		clk_set_parent(hw->clk, req->best_parent_hw->clk);

What about the return value? All other clk_set_parent calls in this patch are
also unchecked, so please add those as well.

> +
> +	return 0;
> +}
> +
> +static unsigned long mux_recalc_rate(struct clk_hw *hw,
> +					unsigned long parent_rate)
> +{
> +	struct clk *div_clk = NULL, *vco_clk = NULL;
> +	struct msm_dp_pll *vco = NULL;
> +
> +	div_clk = clk_get_parent(hw->clk);
> +	if (!div_clk)

According to the header documentation, clk_get_parent can return ERR_PTR as
well. Same comment applies to other callsites.

> +		return 0;
> +
> +	vco_clk = clk_get_parent(div_clk);
> +	if (!vco_clk)
> +		return 0;
> +
> +	vco = hw_clk_to_pll(__clk_get_hw(vco_clk));
> +	if (!vco)
> +		return 0;
> +
> +	if (vco->rate == DP_VCO_HSCLK_RATE_8100MHZDIV1000)
> +		return (vco->rate / 6);

Unnecessary () here and below

> +	else if (vco->rate == DP_VCO_HSCLK_RATE_5400MHZDIV1000)
> +		return (vco->rate / 4);
> +	else
> +		return (vco->rate / 2);
> +}
> +
> +static int dp_pll_10nm_get_provider(struct msm_dp_pll *pll,
> +				     struct clk **link_clk_provider,
> +				     struct clk **pixel_clk_provider)
> +{
> +	struct dp_pll_10nm *pll_10nm = to_dp_pll_10nm(pll);
> +	struct clk_hw_onecell_data *hw_data = pll_10nm->hw_data;
> +
> +	if (link_clk_provider)
> +		*link_clk_provider = hw_data->hws[DP_LINK_CLK_SRC]->clk;
> +	if (pixel_clk_provider)
> +		*pixel_clk_provider = hw_data->hws[DP_PIXEL_CLK_SRC]->clk;
> +
> +	return 0;

Why have a return value when the only place always returns 0? Make it void and
simplify error checking at the callsite.

> +}
> +
> +static const struct clk_ops dp_10nm_pclksel_clk_ops = {
> +	.get_parent = dp_mux_get_parent_10nm,
> +	.set_parent = dp_mux_set_parent_10nm,
> +	.recalc_rate = mux_recalc_rate,
> +	.determine_rate = clk_mux_determine_rate,
> +};
> +
> +static struct clk_hw *dp_pll_10nm_pixel_clk_sel(struct dp_pll_10nm *pll_10nm)
> +{
> +	struct device *dev = &pll_10nm->pdev->dev;
> +	struct dp_pll_10nm_pclksel *pll_pclksel;
> +	struct clk_init_data pclksel_init = {
> +		.parent_names = (const char *[]){
> +				"dp_vco_divsel_two_clk_src",
> +				"dp_vco_divsel_four_clk_src",
> +				"dp_vco_divsel_six_clk_src" },
> +		.num_parents = 3,
> +		.name = "dp_vco_divided_clk_src_mux",
> +		.flags = CLK_IGNORE_UNUSED,
> +		.ops = &dp_10nm_pclksel_clk_ops,
> +	};
> +	int ret;
> +
> +	pll_pclksel = devm_kzalloc(dev, sizeof(*pll_pclksel), GFP_KERNEL);
> +	if (!pll_pclksel)
> +		return ERR_PTR(-ENOMEM);
> +
> +	pll_pclksel->pll = pll_10nm;
> +	pll_pclksel->shift = 0;
> +	pll_pclksel->width = 4;
> +	pll_pclksel->flags = CLK_DIVIDER_ONE_BASED;
> +	pll_pclksel->hw.init = &pclksel_init;

pclksel_init goes out of scope at the end of the function, yet it is persisted
in pll_pclksel. That should be fixed.

> +
> +	ret = clk_hw_register(dev, &pll_pclksel->hw);
> +	if (ret)
> +		return ERR_PTR(ret);
> +
> +	return &pll_pclksel->hw;
> +}
> +
> +static int dp_pll_10nm_register(struct dp_pll_10nm *pll_10nm)
> +{
> +	char clk_name[32], parent[32], vco_name[32];
> +	struct clk_init_data vco_init = {
> +		.parent_names = (const char *[]){ "bi_tcxo" },
> +		.num_parents = 1,
> +		.name = vco_name,
> +		.flags = CLK_IGNORE_UNUSED,
> +		.ops = &dp_10nm_vco_clk_ops,
> +	};
> +	struct device *dev = &pll_10nm->pdev->dev;
> +	struct clk_hw **hws = pll_10nm->hws;
> +	struct clk_hw_onecell_data *hw_data;
> +	struct clk_hw *hw;
> +	int num = 0;
> +	int ret;
> +
> +	DBG("DP->id = %d", pll_10nm->id);
> +
> +	hw_data = devm_kzalloc(dev, sizeof(*hw_data) +
> +			       NUM_PROVIDED_CLKS * sizeof(struct clk_hw *),
> +			       GFP_KERNEL);
> +	if (!hw_data)
> +		return -ENOMEM;
> +
> +	snprintf(vco_name, 32, "dp_vco_clk");
> +	pll_10nm->base.clk_hw.init = &vco_init;

Same comment about scope here

> +	ret = clk_hw_register(dev, &pll_10nm->base.clk_hw);
> +	if (ret)
> +		return ret;
> +	hws[num++] = &pll_10nm->base.clk_hw;
> +
> +	snprintf(clk_name, 32, "dp_link_clk_divsel_ten");
> +	snprintf(parent, 32, "dp_vco_clk");
> +	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +					  CLK_SET_RATE_PARENT, 1, 10);
> +	if (IS_ERR(hw))
> +		return PTR_ERR(hw);
> +	hws[num++] = hw;
> +	hw_data->hws[DP_LINK_CLK_SRC] = hw;
> +
> +	snprintf(clk_name, 32, "dp_vco_divsel_two_clk_src");
> +	snprintf(parent, 32, "dp_vco_clk");
> +	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +					  0, 1, 2);
> +	if (IS_ERR(hw))
> +		return PTR_ERR(hw);
> +	hws[num++] = hw;
> +
> +	snprintf(clk_name, 32, "dp_vco_divsel_four_clk_src");
> +	snprintf(parent, 32, "dp_vco_clk");
> +	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +					  0, 1, 4);
> +	if (IS_ERR(hw))
> +		return PTR_ERR(hw);
> +	hws[num++] = hw;
> +
> +	snprintf(clk_name, 32, "dp_vco_divsel_six_clk_src");
> +	snprintf(parent, 32, "dp_vco_clk");
> +	hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +					  0, 1, 6);
> +	if (IS_ERR(hw))
> +		return PTR_ERR(hw);
> +	hws[num++] = hw;
> +
> +	hw = dp_pll_10nm_pixel_clk_sel(pll_10nm);
> +	if (IS_ERR(hw))
> +		return PTR_ERR(hw);
> +
> +	hws[num++] = hw;
> +	hw_data->hws[DP_PIXEL_CLK_SRC] = hw;

I'm going to leave this chunk for Stephen to comment on, but again I'd rather
not store these clocks as an array and do string lookups on them.

> +
> +	pll_10nm->num_hws = num;
> +
> +	hw_data->num = NUM_PROVIDED_CLKS;
> +	pll_10nm->hw_data = hw_data;
> +
> +	ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
> +				     pll_10nm->hw_data);
> +	if (ret) {
> +		dev_err(dev, "failed to register clk provider: %d\n", ret);
> +		return ret;
> +	}
> +
> +	return ret;
> +}
> +
> +struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
> +{
> +	struct dp_pll_10nm *dp_10nm_pll;
> +	struct msm_dp_pll *pll;
> +	int ret;
> +
> +	if (!pdev)
> +		return ERR_PTR(-ENODEV);
> +
> +	dp_10nm_pll = devm_kzalloc(&pdev->dev, sizeof(*dp_10nm_pll), GFP_KERNEL);
> +	if (!dp_10nm_pll)
> +		return ERR_PTR(-ENOMEM);
> +
> +	DBG("DP PLL%d", id);

Please remove (or convert to DRM_DEV_DEBUG)

> +
> +	dp_10nm_pll->pdev = pdev;
> +	dp_10nm_pll->id = id;
> +	dp_pdb = dp_10nm_pll;
> +
> +	dp_10nm_pll->pll_base = msm_ioremap(pdev, "pll_base", "DP_PLL");
> +	if (IS_ERR_OR_NULL(dp_10nm_pll->pll_base)) {
> +		dev_err(&pdev->dev, "failed to map CMN PLL base\n");

Print the error if pll_base is ERR_PTR, same for below.

> +		return ERR_PTR(-ENOMEM);

You should preserve the error if pll_base is an ERR_PTR, same for below.

> +	}
> +
> +	dp_10nm_pll->phy_base = msm_ioremap(pdev, "phy_base", "DP_PHY");
> +	if (IS_ERR_OR_NULL(dp_10nm_pll->phy_base)) {
> +		dev_err(&pdev->dev, "failed to map CMN PHY base\n");
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	dp_10nm_pll->ln_tx0_base = msm_ioremap(pdev, "ln_tx0_base", "DP_LN_TX0");
> +	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx0_base)) {
> +		dev_err(&pdev->dev, "failed to map CMN LN_TX0 base\n");
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	dp_10nm_pll->ln_tx1_base = msm_ioremap(pdev, "ln_tx1_base", "DP_LN_TX1");
> +	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx1_base)) {
> +		dev_err(&pdev->dev, "failed to map CMN LN_TX1 base\n");
> +		return ERR_PTR(-ENOMEM);
> +	}
> +
> +	ret = of_property_read_u32(pdev->dev.of_node, "cell-index",
> +				&dp_10nm_pll->index);
> +	if (ret) {
> +		pr_err("Unable to get the cell-index ret=%d\n", ret);

If this is truly an error condition, we should return an error. If it's not,
downgrade this to info

> +		dp_10nm_pll->index = 0;
> +	}
> +
> +	ret = msm_dp_pll_util_parse_dt_clock(pdev, &dp_10nm_pll->base);
> +	if (ret) {
> +		pr_err("Unable to parse dt clocks ret=%d\n", ret);
> +		return ERR_PTR(ret);
> +	}
> +
> +	ret = dp_pll_10nm_register(dp_10nm_pll);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to register PLL: %d\n", ret);
> +		return ERR_PTR(ret);
> +	}
> +
> +	pll = &dp_10nm_pll->base;
> +	pll->min_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
> +	pll->max_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;
> +	pll->get_provider = dp_pll_10nm_get_provider;
> +
> +	return pll;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
> new file mode 100644
> index 0000000..f966beb
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
> @@ -0,0 +1,94 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef __DP_PLL_10NM_H
> +#define __DP_PLL_10NM_H
> +
> +#include "dp_pll.h"
> +#include "dp_reg.h"
> +
> +#define DP_VCO_HSCLK_RATE_1620MHZDIV1000	1620000UL

Isn't MHZDIV1000 just KHZ? Same for below

> +#define DP_VCO_HSCLK_RATE_2700MHZDIV1000	2700000UL
> +#define DP_VCO_HSCLK_RATE_5400MHZDIV1000	5400000UL
> +#define DP_VCO_HSCLK_RATE_8100MHZDIV1000	8100000UL
> +
> +#define NUM_DP_CLOCKS_MAX			6
> +
> +#define DP_PHY_PLL_POLL_SLEEP_US		500
> +#define DP_PHY_PLL_POLL_TIMEOUT_US		10000

These can go in the c file (and probably the others too)

> +
> +#define DP_VCO_RATE_8100MHZDIV1000		8100000UL
> +#define DP_VCO_RATE_9720MHZDIV1000		9720000UL
> +#define DP_VCO_RATE_10800MHZDIV1000		10800000UL
> +
> +struct dp_pll_10nm {
> +	struct msm_dp_pll base;
> +
> +	int id;
> +	struct platform_device *pdev;
> +
> +	void __iomem *pll_base;
> +	void __iomem *phy_base;
> +	void __iomem *ln_tx0_base;
> +	void __iomem *ln_tx1_base;
> +
> +	/* private clocks: */
> +	struct clk_hw *hws[NUM_DP_CLOCKS_MAX];
> +	u32 num_hws;
> +
> +	/* clock-provider: */
> +	struct clk_hw_onecell_data *hw_data;
> +
> +	/* lane and orientation settings */
> +	u8 lane_cnt;
> +	u8 orientation;
> +
> +	/* COM PHY settings */
> +	u32 hsclk_sel;
> +	u32 dec_start_mode0;
> +	u32 div_frac_start1_mode0;
> +	u32 div_frac_start2_mode0;
> +	u32 div_frac_start3_mode0;
> +	u32 integloop_gain0_mode0;
> +	u32 integloop_gain1_mode0;
> +	u32 vco_tune_map;
> +	u32 lock_cmp1_mode0;
> +	u32 lock_cmp2_mode0;
> +	u32 lock_cmp3_mode0;
> +	u32 lock_cmp_en;
> +
> +	/* PHY vco divider */
> +	u32 phy_vco_div;
> +	/*
> +	 * Certain pll's needs to update the same vco rate after resume in
> +	 * suspend/resume scenario. Cached the vco rate for such plls.
> +	 */
> +	unsigned long	vco_cached_rate;
> +	u32		cached_cfg0;
> +	u32		cached_cfg1;
> +	u32		cached_outdiv;
> +
> +	uint32_t index;
> +};
> +
> +#define to_dp_pll_10nm(x)	container_of(x, struct dp_pll_10nm, base)

typesafe inline pls

> +
> +int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +				unsigned long parent_rate);
> +unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
> +				unsigned long parent_rate);
> +long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +				unsigned long *parent_rate);
> +int dp_vco_prepare_10nm(struct clk_hw *hw);
> +void dp_vco_unprepare_10nm(struct clk_hw *hw);
> +#endif /* __DP_PLL_10NM_H */
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
> new file mode 100644
> index 0000000..9eb6881
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
> @@ -0,0 +1,531 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)	"%s: " fmt, __func__
> +
> +#include <linux/kernel.h>
> +#include <linux/err.h>
> +#include <linux/iopoll.h>
> +#include <linux/delay.h>
> +
> +#include "dp_pll.h"
> +#include "dp_pll_10nm.h"
> +#include "dp_extcon.h"
> +
> +static int dp_vco_pll_init_db_10nm(struct msm_dp_pll *pll,
> +		unsigned long rate)
> +{
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +	u32 spare_value = 0;
> +
> +	spare_value = PLL_REG_R(dp_res->phy_base, DP_PHY_SPARE0);
> +	dp_res->lane_cnt = spare_value & 0x0F;
> +	dp_res->orientation = (spare_value & 0xF0) >> 4;
> +
> +	pr_debug("%s: spare_value=0x%x, ln_cnt=0x%x, orientation=0x%x\n",
> +			__func__, spare_value, dp_res->lane_cnt, dp_res->orientation);
> +
> +	switch (rate) {
> +	case DP_VCO_HSCLK_RATE_1620MHZDIV1000:
> +		pr_debug("%s: VCO rate: %ld\n", __func__,
> +				DP_VCO_RATE_9720MHZDIV1000);
> +		dp_res->hsclk_sel = 0x0c;
> +		dp_res->dec_start_mode0 = 0x69;
> +		dp_res->div_frac_start1_mode0 = 0x00;
> +		dp_res->div_frac_start2_mode0 = 0x80;
> +		dp_res->div_frac_start3_mode0 = 0x07;
> +		dp_res->integloop_gain0_mode0 = 0x3f;
> +		dp_res->integloop_gain1_mode0 = 0x00;
> +		dp_res->vco_tune_map = 0x00;
> +		dp_res->lock_cmp1_mode0 = 0x6f;
> +		dp_res->lock_cmp2_mode0 = 0x08;
> +		dp_res->lock_cmp3_mode0 = 0x00;
> +		dp_res->phy_vco_div = 0x1;
> +		dp_res->lock_cmp_en = 0x00;
> +		break;
> +	case DP_VCO_HSCLK_RATE_2700MHZDIV1000:
> +		pr_debug("%s: VCO rate: %ld\n", __func__,
> +				DP_VCO_RATE_10800MHZDIV1000);
> +		dp_res->hsclk_sel = 0x04;
> +		dp_res->dec_start_mode0 = 0x69;
> +		dp_res->div_frac_start1_mode0 = 0x00;
> +		dp_res->div_frac_start2_mode0 = 0x80;
> +		dp_res->div_frac_start3_mode0 = 0x07;
> +		dp_res->integloop_gain0_mode0 = 0x3f;
> +		dp_res->integloop_gain1_mode0 = 0x00;
> +		dp_res->vco_tune_map = 0x00;
> +		dp_res->lock_cmp1_mode0 = 0x0f;
> +		dp_res->lock_cmp2_mode0 = 0x0e;
> +		dp_res->lock_cmp3_mode0 = 0x00;
> +		dp_res->phy_vco_div = 0x1;
> +		dp_res->lock_cmp_en = 0x00;
> +		break;
> +	case DP_VCO_HSCLK_RATE_5400MHZDIV1000:
> +		pr_debug("%s: VCO rate: %ld\n", __func__,
> +				DP_VCO_RATE_10800MHZDIV1000);
> +		dp_res->hsclk_sel = 0x00;
> +		dp_res->dec_start_mode0 = 0x8c;
> +		dp_res->div_frac_start1_mode0 = 0x00;
> +		dp_res->div_frac_start2_mode0 = 0x00;
> +		dp_res->div_frac_start3_mode0 = 0x0a;
> +		dp_res->integloop_gain0_mode0 = 0x3f;
> +		dp_res->integloop_gain1_mode0 = 0x00;
> +		dp_res->vco_tune_map = 0x00;
> +		dp_res->lock_cmp1_mode0 = 0x1f;
> +		dp_res->lock_cmp2_mode0 = 0x1c;
> +		dp_res->lock_cmp3_mode0 = 0x00;
> +		dp_res->phy_vco_div = 0x2;
> +		dp_res->lock_cmp_en = 0x00;
> +		break;
> +	case DP_VCO_HSCLK_RATE_8100MHZDIV1000:
> +		pr_debug("%s: VCO rate: %ld\n", __func__,
> +				DP_VCO_RATE_8100MHZDIV1000);
> +		dp_res->hsclk_sel = 0x03;
> +		dp_res->dec_start_mode0 = 0x69;
> +		dp_res->div_frac_start1_mode0 = 0x00;
> +		dp_res->div_frac_start2_mode0 = 0x80;
> +		dp_res->div_frac_start3_mode0 = 0x07;
> +		dp_res->integloop_gain0_mode0 = 0x3f;
> +		dp_res->integloop_gain1_mode0 = 0x00;
> +		dp_res->vco_tune_map = 0x00;
> +		dp_res->lock_cmp1_mode0 = 0x2f;
> +		dp_res->lock_cmp2_mode0 = 0x2a;
> +		dp_res->lock_cmp3_mode0 = 0x00;
> +		dp_res->phy_vco_div = 0x0;
> +		dp_res->lock_cmp_en = 0x08;
> +		break;

Since this is all static, a static const lookup table would probably be more
appropriate.

> +	default:
> +		return -EINVAL;

Log this please

> +	}
> +	return 0;
> +}
> +
> +static int dp_config_vco_rate_10nm(struct msm_dp_pll *pll,
> +		unsigned long rate)
> +{
> +	u32 res = 0;
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +	res = dp_vco_pll_init_db_10nm(pll, rate);
> +	if (res) {
> +		pr_err("VCO Init DB failed\n");
> +		return res;
> +	}
> +
> +	if (dp_res->lane_cnt != 4) {
> +		if (dp_res->orientation == ORIENTATION_CC2)
> +			PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x6d);
> +		else
> +			PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x75);
> +	} else {
> +		PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x7d);
> +	}
> +
> +	/* Make sure the PHY register writes are done */
> +	wmb();
> +
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SVS_MODE_CLK_SEL, 0x01);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_EN_SEL, 0x37);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYS_CLK_CTRL, 0x02);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_ENABLE1, 0x0e);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_BUF_ENABLE, 0x06);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_SEL, 0x30);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CMN_CONFIG, 0x02);
> +
> +	/* Different for each clock rates */
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_HSCLK_SEL, dp_res->hsclk_sel);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_DEC_START_MODE0, dp_res->dec_start_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_DIV_FRAC_START1_MODE0, dp_res->div_frac_start1_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_DIV_FRAC_START2_MODE0, dp_res->div_frac_start2_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_DIV_FRAC_START3_MODE0, dp_res->div_frac_start3_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_INTEGLOOP_GAIN0_MODE0, dp_res->integloop_gain0_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_INTEGLOOP_GAIN1_MODE0, dp_res->integloop_gain1_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_VCO_TUNE_MAP, dp_res->vco_tune_map);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_LOCK_CMP1_MODE0, dp_res->lock_cmp1_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_LOCK_CMP2_MODE0, dp_res->lock_cmp2_mode0);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_LOCK_CMP3_MODE0, dp_res->lock_cmp3_mode0);
> +	/* Make sure the PLL register writes are done */
> +	wmb();
> +
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_BG_TIMER, 0x0a);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORECLK_DIV_MODE0, 0x0a);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_VCO_TUNE_CTRL, 0x00);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x3f);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORE_CLK_EN, 0x1f);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_IVCO, 0x07);
> +	PLL_REG_W(dp_res->pll_base,
> +		QSERDES_COM_LOCK_CMP_EN, dp_res->lock_cmp_en);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_CCTRL_MODE0, 0x36);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_RCTRL_MODE0, 0x16);
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_CP_CTRL_MODE0, 0x06);
> +	/* Make sure the PHY register writes are done */
> +	wmb();
> +
> +	if (dp_res->orientation == ORIENTATION_CC2)
> +		PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x4c);
> +	else
> +		PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x5c);
> +	/* Make sure the PLL register writes are done */
> +	wmb();
> +
> +	/* TX Lane configuration */
> +	PLL_REG_W(dp_res->phy_base,
> +			DP_PHY_TX0_TX1_LANE_CTL, 0x05);
> +	PLL_REG_W(dp_res->phy_base,
> +			DP_PHY_TX2_TX3_LANE_CTL, 0x05);
> +
> +	/* TX-0 register configuration */
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_VMODE_CTRL1, 0x40);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_INTERFACE_SELECT, 0x3d);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_CLKBUF_ENABLE, 0x0f);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_RESET_TSYNC_EN, 0x03);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
> +	PLL_REG_W(dp_res->ln_tx0_base,
> +		TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_INTERFACE_MODE, 0x00);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_BAND, 0x4);
> +
> +	/* TX-1 register configuration */
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_VMODE_CTRL1, 0x40);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_INTERFACE_SELECT, 0x3d);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_CLKBUF_ENABLE, 0x0f);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_RESET_TSYNC_EN, 0x03);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
> +	PLL_REG_W(dp_res->ln_tx1_base,
> +		TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_INTERFACE_MODE, 0x00);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_BAND, 0x4);
> +	/* Make sure the PHY register writes are done */
> +	wmb();
> +
> +	/* dependent on the vco frequency */
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_VCO_DIV, dp_res->phy_vco_div);
> +
> +	return res;
> +}
> +
> +static bool dp_10nm_pll_lock_status(struct dp_pll_10nm *dp_res)
> +{
> +	u32 status;
> +	bool pll_locked;
> +
> +	/* poll for PLL lock status */
> +	if (readl_poll_timeout_atomic((dp_res->pll_base +
> +			QSERDES_COM_C_READY_STATUS),
> +			status,
> +			((status & BIT(0)) > 0),
> +			DP_PHY_PLL_POLL_SLEEP_US,
> +			DP_PHY_PLL_POLL_TIMEOUT_US)) {
> +		pr_err("%s: C_READY status is not high. Status=%x\n",
> +				__func__, status);
> +		pll_locked = false;
> +	} else {
> +		pll_locked = true;
> +	}
> +
> +	return pll_locked;
> +}
> +
> +static bool dp_10nm_phy_rdy_status(struct dp_pll_10nm *dp_res)
> +{
> +	u32 status;
> +	bool phy_ready = true;
> +
> +	/* poll for PHY ready status */
> +	if (readl_poll_timeout_atomic((dp_res->phy_base +
> +			DP_PHY_STATUS),
> +			status,
> +			((status & (BIT(1))) > 0),
> +			DP_PHY_PLL_POLL_SLEEP_US,
> +			DP_PHY_PLL_POLL_TIMEOUT_US)) {
> +		pr_err("%s: Phy_ready is not high. Status=%x\n",
> +				__func__, status);
> +		phy_ready = false;
> +	}
> +
> +	return phy_ready;
> +}
> +
> +static int dp_pll_enable_10nm(struct clk_hw *hw)
> +{
> +	int rc = 0;
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +	u32 bias_en, drvr_en;
> +
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_AUX_CFG2, 0x04);
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x05);
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x09);
> +	wmb(); /* Make sure the PHY register writes are done */
> +
> +	PLL_REG_W(dp_res->pll_base, QSERDES_COM_RESETSM_CNTRL, 0x20);
> +	wmb();	/* Make sure the PLL register writes are done */
> +
> +	if (!dp_10nm_pll_lock_status(dp_res)) {
> +		rc = -EINVAL;
> +		goto lock_err;
> +	}
> +
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
> +	/* Make sure the PHY register writes are done */
> +	wmb();
> +	/* poll for PHY ready status */
> +	if (!dp_10nm_phy_rdy_status(dp_res)) {
> +		rc = -EINVAL;
> +		goto lock_err;
> +	}
> +
> +	pr_debug("%s: PLL is locked\n", __func__);
> +
> +	if (dp_res->lane_cnt == 1) {
> +		bias_en = 0x3e;
> +		drvr_en = 0x13;
> +	} else {
> +		bias_en = 0x3f;
> +		drvr_en = 0x10;
> +	}
> +
> +	if (dp_res->lane_cnt != 4) {
> +		if (dp_res->orientation == ORIENTATION_CC1) {
> +			PLL_REG_W(dp_res->ln_tx1_base,
> +				TXn_HIGHZ_DRVR_EN, drvr_en);
> +			PLL_REG_W(dp_res->ln_tx1_base,
> +				TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +		} else {
> +			PLL_REG_W(dp_res->ln_tx0_base,
> +				TXn_HIGHZ_DRVR_EN, drvr_en);
> +			PLL_REG_W(dp_res->ln_tx0_base,
> +				TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +		}
> +	} else {
> +		PLL_REG_W(dp_res->ln_tx0_base, TXn_HIGHZ_DRVR_EN, drvr_en);
> +		PLL_REG_W(dp_res->ln_tx0_base,
> +			TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +		PLL_REG_W(dp_res->ln_tx1_base, TXn_HIGHZ_DRVR_EN, drvr_en);
> +		PLL_REG_W(dp_res->ln_tx1_base,
> +			TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +	}

I think you could probably simplify this code block with a bit of effort,
especially the top condition.

> +
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_POL_INV, 0x0a);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_POL_INV, 0x0a);
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x18);
> +	udelay(2000);

why udelay?

> +
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
> +
> +	/*
> +	 * Make sure all the register writes are completed before
> +	 * doing any other operation
> +	 */
> +	wmb();
> +
> +	/* poll for PHY ready status */
> +	if (!dp_10nm_phy_rdy_status(dp_res)) {
> +		rc = -EINVAL;
> +		goto lock_err;
> +	}
> +
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_DRV_LVL, 0x38);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_DRV_LVL, 0x38);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_EMP_POST1_LVL, 0x20);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_EMP_POST1_LVL, 0x20);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
> +	PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
> +	PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
> +	/* Make sure the PHY register writes are done */
> +	wmb();
> +
> +lock_err:
> +	return rc;

Remove lock_err and return directly above.

> +}
> +
> +static int dp_pll_disable_10nm(struct clk_hw *hw)
> +{
> +	int rc = 0;
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +	/* Assert DP PHY power down */
> +	PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x2);
> +	/*
> +	 * Make sure all the register writes to disable PLL are
> +	 * completed before doing any other operation
> +	 */
> +	wmb();
> +
> +	return rc;
> +}
> +
> +
> +int dp_vco_prepare_10nm(struct clk_hw *hw)
> +{
> +	int rc = 0;
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +	pr_debug("rate=%ld\n", pll->rate);
> +	if ((dp_res->vco_cached_rate != 0)
> +		&& (dp_res->vco_cached_rate == pll->rate)) {


	if (dp_res->vco_cached_rate && dp_res->vco_cached_rate == pll->rate) {


> +		rc = pll->clk_hw.init->ops->set_rate(hw,
> +			dp_res->vco_cached_rate, dp_res->vco_cached_rate);
> +		if (rc) {
> +			pr_err("index=%d vco_set_rate failed. rc=%d\n",
> +				rc, dp_res->index);
> +			goto error;
> +		}
> +	}
> +
> +	rc = dp_pll_enable_10nm(hw);
> +	if (rc) {
> +		pr_err("ndx=%d failed to enable dp pll\n",
> +					dp_res->index);
> +		goto error;
> +	}
> +
> +	pll->pll_on = true;

Do you need locking around the prepare/unprepare functions?


> +error:
> +	return rc;

Same comment as always

> +}
> +
> +void dp_vco_unprepare_10nm(struct clk_hw *hw)
> +{
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +	if (!dp_res) {
> +		pr_err("Invalid input parameter\n");
> +		return;
> +	}
> +
> +	if (!pll->pll_on) {
> +		pr_err("pll resource can't be enabled\n");
> +		return;
> +	}
> +	dp_res->vco_cached_rate = pll->rate;
> +	dp_pll_disable_10nm(hw);
> +
> +	//dp_res->handoff_resources = false;

??

> +	pll->pll_on = false;
> +}
> +
> +int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +					unsigned long parent_rate)
> +{
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	int rc;
> +
> +	pr_debug("DP lane CLK rate=%ld\n", rate);
> +
> +	rc = dp_config_vco_rate_10nm(pll, rate);
> +	if (rc)
> +		pr_err("%s: Failed to set clk rate\n", __func__);

Should you return early here?

> +
> +	pll->rate = rate;
> +
> +	return 0;
> +}
> +
> +unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
> +					unsigned long parent_rate)
> +{
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +	struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +	u32 div, hsclk_div, link_clk_div = 0;
> +	u64 vco_rate;
> +
> +	div = PLL_REG_R(dp_res->pll_base, QSERDES_COM_HSCLK_SEL);
> +	div &= 0x0f;
> +
> +	if (div == 12)
> +		hsclk_div = 6; /* Default */
> +	else if (div == 4)
> +		hsclk_div = 4;
> +	else if (div == 0)
> +		hsclk_div = 2;
> +	else if (div == 3)
> +		hsclk_div = 1;
> +	else {
> +		pr_debug("unknown divider. forcing to default\n");
> +		hsclk_div = 5;
> +	}
> +
> +	div = PLL_REG_R(dp_res->phy_base, DP_PHY_AUX_CFG2);
> +	div >>= 2;
> +
> +	if ((div & 0x3) == 0)
> +		link_clk_div = 5;
> +	else if ((div & 0x3) == 1)
> +		link_clk_div = 10;
> +	else if ((div & 0x3) == 2)
> +		link_clk_div = 20;
> +	else
> +		pr_err("%s: unsupported div. Phy_mode: %d\n", __func__, div);
> +
> +	if (link_clk_div == 20) {
> +		vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +	} else {
> +		if (hsclk_div == 6)
> +			vco_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
> +		else if (hsclk_div == 4)
> +			vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +		else if (hsclk_div == 2)
> +			vco_rate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
> +		else
> +			vco_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;
> +	}
> +
> +	pr_debug("returning vco rate = %lu\n", (unsigned long)vco_rate);
> +
> +	dp_res->vco_cached_rate = pll->rate = vco_rate;
> +	return (unsigned long)vco_rate;

Hopefully this function will become easier to parse with #define'd values

> +}
> +
> +long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +			unsigned long *parent_rate)
> +{
> +	unsigned long rrate = rate;
> +	struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +
> +	if (rate <= pll->min_rate)
> +		rrate = pll->min_rate;
> +	else if (rate <= DP_VCO_HSCLK_RATE_2700MHZDIV1000)
> +		rrate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +	else if (rate <= DP_VCO_HSCLK_RATE_5400MHZDIV1000)
> +		rrate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
> +	else
> +		rrate = pll->max_rate;

You're assuming min_rate is < 2.7MHz and max_rate > 5.4 MHz. This is true in the
current code, but could change in the future. Fortunatley min/max_rate are only
used here. So delete them from the struct and use the DP_VCO_HSCLK_RATE_* values
directly here.

> +
> +	pr_debug("%s: rrate=%ld\n", __func__, rrate);
> +
> +	*parent_rate = rrate;
> +	return rrate;
> +}
> +
> -- 
> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
> a Linux Foundation Collaborative Project
> 

-- 
Sean Paul, Software Engineer, Google / Chromium OS
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

Re: [Freedreno] [DPU PATCH 3/3] drm/msm/dp: add support for DP PLL driver

[Jordan Crouse]

On Thu, Nov 01, 2018 at 05:03:15PM -0400, Sean Paul wrote:
> On Wed, Oct 10, 2018 at 10:15:59AM -0700, Chandan Uddaraju wrote:
> > Add the needed DP PLL specific files to support
> > display port interface on msm targets.
> > 
> > The DP driver calls the DP PLL driver registration.
> > The DP driver sets the link and pixel clock sources.
> > 
> > Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>
> > ---
> >  drivers/gpu/drm/msm/Kconfig                   |  16 +
> >  drivers/gpu/drm/msm/Makefile                  |   6 +
> >  drivers/gpu/drm/msm/dp/dp_ctrl.c              |   1 +
> >  drivers/gpu/drm/msm/dp/dp_display.c           |  50 +++
> >  drivers/gpu/drm/msm/dp/dp_display.h           |   3 +
> >  drivers/gpu/drm/msm/dp/dp_parser.h            |   3 +
> >  drivers/gpu/drm/msm/dp/dp_power.c             |  77 +++-
> >  drivers/gpu/drm/msm/dp/dp_power.h             |   2 +
> >  drivers/gpu/drm/msm/dp/pll/dp_pll.c           | 153 ++++++++
> >  drivers/gpu/drm/msm/dp/pll/dp_pll.h           |  64 ++++
> >  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c      | 401 +++++++++++++++++++
> >  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h      |  94 +++++
> >  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c | 531 ++++++++++++++++++++++++++
> >  13 files changed, 1389 insertions(+), 12 deletions(-)
> >  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.c
> >  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.h
> >  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
> >  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
> >  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c

<snip>

> > +struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
> > +{
> > +	struct dp_pll_10nm *dp_10nm_pll;
> > +	struct msm_dp_pll *pll;
> > +	int ret;
> > +
> > +	if (!pdev)
> > +		return ERR_PTR(-ENODEV);
> > +
> > +	dp_10nm_pll = devm_kzalloc(&pdev->dev, sizeof(*dp_10nm_pll), GFP_KERNEL);
> > +	if (!dp_10nm_pll)
> > +		return ERR_PTR(-ENOMEM);
> > +
> > +	DBG("DP PLL%d", id);
> 
> Please remove (or convert to DRM_DEV_DEBUG)
> 
> > +
> > +	dp_10nm_pll->pdev = pdev;
> > +	dp_10nm_pll->id = id;
> > +	dp_pdb = dp_10nm_pll;
> > +
> > +	dp_10nm_pll->pll_base = msm_ioremap(pdev, "pll_base", "DP_PLL");
> > +	if (IS_ERR_OR_NULL(dp_10nm_pll->pll_base)) {
> > +		dev_err(&pdev->dev, "failed to map CMN PLL base\n");
> 
> Print the error if pll_base is ERR_PTR, same for below.

FWIW the return value from msm_ioremap is always ERR_PTR never NULL. And
msm_ioremap prints error messages on all failures so all you need is:

if (IS_ERR(ptr))
    return ERR_CAST(ptr);

> > +		return ERR_PTR(-ENOMEM);
> 
> You should preserve the error if pll_base is an ERR_PTR, same for below.
> 
> > +	}
> > +
> > +	dp_10nm_pll->phy_base = msm_ioremap(pdev, "phy_base", "DP_PHY");
> > +	if (IS_ERR_OR_NULL(dp_10nm_pll->phy_base)) {
> > +		dev_err(&pdev->dev, "failed to map CMN PHY base\n");
> > +		return ERR_PTR(-ENOMEM);
> > +	}
> > +
> > +	dp_10nm_pll->ln_tx0_base = msm_ioremap(pdev, "ln_tx0_base", "DP_LN_TX0");
> > +	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx0_base)) {
> > +		dev_err(&pdev->dev, "failed to map CMN LN_TX0 base\n");
> > +		return ERR_PTR(-ENOMEM);
> > +	}
> > +
> > +	dp_10nm_pll->ln_tx1_base = msm_ioremap(pdev, "ln_tx1_base", "DP_LN_TX1");
> > +	if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx1_base)) {
> > +		dev_err(&pdev->dev, "failed to map CMN LN_TX1 base\n");
> > +		return ERR_PTR(-ENOMEM);
> > +	}

<snip>

Jordan

-- 
The Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

Re: [DPU PATCH 3/3] drm/msm/dp: add support for DP PLL driver

[Stephen Boyd]

Quoting Sean Paul (2018-11-01 14:03:15)
> On Wed, Oct 10, 2018 at 10:15:59AM -0700, Chandan Uddaraju wrote:
> 
> > +}
> > +
> >  static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
> >  {
> >       int rc = 0;
> > @@ -472,8 +520,12 @@ static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
> >  
> >       power = container_of(dp_power, struct dp_power_private, dp_power);
> >  
> > -     if (power->pixel_clk_rcg && power->pixel_parent)
> > -             clk_set_parent(power->pixel_clk_rcg, power->pixel_parent);
> > +     if (power->pixel_clk_rcg && power->pixel_provider) {
> > +             clk_set_parent(power->pixel_clk_rcg, power->pixel_provider);
> 
> s/pixel_parent/pixel_provider/ isn't related to this change, can you please use
> the final name in the main dp patch so it's correct in this one?
> 
> > +             pr_debug("%s: is the parent of clk=%s\n",
> > +                                     __clk_get_name(power->pixel_provider),
> > +                                     __clk_get_name(power->pixel_clk_rcg));
> 
> Same comment here, this debug can go in the main patch.

Is there any reason why assigned-clock-parents wouldn't work here?

> > diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
> > index d1adaaf..5effd32 100644
> > --- a/drivers/gpu/drm/msm/dp/dp_power.h
> > +++ b/drivers/gpu/drm/msm/dp/dp_power.h
> > @@ -24,6 +24,7 @@
> >   * @init: initializes the regulators/core clocks/GPIOs/pinctrl
> >   * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
> >   * @clk_enable: enable/disable the DP clocks
> > + * @set_link_clk_parent: set the parent of DP link clock
> >   * @set_pixel_clk_parent: set the parent of DP pixel clock
> >   */
> >  struct dp_power {
[...]
> > +
> > +static int clk_mux_determine_rate(struct clk_hw *hw,
> > +                                  struct clk_rate_request *req)
> > +{
> > +     int ret = 0;
> 
> no need to init this to 0
> 
> > +
> > +     ret = __clk_mux_determine_rate_closest(hw, req);
> > +     if (ret)
> > +             return ret;
> > +
> > +     /* Set the new parent of mux if there is a new valid parent */
> > +     if (hw->clk && req->best_parent_hw->clk)
> > +             clk_set_parent(hw->clk, req->best_parent_hw->clk);
> 
> What about the return value? All other clk_set_parent calls in this patch are
> also unchecked, so please add those as well.

The determine_rate clk_op should _never_ change clk hardware. It's a
function that's about determining what rate a clk can support based on
the rate that's requested and what the hardware can do.

Ok, let me just take a pass at the overall clk parts of this patch
instead of doing an "and also" review on Sean's review.

_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 3/3] drm/msm/dp: add support for DP PLL driver

[Stephen Boyd]

This patch is too big. Please split it up more. I have far too many
review comments on it so it will help if you keep splitting the patch up
into smaller parts that can be more easily reviewed and fixed.

Quoting Chandan Uddaraju (2018-10-10 10:15:59)
> diff --git a/drivers/gpu/drm/msm/dp/dp_ctrl.c b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> index 08a52f5..e23beee 100644
> --- a/drivers/gpu/drm/msm/dp/dp_ctrl.c
> +++ b/drivers/gpu/drm/msm/dp/dp_ctrl.c
> @@ -1051,6 +1051,7 @@ static int dp_ctrl_enable_mainlink_clocks(struct dp_ctrl_private *ctrl)
>  {
>         int ret = 0;
>  
> +       ctrl->power->set_link_clk_parent(ctrl->power);
>         ctrl->power->set_pixel_clk_parent(ctrl->power);
>  
>         dp_ctrl_set_clock_rate(ctrl, "ctrl_link_clk",
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.c b/drivers/gpu/drm/msm/dp/dp_display.c
> index 8c98399..2bf6635 100644
> --- a/drivers/gpu/drm/msm/dp/dp_display.c
> +++ b/drivers/gpu/drm/msm/dp/dp_display.c
> @@ -72,6 +72,48 @@ struct dp_display_private {
>         {}
>  };
>  
> +static int dp_get_pll(struct dp_display_private *dp_priv)
> +{
> +       struct platform_device *pdev = NULL;
> +       struct platform_device *pll_pdev;
> +       struct device_node *pll_node;
> +       struct dp_parser *dp_parser = NULL;
> +
> +       if (!dp_priv) {
> +               pr_err("Invalid Arguments\n");
> +               return -EINVAL;
> +       }
> +
> +       pdev = dp_priv->pdev;
> +       dp_parser = dp_priv->parser;
> +
> +       if (!dp_parser) {
> +               pr_err("Parser not initialized.\n");
> +               return -EINVAL;
> +       }
> +
> +       pll_node = of_parse_phandle(pdev->dev.of_node, "pll-node", 0);
> +       if (!pll_node) {
> +               dev_err(&pdev->dev, "cannot find pll device\n");
> +               return -ENXIO;
> +       }
> +
> +       pll_pdev = of_find_device_by_node(pll_node);
> +       if (pll_pdev)
> +               dp_parser->pll = platform_get_drvdata(pll_pdev);
> +
> +       of_node_put(pll_node);
> +
> +       if (!pll_pdev || !dp_parser->pll) {
> +               dev_err(&pdev->dev, "%s: pll driver is not ready\n", __func__);
> +               return -EPROBE_DEFER;
> +       }
> +
> +       dp_parser->pll_dev = get_device(&pll_pdev->dev);

Why do we need this code? Are we working around some lack of ability to
link different devices together by resource requesting?

> +
> +       return 0;
> +}
> +
>  static irqreturn_t dp_display_irq(int irq, void *dev_id)
>  {
>         struct dp_display_private *dp = dev_id;
> @@ -125,6 +167,12 @@ static int dp_display_bind(struct device *dev, struct device *master,
>                 goto end;
>         }
>  
> +       rc = dp_get_pll(dp);
> +       if (rc) {
> +               pr_err(" DP get PLL instance failed\n");
> +               goto end;
> +       }
> +
>         rc = dp->aux->drm_aux_register(dp->aux);
>         if (rc) {
>                 pr_err("DRM DP AUX register failed\n");
> @@ -921,6 +969,7 @@ int __init msm_dp_register(void)
>  {
>         int ret;
>  
> +       msm_dp_pll_driver_register();
>         ret = platform_driver_register(&dp_display_driver);
>         if (ret) {
>                 pr_err("driver register failed");
> @@ -932,6 +981,7 @@ int __init msm_dp_register(void)
>  
>  void __exit msm_dp_unregister(void)
>  {
> +       msm_dp_pll_driver_unregister();
>         platform_driver_unregister(&dp_display_driver);
>  }
>  
> diff --git a/drivers/gpu/drm/msm/dp/dp_display.h b/drivers/gpu/drm/msm/dp/dp_display.h
> index ca5eae5..9cd6a6b 100644
> --- a/drivers/gpu/drm/msm/dp/dp_display.h
> +++ b/drivers/gpu/drm/msm/dp/dp_display.h
> @@ -52,4 +52,7 @@ struct msm_dp {
>  
>  int dp_display_get_num_of_displays(void);
>  int dp_display_get_displays(void **displays, int count);
> +void __init msm_dp_pll_driver_register(void);
> +void __exit msm_dp_pll_driver_unregister(void);

__init and __exit in header files does nothing.

> +
>  #endif /* _DP_DISPLAY_H_ */
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.c b/drivers/gpu/drm/msm/dp/dp_power.c
> index 1d58480..3a1679c 100644
> --- a/drivers/gpu/drm/msm/dp/dp_power.c
> +++ b/drivers/gpu/drm/msm/dp/dp_power.c
> @@ -23,7 +23,9 @@ struct dp_power_private {
>         struct dp_parser *parser;
>         struct platform_device *pdev;
>         struct clk *pixel_clk_rcg;
> -       struct clk *pixel_parent;
> +       struct clk *link_clk_src;
> +       struct clk *pixel_provider;
> +       struct clk *link_provider;
>  
>         struct dp_power dp_power;
>  
> @@ -154,6 +156,16 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
>                 goto exit;
>         }
>  
> +       if (power->parser->pll && power->parser->pll->get_provider) {
> +               rc = power->parser->pll->get_provider(power->parser->pll,
> +                               &power->link_provider, &power->pixel_provider);
> +               if (rc) {
> +                       pr_info("%s: can't get provider from pll, don't set parent\n",
> +                               __func__);
> +                       return 0;
> +               }
> +       }
> +
>         if (enable) {
>                 rc = msm_dss_get_clk(dev, core->clk_config, core->num_clk);
>                 if (rc) {
> @@ -173,17 +185,10 @@ static int dp_power_clk_init(struct dp_power_private *power, bool enable)
>                 if (IS_ERR(power->pixel_clk_rcg)) {
>                         pr_debug("Unable to get DP pixel clk RCG\n");
>                         power->pixel_clk_rcg = NULL;
> -               }
> -
> -               power->pixel_parent = devm_clk_get(dev, "pixel_parent");
> -               if (IS_ERR(power->pixel_parent)) {
> -                       pr_debug("Unable to get DP pixel RCG parent\n");
> -                       power->pixel_parent = NULL;
> +                       rc = -ENODEV;
> +                       goto ctrl_get_error;
>                 }
>         } else {
> -               if (power->pixel_parent)
> -                       devm_clk_put(dev, power->pixel_parent);
> -
>                 if (power->pixel_clk_rcg)
>                         devm_clk_put(dev, power->pixel_clk_rcg);
>  
> @@ -459,6 +464,49 @@ static void dp_power_client_deinit(struct dp_power *dp_power)
>  
>  }
>  
> +static int dp_power_set_link_clk_parent(struct dp_power *dp_power)
> +{
> +       int rc = 0;
> +       struct dp_power_private *power;
> +       u32 num;
> +       struct dss_clk *cfg;
> +       char *name = "ctrl_link_clk";
> +
> +       if (!dp_power) {
> +               pr_err("invalid power data\n");
> +               rc = -EINVAL;
> +               goto exit;
> +       }
> +
> +       power = container_of(dp_power, struct dp_power_private, dp_power);
> +
> +       num = power->parser->mp[DP_CTRL_PM].num_clk;
> +       cfg = power->parser->mp[DP_CTRL_PM].clk_config;
> +
> +       while (num && strcmp(cfg->clk_name, name)) {
> +               num--;
> +               cfg++;
> +       }
> +
> +       if (num && power->link_provider) {
> +               power->link_clk_src = clk_get_parent(cfg->clk);
> +                       if (power->link_clk_src) {
> +                               clk_set_parent(power->link_clk_src, power->link_provider);
> +                               pr_debug("%s: is the parent of clk=%s\n",
> +                                               __clk_get_name(power->link_provider),
> +                                               __clk_get_name(power->link_clk_src));
> +                       } else {
> +                               pr_err("couldn't get parent for clk=%s\n", name);
> +                               rc = -EINVAL;
> +                       }
> +       } else {
> +               pr_err("%s clock could not be set parent\n", name);
> +               rc = -EINVAL;
> +       }

Hopefully this can just be done with assigned-clock-parents.

> +exit:
> +       return rc;
> +}
> +
>  static int dp_power_set_pixel_clk_parent(struct dp_power *dp_power)
>  {
>         int rc = 0;
> diff --git a/drivers/gpu/drm/msm/dp/dp_power.h b/drivers/gpu/drm/msm/dp/dp_power.h
> index d1adaaf..5effd32 100644
> --- a/drivers/gpu/drm/msm/dp/dp_power.h
> +++ b/drivers/gpu/drm/msm/dp/dp_power.h
> @@ -24,6 +24,7 @@
>   * @init: initializes the regulators/core clocks/GPIOs/pinctrl
>   * @deinit: turns off the regulators/core clocks/GPIOs/pinctrl
>   * @clk_enable: enable/disable the DP clocks
> + * @set_link_clk_parent: set the parent of DP link clock
>   * @set_pixel_clk_parent: set the parent of DP pixel clock
>   */
>  struct dp_power {
> @@ -31,6 +32,7 @@ struct dp_power {
>         int (*deinit)(struct dp_power *power);
>         int (*clk_enable)(struct dp_power *power, enum dp_pm_type pm_type,
>                                 bool enable);
> +       int (*set_link_clk_parent)(struct dp_power *power);
>         int (*set_pixel_clk_parent)(struct dp_power *power);

Seeing these clk wrappers is quite scary. Is this driver written with
some sort of linux abstraction layer inside?

>         int (*power_client_init)(struct dp_power *power);
>         void (*power_client_deinit)(struct dp_power *power);
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.c b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
> new file mode 100644
> index 0000000..a8612b5
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.c
> @@ -0,0 +1,153 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include "dp_pll.h"
> +
> +int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
> +                                       struct msm_dp_pll *pll)
> +{
> +       u32 i = 0, rc = 0;
> +       struct dss_module_power *mp = &pll->mp;
> +       const char *clock_name;
> +       u32 clock_rate;
> +
> +       mp->num_clk = of_property_count_strings(pdev->dev.of_node,
> +                                                       "clock-names");
> +       if (mp->num_clk <= 0) {
> +               pr_err("clocks are not defined\n");
> +               goto clk_err;
> +       }
> +
> +       mp->clk_config = devm_kzalloc(&pdev->dev,
> +                       sizeof(struct dss_clk) * mp->num_clk, GFP_KERNEL);
> +       if (!mp->clk_config) {
> +               rc = -ENOMEM;
> +               mp->num_clk = 0;
> +               goto clk_err;
> +       }
> +
> +       for (i = 0; i < mp->num_clk; i++) {
> +               of_property_read_string_index(pdev->dev.of_node, "clock-names",
> +                                                       i, &clock_name);
> +               strlcpy(mp->clk_config[i].clk_name, clock_name,
> +                               sizeof(mp->clk_config[i].clk_name));
> +
> +               of_property_read_u32_index(pdev->dev.of_node, "clock-rate",
> +                                                       i, &clock_rate);
> +               mp->clk_config[i].rate = clock_rate;
> +
> +               if (!clock_rate)
> +                       mp->clk_config[i].type = DSS_CLK_AHB;
> +               else
> +                       mp->clk_config[i].type = DSS_CLK_PCLK;

Is this custom assigned-clock-rates?

> +       }
> +
> +clk_err:
> +       return rc;
> +}
> +
> +struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,
> +                       enum msm_dp_pll_type type, int id)
> +{
> +       struct device *dev = &pdev->dev;
> +       struct msm_dp_pll *pll;
> +
> +       switch (type) {
> +       case MSM_DP_PLL_10NM:
> +               pll = msm_dp_pll_10nm_init(pdev, id);
> +               break;
> +       default:
> +               pll = ERR_PTR(-ENXIO);
> +               break;
> +       }
> +
> +       if (IS_ERR(pll)) {
> +               dev_err(dev, "%s: failed to init DP PLL\n", __func__);
> +               return pll;
> +       }
> +
> +       pll->type = type;
> +
> +       DBG("DP:%d PLL registered", id);
> +
> +       return pll;
> +}
> +
> +static const struct of_device_id dp_pll_dt_match[] = {
> +#ifdef CONFIG_DRM_MSM_DP_10NM_PLL

Don't do this.

> +       { .compatible = "qcom,dp-pll-10nm" },
> +#endif
> +       {}
> +};
> +
> +static int dp_pll_driver_probe(struct platform_device *pdev)
> +{
> +       struct msm_dp_pll *pll;
> +       struct device *dev = &pdev->dev;
> +       const struct of_device_id *match;
> +       enum msm_dp_pll_type type;
> +
> +       match = of_match_node(dp_pll_dt_match, dev->of_node);
> +       if (!match)
> +               return -ENODEV;
> +
> +       if (!strcmp(match->compatible, "qcom,dp-pll-10nm"))
> +               type = MSM_DP_PLL_10NM;
> +       else
> +               type = MSM_DP_PLL_MAX;
> +
> +       pll = msm_dp_pll_init(pdev, type, 0);
> +       if (IS_ERR_OR_NULL(pll)) {

IS_ERR_OR_NULL is typically a bad sign.

> +               dev_info(dev,
> +                       "%s: pll init failed: %ld, need separate pll clk driver\n",
> +                       __func__, PTR_ERR(pll));

Well if it's NULL, then it's not a PTR_ERR.

> +               return -ENODEV;

And then we just overwrite whatever is returned, ouch.

> +       }
> +
> +       platform_set_drvdata(pdev, pll);
> +
> +       return 0;
> +}
> +
> +static int dp_pll_driver_remove(struct platform_device *pdev)
> +{
> +       struct msm_dp_pll *pll = platform_get_drvdata(pdev);
> +
> +       if (pll) {
> +               //msm_dsi_pll_destroy(pll);

Leftovers?

> +               pll = NULL;
> +       }
> +
> +       platform_set_drvdata(pdev, NULL);
> +
> +       return 0;
> +}
> +
> +static struct platform_driver dp_pll_platform_driver = {
> +       .probe      = dp_pll_driver_probe,
> +       .remove     = dp_pll_driver_remove,
> +       .driver     = {
> +               .name   = "msm_dp_pll",
> +               .of_match_table = dp_pll_dt_match,
> +       },
> +};
> +
> +void __init msm_dp_pll_driver_register(void)
> +{
> +       platform_driver_register(&dp_pll_platform_driver);
> +}
> +
> +void __exit msm_dp_pll_driver_unregister(void)
> +{
> +       platform_driver_unregister(&dp_pll_platform_driver);
> +}

Consider module_platform_driver()? Why is this directly probed from
somewhere else? Some sort of DPU design?

> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll.h b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
> new file mode 100644
> index 0000000..d52a81a
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll.h
> @@ -0,0 +1,64 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef __DP_PLL_H
> +#define __DP_PLL_H
> +
> +#include <linux/clk.h>
> +#include <linux/clk-provider.h>

Typically a bad sign to see a clk provider and consumer in the same
place.

> +#include <linux/platform_device.h>
> +
> +#include "dpu_io_util.h"
> +#include "msm_drv.h"
> +
> +#define PLL_REG_W(base, offset, data)  \
> +                               writel_relaxed((data), (base) + (offset))
> +#define PLL_REG_R(base, offset)        readl_relaxed((base) + (offset))

Can't we just use writel and readl directly?

> +
> +enum msm_dp_pll_type {
> +       MSM_DP_PLL_10NM,
> +       MSM_DP_PLL_MAX
> +};
> +
> +struct msm_dp_pll {
> +       enum msm_dp_pll_type type;
> +       struct clk_hw clk_hw;
> +       unsigned long   rate;           /* current vco rate */

Why are we duplicating what is known to the framework?

> +       u64             min_rate;       /* min vco rate */
> +       u64             max_rate;       /* max vco rate */

Use clk_hw_set_rate_range?

> +       bool            pll_on;

More duplicating of what clk framework knows?

> +       void            *priv;
> +       /* Pll specific resources like GPIO, power supply, clocks, etc*/
> +       struct dss_module_power mp;
> +       int (*get_provider)(struct msm_dp_pll *pll,
> +                       struct clk **link_clk_provider,
> +                       struct clk **pixel_clk_provider);
> +};
> +
> +#define hw_clk_to_pll(x) container_of(x, struct msm_dp_pll, clk_hw)

Usually this would be called to_msm_dp_pll().

> +
> +struct msm_dp_pll *msm_dp_pll_init(struct platform_device *pdev,
> +                       enum msm_dp_pll_type type, int id);
> +
> +int msm_dp_pll_util_parse_dt_clock(struct platform_device *pdev,
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
> new file mode 100644
> index 0000000..a180413
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
> @@ -0,0 +1,401 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +/*
> + * Display Port PLL driver block diagram for branch clocks
> + *
> + *             +------------------------------+
> + *             |         DP_VCO_CLK           |
> + *             |                              |
> + *             |    +-------------------+     |
> + *             |    |   (DP PLL/VCO)    |     |
> + *             |    +---------+---------+     |
> + *             |              v               |
> + *             |   +----------+-----------+   |
> + *             |   | hsclk_divsel_clk_src |   |
> + *             |   +----------+-----------+   |

Is this a divider?

> + *             +------------------------------+
> + *                             |
> + *      +------------<---------v------------>----------+
> + *      |                                              |
> + * +-----v------------+                                 |
> + * | dp_link_clk_src  |                                 |
> + * |    divsel_ten    |                                 |
> + * +---------+--------+                                 |

And dispcc gets a fixed div-10 on the output of the PLL divider?

> + *     |                                               |
> + *     |                                               |
> + *     v                                               v
> + * Input to DISPCC block                                |
> + * for link clk, crypto clk                             |
> + * and interface clock                                  |
> + *                                                     |
> + *                                                     |
> + *     +--------<------------+-----------------+---<---+
> + *     |                     |                 |
> + * +-------v------+  +--------v-----+  +--------v------+
> + * | vco_divided  |  | vco_divided  |  | vco_divided   |
> + * |    _clk_src  |  |    _clk_src  |  |    _clk_src   |
> + * |              |  |              |  |               |
> + * |divsel_six    |  |  divsel_two  |  |  divsel_four  |
> + * +-------+------+  +-----+--------+  +--------+------+
> + *         |              |                    |
> + *     v------->----------v-------------<------v
> + *                         |
> + *             +----------+---------+
> + *             |   vco_divided_clk  |
> + *             |       _src_mux     |
> + *             +---------+----------+
> + *                        |
> + *                        v
> + *              Input to DISPCC block
> + *              for DP pixel clock
> + *
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/err.h>
> +#include <linux/delay.h>
> +#include <linux/regmap.h>
> +#include <linux/clk.h>

I'd expect clk-provider.h here, instead of clk.h

> +
> +#include "dp_pll_10nm.h"
> +
> +#define NUM_PROVIDED_CLKS              2
> +
> +#define DP_LINK_CLK_SRC                        0
> +#define DP_PIXEL_CLK_SRC               1
> +
> +static struct dp_pll_10nm *dp_pdb;
> +
> +/* Op structures */

Drop useless comments please.

> +static const struct clk_ops dp_10nm_vco_clk_ops = {
> +       .recalc_rate = dp_vco_recalc_rate_10nm,
> +       .set_rate = dp_vco_set_rate_10nm,
> +       .round_rate = dp_vco_round_rate_10nm,
> +       .prepare = dp_vco_prepare_10nm,
> +       .unprepare = dp_vco_unprepare_10nm,
> +};
> +
> +struct dp_pll_10nm_pclksel {
> +       struct clk_hw hw;
> +
> +       /* divider params */
> +       u8 shift;
> +       u8 width;
> +       u8 flags; /* same flags as used by clk_divider struct */
> +
> +       struct dp_pll_10nm *pll;
> +};
> +#define to_pll_10nm_pclksel(_hw) container_of(_hw, struct dp_pll_10nm_pclksel, hw)
> +
> +static int dp_mux_set_parent_10nm(struct clk_hw *hw, u8 val)
> +{
> +       struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
> +       struct dp_pll_10nm *dp_res = pclksel->pll;
> +       u32 auxclk_div;
> +
> +       auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
> +       auxclk_div &= ~0x03;    /* bits 0 to 1 */
> +
> +       if (val == 0) /* mux parent index = 0 */
> +               auxclk_div |= 1;
> +       else if (val == 1) /* mux parent index = 1 */
> +               auxclk_div |= 2;
> +       else if (val == 2) /* mux parent index = 2 */
> +               auxclk_div |= 0;

Is this really a mux? It looks like it's a divider that divides the PLL
frequency down. Why add in an extra level of set_parent things when we
could just as easily do division and call up to parent with some
multiplied rate?

> +
> +       PLL_REG_W(dp_res->phy_base,
> +                       DP_PHY_VCO_DIV, auxclk_div);
> +       /* Make sure the PHY registers writes are done */

Which this wmb() doesn't do.

> +       wmb();
> +       pr_debug("%s: mux=%d auxclk_div=%x\n", __func__, val, auxclk_div);
> +
> +       return 0;
> +}
> +
> +static u8 dp_mux_get_parent_10nm(struct clk_hw *hw)
> +{
> +       u32 auxclk_div = 0;
> +       struct dp_pll_10nm_pclksel *pclksel = to_pll_10nm_pclksel(hw);
> +       struct dp_pll_10nm *dp_res = pclksel->pll;
> +       u8 val = 0;
> +
> +       pr_err("clk_hw->init->name = %s\n", hw->init->name);
> +       auxclk_div = PLL_REG_R(dp_res->phy_base, DP_PHY_VCO_DIV);
> +       auxclk_div &= 0x03;
> +
> +       if (auxclk_div == 1) /* Default divider */
> +               val = 0;
> +       else if (auxclk_div == 2)
> +               val = 1;
> +       else if (auxclk_div == 0)
> +               val = 2;
> +
> +       pr_debug("%s: auxclk_div=%d, val=%d\n", __func__, auxclk_div, val);
> +
> +       return val;

Yes, all very odd!

> +}
> +
> +static int clk_mux_determine_rate(struct clk_hw *hw,
> +                                    struct clk_rate_request *req)
> +{
> +       int ret = 0;
> +
> +       ret = __clk_mux_determine_rate_closest(hw, req);
> +       if (ret)
> +               return ret;
> +
> +       /* Set the new parent of mux if there is a new valid parent */
> +       if (hw->clk && req->best_parent_hw->clk)
> +               clk_set_parent(hw->clk, req->best_parent_hw->clk);

No idea what this is, but again we shouldn't be touching the hardware in
determine_rate, and we certainly shouldn't be using clk consumer APIs
from within clk provider ops.

> +
> +       return 0;
> +}
> +
> +static unsigned long mux_recalc_rate(struct clk_hw *hw,
> +                                       unsigned long parent_rate)
> +{
> +       struct clk *div_clk = NULL, *vco_clk = NULL;
> +       struct msm_dp_pll *vco = NULL;
> +
> +       div_clk = clk_get_parent(hw->clk);
> +       if (!div_clk)
> +               return 0;
> +
> +       vco_clk = clk_get_parent(div_clk);
> +       if (!vco_clk)
> +               return 0;
> +
> +       vco = hw_clk_to_pll(__clk_get_hw(vco_clk));
> +       if (!vco)
> +               return 0;

All this parent checking should go away.

> +
> +       if (vco->rate == DP_VCO_HSCLK_RATE_8100MHZDIV1000)
> +               return (vco->rate / 6);
> +       else if (vco->rate == DP_VCO_HSCLK_RATE_5400MHZDIV1000)
> +               return (vco->rate / 4);
> +       else
> +               return (vco->rate / 2);

I'd expect the recalc_rate callback to read some hardware register and
figure out what rate is coming through the clk. This doesn't look to be
doing that. Instead it's reaching up two levels and then looking at some
cached rate inside there to figure out what rate is coming here? That is
weird.

> +}
> +
> +static int dp_pll_10nm_get_provider(struct msm_dp_pll *pll,
> +                                    struct clk **link_clk_provider,
> +                                    struct clk **pixel_clk_provider)
> +{
> +       struct dp_pll_10nm *pll_10nm = to_dp_pll_10nm(pll);
> +       struct clk_hw_onecell_data *hw_data = pll_10nm->hw_data;
> +
> +       if (link_clk_provider)
> +               *link_clk_provider = hw_data->hws[DP_LINK_CLK_SRC]->clk;
> +       if (pixel_clk_provider)
> +               *pixel_clk_provider = hw_data->hws[DP_PIXEL_CLK_SRC]->clk;
> +
> +       return 0;
> +}

I don't know what this function is for, but it looks like some weird
wrapper around kernel things which just makes for more reading and less
transferable knowledge because we have to learn how different drivers
decide to wrap kernel constructs.

> +
> +static const struct clk_ops dp_10nm_pclksel_clk_ops = {
> +       .get_parent = dp_mux_get_parent_10nm,
> +       .set_parent = dp_mux_set_parent_10nm,
> +       .recalc_rate = mux_recalc_rate,
> +       .determine_rate = clk_mux_determine_rate,
> +};
> +
> +static struct clk_hw *dp_pll_10nm_pixel_clk_sel(struct dp_pll_10nm *pll_10nm)
> +{
> +       struct device *dev = &pll_10nm->pdev->dev;
> +       struct dp_pll_10nm_pclksel *pll_pclksel;
> +       struct clk_init_data pclksel_init = {
> +               .parent_names = (const char *[]){
> +                               "dp_vco_divsel_two_clk_src",
> +                               "dp_vco_divsel_four_clk_src",
> +                               "dp_vco_divsel_six_clk_src" },

As I said earlier, this should probably just be a divider and not a mux.

> +               .num_parents = 3,
> +               .name = "dp_vco_divided_clk_src_mux",
> +               .flags = CLK_IGNORE_UNUSED,

Why have this flag? Seems like a workaround for some problem, but who
knows what that problem is.

> +               .ops = &dp_10nm_pclksel_clk_ops,
> +       };
> +       int ret;
> +
> +       pll_pclksel = devm_kzalloc(dev, sizeof(*pll_pclksel), GFP_KERNEL);
> +       if (!pll_pclksel)
> +               return ERR_PTR(-ENOMEM);
> +
> +       pll_pclksel->pll = pll_10nm;
> +       pll_pclksel->shift = 0;
> +       pll_pclksel->width = 4;
> +       pll_pclksel->flags = CLK_DIVIDER_ONE_BASED;

And it is a divider? But not really?

> +       pll_pclksel->hw.init = &pclksel_init;
> +
> +       ret = clk_hw_register(dev, &pll_pclksel->hw);
> +       if (ret)
> +               return ERR_PTR(ret);
> +
> +       return &pll_pclksel->hw;
> +}
> +
> +static int dp_pll_10nm_register(struct dp_pll_10nm *pll_10nm)
> +{
> +       char clk_name[32], parent[32], vco_name[32];
> +       struct clk_init_data vco_init = {
> +               .parent_names = (const char *[]){ "bi_tcxo" },
> +               .num_parents = 1,
> +               .name = vco_name,
> +               .flags = CLK_IGNORE_UNUSED,
> +               .ops = &dp_10nm_vco_clk_ops,
> +       };
> +       struct device *dev = &pll_10nm->pdev->dev;
> +       struct clk_hw **hws = pll_10nm->hws;
> +       struct clk_hw_onecell_data *hw_data;
> +       struct clk_hw *hw;
> +       int num = 0;
> +       int ret;
> +
> +       DBG("DP->id = %d", pll_10nm->id);
> +
> +       hw_data = devm_kzalloc(dev, sizeof(*hw_data) +
> +                              NUM_PROVIDED_CLKS * sizeof(struct clk_hw *),
> +                              GFP_KERNEL);
> +       if (!hw_data)
> +               return -ENOMEM;
> +
> +       snprintf(vco_name, 32, "dp_vco_clk");
> +       pll_10nm->base.clk_hw.init = &vco_init;
> +       ret = clk_hw_register(dev, &pll_10nm->base.clk_hw);
> +       if (ret)
> +               return ret;
> +       hws[num++] = &pll_10nm->base.clk_hw;
> +
> +       snprintf(clk_name, 32, "dp_link_clk_divsel_ten");
> +       snprintf(parent, 32, "dp_vco_clk");

Why are we snprintf strings that are static? Why not just pass them in
places they're used?

> +       hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +                                         CLK_SET_RATE_PARENT, 1, 10);
> +       if (IS_ERR(hw))
> +               return PTR_ERR(hw);
> +       hws[num++] = hw;
> +       hw_data->hws[DP_LINK_CLK_SRC] = hw;
> +
> +       snprintf(clk_name, 32, "dp_vco_divsel_two_clk_src");
> +       snprintf(parent, 32, "dp_vco_clk");
> +       hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +                                         0, 1, 2);
> +       if (IS_ERR(hw))
> +               return PTR_ERR(hw);
> +       hws[num++] = hw;
> +
> +       snprintf(clk_name, 32, "dp_vco_divsel_four_clk_src");
> +       snprintf(parent, 32, "dp_vco_clk");
> +       hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +                                         0, 1, 4);
> +       if (IS_ERR(hw))
> +               return PTR_ERR(hw);
> +       hws[num++] = hw;
> +
> +       snprintf(clk_name, 32, "dp_vco_divsel_six_clk_src");
> +       snprintf(parent, 32, "dp_vco_clk");
> +       hw = clk_hw_register_fixed_factor(dev, clk_name, parent,
> +                                         0, 1, 6);
> +       if (IS_ERR(hw))
> +               return PTR_ERR(hw);
> +       hws[num++] = hw;
> +
> +       hw = dp_pll_10nm_pixel_clk_sel(pll_10nm);
> +       if (IS_ERR(hw))
> +               return PTR_ERR(hw);
> +
> +       hws[num++] = hw;
> +       hw_data->hws[DP_PIXEL_CLK_SRC] = hw;

The good news is that this should be sharply reduced by implementing a
divider instead of fixed dividers that a virtual mux picks from.

> +
> +       pll_10nm->num_hws = num;
> +
> +       hw_data->num = NUM_PROVIDED_CLKS;
> +       pll_10nm->hw_data = hw_data;
> +
> +       ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
> +                                    pll_10nm->hw_data);
> +       if (ret) {
> +               dev_err(dev, "failed to register clk provider: %d\n", ret);
> +               return ret;
> +       }
> +
> +       return ret;
> +}
> +
> +struct msm_dp_pll *msm_dp_pll_10nm_init(struct platform_device *pdev, int id)
> +{
> +       struct dp_pll_10nm *dp_10nm_pll;
> +       struct msm_dp_pll *pll;
> +       int ret;
> +
> +       if (!pdev)
> +               return ERR_PTR(-ENODEV);
> +
> +       dp_10nm_pll = devm_kzalloc(&pdev->dev, sizeof(*dp_10nm_pll), GFP_KERNEL);
> +       if (!dp_10nm_pll)
> +               return ERR_PTR(-ENOMEM);
> +
> +       DBG("DP PLL%d", id);
> +
> +       dp_10nm_pll->pdev = pdev;
> +       dp_10nm_pll->id = id;
> +       dp_pdb = dp_10nm_pll;
> +
> +       dp_10nm_pll->pll_base = msm_ioremap(pdev, "pll_base", "DP_PLL");
> +       if (IS_ERR_OR_NULL(dp_10nm_pll->pll_base)) {
> +               dev_err(&pdev->dev, "failed to map CMN PLL base\n");
> +               return ERR_PTR(-ENOMEM);
> +       }
> +
> +       dp_10nm_pll->phy_base = msm_ioremap(pdev, "phy_base", "DP_PHY");
> +       if (IS_ERR_OR_NULL(dp_10nm_pll->phy_base)) {
> +               dev_err(&pdev->dev, "failed to map CMN PHY base\n");
> +               return ERR_PTR(-ENOMEM);
> +       }
> +
> +       dp_10nm_pll->ln_tx0_base = msm_ioremap(pdev, "ln_tx0_base", "DP_LN_TX0");
> +       if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx0_base)) {
> +               dev_err(&pdev->dev, "failed to map CMN LN_TX0 base\n");
> +               return ERR_PTR(-ENOMEM);
> +       }
> +
> +       dp_10nm_pll->ln_tx1_base = msm_ioremap(pdev, "ln_tx1_base", "DP_LN_TX1");
> +       if (IS_ERR_OR_NULL(dp_10nm_pll->ln_tx1_base)) {
> +               dev_err(&pdev->dev, "failed to map CMN LN_TX1 base\n");
> +               return ERR_PTR(-ENOMEM);
> +       }
> +
> +       ret = of_property_read_u32(pdev->dev.of_node, "cell-index",
> +                               &dp_10nm_pll->index);
> +       if (ret) {
> +               pr_err("Unable to get the cell-index ret=%d\n", ret);
> +               dp_10nm_pll->index = 0;
> +       }
> +
> +       ret = msm_dp_pll_util_parse_dt_clock(pdev, &dp_10nm_pll->base);
> +       if (ret) {
> +               pr_err("Unable to parse dt clocks ret=%d\n", ret);
> +               return ERR_PTR(ret);
> +       }
> +
> +       ret = dp_pll_10nm_register(dp_10nm_pll);
> +       if (ret) {
> +               dev_err(&pdev->dev, "failed to register PLL: %d\n", ret);
> +               return ERR_PTR(ret);
> +       }
> +
> +       pll = &dp_10nm_pll->base;
> +       pll->min_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
> +       pll->max_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;

Pass this to the framework with clk_hw_set_rate_range() and let the
common clk framework clamp min/max for you.

> +       pll->get_provider = dp_pll_10nm_get_provider;
> +
> +       return pll;
> +}
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
> new file mode 100644
> index 0000000..f966beb
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
> @@ -0,0 +1,94 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#ifndef __DP_PLL_10NM_H
> +#define __DP_PLL_10NM_H
> +
> +#include "dp_pll.h"
> +#include "dp_reg.h"
> +
> +#define DP_VCO_HSCLK_RATE_1620MHZDIV1000       1620000UL
> +#define DP_VCO_HSCLK_RATE_2700MHZDIV1000       2700000UL
> +#define DP_VCO_HSCLK_RATE_5400MHZDIV1000       5400000UL
> +#define DP_VCO_HSCLK_RATE_8100MHZDIV1000       8100000UL
> +
> +#define NUM_DP_CLOCKS_MAX                      6
> +
> +#define DP_PHY_PLL_POLL_SLEEP_US               500
> +#define DP_PHY_PLL_POLL_TIMEOUT_US             10000
> +
> +#define DP_VCO_RATE_8100MHZDIV1000             8100000UL
> +#define DP_VCO_RATE_9720MHZDIV1000             9720000UL
> +#define DP_VCO_RATE_10800MHZDIV1000            10800000UL
> +
> +struct dp_pll_10nm {
> +       struct msm_dp_pll base;
> +
> +       int id;
> +       struct platform_device *pdev;
> +
> +       void __iomem *pll_base;
> +       void __iomem *phy_base;
> +       void __iomem *ln_tx0_base;
> +       void __iomem *ln_tx1_base;
> +
> +       /* private clocks: */
> +       struct clk_hw *hws[NUM_DP_CLOCKS_MAX];
> +       u32 num_hws;
> +
> +       /* clock-provider: */
> +       struct clk_hw_onecell_data *hw_data;
> +
> +       /* lane and orientation settings */
> +       u8 lane_cnt;
> +       u8 orientation;
> +
> +       /* COM PHY settings */
> +       u32 hsclk_sel;
> +       u32 dec_start_mode0;
> +       u32 div_frac_start1_mode0;
> +       u32 div_frac_start2_mode0;
> +       u32 div_frac_start3_mode0;
> +       u32 integloop_gain0_mode0;
> +       u32 integloop_gain1_mode0;
> +       u32 vco_tune_map;
> +       u32 lock_cmp1_mode0;
> +       u32 lock_cmp2_mode0;
> +       u32 lock_cmp3_mode0;
> +       u32 lock_cmp_en;
> +
> +       /* PHY vco divider */
> +       u32 phy_vco_div;
> +       /*
> +        * Certain pll's needs to update the same vco rate after resume in

PLLs is plural, not possessive.

> +        * suspend/resume scenario. Cached the vco rate for such plls.

There you go!

> +        */
> +       unsigned long   vco_cached_rate;
> +       u32             cached_cfg0;
> +       u32             cached_cfg1;
> +       u32             cached_outdiv;

Is this to restore across suspend/resume?

> +
> +       uint32_t index;

We use u32 in kernel code, not uint32_t.

> +};
> +
> +#define to_dp_pll_10nm(x)      container_of(x, struct dp_pll_10nm, base)
> +
> +int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +                               unsigned long parent_rate);
> +unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
> +                               unsigned long parent_rate);
> +long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +                               unsigned long *parent_rate);
> +int dp_vco_prepare_10nm(struct clk_hw *hw);
> +void dp_vco_unprepare_10nm(struct clk_hw *hw);
> +#endif /* __DP_PLL_10NM_H */
> diff --git a/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
> new file mode 100644
> index 0000000..9eb6881
> --- /dev/null
> +++ b/drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c
> @@ -0,0 +1,531 @@
> +/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#define pr_fmt(fmt)    "%s: " fmt, __func__
> +
> +#include <linux/kernel.h>
> +#include <linux/err.h>
> +#include <linux/iopoll.h>
> +#include <linux/delay.h>

Where's clk-provider.h?

> +
> +#include "dp_pll.h"
> +#include "dp_pll_10nm.h"
> +#include "dp_extcon.h"

Is this used?

> +
> +static int dp_vco_pll_init_db_10nm(struct msm_dp_pll *pll,
> +               unsigned long rate)
> +{
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +       u32 spare_value = 0;
> +
> +       spare_value = PLL_REG_R(dp_res->phy_base, DP_PHY_SPARE0);
> +       dp_res->lane_cnt = spare_value & 0x0F;
> +       dp_res->orientation = (spare_value & 0xF0) >> 4;
> +
> +       pr_debug("%s: spare_value=0x%x, ln_cnt=0x%x, orientation=0x%x\n",
> +                       __func__, spare_value, dp_res->lane_cnt, dp_res->orientation);
> +
> +       switch (rate) {
> +       case DP_VCO_HSCLK_RATE_1620MHZDIV1000:
> +               pr_debug("%s: VCO rate: %ld\n", __func__,
> +                               DP_VCO_RATE_9720MHZDIV1000);

These debug prints don't match the case statement above. Why?

> +               dp_res->hsclk_sel = 0x0c;
> +               dp_res->dec_start_mode0 = 0x69;
> +               dp_res->div_frac_start1_mode0 = 0x00;
> +               dp_res->div_frac_start2_mode0 = 0x80;
> +               dp_res->div_frac_start3_mode0 = 0x07;
> +               dp_res->integloop_gain0_mode0 = 0x3f;
> +               dp_res->integloop_gain1_mode0 = 0x00;
> +               dp_res->vco_tune_map = 0x00;
> +               dp_res->lock_cmp1_mode0 = 0x6f;
> +               dp_res->lock_cmp2_mode0 = 0x08;
> +               dp_res->lock_cmp3_mode0 = 0x00;
> +               dp_res->phy_vco_div = 0x1;
> +               dp_res->lock_cmp_en = 0x00;
> +               break;
> +       case DP_VCO_HSCLK_RATE_2700MHZDIV1000:
> +               pr_debug("%s: VCO rate: %ld\n", __func__,
> +                               DP_VCO_RATE_10800MHZDIV1000);
> +               dp_res->hsclk_sel = 0x04;
> +               dp_res->dec_start_mode0 = 0x69;
> +               dp_res->div_frac_start1_mode0 = 0x00;
> +               dp_res->div_frac_start2_mode0 = 0x80;
> +               dp_res->div_frac_start3_mode0 = 0x07;
> +               dp_res->integloop_gain0_mode0 = 0x3f;
> +               dp_res->integloop_gain1_mode0 = 0x00;
> +               dp_res->vco_tune_map = 0x00;
> +               dp_res->lock_cmp1_mode0 = 0x0f;
> +               dp_res->lock_cmp2_mode0 = 0x0e;
> +               dp_res->lock_cmp3_mode0 = 0x00;
> +               dp_res->phy_vco_div = 0x1;
> +               dp_res->lock_cmp_en = 0x00;
> +               break;
> +       case DP_VCO_HSCLK_RATE_5400MHZDIV1000:
> +               pr_debug("%s: VCO rate: %ld\n", __func__,
> +                               DP_VCO_RATE_10800MHZDIV1000);
> +               dp_res->hsclk_sel = 0x00;
> +               dp_res->dec_start_mode0 = 0x8c;
> +               dp_res->div_frac_start1_mode0 = 0x00;
> +               dp_res->div_frac_start2_mode0 = 0x00;
> +               dp_res->div_frac_start3_mode0 = 0x0a;
> +               dp_res->integloop_gain0_mode0 = 0x3f;
> +               dp_res->integloop_gain1_mode0 = 0x00;
> +               dp_res->vco_tune_map = 0x00;
> +               dp_res->lock_cmp1_mode0 = 0x1f;
> +               dp_res->lock_cmp2_mode0 = 0x1c;
> +               dp_res->lock_cmp3_mode0 = 0x00;
> +               dp_res->phy_vco_div = 0x2;
> +               dp_res->lock_cmp_en = 0x00;
> +               break;
> +       case DP_VCO_HSCLK_RATE_8100MHZDIV1000:
> +               pr_debug("%s: VCO rate: %ld\n", __func__,
> +                               DP_VCO_RATE_8100MHZDIV1000);

Ah this one matches though.

> +               dp_res->hsclk_sel = 0x03;
> +               dp_res->dec_start_mode0 = 0x69;
> +               dp_res->div_frac_start1_mode0 = 0x00;
> +               dp_res->div_frac_start2_mode0 = 0x80;
> +               dp_res->div_frac_start3_mode0 = 0x07;
> +               dp_res->integloop_gain0_mode0 = 0x3f;
> +               dp_res->integloop_gain1_mode0 = 0x00;
> +               dp_res->vco_tune_map = 0x00;
> +               dp_res->lock_cmp1_mode0 = 0x2f;
> +               dp_res->lock_cmp2_mode0 = 0x2a;
> +               dp_res->lock_cmp3_mode0 = 0x00;
> +               dp_res->phy_vco_div = 0x0;
> +               dp_res->lock_cmp_en = 0x08;
> +               break;
> +       default:
> +               return -EINVAL;
> +       }
> +       return 0;
> +}
> +
> +static int dp_config_vco_rate_10nm(struct msm_dp_pll *pll,
> +               unsigned long rate)
> +{
> +       u32 res = 0;
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +       res = dp_vco_pll_init_db_10nm(pll, rate);
> +       if (res) {
> +               pr_err("VCO Init DB failed\n");
> +               return res;
> +       }
> +
> +       if (dp_res->lane_cnt != 4) {
> +               if (dp_res->orientation == ORIENTATION_CC2)
> +                       PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x6d);
> +               else
> +                       PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x75);
> +       } else {
> +               PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x7d);
> +       }
> +
> +       /* Make sure the PHY register writes are done */
> +       wmb();
> +
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_SVS_MODE_CLK_SEL, 0x01);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_EN_SEL, 0x37);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYS_CLK_CTRL, 0x02);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_ENABLE1, 0x0e);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_SYSCLK_BUF_ENABLE, 0x06);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CLK_SEL, 0x30);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CMN_CONFIG, 0x02);

All these lines could be much shorter with a local variable, 'base',
that got assigned once at the start and then used throughout.

> +
> +       /* Different for each clock rates */
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_HSCLK_SEL, dp_res->hsclk_sel);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_DEC_START_MODE0, dp_res->dec_start_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_DIV_FRAC_START1_MODE0, dp_res->div_frac_start1_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_DIV_FRAC_START2_MODE0, dp_res->div_frac_start2_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_DIV_FRAC_START3_MODE0, dp_res->div_frac_start3_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_INTEGLOOP_GAIN0_MODE0, dp_res->integloop_gain0_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_INTEGLOOP_GAIN1_MODE0, dp_res->integloop_gain1_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_VCO_TUNE_MAP, dp_res->vco_tune_map);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_LOCK_CMP1_MODE0, dp_res->lock_cmp1_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_LOCK_CMP2_MODE0, dp_res->lock_cmp2_mode0);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_LOCK_CMP3_MODE0, dp_res->lock_cmp3_mode0);
> +       /* Make sure the PLL register writes are done */
> +       wmb();

Is this to make sure that the next register writes happen after the
above register writes? The comment could say that instead, but then
realize that they may be sitting somewhere in the bus waiting to write
to the device still, so if it really has to be written to the device we
need to read back the last register written to be sure that the write
posted to the device.

> +
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_BG_TIMER, 0x0a);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORECLK_DIV_MODE0, 0x0a);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_VCO_TUNE_CTRL, 0x00);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_BIAS_EN_CLKBUFLR_EN, 0x3f);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CORE_CLK_EN, 0x1f);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_IVCO, 0x07);
> +       PLL_REG_W(dp_res->pll_base,
> +               QSERDES_COM_LOCK_CMP_EN, dp_res->lock_cmp_en);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_CCTRL_MODE0, 0x36);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_PLL_RCTRL_MODE0, 0x16);
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_CP_CTRL_MODE0, 0x06);
> +       /* Make sure the PHY register writes are done */
> +       wmb();
> +
> +       if (dp_res->orientation == ORIENTATION_CC2)
> +               PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x4c);
> +       else
> +               PLL_REG_W(dp_res->phy_base, DP_PHY_MODE, 0x5c);
> +       /* Make sure the PLL register writes are done */
> +       wmb();
> +
> +       /* TX Lane configuration */
> +       PLL_REG_W(dp_res->phy_base,
> +                       DP_PHY_TX0_TX1_LANE_CTL, 0x05);
> +       PLL_REG_W(dp_res->phy_base,
> +                       DP_PHY_TX2_TX3_LANE_CTL, 0x05);
> +
> +       /* TX-0 register configuration */
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_VMODE_CTRL1, 0x40);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_INTERFACE_SELECT, 0x3d);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_CLKBUF_ENABLE, 0x0f);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_RESET_TSYNC_EN, 0x03);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
> +       PLL_REG_W(dp_res->ln_tx0_base,
> +               TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_INTERFACE_MODE, 0x00);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_BAND, 0x4);
> +
> +       /* TX-1 register configuration */
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TRANSCEIVER_BIAS_EN, 0x1a);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_VMODE_CTRL1, 0x40);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_PRE_STALL_LDO_BOOST_EN, 0x30);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_INTERFACE_SELECT, 0x3d);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_CLKBUF_ENABLE, 0x0f);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_RESET_TSYNC_EN, 0x03);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TRAN_DRVR_EMP_EN, 0x03);
> +       PLL_REG_W(dp_res->ln_tx1_base,
> +               TXn_PARRATE_REC_DETECT_IDLE_EN, 0x00);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_INTERFACE_MODE, 0x00);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_BAND, 0x4);
> +       /* Make sure the PHY register writes are done */
> +       wmb();
> +
> +       /* dependent on the vco frequency */
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_VCO_DIV, dp_res->phy_vco_div);
> +
> +       return res;
> +}
> +
> +static bool dp_10nm_pll_lock_status(struct dp_pll_10nm *dp_res)
> +{
> +       u32 status;
> +       bool pll_locked;
> +
> +       /* poll for PLL lock status */
> +       if (readl_poll_timeout_atomic((dp_res->pll_base +

Why atomic? As far as I can tell this is done in sleepable context
because it all falls into clk_prepare() path.

> +                       QSERDES_COM_C_READY_STATUS),
> +                       status,
> +                       ((status & BIT(0)) > 0),
> +                       DP_PHY_PLL_POLL_SLEEP_US,
> +                       DP_PHY_PLL_POLL_TIMEOUT_US)) {
> +               pr_err("%s: C_READY status is not high. Status=%x\n",
> +                               __func__, status);
> +               pll_locked = false;

Just 'return false'?

> +       } else {
> +               pll_locked = true;
> +       }
> +
> +       return pll_locked;

And reduce this to 'return true'?

> +}
> +
> +static bool dp_10nm_phy_rdy_status(struct dp_pll_10nm *dp_res)
> +{
> +       u32 status;
> +       bool phy_ready = true;
> +
> +       /* poll for PHY ready status */
> +       if (readl_poll_timeout_atomic((dp_res->phy_base +

No need for atomic?

> +                       DP_PHY_STATUS),
> +                       status,
> +                       ((status & (BIT(1))) > 0),
> +                       DP_PHY_PLL_POLL_SLEEP_US,
> +                       DP_PHY_PLL_POLL_TIMEOUT_US)) {
> +               pr_err("%s: Phy_ready is not high. Status=%x\n",
> +                               __func__, status);
> +               phy_ready = false;
> +       }
> +
> +       return phy_ready;
> +}
> +
> +static int dp_pll_enable_10nm(struct clk_hw *hw)
> +{
> +       int rc = 0;
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +       u32 bias_en, drvr_en;
> +
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_AUX_CFG2, 0x04);
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x05);
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x01);
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x09);
> +       wmb(); /* Make sure the PHY register writes are done */
> +
> +       PLL_REG_W(dp_res->pll_base, QSERDES_COM_RESETSM_CNTRL, 0x20);
> +       wmb();  /* Make sure the PLL register writes are done */
> +
> +       if (!dp_10nm_pll_lock_status(dp_res)) {
> +               rc = -EINVAL;
> +               goto lock_err;
> +       }
> +
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
> +       /* Make sure the PHY register writes are done */
> +       wmb();
> +       /* poll for PHY ready status */
> +       if (!dp_10nm_phy_rdy_status(dp_res)) {
> +               rc = -EINVAL;
> +               goto lock_err;
> +       }
> +
> +       pr_debug("%s: PLL is locked\n", __func__);
> +
> +       if (dp_res->lane_cnt == 1) {
> +               bias_en = 0x3e;
> +               drvr_en = 0x13;
> +       } else {
> +               bias_en = 0x3f;
> +               drvr_en = 0x10;
> +       }
> +
> +       if (dp_res->lane_cnt != 4) {
> +               if (dp_res->orientation == ORIENTATION_CC1) {
> +                       PLL_REG_W(dp_res->ln_tx1_base,
> +                               TXn_HIGHZ_DRVR_EN, drvr_en);
> +                       PLL_REG_W(dp_res->ln_tx1_base,
> +                               TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +               } else {
> +                       PLL_REG_W(dp_res->ln_tx0_base,
> +                               TXn_HIGHZ_DRVR_EN, drvr_en);
> +                       PLL_REG_W(dp_res->ln_tx0_base,
> +                               TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +               }
> +       } else {
> +               PLL_REG_W(dp_res->ln_tx0_base, TXn_HIGHZ_DRVR_EN, drvr_en);
> +               PLL_REG_W(dp_res->ln_tx0_base,
> +                       TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +               PLL_REG_W(dp_res->ln_tx1_base, TXn_HIGHZ_DRVR_EN, drvr_en);
> +               PLL_REG_W(dp_res->ln_tx1_base,
> +                       TXn_TRANSCEIVER_BIAS_EN, bias_en);
> +       }
> +
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_POL_INV, 0x0a);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_POL_INV, 0x0a);
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x18);
> +       udelay(2000);

What are we waiting for? You need an explicit readl() if you're waiting
for that DP_PHY_CFG write to post and do something.

> +
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_CFG, 0x19);
> +
> +       /*
> +        * Make sure all the register writes are completed before
> +        * doing any other operation
> +        */
> +       wmb();
> +
> +       /* poll for PHY ready status */
> +       if (!dp_10nm_phy_rdy_status(dp_res)) {
> +               rc = -EINVAL;
> +               goto lock_err;
> +       }
> +
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_DRV_LVL, 0x38);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_DRV_LVL, 0x38);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_TX_EMP_POST1_LVL, 0x20);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_TX_EMP_POST1_LVL, 0x20);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_TX, 0x06);
> +       PLL_REG_W(dp_res->ln_tx0_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
> +       PLL_REG_W(dp_res->ln_tx1_base, TXn_RES_CODE_LANE_OFFSET_RX, 0x07);
> +       /* Make sure the PHY register writes are done */
> +       wmb();
> +
> +lock_err:
> +       return rc;
> +}
> +
> +static int dp_pll_disable_10nm(struct clk_hw *hw)
> +{
> +       int rc = 0;
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +       /* Assert DP PHY power down */
> +       PLL_REG_W(dp_res->phy_base, DP_PHY_PD_CTL, 0x2);
> +       /*
> +        * Make sure all the register writes to disable PLL are
> +        * completed before doing any other operation
> +        */
> +       wmb();
> +
> +       return rc;
> +}
> +
> +
> +int dp_vco_prepare_10nm(struct clk_hw *hw)
> +{
> +       int rc = 0;
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +       pr_debug("rate=%ld\n", pll->rate);
> +       if ((dp_res->vco_cached_rate != 0)
> +               && (dp_res->vco_cached_rate == pll->rate)) {
> +               rc = pll->clk_hw.init->ops->set_rate(hw,
> +                       dp_res->vco_cached_rate, dp_res->vco_cached_rate);
> +               if (rc) {
> +                       pr_err("index=%d vco_set_rate failed. rc=%d\n",
> +                               rc, dp_res->index);
> +                       goto error;

Please just return instead of goto return.

> +               }
> +       }
> +
> +       rc = dp_pll_enable_10nm(hw);
> +       if (rc) {
> +               pr_err("ndx=%d failed to enable dp pll\n",
> +                                       dp_res->index);
> +               goto error;
> +       }
> +
> +       pll->pll_on = true;
> +error:
> +       return rc;
> +}
> +
> +void dp_vco_unprepare_10nm(struct clk_hw *hw)
> +{
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +
> +       if (!dp_res) {
> +               pr_err("Invalid input parameter\n");
> +               return;
> +       }
> +
> +       if (!pll->pll_on) {
> +               pr_err("pll resource can't be enabled\n");
> +               return;
> +       }
> +       dp_res->vco_cached_rate = pll->rate;

Why are we caching rates on unprepare? I'd think we would want to save
away the rate regardless of on/off state and then restore the rate when
the device is powered back on. That wouldn't necessarily follow the on/off state.

> +       dp_pll_disable_10nm(hw);
> +
> +       //dp_res->handoff_resources = false;

Please remove commented out code.

> +       pll->pll_on = false;
> +}
> +
> +int dp_vco_set_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +                                       unsigned long parent_rate)
> +{
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       int rc;
> +
> +       pr_debug("DP lane CLK rate=%ld\n", rate);
> +
> +       rc = dp_config_vco_rate_10nm(pll, rate);
> +       if (rc)
> +               pr_err("%s: Failed to set clk rate\n", __func__);
> +
> +       pll->rate = rate;
> +
> +       return 0;
> +}
> +
> +unsigned long dp_vco_recalc_rate_10nm(struct clk_hw *hw,
> +                                       unsigned long parent_rate)
> +{
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +       struct dp_pll_10nm *dp_res = to_dp_pll_10nm(pll);
> +       u32 div, hsclk_div, link_clk_div = 0;
> +       u64 vco_rate;
> +
> +       div = PLL_REG_R(dp_res->pll_base, QSERDES_COM_HSCLK_SEL);
> +       div &= 0x0f;
> +
> +       if (div == 12)
> +               hsclk_div = 6; /* Default */
> +       else if (div == 4)
> +               hsclk_div = 4;
> +       else if (div == 0)
> +               hsclk_div = 2;
> +       else if (div == 3)
> +               hsclk_div = 1;
> +       else {
> +               pr_debug("unknown divider. forcing to default\n");
> +               hsclk_div = 5;
> +       }
> +
> +       div = PLL_REG_R(dp_res->phy_base, DP_PHY_AUX_CFG2);
> +       div >>= 2;
> +
> +       if ((div & 0x3) == 0)
> +               link_clk_div = 5;
> +       else if ((div & 0x3) == 1)
> +               link_clk_div = 10;
> +       else if ((div & 0x3) == 2)
> +               link_clk_div = 20;
> +       else
> +               pr_err("%s: unsupported div. Phy_mode: %d\n", __func__, div);
> +
> +       if (link_clk_div == 20) {
> +               vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +       } else {
> +               if (hsclk_div == 6)
> +                       vco_rate = DP_VCO_HSCLK_RATE_1620MHZDIV1000;
> +               else if (hsclk_div == 4)
> +                       vco_rate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +               else if (hsclk_div == 2)
> +                       vco_rate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
> +               else
> +                       vco_rate = DP_VCO_HSCLK_RATE_8100MHZDIV1000;
> +       }
> +
> +       pr_debug("returning vco rate = %lu\n", (unsigned long)vco_rate);
> +
> +       dp_res->vco_cached_rate = pll->rate = vco_rate;
> +       return (unsigned long)vco_rate;
> +}
> +
> +long dp_vco_round_rate_10nm(struct clk_hw *hw, unsigned long rate,
> +                       unsigned long *parent_rate)

Implement determine_rate op instead. It lets you clamp rates better.

> +{
> +       unsigned long rrate = rate;
> +       struct msm_dp_pll *pll = hw_clk_to_pll(hw);
> +
> +       if (rate <= pll->min_rate)
> +               rrate = pll->min_rate;
> +       else if (rate <= DP_VCO_HSCLK_RATE_2700MHZDIV1000)
> +               rrate = DP_VCO_HSCLK_RATE_2700MHZDIV1000;
> +       else if (rate <= DP_VCO_HSCLK_RATE_5400MHZDIV1000)
> +               rrate = DP_VCO_HSCLK_RATE_5400MHZDIV1000;
> +       else
> +               rrate = pll->max_rate;
> +
> +       pr_debug("%s: rrate=%ld\n", __func__, rrate);
> +
> +       *parent_rate = rrate;
> +       return rrate;

This whole function looks not very useful though. Just pass up the rate
to the parent and have it do the rounding?

_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno

Re: [DPU PATCH 0/3] Add support for DisplayPort driver on SnapDragon 845

[Jeykumar Sankaran]

On 2018-10-10 10:15, Chandan Uddaraju wrote:
> These patches add support for Display-Port driver on SnapDragon 845
> hardware. It adds
> DP driver and DP PLL driver files along with the needed device-tree
> bindings.
> 
> The block diagram of DP driver is shown below:
> 
> 
>                  +-------------+
>                  |DRM FRAMEWORK|
>                  +------+------+
>                         |
>                    +----v----+
>                    | DP DRM  |
>                    +----+----+
>                         |
>                    +----v----+
>      +------------+|   DP    +----------++------+
>      +        +---+| DISPLAY |+---+      |      |
>      |        +    +-+-----+-+    |      |      |
>      |        |      |     |      |      |      |
>      |        |      |     |      |      |      |
>      |        |      |     |      |      |      |
>      v        v      v     v      v      v      v
>  +------+ +------+ +---+ +----+ +----+ +---+ +-----+
>  |  DP  | |  DP  | |DP | | DP | | DP | |DP | | DP  |
>  |PARSER| |EXTCON| |AUX| |LINK| |CTRL| |PHY| |POWER|
>  +--+---+ +---+--+ +---+ +----+ +--+-+ +-+-+ +-----+
>     |         |                    |     |
>  +--v---+ +---v-----+             +v-----v+
>  |DEVICE| |EXTCON   |             |  DP   |
>  | TREE | |INTERFACE|             |CATALOG|
>  +------+ +---------+             +---+---+
>                                       |
>                                   +---v----+
>                                   |CTRL/PHY|
>                                   |   HW   |
>                                   +--------+
> 
It will be more helpful to have this block diagram in

[DPU PATCH 2/3] drm/msm/dp: add displayPort driver support

Thanks,
Jeykumar S.


> 
> These patches have dependency on clock driver changes mentioned below:
> https://patchwork.kernel.org/patch/10632753/
> https://patchwork.kernel.org/patch/10632757/
> 
> 
> 
> Chandan Uddaraju (3):
>   dt-bindings: msm/dp: add bindings of DP/DP-PLL driver for Snapdragon
>     845
>   drm/msm/dp: add displayPort driver support
>   drm/msm/dp: add support for DP PLL driver
> 
>  .../devicetree/bindings/display/msm/dp.txt         |  249 ++++
>  .../devicetree/bindings/display/msm/dpu.txt        |   16 +-
>  drivers/gpu/drm/msm/Kconfig                        |   25 +
>  drivers/gpu/drm/msm/Makefile                       |   21 +-
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c        |  206 +++
>  drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.h        |   44 +
>  drivers/gpu/drm/msm/dp/dp_aux.c                    |  570 +++++++
>  drivers/gpu/drm/msm/dp/dp_aux.h                    |   44 +
>  drivers/gpu/drm/msm/dp/dp_catalog.c                | 1188 
> +++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_catalog.h                |  144 ++
>  drivers/gpu/drm/msm/dp/dp_ctrl.c                   | 1476
> +++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_ctrl.h                   |   50 +
>  drivers/gpu/drm/msm/dp/dp_debug.c                  |  507 +++++++
>  drivers/gpu/drm/msm/dp/dp_debug.h                  |   81 +
>  drivers/gpu/drm/msm/dp/dp_display.c                | 1027 
> +++++++++++++
>  drivers/gpu/drm/msm/dp/dp_display.h                |   58 +
>  drivers/gpu/drm/msm/dp/dp_drm.c                    |  542 +++++++
>  drivers/gpu/drm/msm/dp/dp_drm.h                    |   52 +
>  drivers/gpu/drm/msm/dp/dp_extcon.c                 |  400 +++++
>  drivers/gpu/drm/msm/dp/dp_extcon.h                 |  111 ++
>  drivers/gpu/drm/msm/dp/dp_link.c                   | 1549
> ++++++++++++++++++++
>  drivers/gpu/drm/msm/dp/dp_link.h                   |  184 +++
>  drivers/gpu/drm/msm/dp/dp_panel.c                  |  624 ++++++++
>  drivers/gpu/drm/msm/dp/dp_panel.h                  |  121 ++
>  drivers/gpu/drm/msm/dp/dp_parser.c                 |  679 +++++++++
>  drivers/gpu/drm/msm/dp/dp_parser.h                 |  208 +++
>  drivers/gpu/drm/msm/dp/dp_power.c                  |  652 ++++++++
>  drivers/gpu/drm/msm/dp/dp_power.h                  |   59 +
>  drivers/gpu/drm/msm/dp/dp_reg.h                    |  357 +++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll.c                |  153 ++
>  drivers/gpu/drm/msm/dp/pll/dp_pll.h                |   64 +
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c           |  401 +++++
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h           |   94 ++
>  drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c      |  531 +++++++
>  drivers/gpu/drm/msm/msm_drv.c                      |    2 +
>  drivers/gpu/drm/msm/msm_drv.h                      |   22 +
>  include/drm/drm_dp_helper.h                        |   19 +
>  37 files changed, 12525 insertions(+), 5 deletions(-)
>  create mode 100644 
> Documentation/devicetree/bindings/display/msm/dp.txt
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_aux.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_catalog.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_ctrl.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_debug.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_display.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_drm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_extcon.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_link.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_panel.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_parser.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.c
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_power.h
>  create mode 100644 drivers/gpu/drm/msm/dp/dp_reg.h
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.c
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll.h
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.c
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm.h
>  create mode 100644 drivers/gpu/drm/msm/dp/pll/dp_pll_10nm_util.c

-- 
Jeykumar S
_______________________________________________
Freedreno mailing list
Freedreno@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/freedreno