Merge branch 'tda998x-devel' of git://ftp.arm.linux.org.uk/~rmk/linux-cubox into drm-next (920f9464) · Commits · 戴 / test

Documentation/devicetree/bindings/drm/i2c/tda998x.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -3,6 +3,8 @@ Device-Tree bindings for the NXP TDA998x HDMI transmitter
		Required properties;
		- compatible: must be "nxp,tda998x"

		- reg: I2C address

		Optional properties:
		- interrupts: interrupt number and trigger type
		default: polling

drivers/gpu/drm/i2c/tda998x_drv.c

+306 −81

Original line number	Diff line number	Diff line
		@@ -15,8 +15,7 @@
		* this program. If not, see <http://www.gnu.org/licenses/>.
		*/



		#include <linux/component.h>
		#include <linux/hdmi.h>
		#include <linux/module.h>
		#include <linux/irq.h>
		@@ -730,12 +729,9 @@ tda998x_configure_audio(struct tda998x_priv *priv,

		/* DRM encoder functions */

		static void
		tda998x_encoder_set_config(struct drm_encoder encoder, void params)
		static void tda998x_encoder_set_config(struct tda998x_priv *priv,
		const struct tda998x_encoder_params *p)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		struct tda998x_encoder_params *p = params;

		priv->vip_cntrl_0 = VIP_CNTRL_0_SWAP_A(p->swap_a) \|
		(p->mirr_a ? VIP_CNTRL_0_MIRR_A : 0) \|
		VIP_CNTRL_0_SWAP_B(p->swap_b) \|
		@@ -752,11 +748,8 @@ tda998x_encoder_set_config(struct drm_encoder encoder, void params)
		priv->params = *p;
		}

		static void
		tda998x_encoder_dpms(struct drm_encoder *encoder, int mode)
		static void tda998x_encoder_dpms(struct tda998x_priv *priv, int mode)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);

		/* we only care about on or off: */
		if (mode != DRM_MODE_DPMS_ON)
		mode = DRM_MODE_DPMS_OFF;
		@@ -806,8 +799,7 @@ tda998x_encoder_mode_fixup(struct drm_encoder *encoder,
		return true;
		}

		static int
		tda998x_encoder_mode_valid(struct drm_encoder *encoder,
		static int tda998x_encoder_mode_valid(struct tda998x_priv *priv,
		struct drm_display_mode *mode)
		{
		if (mode->clock > 150000)
		@@ -820,11 +812,10 @@ tda998x_encoder_mode_valid(struct drm_encoder *encoder,
		}

		static void
		tda998x_encoder_mode_set(struct drm_encoder *encoder,
		tda998x_encoder_mode_set(struct tda998x_priv *priv,
		struct drm_display_mode *mode,
		struct drm_display_mode *adjusted_mode)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		uint16_t ref_pix, ref_line, n_pix, n_line;
		uint16_t hs_pix_s, hs_pix_e;
		uint16_t vs1_pix_s, vs1_pix_e, vs1_line_s, vs1_line_e;
		@@ -1012,20 +1003,16 @@ tda998x_encoder_mode_set(struct drm_encoder *encoder,
		}

		static enum drm_connector_status
		tda998x_encoder_detect(struct drm_encoder *encoder,
		struct drm_connector *connector)
		tda998x_encoder_detect(struct tda998x_priv *priv)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		uint8_t val = cec_read(priv, REG_CEC_RXSHPDLEV);

		return (val & CEC_RXSHPDLEV_HPD) ? connector_status_connected :
		connector_status_disconnected;
		}

		static int
		read_edid_block(struct drm_encoder encoder, uint8_t buf, int blk)
		static int read_edid_block(struct tda998x_priv priv, uint8_t buf, int blk)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		uint8_t offset, segptr;
		int ret, i;

		@@ -1079,10 +1066,8 @@ read_edid_block(struct drm_encoder encoder, uint8_t buf, int blk)
		return 0;
		}

		static uint8_t *
		do_get_edid(struct drm_encoder *encoder)
		static uint8_t do_get_edid(struct tda998x_priv priv)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		int j, valid_extensions = 0;
		uint8_t block, new;
		bool print_bad_edid = drm_debug & DRM_UT_KMS;
		@@ -1094,7 +1079,7 @@ do_get_edid(struct drm_encoder *encoder)
		reg_clear(priv, REG_TX4, TX4_PD_RAM);

		/* base block fetch */
		if (read_edid_block(encoder, block, 0))
		if (read_edid_block(priv, block, 0))
		goto fail;

		if (!drm_edid_block_valid(block, 0, print_bad_edid))
		@@ -1111,7 +1096,7 @@ do_get_edid(struct drm_encoder *encoder)

		for (j = 1; j <= block[0x7e]; j++) {
		uint8_t ext_block = block + (valid_extensions + 1) EDID_LENGTH;
		if (read_edid_block(encoder, ext_block, j))
		if (read_edid_block(priv, ext_block, j))
		goto fail;

		if (!drm_edid_block_valid(ext_block, j, print_bad_edid))
		@@ -1144,11 +1129,10 @@ fail:
		}

		static int
		tda998x_encoder_get_modes(struct drm_encoder *encoder,
		tda998x_encoder_get_modes(struct tda998x_priv *priv,
		struct drm_connector *connector)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);
		struct edid edid = (struct edid )do_get_edid(encoder);
		struct edid edid = (struct edid )do_get_edid(priv);
		int n = 0;

		if (edid) {
		@@ -1161,18 +1145,14 @@ tda998x_encoder_get_modes(struct drm_encoder *encoder,
		return n;
		}

		static int
		tda998x_encoder_create_resources(struct drm_encoder *encoder,
		static void tda998x_encoder_set_polling(struct tda998x_priv *priv,
		struct drm_connector *connector)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);

		if (priv->hdmi->irq)
		connector->polled = DRM_CONNECTOR_POLL_HPD;
		else
		connector->polled = DRM_CONNECTOR_POLL_CONNECT \|
		DRM_CONNECTOR_POLL_DISCONNECT;
		return 0;
		}

		static int
		@@ -1185,11 +1165,8 @@ tda998x_encoder_set_property(struct drm_encoder *encoder,
		return 0;
		}

		static void
		tda998x_encoder_destroy(struct drm_encoder *encoder)
		static void tda998x_destroy(struct tda998x_priv *priv)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);

		/* disable all IRQs and free the IRQ handler */
		cec_write(priv, REG_CEC_RXSHPDINTENA, 0);
		reg_clear(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD);
		@@ -1197,53 +1174,88 @@ tda998x_encoder_destroy(struct drm_encoder *encoder)
		free_irq(priv->hdmi->irq, priv);

		i2c_unregister_device(priv->cec);
		}

		/* Slave encoder support */

		static void
		tda998x_encoder_slave_set_config(struct drm_encoder encoder, void params)
		{
		tda998x_encoder_set_config(to_tda998x_priv(encoder), params);
		}

		static void tda998x_encoder_slave_destroy(struct drm_encoder *encoder)
		{
		struct tda998x_priv *priv = to_tda998x_priv(encoder);

		tda998x_destroy(priv);
		drm_i2c_encoder_destroy(encoder);
		kfree(priv);
		}

		static struct drm_encoder_slave_funcs tda998x_encoder_funcs = {
		.set_config = tda998x_encoder_set_config,
		.destroy = tda998x_encoder_destroy,
		.dpms = tda998x_encoder_dpms,
		.save = tda998x_encoder_save,
		.restore = tda998x_encoder_restore,
		.mode_fixup = tda998x_encoder_mode_fixup,
		.mode_valid = tda998x_encoder_mode_valid,
		.mode_set = tda998x_encoder_mode_set,
		.detect = tda998x_encoder_detect,
		.get_modes = tda998x_encoder_get_modes,
		.create_resources = tda998x_encoder_create_resources,
		.set_property = tda998x_encoder_set_property,
		};
		static void tda998x_encoder_slave_dpms(struct drm_encoder *encoder, int mode)
		{
		tda998x_encoder_dpms(to_tda998x_priv(encoder), mode);
		}

		/* I2C driver functions */
		static int tda998x_encoder_slave_mode_valid(struct drm_encoder *encoder,
		struct drm_display_mode *mode)
		{
		return tda998x_encoder_mode_valid(to_tda998x_priv(encoder), mode);
		}

		static int
		tda998x_probe(struct i2c_client client, const struct i2c_device_id id)
		static void
		tda998x_encoder_slave_mode_set(struct drm_encoder *encoder,
		struct drm_display_mode *mode,
		struct drm_display_mode *adjusted_mode)
		{
		return 0;
		tda998x_encoder_mode_set(to_tda998x_priv(encoder), mode, adjusted_mode);
		}

		static enum drm_connector_status
		tda998x_encoder_slave_detect(struct drm_encoder *encoder,
		struct drm_connector *connector)
		{
		return tda998x_encoder_detect(to_tda998x_priv(encoder));
		}

		static int tda998x_encoder_slave_get_modes(struct drm_encoder *encoder,
		struct drm_connector *connector)
		{
		return tda998x_encoder_get_modes(to_tda998x_priv(encoder), connector);
		}

		static int
		tda998x_remove(struct i2c_client *client)
		tda998x_encoder_slave_create_resources(struct drm_encoder *encoder,
		struct drm_connector *connector)
		{
		tda998x_encoder_set_polling(to_tda998x_priv(encoder), connector);
		return 0;
		}

		static int
		tda998x_encoder_init(struct i2c_client *client,
		struct drm_device *dev,
		struct drm_encoder_slave *encoder_slave)
		static struct drm_encoder_slave_funcs tda998x_encoder_slave_funcs = {
		.set_config = tda998x_encoder_slave_set_config,
		.destroy = tda998x_encoder_slave_destroy,
		.dpms = tda998x_encoder_slave_dpms,
		.save = tda998x_encoder_save,
		.restore = tda998x_encoder_restore,
		.mode_fixup = tda998x_encoder_mode_fixup,
		.mode_valid = tda998x_encoder_slave_mode_valid,
		.mode_set = tda998x_encoder_slave_mode_set,
		.detect = tda998x_encoder_slave_detect,
		.get_modes = tda998x_encoder_slave_get_modes,
		.create_resources = tda998x_encoder_slave_create_resources,
		.set_property = tda998x_encoder_set_property,
		};

		/* I2C driver functions */

		static int tda998x_create(struct i2c_client client, struct tda998x_priv priv)
		{
		struct tda998x_priv *priv;
		struct device_node *np = client->dev.of_node;
		u32 video;
		int rev_lo, rev_hi, ret;

		priv = kzalloc(sizeof(*priv), GFP_KERNEL);
		if (!priv)
		return -ENOMEM;

		priv->vip_cntrl_0 = VIP_CNTRL_0_SWAP_A(2) \| VIP_CNTRL_0_SWAP_B(3);
		priv->vip_cntrl_1 = VIP_CNTRL_1_SWAP_C(0) \| VIP_CNTRL_1_SWAP_D(1);
		priv->vip_cntrl_2 = VIP_CNTRL_2_SWAP_E(4) \| VIP_CNTRL_2_SWAP_F(5);
		@@ -1251,17 +1263,11 @@ tda998x_encoder_init(struct i2c_client *client,
		priv->current_page = 0xff;
		priv->hdmi = client;
		priv->cec = i2c_new_dummy(client->adapter, 0x34);
		if (!priv->cec) {
		kfree(priv);
		if (!priv->cec)
		return -ENODEV;
		}

		priv->encoder = &encoder_slave->base;
		priv->dpms = DRM_MODE_DPMS_OFF;

		encoder_slave->slave_priv = priv;
		encoder_slave->slave_funcs = &tda998x_encoder_funcs;

		/* wake up the device: */
		cec_write(priv, REG_CEC_ENAMODS,
		CEC_ENAMODS_EN_RXSENS \| CEC_ENAMODS_EN_HDMI);
		@@ -1364,12 +1370,231 @@ fail:
		*/
		if (priv->cec)
		i2c_unregister_device(priv->cec);
		kfree(priv);
		encoder_slave->slave_priv = NULL;
		encoder_slave->slave_funcs = NULL;
		return -ENXIO;
		}

		static int tda998x_encoder_init(struct i2c_client *client,
		struct drm_device *dev,
		struct drm_encoder_slave *encoder_slave)
		{
		struct tda998x_priv *priv;
		int ret;

		priv = kzalloc(sizeof(*priv), GFP_KERNEL);
		if (!priv)
		return -ENOMEM;

		priv->encoder = &encoder_slave->base;

		ret = tda998x_create(client, priv);
		if (ret) {
		kfree(priv);
		return ret;
		}

		encoder_slave->slave_priv = priv;
		encoder_slave->slave_funcs = &tda998x_encoder_slave_funcs;

		return 0;
		}

		struct tda998x_priv2 {
		struct tda998x_priv base;
		struct drm_encoder encoder;
		struct drm_connector connector;
		};

		#define conn_to_tda998x_priv2(x) \
		container_of(x, struct tda998x_priv2, connector);

		#define enc_to_tda998x_priv2(x) \
		container_of(x, struct tda998x_priv2, encoder);

		static void tda998x_encoder2_dpms(struct drm_encoder *encoder, int mode)
		{
		struct tda998x_priv2 *priv = enc_to_tda998x_priv2(encoder);

		tda998x_encoder_dpms(&priv->base, mode);
		}

		static void tda998x_encoder_prepare(struct drm_encoder *encoder)
		{
		tda998x_encoder2_dpms(encoder, DRM_MODE_DPMS_OFF);
		}

		static void tda998x_encoder_commit(struct drm_encoder *encoder)
		{
		tda998x_encoder2_dpms(encoder, DRM_MODE_DPMS_ON);
		}

		static void tda998x_encoder2_mode_set(struct drm_encoder *encoder,
		struct drm_display_mode *mode,
		struct drm_display_mode *adjusted_mode)
		{
		struct tda998x_priv2 *priv = enc_to_tda998x_priv2(encoder);

		tda998x_encoder_mode_set(&priv->base, mode, adjusted_mode);
		}

		static const struct drm_encoder_helper_funcs tda998x_encoder_helper_funcs = {
		.dpms = tda998x_encoder2_dpms,
		.save = tda998x_encoder_save,
		.restore = tda998x_encoder_restore,
		.mode_fixup = tda998x_encoder_mode_fixup,
		.prepare = tda998x_encoder_prepare,
		.commit = tda998x_encoder_commit,
		.mode_set = tda998x_encoder2_mode_set,
		};

		static void tda998x_encoder_destroy(struct drm_encoder *encoder)
		{
		struct tda998x_priv2 *priv = enc_to_tda998x_priv2(encoder);

		tda998x_destroy(&priv->base);
		drm_encoder_cleanup(encoder);
		}

		static const struct drm_encoder_funcs tda998x_encoder_funcs = {
		.destroy = tda998x_encoder_destroy,
		};

		static int tda998x_connector_get_modes(struct drm_connector *connector)
		{
		struct tda998x_priv2 *priv = conn_to_tda998x_priv2(connector);

		return tda998x_encoder_get_modes(&priv->base, connector);
		}

		static int tda998x_connector_mode_valid(struct drm_connector *connector,
		struct drm_display_mode *mode)
		{
		struct tda998x_priv2 *priv = conn_to_tda998x_priv2(connector);

		return tda998x_encoder_mode_valid(&priv->base, mode);
		}

		static struct drm_encoder *
		tda998x_connector_best_encoder(struct drm_connector *connector)
		{
		struct tda998x_priv2 *priv = conn_to_tda998x_priv2(connector);

		return &priv->encoder;
		}

		static
		const struct drm_connector_helper_funcs tda998x_connector_helper_funcs = {
		.get_modes = tda998x_connector_get_modes,
		.mode_valid = tda998x_connector_mode_valid,
		.best_encoder = tda998x_connector_best_encoder,
		};

		static enum drm_connector_status
		tda998x_connector_detect(struct drm_connector *connector, bool force)
		{
		struct tda998x_priv2 *priv = conn_to_tda998x_priv2(connector);

		return tda998x_encoder_detect(&priv->base);
		}

		static void tda998x_connector_destroy(struct drm_connector *connector)
		{
		drm_sysfs_connector_remove(connector);
		drm_connector_cleanup(connector);
		}

		static const struct drm_connector_funcs tda998x_connector_funcs = {
		.dpms = drm_helper_connector_dpms,
		.fill_modes = drm_helper_probe_single_connector_modes,
		.detect = tda998x_connector_detect,
		.destroy = tda998x_connector_destroy,
		};

		static int tda998x_bind(struct device dev, struct device master, void *data)
		{
		struct tda998x_encoder_params *params = dev->platform_data;
		struct i2c_client *client = to_i2c_client(dev);
		struct drm_device *drm = data;
		struct tda998x_priv2 *priv;
		int ret;

		priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
		if (!priv)
		return -ENOMEM;

		dev_set_drvdata(dev, priv);

		priv->base.encoder = &priv->encoder;
		priv->connector.interlace_allowed = 1;
		priv->encoder.possible_crtcs = 1 << 0;

		ret = tda998x_create(client, &priv->base);
		if (ret)
		return ret;

		if (!dev->of_node && params)
		tda998x_encoder_set_config(&priv->base, params);

		tda998x_encoder_set_polling(&priv->base, &priv->connector);

		drm_encoder_helper_add(&priv->encoder, &tda998x_encoder_helper_funcs);
		ret = drm_encoder_init(drm, &priv->encoder, &tda998x_encoder_funcs,
		DRM_MODE_ENCODER_TMDS);
		if (ret)
		goto err_encoder;

		drm_connector_helper_add(&priv->connector,
		&tda998x_connector_helper_funcs);
		ret = drm_connector_init(drm, &priv->connector,
		&tda998x_connector_funcs,
		DRM_MODE_CONNECTOR_HDMIA);
		if (ret)
		goto err_connector;

		ret = drm_sysfs_connector_add(&priv->connector);
		if (ret)
		goto err_sysfs;

		priv->connector.encoder = &priv->encoder;
		drm_mode_connector_attach_encoder(&priv->connector, &priv->encoder);

		return 0;

		err_sysfs:
		drm_connector_cleanup(&priv->connector);
		err_connector:
		drm_encoder_cleanup(&priv->encoder);
		err_encoder:
		tda998x_destroy(&priv->base);
		return ret;
		}

		static void tda998x_unbind(struct device dev, struct device master,
		void *data)
		{
		struct tda998x_priv2 *priv = dev_get_drvdata(dev);

		drm_connector_cleanup(&priv->connector);
		drm_encoder_cleanup(&priv->encoder);
		tda998x_destroy(&priv->base);
		}

		static const struct component_ops tda998x_ops = {
		.bind = tda998x_bind,
		.unbind = tda998x_unbind,
		};

		static int
		tda998x_probe(struct i2c_client client, const struct i2c_device_id id)
		{
		return component_add(&client->dev, &tda998x_ops);
		}

		static int tda998x_remove(struct i2c_client *client)
		{
		component_del(&client->dev, &tda998x_ops);
		return 0;
		}

		#ifdef CONFIG_OF
		static const struct of_device_id tda998x_dt_ids[] = {
		{ .compatible = "nxp,tda998x", },

Admin message