Hi Andrzej
I will fixed these and upstream.
Thanks for your comment.
-----Original Message----- From: Andrzej Hajda [mailto:a.hajda@samsung.com] Sent: Friday, January 22, 2021 7:02 PM To: Allen Chen (陳柏宇) Cc: Kenneth Hung (洪家倫); Jitao Shi; Jau-Chih Tseng (曾昭智); Yilun Lin; David Airlie; Neil Armstrong; Jernej Skrabec; open list:DRM DRIVERS; open list; Hermes Wu (吳佳宏); moderated list:ARM/Mediatek SoC support; Laurent Pinchart; Pi-Hsun Shih; Matthias Brugger; moderated list:ARM/Mediatek SoC support; Jonas Karlman Subject: Re: [PATCH v6] drm/bridge: add it6505 driver
Hi Allen,
Sorry for long delay.
W dniu 08.12.2020 o 11:58, allen pisze:
This adds support for the iTE IT6505. This device can convert DPI signal to DP output.
From: Allen Chen allen.chen@ite.com.tw Signed-off-by: Jitao Shi jitao.shi@mediatek.com Signed-off-by: Pi-Hsun Shih pihsun@chromium.org Signed-off-by: Yilun Lin yllin@google.com Signed-off-by: Hermes Wu hermes.wu@ite.com.tw Signed-off-by: Allen Chen allen.chen@ite.com.tw
drivers/gpu/drm/bridge/Kconfig | 7 + drivers/gpu/drm/bridge/Makefile | 1 + drivers/gpu/drm/bridge/ite-it6505.c | 3343 +++++++++++++++++++++++++++ 3 files changed, 3351 insertions(+) create mode 100644 drivers/gpu/drm/bridge/ite-it6505.c
diff --git a/drivers/gpu/drm/bridge/Kconfig b/drivers/gpu/drm/bridge/Kconfig index e4110d6ca7b3c..25d34d7196004 100644 --- a/drivers/gpu/drm/bridge/Kconfig +++ b/drivers/gpu/drm/bridge/Kconfig @@ -74,6 +74,13 @@ config DRM_LONTIUM_LT9611UXC HDMI signals Please say Y if you have such hardware.
+config DRM_ITE_IT6505
- tristate "ITE IT6505 DisplayPort bridge"
- depends on OF
- select DRM_KMS_HELPER
- help
ITE IT6505 DisplayPort bridge chip driver.- config DRM_LVDS_CODEC tristate "Transparent LVDS encoders and decoders support" depends on OF
diff --git a/drivers/gpu/drm/bridge/Makefile b/drivers/gpu/drm/bridge/Makefile index 86e7acc76f8d6..2b2f8f0b5b0fa 100644 --- a/drivers/gpu/drm/bridge/Makefile +++ b/drivers/gpu/drm/bridge/Makefile @@ -4,6 +4,7 @@ obj-$(CONFIG_DRM_CHRONTEL_CH7033) += chrontel-ch7033.o obj-$(CONFIG_DRM_DISPLAY_CONNECTOR) += display-connector.o obj-$(CONFIG_DRM_LONTIUM_LT9611) += lontium-lt9611.o obj-$(CONFIG_DRM_LONTIUM_LT9611UXC) += lontium-lt9611uxc.o +obj-$(CONFIG_DRM_ITE_IT6505) += ite-it6505.o
Please keep alphabetic order.
obj-$(CONFIG_DRM_LVDS_CODEC) += lvds-codec.o obj-$(CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW) += megachips-stdpxxxx-ge-b850v3-fw.o obj-$(CONFIG_DRM_NXP_PTN3460) += nxp-ptn3460.o diff --git a/drivers/gpu/drm/bridge/ite-it6505.c b/drivers/gpu/drm/bridge/ite-it6505.c new file mode 100644 index 0000000000000..5e76719a51a4a --- /dev/null +++ b/drivers/gpu/drm/bridge/ite-it6505.c @@ -0,0 +1,3343 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/*
- Copyright (c) 2020, The Linux Foundation. All rights reserved.
- */
+#include <linux/bits.h> +#include <linux/delay.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/extcon.h> +#include <linux/fs.h> +#include <linux/gpio/consumer.h> +#include <linux/i2c.h> +#include <linux/interrupt.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/pm_runtime.h> +#include <linux/regmap.h> +#include <linux/regulator/consumer.h> +#include <linux/types.h> +#include <linux/wait.h>
+#include <crypto/hash.h>
+#include <drm/drm_atomic_helper.h> +#include <drm/drm_bridge.h> +#include <drm/drm_crtc.h> +#include <drm/drm_crtc_helper.h> +#include <drm/drm_dp_helper.h> +#include <drm/drm_edid.h> +#include <drm/drm_hdcp.h> +#include <drm/drm_print.h> +#include <drm/drm_probe_helper.h>
+#include <sound/hdmi-codec.h>
+#define REG_IC_VER 0x04
+#define REG_RESET_CTRL 0x05 +#define VIDEO_RESET BIT(0) +#define AUDIO_RESET BIT(1) +#define ALL_LOGIC_RESET BIT(2) +#define AUX_RESET BIT(3) +#define HDCP_RESET BIT(4)
+#define INT_STATUS_01 0x06 +#define INT_MASK_01 0x09 +#define INT_HPD_CHANGE BIT(0) +#define INT_RECEIVE_HPD_IRQ BIT(1) +#define INT_SCDT_CHANGE BIT(2) +#define INT_HDCP_FAIL BIT(3) +#define INT_HDCP_DONE BIT(4)
+#define INT_STATUS_02 0x07 +#define INT_MASK_02 0x0A +#define INT_AUX_CMD_FAIL BIT(0) +#define INT_HDCP_KSV_CHECK BIT(1) +#define INT_AUDIO_FIFO_ERROR BIT(2)
+#define INT_STATUS_03 0x08 +#define INT_MASK_03 0x0B +#define INT_LINK_TRAIN_FAIL BIT(4) +#define INT_VID_FIFO_ERROR BIT(5) +#define INT_IO_LATCH_FIFO_OVERFLOW BIT(7)
+#define REG_SYSTEM_STS 0x0D +#define INT_STS BIT(0) +#define HPD_STS BIT(1) +#define VIDEO_STB BIT(2)
+#define REG_LINK_TRAIN_STS 0x0E +#define LINK_STATE_CR BIT(2) +#define LINK_STATE_EQ BIT(3) +#define LINK_STATE_NORP BIT(4)
+#define REG_BANK_SEL 0x0F +#define REG_CLK_CTRL0 0x10 +#define M_PCLK_DELAY 0x03
+#define REG_AUX_OPT 0x11 +#define AUX_AUTO_RST BIT(0) +#define AUX_FIX_FREQ BIT(3)
+#define REG_DATA_CTRL0 0x12 +#define VIDEO_LATCH_EDGE BIT(4) +#define ENABLE_PCLK_COUNTER BIT(7)
+#define REG_PCLK_COUNTER_VALUE 0x13
+#define REG_501_FIFO_CTRL 0x15 +#define RST_501_FIFO BIT(1)
+#define REG_TRAIN_CTRL0 0x16 +#define FORCE_LBR BIT(0) +#define LANE_COUNT_MASK 0x06 +#define LANE_SWAP BIT(3) +#define SPREAD_AMP_5 BIT(4) +#define FORCE_CR_DONE BIT(5) +#define FORCE_EQ_DONE BIT(6)
+#define REG_TRAIN_CTRL1 0x17 +#define AUTO_TRAIN BIT(0) +#define MANUAL_TRAIN BIT(1) +#define FORCE_RETRAIN BIT(2)
+#define REG_AUX_CTRL 0x23 +#define CLR_EDID_FIFO BIT(0) +#define AUX_USER_MODE BIT(1) +#define AUX_NO_SEGMENT_WR BIT(6) +#define AUX_EN_FIFO_READ BIT(7)
+#define REG_AUX_ADR_0_7 0x24 +#define REG_AUX_ADR_8_15 0x25 +#define REG_AUX_ADR_16_19 0x26 +#define REG_AUX_OUT_DATA0 0x27
+#define REG_AUX_CMD_REQ 0x2B +#define AUX_BUSY BIT(5)
+#define REG_AUX_DATA_0_7 0x2C +#define REG_AUX_DATA_8_15 0x2D +#define REG_AUX_DATA_16_23 0x2E +#define REG_AUX_DATA_24_31 0x2F
+#define REG_AUX_DATA_FIFO 0x2F
+#define REG_AUX_ERROR_STS 0x9F +#define M_AUX_REQ_FAIL 0x03
+#define REG_HDCP_CTRL1 0x38 +#define HDCP_CP_ENABLE BIT(0)
+#define REG_HDCP_TRIGGER 0x39 +#define HDCP_TRIGGER_START BIT(0) +#define HDCP_TRIGGER_CPIRQ BIT(1) +#define HDCP_TRIGGER_KSV_DONE BIT(4) +#define HDCP_TRIGGER_KSV_FAIL BIT(5)
+#define REG_HDCP_CTRL2 0x3A +#define HDCP_AN_SEL BIT(0) +#define HDCP_AN_GEN BIT(1) +#define HDCP_HW_HPDIRQ_ACT BIT(2) +#define HDCP_EN_M0_READ BIT(5)
+#define REG_M0_0_7 0x4C +#define REG_AN_0_7 0x4C +#define REG_SP_CTRL0 0x58 +#define REG_IP_CTRL1 0x59 +#define REG_IP_CTRL2 0x5A
+#define REG_LINK_DRV 0x5C +#define DRV_HS BIT(1)
+#define REG_DRV_LN_DATA_SEL 0x5D
+#define REG_AUX 0x5E
+#define REG_VID_BUS_CTRL0 0x60 +#define IN_DDR BIT(2) +#define DDR_CD (0x01 << 6)
+#define REG_VID_BUS_CTRL1 0x61 +#define TX_FIFO_RESET BIT(1)
+#define REG_INPUT_CTRL 0xA0 +#define INPUT_HSYNC_POL BIT(0) +#define INPUT_VSYNC_POL BIT(2) +#define INPUT_INTERLACED BIT(4)
+#define REG_INPUT_HTOTAL 0xA1 +#define REG_INPUT_HACTIVE_START 0xA3 +#define REG_INPUT_HACTIVE_WIDTH 0xA5 +#define REG_INPUT_HFRONT_PORCH 0xA7 +#define REG_INPUT_HSYNC_WIDTH 0xA9 +#define REG_INPUT_VTOTAL 0xAB +#define REG_INPUT_VACTIVE_START 0xAD +#define REG_INPUT_VACTIVE_WIDTH 0xAF +#define REG_INPUT_VFRONT_PORCH 0xB1 +#define REG_INPUT_VSYNC_WIDTH 0xB3
+#define REG_AUDIO_SRC_CTRL 0xB8 +#define M_AUDIO_I2S_EN 0x0F +#define EN_I2S0 BIT(0) +#define EN_I2S1 BIT(1) +#define EN_I2S2 BIT(2) +#define EN_I2S3 BIT(3) +#define AUDIO_FIFO_RESET BIT(7)
+#define REG_AUDIO_FMT 0xB9 +#define REG_AUDIO_FIFO_SEL 0xBA
+#define REG_AUDIO_CTRL0 0xBB +#define AUDIO_FULL_PKT BIT(4) +#define AUDIO_16B_BOUND BIT(5)
+#define REG_AUDIO_CTRL1 0xBC +#define REG_AUDIO_INPUT_FREQ 0xBE
+#define REG_IEC958_STS0 0xBF +#define REG_IEC958_STS1 0xC0 +#define REG_IEC958_STS2 0xC1 +#define REG_IEC958_STS3 0xC2 +#define REG_IEC958_STS4 0xC3
+#define REG_HPD_IRQ_TIME 0xC9 +#define REG_AUX_DEBUG_MODE 0xCA +#define REG_AUX_OPT2 0xCB +#define REG_HDCP_OPT 0xCE +#define REG_USER_DRV_PRE 0xCF
+#define REG_DATA_MUTE_CTRL 0xD3 +#define ENABLE_ENHANCED_FRAME BIT(0) +#define ENABLE_AUTO_VIDEO_FIFO_RESET BIT(1) +#define EN_VID_MUTE BIT(4) +#define EN_AUD_MUTE BIT(5)
+#define REG_TIME_STMP_CTRL 0xD4 +#define EN_ENHANCE_VID_STMP BIT(0) +#define EN_ENHANCE_AUD_STMP BIT(2) +#define M_STAMP_STEP 0x30 +#define EN_SSC_GAT BIT(6)
+#define REG_INFOFRAME_CTRL 0xE8 +#define EN_AVI_PKT BIT(0) +#define EN_AUD_PKT BIT(1) +#define EN_MPG_PKT BIT(2) +#define EN_GEN_PKT BIT(3) +#define EN_VID_TIME_STMP BIT(4) +#define EN_AUD_TIME_STMP BIT(5) +#define EN_VID_CTRL_PKT (EN_AVI_PKT | EN_VID_TIME_STMP) +#define EN_AUD_CTRL_PKT (EN_AUD_PKT | EN_AUD_TIME_STMP)
+#define REG_AUDIO_N_0_7 0xDE +#define REG_AUDIO_N_8_15 0xDF +#define REG_AUDIO_N_16_23 0xE0
+#define REG_AVI_INFO_DB1 0xE9 +#define REG_AVI_INFO_DB2 0xEA +#define REG_AVI_INFO_DB3 0xEB +#define REG_AVI_INFO_DB4 0xEC +#define REG_AVI_INFO_DB5 0xED +#define REG_AVI_INFO_SUM 0xF6
+#define REG_AUD_INFOFRAM_DB1 0xF7 +#define REG_AUD_INFOFRAM_DB2 0xF8 +#define REG_AUD_INFOFRAM_DB3 0xF9 +#define REG_AUD_INFOFRAM_DB4 0xFA +#define REG_AUD_INFOFRAM_SUM 0xFB
+/* the following six registers are in bank1 */ +#define REG_DRV_0_DB_800_MV 0x7E +#define REG_PRE_0_DB_800_MV 0x7F +#define REG_PRE_3P5_DB_800_MV 0x81 +#define REG_SSC_CTRL0 0x88 +#define REG_SSC_CTRL1 0x89 +#define REG_SSC_CTRL2 0x8A
+#define RBR DP_LINK_BW_1_62 +#define HBR DP_LINK_BW_2_7 +#define HBR2 DP_LINK_BW_5_4 +#define HBR3 DP_LINK_BW_8_1
+/* Vendor option */ +#define HDCP_DESIRED 1 +#define MAX_LANE_COUNT 4 +#define MAX_LINK_RATE HBR +#define AUTO_TRAIN_RETRY 3 +#define MAX_HDCP_DOWN_STREAM_COUNT 10 +#define MAX_CR_LEVEL 0x03 +#define MAX_EQ_LEVEL 0x03 +#define AUX_WAIT_TIMEOUT_MS 15 +#define AUX_FIFO_MAX_SIZE 32 +#define PIXEL_CLK_DELAY 1 +#define PIXEL_CLK_INVERSE 0 +#define ADJUST_PHASE_THRESHOLD 80000 +#define DPI_PIXEL_CLK_MAX 95000 +#define HDCP_SHA1_FIFO_LEN (MAX_HDCP_DOWN_STREAM_COUNT * 5 + 10) +#define DEFAULT_PWR_ON 0 +#define DEFAULT_DRV_HOLD 0
+#define AUDIO_SELECT I2S +#define AUDIO_TYPE LPCM +#define AUDIO_SAMPLE_RATE SAMPLE_RATE_48K
Better drop this define and use SAMPLE_RATE_48K directly.
+#define AUDIO_CHANNEL_COUNT 2
+/*
- 0: Standard I2S
- 1: 32bit I2S
- */
+#define I2S_INPUT_FORMAT 1
Maybe it would be more usable to use defines as follows:
+#define I2S_INPUT_FORMAT_STANDARD 0
+#define I2S_INPUT_FORMAT_32BIT 1
+#define I2S_INPUT_FORMAT_DEFAULT I2S_INPUT_FORMAT_32BIT
Less lines, no comments, self-documenting code. Even more I guess you can drop I2S_INPUT_FORMAT_DEFAULT and use I2S_INPUT_FORMAT_32BIT instead.
+/*
- 0: Left-justified
- 1: Right-justified
- */
+#define I2S_JUSTIFIED 0
+/*
- 0: Data delay 1T correspond to WS
- 1: No data delay correspond to WS
- */
+#define I2S_DATA_DELAY 0
+/*
- 0: Left channel
- 1: Right channel
- */
+#define I2S_WS_CHANNEL 0
+/*
- 0: MSB shift first
- 1: LSB shift first
- */
+#define I2S_DATA_SEQUENCE 0
ditto for above 4 defines
+/*
- Audio Sample Word Length
- WORD_LENGTH_16BIT
- WORD_LENGTH_18BIT
- WORD_LENGTH_20BIT
- WORD_LENGTH_24BIT
- */
+#define AUDIO_WORD_LENGTH WORD_LENGTH_24BIT
ditto, moreover using symbols not yet defined is confusing/ugly, even if the (pre)compiler allows it.
+enum aux_cmd_type {
- CMD_AUX_NATIVE_READ = 0x0,
- CMD_AUX_NATIVE_WRITE = 0x5,
- CMD_AUX_I2C_EDID_READ = 0xB,
+};
+enum aux_cmd_reply {
- REPLY_ACK,
- REPLY_NACK,
- REPLY_DEFER,
+};
+enum link_train_status {
- LINK_IDLE,
- LINK_BUSY,
- LINK_OK,
+};
+enum hdcp_state {
- HDCP_AUTH_IDLE,
- HDCP_AUTH_GOING,
- HDCP_AUTH_DONE,
+};
+struct it6505_platform_data {
- struct regulator *pwr18;
- struct regulator *ovdd;
- struct gpio_desc *gpiod_reset;
+};
+enum it6505_audio_select {
- I2S = 0,
- SPDIF,
+};
+enum it6505_audio_sample_rate {
- SAMPLE_RATE_24K = 0x6,
- SAMPLE_RATE_32K = 0x3,
- SAMPLE_RATE_48K = 0x2,
- SAMPLE_RATE_96K = 0xA,
- SAMPLE_RATE_192K = 0xE,
- SAMPLE_RATE_44_1K = 0x0,
- SAMPLE_RATE_88_2K = 0x8,
- SAMPLE_RATE_176_4K = 0xC,
+};
+enum it6505_audio_type {
- LPCM = 0,
- NLPCM,
- DSS,
+};
+enum it6505_audio_word_length {
- WORD_LENGTH_16BIT = 0,
- WORD_LENGTH_18BIT,
- WORD_LENGTH_20BIT,
- WORD_LENGTH_24BIT,
+};
+struct it6505_audio_data {
- enum it6505_audio_select select;
- enum it6505_audio_sample_rate sample_rate;
- enum it6505_audio_type type;
- enum it6505_audio_word_length word_length;
- u8 channel_count;
- u8 i2s_input_format;
- u8 i2s_justified;
- u8 i2s_data_delay;
- u8 i2s_ws_channel;
- u8 i2s_data_sequence;
+};
+struct it6505_audio_sample_rate_map {
- enum it6505_audio_sample_rate rate;
- int sample_rate_value;
+};
+struct it6505_drm_dp_link {
- unsigned char revision;
- unsigned int rate;
- unsigned int num_lanes;
- unsigned long capabilities;
+};
+struct it6505 {
- struct drm_dp_aux aux;
- struct drm_bridge bridge;
- struct i2c_client *client;
- struct edid *edid;
- struct drm_connector connector;
- struct it6505_drm_dp_link link;
- struct it6505_platform_data pdata;
- struct mutex extcon_lock;
- struct mutex mode_lock;
- struct mutex aux_lock;
- struct regmap *regmap;
- struct drm_display_mode video_info;
- struct notifier_block event_nb;
- struct extcon_dev *extcon;
- struct work_struct extcon_wq;
- enum drm_connector_status connector_status;
- enum link_train_status link_state;
- struct work_struct link_works;
- u8 dpcd[DP_RECEIVER_CAP_SIZE];
- u8 lane_count;
- u8 link_rate_bw_code;
- u8 sink_count;
- bool step_train;
- bool branch_device;
- bool enable_ssc;
- bool lane_swap_disabled;
- bool lane_swap;
- bool powered;
- u32 afe_setting;
- enum hdcp_state hdcp_status;
- struct delayed_work hdcp_work;
- struct work_struct hdcp_wait_ksv_list;
- struct completion wait_edid_complete;
- u8 auto_train_retry;
- bool hdcp_desired;
- bool is_repeater;
- u8 hdcp_down_stream_count;
- u8 bksvs[DRM_HDCP_KSV_LEN];
- u8 sha1_input[HDCP_SHA1_FIFO_LEN];
- bool enable_enhanced_frame;
- hdmi_codec_plugged_cb plugged_cb;
- struct device *codec_dev;
- struct delayed_work delayed_audio;
- struct it6505_audio_data audio;
- /* it6505 driver hold option */
- bool enable_drv_hold;
+};
+struct it6505_step_train_para {
- u8 voltage_swing[MAX_LANE_COUNT];
- u8 pre_emphasis[MAX_LANE_COUNT];
+};
+/*
- Vendor option afe settings for different platforms
- 0: without FPC cable
- 1: with FPC cable
- */
+static u8 const afe_setting_table[][3] = {
- {0x82, 0x00, 0x45},
- {0x93, 0x2A, 0x85}
+};
+static const struct it6505_audio_sample_rate_map audio_sample_rate_map[] = {
- {SAMPLE_RATE_24K, 24000},
- {SAMPLE_RATE_32K, 32000},
- {SAMPLE_RATE_48K, 48000},
- {SAMPLE_RATE_96K, 96000},
- {SAMPLE_RATE_192K, 192000},
- {SAMPLE_RATE_44_1K, 44100},
- {SAMPLE_RATE_88_2K, 88200},
- {SAMPLE_RATE_176_4K, 176400},
+};
+static const struct regmap_range it6505_bridge_volatile_ranges[] = {
- { .range_min = 0, .range_max = 0xFF },
+};
+static const struct regmap_access_table it6505_bridge_volatile_table = {
- .yes_ranges = it6505_bridge_volatile_ranges,
- .n_yes_ranges = ARRAY_SIZE(it6505_bridge_volatile_ranges),
+};
+static const struct regmap_config it6505_regmap_config = {
- .reg_bits = 8,
- .val_bits = 8,
- .volatile_table = &it6505_bridge_volatile_table,
- .cache_type = REGCACHE_NONE,
+};
+static int it6505_read(struct it6505 *it6505, unsigned int reg_addr) +{
- unsigned int value;
- int err;
- struct device *dev = &it6505->client->dev;
- err = regmap_read(it6505->regmap, reg_addr, &value);
- if (err < 0) {
DRM_DEV_ERROR(dev, "read failed reg[0x%x] err: %d", reg_addr,err);return err;- }
- return value;
+}
+static int it6505_write(struct it6505 *it6505, unsigned int reg_addr,
unsigned int reg_val)+{
- int err;
- struct device *dev = &it6505->client->dev;
- err = regmap_write(it6505->regmap, reg_addr, reg_val);
- if (err < 0) {
DRM_DEV_ERROR(dev, "write failed reg[0x%x] = 0x%x err = %d",reg_addr, reg_val, err);return err;- }
- return 0;
+}
+static int it6505_set_bits(struct it6505 *it6505, unsigned int reg,
unsigned int mask, unsigned int value)+{
- int err;
- struct device *dev = &it6505->client->dev;
- err = regmap_update_bits(it6505->regmap, reg, mask, value);
- if (err < 0) {
DRM_DEV_ERROR(dev, "write reg[0x%x] = 0x%x mask = 0x%x failed err %d",reg, value, mask, err);return err;- }
- return 0;
+}
+static void it6505_debug_print(struct it6505 *it6505, unsigned int reg,
const char *prefix)+{
- struct device *dev = &it6505->client->dev;
- int val;
- if (likely(!(__drm_debug & DRM_UT_DRIVER)))
return;- val = it6505_read(it6505, reg);
- if (val < 0)
DRM_DEV_DEBUG_DRIVER(dev, "%s reg[%02x] read error (%d)",prefix, reg, val);- else
DRM_DEV_DEBUG_DRIVER(dev, "%s reg[%02x] = 0x%02x", prefix, reg,val);+}
+static int it6505_dpcd_read(struct it6505 *it6505, unsigned long offset) +{
- u8 value;
- int ret;
- struct device *dev = &it6505->client->dev;
- ret = drm_dp_dpcd_readb(&it6505->aux, offset, &value);
- if (ret < 0) {
DRM_DEV_ERROR(dev, "DPCD read failed [0x%lx] ret: %d", offset,ret);return ret;- }
- return value;
+}
+static int it6505_dpcd_write(struct it6505 *it6505, unsigned long offset,
unsigned long datain)+{
- int ret;
- struct device *dev = &it6505->client->dev;
- ret = drm_dp_dpcd_writeb(&it6505->aux, offset, datain);
- if (ret < 0) {
DRM_DEV_ERROR(dev, "DPCD write failed [0x%lx] ret: %d", offset,ret);return ret;- }
- return 0;
+}
+static int it6505_get_dpcd(struct it6505 *it6505, int offset, u8 *dpcd, int num) +{
- int ret;
- struct device *dev = &it6505->client->dev;
- ret = drm_dp_dpcd_read(&it6505->aux, offset, dpcd, num);
- if (ret < 0)
return ret;- DRM_DEV_DEBUG_DRIVER(dev, "ret = %d DPCD[0x%x] = 0x%*ph", ret, offset,
num, dpcd);- return 0;
+}
+static void it6505_dump(struct it6505 *it6505) +{
- unsigned int i, j;
- u8 regs[16];
- struct device *dev = &it6505->client->dev;
- for (i = 0; i <= 0xff; i += 16) {
for (j = 0; j < 16; j++)regs[j] = it6505_read(it6505, i + j);DRM_DEV_DEBUG_DRIVER(dev, "[0x%02x] = %16ph", i, regs);- }
+}
+static bool it6505_get_sink_hpd_status(struct it6505 *it6505) +{
- int reg_0d;
- reg_0d = it6505_read(it6505, REG_SYSTEM_STS);
- if (reg_0d < 0)
return false;- return !!(reg_0d & HPD_STS);
Drop !!, compiler will perform correct conversion.
+}
+static int it6505_read_word(struct it6505 *it6505, unsigned int reg) +{
- int val0, val1;
- val0 = it6505_read(it6505, reg);
- if (val0 < 0)
return val0;- val1 = it6505_read(it6505, reg + 1);
- if (val1 < 0)
return val1;- return (val1 << 8) | val0;
+}
+static void it6505_calc_video_info(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- int hsync_pol, vsync_pol, interlaced;
- int htotal, hdes, hdew, hfph, hsyncw;
- int vtotal, vdes, vdew, vfph, vsyncw;
- int rddata, i, pclk, sum = 0;
- usleep_range(10000, 15000);
- it6505_write(it6505, REG_BANK_SEL, 0x00);
- rddata = it6505_read(it6505, REG_INPUT_CTRL);
- hsync_pol = rddata & INPUT_HSYNC_POL;
- vsync_pol = (rddata & INPUT_VSYNC_POL) >> 2;
- interlaced = (rddata & INPUT_INTERLACED) >> 4;
- htotal = it6505_read_word(it6505, REG_INPUT_HTOTAL) & 0x1FFF;
- hdes = it6505_read_word(it6505, REG_INPUT_HACTIVE_START) & 0x1FFF;
- hdew = it6505_read_word(it6505, REG_INPUT_HACTIVE_WIDTH) & 0x1FFF;
- hfph = it6505_read_word(it6505, REG_INPUT_HFRONT_PORCH) & 0x1FFF;
- hsyncw = it6505_read_word(it6505, REG_INPUT_HSYNC_WIDTH) & 0x1FFF;
- vtotal = it6505_read_word(it6505, REG_INPUT_VTOTAL) & 0xFFF;
- vdes = it6505_read_word(it6505, REG_INPUT_VACTIVE_START) & 0xFFF;
- vdew = it6505_read_word(it6505, REG_INPUT_VACTIVE_WIDTH) & 0xFFF;
- vfph = it6505_read_word(it6505, REG_INPUT_VFRONT_PORCH) & 0xFFF;
- vsyncw = it6505_read_word(it6505, REG_INPUT_VSYNC_WIDTH) & 0xFFF;
- DRM_DEV_DEBUG_DRIVER(dev, "hsync_pol:%d, vsync_pol:%d, interlaced:%d",
hsync_pol, vsync_pol, interlaced);- DRM_DEV_DEBUG_DRIVER(dev, "hactive_start:%d, vactive_start:%d",
hdes, vdes);- for (i = 0; i < 10; i++) {
it6505_set_bits(it6505, REG_DATA_CTRL0, ENABLE_PCLK_COUNTER,ENABLE_PCLK_COUNTER);usleep_range(10000, 15000);it6505_set_bits(it6505, REG_DATA_CTRL0, ENABLE_PCLK_COUNTER,0x00);rddata = it6505_read_word(it6505, REG_PCLK_COUNTER_VALUE) &0xFFF;sum += rddata;- }
- if (sum == 0) {
DRM_DEV_DEBUG_DRIVER(dev, "calc video timing error");return;- }
- sum /= 10;
- pclk = 13500 * 2048 / sum;
- it6505->video_info.clock = pclk;
- it6505->video_info.hdisplay = hdew;
- it6505->video_info.hsync_start = hdew + hfph;
- it6505->video_info.hsync_end = hdew + hfph + hsyncw;
- it6505->video_info.htotal = htotal;
- it6505->video_info.vdisplay = vdew;
- it6505->video_info.vsync_start = vdew + vfph;
- it6505->video_info.vsync_end = vdew + vfph + vsyncw;
- it6505->video_info.vtotal = vtotal;
- DRM_DEV_DEBUG_DRIVER(dev, DRM_MODE_FMT,
DRM_MODE_ARG(&it6505->video_info));+}
+static int it6505_drm_dp_link_probe(struct drm_dp_aux *aux,
struct it6505_drm_dp_link *link)+{
- u8 values[3];
- int err;
- memset(link, 0, sizeof(*link));
- err = drm_dp_dpcd_read(aux, DP_DPCD_REV, values, sizeof(values));
- if (err < 0)
return err;- link->revision = values[0];
- link->rate = drm_dp_bw_code_to_link_rate(values[1]);
- link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK;
- if (values[2] & DP_ENHANCED_FRAME_CAP)
link->capabilities = 1;- return 0;
+}
+static int it6505_drm_dp_link_power_up(struct drm_dp_aux *aux,
struct it6505_drm_dp_link *link)+{
- u8 value;
- int err;
- /* DP_SET_POWER register is only available on DPCD v1.1 and later */
- if (link->revision < 0x11)
return 0;- err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value);
- if (err < 0)
return err;- value &= ~DP_SET_POWER_MASK;
- value |= DP_SET_POWER_D0;
- err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value);
- if (err < 0)
return err;- /*
* According to the DP 1.1 specification, a "Sink Device must exit the* power saving state within 1 ms" (Section 2.5.3.1, Table 5-52, "Sink* Control Field" (register 0x600).*/- usleep_range(1000, 2000);
- return 0;
+}
+static void it6505_clear_int(struct it6505 *it6505) +{
- it6505_write(it6505, REG_BANK_SEL, 0x00);
- it6505_write(it6505, INT_STATUS_01, 0xFF);
- it6505_write(it6505, INT_STATUS_02, 0xFF);
- it6505_write(it6505, INT_STATUS_03, 0xFF);
+}
+static void it6505_int_mask_enable(struct it6505 *it6505) +{
- it6505_write(it6505, REG_BANK_SEL, 0x00);
- it6505_write(it6505, INT_MASK_01, 0x1F);
- it6505_write(it6505, INT_MASK_02, 0x07);
- it6505_write(it6505, INT_MASK_03, 0xB0);
+}
+static void it6505_int_mask_disable(struct it6505 *it6505) +{
- it6505_write(it6505, REG_BANK_SEL, 0x00);
- it6505_write(it6505, INT_MASK_01, 0x00);
- it6505_write(it6505, INT_MASK_02, 0x00);
- it6505_write(it6505, INT_MASK_03, 0x00);
+}
+static void it6505_lane_termination_on(struct it6505 *it6505) +{
- int regcf;
- regcf = it6505_read(it6505, REG_USER_DRV_PRE);
- if (regcf == 0xF0)
it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x00);- if (regcf == 0x70) {
if (it6505->lane_swap) {switch (it6505->lane_count) {case 1:case 2:it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,0x0C, 0x08);break;default:it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,0x0C, 0x0C);break;}} else {switch (it6505->lane_count) {case 1:case 2:it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,0x0C, 0x04);break;default:it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,0x0C, 0x0C);break;}}- }
+}
+static void it6505_lane_termination_off(struct it6505 *it6505) +{
- int regcf;
- regcf = it6505_read(it6505, REG_USER_DRV_PRE);
- if (regcf == 0xF0)
it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x80);- if (regcf == 0x70)
it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x0C, 0x00);+}
+static void it6505_lane_power_on(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_LINK_DRV, 0xF1,
(it6505->lane_swap ?GENMASK(7, 8 - it6505->lane_count) :GENMASK(3 + it6505->lane_count, 4)) |0x01);+}
+static void it6505_lane_power_off(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_LINK_DRV, 0xF0, 0x00);
+}
+static void it6505_lane_off(struct it6505 *it6505) +{
- it6505_lane_power_off(it6505);
- it6505_lane_termination_off(it6505);
+}
+static void it6505_aux_termination_on(struct it6505 *it6505) +{
- int regcf;
- regcf = it6505_read(it6505, REG_USER_DRV_PRE);
- if (regcf == 0xF0)
it6505_lane_termination_on(it6505);- if (regcf == 0x70)
it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x80);+}
+static void it6505_aux_power_on(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_AUX, 0x02, 0x02);
+}
+static void it6505_aux_on(struct it6505 *it6505) +{
- it6505_aux_power_on(it6505);
- it6505_aux_termination_on(it6505);
+}
+static void it6505_aux_reset(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_RESET_CTRL, AUX_RESET, AUX_RESET);
- it6505_set_bits(it6505, REG_RESET_CTRL, AUX_RESET, 0x00);
+}
+static void it6505_reset_logic(struct it6505 *it6505) +{
- regmap_write(it6505->regmap, REG_RESET_CTRL, ALL_LOGIC_RESET);
- usleep_range(1000, 1500);
+}
+static bool it6505_aux_op_finished(struct it6505 *it6505) +{
- int reg2b = it6505_read(it6505, REG_AUX_CMD_REQ);
- if (reg2b < 0)
return false;- return (reg2b & AUX_BUSY) == 0;
+}
+static int it6505_aux_wait(struct it6505 *it6505) +{
- int status;
- unsigned long timeout;
- struct device *dev = &it6505->client->dev;
- timeout = jiffies + msecs_to_jiffies(AUX_WAIT_TIMEOUT_MS) + 1;
- while (!it6505_aux_op_finished(it6505)) {
if (time_after(jiffies, timeout)) {DRM_DEV_ERROR(dev, "Timed out waiting AUX to finish");return -ETIMEDOUT;}usleep_range(1000, 2000);- }
- status = it6505_read(it6505, REG_AUX_ERROR_STS);
- if (status < 0) {
DRM_DEV_ERROR(dev, "Failed to read AUX channel: %d", status);return status;- }
- return 0;
+}
+static ssize_t it6505_aux_operation(struct it6505 *it6505,
enum aux_cmd_type cmd,unsigned int address, u8 *buffer,size_t size, enum aux_cmd_reply *reply)+{
- int i, ret;
- bool aux_write_check = false;
- if (!it6505_get_sink_hpd_status(it6505))
return -EIO;- /* set AUX user mode */
- it6505_set_bits(it6505, REG_AUX_CTRL, AUX_USER_MODE, AUX_USER_MODE);
+aux_op_start:
- if (cmd == CMD_AUX_I2C_EDID_READ) {
/* AUX EDID FIFO has max length of AUX_FIFO_MAX_SIZE bytes. */size = min_t(size_t, size, AUX_FIFO_MAX_SIZE);/* Enable AUX FIFO read back and clear FIFO */it6505_set_bits(it6505, REG_AUX_CTRL,AUX_EN_FIFO_READ | CLR_EDID_FIFO,AUX_EN_FIFO_READ | CLR_EDID_FIFO);it6505_set_bits(it6505, REG_AUX_CTRL,AUX_EN_FIFO_READ | CLR_EDID_FIFO,AUX_EN_FIFO_READ);- } else {
/* The DP AUX transmit buffer has 4 bytes. */size = min_t(size_t, size, 4);it6505_set_bits(it6505, REG_AUX_CTRL, AUX_NO_SEGMENT_WR,AUX_NO_SEGMENT_WR);- }
- /* Start Address[7:0] */
- it6505_write(it6505, REG_AUX_ADR_0_7, (address >> 0) & 0xFF);
- /* Start Address[15:8] */
- it6505_write(it6505, REG_AUX_ADR_8_15, (address >> 8) & 0xFF);
- /* WriteNum[3:0]+StartAdr[19:16] */
- it6505_write(it6505, REG_AUX_ADR_16_19,
((address >> 16) & 0x0F) | ((size - 1) << 4));- if (cmd == CMD_AUX_NATIVE_WRITE)
regmap_bulk_write(it6505->regmap, REG_AUX_OUT_DATA0, buffer,size);- /* Aux Fire */
- it6505_write(it6505, REG_AUX_CMD_REQ, cmd);
- ret = it6505_aux_wait(it6505);
- if (ret < 0)
goto aux_op_err;- ret = it6505_read(it6505, REG_AUX_ERROR_STS);
- if (ret < 0)
goto aux_op_err;- switch ((ret >> 6) & 0x3) {
- case 0:
*reply = REPLY_ACK;break;- case 1:
*reply = REPLY_DEFER;ret = -EAGAIN;goto aux_op_err;- case 2:
*reply = REPLY_NACK;ret = -EIO;goto aux_op_err;- case 3:
ret = -ETIMEDOUT;goto aux_op_err;- }
- /* Read back Native Write data */
- if (cmd == CMD_AUX_NATIVE_WRITE) {
aux_write_check = true;cmd = CMD_AUX_NATIVE_READ;goto aux_op_start;- }
- if (cmd == CMD_AUX_I2C_EDID_READ) {
for (i = 0; i < size; i++) {ret = it6505_read(it6505, REG_AUX_DATA_FIFO);if (ret < 0)goto aux_op_err;buffer[i] = ret;}- } else {
for (i = 0; i < size; i++) {ret = it6505_read(it6505, REG_AUX_DATA_0_7 + i);if (ret < 0)goto aux_op_err;if (aux_write_check && buffer[size - 1 - i] != ret) {ret = -EINVAL;goto aux_op_err;}buffer[size - 1 - i] = ret;}- }
- ret = i;
+aux_op_err:
- if (cmd == CMD_AUX_I2C_EDID_READ) {
/* clear AUX FIFO */it6505_set_bits(it6505, REG_AUX_CTRL,AUX_EN_FIFO_READ | CLR_EDID_FIFO,AUX_EN_FIFO_READ | CLR_EDID_FIFO);it6505_set_bits(it6505, REG_AUX_CTRL,AUX_EN_FIFO_READ | CLR_EDID_FIFO, 0x00);- }
- /* Leave AUX user mode */
- it6505_set_bits(it6505, REG_AUX_CTRL, AUX_USER_MODE, 0);
- return ret;
+}
+static ssize_t it6505_aux_do_transfer(struct it6505 *it6505,
enum aux_cmd_type cmd,unsigned int address, u8 *buffer,size_t size, enum aux_cmd_reply *reply)+{
- int i, ret_size, ret = 0, request_size;
- mutex_lock(&it6505->aux_lock);
- for (i = 0; i < size; i += 4) {
request_size = min((int)size - i, 4);ret_size = it6505_aux_operation(it6505, cmd, address + i,buffer + i, request_size,reply);if (ret_size < 0) {ret = ret_size;goto aux_op_err;}ret += ret_size;- }
+aux_op_err:
- mutex_unlock(&it6505->aux_lock);
- return ret;
+}
+static ssize_t it6505_aux_transfer(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)+{
- struct it6505 *it6505 = container_of(aux, struct it6505, aux);
- u8 cmd;
- bool is_i2c = !(msg->request & DP_AUX_NATIVE_WRITE);
- int ret;
- enum aux_cmd_reply reply;
- /* IT6505 doesn't support arbitrary I2C read / write. */
- if (is_i2c)
return -EINVAL;- switch (msg->request) {
- case DP_AUX_NATIVE_READ:
cmd = CMD_AUX_NATIVE_READ;break;- case DP_AUX_NATIVE_WRITE:
cmd = CMD_AUX_NATIVE_WRITE;break;- default:
return -EINVAL;- }
- ret = it6505_aux_do_transfer(it6505, cmd, msg->address, msg->buffer,
msg->size, &reply);- if (ret < 0)
return ret;- switch (reply) {
- case REPLY_ACK:
msg->reply = DP_AUX_NATIVE_REPLY_ACK;break;- case REPLY_NACK:
msg->reply = DP_AUX_NATIVE_REPLY_NACK;break;- case REPLY_DEFER:
msg->reply = DP_AUX_NATIVE_REPLY_DEFER;break;- }
- return ret;
+}
+static int it6505_get_edid_block(void *data, u8 *buf, unsigned int block,
size_t len)+{
- struct it6505 *it6505 = data;
- struct device *dev = &it6505->client->dev;
- enum aux_cmd_reply reply;
- int offset, ret, aux_retry = 100;
- it6505_aux_reset(it6505);
- DRM_DEV_DEBUG_DRIVER(dev, "block number = %d", block);
- for (offset = 0; offset < EDID_LENGTH;) {
ret = it6505_aux_do_transfer(it6505, CMD_AUX_I2C_EDID_READ,block * EDID_LENGTH + offset,buf + offset, 8, &reply);if (ret < 0 && ret != -EAGAIN)return ret;switch (reply) {case REPLY_ACK:DRM_DEV_DEBUG_DRIVER(dev, "[0x%02x]: %8ph", offset,buf + offset);offset += 8;aux_retry = 100;break;case REPLY_NACK:return -EIO;case REPLY_DEFER:msleep(20);if (!(--aux_retry))return -EIO;}- }
- return 0;
+}
+static void it6505_variable_config(struct it6505 *it6505) +{
- it6505->link_rate_bw_code = HBR;
- it6505->lane_count = MAX_LANE_COUNT;
- it6505->link_state = LINK_IDLE;
- it6505->hdcp_desired = HDCP_DESIRED;
- it6505->auto_train_retry = AUTO_TRAIN_RETRY;
- it6505->audio.select = AUDIO_SELECT;
- it6505->audio.sample_rate = AUDIO_SAMPLE_RATE;
- it6505->audio.channel_count = AUDIO_CHANNEL_COUNT;
- it6505->audio.type = AUDIO_TYPE;
- it6505->audio.i2s_input_format = I2S_INPUT_FORMAT;
- it6505->audio.i2s_justified = I2S_JUSTIFIED;
- it6505->audio.i2s_data_delay = I2S_DATA_DELAY;
- it6505->audio.i2s_ws_channel = I2S_WS_CHANNEL;
- it6505->audio.i2s_data_sequence = I2S_DATA_SEQUENCE;
- it6505->audio.word_length = AUDIO_WORD_LENGTH;
- memset(it6505->sha1_input, 0, sizeof(it6505->sha1_input));
- memset(it6505->bksvs, 0, sizeof(it6505->bksvs));
+}
+static int it6505_send_video_infoframe(struct it6505 *it6505,
struct hdmi_avi_infoframe *frame)+{
- u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE];
- int err;
- struct device *dev = &it6505->client->dev;
- err = hdmi_avi_infoframe_pack(frame, buffer, sizeof(buffer));
- if (err < 0) {
DRM_DEV_ERROR(dev, "Failed to pack AVI infoframe: %d", err);return err;- }
- err = it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AVI_PKT, 0x00);
- if (err)
return err;- err = regmap_bulk_write(it6505->regmap, REG_AVI_INFO_DB1,
buffer + HDMI_INFOFRAME_HEADER_SIZE,frame->length);- if (err)
return err;- err = it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AVI_PKT,
EN_AVI_PKT);- if (err)
return err;- return 0;
+}
+static void it6505_get_extcon_property(struct it6505 *it6505) +{
- int err;
- union extcon_property_value property;
- struct device *dev = &it6505->client->dev;
- if (it6505->extcon && !it6505->lane_swap_disabled) {
err = extcon_get_property(it6505->extcon, EXTCON_DISP_DP,EXTCON_PROP_USB_TYPEC_POLARITY,&property);if (err) {DRM_DEV_ERROR(dev, "get property fail!");return;}it6505->lane_swap = property.intval;- }
+}
+static void it6505_clk_phase_adjustment(struct it6505 *it6505,
const struct drm_display_mode *mode)+{
- it6505_set_bits(it6505, REG_CLK_CTRL0, M_PCLK_DELAY,
mode->clock < ADJUST_PHASE_THRESHOLD ? PIXEL_CLK_DELAY : 0);- it6505_set_bits(it6505, REG_DATA_CTRL0, VIDEO_LATCH_EDGE,
PIXEL_CLK_INVERSE << 4);+}
+static void it6505_init(struct it6505 *it6505) +{
- it6505_write(it6505, REG_BANK_SEL, 0x00);
- it6505_write(it6505, REG_AUX_OPT, AUX_AUTO_RST | AUX_FIX_FREQ);
- it6505_write(it6505, REG_AUX_CTRL, AUX_NO_SEGMENT_WR);
- it6505_write(it6505, REG_HDCP_CTRL2, HDCP_AN_SEL | HDCP_HW_HPDIRQ_ACT);
- it6505_write(it6505, REG_VID_BUS_CTRL0, IN_DDR | DDR_CD);
- it6505_write(it6505, REG_VID_BUS_CTRL1, 0x01);
- it6505_write(it6505, REG_AUDIO_CTRL0, AUDIO_16B_BOUND);
- /* chip internal setting, don't modify */
- it6505_write(it6505, REG_HPD_IRQ_TIME, 0xF5);
- it6505_write(it6505, REG_AUX_DEBUG_MODE, 0x4D);
- it6505_write(it6505, REG_AUX_OPT2, 0x17);
- it6505_write(it6505, REG_HDCP_OPT, 0x60);
- it6505_write(it6505, REG_DATA_MUTE_CTRL,
EN_VID_MUTE | EN_AUD_MUTE | ENABLE_AUTO_VIDEO_FIFO_RESET);- it6505_write(it6505, REG_TIME_STMP_CTRL,
EN_SSC_GAT | EN_ENHANCE_VID_STMP | EN_ENHANCE_AUD_STMP);- it6505_write(it6505, REG_INFOFRAME_CTRL, 0x00);
- it6505_write(it6505, REG_BANK_SEL, 0x01);
- it6505_write(it6505, REG_DRV_0_DB_800_MV,
afe_setting_table[it6505->afe_setting][0]);- it6505_write(it6505, REG_PRE_0_DB_800_MV,
afe_setting_table[it6505->afe_setting][1]);- it6505_write(it6505, REG_PRE_3P5_DB_800_MV,
afe_setting_table[it6505->afe_setting][2]);- it6505_write(it6505, REG_SSC_CTRL0, 0x9E);
- it6505_write(it6505, REG_SSC_CTRL1, 0x1C);
- it6505_write(it6505, REG_SSC_CTRL2, 0x42);
- it6505_write(it6505, REG_BANK_SEL, 0x00);
+}
+static void it6505_video_disable(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, EN_VID_MUTE);
- it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_VID_CTRL_PKT, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, VIDEO_RESET);
+}
+static void it6505_video_reset(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, EN_VID_MUTE);
- it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_VID_CTRL_PKT, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, VIDEO_RESET);
- it6505_set_bits(it6505, REG_501_FIFO_CTRL, RST_501_FIFO, RST_501_FIFO);
- it6505_set_bits(it6505, REG_501_FIFO_CTRL, RST_501_FIFO, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, 0x00);
+}
+static void it6505_update_video_parameter(struct it6505 *it6505,
const struct drm_display_mode *mode)+{
- it6505_clk_phase_adjustment(it6505, mode);
- it6505_video_disable(it6505);
+}
+static bool it6505_audio_input(struct it6505 *it6505) +{
- int reg05, regbe;
- reg05 = it6505_read(it6505, REG_RESET_CTRL);
- it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, 0x00);
- usleep_range(3000, 4000);
- regbe = it6505_read(it6505, REG_AUDIO_INPUT_FREQ);
- it6505_write(it6505, REG_RESET_CTRL, reg05);
- return regbe != 0xFF;
+}
+static void it6505_setup_audio_channel_status(struct it6505 *it6505) +{
- enum it6505_audio_sample_rate sample_rate = it6505->audio.sample_rate;
- u8 audio_word_length_map[] = { 0x02, 0x04, 0x03, 0x0B };
- /* Channel Status */
- it6505_write(it6505, REG_IEC958_STS0, it6505->audio.type << 1);
- it6505_write(it6505, REG_IEC958_STS1, 0x00);
- it6505_write(it6505, REG_IEC958_STS2, 0x00);
- it6505_write(it6505, REG_IEC958_STS3, sample_rate);
- it6505_write(it6505, REG_IEC958_STS4, (~sample_rate << 4) |
audio_word_length_map[it6505->audio.word_length]);+}
+static void it6505_setup_audio_format(struct it6505 *it6505) +{
- /* I2S MODE */
- it6505_write(it6505, REG_AUDIO_FMT,
(it6505->audio.word_length << 5) |(it6505->audio.i2s_data_sequence << 4) |(it6505->audio.i2s_ws_channel << 3) |(it6505->audio.i2s_data_delay << 2) |(it6505->audio.i2s_justified << 1) |it6505->audio.i2s_input_format);- if (it6505->audio.select == SPDIF) {
it6505_write(it6505, REG_AUDIO_FIFO_SEL, 0x00);/* 0x30 = 128*FS */it6505_set_bits(it6505, REG_AUX_OPT, 0xF0, 0x30);- } else {
it6505_write(it6505, REG_AUDIO_FIFO_SEL, 0xE4);- }
- it6505_write(it6505, REG_AUDIO_CTRL0, 0x20);
- it6505_write(it6505, REG_AUDIO_CTRL1, 0x00);
+}
+static void it6505_enable_audio_source(struct it6505 *it6505) +{
- unsigned int audio_source_count;
- audio_source_count = BIT(DIV_ROUND_UP(it6505->audio.channel_count, 2))
- 1;- audio_source_count |= it6505->audio.select << 4;
- it6505_write(it6505, REG_AUDIO_SRC_CTRL, audio_source_count);
+}
+static void it6505_enable_audio_infoframe(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- u8 audio_info_ca[] = { 0x00, 0x00, 0x01, 0x03, 0x07, 0x0B, 0x0F, 0x1F };
- DRM_DEV_DEBUG_DRIVER(dev, "infoframe channel_allocation:0x%02x",
audio_info_ca[it6505->audio.channel_count - 1]);- it6505_write(it6505, REG_AUD_INFOFRAM_DB1, it6505->audio.channel_count
- 1);- it6505_write(it6505, REG_AUD_INFOFRAM_DB2, 0x00);
- it6505_write(it6505, REG_AUD_INFOFRAM_DB3,
audio_info_ca[it6505->audio.channel_count - 1]);- it6505_write(it6505, REG_AUD_INFOFRAM_DB4, 0x00);
- it6505_write(it6505, REG_AUD_INFOFRAM_SUM, 0x00);
- /* Enable Audio InfoFrame */
- it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AUD_CTRL_PKT,
EN_AUD_CTRL_PKT);+}
+static void it6505_disable_audio(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_AUD_MUTE, EN_AUD_MUTE);
- it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, M_AUDIO_I2S_EN, 0x00);
- it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AUD_CTRL_PKT, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, AUDIO_RESET);
+}
+static void it6505_enable_audio(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- int regbe;
- DRM_DEV_DEBUG_DRIVER(dev, "start");
- it6505_disable_audio(it6505);
- it6505_setup_audio_channel_status(it6505);
- it6505_setup_audio_format(it6505);
- it6505_enable_audio_source(it6505);
- it6505_enable_audio_infoframe(it6505);
- it6505_write(it6505, REG_AUDIO_N_0_7, 0x00);
- it6505_write(it6505, REG_AUDIO_N_8_15, 0x80);
- it6505_write(it6505, REG_AUDIO_N_16_23, 0x00);
- it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, AUDIO_FIFO_RESET,
AUDIO_FIFO_RESET);- it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, AUDIO_FIFO_RESET, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, 0x00);
- regbe = it6505_read(it6505, REG_AUDIO_INPUT_FREQ);
- DRM_DEV_DEBUG_DRIVER(dev, "regbe:0x%02x audio input fs: %d.%d kHz",
regbe, 6750 / regbe, (6750 % regbe) * 10 / regbe);- it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_AUD_MUTE, 0x00);
+}
+static bool it6505_use_step_train_check(struct it6505 *it6505) +{
- if (it6505->link.revision >= 0x12)
return it6505->dpcd[DP_TRAINING_AUX_RD_INTERVAL] >= 0x01;- return true;
+}
+static void it6505_parse_link_capabilities(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- struct it6505_drm_dp_link *link = &it6505->link;
- int bcaps;
- if (it6505->dpcd[0] == 0) {
it6505_aux_on(it6505);it6505_get_dpcd(it6505, DP_DPCD_REV, it6505->dpcd,ARRAY_SIZE(it6505->dpcd));- }
- DRM_DEV_DEBUG_DRIVER(dev, "DPCD Rev.: %d.%d",
link->revision >> 4, link->revision & 0x0F);- DRM_DEV_DEBUG_DRIVER(dev, "Sink max link rate: %d.%02d Gbps per lane",
link->rate / 100000, link->rate / 1000 % 100);- it6505->link_rate_bw_code = drm_dp_link_rate_to_bw_code(link->rate);
- DRM_DEV_DEBUG_DRIVER(dev, "link rate bw code:0x%02x",
it6505->link_rate_bw_code);- it6505->link_rate_bw_code = min((int)it6505->link_rate_bw_code,
MAX_LINK_RATE);- it6505->lane_count = link->num_lanes;
- DRM_DEV_DEBUG_DRIVER(dev, "Sink support %d lanes training",
it6505->lane_count);- it6505->lane_count = min((int)it6505->lane_count, MAX_LANE_COUNT);
- it6505->branch_device = drm_dp_is_branch(it6505->dpcd);
- DRM_DEV_DEBUG_DRIVER(dev, "Sink %sbranch device",
it6505->branch_device ? "" : "Not ");- it6505->enable_enhanced_frame = !!link->capabilities;
- DRM_DEV_DEBUG_DRIVER(dev, "Sink %sSupport Enhanced Framing",
it6505->enable_enhanced_frame ? "" : "Not ");- it6505->enable_ssc = !!(it6505->dpcd[DP_MAX_DOWNSPREAD] &
DP_MAX_DOWNSPREAD_0_5);- DRM_DEV_DEBUG_DRIVER(dev, "Maximum Down-Spread: %s, %ssupport SSC!",
it6505->enable_ssc ? "0.5" : "0",it6505->enable_ssc ? "" : "Not ");- it6505->step_train = it6505_use_step_train_check(it6505);
- if (it6505->step_train)
DRM_DEV_DEBUG_DRIVER(dev, "auto train fail, will step train");- bcaps = it6505_dpcd_read(it6505, DP_AUX_HDCP_BCAPS);
- DRM_DEV_DEBUG_DRIVER(dev, "bcaps:0x%02x", bcaps);
- if (bcaps & DP_BCAPS_HDCP_CAPABLE) {
it6505->is_repeater = !!(bcaps & DP_BCAPS_REPEATER_PRESENT);DRM_DEV_DEBUG_DRIVER(dev, "Support HDCP! Downstream is %s!",it6505->is_repeater ? "repeater" :"receiver");- } else {
DRM_DEV_DEBUG_DRIVER(dev, "Sink not support HDCP!");it6505->hdcp_desired = false;- }
- DRM_DEV_DEBUG_DRIVER(dev, "HDCP %s",
it6505->hdcp_desired ? "desired" : "undesired");+}
+static void it6505_setup_ssc(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_TRAIN_CTRL0, SPREAD_AMP_5,
it6505->enable_ssc ? SPREAD_AMP_5 : 0x00);- if (it6505->enable_ssc) {
it6505_write(it6505, REG_BANK_SEL, 0x01);it6505_write(it6505, REG_SSC_CTRL0, 0x9E);it6505_write(it6505, REG_SSC_CTRL1, 0x1C);it6505_write(it6505, REG_SSC_CTRL2, 0x42);it6505_write(it6505, REG_BANK_SEL, 0x00);it6505_write(it6505, REG_SP_CTRL0, 0x07);it6505_write(it6505, REG_IP_CTRL1, 0x29);it6505_write(it6505, REG_IP_CTRL2, 0x03);/* Stamp Interrupt Step */it6505_set_bits(it6505, REG_TIME_STMP_CTRL, M_STAMP_STEP,0x10);it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL,DP_SPREAD_AMP_0_5);- } else {
it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL, 0x00);it6505_set_bits(it6505, REG_TIME_STMP_CTRL, M_STAMP_STEP,0x00);- }
+}
+static inline void it6505_link_rate_setup(struct it6505 *it6505) +{
- it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_LBR,
(it6505->link_rate_bw_code == RBR) ? FORCE_LBR : 0x00);- it6505_set_bits(it6505, REG_LINK_DRV, DRV_HS,
(it6505->link_rate_bw_code == RBR) ? 0x00 : DRV_HS);+}
+static void it6505_lane_count_setup(struct it6505 *it6505) +{
- it6505_get_extcon_property(it6505);
- it6505_set_bits(it6505, REG_TRAIN_CTRL0, LANE_SWAP,
it6505->lane_swap ? LANE_SWAP : 0x00);- it6505_set_bits(it6505, REG_TRAIN_CTRL0, LANE_COUNT_MASK,
(it6505->lane_count - 1) << 1);+}
+static void it6505_link_training_setup(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- if (it6505->enable_enhanced_frame)
it6505_set_bits(it6505, REG_DATA_MUTE_CTRL,ENABLE_ENHANCED_FRAME, ENABLE_ENHANCED_FRAME);- it6505_link_rate_setup(it6505);
- it6505_lane_count_setup(it6505);
- it6505_setup_ssc(it6505);
- DRM_DEV_DEBUG_DRIVER(dev,
"%s, %d lanes, %sable ssc, %sable enhanced frame",it6505->link_rate_bw_code != RBR ? "HBR" : "RBR",it6505->lane_count,it6505->enable_ssc ? "en" : "dis",it6505->enable_enhanced_frame ? "en" : "dis");+}
+static bool it6505_link_start_auto_train(struct it6505 *it6505) +{
- int timeout = 500, link_training_state;
- bool state = false;
- mutex_lock(&it6505->aux_lock);
- it6505_set_bits(it6505, REG_TRAIN_CTRL0,
FORCE_CR_DONE | FORCE_EQ_DONE, 0x00);- it6505_write(it6505, REG_TRAIN_CTRL1, FORCE_RETRAIN);
- it6505_write(it6505, REG_TRAIN_CTRL1, AUTO_TRAIN);
- while (timeout > 0) {
usleep_range(1000, 2000);link_training_state = it6505_read(it6505, REG_LINK_TRAIN_STS);if ((link_training_state > 0) &&(link_training_state & LINK_STATE_NORP)) {state = true;goto unlock;}timeout--;- }
+unlock:
- mutex_unlock(&it6505->aux_lock);
- return state;
+}
+static int it6505_drm_dp_link_configure(struct it6505 *it6505) +{
- u8 values[2];
- int err;
- struct drm_dp_aux *aux = &it6505->aux;
- values[0] = it6505->link_rate_bw_code;
- values[1] = it6505->lane_count;
- if (it6505->enable_enhanced_frame)
values[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;- err = drm_dp_dpcd_write(aux, DP_LINK_BW_SET, values, sizeof(values));
- if (err < 0)
return err;- return 0;
+}
+static bool it6505_check_voltage_swing_max(u8 lane_voltage_swing_pre_emphasis) +{
- return ((lane_voltage_swing_pre_emphasis & 0x03) == MAX_CR_LEVEL);
+}
+static bool it6505_check_pre_emphasis_max(u8 lane_voltage_swing_pre_emphasis) +{
- return ((lane_voltage_swing_pre_emphasis & 0x03) == MAX_EQ_LEVEL);
+}
+static bool it6505_check_max_voltage_swing_reached(u8 *lane_voltage_swing,
u8 lane_count)+{
- u8 i;
- for (i = 0; i < lane_count; i++) {
if (lane_voltage_swing[i] & DP_TRAIN_MAX_SWING_REACHED)return true;- }
- return false;
+}
+static bool it6505_step_train_lane_voltage_pre_emphasis_set(
- struct it6505 *it6505,
- struct it6505_step_train_para *lane_voltage_pre_emphasis,
- u8 *lane_voltage_pre_emphasis_set)
+{
- u8 i;
- for (i = 0; i < it6505->lane_count; i++) {
lane_voltage_pre_emphasis->voltage_swing[i] &= 0x03;lane_voltage_pre_emphasis_set[i] =lane_voltage_pre_emphasis->voltage_swing[i];if (it6505_check_voltage_swing_max(lane_voltage_pre_emphasis->voltage_swing[i]))lane_voltage_pre_emphasis_set[i] |=DP_TRAIN_MAX_SWING_REACHED;lane_voltage_pre_emphasis->pre_emphasis[i] &= 0x03;lane_voltage_pre_emphasis_set[i] |=lane_voltage_pre_emphasis->pre_emphasis[i]<< DP_TRAIN_PRE_EMPHASIS_SHIFT;if (it6505_check_pre_emphasis_max(lane_voltage_pre_emphasis->pre_emphasis[i]))lane_voltage_pre_emphasis_set[i] |=DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;it6505_dpcd_write(it6505, DP_TRAINING_LANE0_SET + i,lane_voltage_pre_emphasis_set[i]);if (lane_voltage_pre_emphasis_set[i] !=it6505_dpcd_read(it6505, DP_TRAINING_LANE0_SET + i))return false;- }
- return true;
+}
+static bool +it6505_step_cr_train(struct it6505 *it6505,
struct it6505_step_train_para *lane_voltage_pre_emphasis)+{
- u8 loop_count = 0, i = 0, j;
- u8 link_status[DP_LINK_STATUS_SIZE] = { 0 };
- u8 lane_level_config[MAX_LANE_COUNT] = { 0 };
- int pre_emphasis_adjust = -1, voltage_swing_adjust = -1;
- it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL,
it6505->enable_ssc ? DP_SPREAD_AMP_0_5 : 0x00);- it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
DP_TRAINING_PATTERN_1);- while (loop_count < 5 && i < 10) {
i++;if (!it6505_step_train_lane_voltage_pre_emphasis_set(it6505, lane_voltage_pre_emphasis,lane_level_config))continue;drm_dp_link_train_clock_recovery_delay(it6505->dpcd);drm_dp_dpcd_read_link_status(&it6505->aux, link_status);if (drm_dp_clock_recovery_ok(link_status, it6505->lane_count)) {it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_CR_DONE,FORCE_CR_DONE);return true;}DRM_DEV_DEBUG_DRIVER(&it6505->client->dev, "cr not done");if (it6505_check_max_voltage_swing_reached(lane_level_config,it6505->lane_count))goto cr_train_fail;for (j = 0; j < it6505->lane_count; j++) {lane_voltage_pre_emphasis->voltage_swing[j] =drm_dp_get_adjust_request_voltage(link_status,j) >>DP_TRAIN_VOLTAGE_SWING_SHIFT;lane_voltage_pre_emphasis->pre_emphasis[j] =drm_dp_get_adjust_request_pre_emphasis(link_status, j) >>DP_TRAIN_PRE_EMPHASIS_SHIFT;if ((voltage_swing_adjust ==lane_voltage_pre_emphasis->voltage_swing[j]) &&(pre_emphasis_adjust ==lane_voltage_pre_emphasis->pre_emphasis[j])) {loop_count++;continue;}voltage_swing_adjust =lane_voltage_pre_emphasis->voltage_swing[j];pre_emphasis_adjust =lane_voltage_pre_emphasis->pre_emphasis[j];loop_count = 0;if (voltage_swing_adjust + pre_emphasis_adjust >MAX_EQ_LEVEL)lane_voltage_pre_emphasis->voltage_swing[j] =MAX_EQ_LEVEL -lane_voltage_pre_emphasis->pre_emphasis[j];}- }
+cr_train_fail:
- it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
DP_TRAINING_PATTERN_DISABLE);- return false;
+}
+static bool +it6505_step_eq_train(struct it6505 *it6505,
struct it6505_step_train_para *lane_voltage_pre_emphasis)+{
- u8 loop_count = 0, i, link_status[DP_LINK_STATUS_SIZE] = { 0 };
- u8 lane_level_config[MAX_LANE_COUNT] = { 0 };
- it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
DP_TRAINING_PATTERN_2);- while (loop_count < 6) {
loop_count++;if (!it6505_step_train_lane_voltage_pre_emphasis_set(it6505, lane_voltage_pre_emphasis,lane_level_config))continue;drm_dp_link_train_channel_eq_delay(it6505->dpcd);drm_dp_dpcd_read_link_status(&it6505->aux, link_status);if (!drm_dp_clock_recovery_ok(link_status, it6505->lane_count))goto eq_train_fail;if (drm_dp_channel_eq_ok(link_status, it6505->lane_count)) {it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,DP_TRAINING_PATTERN_DISABLE);it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_EQ_DONE,FORCE_EQ_DONE);return true;}DRM_DEV_DEBUG_DRIVER(&it6505->client->dev, "eq not done");for (i = 0; i < it6505->lane_count; i++) {lane_voltage_pre_emphasis->voltage_swing[i] =drm_dp_get_adjust_request_voltage(link_status,i) >>DP_TRAIN_VOLTAGE_SWING_SHIFT;lane_voltage_pre_emphasis->pre_emphasis[i] =drm_dp_get_adjust_request_pre_emphasis(link_status, i) >>DP_TRAIN_PRE_EMPHASIS_SHIFT;if (lane_voltage_pre_emphasis->voltage_swing[i] +lane_voltage_pre_emphasis->pre_emphasis[i] >MAX_EQ_LEVEL)lane_voltage_pre_emphasis->voltage_swing[i] =0x03 - lane_voltage_pre_emphasis->pre_emphasis[i];}- }
+eq_train_fail:
- it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
DP_TRAINING_PATTERN_DISABLE);- return false;
+}
+static bool it6505_link_start_step_train(struct it6505 *it6505) +{
- int err;
- struct it6505_step_train_para lane_voltage_pre_emphasis = {
.voltage_swing = { 0 },.pre_emphasis = { 0 },- };
- DRM_DEV_DEBUG_DRIVER(&it6505->client->dev, "start");
- err = it6505_drm_dp_link_configure(it6505);
- if (err < 0)
return false;- if (!it6505_step_cr_train(it6505, &lane_voltage_pre_emphasis))
return false;- if (!it6505_step_eq_train(it6505, &lane_voltage_pre_emphasis))
return false;- return true;
+}
The whole link training is performed in different drivers in similar way, maybe some day someone will be able to abstract out common parts and create nice helpers for it.
+static bool it6505_get_video_status(struct it6505 *it6505) +{
- int reg_0d;
- reg_0d = it6505_read(it6505, REG_SYSTEM_STS);
- if (reg_0d < 0)
return false;- return !!(reg_0d & VIDEO_STB);
Again !!
+}
+static void it6505_reset_hdcp(struct it6505 *it6505) +{
- it6505->hdcp_status = HDCP_AUTH_IDLE;
- /* Disable CP_Desired */
- it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, 0x00);
- it6505_set_bits(it6505, REG_RESET_CTRL, HDCP_RESET, HDCP_RESET);
+}
+static void it6505_start_hdcp(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- DRM_DEV_DEBUG_DRIVER(dev, "start");
- it6505_reset_hdcp(it6505);
- queue_delayed_work(system_wq, &it6505->hdcp_work,
msecs_to_jiffies(2400));+}
+static void it6505_stop_hdcp(struct it6505 *it6505) +{
- it6505_reset_hdcp(it6505);
- cancel_delayed_work(&it6505->hdcp_work);
+}
+static bool it6505_hdcp_is_ksv_valid(u8 *ksv) +{
- int i, ones = 0;
- /* KSV has 20 1's and 20 0's */
- for (i = 0; i < DRM_HDCP_KSV_LEN; i++)
ones += hweight8(ksv[i]);- if (ones != 20)
return false;- return true;
+}
+static void it6505_hdcp_part1_auth(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- u8 hdcp_bcaps;
- it6505_set_bits(it6505, REG_RESET_CTRL, HDCP_RESET, 0x00);
- /* Disable CP_Desired */
- it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, 0x00);
- usleep_range(1000, 1500);
- hdcp_bcaps = it6505_dpcd_read(it6505, DP_AUX_HDCP_BCAPS);
- DRM_DEV_DEBUG_DRIVER(dev, "DPCD[0x68028]: 0x%02x",
hdcp_bcaps);- if (!hdcp_bcaps)
return;- /* clear the repeater List Chk Done and fail bit */
- it6505_set_bits(it6505, REG_HDCP_TRIGGER,
HDCP_TRIGGER_KSV_DONE | HDCP_TRIGGER_KSV_FAIL,0x00);- /* Enable An Generator */
- it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_AN_GEN, HDCP_AN_GEN);
- /* delay1ms(10);*/
drop the comment - it does not add valuable info
- usleep_range(10000, 15000);
- /* Stop An Generator */
- it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_AN_GEN, 0x00);
- it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, HDCP_CP_ENABLE);
- it6505_set_bits(it6505, REG_HDCP_TRIGGER, HDCP_TRIGGER_START,
HDCP_TRIGGER_START);- it6505->hdcp_status = HDCP_AUTH_GOING;
+}
+static int it6505_sha1_digest(struct it6505 *it6505, u8 *sha1_input,
unsigned int size, u8 *output_av)+{
- struct shash_desc *desc;
- struct crypto_shash *tfm;
- int err;
- struct device *dev = &it6505->client->dev;
- tfm = crypto_alloc_shash("sha1", 0, 0);
- if (IS_ERR(tfm)) {
DRM_DEV_ERROR(dev, "crypto_alloc_shash sha1 failed");return PTR_ERR(tfm);- }
- desc = kzalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);
- if (!desc) {
crypto_free_shash(tfm);return -ENOMEM;- }
- desc->tfm = tfm;
- err = crypto_shash_digest(desc, sha1_input, size, output_av);
- if (err)
DRM_DEV_ERROR(dev, "crypto_shash_digest sha1 failed");- crypto_free_shash(tfm);
- kfree(desc);
- return err;
+}
+static int it6505_setup_sha1_input(struct it6505 *it6505, u8 *sha1_input) +{
- struct device *dev = &it6505->client->dev;
- u8 binfo[2];
- int down_stream_count, i, err, msg_count = 0;
- err = it6505_get_dpcd(it6505, DP_AUX_HDCP_BINFO, binfo,
ARRAY_SIZE(binfo));- if (err < 0) {
DRM_DEV_ERROR(dev, "Read binfo value Fail");return err;- }
- down_stream_count = binfo[0] & 0x7F;
- DRM_DEV_DEBUG_DRIVER(dev, "binfo:0x%*ph", (int)ARRAY_SIZE(binfo),
binfo);- if ((binfo[0] & BIT(7)) || (binfo[1] & BIT(3))) {
DRM_DEV_ERROR(dev, "HDCP max cascade device exceed");return 0;- }
- if (!down_stream_count ||
(down_stream_count > MAX_HDCP_DOWN_STREAM_COUNT)) {DRM_DEV_ERROR(dev, "HDCP down stream count Error %d",down_stream_count);return 0;- }
- for (i = 0; i < down_stream_count; i++) {
err = it6505_get_dpcd(it6505, DP_AUX_HDCP_KSV_FIFO +(i % 3) * DRM_HDCP_KSV_LEN,sha1_input + msg_count,DRM_HDCP_KSV_LEN);if (err < 0)return err;msg_count += 5;- }
- it6505->hdcp_down_stream_count = down_stream_count;
- sha1_input[msg_count++] = binfo[0];
- sha1_input[msg_count++] = binfo[1];
- it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_EN_M0_READ,
HDCP_EN_M0_READ);- err = regmap_bulk_read(it6505->regmap, REG_M0_0_7,
sha1_input + msg_count, 8);- it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_EN_M0_READ, 0x00);
- if (err < 0) {
DRM_DEV_ERROR(dev, " Warning, Read M value Fail");return err;- }
- msg_count += 8;
- return msg_count;
+}
+static bool it6505_hdcp_part2_ksvlist_check(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- u8 av[5][4], bv[5][4];
- int i, err;
- i = it6505_setup_sha1_input(it6505, it6505->sha1_input);
- if (i <= 0) {
DRM_DEV_ERROR(dev, "SHA-1 Input length error %d", i);return false;- }
- it6505_sha1_digest(it6505, it6505->sha1_input, i, (u8 *)av);
- err = it6505_get_dpcd(it6505, DP_AUX_HDCP_V_PRIME(0), (u8 *)bv,
sizeof(bv));- if (err < 0) {
DRM_DEV_ERROR(dev, "Read V' value Fail");return false;- }
- for (i = 0; i < 5; i++)
if ((bv[i][3] != av[i][0]) || (bv[i][2] != av[i][1]) ||(bv[i][1] != av[i][2]) || (bv[i][0] != av[i][3]))return false;- DRM_DEV_DEBUG_DRIVER(dev, "V' all match!!");
- return true;
+}
+static void it6505_hdcp_wait_ksv_list(struct work_struct *work) +{
- struct it6505 *it6505 = container_of(work, struct it6505,
hdcp_wait_ksv_list);- struct device *dev = &it6505->client->dev;
- unsigned int timeout = 5000;
- u8 bstatus = 0;
- bool ksv_list_check;
- timeout /= 20;
- while (timeout > 0) {
if (!it6505_get_sink_hpd_status(it6505))return;bstatus = it6505_dpcd_read(it6505, DP_AUX_HDCP_BSTATUS);if (bstatus & DP_BSTATUS_READY)break;msleep(20);timeout--;- }
- if (timeout == 0) {
DRM_DEV_DEBUG_DRIVER(dev, "timeout and ksv list wait failed");goto timeout;- }
- ksv_list_check = it6505_hdcp_part2_ksvlist_check(it6505);
- DRM_DEV_DEBUG_DRIVER(dev, "ksv list ready, ksv list check %s",
ksv_list_check ? "pass" : "fail");- if (ksv_list_check) {
it6505_set_bits(it6505, REG_HDCP_TRIGGER,HDCP_TRIGGER_KSV_DONE, HDCP_TRIGGER_KSV_DONE);return;- }
+timeout:
- it6505_set_bits(it6505, REG_HDCP_TRIGGER,
HDCP_TRIGGER_KSV_DONE | HDCP_TRIGGER_KSV_FAIL,HDCP_TRIGGER_KSV_DONE | HDCP_TRIGGER_KSV_FAIL);+}
+static void it6505_hdcp_work(struct work_struct *work) +{
- struct it6505 *it6505 = container_of(work, struct it6505,
hdcp_work.work);- struct device *dev = &it6505->client->dev;
- int ret;
- u8 link_status[DP_LINK_STATUS_SIZE] = { 0 };
- DRM_DEV_DEBUG_DRIVER(dev, "start");
- if (!it6505_get_sink_hpd_status(it6505))
return;- ret = drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
- DRM_DEV_DEBUG_DRIVER(dev, "ret: %d link_status: %*ph", ret,
(int)sizeof(link_status), link_status);- if ((ret < 0) || !drm_dp_channel_eq_ok(link_status, it6505->lane_count)
|| !it6505_get_video_status(it6505)) {DRM_DEV_DEBUG_DRIVER(dev, "link train not done or no video");return;- }
- ret = it6505_get_dpcd(it6505, DP_AUX_HDCP_BKSV, it6505->bksvs,
ARRAY_SIZE(it6505->bksvs));- if (ret < 0) {
DRM_DEV_ERROR(dev, "fail to get bksv ret: %d", ret);it6505_set_bits(it6505, REG_HDCP_TRIGGER,HDCP_TRIGGER_KSV_FAIL, HDCP_TRIGGER_KSV_FAIL);- }
- DRM_DEV_DEBUG_DRIVER(dev, "bksv = 0x%*ph",
(int)ARRAY_SIZE(it6505->bksvs), it6505->bksvs);- if (!it6505_hdcp_is_ksv_valid(it6505->bksvs)) {
DRM_DEV_ERROR(dev, "Display Port bksv not valid");it6505_set_bits(it6505, REG_HDCP_TRIGGER,HDCP_TRIGGER_KSV_FAIL, HDCP_TRIGGER_KSV_FAIL);- }
- it6505_hdcp_part1_auth(it6505);
+}
+static void it6505_show_hdcp_info(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- int i;
- u8 *sha1 = it6505->sha1_input;
- DRM_DEV_DEBUG_DRIVER(dev, "hdcp_status: %d is_repeater: %d",
it6505->hdcp_status, it6505->is_repeater);- DRM_DEV_DEBUG_DRIVER(dev, "bksv = 0x%*ph",
(int)ARRAY_SIZE(it6505->bksvs), it6505->bksvs);- if (it6505->is_repeater) {
DRM_DEV_DEBUG_DRIVER(dev, "hdcp_down_stream_count: %d",it6505->hdcp_down_stream_count);DRM_DEV_DEBUG_DRIVER(dev, "sha1_input: 0x%*ph",(int)ARRAY_SIZE(it6505->sha1_input),it6505->sha1_input);for (i = 0; i < it6505->hdcp_down_stream_count; i++) {DRM_DEV_DEBUG_DRIVER(dev, "KSV_%d = 0x%*ph", i,DRM_HDCP_KSV_LEN, sha1);sha1 += DRM_HDCP_KSV_LEN;}DRM_DEV_DEBUG_DRIVER(dev, "binfo: 0x%2ph M0: 0x%8ph",sha1, sha1 + 2);- }
+}
+static void it6505_stop_link_train(struct it6505 *it6505) +{
- it6505->link_state = LINK_IDLE;
- cancel_work_sync(&it6505->link_works);
- it6505_write(it6505, REG_TRAIN_CTRL1, FORCE_RETRAIN);
+}
+static void it6505_link_train_ok(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- it6505->link_state = LINK_OK;
- /* disalbe mute enable avi info frame */
- it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, 0x00);
- it6505_set_bits(it6505, REG_INFOFRAME_CTRL,
EN_VID_CTRL_PKT, EN_VID_CTRL_PKT);- if (it6505_audio_input(it6505)) {
DRM_DEV_DEBUG_DRIVER(dev, "Enable audio!");it6505_enable_audio(it6505);- }
- if (it6505->hdcp_desired)
it6505_start_hdcp(it6505);+}
+static void it6505_link_step_train_process(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- int ret, i, step_retry = 3;
- DRM_DEV_DEBUG_DRIVER(dev, "Start step train");
- if (it6505->sink_count == 0) {
DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d, force eq",it6505->sink_count);it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_EQ_DONE,FORCE_EQ_DONE);return;- }
- if (!it6505->step_train) {
DRM_DEV_DEBUG_DRIVER(dev, "not support step train");return;- }
- /* setp training start here */
- for (i = 0; i < step_retry; i++) {
it6505_set_bits(it6505, REG_TRAIN_CTRL0,FORCE_CR_DONE | FORCE_EQ_DONE, 0x00);it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,DP_TRAINING_PATTERN_DISABLE);ret = it6505_link_start_step_train(it6505);DRM_DEV_DEBUG_DRIVER(dev, "step train %s, retry:%d times",ret ? "pass" : "failed", i + 1);if (ret) {it6505_link_train_ok(it6505);return;}- }
- DRM_DEV_DEBUG_DRIVER(dev, "training fail");
- it6505->link_state = LINK_IDLE;
- it6505_video_reset(it6505);
+}
+static void it6505_link_training_work(struct work_struct *work) +{
- struct it6505 *it6505 = container_of(work, struct it6505, link_works);
- struct device *dev = &it6505->client->dev;
- int ret;
- DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count: %d",
it6505->sink_count);- if (!it6505_get_sink_hpd_status(it6505))
return;- it6505_link_training_setup(it6505);
- it6505_reset_hdcp(it6505);
- it6505_aux_reset(it6505);
- if (it6505->auto_train_retry < 1) {
it6505_link_step_train_process(it6505);return;- }
- ret = it6505_link_start_auto_train(it6505);
- DRM_DEV_DEBUG_DRIVER(dev, "auto train %s, auto_train_retry: %d",
ret ? "pass" : "failed", it6505->auto_train_retry);- it6505->auto_train_retry--;
- if (ret) {
it6505_link_train_ok(it6505);return;- }
- it6505_dump(it6505);
+}
+static void it6505_plugged_status_to_codec(struct it6505 *it6505) +{
- enum drm_connector_status status = it6505->connector_status;
- if (it6505->plugged_cb && it6505->codec_dev)
it6505->plugged_cb(it6505->codec_dev,status == connector_status_connected);+}
+static int it6505_process_hpd_irq(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- int ret, dpcd_sink_count, dp_irq_vector, bstatus;
- u8 link_status[DP_LINK_STATUS_SIZE];
- if (!it6505_get_sink_hpd_status(it6505)) {
DRM_DEV_DEBUG_DRIVER(dev, "HPD_IRQ HPD low");it6505->sink_count = 0;return 0;- }
- ret = it6505_dpcd_read(it6505, DP_SINK_COUNT);
- if (ret < 0)
return ret;- dpcd_sink_count = DP_GET_SINK_COUNT(ret);
- DRM_DEV_DEBUG_DRIVER(dev, "dpcd_sink_count: %d it6505->sink_count:%d",
dpcd_sink_count, it6505->sink_count);- if (it6505->branch_device && dpcd_sink_count != it6505->sink_count) {
memset(it6505->dpcd, 0, sizeof(it6505->dpcd));it6505->sink_count = dpcd_sink_count;kfree(it6505->edid);it6505->edid = NULL;it6505_reset_logic(it6505);it6505_int_mask_enable(it6505);it6505_init(it6505);return 0;- }
- dp_irq_vector = it6505_dpcd_read(it6505, DP_DEVICE_SERVICE_IRQ_VECTOR);
- if (dp_irq_vector < 0)
return dp_irq_vector;- DRM_DEV_DEBUG_DRIVER(dev, "dp_irq_vector = 0x%02x", dp_irq_vector);
- if (dp_irq_vector & DP_CP_IRQ) {
it6505_set_bits(it6505, REG_HDCP_TRIGGER, HDCP_TRIGGER_CPIRQ,HDCP_TRIGGER_CPIRQ);bstatus = it6505_dpcd_read(it6505, DP_AUX_HDCP_BSTATUS);if (bstatus < 0)return bstatus;DRM_DEV_DEBUG_DRIVER(dev, "Bstatus = 0x%02x", bstatus);- }
- ret = drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
- if (ret < 0) {
DRM_DEV_ERROR(dev, "Fail to read link status ret: %d",ret);return ret;- }
- DRM_DEV_DEBUG_DRIVER(dev, "link status = 0x%*ph",
(int)ARRAY_SIZE(link_status), link_status);- if (!drm_dp_channel_eq_ok(link_status, it6505->lane_count)) {
it6505->auto_train_retry = AUTO_TRAIN_RETRY;it6505_video_reset(it6505);- }
- return 0;
+}
+static void it6505_check_reg06(struct it6505 *it6505, unsigned int reg06) +{
- struct device *dev = &it6505->client->dev;
- bool data;
- if (reg06 & INT_HPD_CHANGE) {
data = it6505_get_sink_hpd_status(it6505);DRM_DEV_DEBUG_DRIVER(dev, "hpd change interrupt, change to %s",data ? "high" : "low");if (it6505->connector.dev)drm_helper_hpd_irq_event(it6505->connector.dev);DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count: %d",it6505->sink_count);if (data) {wait_for_completion_timeout(&it6505->wait_edid_complete,msecs_to_jiffies(6000));it6505_lane_termination_on(it6505);it6505_lane_power_on(it6505);/** for some dongle which issue HPD_irq* when sink count change from 0->1* it6505 not able to receive HPD_IRQ* if HW never go into trainig done*/if (it6505->branch_device && it6505->sink_count == 0)schedule_work(&it6505->link_works);if (!it6505_get_video_status(it6505))it6505_video_reset(it6505);it6505_calc_video_info(it6505);} else {kfree(it6505->edid);it6505->edid = NULL;memset(it6505->dpcd, 0, sizeof(it6505->dpcd));if (it6505->hdcp_desired)it6505_stop_hdcp(it6505);it6505_video_disable(it6505);it6505_disable_audio(it6505);it6505_stop_link_train(it6505);it6505_lane_off(it6505);return;}- }
- if (reg06 & INT_RECEIVE_HPD_IRQ) {
DRM_DEV_DEBUG_DRIVER(dev, "hpd_irq interrupt");if (it6505_process_hpd_irq(it6505) < 0)DRM_DEV_DEBUG_DRIVER(dev, "process hpd_irq fail!");- }
- if (reg06 & INT_SCDT_CHANGE) {
data = it6505_get_video_status(it6505);DRM_DEV_DEBUG_DRIVER(dev, "video stable change interrupt, %s",data ? "stable" : "unstable");it6505_calc_video_info(it6505);if (data)schedule_work(&it6505->link_works);- }
- if (reg06 & INT_HDCP_DONE) {
DRM_DEV_DEBUG_DRIVER(dev, "hdcp done interrupt");it6505->hdcp_status = HDCP_AUTH_DONE;it6505_show_hdcp_info(it6505);- }
- if (reg06 & INT_HDCP_FAIL) {
DRM_DEV_DEBUG_DRIVER(dev, "hdcp fail interrupt");it6505->hdcp_status = HDCP_AUTH_IDLE;it6505_show_hdcp_info(it6505);it6505_start_hdcp(it6505);- }
+}
+static void it6505_check_reg07(struct it6505 *it6505, unsigned int reg07) +{
- struct device *dev = &it6505->client->dev;
- if (reg07 & INT_AUX_CMD_FAIL)
DRM_DEV_DEBUG_DRIVER(dev, "AUX PC Request Fail Interrupt");- if (reg07 & INT_HDCP_KSV_CHECK) {
DRM_DEV_DEBUG_DRIVER(dev, "HDCP event Interrupt");schedule_work(&it6505->hdcp_wait_ksv_list);- }
- if (reg07 & INT_AUDIO_FIFO_ERROR) {
DRM_DEV_DEBUG_DRIVER(dev, "audio fifo error Interrupt");if (it6505_audio_input(it6505))it6505_enable_audio(it6505);- }
+}
+static void it6505_check_reg08(struct it6505 *it6505, unsigned int reg08) +{
- struct device *dev = &it6505->client->dev;
- if (reg08 & INT_LINK_TRAIN_FAIL) {
DRM_DEV_DEBUG_DRIVER(dev, "link training fail interrupt");schedule_work(&it6505->link_works);- }
- if (reg08 & INT_VID_FIFO_ERROR) {
DRM_DEV_DEBUG_DRIVER(dev, "video fifo overflow interrupt");it6505->auto_train_retry = AUTO_TRAIN_RETRY;flush_work(&it6505->link_works);it6505_stop_hdcp(it6505);it6505_video_reset(it6505);- }
- if (reg08 & INT_IO_LATCH_FIFO_OVERFLOW) {
DRM_DEV_DEBUG_DRIVER(dev, "IO latch fifo overflow interrupt");it6505->auto_train_retry = AUTO_TRAIN_RETRY;flush_work(&it6505->link_works);it6505_stop_hdcp(it6505);it6505_video_reset(it6505);- }
+}
+static irqreturn_t it6505_int_threaded_handler(int unused, void *data) +{
- struct it6505 *it6505 = data;
- struct device *dev = &it6505->client->dev;
- int reg06, reg07, reg08;
- msleep(100);
- mutex_lock(&it6505->extcon_lock);
- if (it6505->enable_drv_hold || !it6505->powered)
goto unlock;- reg06 = it6505_read(it6505, INT_STATUS_01);
- reg07 = it6505_read(it6505, INT_STATUS_02);
- reg08 = it6505_read(it6505, INT_STATUS_03);
- it6505_write(it6505, INT_STATUS_01, reg06);
- it6505_write(it6505, INT_STATUS_02, reg07);
- it6505_write(it6505, INT_STATUS_03, reg08);
- DRM_DEV_DEBUG_DRIVER(dev, "reg06 = 0x%02x", reg06);
- DRM_DEV_DEBUG_DRIVER(dev, "reg07 = 0x%02x", reg07);
- DRM_DEV_DEBUG_DRIVER(dev, "reg08 = 0x%02x", reg08);
- it6505_debug_print(it6505, REG_SYSTEM_STS, "");
- if (reg06 != 0)
it6505_check_reg06(it6505, reg06);- if (reg07 != 0)
it6505_check_reg07(it6505, reg07);- if (reg08 != 0)
it6505_check_reg08(it6505, reg08);
The whole irq handler looks ugly, you can collate all three INT_STATUS_* regs into one value and then check which bits are on and then call apropriate irq handler.
See [1] for example.
[1]: https://elixir.bootlin.com/linux/v4.15/source/drivers/gpu/drm/bridge/sil-sii...
+unlock:
- mutex_unlock(&it6505->extcon_lock);
- return IRQ_HANDLED;
+}
+static int it6505_poweron(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- struct it6505_platform_data *pdata = &it6505->pdata;
- int err;
- if (it6505->powered) {
DRM_DEV_DEBUG_DRIVER(dev, "it6505 already powered on");return 0;- }
- if (pdata->pwr18) {
err = regulator_enable(pdata->pwr18);if (err) {DRM_DEV_DEBUG_DRIVER(dev, "Failed to enable VDD18: %d",err);return err;}- }
- if (pdata->ovdd) {
/* time interval between IVDD and OVDD at least be 1ms */usleep_range(1000, 2000);err = regulator_enable(pdata->ovdd);if (err) {regulator_disable(pdata->pwr18);return err;}- }
- /* time interval between OVDD and SYSRSTN at least be 10ms */
- if (pdata->gpiod_reset) {
usleep_range(10000, 20000);gpiod_set_value_cansleep(pdata->gpiod_reset, 0);usleep_range(1000, 2000);gpiod_set_value_cansleep(pdata->gpiod_reset, 1);usleep_range(10000, 20000);- }
- it6505_reset_logic(it6505);
- it6505_int_mask_enable(it6505);
- it6505_init(it6505);
- it6505_lane_off(it6505);
- it6505->powered = true;
- return 0;
+}
+static int it6505_poweroff(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- struct it6505_platform_data *pdata = &it6505->pdata;
- int err;
- if (!it6505->powered) {
DRM_DEV_DEBUG_DRIVER(dev, "power had been already off");return 0;- }
- if (pdata->gpiod_reset)
gpiod_set_value_cansleep(pdata->gpiod_reset, 0);- if (pdata->pwr18) {
err = regulator_disable(pdata->pwr18);if (err)return err;- }
- if (pdata->ovdd) {
err = regulator_disable(pdata->ovdd);if (err)return err;- }
- it6505->powered = false;
- kfree(it6505->edid);
- it6505->edid = NULL;
- it6505->sink_count = 0;
- return 0;
+}
+static inline struct it6505 *connector_to_it6505(struct drm_connector *c) +{
- return container_of(c, struct it6505, connector);
+}
+static int it6505_get_modes(struct drm_connector *connector) +{
- struct it6505 *it6505 = connector_to_it6505(connector);
- int err, num_modes = 0, i;
- struct device *dev = &it6505->client->dev;
- if (it6505->edid)
return drm_add_edid_modes(connector, it6505->edid);- mutex_lock(&it6505->mode_lock);
- reinit_completion(&it6505->wait_edid_complete);
- for (i = 0; i < 3; i++) {
if (!it6505_get_sink_hpd_status(it6505))goto unlock;it6505->edid = drm_do_get_edid(&it6505->connector,it6505_get_edid_block, it6505);if (it6505->edid)break;- }
- if (!it6505->edid) {
DRM_DEV_ERROR(dev, "Failed to read EDID");num_modes = -EIO;goto unlock;- }
- err = drm_connector_update_edid_property(connector, it6505->edid);
- if (err) {
DRM_DEV_ERROR(dev, "Failed to update EDID property: %d", err);num_modes = err;goto unlock;- }
- num_modes = drm_add_edid_modes(connector, it6505->edid);
+unlock:
- complete(&it6505->wait_edid_complete);
- mutex_unlock(&it6505->mode_lock);
- return num_modes;
+}
+static const struct drm_connector_helper_funcs it6505_connector_helper_funcs = {
- .get_modes = it6505_get_modes,
+};
+static enum drm_connector_status it6505_detect(struct drm_connector *connector,
bool force)+{
- struct it6505 *it6505 = connector_to_it6505(connector);
- struct device *dev = &it6505->client->dev;
- enum drm_connector_status status = connector_status_disconnected;
- DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d powered:%d",
it6505->sink_count, it6505->powered);- mutex_lock(&it6505->mode_lock);
- if (!it6505->powered)
goto unlock;- if (it6505->enable_drv_hold) {
status = it6505_get_sink_hpd_status(it6505) ?connector_status_connected :connector_status_disconnected;goto unlock;- }
- if (it6505_get_sink_hpd_status(it6505)) {
it6505_aux_on(it6505);it6505_drm_dp_link_probe(&it6505->aux, &it6505->link);it6505_drm_dp_link_power_up(&it6505->aux, &it6505->link);it6505->auto_train_retry = AUTO_TRAIN_RETRY;if (it6505->dpcd[0] == 0) {it6505_get_dpcd(it6505, DP_DPCD_REV, it6505->dpcd,ARRAY_SIZE(it6505->dpcd));it6505_variable_config(it6505);it6505_parse_link_capabilities(it6505);}it6505->sink_count = DP_GET_SINK_COUNT(it6505_dpcd_read(it6505,DP_SINK_COUNT));DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d branch:%d",it6505->sink_count, it6505->branch_device);if (it6505->branch_device) {status = (it6505->sink_count != 0) ?connector_status_connected :connector_status_disconnected;} else {status = connector_status_connected;}- } else {
it6505->sink_count = 0;memset(it6505->dpcd, 0, sizeof(it6505->dpcd));- }
+unlock:
- if (it6505->connector_status != status) {
it6505->connector_status = status;it6505_plugged_status_to_codec(it6505);- }
- mutex_unlock(&it6505->mode_lock);
- return status;
+}
+static const struct drm_connector_funcs it6505_connector_funcs = {
- .fill_modes = drm_helper_probe_single_connector_modes,
- .detect = it6505_detect,
- .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 it6505_extcon_notifier(struct notifier_block *self,
unsigned long event, void *ptr)+{
- struct it6505 *it6505 = container_of(self, struct it6505, event_nb);
- schedule_work(&it6505->extcon_wq);
- return NOTIFY_DONE;
+}
+static void it6505_extcon_work(struct work_struct *work) +{
- struct it6505 *it6505 = container_of(work, struct it6505, extcon_wq);
- struct device *dev = &it6505->client->dev;
- int state = extcon_get_state(it6505->extcon, EXTCON_DISP_DP);
- unsigned int pwroffretry = 0;
- if (it6505->enable_drv_hold)
return;- mutex_lock(&it6505->extcon_lock);
- DRM_DEV_DEBUG_DRIVER(dev, "EXTCON_DISP_DP = 0x%02x", state);
- if (state > 0) {
DRM_DEV_DEBUG_DRIVER(dev, "start to power on");msleep(100);it6505_poweron(it6505);- } else {
DRM_DEV_DEBUG_DRIVER(dev, "start to power off");while (it6505_poweroff(it6505) && pwroffretry++ < 5) {DRM_DEV_DEBUG_DRIVER(dev, "power off fail %d times",pwroffretry);}drm_helper_hpd_irq_event(it6505->connector.dev);memset(it6505->dpcd, 0, sizeof(it6505->dpcd));DRM_DEV_DEBUG_DRIVER(dev, "power off it6505 success!");- }
- mutex_unlock(&it6505->extcon_lock);
+}
+static int it6505_use_notifier_module(struct it6505 *it6505) +{
- int ret;
- struct device *dev = &it6505->client->dev;
- it6505->event_nb.notifier_call = it6505_extcon_notifier;
- INIT_WORK(&it6505->extcon_wq, it6505_extcon_work);
- ret = devm_extcon_register_notifier(&it6505->client->dev,
it6505->extcon, EXTCON_DISP_DP,&it6505->event_nb);- if (ret) {
DRM_DEV_ERROR(dev, "failed to register notifier for DP");return ret;- }
- schedule_work(&it6505->extcon_wq);
- return 0;
+}
+static void it6505_remove_notifier_module(struct it6505 *it6505) +{
- if (it6505->extcon) {
devm_extcon_unregister_notifier(&it6505->client->dev,it6505->extcon, EXTCON_DISP_DP,&it6505->event_nb);flush_work(&it6505->extcon_wq);- }
+}
+static void __maybe_unused it6505_delayed_audio(struct work_struct *work) +{
- struct it6505 *it6505 = container_of(work, struct it6505,
delayed_audio.work);- DRM_DEV_DEBUG_DRIVER(&it6505->client->dev, "start");
- if (!it6505->powered)
return;- if (!it6505->enable_drv_hold)
it6505_enable_audio(it6505);+}
+static int __maybe_unused it6505_audio_setup_hw_params(struct it6505 *it6505,
struct hdmi_codec_params *params)+{
- struct device *dev = &it6505->client->dev;
- int i = 0;
- DRM_DEV_DEBUG_DRIVER(dev, "%s %d Hz, %d bit, %d channels\n", __func__,
params->sample_rate, params->sample_width,params->cea.channels);- if (!it6505->bridge.encoder)
return -ENODEV;- if (params->cea.channels <= 1 || params->cea.channels > 8) {
DRM_DEV_DEBUG_DRIVER(dev, "channel number: %d not support",it6505->audio.channel_count);return -EINVAL;- }
- it6505->audio.channel_count = params->cea.channels;
- while (i < ARRAY_SIZE(audio_sample_rate_map) &&
params->sample_rate !=audio_sample_rate_map[i].sample_rate_value) {i++;- }
- if (i == ARRAY_SIZE(audio_sample_rate_map)) {
DRM_DEV_DEBUG_DRIVER(dev, "sample rate: %d Hz not support",params->sample_rate);return -EINVAL;- }
- it6505->audio.sample_rate = audio_sample_rate_map[i].rate;
- switch (params->sample_width) {
- case 16:
it6505->audio.word_length = WORD_LENGTH_16BIT;break;- case 18:
it6505->audio.word_length = WORD_LENGTH_18BIT;break;- case 20:
it6505->audio.word_length = WORD_LENGTH_20BIT;break;- case 24:
- case 32:
it6505->audio.word_length = WORD_LENGTH_24BIT;break;- default:
DRM_DEV_DEBUG_DRIVER(dev, "wordlength: %d bit not support",params->sample_width);return -EINVAL;- }
- return 0;
+}
+static void __maybe_unused it6505_audio_shutdown(struct device *dev, void *data) +{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- if (it6505->powered)
it6505_disable_audio(it6505);+}
+static int __maybe_unused it6505_audio_hook_plugged_cb(struct device *dev,
void *data,hdmi_codec_plugged_cb fn,struct device *codec_dev)+{
- struct it6505 *it6505 = data;
- it6505->plugged_cb = fn;
- it6505->codec_dev = codec_dev;
- it6505_plugged_status_to_codec(it6505);
- return 0;
+}
+static inline struct it6505 *bridge_to_it6505(struct drm_bridge *bridge) +{
- return container_of(bridge, struct it6505, bridge);
+}
+static void it6505_bridge_mode_set(struct drm_bridge *bridge,
const struct drm_display_mode *mode,const struct drm_display_mode *adjusted_mode)+{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- struct hdmi_avi_infoframe frame;
- int err;
- struct device *dev = &it6505->client->dev;
- if (WARN_ON(!it6505->powered))
return;- mutex_lock(&it6505->mode_lock);
- err = drm_hdmi_avi_infoframe_from_display_mode(&frame,
&it6505->connector,adjusted_mode);- if (err) {
DRM_DEV_ERROR(dev, "Failed to setup AVI infoframe: %d", err);goto unlock;- }
- it6505_update_video_parameter(it6505, adjusted_mode);
- err = it6505_send_video_infoframe(it6505, &frame);
- if (err)
DRM_DEV_ERROR(dev, "Failed to send AVI infoframe: %d", err);+unlock:
- mutex_unlock(&it6505->mode_lock);
+}
+static int it6505_bridge_attach(struct drm_bridge *bridge,
enum drm_bridge_attach_flags flags)+{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- struct device *dev = &it6505->client->dev;
- int err;
- if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR) {
DRM_ERROR("Fix bridge driver to make connector optional!");return 0;
Error should be returned here
- }
- if (!bridge->encoder) {
DRM_DEV_ERROR(dev, "Parent encoder object not found");return -ENODEV;- }
- err = drm_connector_init(bridge->dev, &it6505->connector,
&it6505_connector_funcs,DRM_MODE_CONNECTOR_DisplayPort);- if (err < 0) {
DRM_DEV_ERROR(dev, "Failed to initialize connector: %d", err);return err;- }
- drm_connector_helper_add(&it6505->connector,
&it6505_connector_helper_funcs);- it6505->connector.polled = DRM_CONNECTOR_POLL_HPD;
- err = drm_connector_attach_encoder(&it6505->connector, bridge->encoder);
- if (err < 0) {
DRM_DEV_ERROR(dev, "Failed to link up connector to encoder: %d",err);goto cleanup_connector;- }
- err = drm_connector_register(&it6505->connector);
- if (err < 0) {
DRM_DEV_ERROR(dev, "Failed to register connector: %d", err);goto cleanup_connector;- }
- if (it6505->extcon) {
err = it6505_use_notifier_module(it6505);if (err < 0) {drm_connector_unregister(&it6505->connector);goto cleanup_connector;}- }
- return 0;
+cleanup_connector:
- drm_connector_cleanup(&it6505->connector);
- return err;
+}
+static void it6505_bridge_detach(struct drm_bridge *bridge) +{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- flush_work(&it6505->link_works);
- it6505_remove_notifier_module(it6505);
- drm_connector_unregister(&it6505->connector);
- drm_connector_cleanup(&it6505->connector);
+}
+static enum drm_mode_status +it6505_bridge_mode_valid(struct drm_bridge *bridge,
const struct drm_display_info *info,const struct drm_display_mode *mode)+{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- if (mode->flags & DRM_MODE_FLAG_INTERLACE)
return MODE_NO_INTERLACE;- if (mode->clock > DPI_PIXEL_CLK_MAX)
return MODE_CLOCK_HIGH;- it6505->video_info.clock = mode->clock;
- return MODE_OK;
+}
+static void it6505_bridge_enable(struct drm_bridge *bridge) +{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- it6505_int_mask_enable(it6505);
- it6505_video_reset(it6505);
+}
+static void it6505_bridge_disable(struct drm_bridge *bridge) +{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- if (it6505->powered)
it6505_video_disable(it6505);+}
+static enum drm_connector_status +it6505_bridge_detect(struct drm_bridge *bridge) +{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- return it6505_detect(&it6505->connector, 0);
+}
+static struct edid *it6505_bridge_get_edid(struct drm_bridge *bridge,
struct drm_connector *connector)+{
- struct it6505 *it6505 = bridge_to_it6505(bridge);
- struct device *dev = &it6505->client->dev;
- struct edid *edid;
- edid = drm_do_get_edid(&it6505->connector, it6505_get_edid_block,
it6505);- if (!edid) {
DRM_DEV_DEBUG_DRIVER(dev, "failed to get edid!");return NULL;- }
- return edid;
+}
+static const struct drm_bridge_funcs it6505_bridge_funcs = {
- .attach = it6505_bridge_attach,
- .detach = it6505_bridge_detach,
- .mode_valid = it6505_bridge_mode_valid,
- .mode_set = it6505_bridge_mode_set,
- .enable = it6505_bridge_enable,
- .disable = it6505_bridge_disable,
- .detect = it6505_bridge_detect,
- .get_edid = it6505_bridge_get_edid,
+};
+#ifdef CONFIG_PM_SLEEP
+static int it6505_bridge_resume(struct device *dev) +{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- return it6505_poweron(it6505);
+}
+static int it6505_bridge_suspend(struct device *dev) +{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- return it6505_poweroff(it6505);
+}
+static SIMPLE_DEV_PM_OPS(it6505_bridge_pm_ops, it6505_bridge_suspend,
it6505_bridge_resume);+#endif
+static int it6505_init_pdata(struct it6505 *it6505) +{
- struct it6505_platform_data *pdata = &it6505->pdata;
- struct device *dev = &it6505->client->dev;
- /* 1.0V digital core power regulator */
- pdata->pwr18 = devm_regulator_get(dev, "pwr18");
- if (IS_ERR(pdata->pwr18)) {
DRM_DEV_ERROR(dev, "pwr18 regulator not found");return PTR_ERR(pdata->pwr18);- }
- pdata->ovdd = devm_regulator_get(dev, "ovdd");
- if (IS_ERR(pdata->ovdd)) {
DRM_DEV_ERROR(dev, "ovdd regulator not found");return PTR_ERR(pdata->ovdd);- }
- pdata->gpiod_reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
- if (IS_ERR(pdata->gpiod_reset)) {
DRM_DEV_ERROR(dev, "gpiod_reset gpio not found");return PTR_ERR(pdata->gpiod_reset);- }
- return 0;
+}
+static void it6505_parse_dt(struct it6505 *it6505) +{
- struct device *dev = &it6505->client->dev;
- u32 *afe_setting = &it6505->afe_setting;
- it6505->lane_swap_disabled =
device_property_read_bool(dev, "no-laneswap");- if (it6505->lane_swap_disabled)
it6505->lane_swap = false;- if (device_property_read_u32(dev, "afe-setting", afe_setting) == 0) {
if (*afe_setting >= ARRAY_SIZE(afe_setting_table)) {DRM_DEV_ERROR(dev, "afe setting error, use default");*afe_setting = 0;}- } else {
*afe_setting = 0;- }
- DRM_DEV_DEBUG_DRIVER(dev, "using afe_setting: %d", *afe_setting);
+}
+static ssize_t print_timing_show(struct device *dev,
struct device_attribute *attr, char *buf)+{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- struct drm_display_mode *vid = &it6505->video_info;
- char *str = buf, *end = buf + PAGE_SIZE;
- it6505_calc_video_info(it6505);
- str += scnprintf(str, end - str, "---video timing---\n");
- str += scnprintf(str, end - str, "PCLK:%d.%03dMHz\n",
vid->clock / 1000, vid->clock % 1000);- str += scnprintf(str, end - str, "HTotal:%d\n", vid->htotal);
- str += scnprintf(str, end - str, "HActive:%d\n", vid->hdisplay);
- str += scnprintf(str, end - str, "HFrontPorch:%d\n",
vid->hsync_start - vid->hdisplay);- str += scnprintf(str, end - str, "HSyncWidth:%d\n",
vid->hsync_end - vid->hsync_start);- str += scnprintf(str, end - str, "HBackPorch:%d\n",
vid->htotal - vid->hsync_end);- str += scnprintf(str, end - str, "VTotal:%d\n", vid->vtotal);
- str += scnprintf(str, end - str, "VActive:%d\n", vid->vdisplay);
- str += scnprintf(str, end - str, "VFrontPorch:%d\n",
vid->vsync_start - vid->vdisplay);- str += scnprintf(str, end - str, "VSyncWidth:%d\n",
vid->vsync_end - vid->vsync_start);- str += scnprintf(str, end - str, "VBackPorch:%d\n",
vid->vtotal - vid->vsync_end);- return str - buf;
+}
+static ssize_t force_pwronoff_store(struct device *dev,
struct device_attribute *attr,const char *buf, size_t count)+{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- int pwr;
- if (kstrtoint(buf, 10, &pwr) < 0)
return -EINVAL;- if (pwr)
it6505_poweron(it6505);- else
it6505_poweroff(it6505);- return count;
+}
+static ssize_t enable_drv_hold_show(struct device *dev,
struct device_attribute *attr, char *buf)+{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- return scnprintf(buf, PAGE_SIZE, "%d\n", it6505->enable_drv_hold);
+}
+static ssize_t enable_drv_hold_store(struct device *dev,
struct device_attribute *attr,const char *buf, size_t count)+{
- struct it6505 *it6505 = dev_get_drvdata(dev);
- unsigned int drv_hold;
- if (kstrtoint(buf, 10, &drv_hold) < 0)
return -EINVAL;- it6505->enable_drv_hold = !!drv_hold;
Again !!, please just find all occurrences of it an remove them if it is assigned to bool type.
- if (it6505->enable_drv_hold) {
it6505_int_mask_disable(it6505);- } else {
it6505_clear_int(it6505);it6505_int_mask_enable(it6505);if (it6505->powered) {it6505->connector_status =it6505_get_sink_hpd_status(it6505) ?connector_status_connected :connector_status_disconnected;} else {it6505->connector_status =connector_status_disconnected;}- }
- return count;
+}
+static DEVICE_ATTR_RO(print_timing); +static DEVICE_ATTR_WO(force_pwronoff); +static DEVICE_ATTR_RW(enable_drv_hold);
+static const struct attribute *it6505_attrs[] = {
- &dev_attr_print_timing.attr,
- &dev_attr_force_pwronoff.attr,
- &dev_attr_enable_drv_hold.attr,
- NULL,
+};
+static void it6505_shutdown(struct i2c_client *client) +{
- struct it6505 *it6505 = dev_get_drvdata(&client->dev);
- kfree(it6505->edid);
- it6505->edid = NULL;
- if (it6505->powered)
it6505_lane_off(it6505);+}
+static int it6505_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)+{
- struct it6505 *it6505;
- struct device *dev = &client->dev;
- struct extcon_dev *extcon;
- int err, intp_irq;
- it6505 = devm_kzalloc(&client->dev, sizeof(*it6505), GFP_KERNEL);
- if (!it6505)
return -ENOMEM;- mutex_init(&it6505->extcon_lock);
- mutex_init(&it6505->mode_lock);
- mutex_init(&it6505->aux_lock);
- it6505->bridge.of_node = client->dev.of_node;
- it6505->connector_status = connector_status_disconnected;
- it6505->client = client;
- i2c_set_clientdata(client, it6505);
- /* get extcon device from DTS */
- extcon = extcon_get_edev_by_phandle(dev, 0);
- if (PTR_ERR(extcon) == -EPROBE_DEFER)
return -EPROBE_DEFER;- if (IS_ERR(extcon)) {
DRM_DEV_ERROR(dev, "can not get extcon device!");return PTR_ERR(extcon);- }
- it6505->extcon = extcon;
- it6505->regmap = devm_regmap_init_i2c(client, &it6505_regmap_config);
- if (IS_ERR(it6505->regmap)) {
DRM_DEV_ERROR(dev, "regmap i2c init failed");err = PTR_ERR(it6505->regmap);return err;- }
- err = it6505_init_pdata(it6505);
- if (err) {
DRM_DEV_ERROR(dev, "Failed to initialize pdata: %d", err);return err;- }
- it6505_parse_dt(it6505);
- intp_irq = client->irq;
- if (!intp_irq) {
DRM_DEV_ERROR(dev, "Failed to get INTP IRQ");err = -ENODEV;return err;- }
- err = devm_request_threaded_irq(&client->dev, intp_irq, NULL,
it6505_int_threaded_handler,IRQF_TRIGGER_LOW | IRQF_ONESHOT,"it6505-intp", it6505);- if (err) {
DRM_DEV_ERROR(dev, "Failed to request INTP threaded IRQ: %d",err);return err;- }
- /* Register aux channel */
- it6505->aux.name = "DP-AUX";
- it6505->aux.dev = dev;
- it6505->aux.transfer = it6505_aux_transfer;
- err = drm_dp_aux_register(&it6505->aux);
- if (err < 0) {
DRM_DEV_ERROR(dev, "Failed to register aux: %d", err);return err;- }
- INIT_WORK(&it6505->link_works, it6505_link_training_work);
- INIT_WORK(&it6505->hdcp_wait_ksv_list, it6505_hdcp_wait_ksv_list);
- INIT_DELAYED_WORK(&it6505->hdcp_work, it6505_hdcp_work);
- init_completion(&it6505->wait_edid_complete);
- memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
- it6505->powered = false;
- it6505->enable_drv_hold = DEFAULT_DRV_HOLD;
- if (DEFAULT_PWR_ON)
it6505_poweron(it6505);- err = sysfs_create_files(&client->dev.kobj, it6505_attrs);
- if (err) {
drm_dp_aux_unregister(&it6505->aux);return err;- }
- it6505->bridge.funcs = &it6505_bridge_funcs;
- drm_bridge_add(&it6505->bridge);
- return 0;
+}
+static int it6505_i2c_remove(struct i2c_client *client) +{
- struct it6505 *it6505 = i2c_get_clientdata(client);
- drm_connector_unregister(&it6505->connector);
- drm_connector_cleanup(&it6505->connector);
- drm_bridge_remove(&it6505->bridge);
- drm_dp_aux_unregister(&it6505->aux);
- sysfs_remove_files(&client->dev.kobj, it6505_attrs);
- it6505_poweroff(it6505);
- return 0;
+}
+static const struct i2c_device_id it6505_id[] = {
- { "it6505", 0 },
- { }
+};
+MODULE_DEVICE_TABLE(i2c, it6505_id);
+static const struct of_device_id it6505_of_match[] = {
- { .compatible = "ite,it6505" },
- { }
+};
+static struct i2c_driver it6505_i2c_driver = {
- .driver = {
.name = "it6505",.of_match_table = it6505_of_match,+#ifdef CONFIG_PM_SLEEP
.pm = &it6505_bridge_pm_ops,+#endif
- },
- .probe = it6505_i2c_probe,
- .remove = it6505_i2c_remove,
- .shutdown = it6505_shutdown,
- .id_table = it6505_id,
+};
+module_i2c_driver(it6505_i2c_driver);
+MODULE_AUTHOR("Allen Chen allen.chen@ite.com.tw"); +MODULE_DESCRIPTION("IT6505 DisplayPort Transmitter driver"); +MODULE_LICENSE("GPL v2");
The shape of the driver looks OK to me, but it is quite big and interacts with many subsystem, so for sure my review was not profound :)
Few more things:
- it would be good to replace some magic numbers inside the code with proper macros, all these 0xF0, 0x70, BIT(x) are quite cryptic.
- REG_BANK_SEL is usually at 0, only sometimes is switched to 1, so maybe it should be enough to set it to 1 if necessary and then immediately set back to 0, as default value, instead of setting it multiple times,
- sometimes you are accessing arrays (int status, mask, it6505_dump) maybe it would be good to create helpers to read/write arrays to simplify the code little bit.
As I said it would be good to get someone's else review, as the driver is big.
Regards
Andrzej