cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

adv7511_drv.c (38522B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Analog Devices ADV7511 HDMI transmitter driver
      4 *
      5 * Copyright 2012 Analog Devices Inc.
      6 */
      7
      8#include <linux/clk.h>
      9#include <linux/device.h>
     10#include <linux/gpio/consumer.h>
     11#include <linux/module.h>
     12#include <linux/of_device.h>
     13#include <linux/slab.h>
     14
     15#include <media/cec.h>
     16
     17#include <drm/drm_atomic.h>
     18#include <drm/drm_atomic_helper.h>
     19#include <drm/drm_edid.h>
     20#include <drm/drm_print.h>
     21#include <drm/drm_probe_helper.h>
     22
     23#include "adv7511.h"
     24
     25/* ADI recommended values for proper operation. */
     26static const struct reg_sequence adv7511_fixed_registers[] = {
     27	{ 0x98, 0x03 },
     28	{ 0x9a, 0xe0 },
     29	{ 0x9c, 0x30 },
     30	{ 0x9d, 0x61 },
     31	{ 0xa2, 0xa4 },
     32	{ 0xa3, 0xa4 },
     33	{ 0xe0, 0xd0 },
     34	{ 0xf9, 0x00 },
     35	{ 0x55, 0x02 },
     36};
     37
     38/* -----------------------------------------------------------------------------
     39 * Register access
     40 */
     41
     42static const uint8_t adv7511_register_defaults[] = {
     43	0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00 */
     44	0x00, 0x00, 0x01, 0x0e, 0xbc, 0x18, 0x01, 0x13,
     45	0x25, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10 */
     46	0x46, 0x62, 0x04, 0xa8, 0x00, 0x00, 0x1c, 0x84,
     47	0x1c, 0xbf, 0x04, 0xa8, 0x1e, 0x70, 0x02, 0x1e, /* 20 */
     48	0x00, 0x00, 0x04, 0xa8, 0x08, 0x12, 0x1b, 0xac,
     49	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 30 */
     50	0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xb0,
     51	0x00, 0x50, 0x90, 0x7e, 0x79, 0x70, 0x00, 0x00, /* 40 */
     52	0x00, 0xa8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
     53	0x00, 0x00, 0x02, 0x0d, 0x00, 0x00, 0x00, 0x00, /* 50 */
     54	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     55	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 60 */
     56	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     57	0x01, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 70 */
     58	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     59	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 80 */
     60	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     61	0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, /* 90 */
     62	0x0b, 0x02, 0x00, 0x18, 0x5a, 0x60, 0x00, 0x00,
     63	0x00, 0x00, 0x80, 0x80, 0x08, 0x04, 0x00, 0x00, /* a0 */
     64	0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x14,
     65	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* b0 */
     66	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     67	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* c0 */
     68	0x00, 0x03, 0x00, 0x00, 0x02, 0x00, 0x01, 0x04,
     69	0x30, 0xff, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, /* d0 */
     70	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
     71	0x80, 0x75, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, /* e0 */
     72	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     73	0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x11, 0x00, /* f0 */
     74	0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     75};
     76
     77static bool adv7511_register_volatile(struct device *dev, unsigned int reg)
     78{
     79	switch (reg) {
     80	case ADV7511_REG_CHIP_REVISION:
     81	case ADV7511_REG_SPDIF_FREQ:
     82	case ADV7511_REG_CTS_AUTOMATIC1:
     83	case ADV7511_REG_CTS_AUTOMATIC2:
     84	case ADV7511_REG_VIC_DETECTED:
     85	case ADV7511_REG_VIC_SEND:
     86	case ADV7511_REG_AUX_VIC_DETECTED:
     87	case ADV7511_REG_STATUS:
     88	case ADV7511_REG_GC(1):
     89	case ADV7511_REG_INT(0):
     90	case ADV7511_REG_INT(1):
     91	case ADV7511_REG_PLL_STATUS:
     92	case ADV7511_REG_AN(0):
     93	case ADV7511_REG_AN(1):
     94	case ADV7511_REG_AN(2):
     95	case ADV7511_REG_AN(3):
     96	case ADV7511_REG_AN(4):
     97	case ADV7511_REG_AN(5):
     98	case ADV7511_REG_AN(6):
     99	case ADV7511_REG_AN(7):
    100	case ADV7511_REG_HDCP_STATUS:
    101	case ADV7511_REG_BCAPS:
    102	case ADV7511_REG_BKSV(0):
    103	case ADV7511_REG_BKSV(1):
    104	case ADV7511_REG_BKSV(2):
    105	case ADV7511_REG_BKSV(3):
    106	case ADV7511_REG_BKSV(4):
    107	case ADV7511_REG_DDC_STATUS:
    108	case ADV7511_REG_EDID_READ_CTRL:
    109	case ADV7511_REG_BSTATUS(0):
    110	case ADV7511_REG_BSTATUS(1):
    111	case ADV7511_REG_CHIP_ID_HIGH:
    112	case ADV7511_REG_CHIP_ID_LOW:
    113		return true;
    114	}
    115
    116	return false;
    117}
    118
    119static const struct regmap_config adv7511_regmap_config = {
    120	.reg_bits = 8,
    121	.val_bits = 8,
    122
    123	.max_register = 0xff,
    124	.cache_type = REGCACHE_RBTREE,
    125	.reg_defaults_raw = adv7511_register_defaults,
    126	.num_reg_defaults_raw = ARRAY_SIZE(adv7511_register_defaults),
    127
    128	.volatile_reg = adv7511_register_volatile,
    129};
    130
    131/* -----------------------------------------------------------------------------
    132 * Hardware configuration
    133 */
    134
    135static void adv7511_set_colormap(struct adv7511 *adv7511, bool enable,
    136				 const uint16_t *coeff,
    137				 unsigned int scaling_factor)
    138{
    139	unsigned int i;
    140
    141	regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(1),
    142			   ADV7511_CSC_UPDATE_MODE, ADV7511_CSC_UPDATE_MODE);
    143
    144	if (enable) {
    145		for (i = 0; i < 12; ++i) {
    146			regmap_update_bits(adv7511->regmap,
    147					   ADV7511_REG_CSC_UPPER(i),
    148					   0x1f, coeff[i] >> 8);
    149			regmap_write(adv7511->regmap,
    150				     ADV7511_REG_CSC_LOWER(i),
    151				     coeff[i] & 0xff);
    152		}
    153	}
    154
    155	if (enable)
    156		regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(0),
    157				   0xe0, 0x80 | (scaling_factor << 5));
    158	else
    159		regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(0),
    160				   0x80, 0x00);
    161
    162	regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(1),
    163			   ADV7511_CSC_UPDATE_MODE, 0);
    164}
    165
    166static int adv7511_packet_enable(struct adv7511 *adv7511, unsigned int packet)
    167{
    168	if (packet & 0xff)
    169		regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE0,
    170				   packet, 0xff);
    171
    172	if (packet & 0xff00) {
    173		packet >>= 8;
    174		regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1,
    175				   packet, 0xff);
    176	}
    177
    178	return 0;
    179}
    180
    181static int adv7511_packet_disable(struct adv7511 *adv7511, unsigned int packet)
    182{
    183	if (packet & 0xff)
    184		regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE0,
    185				   packet, 0x00);
    186
    187	if (packet & 0xff00) {
    188		packet >>= 8;
    189		regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1,
    190				   packet, 0x00);
    191	}
    192
    193	return 0;
    194}
    195
    196/* Coefficients for adv7511 color space conversion */
    197static const uint16_t adv7511_csc_ycbcr_to_rgb[] = {
    198	0x0734, 0x04ad, 0x0000, 0x1c1b,
    199	0x1ddc, 0x04ad, 0x1f24, 0x0135,
    200	0x0000, 0x04ad, 0x087c, 0x1b77,
    201};
    202
    203static void adv7511_set_config_csc(struct adv7511 *adv7511,
    204				   struct drm_connector *connector,
    205				   bool rgb, bool hdmi_mode)
    206{
    207	struct adv7511_video_config config;
    208	bool output_format_422, output_format_ycbcr;
    209	unsigned int mode;
    210	uint8_t infoframe[17];
    211
    212	config.hdmi_mode = hdmi_mode;
    213
    214	hdmi_avi_infoframe_init(&config.avi_infoframe);
    215
    216	config.avi_infoframe.scan_mode = HDMI_SCAN_MODE_UNDERSCAN;
    217
    218	if (rgb) {
    219		config.csc_enable = false;
    220		config.avi_infoframe.colorspace = HDMI_COLORSPACE_RGB;
    221	} else {
    222		config.csc_scaling_factor = ADV7511_CSC_SCALING_4;
    223		config.csc_coefficents = adv7511_csc_ycbcr_to_rgb;
    224
    225		if ((connector->display_info.color_formats &
    226		     DRM_COLOR_FORMAT_YCBCR422) &&
    227		    config.hdmi_mode) {
    228			config.csc_enable = false;
    229			config.avi_infoframe.colorspace =
    230				HDMI_COLORSPACE_YUV422;
    231		} else {
    232			config.csc_enable = true;
    233			config.avi_infoframe.colorspace = HDMI_COLORSPACE_RGB;
    234		}
    235	}
    236
    237	if (config.hdmi_mode) {
    238		mode = ADV7511_HDMI_CFG_MODE_HDMI;
    239
    240		switch (config.avi_infoframe.colorspace) {
    241		case HDMI_COLORSPACE_YUV444:
    242			output_format_422 = false;
    243			output_format_ycbcr = true;
    244			break;
    245		case HDMI_COLORSPACE_YUV422:
    246			output_format_422 = true;
    247			output_format_ycbcr = true;
    248			break;
    249		default:
    250			output_format_422 = false;
    251			output_format_ycbcr = false;
    252			break;
    253		}
    254	} else {
    255		mode = ADV7511_HDMI_CFG_MODE_DVI;
    256		output_format_422 = false;
    257		output_format_ycbcr = false;
    258	}
    259
    260	adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
    261
    262	adv7511_set_colormap(adv7511, config.csc_enable,
    263			     config.csc_coefficents,
    264			     config.csc_scaling_factor);
    265
    266	regmap_update_bits(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG1, 0x81,
    267			   (output_format_422 << 7) | output_format_ycbcr);
    268
    269	regmap_update_bits(adv7511->regmap, ADV7511_REG_HDCP_HDMI_CFG,
    270			   ADV7511_HDMI_CFG_MODE_MASK, mode);
    271
    272	hdmi_avi_infoframe_pack(&config.avi_infoframe, infoframe,
    273				sizeof(infoframe));
    274
    275	/* The AVI infoframe id is not configurable */
    276	regmap_bulk_write(adv7511->regmap, ADV7511_REG_AVI_INFOFRAME_VERSION,
    277			  infoframe + 1, sizeof(infoframe) - 1);
    278
    279	adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
    280}
    281
    282static void adv7511_set_link_config(struct adv7511 *adv7511,
    283				    const struct adv7511_link_config *config)
    284{
    285	/*
    286	 * The input style values documented in the datasheet don't match the
    287	 * hardware register field values :-(
    288	 */
    289	static const unsigned int input_styles[4] = { 0, 2, 1, 3 };
    290
    291	unsigned int clock_delay;
    292	unsigned int color_depth;
    293	unsigned int input_id;
    294
    295	clock_delay = (config->clock_delay + 1200) / 400;
    296	color_depth = config->input_color_depth == 8 ? 3
    297		    : (config->input_color_depth == 10 ? 1 : 2);
    298
    299	/* TODO Support input ID 6 */
    300	if (config->input_colorspace != HDMI_COLORSPACE_YUV422)
    301		input_id = config->input_clock == ADV7511_INPUT_CLOCK_DDR
    302			 ? 5 : 0;
    303	else if (config->input_clock == ADV7511_INPUT_CLOCK_DDR)
    304		input_id = config->embedded_sync ? 8 : 7;
    305	else if (config->input_clock == ADV7511_INPUT_CLOCK_2X)
    306		input_id = config->embedded_sync ? 4 : 3;
    307	else
    308		input_id = config->embedded_sync ? 2 : 1;
    309
    310	regmap_update_bits(adv7511->regmap, ADV7511_REG_I2C_FREQ_ID_CFG, 0xf,
    311			   input_id);
    312	regmap_update_bits(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG1, 0x7e,
    313			   (color_depth << 4) |
    314			   (input_styles[config->input_style] << 2));
    315	regmap_write(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG2,
    316		     config->input_justification << 3);
    317	regmap_write(adv7511->regmap, ADV7511_REG_TIMING_GEN_SEQ,
    318		     config->sync_pulse << 2);
    319
    320	regmap_write(adv7511->regmap, 0xba, clock_delay << 5);
    321
    322	adv7511->embedded_sync = config->embedded_sync;
    323	adv7511->hsync_polarity = config->hsync_polarity;
    324	adv7511->vsync_polarity = config->vsync_polarity;
    325	adv7511->rgb = config->input_colorspace == HDMI_COLORSPACE_RGB;
    326}
    327
    328static void __adv7511_power_on(struct adv7511 *adv7511)
    329{
    330	adv7511->current_edid_segment = -1;
    331
    332	regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER,
    333			   ADV7511_POWER_POWER_DOWN, 0);
    334	if (adv7511->i2c_main->irq) {
    335		/*
    336		 * Documentation says the INT_ENABLE registers are reset in
    337		 * POWER_DOWN mode. My 7511w preserved the bits, however.
    338		 * Still, let's be safe and stick to the documentation.
    339		 */
    340		regmap_write(adv7511->regmap, ADV7511_REG_INT_ENABLE(0),
    341			     ADV7511_INT0_EDID_READY | ADV7511_INT0_HPD);
    342		regmap_update_bits(adv7511->regmap,
    343				   ADV7511_REG_INT_ENABLE(1),
    344				   ADV7511_INT1_DDC_ERROR,
    345				   ADV7511_INT1_DDC_ERROR);
    346	}
    347
    348	/*
    349	 * Per spec it is allowed to pulse the HPD signal to indicate that the
    350	 * EDID information has changed. Some monitors do this when they wakeup
    351	 * from standby or are enabled. When the HPD goes low the adv7511 is
    352	 * reset and the outputs are disabled which might cause the monitor to
    353	 * go to standby again. To avoid this we ignore the HPD pin for the
    354	 * first few seconds after enabling the output. On the other hand
    355	 * adv7535 require to enable HPD Override bit for proper HPD.
    356	 */
    357	if (adv7511->type == ADV7535)
    358		regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2,
    359				   ADV7535_REG_POWER2_HPD_OVERRIDE,
    360				   ADV7535_REG_POWER2_HPD_OVERRIDE);
    361	else
    362		regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2,
    363				   ADV7511_REG_POWER2_HPD_SRC_MASK,
    364				   ADV7511_REG_POWER2_HPD_SRC_NONE);
    365}
    366
    367static void adv7511_power_on(struct adv7511 *adv7511)
    368{
    369	__adv7511_power_on(adv7511);
    370
    371	/*
    372	 * Most of the registers are reset during power down or when HPD is low.
    373	 */
    374	regcache_sync(adv7511->regmap);
    375
    376	if (adv7511->type == ADV7533 || adv7511->type == ADV7535)
    377		adv7533_dsi_power_on(adv7511);
    378	adv7511->powered = true;
    379}
    380
    381static void __adv7511_power_off(struct adv7511 *adv7511)
    382{
    383	/* TODO: setup additional power down modes */
    384	if (adv7511->type == ADV7535)
    385		regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2,
    386				   ADV7535_REG_POWER2_HPD_OVERRIDE, 0);
    387
    388	regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER,
    389			   ADV7511_POWER_POWER_DOWN,
    390			   ADV7511_POWER_POWER_DOWN);
    391	regmap_update_bits(adv7511->regmap,
    392			   ADV7511_REG_INT_ENABLE(1),
    393			   ADV7511_INT1_DDC_ERROR, 0);
    394	regcache_mark_dirty(adv7511->regmap);
    395}
    396
    397static void adv7511_power_off(struct adv7511 *adv7511)
    398{
    399	__adv7511_power_off(adv7511);
    400	if (adv7511->type == ADV7533 || adv7511->type == ADV7535)
    401		adv7533_dsi_power_off(adv7511);
    402	adv7511->powered = false;
    403}
    404
    405/* -----------------------------------------------------------------------------
    406 * Interrupt and hotplug detection
    407 */
    408
    409static bool adv7511_hpd(struct adv7511 *adv7511)
    410{
    411	unsigned int irq0;
    412	int ret;
    413
    414	ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(0), &irq0);
    415	if (ret < 0)
    416		return false;
    417
    418	if (irq0 & ADV7511_INT0_HPD) {
    419		regmap_write(adv7511->regmap, ADV7511_REG_INT(0),
    420			     ADV7511_INT0_HPD);
    421		return true;
    422	}
    423
    424	return false;
    425}
    426
    427static void adv7511_hpd_work(struct work_struct *work)
    428{
    429	struct adv7511 *adv7511 = container_of(work, struct adv7511, hpd_work);
    430	enum drm_connector_status status;
    431	unsigned int val;
    432	int ret;
    433
    434	ret = regmap_read(adv7511->regmap, ADV7511_REG_STATUS, &val);
    435	if (ret < 0)
    436		status = connector_status_disconnected;
    437	else if (val & ADV7511_STATUS_HPD)
    438		status = connector_status_connected;
    439	else
    440		status = connector_status_disconnected;
    441
    442	/*
    443	 * The bridge resets its registers on unplug. So when we get a plug
    444	 * event and we're already supposed to be powered, cycle the bridge to
    445	 * restore its state.
    446	 */
    447	if (status == connector_status_connected &&
    448	    adv7511->connector.status == connector_status_disconnected &&
    449	    adv7511->powered) {
    450		regcache_mark_dirty(adv7511->regmap);
    451		adv7511_power_on(adv7511);
    452	}
    453
    454	if (adv7511->connector.status != status) {
    455		adv7511->connector.status = status;
    456
    457		if (adv7511->connector.dev) {
    458			if (status == connector_status_disconnected)
    459				cec_phys_addr_invalidate(adv7511->cec_adap);
    460			drm_kms_helper_hotplug_event(adv7511->connector.dev);
    461		} else {
    462			drm_bridge_hpd_notify(&adv7511->bridge, status);
    463		}
    464	}
    465}
    466
    467static int adv7511_irq_process(struct adv7511 *adv7511, bool process_hpd)
    468{
    469	unsigned int irq0, irq1;
    470	int ret;
    471
    472	ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(0), &irq0);
    473	if (ret < 0)
    474		return ret;
    475
    476	ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(1), &irq1);
    477	if (ret < 0)
    478		return ret;
    479
    480	regmap_write(adv7511->regmap, ADV7511_REG_INT(0), irq0);
    481	regmap_write(adv7511->regmap, ADV7511_REG_INT(1), irq1);
    482
    483	if (process_hpd && irq0 & ADV7511_INT0_HPD && adv7511->bridge.encoder)
    484		schedule_work(&adv7511->hpd_work);
    485
    486	if (irq0 & ADV7511_INT0_EDID_READY || irq1 & ADV7511_INT1_DDC_ERROR) {
    487		adv7511->edid_read = true;
    488
    489		if (adv7511->i2c_main->irq)
    490			wake_up_all(&adv7511->wq);
    491	}
    492
    493#ifdef CONFIG_DRM_I2C_ADV7511_CEC
    494	adv7511_cec_irq_process(adv7511, irq1);
    495#endif
    496
    497	return 0;
    498}
    499
    500static irqreturn_t adv7511_irq_handler(int irq, void *devid)
    501{
    502	struct adv7511 *adv7511 = devid;
    503	int ret;
    504
    505	ret = adv7511_irq_process(adv7511, true);
    506	return ret < 0 ? IRQ_NONE : IRQ_HANDLED;
    507}
    508
    509/* -----------------------------------------------------------------------------
    510 * EDID retrieval
    511 */
    512
    513static int adv7511_wait_for_edid(struct adv7511 *adv7511, int timeout)
    514{
    515	int ret;
    516
    517	if (adv7511->i2c_main->irq) {
    518		ret = wait_event_interruptible_timeout(adv7511->wq,
    519				adv7511->edid_read, msecs_to_jiffies(timeout));
    520	} else {
    521		for (; timeout > 0; timeout -= 25) {
    522			ret = adv7511_irq_process(adv7511, false);
    523			if (ret < 0)
    524				break;
    525
    526			if (adv7511->edid_read)
    527				break;
    528
    529			msleep(25);
    530		}
    531	}
    532
    533	return adv7511->edid_read ? 0 : -EIO;
    534}
    535
    536static int adv7511_get_edid_block(void *data, u8 *buf, unsigned int block,
    537				  size_t len)
    538{
    539	struct adv7511 *adv7511 = data;
    540	struct i2c_msg xfer[2];
    541	uint8_t offset;
    542	unsigned int i;
    543	int ret;
    544
    545	if (len > 128)
    546		return -EINVAL;
    547
    548	if (adv7511->current_edid_segment != block / 2) {
    549		unsigned int status;
    550
    551		ret = regmap_read(adv7511->regmap, ADV7511_REG_DDC_STATUS,
    552				  &status);
    553		if (ret < 0)
    554			return ret;
    555
    556		if (status != 2) {
    557			adv7511->edid_read = false;
    558			regmap_write(adv7511->regmap, ADV7511_REG_EDID_SEGMENT,
    559				     block);
    560			ret = adv7511_wait_for_edid(adv7511, 200);
    561			if (ret < 0)
    562				return ret;
    563		}
    564
    565		/* Break this apart, hopefully more I2C controllers will
    566		 * support 64 byte transfers than 256 byte transfers
    567		 */
    568
    569		xfer[0].addr = adv7511->i2c_edid->addr;
    570		xfer[0].flags = 0;
    571		xfer[0].len = 1;
    572		xfer[0].buf = &offset;
    573		xfer[1].addr = adv7511->i2c_edid->addr;
    574		xfer[1].flags = I2C_M_RD;
    575		xfer[1].len = 64;
    576		xfer[1].buf = adv7511->edid_buf;
    577
    578		offset = 0;
    579
    580		for (i = 0; i < 4; ++i) {
    581			ret = i2c_transfer(adv7511->i2c_edid->adapter, xfer,
    582					   ARRAY_SIZE(xfer));
    583			if (ret < 0)
    584				return ret;
    585			else if (ret != 2)
    586				return -EIO;
    587
    588			xfer[1].buf += 64;
    589			offset += 64;
    590		}
    591
    592		adv7511->current_edid_segment = block / 2;
    593	}
    594
    595	if (block % 2 == 0)
    596		memcpy(buf, adv7511->edid_buf, len);
    597	else
    598		memcpy(buf, adv7511->edid_buf + 128, len);
    599
    600	return 0;
    601}
    602
    603/* -----------------------------------------------------------------------------
    604 * ADV75xx helpers
    605 */
    606
    607static struct edid *adv7511_get_edid(struct adv7511 *adv7511,
    608				     struct drm_connector *connector)
    609{
    610	struct edid *edid;
    611
    612	/* Reading the EDID only works if the device is powered */
    613	if (!adv7511->powered) {
    614		unsigned int edid_i2c_addr =
    615					(adv7511->i2c_edid->addr << 1);
    616
    617		__adv7511_power_on(adv7511);
    618
    619		/* Reset the EDID_I2C_ADDR register as it might be cleared */
    620		regmap_write(adv7511->regmap, ADV7511_REG_EDID_I2C_ADDR,
    621			     edid_i2c_addr);
    622	}
    623
    624	edid = drm_do_get_edid(connector, adv7511_get_edid_block, adv7511);
    625
    626	if (!adv7511->powered)
    627		__adv7511_power_off(adv7511);
    628
    629	adv7511_set_config_csc(adv7511, connector, adv7511->rgb,
    630			       drm_detect_hdmi_monitor(edid));
    631
    632	cec_s_phys_addr_from_edid(adv7511->cec_adap, edid);
    633
    634	return edid;
    635}
    636
    637static int adv7511_get_modes(struct adv7511 *adv7511,
    638			     struct drm_connector *connector)
    639{
    640	struct edid *edid;
    641	unsigned int count;
    642
    643	edid = adv7511_get_edid(adv7511, connector);
    644
    645	drm_connector_update_edid_property(connector, edid);
    646	count = drm_add_edid_modes(connector, edid);
    647
    648	kfree(edid);
    649
    650	return count;
    651}
    652
    653static enum drm_connector_status
    654adv7511_detect(struct adv7511 *adv7511, struct drm_connector *connector)
    655{
    656	enum drm_connector_status status;
    657	unsigned int val;
    658	bool hpd;
    659	int ret;
    660
    661	ret = regmap_read(adv7511->regmap, ADV7511_REG_STATUS, &val);
    662	if (ret < 0)
    663		return connector_status_disconnected;
    664
    665	if (val & ADV7511_STATUS_HPD)
    666		status = connector_status_connected;
    667	else
    668		status = connector_status_disconnected;
    669
    670	hpd = adv7511_hpd(adv7511);
    671
    672	/* The chip resets itself when the cable is disconnected, so in case
    673	 * there is a pending HPD interrupt and the cable is connected there was
    674	 * at least one transition from disconnected to connected and the chip
    675	 * has to be reinitialized. */
    676	if (status == connector_status_connected && hpd && adv7511->powered) {
    677		regcache_mark_dirty(adv7511->regmap);
    678		adv7511_power_on(adv7511);
    679		if (connector)
    680			adv7511_get_modes(adv7511, connector);
    681		if (adv7511->status == connector_status_connected)
    682			status = connector_status_disconnected;
    683	} else {
    684		/* Renable HPD sensing */
    685		if (adv7511->type == ADV7535)
    686			regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2,
    687					   ADV7535_REG_POWER2_HPD_OVERRIDE,
    688					   ADV7535_REG_POWER2_HPD_OVERRIDE);
    689		else
    690			regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2,
    691					   ADV7511_REG_POWER2_HPD_SRC_MASK,
    692					   ADV7511_REG_POWER2_HPD_SRC_BOTH);
    693	}
    694
    695	adv7511->status = status;
    696	return status;
    697}
    698
    699static enum drm_mode_status adv7511_mode_valid(struct adv7511 *adv7511,
    700			      struct drm_display_mode *mode)
    701{
    702	if (mode->clock > 165000)
    703		return MODE_CLOCK_HIGH;
    704
    705	return MODE_OK;
    706}
    707
    708static void adv7511_mode_set(struct adv7511 *adv7511,
    709			     const struct drm_display_mode *mode,
    710			     const struct drm_display_mode *adj_mode)
    711{
    712	unsigned int low_refresh_rate;
    713	unsigned int hsync_polarity = 0;
    714	unsigned int vsync_polarity = 0;
    715
    716	if (adv7511->embedded_sync) {
    717		unsigned int hsync_offset, hsync_len;
    718		unsigned int vsync_offset, vsync_len;
    719
    720		hsync_offset = adj_mode->crtc_hsync_start -
    721			       adj_mode->crtc_hdisplay;
    722		vsync_offset = adj_mode->crtc_vsync_start -
    723			       adj_mode->crtc_vdisplay;
    724		hsync_len = adj_mode->crtc_hsync_end -
    725			    adj_mode->crtc_hsync_start;
    726		vsync_len = adj_mode->crtc_vsync_end -
    727			    adj_mode->crtc_vsync_start;
    728
    729		/* The hardware vsync generator has a off-by-one bug */
    730		vsync_offset += 1;
    731
    732		regmap_write(adv7511->regmap, ADV7511_REG_HSYNC_PLACEMENT_MSB,
    733			     ((hsync_offset >> 10) & 0x7) << 5);
    734		regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(0),
    735			     (hsync_offset >> 2) & 0xff);
    736		regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(1),
    737			     ((hsync_offset & 0x3) << 6) |
    738			     ((hsync_len >> 4) & 0x3f));
    739		regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(2),
    740			     ((hsync_len & 0xf) << 4) |
    741			     ((vsync_offset >> 6) & 0xf));
    742		regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(3),
    743			     ((vsync_offset & 0x3f) << 2) |
    744			     ((vsync_len >> 8) & 0x3));
    745		regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(4),
    746			     vsync_len & 0xff);
    747
    748		hsync_polarity = !(adj_mode->flags & DRM_MODE_FLAG_PHSYNC);
    749		vsync_polarity = !(adj_mode->flags & DRM_MODE_FLAG_PVSYNC);
    750	} else {
    751		enum adv7511_sync_polarity mode_hsync_polarity;
    752		enum adv7511_sync_polarity mode_vsync_polarity;
    753
    754		/**
    755		 * If the input signal is always low or always high we want to
    756		 * invert or let it passthrough depending on the polarity of the
    757		 * current mode.
    758		 **/
    759		if (adj_mode->flags & DRM_MODE_FLAG_NHSYNC)
    760			mode_hsync_polarity = ADV7511_SYNC_POLARITY_LOW;
    761		else
    762			mode_hsync_polarity = ADV7511_SYNC_POLARITY_HIGH;
    763
    764		if (adj_mode->flags & DRM_MODE_FLAG_NVSYNC)
    765			mode_vsync_polarity = ADV7511_SYNC_POLARITY_LOW;
    766		else
    767			mode_vsync_polarity = ADV7511_SYNC_POLARITY_HIGH;
    768
    769		if (adv7511->hsync_polarity != mode_hsync_polarity &&
    770		    adv7511->hsync_polarity !=
    771		    ADV7511_SYNC_POLARITY_PASSTHROUGH)
    772			hsync_polarity = 1;
    773
    774		if (adv7511->vsync_polarity != mode_vsync_polarity &&
    775		    adv7511->vsync_polarity !=
    776		    ADV7511_SYNC_POLARITY_PASSTHROUGH)
    777			vsync_polarity = 1;
    778	}
    779
    780	if (drm_mode_vrefresh(mode) <= 24)
    781		low_refresh_rate = ADV7511_LOW_REFRESH_RATE_24HZ;
    782	else if (drm_mode_vrefresh(mode) <= 25)
    783		low_refresh_rate = ADV7511_LOW_REFRESH_RATE_25HZ;
    784	else if (drm_mode_vrefresh(mode) <= 30)
    785		low_refresh_rate = ADV7511_LOW_REFRESH_RATE_30HZ;
    786	else
    787		low_refresh_rate = ADV7511_LOW_REFRESH_RATE_NONE;
    788
    789	regmap_update_bits(adv7511->regmap, 0xfb,
    790		0x6, low_refresh_rate << 1);
    791	regmap_update_bits(adv7511->regmap, 0x17,
    792		0x60, (vsync_polarity << 6) | (hsync_polarity << 5));
    793
    794	if (adv7511->type == ADV7533 || adv7511->type == ADV7535)
    795		adv7533_mode_set(adv7511, adj_mode);
    796
    797	drm_mode_copy(&adv7511->curr_mode, adj_mode);
    798
    799	/*
    800	 * TODO Test first order 4:2:2 to 4:4:4 up conversion method, which is
    801	 * supposed to give better results.
    802	 */
    803
    804	adv7511->f_tmds = mode->clock;
    805}
    806
    807/* -----------------------------------------------------------------------------
    808 * DRM Connector Operations
    809 */
    810
    811static struct adv7511 *connector_to_adv7511(struct drm_connector *connector)
    812{
    813	return container_of(connector, struct adv7511, connector);
    814}
    815
    816static int adv7511_connector_get_modes(struct drm_connector *connector)
    817{
    818	struct adv7511 *adv = connector_to_adv7511(connector);
    819
    820	return adv7511_get_modes(adv, connector);
    821}
    822
    823static enum drm_mode_status
    824adv7511_connector_mode_valid(struct drm_connector *connector,
    825			     struct drm_display_mode *mode)
    826{
    827	struct adv7511 *adv = connector_to_adv7511(connector);
    828
    829	return adv7511_mode_valid(adv, mode);
    830}
    831
    832static struct drm_connector_helper_funcs adv7511_connector_helper_funcs = {
    833	.get_modes = adv7511_connector_get_modes,
    834	.mode_valid = adv7511_connector_mode_valid,
    835};
    836
    837static enum drm_connector_status
    838adv7511_connector_detect(struct drm_connector *connector, bool force)
    839{
    840	struct adv7511 *adv = connector_to_adv7511(connector);
    841
    842	return adv7511_detect(adv, connector);
    843}
    844
    845static const struct drm_connector_funcs adv7511_connector_funcs = {
    846	.fill_modes = drm_helper_probe_single_connector_modes,
    847	.detect = adv7511_connector_detect,
    848	.destroy = drm_connector_cleanup,
    849	.reset = drm_atomic_helper_connector_reset,
    850	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
    851	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
    852};
    853
    854static int adv7511_connector_init(struct adv7511 *adv)
    855{
    856	struct drm_bridge *bridge = &adv->bridge;
    857	int ret;
    858
    859	if (!bridge->encoder) {
    860		DRM_ERROR("Parent encoder object not found");
    861		return -ENODEV;
    862	}
    863
    864	if (adv->i2c_main->irq)
    865		adv->connector.polled = DRM_CONNECTOR_POLL_HPD;
    866	else
    867		adv->connector.polled = DRM_CONNECTOR_POLL_CONNECT |
    868				DRM_CONNECTOR_POLL_DISCONNECT;
    869
    870	ret = drm_connector_init(bridge->dev, &adv->connector,
    871				 &adv7511_connector_funcs,
    872				 DRM_MODE_CONNECTOR_HDMIA);
    873	if (ret < 0) {
    874		DRM_ERROR("Failed to initialize connector with drm\n");
    875		return ret;
    876	}
    877	drm_connector_helper_add(&adv->connector,
    878				 &adv7511_connector_helper_funcs);
    879	drm_connector_attach_encoder(&adv->connector, bridge->encoder);
    880
    881	return 0;
    882}
    883
    884/* -----------------------------------------------------------------------------
    885 * DRM Bridge Operations
    886 */
    887
    888static struct adv7511 *bridge_to_adv7511(struct drm_bridge *bridge)
    889{
    890	return container_of(bridge, struct adv7511, bridge);
    891}
    892
    893static void adv7511_bridge_enable(struct drm_bridge *bridge)
    894{
    895	struct adv7511 *adv = bridge_to_adv7511(bridge);
    896
    897	adv7511_power_on(adv);
    898}
    899
    900static void adv7511_bridge_disable(struct drm_bridge *bridge)
    901{
    902	struct adv7511 *adv = bridge_to_adv7511(bridge);
    903
    904	adv7511_power_off(adv);
    905}
    906
    907static void adv7511_bridge_mode_set(struct drm_bridge *bridge,
    908				    const struct drm_display_mode *mode,
    909				    const struct drm_display_mode *adj_mode)
    910{
    911	struct adv7511 *adv = bridge_to_adv7511(bridge);
    912
    913	adv7511_mode_set(adv, mode, adj_mode);
    914}
    915
    916static int adv7511_bridge_attach(struct drm_bridge *bridge,
    917				 enum drm_bridge_attach_flags flags)
    918{
    919	struct adv7511 *adv = bridge_to_adv7511(bridge);
    920	int ret = 0;
    921
    922	if (!(flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)) {
    923		ret = adv7511_connector_init(adv);
    924		if (ret < 0)
    925			return ret;
    926	}
    927
    928	if (adv->i2c_main->irq)
    929		regmap_write(adv->regmap, ADV7511_REG_INT_ENABLE(0),
    930			     ADV7511_INT0_HPD);
    931
    932	return ret;
    933}
    934
    935static enum drm_connector_status adv7511_bridge_detect(struct drm_bridge *bridge)
    936{
    937	struct adv7511 *adv = bridge_to_adv7511(bridge);
    938
    939	return adv7511_detect(adv, NULL);
    940}
    941
    942static struct edid *adv7511_bridge_get_edid(struct drm_bridge *bridge,
    943					    struct drm_connector *connector)
    944{
    945	struct adv7511 *adv = bridge_to_adv7511(bridge);
    946
    947	return adv7511_get_edid(adv, connector);
    948}
    949
    950static void adv7511_bridge_hpd_notify(struct drm_bridge *bridge,
    951				      enum drm_connector_status status)
    952{
    953	struct adv7511 *adv = bridge_to_adv7511(bridge);
    954
    955	if (status == connector_status_disconnected)
    956		cec_phys_addr_invalidate(adv->cec_adap);
    957}
    958
    959static const struct drm_bridge_funcs adv7511_bridge_funcs = {
    960	.enable = adv7511_bridge_enable,
    961	.disable = adv7511_bridge_disable,
    962	.mode_set = adv7511_bridge_mode_set,
    963	.attach = adv7511_bridge_attach,
    964	.detect = adv7511_bridge_detect,
    965	.get_edid = adv7511_bridge_get_edid,
    966	.hpd_notify = adv7511_bridge_hpd_notify,
    967};
    968
    969/* -----------------------------------------------------------------------------
    970 * Probe & remove
    971 */
    972
    973static const char * const adv7511_supply_names[] = {
    974	"avdd",
    975	"dvdd",
    976	"pvdd",
    977	"bgvdd",
    978	"dvdd-3v",
    979};
    980
    981static const char * const adv7533_supply_names[] = {
    982	"avdd",
    983	"dvdd",
    984	"pvdd",
    985	"a2vdd",
    986	"v3p3",
    987	"v1p2",
    988};
    989
    990static int adv7511_init_regulators(struct adv7511 *adv)
    991{
    992	struct device *dev = &adv->i2c_main->dev;
    993	const char * const *supply_names;
    994	unsigned int i;
    995	int ret;
    996
    997	if (adv->type == ADV7511) {
    998		supply_names = adv7511_supply_names;
    999		adv->num_supplies = ARRAY_SIZE(adv7511_supply_names);
   1000	} else {
   1001		supply_names = adv7533_supply_names;
   1002		adv->num_supplies = ARRAY_SIZE(adv7533_supply_names);
   1003	}
   1004
   1005	adv->supplies = devm_kcalloc(dev, adv->num_supplies,
   1006				     sizeof(*adv->supplies), GFP_KERNEL);
   1007	if (!adv->supplies)
   1008		return -ENOMEM;
   1009
   1010	for (i = 0; i < adv->num_supplies; i++)
   1011		adv->supplies[i].supply = supply_names[i];
   1012
   1013	ret = devm_regulator_bulk_get(dev, adv->num_supplies, adv->supplies);
   1014	if (ret)
   1015		return ret;
   1016
   1017	return regulator_bulk_enable(adv->num_supplies, adv->supplies);
   1018}
   1019
   1020static void adv7511_uninit_regulators(struct adv7511 *adv)
   1021{
   1022	regulator_bulk_disable(adv->num_supplies, adv->supplies);
   1023}
   1024
   1025static bool adv7511_cec_register_volatile(struct device *dev, unsigned int reg)
   1026{
   1027	struct i2c_client *i2c = to_i2c_client(dev);
   1028	struct adv7511 *adv7511 = i2c_get_clientdata(i2c);
   1029
   1030	reg -= adv7511->reg_cec_offset;
   1031
   1032	switch (reg) {
   1033	case ADV7511_REG_CEC_RX1_FRAME_HDR:
   1034	case ADV7511_REG_CEC_RX1_FRAME_DATA0 ... ADV7511_REG_CEC_RX1_FRAME_DATA0 + 14:
   1035	case ADV7511_REG_CEC_RX1_FRAME_LEN:
   1036	case ADV7511_REG_CEC_RX2_FRAME_HDR:
   1037	case ADV7511_REG_CEC_RX2_FRAME_DATA0 ... ADV7511_REG_CEC_RX2_FRAME_DATA0 + 14:
   1038	case ADV7511_REG_CEC_RX2_FRAME_LEN:
   1039	case ADV7511_REG_CEC_RX3_FRAME_HDR:
   1040	case ADV7511_REG_CEC_RX3_FRAME_DATA0 ... ADV7511_REG_CEC_RX3_FRAME_DATA0 + 14:
   1041	case ADV7511_REG_CEC_RX3_FRAME_LEN:
   1042	case ADV7511_REG_CEC_RX_STATUS:
   1043	case ADV7511_REG_CEC_RX_BUFFERS:
   1044	case ADV7511_REG_CEC_TX_LOW_DRV_CNT:
   1045		return true;
   1046	}
   1047
   1048	return false;
   1049}
   1050
   1051static const struct regmap_config adv7511_cec_regmap_config = {
   1052	.reg_bits = 8,
   1053	.val_bits = 8,
   1054
   1055	.max_register = 0xff,
   1056	.cache_type = REGCACHE_RBTREE,
   1057	.volatile_reg = adv7511_cec_register_volatile,
   1058};
   1059
   1060static int adv7511_init_cec_regmap(struct adv7511 *adv)
   1061{
   1062	int ret;
   1063
   1064	adv->i2c_cec = i2c_new_ancillary_device(adv->i2c_main, "cec",
   1065						ADV7511_CEC_I2C_ADDR_DEFAULT);
   1066	if (IS_ERR(adv->i2c_cec))
   1067		return PTR_ERR(adv->i2c_cec);
   1068	i2c_set_clientdata(adv->i2c_cec, adv);
   1069
   1070	adv->regmap_cec = devm_regmap_init_i2c(adv->i2c_cec,
   1071					&adv7511_cec_regmap_config);
   1072	if (IS_ERR(adv->regmap_cec)) {
   1073		ret = PTR_ERR(adv->regmap_cec);
   1074		goto err;
   1075	}
   1076
   1077	if (adv->type == ADV7533 || adv->type == ADV7535) {
   1078		ret = adv7533_patch_cec_registers(adv);
   1079		if (ret)
   1080			goto err;
   1081
   1082		adv->reg_cec_offset = ADV7533_REG_CEC_OFFSET;
   1083	}
   1084
   1085	return 0;
   1086err:
   1087	i2c_unregister_device(adv->i2c_cec);
   1088	return ret;
   1089}
   1090
   1091static int adv7511_parse_dt(struct device_node *np,
   1092			    struct adv7511_link_config *config)
   1093{
   1094	const char *str;
   1095	int ret;
   1096
   1097	of_property_read_u32(np, "adi,input-depth", &config->input_color_depth);
   1098	if (config->input_color_depth != 8 && config->input_color_depth != 10 &&
   1099	    config->input_color_depth != 12)
   1100		return -EINVAL;
   1101
   1102	ret = of_property_read_string(np, "adi,input-colorspace", &str);
   1103	if (ret < 0)
   1104		return ret;
   1105
   1106	if (!strcmp(str, "rgb"))
   1107		config->input_colorspace = HDMI_COLORSPACE_RGB;
   1108	else if (!strcmp(str, "yuv422"))
   1109		config->input_colorspace = HDMI_COLORSPACE_YUV422;
   1110	else if (!strcmp(str, "yuv444"))
   1111		config->input_colorspace = HDMI_COLORSPACE_YUV444;
   1112	else
   1113		return -EINVAL;
   1114
   1115	ret = of_property_read_string(np, "adi,input-clock", &str);
   1116	if (ret < 0)
   1117		return ret;
   1118
   1119	if (!strcmp(str, "1x"))
   1120		config->input_clock = ADV7511_INPUT_CLOCK_1X;
   1121	else if (!strcmp(str, "2x"))
   1122		config->input_clock = ADV7511_INPUT_CLOCK_2X;
   1123	else if (!strcmp(str, "ddr"))
   1124		config->input_clock = ADV7511_INPUT_CLOCK_DDR;
   1125	else
   1126		return -EINVAL;
   1127
   1128	if (config->input_colorspace == HDMI_COLORSPACE_YUV422 ||
   1129	    config->input_clock != ADV7511_INPUT_CLOCK_1X) {
   1130		ret = of_property_read_u32(np, "adi,input-style",
   1131					   &config->input_style);
   1132		if (ret)
   1133			return ret;
   1134
   1135		if (config->input_style < 1 || config->input_style > 3)
   1136			return -EINVAL;
   1137
   1138		ret = of_property_read_string(np, "adi,input-justification",
   1139					      &str);
   1140		if (ret < 0)
   1141			return ret;
   1142
   1143		if (!strcmp(str, "left"))
   1144			config->input_justification =
   1145				ADV7511_INPUT_JUSTIFICATION_LEFT;
   1146		else if (!strcmp(str, "evenly"))
   1147			config->input_justification =
   1148				ADV7511_INPUT_JUSTIFICATION_EVENLY;
   1149		else if (!strcmp(str, "right"))
   1150			config->input_justification =
   1151				ADV7511_INPUT_JUSTIFICATION_RIGHT;
   1152		else
   1153			return -EINVAL;
   1154
   1155	} else {
   1156		config->input_style = 1;
   1157		config->input_justification = ADV7511_INPUT_JUSTIFICATION_LEFT;
   1158	}
   1159
   1160	of_property_read_u32(np, "adi,clock-delay", &config->clock_delay);
   1161	if (config->clock_delay < -1200 || config->clock_delay > 1600)
   1162		return -EINVAL;
   1163
   1164	config->embedded_sync = of_property_read_bool(np, "adi,embedded-sync");
   1165
   1166	/* Hardcode the sync pulse configurations for now. */
   1167	config->sync_pulse = ADV7511_INPUT_SYNC_PULSE_NONE;
   1168	config->vsync_polarity = ADV7511_SYNC_POLARITY_PASSTHROUGH;
   1169	config->hsync_polarity = ADV7511_SYNC_POLARITY_PASSTHROUGH;
   1170
   1171	return 0;
   1172}
   1173
   1174static int adv7511_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
   1175{
   1176	struct adv7511_link_config link_config;
   1177	struct adv7511 *adv7511;
   1178	struct device *dev = &i2c->dev;
   1179	unsigned int val;
   1180	int ret;
   1181
   1182	if (!dev->of_node)
   1183		return -EINVAL;
   1184
   1185	adv7511 = devm_kzalloc(dev, sizeof(*adv7511), GFP_KERNEL);
   1186	if (!adv7511)
   1187		return -ENOMEM;
   1188
   1189	adv7511->i2c_main = i2c;
   1190	adv7511->powered = false;
   1191	adv7511->status = connector_status_disconnected;
   1192
   1193	if (dev->of_node)
   1194		adv7511->type = (enum adv7511_type)of_device_get_match_data(dev);
   1195	else
   1196		adv7511->type = id->driver_data;
   1197
   1198	memset(&link_config, 0, sizeof(link_config));
   1199
   1200	if (adv7511->type == ADV7511)
   1201		ret = adv7511_parse_dt(dev->of_node, &link_config);
   1202	else
   1203		ret = adv7533_parse_dt(dev->of_node, adv7511);
   1204	if (ret)
   1205		return ret;
   1206
   1207	ret = adv7511_init_regulators(adv7511);
   1208	if (ret) {
   1209		dev_err(dev, "failed to init regulators\n");
   1210		return ret;
   1211	}
   1212
   1213	/*
   1214	 * The power down GPIO is optional. If present, toggle it from active to
   1215	 * inactive to wake up the encoder.
   1216	 */
   1217	adv7511->gpio_pd = devm_gpiod_get_optional(dev, "pd", GPIOD_OUT_HIGH);
   1218	if (IS_ERR(adv7511->gpio_pd)) {
   1219		ret = PTR_ERR(adv7511->gpio_pd);
   1220		goto uninit_regulators;
   1221	}
   1222
   1223	if (adv7511->gpio_pd) {
   1224		usleep_range(5000, 6000);
   1225		gpiod_set_value_cansleep(adv7511->gpio_pd, 0);
   1226	}
   1227
   1228	adv7511->regmap = devm_regmap_init_i2c(i2c, &adv7511_regmap_config);
   1229	if (IS_ERR(adv7511->regmap)) {
   1230		ret = PTR_ERR(adv7511->regmap);
   1231		goto uninit_regulators;
   1232	}
   1233
   1234	ret = regmap_read(adv7511->regmap, ADV7511_REG_CHIP_REVISION, &val);
   1235	if (ret)
   1236		goto uninit_regulators;
   1237	dev_dbg(dev, "Rev. %d\n", val);
   1238
   1239	if (adv7511->type == ADV7511)
   1240		ret = regmap_register_patch(adv7511->regmap,
   1241					    adv7511_fixed_registers,
   1242					    ARRAY_SIZE(adv7511_fixed_registers));
   1243	else
   1244		ret = adv7533_patch_registers(adv7511);
   1245	if (ret)
   1246		goto uninit_regulators;
   1247
   1248	adv7511_packet_disable(adv7511, 0xffff);
   1249
   1250	adv7511->i2c_edid = i2c_new_ancillary_device(i2c, "edid",
   1251					ADV7511_EDID_I2C_ADDR_DEFAULT);
   1252	if (IS_ERR(adv7511->i2c_edid)) {
   1253		ret = PTR_ERR(adv7511->i2c_edid);
   1254		goto uninit_regulators;
   1255	}
   1256
   1257	regmap_write(adv7511->regmap, ADV7511_REG_EDID_I2C_ADDR,
   1258		     adv7511->i2c_edid->addr << 1);
   1259
   1260	adv7511->i2c_packet = i2c_new_ancillary_device(i2c, "packet",
   1261					ADV7511_PACKET_I2C_ADDR_DEFAULT);
   1262	if (IS_ERR(adv7511->i2c_packet)) {
   1263		ret = PTR_ERR(adv7511->i2c_packet);
   1264		goto err_i2c_unregister_edid;
   1265	}
   1266
   1267	regmap_write(adv7511->regmap, ADV7511_REG_PACKET_I2C_ADDR,
   1268		     adv7511->i2c_packet->addr << 1);
   1269
   1270	ret = adv7511_init_cec_regmap(adv7511);
   1271	if (ret)
   1272		goto err_i2c_unregister_packet;
   1273
   1274	regmap_write(adv7511->regmap, ADV7511_REG_CEC_I2C_ADDR,
   1275		     adv7511->i2c_cec->addr << 1);
   1276
   1277	INIT_WORK(&adv7511->hpd_work, adv7511_hpd_work);
   1278
   1279	if (i2c->irq) {
   1280		init_waitqueue_head(&adv7511->wq);
   1281
   1282		ret = devm_request_threaded_irq(dev, i2c->irq, NULL,
   1283						adv7511_irq_handler,
   1284						IRQF_ONESHOT, dev_name(dev),
   1285						adv7511);
   1286		if (ret)
   1287			goto err_unregister_cec;
   1288	}
   1289
   1290	adv7511_power_off(adv7511);
   1291
   1292	i2c_set_clientdata(i2c, adv7511);
   1293
   1294	if (adv7511->type == ADV7511)
   1295		adv7511_set_link_config(adv7511, &link_config);
   1296
   1297	ret = adv7511_cec_init(dev, adv7511);
   1298	if (ret)
   1299		goto err_unregister_cec;
   1300
   1301	adv7511->bridge.funcs = &adv7511_bridge_funcs;
   1302	adv7511->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID;
   1303	if (adv7511->i2c_main->irq)
   1304		adv7511->bridge.ops |= DRM_BRIDGE_OP_HPD;
   1305
   1306	adv7511->bridge.of_node = dev->of_node;
   1307	adv7511->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
   1308
   1309	drm_bridge_add(&adv7511->bridge);
   1310
   1311	adv7511_audio_init(dev, adv7511);
   1312
   1313	if (adv7511->type == ADV7533 || adv7511->type == ADV7535) {
   1314		ret = adv7533_attach_dsi(adv7511);
   1315		if (ret)
   1316			goto err_unregister_audio;
   1317	}
   1318
   1319	return 0;
   1320
   1321err_unregister_audio:
   1322	adv7511_audio_exit(adv7511);
   1323	drm_bridge_remove(&adv7511->bridge);
   1324err_unregister_cec:
   1325	cec_unregister_adapter(adv7511->cec_adap);
   1326	i2c_unregister_device(adv7511->i2c_cec);
   1327	clk_disable_unprepare(adv7511->cec_clk);
   1328err_i2c_unregister_packet:
   1329	i2c_unregister_device(adv7511->i2c_packet);
   1330err_i2c_unregister_edid:
   1331	i2c_unregister_device(adv7511->i2c_edid);
   1332uninit_regulators:
   1333	adv7511_uninit_regulators(adv7511);
   1334
   1335	return ret;
   1336}
   1337
   1338static int adv7511_remove(struct i2c_client *i2c)
   1339{
   1340	struct adv7511 *adv7511 = i2c_get_clientdata(i2c);
   1341
   1342	i2c_unregister_device(adv7511->i2c_cec);
   1343	clk_disable_unprepare(adv7511->cec_clk);
   1344
   1345	adv7511_uninit_regulators(adv7511);
   1346
   1347	drm_bridge_remove(&adv7511->bridge);
   1348
   1349	adv7511_audio_exit(adv7511);
   1350
   1351	cec_unregister_adapter(adv7511->cec_adap);
   1352
   1353	i2c_unregister_device(adv7511->i2c_packet);
   1354	i2c_unregister_device(adv7511->i2c_edid);
   1355
   1356	return 0;
   1357}
   1358
   1359static const struct i2c_device_id adv7511_i2c_ids[] = {
   1360	{ "adv7511", ADV7511 },
   1361	{ "adv7511w", ADV7511 },
   1362	{ "adv7513", ADV7511 },
   1363	{ "adv7533", ADV7533 },
   1364	{ "adv7535", ADV7535 },
   1365	{ }
   1366};
   1367MODULE_DEVICE_TABLE(i2c, adv7511_i2c_ids);
   1368
   1369static const struct of_device_id adv7511_of_ids[] = {
   1370	{ .compatible = "adi,adv7511", .data = (void *)ADV7511 },
   1371	{ .compatible = "adi,adv7511w", .data = (void *)ADV7511 },
   1372	{ .compatible = "adi,adv7513", .data = (void *)ADV7511 },
   1373	{ .compatible = "adi,adv7533", .data = (void *)ADV7533 },
   1374	{ .compatible = "adi,adv7535", .data = (void *)ADV7535 },
   1375	{ }
   1376};
   1377MODULE_DEVICE_TABLE(of, adv7511_of_ids);
   1378
   1379static struct mipi_dsi_driver adv7533_dsi_driver = {
   1380	.driver.name = "adv7533",
   1381};
   1382
   1383static struct i2c_driver adv7511_driver = {
   1384	.driver = {
   1385		.name = "adv7511",
   1386		.of_match_table = adv7511_of_ids,
   1387	},
   1388	.id_table = adv7511_i2c_ids,
   1389	.probe = adv7511_probe,
   1390	.remove = adv7511_remove,
   1391};
   1392
   1393static int __init adv7511_init(void)
   1394{
   1395	if (IS_ENABLED(CONFIG_DRM_MIPI_DSI))
   1396		mipi_dsi_driver_register(&adv7533_dsi_driver);
   1397
   1398	return i2c_add_driver(&adv7511_driver);
   1399}
   1400module_init(adv7511_init);
   1401
   1402static void __exit adv7511_exit(void)
   1403{
   1404	i2c_del_driver(&adv7511_driver);
   1405
   1406	if (IS_ENABLED(CONFIG_DRM_MIPI_DSI))
   1407		mipi_dsi_driver_unregister(&adv7533_dsi_driver);
   1408}
   1409module_exit(adv7511_exit);
   1410
   1411MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
   1412MODULE_DESCRIPTION("ADV7511 HDMI transmitter driver");
   1413MODULE_LICENSE("GPL");