return adv7511_edid_read(adv, connector);
}
-static int adv7511_bridge_hdmi_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int adv7511_bridge_hdmi_clear_audio_infoframe(struct drm_bridge *bridge)
{
struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_AUDIO_INFOFRAME);
- break;
- case HDMI_INFOFRAME_TYPE_AVI:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
- break;
- case HDMI_INFOFRAME_TYPE_SPD:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPD);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
- break;
- default:
- drm_dbg_driver(adv7511->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type);
- break;
- }
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_AUDIO_INFOFRAME);
return 0;
}
-static int adv7511_bridge_hdmi_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int adv7511_bridge_hdmi_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- /* send current Audio infoframe values while updating */
- regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
- BIT(5), BIT(5));
-
- /* The Audio infoframe id is not configurable */
- regmap_bulk_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME_VERSION,
- buffer + 1, len - 1);
-
- /* use Audio infoframe updated info */
- regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
- BIT(5), 0);
-
- adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_AUDIO_INFOFRAME);
- break;
- case HDMI_INFOFRAME_TYPE_AVI:
- /* send current AVI infoframe values while updating */
- regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
- BIT(6), BIT(6));
-
- /* The AVI infoframe id is not configurable */
- regmap_bulk_write(adv7511->regmap, ADV7511_REG_AVI_INFOFRAME_VERSION,
- buffer + 1, len - 1);
-
- regmap_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME_LENGTH, 0x2);
- regmap_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME(1), 0x1);
-
- /* use AVI infoframe updated info */
- regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
- BIT(6), 0);
-
- adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
- break;
- case HDMI_INFOFRAME_TYPE_SPD:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPD);
- regmap_bulk_write(adv7511->regmap_packet, ADV7511_PACKET_SPD(0),
- buffer, len);
- adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_SPD);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
- regmap_bulk_write(adv7511->regmap_packet, ADV7511_PACKET_SPARE1(0),
- buffer, len);
- adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
- break;
- default:
- drm_dbg_driver(adv7511->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type);
- break;
- }
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_clear_spd_infoframe(struct drm_bridge *bridge)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPD);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_write_audio_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ /* send current Audio infoframe values while updating */
+ regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
+ BIT(5), BIT(5));
+
+ /* The Audio infoframe id is not configurable */
+ regmap_bulk_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME_VERSION,
+ buffer + 1, len - 1);
+
+ /* use Audio infoframe updated info */
+ regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
+ BIT(5), 0);
+
+ adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_AUDIO_INFOFRAME);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ /* send current AVI infoframe values while updating */
+ regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
+ BIT(6), BIT(6));
+
+ /* The AVI infoframe id is not configurable */
+ regmap_bulk_write(adv7511->regmap, ADV7511_REG_AVI_INFOFRAME_VERSION,
+ buffer + 1, len - 1);
+
+ regmap_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME_LENGTH, 0x2);
+ regmap_write(adv7511->regmap, ADV7511_REG_AUDIO_INFOFRAME(1), 0x1);
+
+ /* use AVI infoframe updated info */
+ regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE,
+ BIT(6), 0);
+
+ adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_AVI_INFOFRAME);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_write_spd_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPD);
+ regmap_bulk_write(adv7511->regmap_packet, ADV7511_PACKET_SPD(0),
+ buffer, len);
+ adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_SPD);
+
+ return 0;
+}
+
+static int adv7511_bridge_hdmi_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct adv7511 *adv7511 = bridge_to_adv7511(bridge);
+
+ adv7511_packet_disable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
+ regmap_bulk_write(adv7511->regmap_packet, ADV7511_PACKET_SPARE1(0),
+ buffer, len);
+ adv7511_packet_enable(adv7511, ADV7511_PACKET_ENABLE_SPARE1);
return 0;
}
.atomic_reset = drm_atomic_helper_bridge_reset,
.hdmi_tmds_char_rate_valid = adv7511_bridge_hdmi_tmds_char_rate_valid,
- .hdmi_clear_infoframe = adv7511_bridge_hdmi_clear_infoframe,
- .hdmi_write_infoframe = adv7511_bridge_hdmi_write_infoframe,
+ .hdmi_clear_audio_infoframe = adv7511_bridge_hdmi_clear_audio_infoframe,
+ .hdmi_write_audio_infoframe = adv7511_bridge_hdmi_write_audio_infoframe,
+ .hdmi_clear_avi_infoframe = adv7511_bridge_hdmi_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = adv7511_bridge_hdmi_write_avi_infoframe,
+ .hdmi_clear_spd_infoframe = adv7511_bridge_hdmi_clear_spd_infoframe,
+ .hdmi_write_spd_infoframe = adv7511_bridge_hdmi_write_spd_infoframe,
+ .hdmi_clear_hdmi_infoframe = adv7511_bridge_hdmi_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = adv7511_bridge_hdmi_write_hdmi_infoframe,
.hdmi_audio_startup = adv7511_hdmi_audio_startup,
.hdmi_audio_prepare = adv7511_hdmi_audio_prepare,
adv7511->bridge.ops = DRM_BRIDGE_OP_DETECT |
DRM_BRIDGE_OP_EDID |
- DRM_BRIDGE_OP_HDMI;
+ DRM_BRIDGE_OP_HDMI |
+ DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME;
if (adv7511->i2c_main->irq)
adv7511->bridge.ops |= DRM_BRIDGE_OP_HPD;
hdmi_modb(hdmi, HDMI_STATUS, m_MASK_INT_HOTPLUG, v_MASK_INT_HOTPLUG(1));
}
-static int inno_hdmi_bridge_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int inno_hdmi_bridge_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct inno_hdmi *hdmi = bridge_to_inno_hdmi(bridge);
- if (type != HDMI_INFOFRAME_TYPE_AVI) {
- drm_err(bridge->dev, "Unsupported infoframe type: %u\n", type);
- return 0;
- }
-
hdmi_writeb(hdmi, HDMI_CONTROL_PACKET_BUF_INDEX, INFOFRAME_AVI);
return 0;
}
-static int inno_hdmi_bridge_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int inno_hdmi_bridge_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
struct inno_hdmi *hdmi = bridge_to_inno_hdmi(bridge);
ssize_t i;
- if (type != HDMI_INFOFRAME_TYPE_AVI) {
- drm_err(bridge->dev, "Unsupported infoframe type: %u\n", type);
- return 0;
- }
-
- inno_hdmi_bridge_clear_infoframe(bridge, type);
+ inno_hdmi_bridge_clear_avi_infoframe(bridge);
for (i = 0; i < len; i++)
hdmi_writeb(hdmi, HDMI_CONTROL_PACKET_ADDR + i, buffer[i]);
return 0;
}
+static int inno_hdmi_bridge_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ drm_warn_once(bridge->encoder->dev, "HDMI VSI not implemented\n");
+
+ return 0;
+}
+
+static int inno_hdmi_bridge_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ drm_warn_once(bridge->encoder->dev, "HDMI VSI not implemented\n");
+
+ return 0;
+}
+
static int inno_hdmi_config_video_csc(struct inno_hdmi *hdmi,
struct drm_connector *connector,
struct drm_display_mode *mode)
.atomic_disable = inno_hdmi_bridge_atomic_disable,
.detect = inno_hdmi_bridge_detect,
.edid_read = inno_hdmi_bridge_edid_read,
- .hdmi_clear_infoframe = inno_hdmi_bridge_clear_infoframe,
- .hdmi_write_infoframe = inno_hdmi_bridge_write_infoframe,
+ .hdmi_clear_avi_infoframe = inno_hdmi_bridge_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = inno_hdmi_bridge_write_avi_infoframe,
+ .hdmi_clear_hdmi_infoframe = inno_hdmi_bridge_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = inno_hdmi_bridge_write_hdmi_infoframe,
.mode_valid = inno_hdmi_bridge_mode_valid,
};
return MODE_OK;
}
-static int it6263_hdmi_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int it6263_hdmi_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct it6263 *it = bridge_to_it6263(bridge);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- regmap_write(it->hdmi_regmap, HDMI_REG_AVI_INFOFRM_CTRL, 0);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- regmap_write(it->hdmi_regmap, HDMI_REG_PKT_NULL_CTRL, 0);
- break;
- default:
- dev_dbg(it->dev, "unsupported HDMI infoframe 0x%x\n", type);
- }
+ regmap_write(it->hdmi_regmap, HDMI_REG_AVI_INFOFRM_CTRL, 0);
+
+ return 0;
+}
+
+static int it6263_hdmi_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ struct it6263 *it = bridge_to_it6263(bridge);
+
+ regmap_write(it->hdmi_regmap, HDMI_REG_PKT_NULL_CTRL, 0);
return 0;
}
-static int it6263_hdmi_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int it6263_hdmi_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
struct it6263 *it = bridge_to_it6263(bridge);
struct regmap *regmap = it->hdmi_regmap;
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- /* write the first AVI infoframe data byte chunk(DB1-DB5) */
- regmap_bulk_write(regmap, HDMI_REG_AVI_DB1,
- &buffer[HDMI_INFOFRAME_HEADER_SIZE],
- HDMI_AVI_DB_CHUNK1_SIZE);
-
- /* write the second AVI infoframe data byte chunk(DB6-DB13) */
- regmap_bulk_write(regmap, HDMI_REG_AVI_DB6,
- &buffer[HDMI_INFOFRAME_HEADER_SIZE +
- HDMI_AVI_DB_CHUNK1_SIZE],
- HDMI_AVI_DB_CHUNK2_SIZE);
-
- /* write checksum */
- regmap_write(regmap, HDMI_REG_AVI_CSUM, buffer[3]);
-
- regmap_write(regmap, HDMI_REG_AVI_INFOFRM_CTRL,
- ENABLE_PKT | REPEAT_PKT);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- /* write header and payload */
- regmap_bulk_write(regmap, HDMI_REG_PKT_HB(0), buffer, len);
-
- regmap_write(regmap, HDMI_REG_PKT_NULL_CTRL,
- ENABLE_PKT | REPEAT_PKT);
- break;
- default:
- dev_dbg(it->dev, "unsupported HDMI infoframe 0x%x\n", type);
- }
+ /* write the first AVI infoframe data byte chunk(DB1-DB5) */
+ regmap_bulk_write(regmap, HDMI_REG_AVI_DB1,
+ &buffer[HDMI_INFOFRAME_HEADER_SIZE],
+ HDMI_AVI_DB_CHUNK1_SIZE);
+
+ /* write the second AVI infoframe data byte chunk(DB6-DB13) */
+ regmap_bulk_write(regmap, HDMI_REG_AVI_DB6,
+ &buffer[HDMI_INFOFRAME_HEADER_SIZE +
+ HDMI_AVI_DB_CHUNK1_SIZE],
+ HDMI_AVI_DB_CHUNK2_SIZE);
+
+ /* write checksum */
+ regmap_write(regmap, HDMI_REG_AVI_CSUM, buffer[3]);
+
+ regmap_write(regmap, HDMI_REG_AVI_INFOFRM_CTRL,
+ ENABLE_PKT | REPEAT_PKT);
+
+ return 0;
+}
+
+static int it6263_hdmi_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct it6263 *it = bridge_to_it6263(bridge);
+ struct regmap *regmap = it->hdmi_regmap;
+
+ /* write header and payload */
+ regmap_bulk_write(regmap, HDMI_REG_PKT_HB(0), buffer, len);
+
+ regmap_write(regmap, HDMI_REG_PKT_NULL_CTRL,
+ ENABLE_PKT | REPEAT_PKT);
+
return 0;
}
.edid_read = it6263_bridge_edid_read,
.atomic_get_input_bus_fmts = it6263_bridge_atomic_get_input_bus_fmts,
.hdmi_tmds_char_rate_valid = it6263_hdmi_tmds_char_rate_valid,
- .hdmi_clear_infoframe = it6263_hdmi_clear_infoframe,
- .hdmi_write_infoframe = it6263_hdmi_write_infoframe,
+ .hdmi_clear_avi_infoframe = it6263_hdmi_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = it6263_hdmi_write_avi_infoframe,
+ .hdmi_clear_hdmi_infoframe = it6263_hdmi_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = it6263_hdmi_write_hdmi_infoframe,
};
static int it6263_probe(struct i2c_client *client)
#define LT9611_INFOFRAME_AUDIO 0x02
#define LT9611_INFOFRAME_AVI 0x08
#define LT9611_INFOFRAME_SPD 0x10
-#define LT9611_INFOFRAME_VENDOR 0x20
+#define LT9611_INFOFRAME_HDMI 0x20
-static int lt9611_hdmi_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int lt9611_hdmi_clear_audio_infoframe(struct drm_bridge *bridge)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
- unsigned int mask;
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- mask = LT9611_INFOFRAME_AUDIO;
- break;
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_AUDIO, 0);
- case HDMI_INFOFRAME_TYPE_AVI:
- mask = LT9611_INFOFRAME_AVI;
- break;
+ return 0;
+}
- case HDMI_INFOFRAME_TYPE_SPD:
- mask = LT9611_INFOFRAME_SPD;
- break;
+static int lt9611_hdmi_clear_avi_infoframe(struct drm_bridge *bridge)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
- case HDMI_INFOFRAME_TYPE_VENDOR:
- mask = LT9611_INFOFRAME_VENDOR;
- break;
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_AVI, 0);
- default:
- drm_dbg_driver(lt9611->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type);
- mask = 0;
- break;
- }
+ return 0;
+}
+
+static int lt9611_hdmi_clear_spd_infoframe(struct drm_bridge *bridge)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
- if (mask)
- regmap_update_bits(lt9611->regmap, 0x843d, mask, 0);
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_SPD, 0);
return 0;
}
-static int lt9611_hdmi_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int lt9611_hdmi_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
+
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_HDMI, 0);
+
+ return 0;
+}
+
+static int lt9611_hdmi_write_audio_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
- unsigned int mask, addr;
int i;
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- mask = LT9611_INFOFRAME_AUDIO;
- addr = 0x84b2;
- break;
-
- case HDMI_INFOFRAME_TYPE_AVI:
- mask = LT9611_INFOFRAME_AVI;
- addr = 0x8440;
- break;
-
- case HDMI_INFOFRAME_TYPE_SPD:
- mask = LT9611_INFOFRAME_SPD;
- addr = 0x8493;
- break;
-
- case HDMI_INFOFRAME_TYPE_VENDOR:
- mask = LT9611_INFOFRAME_VENDOR;
- addr = 0x8474;
- break;
-
- default:
- drm_dbg_driver(lt9611->bridge.dev, "Unsupported HDMI InfoFrame %x\n", type);
- mask = 0;
- break;
- }
+ for (i = 0; i < len; i++)
+ regmap_write(lt9611->regmap, 0x84b2 + i, buffer[i]);
- if (mask) {
- for (i = 0; i < len; i++)
- regmap_write(lt9611->regmap, addr + i, buffer[i]);
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_AUDIO, LT9611_INFOFRAME_AUDIO);
- regmap_update_bits(lt9611->regmap, 0x843d, mask, mask);
- }
+ return 0;
+}
+
+static int lt9611_hdmi_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
+ int i;
+
+ for (i = 0; i < len; i++)
+ regmap_write(lt9611->regmap, 0x8440 + i, buffer[i]);
+
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_AVI, LT9611_INFOFRAME_AVI);
+
+ return 0;
+}
+
+static int lt9611_hdmi_write_spd_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
+ int i;
+
+ for (i = 0; i < len; i++)
+ regmap_write(lt9611->regmap, 0x8493 + i, buffer[i]);
+
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_SPD, LT9611_INFOFRAME_SPD);
+
+ return 0;
+}
+
+static int lt9611_hdmi_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
+ int i;
+
+ for (i = 0; i < len; i++)
+ regmap_write(lt9611->regmap, 0x8474 + i, buffer[i]);
+
+ regmap_update_bits(lt9611->regmap, 0x843d, LT9611_INFOFRAME_HDMI, LT9611_INFOFRAME_HDMI);
return 0;
}
.atomic_get_input_bus_fmts = lt9611_atomic_get_input_bus_fmts,
.hdmi_tmds_char_rate_valid = lt9611_hdmi_tmds_char_rate_valid,
- .hdmi_write_infoframe = lt9611_hdmi_write_infoframe,
- .hdmi_clear_infoframe = lt9611_hdmi_clear_infoframe,
+ .hdmi_write_audio_infoframe = lt9611_hdmi_write_audio_infoframe,
+ .hdmi_clear_audio_infoframe = lt9611_hdmi_clear_audio_infoframe,
+ .hdmi_write_avi_infoframe = lt9611_hdmi_write_avi_infoframe,
+ .hdmi_clear_avi_infoframe = lt9611_hdmi_clear_avi_infoframe,
+ .hdmi_write_spd_infoframe = lt9611_hdmi_write_spd_infoframe,
+ .hdmi_clear_spd_infoframe = lt9611_hdmi_clear_spd_infoframe,
+ .hdmi_write_hdmi_infoframe = lt9611_hdmi_write_hdmi_infoframe,
+ .hdmi_clear_hdmi_infoframe = lt9611_hdmi_clear_hdmi_infoframe,
.hdmi_audio_startup = lt9611_hdmi_audio_startup,
.hdmi_audio_prepare = lt9611_hdmi_audio_prepare,
lt9611->bridge.of_node = client->dev.of_node;
lt9611->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID |
DRM_BRIDGE_OP_HPD | DRM_BRIDGE_OP_MODES |
- DRM_BRIDGE_OP_HDMI | DRM_BRIDGE_OP_HDMI_AUDIO;
+ DRM_BRIDGE_OP_HDMI | DRM_BRIDGE_OP_HDMI_AUDIO |
+ DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME;
lt9611->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
lt9611->bridge.vendor = "Lontium";
lt9611->bridge.product = "LT9611";
#include <drm/drm_connector.h>
#include <drm/drm_edid.h>
#include <drm/drm_modes.h>
+#include <drm/drm_print.h>
#include <media/cec.h>
return MODE_OK;
}
-static int dw_hdmi_qp_bridge_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int dw_hdmi_qp_bridge_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct dw_hdmi_qp *hdmi = bridge->driver_private;
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- dw_hdmi_qp_mod(hdmi, 0, PKTSCHED_AVI_TX_EN | PKTSCHED_GCP_TX_EN,
- PKTSCHED_PKT_EN);
- break;
+ dw_hdmi_qp_mod(hdmi, 0, PKTSCHED_AVI_TX_EN | PKTSCHED_GCP_TX_EN,
+ PKTSCHED_PKT_EN);
- case HDMI_INFOFRAME_TYPE_DRM:
- dw_hdmi_qp_mod(hdmi, 0, PKTSCHED_DRMI_TX_EN, PKTSCHED_PKT_EN);
- break;
+ return 0;
+}
- case HDMI_INFOFRAME_TYPE_AUDIO:
- dw_hdmi_qp_mod(hdmi, 0,
- PKTSCHED_ACR_TX_EN |
- PKTSCHED_AUDS_TX_EN |
- PKTSCHED_AUDI_TX_EN,
- PKTSCHED_PKT_EN);
- break;
- default:
- dev_dbg(hdmi->dev, "Unsupported infoframe type %x\n", type);
- }
+static int dw_hdmi_qp_bridge_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ /* FIXME: add support for this InfoFrame */
+
+ drm_warn_once(bridge->encoder->dev, "HDMI VSI not supported\n");
return 0;
}
-static int dw_hdmi_qp_bridge_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int dw_hdmi_qp_bridge_clear_hdr_drm_infoframe(struct drm_bridge *bridge)
{
struct dw_hdmi_qp *hdmi = bridge->driver_private;
- dw_hdmi_qp_bridge_clear_infoframe(bridge, type);
+ dw_hdmi_qp_mod(hdmi, 0, PKTSCHED_DRMI_TX_EN, PKTSCHED_PKT_EN);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- return dw_hdmi_qp_config_avi_infoframe(hdmi, buffer, len);
+ return 0;
+}
- case HDMI_INFOFRAME_TYPE_DRM:
- return dw_hdmi_qp_config_drm_infoframe(hdmi, buffer, len);
+static int dw_hdmi_qp_bridge_clear_audio_infoframe(struct drm_bridge *bridge)
+{
+ struct dw_hdmi_qp *hdmi = bridge->driver_private;
- case HDMI_INFOFRAME_TYPE_AUDIO:
- return dw_hdmi_qp_config_audio_infoframe(hdmi, buffer, len);
+ dw_hdmi_qp_mod(hdmi, 0,
+ PKTSCHED_ACR_TX_EN |
+ PKTSCHED_AUDS_TX_EN |
+ PKTSCHED_AUDI_TX_EN,
+ PKTSCHED_PKT_EN);
- default:
- dev_dbg(hdmi->dev, "Unsupported infoframe type %x\n", type);
- return 0;
- }
+ return 0;
+}
+
+static int dw_hdmi_qp_bridge_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct dw_hdmi_qp *hdmi = bridge->driver_private;
+
+ dw_hdmi_qp_bridge_clear_avi_infoframe(bridge);
+
+ return dw_hdmi_qp_config_avi_infoframe(hdmi, buffer, len);
+}
+
+static int dw_hdmi_qp_bridge_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ dw_hdmi_qp_bridge_clear_hdmi_infoframe(bridge);
+
+ /* FIXME: add support for the HDMI VSI */
+
+ return 0;
+}
+
+static int dw_hdmi_qp_bridge_write_hdr_drm_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct dw_hdmi_qp *hdmi = bridge->driver_private;
+
+ dw_hdmi_qp_bridge_clear_hdr_drm_infoframe(bridge);
+
+ return dw_hdmi_qp_config_drm_infoframe(hdmi, buffer, len);
+}
+
+static int dw_hdmi_qp_bridge_write_audio_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct dw_hdmi_qp *hdmi = bridge->driver_private;
+
+ dw_hdmi_qp_bridge_clear_audio_infoframe(bridge);
+
+ return dw_hdmi_qp_config_audio_infoframe(hdmi, buffer, len);
}
#ifdef CONFIG_DRM_DW_HDMI_QP_CEC
.detect = dw_hdmi_qp_bridge_detect,
.edid_read = dw_hdmi_qp_bridge_edid_read,
.hdmi_tmds_char_rate_valid = dw_hdmi_qp_bridge_tmds_char_rate_valid,
- .hdmi_clear_infoframe = dw_hdmi_qp_bridge_clear_infoframe,
- .hdmi_write_infoframe = dw_hdmi_qp_bridge_write_infoframe,
+ .hdmi_clear_avi_infoframe = dw_hdmi_qp_bridge_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = dw_hdmi_qp_bridge_write_avi_infoframe,
+ .hdmi_clear_hdmi_infoframe = dw_hdmi_qp_bridge_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = dw_hdmi_qp_bridge_write_hdmi_infoframe,
+ .hdmi_clear_hdr_drm_infoframe = dw_hdmi_qp_bridge_clear_hdr_drm_infoframe,
+ .hdmi_write_hdr_drm_infoframe = dw_hdmi_qp_bridge_write_hdr_drm_infoframe,
+ .hdmi_clear_audio_infoframe = dw_hdmi_qp_bridge_clear_audio_infoframe,
+ .hdmi_write_audio_infoframe = dw_hdmi_qp_bridge_write_audio_infoframe,
.hdmi_audio_startup = dw_hdmi_qp_audio_enable,
.hdmi_audio_shutdown = dw_hdmi_qp_audio_disable,
.hdmi_audio_prepare = dw_hdmi_qp_audio_prepare,
hdmi->bridge.ops = DRM_BRIDGE_OP_DETECT |
DRM_BRIDGE_OP_EDID |
DRM_BRIDGE_OP_HDMI |
- DRM_BRIDGE_OP_HDMI_AUDIO;
+ DRM_BRIDGE_OP_HDMI_AUDIO |
+ DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME;
if (!hdmi->no_hpd)
hdmi->bridge.ops |= DRM_BRIDGE_OP_HPD;
hdmi->bridge.of_node = pdev->dev.of_node;
if (!bridge)
return -EINVAL;
- return bridge->funcs->hdmi_clear_infoframe(bridge, type);
+ switch (type) {
+ case HDMI_INFOFRAME_TYPE_AVI:
+ /* required */
+ return bridge->funcs->hdmi_clear_avi_infoframe(bridge);
+ case HDMI_INFOFRAME_TYPE_VENDOR:
+ /* required */
+ return bridge->funcs->hdmi_clear_hdmi_infoframe(bridge);
+ case HDMI_INFOFRAME_TYPE_AUDIO:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO)
+ return bridge->funcs->hdmi_clear_audio_infoframe(bridge);
+ break;
+ case HDMI_INFOFRAME_TYPE_DRM:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME)
+ return bridge->funcs->hdmi_clear_hdr_drm_infoframe(bridge);
+ break;
+ case HDMI_INFOFRAME_TYPE_SPD:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME)
+ return bridge->funcs->hdmi_clear_spd_infoframe(bridge);
+ break;
+ }
+
+ drm_dbg_driver(connector->dev, "Unsupported HDMI InfoFrame %x\n", type);
+
+ return 0;
}
static int drm_bridge_connector_write_infoframe(struct drm_connector *connector,
if (!bridge)
return -EINVAL;
- return bridge->funcs->hdmi_write_infoframe(bridge, type, buffer, len);
+ switch (type) {
+ case HDMI_INFOFRAME_TYPE_AVI:
+ /* required */
+ return bridge->funcs->hdmi_write_avi_infoframe(bridge, buffer, len);
+ case HDMI_INFOFRAME_TYPE_VENDOR:
+ /* required */
+ return bridge->funcs->hdmi_write_hdmi_infoframe(bridge, buffer, len);
+ case HDMI_INFOFRAME_TYPE_AUDIO:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO)
+ return bridge->funcs->hdmi_write_audio_infoframe(bridge, buffer, len);
+ break;
+ case HDMI_INFOFRAME_TYPE_DRM:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME)
+ return bridge->funcs->hdmi_write_hdr_drm_infoframe(bridge, buffer, len);
+ break;
+ case HDMI_INFOFRAME_TYPE_SPD:
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME)
+ return bridge->funcs->hdmi_write_spd_infoframe(bridge, buffer, len);
+ break;
+ }
+
+ drm_dbg_driver(connector->dev, "Unsupported HDMI InfoFrame %x\n", type);
+
+ return 0;
}
static const struct drm_edid *
if (bridge->ops & DRM_BRIDGE_OP_HDMI) {
if (bridge_connector->bridge_hdmi)
return ERR_PTR(-EBUSY);
- if (!bridge->funcs->hdmi_write_infoframe ||
- !bridge->funcs->hdmi_clear_infoframe)
+ if (!bridge->funcs->hdmi_write_avi_infoframe ||
+ !bridge->funcs->hdmi_clear_avi_infoframe ||
+ !bridge->funcs->hdmi_write_hdmi_infoframe ||
+ !bridge->funcs->hdmi_clear_hdmi_infoframe)
+ return ERR_PTR(-EINVAL);
+
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME &&
+ (!bridge->funcs->hdmi_write_hdr_drm_infoframe ||
+ !bridge->funcs->hdmi_clear_hdr_drm_infoframe))
+ return ERR_PTR(-EINVAL);
+
+ if (bridge->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME &&
+ (!bridge->funcs->hdmi_write_spd_infoframe ||
+ !bridge->funcs->hdmi_clear_spd_infoframe))
return ERR_PTR(-EINVAL);
bridge_connector->bridge_hdmi = drm_bridge_get(bridge);
!bridge->hdmi_audio_spdif_playback)
return ERR_PTR(-EINVAL);
- if (!bridge->funcs->hdmi_audio_prepare ||
+ if (!bridge->funcs->hdmi_write_audio_infoframe ||
+ !bridge->funcs->hdmi_clear_audio_infoframe ||
+ !bridge->funcs->hdmi_audio_prepare ||
!bridge->funcs->hdmi_audio_shutdown)
return ERR_PTR(-EINVAL);
hdmi->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID
| DRM_BRIDGE_OP_HPD;
- if (ver_conf->bridge_funcs->hdmi_write_infoframe &&
- ver_conf->bridge_funcs->hdmi_clear_infoframe)
- hdmi->bridge.ops |= DRM_BRIDGE_OP_HDMI;
+ /* Only v2 support OP_HDMI now and it we know that it also support SPD */
+ if (ver_conf->bridge_funcs->hdmi_write_avi_infoframe &&
+ ver_conf->bridge_funcs->hdmi_clear_avi_infoframe)
+ hdmi->bridge.ops |= DRM_BRIDGE_OP_HDMI |
+ DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME;
hdmi->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
hdmi->bridge.ddc = hdmi->ddc_adpt;
return val;
}
-static void mtk_hdmi_v2_hw_write_audio_infoframe(struct mtk_hdmi *hdmi, const u8 *buffer)
+static int mtk_hdmi_v2_hdmi_write_audio_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AUD_EN | AUD_EN_WR);
regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AUD_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_RPT, AUD_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_EN, AUD_EN | AUD_EN_WR);
+
+ return 0;
}
-static void mtk_hdmi_v2_hw_write_avi_infoframe(struct mtk_hdmi *hdmi, const u8 *buffer)
+static int mtk_hdmi_v2_hdmi_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AVI_EN_WR | AVI_EN);
regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AVI_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_RPT, AVI_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_EN, AVI_EN_WR | AVI_EN);
+
+ return 0;
}
-static void mtk_hdmi_v2_hw_write_spd_infoframe(struct mtk_hdmi *hdmi, const u8 *buffer)
+static int mtk_hdmi_v2_hdmi_write_spd_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
regmap_clear_bits(hdmi->regs, TOP_INFO_EN, SPD_EN_WR | SPD_EN);
regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, SPD_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_EN, SPD_EN_WR | SPD_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_RPT, SPD_RPT_EN);
+
+ return 0;
}
-static void mtk_hdmi_v2_hw_write_vendor_infoframe(struct mtk_hdmi *hdmi, const u8 *buffer)
+static int mtk_hdmi_v2_hdmi_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
regmap_clear_bits(hdmi->regs, TOP_INFO_EN, VSIF_EN_WR | VSIF_EN);
regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, VSIF_RPT_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_EN, VSIF_EN_WR | VSIF_EN);
regmap_set_bits(hdmi->regs, TOP_INFO_RPT, VSIF_RPT_EN);
+
+ return 0;
}
static void mtk_hdmi_yuv420_downsampling(struct mtk_hdmi *hdmi, bool enable)
if (ret < 0)
return ret;
- mtk_hdmi_v2_hw_write_audio_infoframe(hdmi, buffer);
+ mtk_hdmi_v2_hdmi_write_audio_infoframe(&hdmi->bridge, buffer, sizeof(buffer));
return 0;
}
return MODE_OK;
}
-static int mtk_hdmi_v2_hdmi_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int mtk_hdmi_v2_hdmi_clear_audio_infoframe(struct drm_bridge *bridge)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AUD_EN_WR | AUD_EN);
- regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AUD_RPT_EN);
- break;
- case HDMI_INFOFRAME_TYPE_AVI:
- regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AVI_EN_WR | AVI_EN);
- regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AVI_RPT_EN);
- break;
- case HDMI_INFOFRAME_TYPE_SPD:
- regmap_clear_bits(hdmi->regs, TOP_INFO_EN, SPD_EN_WR | SPD_EN);
- regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, SPD_RPT_EN);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- regmap_clear_bits(hdmi->regs, TOP_INFO_EN, VSIF_EN_WR | VSIF_EN);
- regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, VSIF_RPT_EN);
- break;
- case HDMI_INFOFRAME_TYPE_DRM:
- default:
- break;
- };
+ regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AUD_EN_WR | AUD_EN);
+ regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AUD_RPT_EN);
return 0;
}
-static int mtk_hdmi_v2_hdmi_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+static int mtk_hdmi_v2_hdmi_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AUDIO:
- mtk_hdmi_v2_hw_write_audio_infoframe(hdmi, buffer);
- break;
- case HDMI_INFOFRAME_TYPE_AVI:
- mtk_hdmi_v2_hw_write_avi_infoframe(hdmi, buffer);
- break;
- case HDMI_INFOFRAME_TYPE_SPD:
- mtk_hdmi_v2_hw_write_spd_infoframe(hdmi, buffer);
- break;
- case HDMI_INFOFRAME_TYPE_VENDOR:
- mtk_hdmi_v2_hw_write_vendor_infoframe(hdmi, buffer);
- break;
- case HDMI_INFOFRAME_TYPE_DRM:
- default:
- dev_err(hdmi->dev, "Unsupported HDMI infoframe type %u\n", type);
- break;
- };
+ regmap_clear_bits(hdmi->regs, TOP_INFO_EN, AVI_EN_WR | AVI_EN);
+ regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, AVI_RPT_EN);
+
+ return 0;
+}
+
+static int mtk_hdmi_v2_hdmi_clear_spd_infoframe(struct drm_bridge *bridge)
+{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
+ regmap_clear_bits(hdmi->regs, TOP_INFO_EN, SPD_EN_WR | SPD_EN);
+ regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, SPD_RPT_EN);
+
+ return 0;
+}
+
+static int mtk_hdmi_v2_hdmi_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
+
+ regmap_clear_bits(hdmi->regs, TOP_INFO_EN, VSIF_EN_WR | VSIF_EN);
+ regmap_clear_bits(hdmi->regs, TOP_INFO_RPT, VSIF_RPT_EN);
return 0;
}
.hpd_enable = mtk_hdmi_v2_hpd_enable,
.hpd_disable = mtk_hdmi_v2_hpd_disable,
.hdmi_tmds_char_rate_valid = mtk_hdmi_v2_hdmi_tmds_char_rate_valid,
- .hdmi_clear_infoframe = mtk_hdmi_v2_hdmi_clear_infoframe,
- .hdmi_write_infoframe = mtk_hdmi_v2_hdmi_write_infoframe,
+ .hdmi_clear_audio_infoframe = mtk_hdmi_v2_hdmi_clear_audio_infoframe,
+ .hdmi_write_audio_infoframe = mtk_hdmi_v2_hdmi_write_audio_infoframe,
+ .hdmi_clear_avi_infoframe = mtk_hdmi_v2_hdmi_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = mtk_hdmi_v2_hdmi_write_avi_infoframe,
+ .hdmi_clear_spd_infoframe = mtk_hdmi_v2_hdmi_clear_spd_infoframe,
+ .hdmi_write_spd_infoframe = mtk_hdmi_v2_hdmi_write_spd_infoframe,
+ .hdmi_clear_hdmi_infoframe = mtk_hdmi_v2_hdmi_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = mtk_hdmi_v2_hdmi_write_hdmi_infoframe,
.debugfs_init = mtk_hdmi_v2_debugfs_init,
};
#define SPD_IFRAME_LINE_NUMBER 1
#define VENSPEC_IFRAME_LINE_NUMBER 3
-static int msm_hdmi_config_avi_infoframe(struct hdmi *hdmi,
- const u8 *buffer, size_t len)
+static int msm_hdmi_bridge_clear_avi_infoframe(struct drm_bridge *bridge)
{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
+ u32 val;
+
+ val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL0);
+ val &= ~(HDMI_INFOFRAME_CTRL0_AVI_SEND |
+ HDMI_INFOFRAME_CTRL0_AVI_CONT);
+ hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL0, val);
+
+ val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL1);
+ val &= ~HDMI_INFOFRAME_CTRL1_AVI_INFO_LINE__MASK;
+ hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL1, val);
+
+ return 0;
+}
+
+static int msm_hdmi_bridge_clear_audio_infoframe(struct drm_bridge *bridge)
+{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
+ u32 val;
+
+ val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL0);
+ val &= ~(HDMI_INFOFRAME_CTRL0_AUDIO_INFO_SEND |
+ HDMI_INFOFRAME_CTRL0_AUDIO_INFO_CONT |
+ HDMI_INFOFRAME_CTRL0_AUDIO_INFO_SOURCE |
+ HDMI_INFOFRAME_CTRL0_AUDIO_INFO_UPDATE);
+ hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL0, val);
+
+ val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL1);
+ val &= ~HDMI_INFOFRAME_CTRL1_AUDIO_INFO_LINE__MASK;
+ hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL1, val);
+
+ return 0;
+}
+
+static int msm_hdmi_bridge_clear_spd_infoframe(struct drm_bridge *bridge)
+{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
+ u32 val;
+
+ val = hdmi_read(hdmi, REG_HDMI_GEN_PKT_CTRL);
+ val &= ~(HDMI_GEN_PKT_CTRL_GENERIC1_SEND |
+ HDMI_GEN_PKT_CTRL_GENERIC1_CONT |
+ HDMI_GEN_PKT_CTRL_GENERIC1_LINE__MASK);
+ hdmi_write(hdmi, REG_HDMI_GEN_PKT_CTRL, val);
+
+ return 0;
+}
+
+static int msm_hdmi_bridge_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
+ u32 val;
+
+ val = hdmi_read(hdmi, REG_HDMI_GEN_PKT_CTRL);
+ val &= ~(HDMI_GEN_PKT_CTRL_GENERIC0_SEND |
+ HDMI_GEN_PKT_CTRL_GENERIC0_CONT |
+ HDMI_GEN_PKT_CTRL_GENERIC0_UPDATE |
+ HDMI_GEN_PKT_CTRL_GENERIC0_LINE__MASK);
+ hdmi_write(hdmi, REG_HDMI_GEN_PKT_CTRL, val);
+
+ return 0;
+}
+
+static int msm_hdmi_bridge_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
u32 buf[4] = {};
u32 val;
int i;
return -EINVAL;
}
+ msm_hdmi_bridge_clear_avi_infoframe(bridge);
+
/*
* the AVI_INFOx registers don't map exactly to how the AVI infoframes
* are packed according to the spec. The checksum from the header is
return 0;
}
-static int msm_hdmi_config_audio_infoframe(struct hdmi *hdmi,
- const u8 *buffer, size_t len)
+static int msm_hdmi_bridge_write_audio_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
u32 val;
if (len != HDMI_INFOFRAME_SIZE(AUDIO)) {
return -EINVAL;
}
+ msm_hdmi_bridge_clear_audio_infoframe(bridge);
+
hdmi_write(hdmi, REG_HDMI_AUDIO_INFO0,
buffer[3] |
buffer[4] << 8 |
return 0;
}
-static int msm_hdmi_config_spd_infoframe(struct hdmi *hdmi,
- const u8 *buffer, size_t len)
+static int msm_hdmi_bridge_write_spd_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
u32 buf[7] = {};
u32 val;
int i;
return -EINVAL;
}
+ msm_hdmi_bridge_clear_spd_infoframe(bridge);
+
/* checksum gets written together with the body of the frame */
hdmi_write(hdmi, REG_HDMI_GENERIC1_HDR,
buffer[0] |
return 0;
}
-static int msm_hdmi_config_hdmi_infoframe(struct hdmi *hdmi,
- const u8 *buffer, size_t len)
+static int msm_hdmi_bridge_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
+ struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
+ struct hdmi *hdmi = hdmi_bridge->hdmi;
u32 buf[7] = {};
u32 val;
int i;
return -EINVAL;
}
+ msm_hdmi_bridge_clear_hdmi_infoframe(bridge);
+
/* checksum gets written together with the body of the frame */
hdmi_write(hdmi, REG_HDMI_GENERIC0_HDR,
buffer[0] |
return 0;
}
-static int msm_hdmi_bridge_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
-{
- struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
- struct hdmi *hdmi = hdmi_bridge->hdmi;
- u32 val;
-
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL0);
- val &= ~(HDMI_INFOFRAME_CTRL0_AVI_SEND |
- HDMI_INFOFRAME_CTRL0_AVI_CONT);
- hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL0, val);
-
- val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL1);
- val &= ~HDMI_INFOFRAME_CTRL1_AVI_INFO_LINE__MASK;
- hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL1, val);
-
- break;
-
- case HDMI_INFOFRAME_TYPE_AUDIO:
- val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL0);
- val &= ~(HDMI_INFOFRAME_CTRL0_AUDIO_INFO_SEND |
- HDMI_INFOFRAME_CTRL0_AUDIO_INFO_CONT |
- HDMI_INFOFRAME_CTRL0_AUDIO_INFO_SOURCE |
- HDMI_INFOFRAME_CTRL0_AUDIO_INFO_UPDATE);
- hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL0, val);
-
- val = hdmi_read(hdmi, REG_HDMI_INFOFRAME_CTRL1);
- val &= ~HDMI_INFOFRAME_CTRL1_AUDIO_INFO_LINE__MASK;
- hdmi_write(hdmi, REG_HDMI_INFOFRAME_CTRL1, val);
-
- break;
-
- case HDMI_INFOFRAME_TYPE_SPD:
- val = hdmi_read(hdmi, REG_HDMI_GEN_PKT_CTRL);
- val &= ~(HDMI_GEN_PKT_CTRL_GENERIC1_SEND |
- HDMI_GEN_PKT_CTRL_GENERIC1_CONT |
- HDMI_GEN_PKT_CTRL_GENERIC1_LINE__MASK);
- hdmi_write(hdmi, REG_HDMI_GEN_PKT_CTRL, val);
-
- break;
-
- case HDMI_INFOFRAME_TYPE_VENDOR:
- val = hdmi_read(hdmi, REG_HDMI_GEN_PKT_CTRL);
- val &= ~(HDMI_GEN_PKT_CTRL_GENERIC0_SEND |
- HDMI_GEN_PKT_CTRL_GENERIC0_CONT |
- HDMI_GEN_PKT_CTRL_GENERIC0_UPDATE |
- HDMI_GEN_PKT_CTRL_GENERIC0_LINE__MASK);
- hdmi_write(hdmi, REG_HDMI_GEN_PKT_CTRL, val);
-
- break;
-
- default:
- drm_dbg_driver(hdmi_bridge->base.dev, "Unsupported infoframe type %x\n", type);
- }
-
- return 0;
-}
-
-static int msm_hdmi_bridge_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
-{
- struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
- struct hdmi *hdmi = hdmi_bridge->hdmi;
-
- msm_hdmi_bridge_clear_infoframe(bridge, type);
-
- switch (type) {
- case HDMI_INFOFRAME_TYPE_AVI:
- return msm_hdmi_config_avi_infoframe(hdmi, buffer, len);
- case HDMI_INFOFRAME_TYPE_AUDIO:
- return msm_hdmi_config_audio_infoframe(hdmi, buffer, len);
- case HDMI_INFOFRAME_TYPE_SPD:
- return msm_hdmi_config_spd_infoframe(hdmi, buffer, len);
- case HDMI_INFOFRAME_TYPE_VENDOR:
- return msm_hdmi_config_hdmi_infoframe(hdmi, buffer, len);
- default:
- drm_dbg_driver(hdmi_bridge->base.dev, "Unsupported infoframe type %x\n", type);
- return 0;
- }
-}
-
static void msm_hdmi_set_timings(struct hdmi *hdmi,
const struct drm_display_mode *mode);
.hpd_enable = msm_hdmi_hpd_enable,
.hpd_disable = msm_hdmi_hpd_disable,
.hdmi_tmds_char_rate_valid = msm_hdmi_bridge_tmds_char_rate_valid,
- .hdmi_clear_infoframe = msm_hdmi_bridge_clear_infoframe,
- .hdmi_write_infoframe = msm_hdmi_bridge_write_infoframe,
+ .hdmi_clear_audio_infoframe = msm_hdmi_bridge_clear_audio_infoframe,
+ .hdmi_write_audio_infoframe = msm_hdmi_bridge_write_audio_infoframe,
+ .hdmi_clear_avi_infoframe = msm_hdmi_bridge_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = msm_hdmi_bridge_write_avi_infoframe,
+ .hdmi_clear_spd_infoframe = msm_hdmi_bridge_clear_spd_infoframe,
+ .hdmi_write_spd_infoframe = msm_hdmi_bridge_write_spd_infoframe,
+ .hdmi_clear_hdmi_infoframe = msm_hdmi_bridge_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = msm_hdmi_bridge_write_hdmi_infoframe,
.hdmi_audio_prepare = msm_hdmi_bridge_audio_prepare,
.hdmi_audio_shutdown = msm_hdmi_bridge_audio_shutdown,
};
hdmi->tmdsclk = DEFAULT_PLLA_RATE;
}
-static int rk3066_hdmi_bridge_clear_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type)
+static int rk3066_hdmi_bridge_clear_avi_infoframe(struct drm_bridge *bridge)
{
struct rk3066_hdmi *hdmi = bridge_to_rk3066_hdmi(bridge);
- if (type != HDMI_INFOFRAME_TYPE_AVI) {
- drm_err(bridge->dev, "Unsupported infoframe type: %u\n", type);
- return 0;
- }
-
hdmi_writeb(hdmi, HDMI_CP_BUF_INDEX, HDMI_INFOFRAME_AVI);
return 0;
}
static int
-rk3066_hdmi_bridge_write_infoframe(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len)
+rk3066_hdmi_bridge_clear_hdmi_infoframe(struct drm_bridge *bridge)
+{
+ /* FIXME: add support for this InfoFrame */
+
+ drm_warn_once(bridge->encoder->dev, "HDMI VSI not supported\n");
+
+ return 0;
+}
+
+static int
+rk3066_hdmi_bridge_write_avi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
{
struct rk3066_hdmi *hdmi = bridge_to_rk3066_hdmi(bridge);
ssize_t i;
- if (type != HDMI_INFOFRAME_TYPE_AVI) {
- drm_err(bridge->dev, "Unsupported infoframe type: %u\n", type);
- return 0;
- }
-
- rk3066_hdmi_bridge_clear_infoframe(bridge, type);
+ rk3066_hdmi_bridge_clear_avi_infoframe(bridge);
for (i = 0; i < len; i++)
hdmi_writeb(hdmi, HDMI_CP_BUF_ACC_HB0 + i * 4, buffer[i]);
return 0;
}
+static int
+rk3066_hdmi_bridge_write_hdmi_infoframe(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len)
+{
+ rk3066_hdmi_bridge_clear_hdmi_infoframe(bridge);
+
+ /* FIXME: add support for this InfoFrame */
+
+ return 0;
+}
+
static int rk3066_hdmi_config_video_timing(struct rk3066_hdmi *hdmi,
struct drm_display_mode *mode)
{
.atomic_disable = rk3066_hdmi_bridge_atomic_disable,
.detect = rk3066_hdmi_bridge_detect,
.edid_read = rk3066_hdmi_bridge_edid_read,
- .hdmi_clear_infoframe = rk3066_hdmi_bridge_clear_infoframe,
- .hdmi_write_infoframe = rk3066_hdmi_bridge_write_infoframe,
+ .hdmi_clear_avi_infoframe = rk3066_hdmi_bridge_clear_avi_infoframe,
+ .hdmi_write_avi_infoframe = rk3066_hdmi_bridge_write_avi_infoframe,
+ .hdmi_clear_hdmi_infoframe = rk3066_hdmi_bridge_clear_hdmi_infoframe,
+ .hdmi_write_hdmi_infoframe = rk3066_hdmi_bridge_write_hdmi_infoframe,
.mode_valid = rk3066_hdmi_bridge_mode_valid,
};
unsigned long long tmds_rate);
/**
- * @hdmi_clear_infoframe:
+ * @hdmi_clear_avi_infoframe:
*
* This callback clears the infoframes in the hardware during commit.
- * It will be called multiple times, once for every disabled infoframe
- * type.
*
* This callback is optional but it must be implemented by bridges that
* set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
*/
- int (*hdmi_clear_infoframe)(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type);
+ int (*hdmi_clear_avi_infoframe)(struct drm_bridge *bridge);
+
+ /**
+ * @hdmi_write_avi_infoframe:
+ *
+ * Program the infoframe into the hardware.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
+ */
+ int (*hdmi_write_avi_infoframe)(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len);
+
+ /**
+ * @hdmi_clear_hdmi_infoframe:
+ *
+ * This callback clears the infoframes in the hardware during commit.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
+ */
+ int (*hdmi_clear_hdmi_infoframe)(struct drm_bridge *bridge);
+
/**
- * @hdmi_write_infoframe:
+ * @hdmi_write_hdmi_infoframe:
*
- * Program the infoframe into the hardware. It will be called multiple
- * times, once for every updated infoframe type.
+ * Program the infoframe into the hardware.
*
* This callback is optional but it must be implemented by bridges that
* set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
*/
- int (*hdmi_write_infoframe)(struct drm_bridge *bridge,
- enum hdmi_infoframe_type type,
- const u8 *buffer, size_t len);
+ int (*hdmi_write_hdmi_infoframe)(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len);
+
+ /**
+ * @hdmi_clear_hdr_drm_infoframe:
+ *
+ * This callback clears the infoframes in the hardware during commit.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME flag in their
+ * &drm_bridge->ops.
+ */
+ int (*hdmi_clear_hdr_drm_infoframe)(struct drm_bridge *bridge);
+
+ /**
+ * @hdmi_write_hdr_drm_infoframe:
+ *
+ * Program the infoframe into the hardware.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME flag in their
+ * &drm_bridge->ops.
+ */
+ int (*hdmi_write_hdr_drm_infoframe)(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len);
+
+ /**
+ * @hdmi_clear_spd_infoframe:
+ *
+ * This callback clears the infoframes in the hardware during commit.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME flag in their
+ * &drm_bridge->ops.
+ */
+ int (*hdmi_clear_spd_infoframe)(struct drm_bridge *bridge);
+
+ /**
+ * @hdmi_write_spd_infoframe:
+ *
+ * Program the infoframe into the hardware.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME flag in their
+ * &drm_bridge->ops.
+ */
+ int (*hdmi_write_spd_infoframe)(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len);
+
+ /**
+ * @hdmi_clear_audio_infoframe:
+ *
+ * This callback clears the infoframes in the hardware during commit.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
+ */
+ int (*hdmi_clear_audio_infoframe)(struct drm_bridge *bridge);
+
+ /**
+ * @hdmi_write_audio_infoframe:
+ *
+ * Program the infoframe into the hardware.
+ *
+ * This callback is optional but it must be implemented by bridges that
+ * set the DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
+ */
+ int (*hdmi_write_audio_infoframe)(struct drm_bridge *bridge,
+ const u8 *buffer, size_t len);
/**
* @hdmi_audio_startup:
/**
* @DRM_BRIDGE_OP_HDMI: The bridge provides HDMI connector operations,
* including infoframes support. Bridges that set this flag must
- * implement the &drm_bridge_funcs->write_infoframe callback.
+ * provide HDMI-related information and implement the
+ * &drm_bridge_funcs->clear_avi_infoframe,
+ * &drm_bridge_funcs->write_avi_infoframe,
+ * &drm_bridge_funcs->clear_hdmi_infoframe and
+ * &drm_bridge_funcs->write_hdmi_infoframe callbacks.
*
* Note: currently there can be at most one bridge in a chain that sets
* this bit. This is to simplify corresponding glue code in connector
* Bridges that set this flag must implement the
* &drm_bridge_funcs->hdmi_audio_prepare and
* &drm_bridge_funcs->hdmi_audio_shutdown callbacks.
+ * If the bridge implements @DRM_BRIDGE_OP_HDMI, it also must implement
+ * &drm_bridge_funcs->hdmi_write_audio_infoframe and
+ * &drm_bridge_funcs->hdmi_cleaer_audio_infoframe callbacks.
*
* Note: currently there can be at most one bridge in a chain that sets
* this bit. This is to simplify corresponding glue code in connector
* to be present.
*/
DRM_BRIDGE_OP_HDMI_CEC_ADAPTER = BIT(8),
+ /**
+ * @DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME: The bridge supports
+ * &drm_bridge_funcs->hdmi_write_hdr_drm_infoframe and
+ * &drm_bridge_funcs->hdmi_clear_hdr_drm_infoframe callbacks.
+ */
+ DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME = BIT(9),
+ /**
+ * @DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME: The bridge supports
+ * &drm_bridge_funcs->hdmi_write_spd_infoframe and
+ * &drm_bridge_funcs->hdmi_clear_spd_infoframe callbacks.
+ */
+ DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME = BIT(10),
};
/**
projects / thirdparty / kernel / linux.git / commitdiff
