Lines Matching refs:it6505
290 #define DEBUGFS_DIR_NAME "it6505-debugfs"
404 struct it6505 {
458 /* it6505 driver hold option */
502 .name = "it6505",
523 static int it6505_read(struct it6505 *it6505, unsigned int reg_addr)
527 struct device *dev = it6505->dev;
529 if (!it6505->powered)
532 err = regmap_read(it6505->regmap, reg_addr, &value);
541 static int it6505_write(struct it6505 *it6505, unsigned int reg_addr,
545 struct device *dev = it6505->dev;
547 if (!it6505->powered)
550 err = regmap_write(it6505->regmap, reg_addr, reg_val);
561 static int it6505_set_bits(struct it6505 *it6505, unsigned int reg,
565 struct device *dev = it6505->dev;
567 if (!it6505->powered)
570 err = regmap_update_bits(it6505->regmap, reg, mask, value);
580 static void it6505_debug_print(struct it6505 *it6505, unsigned int reg,
583 struct device *dev = it6505->dev;
589 val = it6505_read(it6505, reg);
598 static int it6505_dpcd_read(struct it6505 *it6505, unsigned long offset)
602 struct device *dev = it6505->dev;
604 ret = drm_dp_dpcd_readb(&it6505->aux, offset, &value);
612 static int it6505_dpcd_write(struct it6505 *it6505, unsigned long offset,
616 struct device *dev = it6505->dev;
618 ret = drm_dp_dpcd_writeb(&it6505->aux, offset, datain);
626 static int it6505_get_dpcd(struct it6505 *it6505, int offset, u8 *dpcd, int num)
629 struct device *dev = it6505->dev;
631 ret = drm_dp_dpcd_read(&it6505->aux, offset, dpcd, num);
642 static void it6505_dump(struct it6505 *it6505)
646 struct device *dev = it6505->dev;
650 regs[j] = it6505_read(it6505, i + j);
656 static bool it6505_get_sink_hpd_status(struct it6505 *it6505)
660 reg_0d = it6505_read(it6505, REG_SYSTEM_STS);
668 static int it6505_read_word(struct it6505 *it6505, unsigned int reg)
672 val0 = it6505_read(it6505, reg);
676 val1 = it6505_read(it6505, reg + 1);
683 static void it6505_calc_video_info(struct it6505 *it6505)
685 struct device *dev = it6505->dev;
692 rddata = it6505_read(it6505, REG_INPUT_CTRL);
697 htotal = it6505_read_word(it6505, REG_INPUT_HTOTAL) & 0x1FFF;
698 hdes = it6505_read_word(it6505, REG_INPUT_HACTIVE_START) & 0x1FFF;
699 hdew = it6505_read_word(it6505, REG_INPUT_HACTIVE_WIDTH) & 0x1FFF;
700 hfph = it6505_read_word(it6505, REG_INPUT_HFRONT_PORCH) & 0x1FFF;
701 hsyncw = it6505_read_word(it6505, REG_INPUT_HSYNC_WIDTH) & 0x1FFF;
703 vtotal = it6505_read_word(it6505, REG_INPUT_VTOTAL) & 0xFFF;
704 vdes = it6505_read_word(it6505, REG_INPUT_VACTIVE_START) & 0xFFF;
705 vdew = it6505_read_word(it6505, REG_INPUT_VACTIVE_WIDTH) & 0xFFF;
706 vfph = it6505_read_word(it6505, REG_INPUT_VFRONT_PORCH) & 0xFFF;
707 vsyncw = it6505_read_word(it6505, REG_INPUT_VSYNC_WIDTH) & 0xFFF;
715 it6505_set_bits(it6505, REG_DATA_CTRL0, ENABLE_PCLK_COUNTER,
718 it6505_set_bits(it6505, REG_DATA_CTRL0, ENABLE_PCLK_COUNTER,
720 rddata = it6505_read_word(it6505, REG_PCLK_COUNTER_VALUE) &
733 it6505->video_info.clock = pclk;
734 it6505->video_info.hdisplay = hdew;
735 it6505->video_info.hsync_start = hdew + hfph;
736 it6505->video_info.hsync_end = hdew + hfph + hsyncw;
737 it6505->video_info.htotal = htotal;
738 it6505->video_info.vdisplay = vdew;
739 it6505->video_info.vsync_start = vdew + vfph;
740 it6505->video_info.vsync_end = vdew + vfph + vsyncw;
741 it6505->video_info.vtotal = vtotal;
744 DRM_MODE_ARG(&it6505->video_info));
781 static void it6505_clear_int(struct it6505 *it6505)
783 it6505_write(it6505, INT_STATUS_01, 0xFF);
784 it6505_write(it6505, INT_STATUS_02, 0xFF);
785 it6505_write(it6505, INT_STATUS_03, 0xFF);
788 static void it6505_int_mask_enable(struct it6505 *it6505)
790 it6505_write(it6505, INT_MASK_01, BIT(INT_HPD_CHANGE) |
794 it6505_write(it6505, INT_MASK_02, BIT(INT_AUX_CMD_FAIL) |
797 it6505_write(it6505, INT_MASK_03, BIT(INT_LINK_TRAIN_FAIL) |
801 static void it6505_int_mask_disable(struct it6505 *it6505)
803 it6505_write(it6505, INT_MASK_01, 0x00);
804 it6505_write(it6505, INT_MASK_02, 0x00);
805 it6505_write(it6505, INT_MASK_03, 0x00);
808 static void it6505_lane_termination_on(struct it6505 *it6505)
812 regcf = it6505_read(it6505, REG_USER_DRV_PRE);
815 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x00);
818 if (it6505->lane_swap) {
819 switch (it6505->lane_count) {
822 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,
826 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,
831 switch (it6505->lane_count) {
834 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,
838 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL,
846 static void it6505_lane_termination_off(struct it6505 *it6505)
850 regcf = it6505_read(it6505, REG_USER_DRV_PRE);
853 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x80);
856 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x0C, 0x00);
859 static void it6505_lane_power_on(struct it6505 *it6505)
861 it6505_set_bits(it6505, REG_LINK_DRV, 0xF1,
862 (it6505->lane_swap ?
863 GENMASK(7, 8 - it6505->lane_count) :
864 GENMASK(3 + it6505->lane_count, 4)) |
868 static void it6505_lane_power_off(struct it6505 *it6505)
870 it6505_set_bits(it6505, REG_LINK_DRV, 0xF0, 0x00);
873 static void it6505_lane_off(struct it6505 *it6505)
875 it6505_lane_power_off(it6505);
876 it6505_lane_termination_off(it6505);
879 static void it6505_aux_termination_on(struct it6505 *it6505)
883 regcf = it6505_read(it6505, REG_USER_DRV_PRE);
886 it6505_lane_termination_on(it6505);
889 it6505_set_bits(it6505, REG_DRV_LN_DATA_SEL, 0x80, 0x80);
892 static void it6505_aux_power_on(struct it6505 *it6505)
894 it6505_set_bits(it6505, REG_AUX, 0x02, 0x02);
897 static void it6505_aux_on(struct it6505 *it6505)
899 it6505_aux_power_on(it6505);
900 it6505_aux_termination_on(it6505);
903 static void it6505_aux_reset(struct it6505 *it6505)
905 it6505_set_bits(it6505, REG_RESET_CTRL, AUX_RESET, AUX_RESET);
906 it6505_set_bits(it6505, REG_RESET_CTRL, AUX_RESET, 0x00);
909 static void it6505_reset_logic(struct it6505 *it6505)
911 regmap_write(it6505->regmap, REG_RESET_CTRL, ALL_LOGIC_RESET);
915 static bool it6505_aux_op_finished(struct it6505 *it6505)
917 int reg2b = it6505_read(it6505, REG_AUX_CMD_REQ);
925 static int it6505_aux_wait(struct it6505 *it6505)
929 struct device *dev = it6505->dev;
933 while (!it6505_aux_op_finished(it6505)) {
941 status = it6505_read(it6505, REG_AUX_ERROR_STS);
950 static ssize_t it6505_aux_operation(struct it6505 *it6505,
958 if (!it6505_get_sink_hpd_status(it6505))
962 it6505_set_bits(it6505, REG_AUX_CTRL, AUX_USER_MODE, AUX_USER_MODE);
969 it6505_set_bits(it6505, REG_AUX_CTRL,
973 it6505_set_bits(it6505, REG_AUX_CTRL,
979 it6505_set_bits(it6505, REG_AUX_CTRL, AUX_NO_SEGMENT_WR,
984 it6505_write(it6505, REG_AUX_ADR_0_7, (address >> 0) & 0xFF);
986 it6505_write(it6505, REG_AUX_ADR_8_15, (address >> 8) & 0xFF);
988 it6505_write(it6505, REG_AUX_ADR_16_19,
992 regmap_bulk_write(it6505->regmap, REG_AUX_OUT_DATA0, buffer,
996 it6505_write(it6505, REG_AUX_CMD_REQ, cmd);
998 ret = it6505_aux_wait(it6505);
1002 ret = it6505_read(it6505, REG_AUX_ERROR_STS);
1032 ret = it6505_read(it6505, REG_AUX_DATA_FIFO);
1039 ret = it6505_read(it6505, REG_AUX_DATA_0_7 + i);
1057 it6505_set_bits(it6505, REG_AUX_CTRL,
1060 it6505_set_bits(it6505, REG_AUX_CTRL,
1065 it6505_set_bits(it6505, REG_AUX_CTRL, AUX_USER_MODE, 0);
1070 static ssize_t it6505_aux_do_transfer(struct it6505 *it6505,
1077 mutex_lock(&it6505->aux_lock);
1080 ret_size = it6505_aux_operation(it6505, cmd, address + i,
1092 mutex_unlock(&it6505->aux_lock);
1099 struct it6505 *it6505 = container_of(aux, struct it6505, aux);
1120 ret = it6505_aux_do_transfer(it6505, cmd, msg->address, msg->buffer,
1143 struct it6505 *it6505 = data;
1144 struct device *dev = it6505->dev;
1148 it6505_aux_reset(it6505);
1152 ret = it6505_aux_do_transfer(it6505, CMD_AUX_I2C_EDID_READ,
1178 static void it6505_variable_config(struct it6505 *it6505)
1180 it6505->link_rate_bw_code = HBR;
1181 it6505->lane_count = MAX_LANE_COUNT;
1182 it6505->link_state = LINK_IDLE;
1183 it6505->hdcp_desired = HDCP_DESIRED;
1184 it6505->auto_train_retry = AUTO_TRAIN_RETRY;
1185 it6505->audio.select = AUDIO_SELECT;
1186 it6505->audio.sample_rate = AUDIO_SAMPLE_RATE;
1187 it6505->audio.channel_count = AUDIO_CHANNEL_COUNT;
1188 it6505->audio.type = AUDIO_TYPE;
1189 it6505->audio.i2s_input_format = I2S_INPUT_FORMAT;
1190 it6505->audio.i2s_justified = I2S_JUSTIFIED;
1191 it6505->audio.i2s_data_delay = I2S_DATA_DELAY;
1192 it6505->audio.i2s_ws_channel = I2S_WS_CHANNEL;
1193 it6505->audio.i2s_data_sequence = I2S_DATA_SEQUENCE;
1194 it6505->audio.word_length = AUDIO_WORD_LENGTH;
1195 memset(it6505->sha1_input, 0, sizeof(it6505->sha1_input));
1196 memset(it6505->bksvs, 0, sizeof(it6505->bksvs));
1199 static int it6505_send_video_infoframe(struct it6505 *it6505,
1204 struct device *dev = it6505->dev;
1212 err = it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AVI_PKT, 0x00);
1216 err = regmap_bulk_write(it6505->regmap, REG_AVI_INFO_DB1,
1222 err = it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AVI_PKT,
1230 static void it6505_get_extcon_property(struct it6505 *it6505)
1234 struct device *dev = it6505->dev;
1236 if (it6505->extcon && !it6505->lane_swap_disabled) {
1237 err = extcon_get_property(it6505->extcon, EXTCON_DISP_DP,
1244 it6505->lane_swap = property.intval;
1248 static void it6505_clk_phase_adjustment(struct it6505 *it6505,
1253 it6505_set_bits(it6505, REG_CLK_CTRL0, M_PCLK_DELAY,
1255 it6505_set_bits(it6505, REG_DATA_CTRL0, VIDEO_LATCH_EDGE,
1259 static void it6505_link_reset_step_train(struct it6505 *it6505)
1261 it6505_set_bits(it6505, REG_TRAIN_CTRL0,
1263 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1267 static void it6505_init(struct it6505 *it6505)
1269 it6505_write(it6505, REG_AUX_OPT, AUX_AUTO_RST | AUX_FIX_FREQ);
1270 it6505_write(it6505, REG_AUX_CTRL, AUX_NO_SEGMENT_WR);
1271 it6505_write(it6505, REG_HDCP_CTRL2, HDCP_AN_SEL | HDCP_HW_HPDIRQ_ACT);
1272 it6505_write(it6505, REG_VID_BUS_CTRL0, IN_DDR | DDR_CD);
1273 it6505_write(it6505, REG_VID_BUS_CTRL1, 0x01);
1274 it6505_write(it6505, REG_AUDIO_CTRL0, AUDIO_16B_BOUND);
1277 it6505_write(it6505, REG_HPD_IRQ_TIME, 0xF5);
1278 it6505_write(it6505, REG_AUX_DEBUG_MODE, 0x4D);
1279 it6505_write(it6505, REG_AUX_OPT2, 0x17);
1280 it6505_write(it6505, REG_HDCP_OPT, 0x60);
1281 it6505_write(it6505, REG_DATA_MUTE_CTRL,
1283 it6505_write(it6505, REG_TIME_STMP_CTRL,
1285 it6505_write(it6505, REG_INFOFRAME_CTRL, 0x00);
1286 it6505_write(it6505, REG_DRV_0_DB_800_MV,
1287 afe_setting_table[it6505->afe_setting][0]);
1288 it6505_write(it6505, REG_PRE_0_DB_800_MV,
1289 afe_setting_table[it6505->afe_setting][1]);
1290 it6505_write(it6505, REG_PRE_3P5_DB_800_MV,
1291 afe_setting_table[it6505->afe_setting][2]);
1292 it6505_write(it6505, REG_SSC_CTRL0, 0x9E);
1293 it6505_write(it6505, REG_SSC_CTRL1, 0x1C);
1294 it6505_write(it6505, REG_SSC_CTRL2, 0x42);
1297 static void it6505_video_disable(struct it6505 *it6505)
1299 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, EN_VID_MUTE);
1300 it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_VID_CTRL_PKT, 0x00);
1301 it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, VIDEO_RESET);
1304 static void it6505_video_reset(struct it6505 *it6505)
1306 it6505_link_reset_step_train(it6505);
1307 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, EN_VID_MUTE);
1308 it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_VID_CTRL_PKT, 0x00);
1309 it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, VIDEO_RESET);
1310 it6505_set_bits(it6505, REG_501_FIFO_CTRL, RST_501_FIFO, RST_501_FIFO);
1311 it6505_set_bits(it6505, REG_501_FIFO_CTRL, RST_501_FIFO, 0x00);
1312 it6505_set_bits(it6505, REG_RESET_CTRL, VIDEO_RESET, 0x00);
1315 static void it6505_update_video_parameter(struct it6505 *it6505,
1318 it6505_clk_phase_adjustment(it6505, mode);
1319 it6505_video_disable(it6505);
1322 static bool it6505_audio_input(struct it6505 *it6505)
1326 reg05 = it6505_read(it6505, REG_RESET_CTRL);
1327 it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, 0x00);
1329 regbe = it6505_read(it6505, REG_AUDIO_INPUT_FREQ);
1330 it6505_write(it6505, REG_RESET_CTRL, reg05);
1335 static void it6505_setup_audio_channel_status(struct it6505 *it6505)
1337 enum it6505_audio_sample_rate sample_rate = it6505->audio.sample_rate;
1341 it6505_write(it6505, REG_IEC958_STS0, it6505->audio.type << 1);
1342 it6505_write(it6505, REG_IEC958_STS1, 0x00);
1343 it6505_write(it6505, REG_IEC958_STS2, 0x00);
1344 it6505_write(it6505, REG_IEC958_STS3, sample_rate);
1345 it6505_write(it6505, REG_IEC958_STS4, (~sample_rate << 4) |
1346 audio_word_length_map[it6505->audio.word_length]);
1349 static void it6505_setup_audio_format(struct it6505 *it6505)
1352 it6505_write(it6505, REG_AUDIO_FMT,
1353 (it6505->audio.word_length << 5) |
1354 (it6505->audio.i2s_data_sequence << 4) |
1355 (it6505->audio.i2s_ws_channel << 3) |
1356 (it6505->audio.i2s_data_delay << 2) |
1357 (it6505->audio.i2s_justified << 1) |
1358 it6505->audio.i2s_input_format);
1359 if (it6505->audio.select == SPDIF) {
1360 it6505_write(it6505, REG_AUDIO_FIFO_SEL, 0x00);
1362 it6505_set_bits(it6505, REG_AUX_OPT, 0xF0, 0x30);
1364 it6505_write(it6505, REG_AUDIO_FIFO_SEL, 0xE4);
1367 it6505_write(it6505, REG_AUDIO_CTRL0, 0x20);
1368 it6505_write(it6505, REG_AUDIO_CTRL1, 0x00);
1371 static void it6505_enable_audio_source(struct it6505 *it6505)
1375 audio_source_count = BIT(DIV_ROUND_UP(it6505->audio.channel_count, 2))
1378 audio_source_count |= it6505->audio.select << 4;
1380 it6505_write(it6505, REG_AUDIO_SRC_CTRL, audio_source_count);
1383 static void it6505_enable_audio_infoframe(struct it6505 *it6505)
1385 struct device *dev = it6505->dev;
1389 audio_info_ca[it6505->audio.channel_count - 1]);
1391 it6505_write(it6505, REG_AUD_INFOFRAM_DB1, it6505->audio.channel_count
1393 it6505_write(it6505, REG_AUD_INFOFRAM_DB2, 0x00);
1394 it6505_write(it6505, REG_AUD_INFOFRAM_DB3,
1395 audio_info_ca[it6505->audio.channel_count - 1]);
1396 it6505_write(it6505, REG_AUD_INFOFRAM_DB4, 0x00);
1397 it6505_write(it6505, REG_AUD_INFOFRAM_SUM, 0x00);
1400 it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AUD_CTRL_PKT,
1404 static void it6505_disable_audio(struct it6505 *it6505)
1406 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_AUD_MUTE, EN_AUD_MUTE);
1407 it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, M_AUDIO_I2S_EN, 0x00);
1408 it6505_set_bits(it6505, REG_INFOFRAME_CTRL, EN_AUD_CTRL_PKT, 0x00);
1409 it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, AUDIO_RESET);
1412 static void it6505_enable_audio(struct it6505 *it6505)
1414 struct device *dev = it6505->dev;
1418 it6505_disable_audio(it6505);
1420 it6505_setup_audio_channel_status(it6505);
1421 it6505_setup_audio_format(it6505);
1422 it6505_enable_audio_source(it6505);
1423 it6505_enable_audio_infoframe(it6505);
1425 it6505_write(it6505, REG_AUDIO_N_0_7, 0x00);
1426 it6505_write(it6505, REG_AUDIO_N_8_15, 0x80);
1427 it6505_write(it6505, REG_AUDIO_N_16_23, 0x00);
1429 it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, AUDIO_FIFO_RESET,
1431 it6505_set_bits(it6505, REG_AUDIO_SRC_CTRL, AUDIO_FIFO_RESET, 0x00);
1432 it6505_set_bits(it6505, REG_RESET_CTRL, AUDIO_RESET, 0x00);
1433 regbe = it6505_read(it6505, REG_AUDIO_INPUT_FREQ);
1436 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_AUD_MUTE, 0x00);
1439 static bool it6505_use_step_train_check(struct it6505 *it6505)
1441 if (it6505->link.revision >= 0x12)
1442 return it6505->dpcd[DP_TRAINING_AUX_RD_INTERVAL] >= 0x01;
1447 static void it6505_parse_link_capabilities(struct it6505 *it6505)
1449 struct device *dev = it6505->dev;
1450 struct it6505_drm_dp_link *link = &it6505->link;
1453 if (it6505->dpcd[0] == 0) {
1460 link->revision = it6505->dpcd[0];
1461 link->rate = drm_dp_bw_code_to_link_rate(it6505->dpcd[1]);
1462 link->num_lanes = it6505->dpcd[2] & DP_MAX_LANE_COUNT_MASK;
1464 if (it6505->dpcd[2] & DP_ENHANCED_FRAME_CAP)
1473 it6505->link_rate_bw_code = drm_dp_link_rate_to_bw_code(link->rate);
1475 it6505->link_rate_bw_code);
1476 it6505->link_rate_bw_code = min_t(int, it6505->link_rate_bw_code,
1479 it6505->lane_count = link->num_lanes;
1481 it6505->lane_count);
1482 it6505->lane_count = min_t(int, it6505->lane_count,
1483 it6505->max_lane_count);
1485 it6505->branch_device = drm_dp_is_branch(it6505->dpcd);
1487 it6505->branch_device ? "" : "Not ");
1489 it6505->enable_enhanced_frame = link->capabilities;
1491 it6505->enable_enhanced_frame ? "" : "Not ");
1493 it6505->enable_ssc = (it6505->dpcd[DP_MAX_DOWNSPREAD] &
1496 it6505->enable_ssc ? "0.5" : "0",
1497 it6505->enable_ssc ? "" : "Not ");
1499 it6505->step_train = it6505_use_step_train_check(it6505);
1500 if (it6505->step_train)
1503 bcaps = it6505_dpcd_read(it6505, DP_AUX_HDCP_BCAPS);
1506 it6505->is_repeater = (bcaps & DP_BCAPS_REPEATER_PRESENT);
1508 it6505->is_repeater ? "repeater" :
1512 it6505->hdcp_desired = false;
1515 it6505->hdcp_desired ? "desired" : "undesired");
1518 static void it6505_setup_ssc(struct it6505 *it6505)
1520 it6505_set_bits(it6505, REG_TRAIN_CTRL0, SPREAD_AMP_5,
1521 it6505->enable_ssc ? SPREAD_AMP_5 : 0x00);
1522 if (it6505->enable_ssc) {
1523 it6505_write(it6505, REG_SSC_CTRL0, 0x9E);
1524 it6505_write(it6505, REG_SSC_CTRL1, 0x1C);
1525 it6505_write(it6505, REG_SSC_CTRL2, 0x42);
1526 it6505_write(it6505, REG_SP_CTRL0, 0x07);
1527 it6505_write(it6505, REG_IP_CTRL1, 0x29);
1528 it6505_write(it6505, REG_IP_CTRL2, 0x03);
1530 it6505_set_bits(it6505, REG_TIME_STMP_CTRL, M_STAMP_STEP,
1532 it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL,
1535 it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL, 0x00);
1536 it6505_set_bits(it6505, REG_TIME_STMP_CTRL, M_STAMP_STEP,
1541 static inline void it6505_link_rate_setup(struct it6505 *it6505)
1543 it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_LBR,
1544 (it6505->link_rate_bw_code == RBR) ? FORCE_LBR : 0x00);
1545 it6505_set_bits(it6505, REG_LINK_DRV, DRV_HS,
1546 (it6505->link_rate_bw_code == RBR) ? 0x00 : DRV_HS);
1549 static void it6505_lane_count_setup(struct it6505 *it6505)
1551 it6505_get_extcon_property(it6505);
1552 it6505_set_bits(it6505, REG_TRAIN_CTRL0, LANE_SWAP,
1553 it6505->lane_swap ? LANE_SWAP : 0x00);
1554 it6505_set_bits(it6505, REG_TRAIN_CTRL0, LANE_COUNT_MASK,
1555 (it6505->lane_count - 1) << 1);
1558 static void it6505_link_training_setup(struct it6505 *it6505)
1560 struct device *dev = it6505->dev;
1562 if (it6505->enable_enhanced_frame)
1563 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL,
1566 it6505_link_rate_setup(it6505);
1567 it6505_lane_count_setup(it6505);
1568 it6505_setup_ssc(it6505);
1571 it6505->link_rate_bw_code != RBR ? "HBR" : "RBR",
1572 it6505->lane_count,
1573 it6505->enable_ssc ? "en" : "dis",
1574 it6505->enable_enhanced_frame ? "en" : "dis");
1577 static bool it6505_link_start_auto_train(struct it6505 *it6505)
1582 mutex_lock(&it6505->aux_lock);
1583 it6505_set_bits(it6505, REG_TRAIN_CTRL0,
1585 it6505_write(it6505, REG_TRAIN_CTRL1, FORCE_RETRAIN);
1586 it6505_write(it6505, REG_TRAIN_CTRL1, AUTO_TRAIN);
1590 link_training_state = it6505_read(it6505, REG_LINK_TRAIN_STS);
1601 mutex_unlock(&it6505->aux_lock);
1606 static int it6505_drm_dp_link_configure(struct it6505 *it6505)
1610 struct drm_dp_aux *aux = &it6505->aux;
1612 values[0] = it6505->link_rate_bw_code;
1613 values[1] = it6505->lane_count;
1615 if (it6505->enable_enhanced_frame)
1649 step_train_lane_voltage_para_set(struct it6505 *it6505,
1658 for (i = 0; i < it6505->lane_count; i++) {
1671 it6505_dpcd_write(it6505, DP_TRAINING_LANE0_SET + i,
1675 it6505_dpcd_read(it6505, DP_TRAINING_LANE0_SET + i))
1683 it6505_step_cr_train(struct it6505 *it6505,
1690 const struct drm_dp_aux *aux = &it6505->aux;
1692 it6505_dpcd_write(it6505, DP_DOWNSPREAD_CTRL,
1693 it6505->enable_ssc ? DP_SPREAD_AMP_0_5 : 0x00);
1694 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1699 if (!step_train_lane_voltage_para_set(it6505,
1703 drm_dp_link_train_clock_recovery_delay(aux, it6505->dpcd);
1704 drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
1706 if (drm_dp_clock_recovery_ok(link_status, it6505->lane_count)) {
1707 it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_CR_DONE,
1711 DRM_DEV_DEBUG_DRIVER(it6505->dev, "cr not done");
1714 it6505->lane_count))
1717 for (j = 0; j < it6505->lane_count; j++) {
1750 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1757 it6505_step_eq_train(struct it6505 *it6505,
1762 const struct drm_dp_aux *aux = &it6505->aux;
1764 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1770 if (!step_train_lane_voltage_para_set(it6505,
1775 drm_dp_link_train_channel_eq_delay(aux, it6505->dpcd);
1776 drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
1778 if (!drm_dp_clock_recovery_ok(link_status, it6505->lane_count))
1781 if (drm_dp_channel_eq_ok(link_status, it6505->lane_count)) {
1782 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1784 it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_EQ_DONE,
1788 DRM_DEV_DEBUG_DRIVER(it6505->dev, "eq not done");
1790 for (i = 0; i < it6505->lane_count; i++) {
1810 it6505_dpcd_write(it6505, DP_TRAINING_PATTERN_SET,
1815 static bool it6505_link_start_step_train(struct it6505 *it6505)
1823 DRM_DEV_DEBUG_DRIVER(it6505->dev, "start");
1824 err = it6505_drm_dp_link_configure(it6505);
1828 if (!it6505_step_cr_train(it6505, &lane_voltage_pre_emphasis))
1830 if (!it6505_step_eq_train(it6505, &lane_voltage_pre_emphasis))
1835 static bool it6505_get_video_status(struct it6505 *it6505)
1839 reg_0d = it6505_read(it6505, REG_SYSTEM_STS);
1847 static void it6505_reset_hdcp(struct it6505 *it6505)
1849 it6505->hdcp_status = HDCP_AUTH_IDLE;
1851 it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, 0x00);
1852 it6505_set_bits(it6505, REG_RESET_CTRL, HDCP_RESET, HDCP_RESET);
1855 static void it6505_start_hdcp(struct it6505 *it6505)
1857 struct device *dev = it6505->dev;
1860 it6505_reset_hdcp(it6505);
1861 queue_delayed_work(system_wq, &it6505->hdcp_work,
1865 static void it6505_stop_hdcp(struct it6505 *it6505)
1867 it6505_reset_hdcp(it6505);
1868 cancel_delayed_work(&it6505->hdcp_work);
1883 static void it6505_hdcp_part1_auth(struct it6505 *it6505)
1885 struct device *dev = it6505->dev;
1888 it6505_set_bits(it6505, REG_RESET_CTRL, HDCP_RESET, 0x00);
1890 it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, 0x00);
1893 hdcp_bcaps = it6505_dpcd_read(it6505, DP_AUX_HDCP_BCAPS);
1901 it6505_set_bits(it6505, REG_HDCP_TRIGGER,
1906 it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_AN_GEN, HDCP_AN_GEN);
1910 it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_AN_GEN, 0x00);
1912 it6505_set_bits(it6505, REG_HDCP_CTRL1, HDCP_CP_ENABLE, HDCP_CP_ENABLE);
1914 it6505_set_bits(it6505, REG_HDCP_TRIGGER, HDCP_TRIGGER_START,
1917 it6505->hdcp_status = HDCP_AUTH_GOING;
1920 static int it6505_sha1_digest(struct it6505 *it6505, u8 *sha1_input,
1926 struct device *dev = it6505->dev;
1949 static int it6505_setup_sha1_input(struct it6505 *it6505, u8 *sha1_input)
1951 struct device *dev = it6505->dev;
1955 err = it6505_get_dpcd(it6505, DP_AUX_HDCP_BINFO, binfo,
1980 err = it6505_get_dpcd(it6505, DP_AUX_HDCP_KSV_FIFO +
1991 it6505->hdcp_down_stream_count = down_stream_count;
1995 it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_EN_M0_READ,
1998 err = regmap_bulk_read(it6505->regmap, REG_M0_0_7,
2001 it6505_set_bits(it6505, REG_HDCP_CTRL2, HDCP_EN_M0_READ, 0x00);
2013 static bool it6505_hdcp_part2_ksvlist_check(struct it6505 *it6505)
2015 struct device *dev = it6505->dev;
2019 i = it6505_setup_sha1_input(it6505, it6505->sha1_input);
2025 it6505_sha1_digest(it6505, it6505->sha1_input, i, (u8 *)av);
2027 err = it6505_get_dpcd(it6505, DP_AUX_HDCP_V_PRIME(0), (u8 *)bv,
2046 struct it6505 *it6505 = container_of(work, struct it6505,
2048 struct device *dev = it6505->dev;
2055 if (!it6505_get_sink_hpd_status(it6505))
2058 bstatus = it6505_dpcd_read(it6505, DP_AUX_HDCP_BSTATUS);
2072 ksv_list_check = it6505_hdcp_part2_ksvlist_check(it6505);
2076 it6505_set_bits(it6505, REG_HDCP_TRIGGER,
2081 it6505_set_bits(it6505, REG_HDCP_TRIGGER,
2088 struct it6505 *it6505 = container_of(work, struct it6505,
2090 struct device *dev = it6505->dev;
2096 if (!it6505_get_sink_hpd_status(it6505))
2099 ret = drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
2103 if (ret < 0 || !drm_dp_channel_eq_ok(link_status, it6505->lane_count) ||
2104 !it6505_get_video_status(it6505)) {
2109 ret = it6505_get_dpcd(it6505, DP_AUX_HDCP_BKSV, it6505->bksvs,
2110 ARRAY_SIZE(it6505->bksvs));
2113 it6505_set_bits(it6505, REG_HDCP_TRIGGER,
2118 (int)ARRAY_SIZE(it6505->bksvs), it6505->bksvs);
2120 if (!it6505_hdcp_is_ksv_valid(it6505->bksvs)) {
2122 it6505_set_bits(it6505, REG_HDCP_TRIGGER,
2126 it6505_hdcp_part1_auth(it6505);
2129 static void it6505_show_hdcp_info(struct it6505 *it6505)
2131 struct device *dev = it6505->dev;
2133 u8 *sha1 = it6505->sha1_input;
2136 it6505->hdcp_status, it6505->is_repeater);
2138 (int)ARRAY_SIZE(it6505->bksvs), it6505->bksvs);
2140 if (it6505->is_repeater) {
2142 it6505->hdcp_down_stream_count);
2144 (int)ARRAY_SIZE(it6505->sha1_input),
2145 it6505->sha1_input);
2146 for (i = 0; i < it6505->hdcp_down_stream_count; i++) {
2156 static void it6505_stop_link_train(struct it6505 *it6505)
2158 it6505->link_state = LINK_IDLE;
2159 cancel_work_sync(&it6505->link_works);
2160 it6505_write(it6505, REG_TRAIN_CTRL1, FORCE_RETRAIN);
2163 static void it6505_link_train_ok(struct it6505 *it6505)
2165 struct device *dev = it6505->dev;
2167 it6505->link_state = LINK_OK;
2169 it6505_set_bits(it6505, REG_DATA_MUTE_CTRL, EN_VID_MUTE, 0x00);
2170 it6505_set_bits(it6505, REG_INFOFRAME_CTRL,
2173 if (it6505_audio_input(it6505)) {
2175 it6505_enable_audio(it6505);
2178 if (it6505->hdcp_desired)
2179 it6505_start_hdcp(it6505);
2182 static void it6505_link_step_train_process(struct it6505 *it6505)
2184 struct device *dev = it6505->dev;
2189 if (it6505->sink_count == 0) {
2190 DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d, force eq",
2191 it6505->sink_count);
2192 it6505_set_bits(it6505, REG_TRAIN_CTRL0, FORCE_EQ_DONE,
2197 if (!it6505->step_train) {
2204 it6505_link_reset_step_train(it6505);
2205 ret = it6505_link_start_step_train(it6505);
2209 it6505_link_train_ok(it6505);
2215 it6505->link_state = LINK_IDLE;
2216 it6505_video_reset(it6505);
2221 struct it6505 *it6505 = container_of(work, struct it6505, link_works);
2222 struct device *dev = it6505->dev;
2225 DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count: %d",
2226 it6505->sink_count);
2228 if (!it6505_get_sink_hpd_status(it6505))
2231 it6505_link_training_setup(it6505);
2232 it6505_reset_hdcp(it6505);
2233 it6505_aux_reset(it6505);
2235 if (it6505->auto_train_retry < 1) {
2236 it6505_link_step_train_process(it6505);
2240 ret = it6505_link_start_auto_train(it6505);
2242 ret ? "pass" : "failed", it6505->auto_train_retry);
2243 it6505->auto_train_retry--;
2246 it6505_link_train_ok(it6505);
2250 it6505_dump(it6505);
2253 static void it6505_plugged_status_to_codec(struct it6505 *it6505)
2255 enum drm_connector_status status = it6505->connector_status;
2257 if (it6505->plugged_cb && it6505->codec_dev)
2258 it6505->plugged_cb(it6505->codec_dev,
2262 static void it6505_remove_edid(struct it6505 *it6505)
2264 kfree(it6505->cached_edid);
2265 it6505->cached_edid = NULL;
2268 static int it6505_process_hpd_irq(struct it6505 *it6505)
2270 struct device *dev = it6505->dev;
2274 if (!it6505_get_sink_hpd_status(it6505)) {
2276 it6505->sink_count = 0;
2280 ret = it6505_dpcd_read(it6505, DP_SINK_COUNT);
2285 DRM_DEV_DEBUG_DRIVER(dev, "dpcd_sink_count: %d it6505->sink_count:%d",
2286 dpcd_sink_count, it6505->sink_count);
2288 if (it6505->branch_device && dpcd_sink_count != it6505->sink_count) {
2289 memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
2290 it6505->sink_count = dpcd_sink_count;
2291 it6505_reset_logic(it6505);
2292 it6505_int_mask_enable(it6505);
2293 it6505_init(it6505);
2294 it6505_remove_edid(it6505);
2298 dp_irq_vector = it6505_dpcd_read(it6505, DP_DEVICE_SERVICE_IRQ_VECTOR);
2305 it6505_set_bits(it6505, REG_HDCP_TRIGGER, HDCP_TRIGGER_CPIRQ,
2308 bstatus = it6505_dpcd_read(it6505, DP_AUX_HDCP_BSTATUS);
2315 ret = drm_dp_dpcd_read_link_status(&it6505->aux, link_status);
2324 if (!drm_dp_channel_eq_ok(link_status, it6505->lane_count)) {
2325 it6505->auto_train_retry = AUTO_TRAIN_RETRY;
2326 it6505_video_reset(it6505);
2332 static void it6505_irq_hpd(struct it6505 *it6505)
2334 struct device *dev = it6505->dev;
2337 it6505->hpd_state = it6505_get_sink_hpd_status(it6505);
2339 it6505->hpd_state ? "high" : "low");
2341 if (it6505->hpd_state) {
2342 wait_for_completion_timeout(&it6505->extcon_completion,
2344 it6505_aux_on(it6505);
2345 if (it6505->dpcd[0] == 0) {
2346 it6505_get_dpcd(it6505, DP_DPCD_REV, it6505->dpcd,
2347 ARRAY_SIZE(it6505->dpcd));
2348 it6505_variable_config(it6505);
2349 it6505_parse_link_capabilities(it6505);
2351 it6505->auto_train_retry = AUTO_TRAIN_RETRY;
2353 it6505_drm_dp_link_set_power(&it6505->aux, &it6505->link,
2355 dp_sink_count = it6505_dpcd_read(it6505, DP_SINK_COUNT);
2356 it6505->sink_count = DP_GET_SINK_COUNT(dp_sink_count);
2358 DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count: %d",
2359 it6505->sink_count);
2361 it6505_lane_termination_on(it6505);
2362 it6505_lane_power_on(it6505);
2367 * it6505 not able to receive HPD_IRQ
2371 if (it6505->branch_device && it6505->sink_count == 0)
2372 schedule_work(&it6505->link_works);
2374 if (!it6505_get_video_status(it6505))
2375 it6505_video_reset(it6505);
2377 memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
2378 it6505_remove_edid(it6505);
2380 if (it6505->hdcp_desired)
2381 it6505_stop_hdcp(it6505);
2383 it6505_video_disable(it6505);
2384 it6505_disable_audio(it6505);
2385 it6505_stop_link_train(it6505);
2386 it6505_lane_off(it6505);
2387 it6505_link_reset_step_train(it6505);
2390 if (it6505->bridge.dev)
2391 drm_helper_hpd_irq_event(it6505->bridge.dev);
2394 static void it6505_irq_hpd_irq(struct it6505 *it6505)
2396 struct device *dev = it6505->dev;
2400 if (it6505_process_hpd_irq(it6505) < 0)
2404 static void it6505_irq_scdt(struct it6505 *it6505)
2406 struct device *dev = it6505->dev;
2409 data = it6505_get_video_status(it6505);
2412 it6505_calc_video_info(it6505);
2413 it6505_link_reset_step_train(it6505);
2416 schedule_work(&it6505->link_works);
2419 static void it6505_irq_hdcp_done(struct it6505 *it6505)
2421 struct device *dev = it6505->dev;
2424 it6505->hdcp_status = HDCP_AUTH_DONE;
2425 it6505_show_hdcp_info(it6505);
2428 static void it6505_irq_hdcp_fail(struct it6505 *it6505)
2430 struct device *dev = it6505->dev;
2433 it6505->hdcp_status = HDCP_AUTH_IDLE;
2434 it6505_show_hdcp_info(it6505);
2435 it6505_start_hdcp(it6505);
2438 static void it6505_irq_aux_cmd_fail(struct it6505 *it6505)
2440 struct device *dev = it6505->dev;
2445 static void it6505_irq_hdcp_ksv_check(struct it6505 *it6505)
2447 struct device *dev = it6505->dev;
2450 schedule_work(&it6505->hdcp_wait_ksv_list);
2453 static void it6505_irq_audio_fifo_error(struct it6505 *it6505)
2455 struct device *dev = it6505->dev;
2459 if (it6505_audio_input(it6505))
2460 it6505_enable_audio(it6505);
2463 static void it6505_irq_link_train_fail(struct it6505 *it6505)
2465 struct device *dev = it6505->dev;
2468 schedule_work(&it6505->link_works);
2471 static void it6505_irq_video_fifo_error(struct it6505 *it6505)
2473 struct device *dev = it6505->dev;
2476 it6505->auto_train_retry = AUTO_TRAIN_RETRY;
2477 flush_work(&it6505->link_works);
2478 it6505_stop_hdcp(it6505);
2479 it6505_video_reset(it6505);
2482 static void it6505_irq_io_latch_fifo_overflow(struct it6505 *it6505)
2484 struct device *dev = it6505->dev;
2487 it6505->auto_train_retry = AUTO_TRAIN_RETRY;
2488 flush_work(&it6505->link_works);
2489 it6505_stop_hdcp(it6505);
2490 it6505_video_reset(it6505);
2500 struct it6505 *it6505 = data;
2501 struct device *dev = it6505->dev;
2504 void (*handler)(struct it6505 *it6505);
2520 if (it6505->enable_drv_hold || !it6505->powered)
2525 int_status[0] = it6505_read(it6505, INT_STATUS_01);
2526 int_status[1] = it6505_read(it6505, INT_STATUS_02);
2527 int_status[2] = it6505_read(it6505, INT_STATUS_03);
2529 it6505_write(it6505, INT_STATUS_01, int_status[0]);
2530 it6505_write(it6505, INT_STATUS_02, int_status[1]);
2531 it6505_write(it6505, INT_STATUS_03, int_status[2]);
2536 it6505_debug_print(it6505, REG_SYSTEM_STS, "");
2539 irq_vec[0].handler(it6505);
2541 if (it6505->hpd_state) {
2544 irq_vec[i].handler(it6505);
2553 static int it6505_poweron(struct it6505 *it6505)
2555 struct device *dev = it6505->dev;
2556 struct it6505_platform_data *pdata = &it6505->pdata;
2559 DRM_DEV_DEBUG_DRIVER(dev, "it6505 start powered on");
2561 if (it6505->powered) {
2562 DRM_DEV_DEBUG_DRIVER(dev, "it6505 already powered on");
2593 it6505->powered = true;
2594 it6505_reset_logic(it6505);
2595 it6505_int_mask_enable(it6505);
2596 it6505_init(it6505);
2597 it6505_lane_off(it6505);
2602 static int it6505_poweroff(struct it6505 *it6505)
2604 struct device *dev = it6505->dev;
2605 struct it6505_platform_data *pdata = &it6505->pdata;
2608 DRM_DEV_DEBUG_DRIVER(dev, "it6505 start power off");
2610 if (!it6505->powered) {
2630 it6505->powered = false;
2631 it6505->sink_count = 0;
2636 static enum drm_connector_status it6505_detect(struct it6505 *it6505)
2638 struct device *dev = it6505->dev;
2642 DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d powered:%d",
2643 it6505->sink_count, it6505->powered);
2645 mutex_lock(&it6505->mode_lock);
2647 if (!it6505->powered)
2650 if (it6505->enable_drv_hold) {
2651 status = it6505->hpd_state ? connector_status_connected :
2656 if (it6505->hpd_state) {
2657 it6505_drm_dp_link_set_power(&it6505->aux, &it6505->link,
2659 dp_sink_count = it6505_dpcd_read(it6505, DP_SINK_COUNT);
2660 it6505->sink_count = DP_GET_SINK_COUNT(dp_sink_count);
2661 DRM_DEV_DEBUG_DRIVER(dev, "it6505->sink_count:%d branch:%d",
2662 it6505->sink_count, it6505->branch_device);
2664 if (it6505->branch_device) {
2665 status = (it6505->sink_count != 0) ?
2672 it6505->sink_count = 0;
2673 memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
2677 if (it6505->connector_status != status) {
2678 it6505->connector_status = status;
2679 it6505_plugged_status_to_codec(it6505);
2682 mutex_unlock(&it6505->mode_lock);
2690 struct it6505 *it6505 = container_of(self, struct it6505, event_nb);
2692 schedule_work(&it6505->extcon_wq);
2698 struct it6505 *it6505 = container_of(work, struct it6505, extcon_wq);
2699 struct device *dev = it6505->dev;
2702 if (it6505->enable_drv_hold)
2705 mutex_lock(&it6505->extcon_lock);
2707 state = extcon_get_state(it6505->extcon, EXTCON_DISP_DP);
2710 if (state == it6505->extcon_state || unlikely(state < 0))
2712 it6505->extcon_state = state;
2724 it6505_poweron(it6505);
2726 complete_all(&it6505->extcon_completion);
2730 reinit_completion(&it6505->extcon_completion);
2732 drm_helper_hpd_irq_event(it6505->bridge.dev);
2733 memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
2734 DRM_DEV_DEBUG_DRIVER(dev, "power off it6505 success!");
2738 mutex_unlock(&it6505->extcon_lock);
2741 static int it6505_use_notifier_module(struct it6505 *it6505)
2744 struct device *dev = it6505->dev;
2746 it6505->event_nb.notifier_call = it6505_extcon_notifier;
2747 INIT_WORK(&it6505->extcon_wq, it6505_extcon_work);
2748 ret = devm_extcon_register_notifier(it6505->dev,
2749 it6505->extcon, EXTCON_DISP_DP,
2750 &it6505->event_nb);
2756 schedule_work(&it6505->extcon_wq);
2761 static void it6505_remove_notifier_module(struct it6505 *it6505)
2763 if (it6505->extcon) {
2764 devm_extcon_unregister_notifier(it6505->dev,
2765 it6505->extcon, EXTCON_DISP_DP,
2766 &it6505->event_nb);
2768 flush_work(&it6505->extcon_wq);
2774 struct it6505 *it6505 = container_of(work, struct it6505,
2777 DRM_DEV_DEBUG_DRIVER(it6505->dev, "start");
2779 if (!it6505->powered)
2782 if (!it6505->enable_drv_hold)
2783 it6505_enable_audio(it6505);
2786 static int __maybe_unused it6505_audio_setup_hw_params(struct it6505 *it6505,
2790 struct device *dev = it6505->dev;
2797 if (!it6505->bridge.encoder)
2802 it6505->audio.channel_count);
2806 it6505->audio.channel_count = params->cea.channels;
2818 it6505->audio.sample_rate = audio_sample_rate_map[i].rate;
2822 it6505->audio.word_length = WORD_LENGTH_16BIT;
2825 it6505->audio.word_length = WORD_LENGTH_18BIT;
2828 it6505->audio.word_length = WORD_LENGTH_20BIT;
2832 it6505->audio.word_length = WORD_LENGTH_24BIT;
2845 struct it6505 *it6505 = dev_get_drvdata(dev);
2847 if (it6505->powered)
2848 it6505_disable_audio(it6505);
2856 struct it6505 *it6505 = data;
2858 it6505->plugged_cb = fn;
2859 it6505->codec_dev = codec_dev;
2860 it6505_plugged_status_to_codec(it6505);
2865 static inline struct it6505 *bridge_to_it6505(struct drm_bridge *bridge)
2867 return container_of(bridge, struct it6505, bridge);
2873 struct it6505 *it6505 = bridge_to_it6505(bridge);
2874 struct device *dev = it6505->dev;
2888 it6505->aux.drm_dev = bridge->dev;
2890 ret = drm_dp_aux_register(&it6505->aux);
2897 if (it6505->extcon) {
2898 ret = it6505_use_notifier_module(it6505);
2910 struct it6505 *it6505 = bridge_to_it6505(bridge);
2912 flush_work(&it6505->link_works);
2913 it6505_remove_notifier_module(it6505);
2921 struct it6505 *it6505 = bridge_to_it6505(bridge);
2926 if (mode->clock > it6505->max_dpi_pixel_clock)
2929 it6505->video_info.clock = mode->clock;
2937 struct it6505 *it6505 = bridge_to_it6505(bridge);
2938 struct device *dev = it6505->dev;
2976 it6505_update_video_parameter(it6505, mode);
2978 ret = it6505_send_video_infoframe(it6505, &frame);
2983 it6505_int_mask_enable(it6505);
2984 it6505_video_reset(it6505);
2986 it6505_drm_dp_link_set_power(&it6505->aux, &it6505->link,
2993 struct it6505 *it6505 = bridge_to_it6505(bridge);
2994 struct device *dev = it6505->dev;
2998 if (it6505->powered) {
2999 it6505_drm_dp_link_set_power(&it6505->aux, &it6505->link,
3001 it6505_video_disable(it6505);
3008 struct it6505 *it6505 = bridge_to_it6505(bridge);
3009 struct device *dev = it6505->dev;
3019 struct it6505 *it6505 = bridge_to_it6505(bridge);
3020 struct device *dev = it6505->dev;
3030 struct it6505 *it6505 = bridge_to_it6505(bridge);
3032 return it6505_detect(it6505);
3038 struct it6505 *it6505 = bridge_to_it6505(bridge);
3039 struct device *dev = it6505->dev;
3041 if (!it6505->cached_edid) {
3042 it6505->cached_edid = drm_do_get_edid(connector, it6505_get_edid_block,
3043 it6505);
3045 if (!it6505->cached_edid) {
3051 return drm_edid_duplicate(it6505->cached_edid);
3071 struct it6505 *it6505 = dev_get_drvdata(dev);
3073 return it6505_poweron(it6505);
3078 struct it6505 *it6505 = dev_get_drvdata(dev);
3080 return it6505_poweroff(it6505);
3088 static int it6505_init_pdata(struct it6505 *it6505)
3090 struct it6505_platform_data *pdata = &it6505->pdata;
3091 struct device *dev = it6505->dev;
3131 static void it6505_parse_dt(struct it6505 *it6505)
3133 struct device *dev = it6505->dev;
3138 u32 *afe_setting = &it6505->afe_setting;
3139 u32 *max_lane_count = &it6505->max_lane_count;
3140 u32 *max_dpi_pixel_clock = &it6505->max_dpi_pixel_clock;
3142 it6505->lane_swap_disabled =
3145 if (it6505->lane_swap_disabled)
3146 it6505->lane_swap = false;
3203 it6505->afe_setting, it6505->max_lane_count);
3205 it6505->max_dpi_pixel_clock);
3211 struct it6505 *it6505 = file->private_data;
3217 if (!it6505)
3220 it6505_calc_video_info(it6505);
3221 vid = &it6505->video_info;
3250 struct it6505 *it6505 = data;
3252 if (!it6505)
3256 it6505_poweron(it6505);
3258 it6505_poweroff(it6505);
3265 struct it6505 *it6505 = data;
3267 if (!it6505)
3270 *buf = it6505->enable_drv_hold;
3277 struct it6505 *it6505 = data;
3279 if (!it6505)
3282 it6505->enable_drv_hold = drv_hold;
3284 if (it6505->enable_drv_hold) {
3285 it6505_int_mask_disable(it6505);
3287 it6505_clear_int(it6505);
3288 it6505_int_mask_enable(it6505);
3290 if (it6505->powered) {
3291 it6505->connector_status =
3292 it6505_get_sink_hpd_status(it6505) ?
3296 it6505->connector_status =
3324 static void debugfs_create_files(struct it6505 *it6505)
3330 it6505->debugfs, it6505,
3336 static void debugfs_init(struct it6505 *it6505)
3338 struct device *dev = it6505->dev;
3340 it6505->debugfs = debugfs_create_dir(DEBUGFS_DIR_NAME, NULL);
3342 if (IS_ERR(it6505->debugfs)) {
3347 debugfs_create_files(it6505);
3350 static void it6505_debugfs_remove(struct it6505 *it6505)
3352 debugfs_remove_recursive(it6505->debugfs);
3357 struct it6505 *it6505 = dev_get_drvdata(&client->dev);
3359 if (it6505->powered)
3360 it6505_lane_off(it6505);
3365 struct it6505 *it6505;
3370 it6505 = devm_kzalloc(&client->dev, sizeof(*it6505), GFP_KERNEL);
3371 if (!it6505)
3374 mutex_init(&it6505->extcon_lock);
3375 mutex_init(&it6505->mode_lock);
3376 mutex_init(&it6505->aux_lock);
3378 it6505->bridge.of_node = client->dev.of_node;
3379 it6505->connector_status = connector_status_disconnected;
3380 it6505->dev = &client->dev;
3381 i2c_set_clientdata(client, it6505);
3392 it6505->extcon = extcon;
3394 it6505->regmap = devm_regmap_init_i2c(client, &it6505_regmap_config);
3395 if (IS_ERR(it6505->regmap)) {
3397 err = PTR_ERR(it6505->regmap);
3401 err = it6505_init_pdata(it6505);
3407 it6505_parse_dt(it6505);
3420 "it6505-intp", it6505);
3426 INIT_WORK(&it6505->link_works, it6505_link_training_work);
3427 INIT_WORK(&it6505->hdcp_wait_ksv_list, it6505_hdcp_wait_ksv_list);
3428 INIT_DELAYED_WORK(&it6505->hdcp_work, it6505_hdcp_work);
3429 init_completion(&it6505->extcon_completion);
3430 memset(it6505->dpcd, 0, sizeof(it6505->dpcd));
3431 it6505->powered = false;
3432 it6505->enable_drv_hold = DEFAULT_DRV_HOLD;
3435 it6505_poweron(it6505);
3437 DRM_DEV_DEBUG_DRIVER(dev, "it6505 device name: %s", dev_name(dev));
3438 debugfs_init(it6505);
3441 it6505->aux.name = "DP-AUX";
3442 it6505->aux.dev = dev;
3443 it6505->aux.transfer = it6505_aux_transfer;
3444 drm_dp_aux_init(&it6505->aux);
3446 it6505->bridge.funcs = &it6505_bridge_funcs;
3447 it6505->bridge.type = DRM_MODE_CONNECTOR_DisplayPort;
3448 it6505->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
3450 drm_bridge_add(&it6505->bridge);
3457 struct it6505 *it6505 = i2c_get_clientdata(client);
3459 drm_bridge_remove(&it6505->bridge);
3460 drm_dp_aux_unregister(&it6505->aux);
3461 it6505_debugfs_remove(it6505);
3462 it6505_poweroff(it6505);
3463 it6505_remove_edid(it6505);
3467 { "it6505", 0 },
3474 { .compatible = "ite,it6505" },
3480 .name = "it6505",