Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0d5320fc authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge tag 'tilcdc-4.10' of https://github.com/jsarha/linux into drm-next 

tilcdc changes for v4.10

* tag 'tilcdc-4.10' of https://github.com/jsarha/linux: (23 commits)
  drm/tilcdc: fix parsing of some DT properties
  drm/tilcdc: Enable frame done irq and functionality for LCDC rev 1
  drm/tilcdc: Configure video mode to HW in enable() not in mode_set_nofb()
  drm/tilcdc: Load palette at the end of mode_set_nofb()
  drm/tilcdc: Add timeout wait for palette loading to complete
  drm/tilcdc: Enable palette loading for revision 2 LCDC too
  drm/tilcdc: Fix load mode bit-field setting in tilcdc_crtc_enable()
  drm/tilcdc: Add tilcdc_write_mask() to tilcdc_regs.h
  drm/tilcdc: Fix tilcdc_crtc_create() return value handling
  drm/tilcdc: implement palette loading for rev1
  drm/tilcdc: Enable sync lost error and recovery handling for rev 1 LCDC
  drm/tilcdc: Add drm bridge support for attaching drm bridge drivers
  drm/bridge: Add ti-tfp410 DVI transmitter driver
  dt-bindings: Move "ti,tfp410.txt" from display/ti to display/bridge
  drm/tilcdc: Recover from sync lost error flood by resetting the LCDC
  drm/tilcdc: Fix race from forced shutdown of crtc in unload
  drm/tilcdc: Use unload to handle initialization failures
  drm/tilcdc: Stop using struct drm_driver load() callback
  drm/tilcdc: Remove obsolete drm_connector_register() calls
  drm/tilcdc: Correct misspelling in error message
  ...
parents f5590134 0186fcce

Documentation/devicetree/bindings/display/ti/ti,tfp410.txt→Documentation/devicetree/bindings/display/bridge/ti,tfp410.txt

+7 −2
Original line number Diff line number Diff line
@@ -6,10 +6,15 @@ Required properties: 


Optional properties:

- powerdown-gpios: power-down gpio

- reg: I2C address. If and only if present the device node

       should be placed into the i2c controller node where the

       tfp410 i2c is connected to.



Required nodes:

- Video port 0 for DPI input

- Video port 1 for DVI output

- Video port 0 for DPI input [1].

- Video port 1 for DVI output [1].



[1]: Documentation/devicetree/bindings/media/video-interfaces.txt



Example

-------

Documentation/devicetree/bindings/display/tilcdc/tilcdc.txt

+4 −2
Original line number Diff line number Diff line 
Device-Tree bindings for tilcdc DRM driver



Required properties:

 - compatible: value should be "ti,am33xx-tilcdc".

 - compatible: value should be one of the following:

    - "ti,am33xx-tilcdc" for AM335x based boards

    - "ti,da850-tilcdc" for DA850/AM18x/OMAP-L138 based boards

 - interrupts: the interrupt number

 - reg: base address and size of the LCDC device
@@ -51,7 +53,7 @@ Optional nodes: 
Example:



	fb: fb@4830e000 {

		compatible = "ti,am33xx-tilcdc";

		compatible = "ti,am33xx-tilcdc", "ti,da850-tilcdc";

		reg = <0x4830e000 0x1000>;

		interrupt-parent = <&intc>;

		interrupts = <36>;

drivers/gpu/drm/bridge/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -90,6 +90,13 @@ config DRM_TOSHIBA_TC358767 
	---help---

	  Toshiba TC358767 eDP bridge chip driver.



config DRM_TI_TFP410

	tristate "TI TFP410 DVI/HDMI bridge"

	depends on OF

	select DRM_KMS_HELPER

	---help---

	  Texas Instruments TFP410 DVI/HDMI Transmitter driver



source "drivers/gpu/drm/bridge/analogix/Kconfig"



source "drivers/gpu/drm/bridge/adv7511/Kconfig"

drivers/gpu/drm/bridge/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -12,3 +12,4 @@ obj-$(CONFIG_DRM_SII902X) += sii902x.o 
obj-$(CONFIG_DRM_TOSHIBA_TC358767) += tc358767.o

obj-$(CONFIG_DRM_ANALOGIX_DP) += analogix/

obj-$(CONFIG_DRM_I2C_ADV7511) += adv7511/

obj-$(CONFIG_DRM_TI_TFP410) += ti-tfp410.o

drivers/gpu/drm/bridge/ti-tfp410.c

0 → 100644
+317 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 Texas Instruments

 * Author: Jyri Sarha <jsarha@ti.com>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 as published by

 * the Free Software Foundation.

 *

 */



#include <linux/module.h>

#include <linux/of_graph.h>

#include <linux/platform_device.h>

#include <linux/i2c.h>



#include <drm/drmP.h>

#include <drm/drm_atomic_helper.h>

#include <drm/drm_crtc.h>

#include <drm/drm_crtc_helper.h>



struct tfp410 {

	struct drm_bridge	bridge;

	struct drm_connector	connector;



	struct i2c_adapter	*ddc;



	struct device *dev;

};



static inline struct tfp410 *

drm_bridge_to_tfp410(struct drm_bridge *bridge)

{

	return container_of(bridge, struct tfp410, bridge);

}



static inline struct tfp410 *

drm_connector_to_tfp410(struct drm_connector *connector)

{

	return container_of(connector, struct tfp410, connector);

}



static int tfp410_get_modes(struct drm_connector *connector)

{

	struct tfp410 *dvi = drm_connector_to_tfp410(connector);

	struct edid *edid;

	int ret;



	if (!dvi->ddc)

		goto fallback;



	edid = drm_get_edid(connector, dvi->ddc);

	if (!edid) {

		DRM_INFO("EDID read failed. Fallback to standard modes\n");

		goto fallback;

	}



	drm_mode_connector_update_edid_property(connector, edid);



	return drm_add_edid_modes(connector, edid);

fallback:

	/* No EDID, fallback on the XGA standard modes */

	ret = drm_add_modes_noedid(connector, 1920, 1200);



	/* And prefer a mode pretty much anything can handle */

	drm_set_preferred_mode(connector, 1024, 768);



	return ret;

}



static const struct drm_connector_helper_funcs tfp410_con_helper_funcs = {

	.get_modes	= tfp410_get_modes,

};



static enum drm_connector_status

tfp410_connector_detect(struct drm_connector *connector, bool force)

{

	struct tfp410 *dvi = drm_connector_to_tfp410(connector);



	if (dvi->ddc) {

		if (drm_probe_ddc(dvi->ddc))

			return connector_status_connected;

		else

			return connector_status_disconnected;

	}



	return connector_status_unknown;

}



static const struct drm_connector_funcs tfp410_con_funcs = {

	.dpms			= drm_atomic_helper_connector_dpms,

	.detect			= tfp410_connector_detect,

	.fill_modes		= drm_helper_probe_single_connector_modes,

	.destroy		= drm_connector_cleanup,

	.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 int tfp410_attach(struct drm_bridge *bridge)

{

	struct tfp410 *dvi = drm_bridge_to_tfp410(bridge);

	int ret;



	if (!bridge->encoder) {

		dev_err(dvi->dev, "Missing encoder\n");

		return -ENODEV;

	}



	drm_connector_helper_add(&dvi->connector,

				 &tfp410_con_helper_funcs);

	ret = drm_connector_init(bridge->dev, &dvi->connector,

				 &tfp410_con_funcs, DRM_MODE_CONNECTOR_HDMIA);

	if (ret) {

		dev_err(dvi->dev, "drm_connector_init() failed: %d\n", ret);

		return ret;

	}



	drm_mode_connector_attach_encoder(&dvi->connector,

					  bridge->encoder);



	return 0;

}



static const struct drm_bridge_funcs tfp410_bridge_funcs = {

	.attach		= tfp410_attach,

};



static int tfp410_get_connector_ddc(struct tfp410 *dvi)

{

	struct device_node *ep = NULL, *connector_node = NULL;

	struct device_node *ddc_phandle = NULL;

	int ret = 0;



	/* port@1 is the connector node */

	ep = of_graph_get_endpoint_by_regs(dvi->dev->of_node, 1, -1);

	if (!ep)

		goto fail;



	connector_node = of_graph_get_remote_port_parent(ep);

	if (!connector_node)

		goto fail;



	ddc_phandle = of_parse_phandle(connector_node, "ddc-i2c-bus", 0);

	if (!ddc_phandle)

		goto fail;



	dvi->ddc = of_get_i2c_adapter_by_node(ddc_phandle);

	if (dvi->ddc)

		dev_info(dvi->dev, "Connector's ddc i2c bus found\n");

	else

		ret = -EPROBE_DEFER;



fail:

	of_node_put(ep);

	of_node_put(connector_node);

	of_node_put(ddc_phandle);

	return ret;

}



static int tfp410_init(struct device *dev)

{

	struct tfp410 *dvi;

	int ret;



	if (!dev->of_node) {

		dev_err(dev, "device-tree data is missing\n");

		return -ENXIO;

	}



	dvi = devm_kzalloc(dev, sizeof(*dvi), GFP_KERNEL);

	if (!dvi)

		return -ENOMEM;

	dev_set_drvdata(dev, dvi);



	dvi->bridge.funcs = &tfp410_bridge_funcs;

	dvi->bridge.of_node = dev->of_node;

	dvi->dev = dev;



	ret = tfp410_get_connector_ddc(dvi);

	if (ret)

		goto fail;



	ret = drm_bridge_add(&dvi->bridge);

	if (ret) {

		dev_err(dev, "drm_bridge_add() failed: %d\n", ret);

		goto fail;

	}



	return 0;

fail:

	i2c_put_adapter(dvi->ddc);

	return ret;

}



static int tfp410_fini(struct device *dev)

{

	struct tfp410 *dvi = dev_get_drvdata(dev);



	drm_bridge_remove(&dvi->bridge);



	if (dvi->ddc)

		i2c_put_adapter(dvi->ddc);



	return 0;

}



static int tfp410_probe(struct platform_device *pdev)

{

	return tfp410_init(&pdev->dev);

}



static int tfp410_remove(struct platform_device *pdev)

{

	return tfp410_fini(&pdev->dev);

}



static const struct of_device_id tfp410_match[] = {

	{ .compatible = "ti,tfp410" },

	{},

};

MODULE_DEVICE_TABLE(of, tfp410_match);



struct platform_driver tfp410_platform_driver = {

	.probe	= tfp410_probe,

	.remove	= tfp410_remove,

	.driver	= {

		.name		= "tfp410-bridge",

		.of_match_table	= tfp410_match,

	},

};



#if IS_ENABLED(CONFIG_I2C)

/* There is currently no i2c functionality. */

static int tfp410_i2c_probe(struct i2c_client *client,

			    const struct i2c_device_id *id)

{

	int reg;



	if (!client->dev.of_node ||

	    of_property_read_u32(client->dev.of_node, "reg", &reg)) {

		dev_err(&client->dev,

			"Can't get i2c reg property from device-tree\n");

		return -ENXIO;

	}



	return tfp410_init(&client->dev);

}



static int tfp410_i2c_remove(struct i2c_client *client)

{

	return tfp410_fini(&client->dev);

}



static const struct i2c_device_id tfp410_i2c_ids[] = {

	{ "tfp410", 0 },

	{ }

};

MODULE_DEVICE_TABLE(i2c, tfp410_i2c_ids);



static struct i2c_driver tfp410_i2c_driver = {

	.driver = {

		.name	= "tfp410",

		.of_match_table = of_match_ptr(tfp410_match),

	},

	.id_table	= tfp410_i2c_ids,

	.probe		= tfp410_i2c_probe,

	.remove		= tfp410_i2c_remove,

};

#endif /* IS_ENABLED(CONFIG_I2C) */



static struct {

	uint i2c:1;

	uint platform:1;

}  tfp410_registered_driver;



static int __init tfp410_module_init(void)

{

	int ret;



#if IS_ENABLED(CONFIG_I2C)

	ret = i2c_add_driver(&tfp410_i2c_driver);

	if (ret)

		pr_err("%s: registering i2c driver failed: %d",

		       __func__, ret);

	else

		tfp410_registered_driver.i2c = 1;

#endif



	ret = platform_driver_register(&tfp410_platform_driver);

	if (ret)

		pr_err("%s: registering platform driver failed: %d",

		       __func__, ret);

	else

		tfp410_registered_driver.platform = 1;



	if (tfp410_registered_driver.i2c ||

	    tfp410_registered_driver.platform)

		return 0;



	return ret;

}

module_init(tfp410_module_init);



static void __exit tfp410_module_exit(void)

{

#if IS_ENABLED(CONFIG_I2C)

	if (tfp410_registered_driver.i2c)

		i2c_del_driver(&tfp410_i2c_driver);

#endif

	if (tfp410_registered_driver.platform)

		platform_driver_unregister(&tfp410_platform_driver);

}

module_exit(tfp410_module_exit);



MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");

MODULE_DESCRIPTION("TI TFP410 DVI bridge driver");

MODULE_LICENSE("GPL");