drm/msm/hdmi: add hdmi hdcp support
PATCH 2/2 drm/msm/hdmi: add hdmi hdcp support
Add HDMI HDCP support including HDCP PartI/II/III authentication.
--- drivers/gpu/drm/msm/Makefile | 1 + drivers/gpu/drm/msm/hdmi/hdmi.c | 44 + drivers/gpu/drm/msm/hdmi/hdmi.h | 31 + drivers/gpu/drm/msm/hdmi/hdmi_audio.c | 1 - drivers/gpu/drm/msm/hdmi/hdmi_bridge.c | 3 +- drivers/gpu/drm/msm/hdmi/hdmi_connector.c | 7 +- drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c | 1600 +++++++++++++++++++++++++++++ 7 files changed, 1682 insertions(+), 5 deletions(-) create mode 100644 drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
drivers/gpu/drm/msm/Makefile +1 -0
@@ -11,6 +11,7 @@ msm-y := \ hdmi/hdmi_audio.o \ hdmi/hdmi_bridge.o \ hdmi/hdmi_connector.o \ + hdmi/hdmi_hdcp.o \ hdmi/hdmi_i2c.o \ hdmi/hdmi_phy_8960.o \ hdmi/hdmi_phy_8x60.o \
drivers/gpu/drm/msm/hdmi/hdmi.c +44 -0
105 lines not on this page · raw message
drivers/gpu/drm/msm/hdmi/hdmi.h +31 -0
@@ -37,6 +37,8 @@ struct hdmi_audio {int rate; }; +struct hdmi_hdcp_ctrl ; +struct hdmi {struct kref refcount;
@@ -53,6 +55,8 @@ struct hdmi {unsigned long int pixclock;void __iomem *mmio; +void __iomem *qfprom_mmio; +phys_addr_t mmio_phy_addr;struct regulator *hpd_regs[2 ];struct regulator *pwr_regs[2 ];
@@ -70,12 +74,25 @@ struct hdmi {bool hdmi_mode;/* are we in hdmi mode? */ int irq; +struct workqueue_struct *workq; + +struct hdmi_hdcp_ctrl *hdcp_ctrl; + +/* +* spinlock to protect registers shared by different execution +* REG_HDMI_CTRL +* REG_HDMI_DDC_ARBITRATION +* REG_HDMI_HDCP_INT_CTRL +* REG_HDMI_HPD_CTRL +*/ +spinlock_t reg_lock; };/* platform config data (ie. from DT, or pdata) */ struct hdmi_platform_config {struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);const char *mmio_name; +const char *qfprom_mmio_name;/* regulators that need to be on for hpd: */ const char **hpd_reg_names;
@@ -115,6 +132,11 @@ static inline u32 hdmi_read(struct hdmi *hdmi, u32 reg)return msm_readl (hdmi->mmio + reg); } +static inline u32 hdmi_qfprom_read (struct hdmi *hdmi,u32 reg) +{ +return msm_readl (hdmi->qfprom_mmio + reg); +} +static inline struct hdmi *hdmi_reference (struct hdmi *hdmi) {kref_get (&hdmi->refcount);
@@ -179,4 +201,13 @@ void hdmi_i2c_irq(struct i2c_adapter *i2c);void hdmi_i2c_destroy (struct i2c_adapter *i2c);struct i2c_adapter *hdmi_i2c_init (struct hdmi *hdmi); +/* +* hdcp +*/ +void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl); +struct hdmi_hdcp_ctrl *hdmi_hdcp_init (struct hdmi *hdmi); +void hdmi_hdcp_destroy (struct hdmi *hdmi); +int hdmi_hdcp_on (struct hdmi *hdmi); +void hdmi_hdcp_off (struct hdmi *hdmi); +#endif /* __HDMI_CONNECTOR_H__ */
drivers/gpu/drm/msm/hdmi/hdmi_audio.c +0 -1
@@ -203,7 +203,6 @@ int hdmi_audio_update(struct hdmi *hdmi) audio_config |=HDMI_AUDIO_CFG_FIFO_WATERMARK (4 ); audio_config |=HDMI_AUDIO_CFG_ENGINE_ENABLE ; }else { -hdmi_write (hdmi,REG_HDMI_GC ,HDMI_GC_MUTE ); acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_CONT ; acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_SEND ; vbi_pkt_ctrl &= ~HDMI_VBI_PKT_CTRL_GC_ENABLE ;
drivers/gpu/drm/msm/hdmi/hdmi_bridge.c +1 -2
@@ -106,6 +106,7 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge) phy->funcs->powerup (phy, hdmi->pixclock);hdmi_set_mode (hdmi, true); +hdmi_hdcp_on (hdmi); }static void hdmi_bridge_enable (struct drm_bridge *bridge)
@@ -146,8 +147,6 @@ static void hdmi_bridge_mode_set(struct drm_bridge *bridge, hdmi->pixclock = mode->clock *1000 ; - hdmi->hdmi_mode =drm_match_cea_mode (mode) >1 ; - hstart = mode->htotal - mode->hsync_start; hend = mode->htotal - mode->hsync_start + mode->hdisplay;
drivers/gpu/drm/msm/hdmi/hdmi_connector.c +5 -2
@@ -140,6 +140,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector)struct hdmi_phy *phy = hdmi->phy;uint32_t hpd_ctrl;int i, ret; +unsigned long flags; ret =gpio_config (hdmi, true);if (ret) {
@@ -185,6 +186,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) HDMI_HPD_INT_CTRL_INT_EN);/* set timeout to 4.1ms (max) for hardware debounce */ +spin_lock_irqsave (&hdmi->reg_lock, flags); hpd_ctrl =hdmi_read (hdmi,REG_HDMI_HPD_CTRL ); hpd_ctrl |=HDMI_HPD_CTRL_TIMEOUT (0x1fff );
@@ -193,6 +195,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) ~HDMI_HPD_CTRL_ENABLE & hpd_ctrl);hdmi_write (hdmi,REG_HDMI_HPD_CTRL ,HDMI_HPD_CTRL_ENABLE | hpd_ctrl); +spin_unlock_irqrestore (&hdmi->reg_lock, flags);return 0 ;
@@ -248,7 +251,6 @@ hotplug_work(struct work_struct *work)void hdmi_connector_irq (struct drm_connector *connector) {struct hdmi_connector *hdmi_connector =to_hdmi_connector (connector); -struct msm_drm_private *priv = connector->dev->dev_private;struct hdmi *hdmi = hdmi_connector->hdmi;uint32_t hpd_int_status, hpd_int_ctrl;
@@ -272,7 +274,7 @@ void hdmi_connector_irq(struct drm_connector *connector) hpd_int_ctrl |=HDMI_HPD_INT_CTRL_INT_CONNECT ;hdmi_write (hdmi,REG_HDMI_HPD_INT_CTRL , hpd_int_ctrl); -queue_work (priv->wq, &hdmi_connector->hpd_work); +queue_work (hdmi->workq, &hdmi_connector->hpd_work); } }
@@ -350,6 +352,7 @@ static int hdmi_connector_get_modes(struct drm_connector *connector)hdmi_write (hdmi,REG_HDMI_CTRL , hdmi_ctrl); + hdmi->hdmi_mode =drm_detect_hdmi_monitor (edid);drm_mode_connector_update_edid_property (connector, edid);if (edid) {
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +1600 -0
1,600 lines not on this page · raw message
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Quoted 4 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
Signed-off-by Jilai Wang <[email protected]>---
Hi Jilai,
[..]
Quoted 1 line
drivers/gpu/drm/msm/hdmi/hdmi.c +0
-0
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 142
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0@@ -119,6 +137,22 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; } +/* HDCP needs physical address of hdmi register */ + res =platform_get_resource_byname (pdev,IORESOURCE_MEM , + config->mmio_name);
Is this guaranteed to be available at all times? You should probably do some error handling here.
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 145
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ hdmi->mmio_phy_addr = res->start; + +if (config->qfprom_mmio_name) {
Should this check really be here? This will always be set if CONFIG_OF is set and never otherwise and that seems strange to me.
Perhaps you should add the string to the !CONFIG_OF platforms as well or simply add #ifdef CONFIG_OF around this section if that's what you really want. (but seems more like you forgot the non-of case).
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 147
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +2
-0+ hdmi->qfprom_mmio =msm_ioremap (pdev, + config->qfprom_mmio_name,"HDMI_QFPROM" );
Is this a special hdmi qfprom or are you ioremapping _the_ qfprom here?
If so I did suggest that we expose it as a syscon but I think Stephen Boyd had some other ideas.
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 153
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +6
-0+if (IS_ERR (hdmi->qfprom_mmio)) { +dev_info (&pdev->dev,"can't find qfprom resource\n" ); + hdmi->qfprom_mmio =NULL ; + } + }else { + hdmi->qfprom_mmio =NULL ;
hdmi_qfprom_read() seems to be called and read from qfprom_mmio no matter how this ended. Are you sure this (both error paths) shouldn't be handled as a fatal error?
'hdmi' is kzalloc and hence already NULL.
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 248
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0@@ -205,6 +241,13 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; } + hdmi->hdcp_ctrl =hdmi_hdcp_init (hdmi); +if (IS_ERR (hdmi->hdcp_ctrl)) { + ret =PTR_ERR (hdmi->hdcp_ctrl); +dev_warn (dev->dev,"failed to init hdcp: %d(disabled)\n" , ret); + hdmi->hdcp_ctrl =NULL ;
So either you treat this as an error or you don't.
If you're fine continuing execution without hdcp_ctrl then you shouldn't set ret. But in that case it you should probably not print a warning every time you enter hdmi_hdcp_on() and an error on hdmi_hdcp_off().
[..]
Quoted 1 line
drivers/gpu/drm/msm/hdmi/hdmi.h +0
-0
[..]
drivers/gpu/drm/msm/hdmi/hdmi.h struct hdmi { · line 77
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi.h +1
-0@@ -70,12 +74,25 @@ struct hdmi {bool hdmi_mode;/* are we in hdmi mode? */ int irq; +struct workqueue_struct *workq;
Do you really need a special workqueue for this, can't you use the system work queue (or system_long_wq)?
[..]
drivers/gpu/drm/msm/hdmi/hdmi.h static inline u32 hdmi_read(struct hdmi *hdmi, u32 reg) · line 137
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi.h +3
-0+static inline u32 hdmi_qfprom_read (struct hdmi *hdmi,u32 reg) +{ +return msm_readl (hdmi->qfprom_mmio + reg);
As stated above, qfprom_mmio might be NULL.
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi.h +2
-0+} +
[..]
Quoted 1 line
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +0
-0
[..]
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +2
-0+ +#define TZ_HDCP_CMD_ID 0x00004401
Add a definition of SCM_SVC_HDCP being 17 to scm.h and define SCM_CMD_HDCP to 1 here instead.
[..]
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 48
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +3
-0+ +struct hdmi_hdcp_reg_data { +uint32_t reg_id;
You should use u32 instead of uint32_t in the kernel.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 57
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+uint32_t off; +char *name; +uint32_t reg_val; +}; + +struct hdmi_hdcp_ctrl { +struct hdmi *hdmi; +uint32_t auth_retries; +uint32_t tz_hdcp;
Turn this into a bool named something like has_tz_hdcp instead, as that's what it really means.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 68
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;
You shouldn't use "work" as a way to express states in your state machine. Better have 1 auth work function that does all these steps, probably having them split in functions just like you do now.
That way you can have 1 function running the pass of authentication, starting by checking if you're reauthing or not then processing each step one by one, sleeping inbetween them. You can have the functions return -EAGAIN to indicate that you need to retry the current operation and so on.
This would split the state machine from the state executioners and simplify your code.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 75
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +7
-0+uint32_t work_retry_cnt; +uint32_t ksv_fifo_w_index; + +/* +* store aksv from qfprom +*/ +uint8_t aksv[5 ];
You should use u8 intead of uint8_t in the kernel.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 88
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+bool aksv_valid; +uint32_t ds_type; +uint8_t bksv[5 ]; +uint8_t dev_count; +uint8_t depth; +uint8_t ksv_list[5 *127 ]; +bool max_cascade_exceeded; +bool max_dev_exceeded; +}; + +static int hdmi_ddc_read (struct hdmi *hdmi,uint16_t addr,uint8_t offset, +uint8_t *data,uint16_t data_len,bool no_align) +{
As far as I can see you can replace this entire function with:
return i2c_smbus_read_i2c_block_data(hdmi->i2c, addr + offset, data_len, data);
Although note that it would return data_len instead of 0 on success.
Quoted 14 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +14
-0+int rc =0 ; +int retry =5 ; +uint8_t *buf =NULL ; +uint32_t request_len; +struct i2c_msg msgs[] = { + { + .addr = addr >>1 , + .flags =0 , + .len =1 , + .buf = &offset, + }, { + .addr = addr >>1 , + .flags =I2C_M_RD , + .len = data_len,
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 112
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ .buf = data, + } + }; + +DBG ("Start DDC read" ); +retry: +if (no_align) { + rc =i2c_transfer (hdmi->i2c, msgs,2 ); + }else { + request_len =32 * ((data_len +31 ) /32 );
Why are you doing this. The documentation for i2c_msg states that if you set I2C_M_RECV_LEN you have to be able to do something like this, but you don't.
I don't see anything special with the buffers you're reading into, so you should be able to just use i2c_smbus_read_i2c_block_data() and be done with it.
Quoted 18 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +18
-0+ buf =kmalloc (request_len,GFP_KERNEL ); +if (!buf) +return -ENOMEM ; + + msgs[1 ].buf = buf; + rc =i2c_transfer (hdmi->i2c, msgs,2 ); + } + + retry--; +if (rc ==2 ) { + rc =0 ; +if (!no_align) +memcpy (data, buf, data_len); + }else if (retry >0 ) { + goto retry; + }else { + rc = -EIO ; + }
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 140
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +kfree (buf); +DBG ("End DDC read %d" , rc); + +return rc; +} + +static int hdmi_ddc_write (struct hdmi *hdmi,uint16_t addr,uint8_t offset, +uint8_t *data,uint16_t data_len) +{
And as for hdmi_ddc_read, this would be:
i2c_smbus_write_i2c_block_data(hdmi->i2c, addr + offset, data_len, data);
Quoted 37 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +37
-0+int rc =0 ; +int retry =10 ; +uint8_t *buf =NULL ; +struct i2c_msg msgs[] = { + { + .addr = addr >>1 , + .flags =0 , + .len =1 , + } + }; + +DBG ("Start DDC write" ); + buf =kmalloc (data_len +1 ,GFP_KERNEL ); +if (!buf) +return -ENOMEM ; + + buf[0 ] = offset; +memcpy (&buf[1 ], data, data_len); + msgs[0 ].buf = buf; + msgs[0 ].len = data_len +1 ; +retry: + rc =i2c_transfer (hdmi->i2c, msgs,1 ); + + retry--; +if (rc ==1 ) + rc =0 ; +else if (retry >0 ) + goto retry; +else + rc = -EIO ; + +kfree (buf); +DBG ("End DDC write %d" , rc); + +return rc; +} +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 187
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+static int hdmi_hdcp_scm_wr (struct hdmi_hdcp_ctrl *hdcp_ctrl,uint32_t *preg, +uint32_t *pdata,uint32_t count) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +struct scm_hdcp_req scm_buf[SCM_HDCP_MAX_REG ]; +uint32_t resp, phy_addr, idx =0 ; +int i, ret =0 ; + +if (count ==0 ) +return 0 ;
There are no calls to this function where count can be 0, so you can drop this check.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 192
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +5
-0+ +if (!preg || !pdata) { +pr_err ("%s: Invalid pointer\n" , __func__); +return -EINVAL ; + }
There are no calls to this function where either of these are NULL, so you can drop the entire block.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 205
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+ +if (hdcp_ctrl->tz_hdcp) { + phy_addr = (uint32_t )hdmi->mmio_phy_addr; + +while (count) { +memset (scm_buf,0 ,sizeof (scm_buf)); +for (i =0 ; i < count && i <SCM_HDCP_MAX_REG ; i++) { + scm_buf[i].addr = phy_addr + preg[idx]; + scm_buf[i].val = pdata[idx]; + idx++; + } + ret =scm_call (SCM_SVC_HDCP ,SCM_CMD_HDCP , + scm_buf,sizeof (scm_buf), &resp,sizeof (resp));
SCM_SVC_HDCP nor SCM_CMD_HDCP are defined, here. See the comment above related to TZ_HDCP_CMD_ID.
Quoted 18 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +18
-0+ +if (ret || resp) { +pr_err ("%s: error: scm_call ret = %d, resp = %d\n" , + __func__, ret, resp); + ret = -EINVAL ; +break ; + } + + count -= i; + } + }else { +for (i =0 ; i < count; i++) +hdmi_write (hdmi, preg[i], pdata[i]); + } + +return ret; +} +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 233
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi; +uint32_t regval, hdcp_int_status; +unsigned long flags; + +if (!hdcp_ctrl) { +DBG ("HDCP is disabled" ); +return ; + }
No need to print a debug line here every time.
I would have preferred if you made the call from hdmi_irq() conditional instead, then you would need to check here...
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +2
-0+ + hdmi = hdcp_ctrl->hdmi;
And you could have folded this into the declaration above.
Quoted 36 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +36
-0+spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_HDCP_INT_CTRL ); + hdcp_int_status = regval &HDCP_INT_STATUS ; +if (!hdcp_int_status) { +spin_unlock_irqrestore (&hdmi->reg_lock, flags); +return ; + } +/* Clear Interrupts */ + regval |= hdcp_int_status <<1 ; +/* Clear AUTH_FAIL_INFO as well */ +if (hdcp_int_status &BIT (4 )) + regval |=BIT (7 ); +hdmi_write (hdmi,REG_HDMI_HDCP_INT_CTRL , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +DBG ("hdcp irq %x" , regval); +if (hdcp_int_status &BIT (0 )) { +/* AUTH_SUCCESS_INT */ +pr_info ("%s:AUTH_SUCCESS_INT received\n" , __func__); +if (HDCP_STATE_AUTHENTICATING == hdcp_ctrl->hdcp_state) +queue_work (hdmi->workq, + &hdcp_ctrl->hdcp_auth_part1_3_work); + } + +if (hdcp_int_status &BIT (4 )) { +/* AUTH_FAIL_INT */ + regval =hdmi_read (hdmi,REG_HDMI_HDCP_LINK0_STATUS ); +pr_info ("%s: AUTH_FAIL_INT rcvd, LINK0_STATUS=0x%08x\n" , + __func__, regval); +if (HDCP_STATE_AUTHENTICATED == hdcp_ctrl->hdcp_state) +queue_delayed_work (hdmi->workq, + &hdcp_ctrl->hdcp_reauth_work,HZ /2 ); +else if (HDCP_STATE_AUTHENTICATING == hdcp_ctrl->hdcp_state) +queue_work (hdmi->workq, + &hdcp_ctrl->hdcp_auth_part1_3_work); + }
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 281
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +if (hdcp_int_status &BIT (8 )) { +/* DDC_XFER_REQ_INT */ +pr_info ("%s:DDC_XFER_REQ_INT received\n" , __func__); + } + +if (hdcp_int_status &BIT (12 )) { +/* DDC_XFER_DONE_INT */ +pr_info ("%s:DDC_XFER_DONE received\n" , __func__); + }
You should drop the pr_info's here, as they add don't do really do anything.
Quoted 1 line
+} /*
hdmi_hdcp_isr*/
Drop the comment.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 285
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +3
-0+ +static int hdmi_hdcp_count_one (uint8_t *array,uint8_t len) +{
If you can get your buffer into two u32's you can use hweight32 to do this instead.
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+int i, j, count =0 ; + +for (i =0 ; i < len; i++) +for (j =0 ; j <8 ; j++) + count += (((array[i] >> j) &0x1 ) ?1 :0 ); + +return count; +} + +static int hdmi_hdcp_read_validate_aksv (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t qfprom_aksv_lsb, qfprom_aksv_msb;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 308
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* Fetch aksv from QFPROM, this info should be public. */ + qfprom_aksv_lsb =hdmi_qfprom_read (hdmi,HDCP_KSV_LSB ); + qfprom_aksv_msb =hdmi_qfprom_read (hdmi,HDCP_KSV_MSB ); + + hdcp_ctrl->aksv[0 ] = qfprom_aksv_lsb &0xFF ; + hdcp_ctrl->aksv[1 ] = (qfprom_aksv_lsb >>8 ) &0xFF ; + hdcp_ctrl->aksv[2 ] = (qfprom_aksv_lsb >>16 ) &0xFF ; + hdcp_ctrl->aksv[3 ] = (qfprom_aksv_lsb >>24 ) &0xFF ; + hdcp_ctrl->aksv[4 ] = qfprom_aksv_msb &0xFF ;
The only time you use these are in hdmi_hdcp_auth_prepare_work() where you reverse this operation to get them back into two u32's of lsb and msb. Better just store them as such then.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 311
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +3
-0+ +/* check there are 20 ones in AKSV */ +if (hdmi_hdcp_count_one (hdcp_ctrl->aksv,5 ) !=20 ) {
And you can do hweight32(msb) + hweight32(lsb) != 20 here.
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+pr_err ("%s: AKSV QFPROM doesn't have 20 1's, 20 0's\n" , + __func__); +pr_err ("%s: QFPROM AKSV chk failed (AKSV=%02x%08x)\n" , + __func__, qfprom_aksv_msb, + qfprom_aksv_lsb); +return -EINVAL ; + } +DBG ("AKSV=%02x%08x" , qfprom_aksv_msb, qfprom_aksv_lsb); + +return 0 ; +} + +static void reset_hdcp_ddc_failures (struct hdmi_hdcp_ctrl *hdcp_ctrl)
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 334
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+{ +int hdcp_ddc_ctrl1_reg; +int hdcp_ddc_status; +int failure; +int nack0; +struct hdmi *hdmi = hdcp_ctrl->hdmi; + +/* Check for any DDC transfer failures */ + hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + failure = (hdcp_ddc_status >>16 ) &0x1 ;
failure = hdcp_ddc_status & BIT(16);
Quoted 1 line
+ nack0 = (
hdcp_ddc_status>> 14) &0x1;
nack0 = hdcp_ddc_status & BIT(14);
Quoted 14 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +14
-0+DBG ("On Entry: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); + +if (failure ==0x1 ) { +/* +* Indicates that the last HDCP HW DDC transfer failed. +* This occurs when a transfer is attempted with HDCP DDC +* disabled (HDCP_DDC_DISABLE=1) or the number of retries +* matches HDCP_DDC_RETRY_CNT. +* Failure occurred, let's clear it. +*/ +DBG ("DDC failure detected.HDCP_DDC_STATUS=0x%08x" , + hdcp_ddc_status); +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 359
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* First, Disable DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,BIT (0 )); + +/* ACK the Failure to Clear it */ + hdcp_ddc_ctrl1_reg =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_CTRL_1 ); +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_1 , + hdcp_ddc_ctrl1_reg |BIT (0 )); + +/* Check if the FAILURE got Cleared */ + hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS );
Replace the following lines with:
if (hdcp_ddc_status & BIT(16))pr_info("%s: Unable to clear HDCP DDC Failure\n", __func__);
No need to print the debug statement either...
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +7
-0+ hdcp_ddc_status = (hdcp_ddc_status >>16 ) &BIT (0 ); +if (hdcp_ddc_status ==0x0 ) +DBG ("HDCP DDC Failure cleared" ); +else +pr_info ("%s: Unable to clear HDCP DDC Failure\n" , + __func__); +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 376
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* Re-Enable HDCP DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,0 ); + } + +if (nack0 ==0x1 ) { +DBG ("Before: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); +/* Reset HDMI DDC software status */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (3 ));
Split all these in:
val = hdmi_read()
val |= foohdmi_write(val);
To make this readable.
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +4
-0+msleep (20 ); +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) & ~(BIT (3 ))); +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 390
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* Reset HDMI DDC Controller */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (1 )); +msleep (20 ); +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) & ~BIT (1 )); +DBG ("After: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); + } +
Just end the function here, no need for the extra debug printouts...
Quoted 14 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +14
-0+ hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + + failure = (hdcp_ddc_status >>16 ) &BIT (0 ); + nack0 = (hdcp_ddc_status >>14 ) &BIT (0 ); +DBG ("On Exit: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); +} + +static void hdmi_hdcp_hw_ddc_clean (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +uint32_t hdcp_ddc_status, ddc_hw_status; +uint32_t ddc_xfer_done, ddc_xfer_req, ddc_hw_done; +uint32_t ddc_hw_not_ready; +uint32_t timeout_count;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 414
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+struct hdmi *hdmi = hdcp_ctrl->hdmi; + +if (hdmi_read (hdmi,REG_HDMI_DDC_HW_STATUS ) ==0 ) +return ; + +/* Wait to be clean on DDC HW engine */ + timeout_count =100 ; + do { + hdcp_ddc_status = hdmi_read(hdmi, REG_HDMI_HDCP_DDC_STATUS); + ddc_hw_status = hdmi_read(hdmi, REG_HDMI_DDC_HW_STATUS);
An empty line between the reads and the logic would make things much easier to read.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 420
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +6
-0+ ddc_xfer_done = hdcp_ddc_status &BIT (10 ); + ddc_xfer_req = hdcp_ddc_status &BIT (4 ); + ddc_hw_done = ddc_hw_status &BIT (3 ); + ddc_hw_not_ready = !ddc_xfer_done || + ddc_xfer_req || !ddc_hw_done; +
if (!ddc_hw_not_ready)
break;
Simplifies the bottom part of the loop...and then flip the logic around to remove the double negation.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 424
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +4
-0+DBG ("timeout count(%d):ddc hw%sready" , + timeout_count, ddc_hw_not_ready ?" not " :" " ); +DBG ("hdcp_ddc_status[0x%x], ddc_hw_status[0x%x]" , + hdcp_ddc_status, ddc_hw_status);
Don't dump 200 lines of debug prints just because this times out.
Quoted 37 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +37
-0+if (ddc_hw_not_ready) +msleep (20 ); + }while (ddc_hw_not_ready && --timeout_count); +} + +/* +* Only retries defined times then abort current authenticating process +*/ +static int hdmi_msm_if_abort_reauth (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; + +if (++hdcp_ctrl->auth_retries ==AUTH_RETRIES_TIME ) { +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_INACTIVE ; +mutex_unlock (&hdcp_ctrl->state_mutex); + + hdcp_ctrl->auth_retries =0 ; + rc = -ERANGE ; + } + +return rc; +} + +static void hdmi_hdcp_reauth_work (struct work_struct *work) +{ +struct delayed_work *dw =to_delayed_work (work); +struct hdmi_hdcp_ctrl *hdcp_ctrl =container_of (dw, + struct hdmi_hdcp_ctrl, hdcp_reauth_work); +struct hdmi *hdmi = hdcp_ctrl->hdmi; +unsigned long flags; +int rc; + +DBG ("HDCP REAUTH WORK" ); +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_AUTH_FAIL ; +mutex_unlock (&hdcp_ctrl->state_mutex);
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 471
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* +* Disable HPD circuitry. +* This is needed to reset the HDCP cipher engine so that when we +* attempt a re-authentication, HW would clear the AN0_READY and +* AN1_READY bits in HDMI_HDCP_LINK0_STATUS register +*/ +spin_lock_irqsave (&hdmi->reg_lock, flags); +hdmi_write (hdmi,REG_HDMI_HPD_CTRL , +hdmi_read (hdmi,REG_HDMI_HPD_CTRL ) & ~BIT (28 ));
Split things like this into:
val = hdmi_read(hdmi, REG_HDMI_HPD_CTRL);
val &= ~BIT(28);hdmi_write(hdmi, REG_HDMI_HPD_CTRL,val);
For readability.
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* Disable HDCP interrupts */ +hdmi_write (hdmi,REG_HDMI_HDCP_INT_CTRL ,0 ); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +hdmi_write (hdmi,REG_HDMI_HDCP_RESET ,BIT (0 )); + +/* Wait to be clean on DDC HW engine */ +hdmi_hdcp_hw_ddc_clean (hdcp_ctrl); +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 491
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* Disable encryption and disable the HDCP block */ +hdmi_write (hdmi,REG_HDMI_HDCP_CTRL ,0 ); + +/* Enable HPD circuitry */ +spin_lock_irqsave (&hdmi->reg_lock, flags); +hdmi_write (hdmi,REG_HDMI_HPD_CTRL , +hdmi_read (hdmi,REG_HDMI_HPD_CTRL ) |BIT (28 )); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + + rc =hdmi_msm_if_abort_reauth (hdcp_ctrl);
Just inline the hdmi_msm_if_abort_reauth() here, if you extract the state handling to 1 worker function (that sleeps inbetween the steps) you don't need to lock and there's not much code left in the function.
Quoted 46 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +46
-0+if (rc) { +pr_err ("%s: abort reauthentication!\n" , __func__); +return ; + } + +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_AUTHENTICATING ; +mutex_unlock (&hdcp_ctrl->state_mutex); +queue_work (hdmi->workq, &hdcp_ctrl->hdcp_auth_prepare_work); +} + +static void hdmi_hdcp_auth_prepare_work (struct work_struct *work) +{ +struct hdmi_hdcp_ctrl *hdcp_ctrl =container_of (work, + struct hdmi_hdcp_ctrl, hdcp_auth_prepare_work); +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t qfprom_aksv_lsb, qfprom_aksv_msb; +uint32_t link0_status; +uint32_t regval; +unsigned long flags; +int ret; + +if (!hdcp_ctrl->aksv_valid) { + ret =hdmi_hdcp_read_validate_aksv (hdcp_ctrl); +if (ret) { +pr_err ("%s: ASKV validation failed\n" , __func__); +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_INACTIVE ; +mutex_unlock (&hdcp_ctrl->state_mutex); +return ; + } + hdcp_ctrl->aksv_valid = true; + } + +spin_lock_irqsave (&hdmi->reg_lock, flags); +/* disable HDMI Encrypt */ + regval =hdmi_read (hdmi,REG_HDMI_CTRL ); + regval &= ~HDMI_CTRL_ENCRYPTED ; +hdmi_write (hdmi,REG_HDMI_CTRL , regval); + +/* Enabling Software DDC */ + regval =hdmi_read (hdmi,REG_HDMI_DDC_ARBITRATION ); + regval &= ~HDMI_DDC_ARBITRATION_HW_ARBITRATION ; +hdmi_write (hdmi,REG_HDMI_DDC_ARBITRATION , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 547
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* +* Write AKSV read from QFPROM to the HDCP registers. +* This step is needed for HDCP authentication and must be +* written before enabling HDCP. +*/ + qfprom_aksv_lsb = hdcp_ctrl->aksv[3 ]; + qfprom_aksv_lsb = (qfprom_aksv_lsb <<8 ) | hdcp_ctrl->aksv[2 ]; + qfprom_aksv_lsb = (qfprom_aksv_lsb <<8 ) | hdcp_ctrl->aksv[1 ]; + qfprom_aksv_lsb = (qfprom_aksv_lsb <<8 ) | hdcp_ctrl->aksv[0 ]; + qfprom_aksv_msb = hdcp_ctrl->aksv[4 ];
As noted when you extracted these, better just keep them as lsb and msg in hdcp_ctrl.
Quoted 88 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +88
-0+hdmi_write (hdmi,REG_HDMI_HDCP_SW_LOWER_AKSV , qfprom_aksv_lsb); +hdmi_write (hdmi,REG_HDMI_HDCP_SW_UPPER_AKSV , qfprom_aksv_msb); + +/* +* HDCP setup prior to enabling HDCP_CTRL. +* Setup seed values for random number An. +*/ +hdmi_write (hdmi,REG_HDMI_HDCP_ENTROPY_CTRL0 ,0xB1FFB0FF ); +hdmi_write (hdmi,REG_HDMI_HDCP_ENTROPY_CTRL1 ,0xF00DFACE ); + +/* Disable the RngCipher state */ +hdmi_write (hdmi,REG_HDMI_HDCP_DEBUG_CTRL , +hdmi_read (hdmi,REG_HDMI_HDCP_DEBUG_CTRL ) & ~(BIT (2 ))); +DBG ("HDCP_DEBUG_CTRL=0x%08x" , +hdmi_read (hdmi,REG_HDMI_HDCP_DEBUG_CTRL )); + +/* +* Ensure that all register writes are completed before +* enabling HDCP cipher +*/ +wmb (); + +/* +* Enable HDCP +* This needs to be done as early as possible in order for the +* hardware to make An available to read +*/ +hdmi_write (hdmi,REG_HDMI_HDCP_CTRL ,BIT (0 )); + +/* +* If we had stale values for the An ready bit, it should most +* likely be cleared now after enabling HDCP cipher +*/ + link0_status =hdmi_read (hdmi,REG_HDMI_HDCP_LINK0_STATUS ); +DBG ("After enabling HDCP Link0_Status=0x%08x" , link0_status); +if (!(link0_status & (BIT (8 ) |BIT (9 )))) +DBG ("An not ready after enabling HDCP" ); + +/* Clear any DDC failures from previous tries before enable HDCP*/ +reset_hdcp_ddc_failures (hdcp_ctrl); + +DBG ("Queuing work to start HDCP authentication" ); + hdcp_ctrl->work_retry_cnt =AUTH_WORK_RETRIES_TIME ; +queue_delayed_work (hdmi->workq, + &hdcp_ctrl->hdcp_auth_part1_1_work,HZ /2 ); +} + +static void hdmi_hdcp_auth_fail (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t regval; +unsigned long flags; + +DBG ("hdcp auth failed, queue reauth work" ); +/* clear HDMI Encrypt */ +spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_CTRL ); + regval &= ~HDMI_CTRL_ENCRYPTED ; +hdmi_write (hdmi,REG_HDMI_CTRL , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); +queue_delayed_work (hdmi->workq, &hdcp_ctrl->hdcp_reauth_work,HZ /2 ); +} + +static void hdmi_hdcp_auth_done (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t regval; +unsigned long flags; + +/* +* Disable software DDC before going into part3 to make sure +* there is no Arbitration between software and hardware for DDC +*/ +spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_DDC_ARBITRATION ); + regval |=HDMI_DDC_ARBITRATION_HW_ARBITRATION ; +hdmi_write (hdmi,REG_HDMI_DDC_ARBITRATION , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +/* +* Ensure that the state did not change during authentication. +* If it did, it means that deauthenticate/reauthenticate was +* called. In that case, this function doesn't need to enable encryption +*/ +mutex_lock (&hdcp_ctrl->state_mutex); +if (HDCP_STATE_AUTHENTICATING == hdcp_ctrl->hdcp_state) { + hdcp_ctrl->hdcp_state =HDCP_STATE_AUTHENTICATED ; + hdcp_ctrl->auth_retries =0 ;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 645
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* enable HDMI Encrypt */ +spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_CTRL ); + regval |=HDMI_CTRL_ENCRYPTED ; +hdmi_write (hdmi,REG_HDMI_CTRL , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); +mutex_unlock (&hdcp_ctrl->state_mutex); + }else { +mutex_unlock (&hdcp_ctrl->state_mutex);
Please move the mutex_unlock outside the if statement, and drop the else.
Quoted 64 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +64
-0+DBG ("HDCP state changed during authentication" ); + } +} + +/* +* hdcp authenticating part 1: 1st +* Wait Key/An ready +* Read BCAPS from sink +* Write BCAPS and AKSV into HDCP engine +* Write An and AKSV to sink +* Read BKSV from sink and write into HDCP engine +*/ +static int hdmi_hdcp_check_key_an_ready (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t link0_status, an_ready, keys_state; + + link0_status =hdmi_read (hdmi,REG_HDMI_HDCP_LINK0_STATUS ); +/* Wait for HDCP keys to be checked and validated */ + keys_state = (link0_status >>28 ) &0x7 ; +if (keys_state !=HDCP_KEYS_STATE_VALID ) { +DBG ("Keys not ready(%d). s=%d, l0=%0x08x" , + hdcp_ctrl->work_retry_cnt, + keys_state, link0_status); + +return -EAGAIN ; + } + +/* Wait for An0 and An1 bit to be ready */ + an_ready = (link0_status &BIT (8 )) && (link0_status &BIT (9 )); +if (!an_ready) { +DBG ("An not ready(%d). l0_status=0x%08x" , + hdcp_ctrl->work_retry_cnt, link0_status); + +return -EAGAIN ; + } + +return 0 ; +} + +static int hdmi_hdcp_send_aksv_an (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t link0_aksv_0, link0_aksv_1; +uint32_t link0_an_0, link0_an_1; +uint8_t aksv[5 ]; +uint8_t an[8 ]; + +/* Read An0 and An1 */ + link0_an_0 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA5 ); + link0_an_1 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA6 ); + +/* Read AKSV */ + link0_aksv_0 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA3 ); + link0_aksv_1 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA4 ); + +DBG ("Link ASKV=%08x%08x" , link0_aksv_0, link0_aksv_1); +/* Copy An and AKSV to byte arrays for transmission */ + aksv[0 ] = link0_aksv_0 &0xFF ; + aksv[1 ] = (link0_aksv_0 >>8 ) &0xFF ; + aksv[2 ] = (link0_aksv_0 >>16 ) &0xFF ; + aksv[3 ] = (link0_aksv_0 >>24 ) &0xFF ; + aksv[4 ] = link0_aksv_1 &0xFF ;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 719
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ + an[0 ] = link0_an_0 &0xFF ; + an[1 ] = (link0_an_0 >>8 ) &0xFF ; + an[2 ] = (link0_an_0 >>16 ) &0xFF ; + an[3 ] = (link0_an_0 >>24 ) &0xFF ; + an[4 ] = link0_an_1 &0xFF ; + an[5 ] = (link0_an_1 >>8 ) &0xFF ; + an[6 ] = (link0_an_1 >>16 ) &0xFF ; + an[7 ] = (link0_an_1 >>24 ) &0xFF ; +
Turn link0_an_{0,1} in an array of 2 u32 elements and possibly make sure that they are little endian and then just call hdmi_ddc_write(..., &link0_an, sizeof(link0_an));
Quoted 39 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +39
-0+/* Write An to offset 0x18 */ + rc =hdmi_ddc_write (hdmi,HDCP_PORT_ADDR ,0x18 , an,8 ); +if (rc) { +pr_err ("%s:An write failed\n" , __func__); +return rc; + } +DBG ("Link0-An=%08x%08x" , link0_an_1, link0_an_0); + +/* Write AKSV to offset 0x10 */ + rc =hdmi_ddc_write (hdmi,HDCP_PORT_ADDR ,0x10 , aksv,5 ); +if (rc) { +pr_err ("%s:AKSV write failed\n" , __func__); +return rc; + } +DBG ("Link0-AKSV=%02x%08x" , link0_aksv_1 &0xFF , link0_aksv_0); + +return 0 ; +} + +static int hdmi_hdcp_recv_bksv (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t link0_bksv_0, link0_bksv_1; +uint8_t *bksv =NULL ; +uint32_t reg[2 ], data[2 ]; + + bksv = hdcp_ctrl->bksv; + +/* Read BKSV at offset 0x00 */ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x00 , bksv,5 , true); +if (rc) { +pr_err ("%s:BKSV read failed\n" , __func__); +return rc; + } + +/* check there are 20 ones in BKSV */ +if (hdmi_hdcp_count_one (bksv,5 ) !=20 ) { +pr_err (": BKSV doesn't have 20 1's and 20 0's\n" );
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 768
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+pr_err (": BKSV chk fail. BKSV=%02x%02x%02x%02x%02x\n" , + bksv[4 ], bksv[3 ], bksv[2 ], bksv[1 ], bksv[0 ]); +return -EINVAL ; + } + + link0_bksv_0 = bksv[3 ]; + link0_bksv_0 = (link0_bksv_0 <<8 ) | bksv[2 ]; + link0_bksv_0 = (link0_bksv_0 <<8 ) | bksv[1 ]; + link0_bksv_0 = (link0_bksv_0 <<8 ) | bksv[0 ]; + link0_bksv_1 = bksv[4 ];
Either read these straight into two u32, or at least do:
a = bksv[4];
b = bksv[3] << 24;
b |= bksv[2] << 16; b |= bksv[1] << 8; b |= bksv[0];
Quoted 22 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +22
-0+DBG (":BKSV=%02x%08x" , link0_bksv_1, link0_bksv_0); + +/* Write BKSV read from sink to HDCP registers */ + reg[0 ] =REG_HDMI_HDCP_RCVPORT_DATA0 ; + data[0 ] = link0_bksv_0; + reg[1 ] =REG_HDMI_HDCP_RCVPORT_DATA1 ; + data[1 ] = link0_bksv_1; + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, reg, data,2 ); + +return rc; +} + +static int hdmi_hdcp_recv_bcaps (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint32_t reg, data; +uint8_t bcaps; + + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x40 , &bcaps,1 , true); +if (rc) { +pr_err ("%s:BCAPS read failed\n" , __func__);
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 800
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+return rc; + } +DBG ("BCAPS=%02x" , bcaps); + +/* receiver (0), repeater (1) */ + hdcp_ctrl->ds_type = (bcaps &BIT (6 )) ?DS_REPEATER :DS_RECEIVER ; + +/* Write BCAPS to the hardware */ + reg =REG_HDMI_HDCP_RCVPORT_DATA12 ; + data = (uint32_t )bcaps;
Just move these into the function call...
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +5
-0+ rc =hdmi_hdcp_scm_wr (hdcp_ctrl, ®, &data,1 ); + +return rc; +} +
[..]
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +8
-0+ +/* +* hdcp authenticating part 2: 1st +* wait until sink (repeater)'s ksv fifo ready +* read bstatus from sink and write to HDCP engine +*/ +static int hdmi_hdcp_recv_bstatus (struct hdmi_hdcp_ctrl *hdcp_ctrl, +uint8_t bcaps)
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 974
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+{ +int rc; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint16_t bstatus; +bool max_devs_exceeded = false, max_cascade_exceeded = false; +uint32_t repeater_cascade_depth =0 , down_stream_devices =0 ; +uint32_t reg, data; +uint8_t buf[2 ]; + +memset (buf,0 ,sizeof (buf));
If read returns okay buf should have been written to, so this should not be needed.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 983
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+ +/* Read BSTATUS at offset 0x41 */ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x41 , buf,2 , false); +if (rc) { +pr_err ("%s: BSTATUS read failed\n" , __func__); + goto error; + } + bstatus = buf[1 ]; + bstatus = (bstatus <<8 ) | buf[0 ];
bstatus = buf[1] << 8 | buf[0];
Quoted 1 line
+
[..]
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +2
-0+} +
[..]
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1108
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* +* hdcp authenticating part 2: 2nd +* read ksv fifo from sink +* transfer V' from sink to HDCP engine +* reset SHA engine +*/ +int hdmi_hdcp_read_v (struct hdmi *hdmi,char *name, +uint32_t off,uint32_t *val) +{
You can replace this entire function with:
hdmi_dcc_read(hdmi, HDCP_PORT_ADDR, off, val, sizeof(*val), true);
Quoted 23 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +23
-0+int rc =0 ; +uint8_t buf[4 ]; + + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR , off, buf,4 , true); +if (rc) { +pr_err ("%s: Read %s failed\n" , __func__, + name); +return rc; + } + +if (val) + *val = (buf[3 ] <<24 | buf[2 ] <<16 | buf[1 ] <<8 | buf[0 ]); + +DBG ("%s: buf[0]=%x, buf[1]=%x, buf[2]=%x, buf[3]=%x" , name, + buf[0 ], buf[1 ], buf[2 ], buf[3 ]); + +return rc; +} + +static int hdmi_hdcp_transfer_v_h (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +int rc =0 ;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1141
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+struct hdmi_hdcp_reg_data reg_data[] = { + {REG_HDMI_HDCP_RCVPORT_DATA7 ,0x20 ,"V' H0" }, + {REG_HDMI_HDCP_RCVPORT_DATA8 ,0x24 ,"V' H1" }, + {REG_HDMI_HDCP_RCVPORT_DATA9 ,0x28 ,"V' H2" }, + {REG_HDMI_HDCP_RCVPORT_DATA10 ,0x2C ,"V' H3" }, + {REG_HDMI_HDCP_RCVPORT_DATA11 ,0x30 ,"V' H4" }, + }; +struct hdmi_hdcp_reg_data *rd; +uint32_t size =ARRAY_SIZE (reg_data); +uint32_t reg[ARRAY_SIZE (reg_data)], data[ARRAY_SIZE (reg_data)];
Move the data variable to it's own line to make things easier to read.
Quoted 19 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +19
-0+int i; + +for (i =0 ; i < size; i++) { + rd = ®_data[i]; + rc =hdmi_hdcp_read_v (hdmi, rd->name, + rd->off, &data[i]); +if (rc) + goto error; + + reg[i] = reg_data[i].reg_id; + } + + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, reg, data, size); + +error: +return rc; +} + +static int hdmi_hdcp_recv_ksv_fifo (struct hdmi_hdcp_ctrl *hdcp_ctrl)
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1170
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+{ +int rc; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +uint8_t *ksv_fifo =NULL ; +uint32_t ksv_bytes; + + ksv_fifo = hdcp_ctrl->ksv_list; + ksv_bytes =5 * hdcp_ctrl->dev_count; +memset (ksv_fifo,0 , +sizeof (hdcp_ctrl->ksv_list));
Drop the local ksv_fifo and
memset(hdcp_ctrl->ksv_list, 0, sizeof(hdcp_ctrl->ksv_list));
as well as passing hdcp_ctrl->ksv_list to hdmi_ddc_read directly.
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x43 , + ksv_fifo, ksv_bytes, true); +if (rc) +pr_err ("%s: KSV FIFO read failed\n" , __func__); + +return rc; +} +
[..]
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1418
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+int hdmi_hdcp_on (struct hdmi *hdmi) +{ +struct hdmi_hdcp_ctrl *hdcp_ctrl = hdmi->hdcp_ctrl; +uint32_t regval; +unsigned long flags; + +if (!hdcp_ctrl) { +pr_warn ("%s:hdcp_ctrl is NULL\n" , __func__); +return 0 ;
There's little point in having a return value if you return success no matter what.
Quoted 39 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +39
-0+ } + +if (HDCP_STATE_INACTIVE != hdcp_ctrl->hdcp_state) { +DBG ("still active or activating. returning" ); +return 0 ; + } + +/* clear HDMI Encrypt */ +spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_CTRL ); + regval &= ~HDMI_CTRL_ENCRYPTED ; +hdmi_write (hdmi,REG_HDMI_CTRL , regval); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_AUTHENTICATING ; +mutex_unlock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->auth_retries =0 ; +queue_work (hdmi->workq, &hdcp_ctrl->hdcp_auth_prepare_work); + +return 0 ; +} + +void hdmi_hdcp_off (struct hdmi *hdmi) +{ +struct hdmi_hdcp_ctrl *hdcp_ctrl = hdmi->hdcp_ctrl; +unsigned long flags; +uint32_t regval; +int rc =0 ; + +if (!hdcp_ctrl) { +pr_err ("%s:hdcp_ctrl is NULL\n" , __func__); +return ; + } + +if (HDCP_STATE_INACTIVE == hdcp_ctrl->hdcp_state) { +DBG ("hdcp inactive. returning" ); +return ; + }
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1467
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ +/* +* Disable HPD circuitry. +* This is needed to reset the HDCP cipher engine so that when we +* attempt a re-authentication, HW would clear the AN0_READY and +* AN1_READY bits in HDMI_HDCP_LINK0_STATUS register +*/ +spin_lock_irqsave (&hdmi->reg_lock, flags); +hdmi_write (hdmi,REG_HDMI_HPD_CTRL , +hdmi_read (hdmi,REG_HDMI_HPD_CTRL ) & ~BIT (28 ));
Split into:
val = read();
val &= ~BIT(28);
write(val);
Please put 28 in a define with a sane name related to HDP circuitry...
Quoted 32 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +32
-0+ +/* +* Disable HDCP interrupts. +* Also, need to set the state to inactive here so that any ongoing +* reauth works will know that the HDCP session has been turned off. +*/ +hdmi_write (hdmi,REG_HDMI_HDCP_INT_CTRL ,0 ); +spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +/* +* Cancel any pending auth/reauth attempts. +* If one is ongoing, this will wait for it to finish. +* No more reauthentication attempts will be scheduled since we +* set the current state to inactive. +*/ + rc =cancel_work_sync (&hdcp_ctrl->hdcp_auth_prepare_work); +if (rc) +DBG ("Deleted hdcp auth prepare work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_reauth_work); +if (rc) +DBG ("Deleted hdcp reauth work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part1_1_work); +if (rc) +DBG ("Deleted hdcp auth part1_1 work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part1_2_work); +if (rc) +DBG ("Deleted hdcp auth part1_2 work" ); + rc =cancel_work_sync (&hdcp_ctrl->hdcp_auth_part1_3_work); +if (rc) +DBG ("Deleted hdcp auth part1_3 work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part2_1_work); +if (rc)
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1509
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+DBG ("Deleted hdcp auth part2_1 work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part2_2_work); +if (rc) +DBG ("Deleted hdcp auth part2_2 work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part2_3_work); +if (rc) +DBG ("Deleted hdcp auth part2_3 work" ); + rc =cancel_delayed_work_sync (&hdcp_ctrl->hdcp_auth_part2_4_work); +if (rc) +DBG ("Deleted hdcp auth part2_4 work" );
Just drop all these debug printouts, they don't add anything but clutter.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1514
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +5
-0+ +/* set state to inactive after all work cancelled */ +mutex_lock (&hdcp_ctrl->state_mutex); + hdcp_ctrl->hdcp_state =HDCP_STATE_INACTIVE ; +mutex_unlock (&hdcp_ctrl->state_mutex);
You shouldn't have to lock here, your workers are dead.
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +4
-0+ +hdmi_write (hdmi,REG_HDMI_HDCP_RESET ,BIT (0 )); + +/* Disable encryption and disable the HDCP block */
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1528
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+hdmi_write (hdmi,REG_HDMI_HDCP_CTRL ,0 ); + +spin_lock_irqsave (&hdmi->reg_lock, flags); + regval =hdmi_read (hdmi,REG_HDMI_CTRL ); + regval &= ~HDMI_CTRL_ENCRYPTED ; +hdmi_write (hdmi,REG_HDMI_CTRL , regval); + +/* Enable HPD circuitry */ +hdmi_write (hdmi,REG_HDMI_HPD_CTRL , +hdmi_read (hdmi,REG_HDMI_HPD_CTRL ) |BIT (28 ));
Split it into:
val = read()
val |= BIT(28);
write(val);
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1532
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +4
-0+spin_unlock_irqrestore (&hdmi->reg_lock, flags); + +DBG ("HDCP: Off" ); +}/* hdmi_hdcp_off */
Remove the comment.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1545
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+ +struct hdmi_hdcp_ctrl *hdmi_hdcp_init (struct hdmi *hdmi) +{ +uint32_t scm_buf =TZ_HDCP_CMD_ID ; +struct hdmi_hdcp_ctrl *hdcp_ctrl; +uint32_t ret =0 ; +uint32_t resp =0 ; + +if (!hdmi->qfprom_mmio) { +pr_err ("%s: HDCP is not supported without qfprom\n" , + __func__); + ret = -EINVAL ; + goto fail;
Just return here directly.
Quoted 16 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +16
-0+ } + + hdcp_ctrl =kzalloc (sizeof (*hdcp_ctrl),GFP_KERNEL ); +if (!hdcp_ctrl) { + ret = -ENOMEM ; + goto fail; + } + +INIT_WORK (&hdcp_ctrl->hdcp_auth_prepare_work, + hdmi_hdcp_auth_prepare_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_reauth_work, hdmi_hdcp_reauth_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part1_1_work, + hdmi_hdcp_auth_part1_1_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part1_2_work, + hdmi_hdcp_auth_part1_2_work); + INIT_WORK(&hdcp_ctrl->hdcp_auth_part1_3_work,
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1571
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ hdmi_hdcp_auth_part1_3_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part2_1_work, + hdmi_hdcp_auth_part2_1_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part2_2_work, + hdmi_hdcp_auth_part2_2_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part2_3_work, + hdmi_hdcp_auth_part2_3_work); +INIT_DELAYED_WORK (&hdcp_ctrl->hdcp_auth_part2_4_work, + hdmi_hdcp_auth_part2_4_work); +
As I stated before, replace all these steps with one worker function that does something like:
{
if (state == AUTHENTICATED)re_auth();
auth_prepare();
msleep(500);
while (auth_part_1_1() == -EAGAIN)
msleep(20);
msleep(160);
auth_part_1_2();
...
}
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1578
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +7
-0+ hdcp_ctrl->hdmi = hdmi; + hdcp_ctrl->hdcp_state =HDCP_STATE_INACTIVE ; +mutex_init (&hdcp_ctrl->state_mutex); + hdcp_ctrl->aksv_valid = false; + + ret =scm_call (SCM_SVC_INFO ,SCM_CMD_HDCP , &scm_buf, +sizeof (scm_buf), &resp,sizeof (resp));
You're calling command 1 on SCM_SVC_INFO, this is not SCM_CMD_HDCP but rather IS_CALL_AVAIL_CMD. The parameter, 0x00004401, is 17 << 10 | 1; meaning service 17 command 1.
You should use [1] and replace this with:
ret = scm_is_call_available(SCM_SVC_HDCP, SCM_CMD_HDCP);
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1583
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +5
-0+if (ret) { +pr_err ("%s: error: scm_call ret = %d, resp = %d\n" , + __func__, ret, resp); + goto fail; + }else {
There's no need for the else here, as you just goto'ed.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1592
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+DBG ("tz_hdcp = %d" , resp); + hdcp_ctrl->tz_hdcp = resp; + } + +return hdcp_ctrl; +fail: +kfree (hdcp_ctrl); +return ERR_PTR (ret); +}/* hdmi_hdcp_init */
Drop the comment.
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1600
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +8
-0+ +void hdmi_hdcp_destroy (struct hdmi *hdmi) +{ +if (hdmi && hdmi->hdcp_ctrl) { +kfree (hdmi->hdcp_ctrl); + hdmi->hdcp_ctrl =NULL ; + } +}
[1] https://lkml.org/lkml/2014/8/4/768
Regards,
Bjorn
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 19 lines · Bjorn Andersson
Quoted 4 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
Signed-off-by Jilai Wang <[email protected]>---
Hi Jilai,
[..]
Quoted 1 line
drivers/gpu/drm/msm/hdmi/hdmi.c +0
-0[..]
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +0
-0@@ -119,6 +137,22 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; }
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 142
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+/* HDCP needs physical address of hdmi register */ + res =platform_get_resource_byname (pdev,IORESOURCE_MEM , + config->mmio_name);Is this guaranteed to be available at all times? You should probably do some error handling here.
Hi Bjorn,
(as mentioned on irc, but just repeating here for posterity)
this is actually ok in this case, since the previous ioremap would have failed.
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 145
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ hdmi->mmio_phy_addr = res->start; + +if (config->qfprom_mmio_name) {Should this check really be here? This will always be set if
CONFIG_OFis set and never otherwise and that seems strange to me.Perhaps you should add the string to the !CONFIG_OF platforms as well or simply add #ifdef
CONFIG_OFaround this section if that's what you really want. (but seems more like you forgot the non-of case).
or just not cared enough to make HDCP (since it is optional) work on old pre-DT vendor kernel ;-)
fwiw, eventually the !CONFIG_OF stuff will go away.. it just exists because some devices and some use-cases still need old downstream kernels :-(
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 147
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +2
-0+ hdmi->qfprom_mmio =msm_ioremap (pdev, + config->qfprom_mmio_name,"HDMI_QFPROM" );Is this a special hdmi qfprom or are you ioremapping _the_ qfprom here?
If so I did suggest that we expose it as a syscon but I think Stephen Boyd had some other ideas.
afaict (but Jilai can correct me), it is *the* qfprom.. that seems to be how things worked in android kernels. Some better mechanism would be really nice.
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 153
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +6
-0+if (IS_ERR (hdmi->qfprom_mmio)) { +dev_info (&pdev->dev,"can't find qfprom resource\n" ); + hdmi->qfprom_mmio =NULL ; + } + }else { + hdmi->qfprom_mmio =NULL ;
hdmi_qfprom_read()seems to be called and read fromqfprom_mmiono matter how this ended. Are you sure this (both error paths) shouldn't be handled as a fatal error?
hdmi_hdcp_init() fails (and then we continue without HDCP) if qfprom_mmio is NULL..
Quoted 16 lines
'hdmi' is kzalloc and hence already NULL.
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 248
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0@@ -205,6 +241,13 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; } + hdmi->hdcp_ctrl =hdmi_hdcp_init (hdmi); +if (IS_ERR (hdmi->hdcp_ctrl)) { + ret =PTR_ERR (hdmi->hdcp_ctrl); +dev_warn (dev->dev,"failed to init hdcp: %d(disabled)\n" , ret); + hdmi->hdcp_ctrl =NULL ;So either you treat this as an error or you don't.
Quoted 3 lines
If you're fine continuing execution without
hdcp_ctrlthen you shouldn't set ret. But in that case it you should probably not print a warning every time you enterhdmi_hdcp_on()and an error onhdmi_hdcp_off().
agreed, I think it would be better for hdcp_on/off() to take struct hdmi_hdcp_ctrl as param (and just not be called if hdmi->hdcp_ctrl is null)
[snip]
Quoted 7 lines
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ +struct hdmi_hdcp_reg_data { +uint32_t reg_id;You should use u32 instead of
uint32_tin the kernel.
tbh, I'd prefer sticking to stdint types.. before stdint was a thing, u32 made sense
Quoted 29 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +9
-0+uint32_t off; +char *name; +uint32_t reg_val; +}; + +struct hdmi_hdcp_ctrl { +struct hdmi *hdmi; +uint32_t auth_retries; +uint32_t tz_hdcp;Turn this into a bool named something like
has_tz_hdcpinstead, as that's what it really means.drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;You shouldn't use "work" as a way to express states in your state machine. Better have 1 auth work function that does all these steps, probably having them split in functions just like you do now.
Quoted 7 lines
That way you can have 1 function running the pass of authentication, starting by checking if you're reauthing or not then processing each step one by one, sleeping inbetween them. You can have the functions return
-EAGAINto indicate that you need to retry the current operation and so on.This would split the state machine from the state executioners and simplify your code.
As a side note (disclaimer, I'm not an hdcp expert), but I wonder if eventually some of that should be extracted out into some helpers in drm core. I guess that is something we'll figure out when a 2nd driver gains upstream HDCP support. One big work w/ msleep()'s does sound like it would be easier to understand (and therefore easier to refactor out into helpers).
[snip]
Quoted 15 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+ +static int hdmi_hdcp_scm_wr (struct hdmi_hdcp_ctrl *hdcp_ctrl,uint32_t *preg, +uint32_t *pdata,uint32_t count) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +struct scm_hdcp_req scm_buf[SCM_HDCP_MAX_REG ]; +uint32_t resp, phy_addr, idx =0 ; +int i, ret =0 ; + +if (count ==0 ) +return 0 ;There are no calls to this function where count can be 0, so you can drop this check.
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0+ +if (!preg || !pdata) { +pr_err ("%s: Invalid pointer\n" , __func__); +return -EINVAL ; + }There are no calls to this function where either of these are NULL, so you can drop the entire block.
or just WARN_ON() (for both this and the count).. I find that makes the constraints more clear for someone coming along later and mucking with that code
Quoted 49 lines
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ +if (hdcp_ctrl->tz_hdcp) { + phy_addr = (uint32_t )hdmi->mmio_phy_addr;drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+ +while (count) { +memset (scm_buf,0 ,sizeof (scm_buf)); +for (i =0 ; i < count && i <SCM_HDCP_MAX_REG ; i++) { + scm_buf[i].addr = phy_addr + preg[idx]; + scm_buf[i].val = pdata[idx]; + idx++; + } + ret =scm_call (SCM_SVC_HDCP ,SCM_CMD_HDCP , + scm_buf,sizeof (scm_buf), &resp,sizeof (resp));
SCM_SVC_HDCPnorSCM_CMD_HDCPare defined, here. See the comment above related toTZ_HDCP_CMD_ID.Quoted 18 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +18
-0+ +if (ret || resp) { +pr_err ("%s: error: scm_call ret = %d, resp = %d\n" , + __func__, ret, resp); + ret = -EINVAL ; +break ; + } + + count -= i; + } + }else { +for (i =0 ; i < count; i++) +hdmi_write (hdmi, preg[i], pdata[i]); + } + +return ret; +} +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi; +uint32_t regval, hdcp_int_status; +unsigned long flags; + +if (!hdcp_ctrl) { +DBG ("HDCP is disabled" ); +return ; + }No need to print a debug line here every time.
Quoted 2 lines
I would have preferred if you made the call from
hdmi_irq()conditional instead, then you would need to check here...
me too
[snip]
Quoted 92 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+static void reset_hdcp_ddc_failures (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int hdcp_ddc_ctrl1_reg; +int hdcp_ddc_status; +int failure; +int nack0; +struct hdmi *hdmi = hdcp_ctrl->hdmi; + +/* Check for any DDC transfer failures */ + hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + failure = (hdcp_ddc_status >>16 ) &0x1 ;failure =
hdcp_ddc_status& BIT(16);Quoted 1 line
+ nack0 = (
hdcp_ddc_status>> 14) &0x1;nack0 =
hdcp_ddc_status& BIT(14);Quoted 14 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +14
-0+DBG ("On Entry: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); + +if (failure ==0x1 ) { +/* +* Indicates that the last HDCP HW DDC transfer failed. +* This occurs when a transfer is attempted with HDCP DDC +* disabled (HDCP_DDC_DISABLE=1) or the number of retries +* matches HDCP_DDC_RETRY_CNT. +* Failure occurred, let's clear it. +*/ +DBG ("DDC failure detected.HDCP_DDC_STATUS=0x%08x" , + hdcp_ddc_status); +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+/* First, Disable DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,BIT (0 )); + +/* ACK the Failure to Clear it */ + hdcp_ddc_ctrl1_reg =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_CTRL_1 ); +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_1 , + hdcp_ddc_ctrl1_reg |BIT (0 )); + +/* Check if the FAILURE got Cleared */ + hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS );Replace the following lines with:
if (
hdcp_ddc_status& BIT(16))pr_info("%s: Unable to clear HDCP DDC Failure\n", __func__);No need to print the debug statement either...
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +7
-0+ hdcp_ddc_status = (hdcp_ddc_status >>16 ) &BIT (0 ); +if (hdcp_ddc_status ==0x0 ) +DBG ("HDCP DDC Failure cleared" ); +else +pr_info ("%s: Unable to clear HDCP DDC Failure\n" , + __func__); +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+/* Re-Enable HDCP DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,0 ); + } + +if (nack0 ==0x1 ) { +DBG ("Before: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); +/* Reset HDMI DDC software status */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (3 ));Split all these in:
val =hdmi_read()
val |= foohdmi_write(val);To make this readable.
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +4
-0+msleep (20 ); +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) & ~(BIT (3 ))); +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+/* Reset HDMI DDC Controller */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (1 )); +msleep (20 ); +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) & ~BIT (1 )); +DBG ("After: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); + } +Just end the function here, no need for the extra debug printouts...
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +7
-0+ hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + + failure = (hdcp_ddc_status >>16 ) &BIT (0 ); + nack0 = (hdcp_ddc_status >>14 ) &BIT (0 ); +DBG ("On Exit: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); +}
DBG() stuff can always be enabled at runtime.. and when it comes to failures seen with certain monitors, it is usually the monitor the user has and not the ones the developer has, which have fun bugs ;-)
So in general if it is something useful for debugging a failure, when you can just ask the user to 'echo 15 > /sys/modules/drm/parameters/debug' then plug in monitor and send dmesg, I don't mind keeping it.
BR,
-R
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Hi Bjorn,
Quoted 174 lines · Bjorn Andersson
Quoted 22 lines
Quoted 4 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
Signed-off-by Jilai Wang <[email protected]>---
Hi Jilai,
[..]
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +0
-0[..]
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +0
-0@@ -119,6 +137,22 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; }Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 142
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+/* HDCP needs physical address of hdmi register */ + res =platform_get_resource_byname (pdev,IORESOURCE_MEM , + config->mmio_name);Is this guaranteed to be available at all times? You should probably do some error handling here.
Hi Bjorn,
(as mentioned on irc, but just repeating here for posterity)
this is actually ok in this case, since the previous ioremap would have failed.
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 145
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ hdmi->mmio_phy_addr = res->start; + +if (config->qfprom_mmio_name) {Should this check really be here? This will always be set if
CONFIG_OFis set
and never otherwise and that seems strange to me.Quoted 5 lines
Perhaps you should add the string to the !CONFIG_OF platforms as well or simply
add #ifdefCONFIG_OFaround this section if that's what you really want. (but
seems more like you forgot the non-of case).or just not cared enough to make HDCP (since it is optional) work on old pre-DT vendor kernel ;-)
fwiw, eventually the !CONFIG_OF stuff will go away.. it just exists because some devices and some use-cases still need old downstream kernels :-(
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 147
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +2
-0+ hdmi->qfprom_mmio =msm_ioremap (pdev, + config->qfprom_mmio_name,"HDMI_QFPROM" );Is this a special hdmi qfprom or are you ioremapping _the_ qfprom here?
If so I did suggest that we expose it as a syscon but I think Stephen Boyd had
some other ideas.afaict (but Jilai can correct me), it is *the* qfprom.. that seems to be how things worked in android kernels. Some better mechanism would be really nice.
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) · line 153
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +6
-0+if (IS_ERR (hdmi->qfprom_mmio)) { +dev_info (&pdev->dev,"can't find qfprom resource\n"); + hdmi->qfprom_mmio =NULL ; + } + }else { + hdmi->qfprom_mmio =NULL ;Quoted 5 lines
hdmi_qfprom_read()seems to be called and read fromqfprom_mmiono matter how
this ended. Are you sure this (both error paths) shouldn't be handled as a
fatal error?
hdmi_hdcp_init()fails (and then we continue without HDCP) ifqfprom_mmiois NULL..Quoted 18 lines
'hdmi' is kzalloc and hence already NULL.
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c struct hdmi *hdmi_init(struct drm_device *dev, · line 250
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0@@ -205,6 +241,13 @@ struct hdmi *hdmi_init(struct drm_device *dev, struct drm_encoder *encoder) goto fail; } + hdmi->hdcp_ctrl =hdmi_hdcp_init (hdmi); +if (IS_ERR (hdmi->hdcp_ctrl)) { + ret =PTR_ERR (hdmi->hdcp_ctrl); + dev_warn(dev->dev, "failed to init hdcp: %d(disabled)\n", ret); + hdmi->hdcp_ctrl =NULL ;So either you treat this as an error or you don't.
Quoted 5 lines
If you're fine continuing execution without
hdcp_ctrlthen you shouldn't set
ret. But in that case it you should probably not print a warning every time you
enterhdmi_hdcp_on()and an error onhdmi_hdcp_off().agreed, I think it would be better for hdcp_on/off() to take struct
hdmi_hdcp_ctrlas param (and just not be called ifhdmi->hdcp_ctrlis null)[snip]
Quoted 7 lines
[..]
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 3 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ +struct hdmi_hdcp_reg_data { +uint32_t reg_id;You should use u32 instead of
uint32_tin the kernel.tbh, I'd prefer sticking to stdint types.. before stdint was a thing, u32 made sense
Quoted 40 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +9
-0+uint32_t off; +char *name; +uint32_t reg_val; +}; + +struct hdmi_hdcp_ctrl { +struct hdmi *hdmi; +uint32_t auth_retries; +uint32_t tz_hdcp;Turn this into a bool named something like
has_tz_hdcpinstead, as that's what
it really means.drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;You shouldn't use "work" as a way to express states in your state machine.
Better have 1 auth work function that does all these steps, probably having
them split in functions just like you do now.That way you can have 1 function running the pass of authentication, starting
by checking if you're reauthing or not then processing each step one by one,
sleeping inbetween them. You can have the functions return-EAGAINto indicate
that you need to retry the current operation and so on.Quoted 3 lines
This would split the state machine from the state executioners and simplify
your code.
Quoted 9 lines
As a side note (disclaimer, I'm not an hdcp expert), but I wonder if eventually some of that should be extracted out into some helpers in drm core. I guess that is something we'll figure out when a 2nd driver gains upstream HDCP support. One big work w/ msleep()'s does sound like it would be easier to understand (and therefore easier to refactor out into helpers).
[snip]
The reason that I break the partI/PartII work into these small works because I want to avoid to use msleep in work.
Otherwise cancel a HDCP work may cause long delay up to several seconds.
Quoted 209 lines
Quoted 23 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 12 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +2
-0+ +static int hdmi_hdcp_scm_wr(struct hdmi_hdcp_ctrl *hdcp_ctrl, uint32_t*preg,
drivers/gpu/drm/msm/hdmi/hdmi.c +9
-0+ uint32_t *pdata, uint32_t count) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +struct scm_hdcp_req scm_buf[SCM_HDCP_MAX_REG ]; +uint32_t resp, phy_addr, idx =0 ; +int i, ret =0 ; + +if (count ==0 ) +return 0 ;There are no calls to this function where count can be 0, so you can drop this
check.drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0+ +if (!preg || !pdata) { +pr_err ("%s: Invalid pointer\n" , __func__); +return -EINVAL ; + }Quoted 3 lines
There are no calls to this function where either of these are NULL, so you can
drop the entire block.or just
WARN_ON()(for both this and the count).. I find that makes the constraints more clear for someone coming along later and mucking with that codeQuoted 53 lines
Quoted 15 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +7
-0+ +if (hdcp_ctrl->tz_hdcp) { + phy_addr = (uint32_t )hdmi->mmio_phy_addr; + +while (count) { +memset (scm_buf,0 ,sizeof (scm_buf)); + for (i = 0; i < count && i < SCM_HDCP_MAX_REG;i++) {
drivers/gpu/drm/msm/hdmi/hdmi.c +6
-0+ scm_buf[i].addr = phy_addr + preg[idx]; + scm_buf[i].val = pdata[idx]; + idx++; + } + ret = scm_call(SCM_SVC_HDCP, SCM_CMD_HDCP, + scm_buf, sizeof(scm_buf), &resp,Quoted 1 line
sizeof(resp));
SCM_SVC_HDCPnorSCM_CMD_HDCPare defined, here. See the comment above related
toTZ_HDCP_CMD_ID.Quoted 19 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+ +if (ret || resp) { + pr_err("%s: error: scm_call ret = %d,resp = %d\n",
drivers/gpu/drm/msm/hdmi/hdmi.c +15
-0+ __func__, ret, resp); + ret = -EINVAL ; +break ; + } + + count -= i; + } + }else { +for (i =0 ; i < count; i++) +hdmi_write (hdmi, preg[i], pdata[i]); + } + +return ret; +} +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi; +uint32_t regval, hdcp_int_status; +unsigned long flags; + +if (!hdcp_ctrl) { +DBG ("HDCP is disabled" ); +return ; + }No need to print a debug line here every time.
Quoted 2 lines
I would have preferred if you made the call from
hdmi_irq()conditional instead, then you would need to check here...me too
[snip]
Quoted 98 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+static void reset_hdcp_ddc_failures (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int hdcp_ddc_ctrl1_reg; +int hdcp_ddc_status; +int failure; +int nack0; +struct hdmi *hdmi = hdcp_ctrl->hdmi; + +/* Check for any DDC transfer failures */ + hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + failure = (hdcp_ddc_status >>16 ) &0x1 ;failure =
hdcp_ddc_status& BIT(16);Quoted 1 line
+ nack0 = (
hdcp_ddc_status>> 14) &0x1;nack0 =
hdcp_ddc_status& BIT(14);Quoted 27 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +7
-0+DBG ("On Entry: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); + +if (failure ==0x1 ) { +/* +* Indicates that the last HDCP HW DDC transfer failed. +* This occurs when a transfer is attempted with HDCP DDC
+ * disabled (HDCP_DDC_DISABLE=1) or the number of
retriesdrivers/gpu/drm/msm/hdmi/hdmi.c +11
-0+* matches HDCP_DDC_RETRY_CNT. +* Failure occurred, let's clear it. +*/ +DBG ("DDC failure detected.HDCP_DDC_STATUS=0x%08x" , + hdcp_ddc_status); + +/* First, Disable DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,BIT (0 )); + +/* ACK the Failure to Clear it */ + hdcp_ddc_ctrl1_reg = hdmi_read(hdmi,
REG_HDMI_HDCP_DDC_CTRL_1);drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0+hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_1 , + hdcp_ddc_ctrl1_reg |BIT (0 )); + +/* Check if the FAILURE got Cleared */ + hdcp_ddc_status = hdmi_read(hdmi,Quoted 1 line
REG_HDMI_HDCP_DDC_STATUS);Replace the following lines with:
if (
hdcp_ddc_status& BIT(16))pr_info("%s: Unable to clear HDCP DDC Failure\n", __func__);No need to print the debug statement either...
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +5
-0+ hdcp_ddc_status = (hdcp_ddc_status >>16 ) &BIT (0 ); +if (hdcp_ddc_status ==0x0 ) +DBG ("HDCP DDC Failure cleared" ); +else + pr_info("%s: Unable to clear HDCP DDCFailure\n",
drivers/gpu/drm/msm/hdmi/hdmi.c +2
-0+ __func__); +drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+/* Re-Enable HDCP DDC */ +hdmi_write (hdmi,REG_HDMI_HDCP_DDC_CTRL_0 ,0 ); + } + +if (nack0 ==0x1 ) { +DBG ("Before: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); +/* Reset HDMI DDC software status */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (3 ));Split all these in:
val =hdmi_read()
val |= foohdmi_write(val);To make this readable.
Quoted 5 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +3
-0+msleep (20 ); + hdmi_write(hdmi, REG_HDMI_DDC_CTRL, + hdmi_read(hdmi, REG_HDMI_DDC_CTRL) &~(BIT(3)));
drivers/gpu/drm/msm/hdmi/hdmi.c +1
-0+drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +10
-0+/* Reset HDMI DDC Controller */ +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) |BIT (1 )); +msleep (20 ); +hdmi_write (hdmi,REG_HDMI_DDC_CTRL , +hdmi_read (hdmi,REG_HDMI_DDC_CTRL ) & ~BIT (1 )); +DBG ("After: HDMI_DDC_SW_STATUS=0x%08x" , +hdmi_read (hdmi,REG_HDMI_DDC_SW_STATUS )); + } +Just end the function here, no need for the extra debug printouts...
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c
Quoted 7 lines
drivers/gpu/drm/msm/hdmi/hdmi.c +7
-0+ hdcp_ddc_status =hdmi_read (hdmi,REG_HDMI_HDCP_DDC_STATUS ); + + failure = (hdcp_ddc_status >>16 ) &BIT (0 ); + nack0 = (hdcp_ddc_status >>14 ) &BIT (0 ); +DBG ("On Exit: HDCP_DDC_STATUS=0x%x, FAIL=%d, NACK0=%d" , + hdcp_ddc_status, failure, nack0); +}
DBG()stuff can always be enabled at runtime.. and when it comes to failures seen with certain monitors, it is usually the monitor the user has and not the ones the developer has, which have fun bugs ;-)So in general if it is something useful for debugging a failure, when you can just ask the user to 'echo 15 >
/sys/modules/drm/parameters/debug' then plug in monitor and send dmesg, I don't mind keeping it.BR,
-R
Quoted 37 lines · On Wed, Dec 3, 2014 at 12:16 PM, <[email protected]> wrote:
Quoted 37 lines
Quoted 26 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 68
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;You shouldn't use "work" as a way to express states in your state machine.
Better have 1 auth work function that does all these steps, probably having
them split in functions just like you do now.That way you can have 1 function running the pass of authentication, starting
by checking if you're reauthing or not then processing each step one by one,
sleeping inbetween them. You can have the functions return-EAGAINto indicate
that you need to retry the current operation and so on.Quoted 3 lines
This would split the state machine from the state executioners and simplify
your code.As a side note (disclaimer, I'm not an hdcp expert), but I wonder if eventually some of that should be extracted out into some helpers in drm core. I guess that is something we'll figure out when a 2nd driver gains upstream HDCP support. One big work w/ msleep()'s does sound like it would be easier to understand (and therefore easier to refactor out into helpers).
Quoted 6 lines
Quoted 2 lines
[snip]
The reason that I break the partI/PartII work into these small works because I want to avoid to use msleep in work.
Otherwise cancel a HDCP work may cause long delay up to several seconds.
hmm, yeah, several seconds is long enough for user to plug/unplug several displays ;-)
But I guess a wait_event_timeout() plus a wq that is signalled on hpd (or whenever we need to cancel) instead of msleep might do the trick?
BR,
-R
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
On Wed, Dec 3, 2014 at 9:16 AM, <[email protected]> wrote:
[..]
Quoted 37 lines
Quoted 37 lines
Quoted 26 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 68
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;You shouldn't use "work" as a way to express states in your state machine.
Better have 1 auth work function that does all these steps, probably having
them split in functions just like you do now.That way you can have 1 function running the pass of authentication, starting
by checking if you're reauthing or not then processing each step one by one,
sleeping inbetween them. You can have the functions return-EAGAINto indicate
that you need to retry the current operation and so on.Quoted 3 lines
This would split the state machine from the state executioners and simplify
your code.As a side note (disclaimer, I'm not an hdcp expert), but I wonder if eventually some of that should be extracted out into some helpers in drm core. I guess that is something we'll figure out when a 2nd driver gains upstream HDCP support. One big work w/ msleep()'s does sound like it would be easier to understand (and therefore easier to refactor out into helpers).
Quoted 7 lines
Quoted 2 lines
[snip]
The reason that I break the partI/PartII work into these small works because I want to avoid to use msleep in work.
Otherwise cancel a HDCP work may cause long delay up to several seconds.
I definitely think the steps are nice size and make things easy to understand.
If you make the steps that require a retry return out to the main state handling function with a -EAGAIN, then you can have check if you should retry or abort based on cancellation. Giving you the worst case cancellation time of the longest sleep...
As Rob suggest you could use wait_event_timeout() or something to improve this, but on the other hand the worst case here seems to be the HZ/2 after prepare_auth; others are HZ/8, HZ/20 and HZ/50; not "seconds".
So I would start with a simple msleep() for implementation simplicity and then enhance that in a follow up commit (if needed)...
Regards,
Bjorn
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 61 lines · On Wed, Dec 3, 2014 at 9:16 AM, <[email protected]> wrote:
[..]
Quoted 38 lines
Quoted 38 lines
Quoted 27 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 68
Quoted 11 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +11
-0+enum hdmi_hdcp_state hdcp_state; +struct mutex state_mutex; +struct delayed_work hdcp_reauth_work; +struct delayed_work hdcp_auth_part1_1_work; +struct delayed_work hdcp_auth_part1_2_work; +struct work_struct hdcp_auth_part1_3_work; +struct delayed_work hdcp_auth_part2_1_work; +struct delayed_work hdcp_auth_part2_2_work; +struct delayed_work hdcp_auth_part2_3_work; +struct delayed_work hdcp_auth_part2_4_work; +struct work_struct hdcp_auth_prepare_work;You shouldn't use "work" as a way to express states in your state machine.
Better have 1 auth work function that does all these steps, probably having
them split in functions just like you do now.That way you can have 1 function running the pass of authentication, starting
by checking if you're reauthing or not then processing each step one by
one,
sleeping inbetween them. You can have the functions return-EAGAINto indicate
that you need to retry the current operation and so on.Quoted 3 lines
This would split the state machine from the state executioners and simplify
your code.As a side note (disclaimer, I'm not an hdcp expert), but I wonder if eventually some of that should be extracted out into some helpers in drm core. I guess that is something we'll figure out when a 2nd driver gains upstream HDCP support. One big work w/ msleep()'s does sound like it would be easier to understand (and therefore easier to refactor out into helpers).
Quoted 7 lines
Quoted 2 lines
[snip]
The reason that I break the partI/PartII work into these small works because I want to avoid to use msleep in work.
Otherwise cancel a HDCP work may cause long delay up to several seconds.I definitely think the steps are nice size and make things easy to understand.
If you make the steps that require a retry return out to the main state handling function with a
-EAGAIN, then you can have check if you should retry or abort based on cancellation. Giving you the worst case cancellation time of the longest sleep...As Rob suggest you could use
wait_event_timeout()or something to improve this, but on the other hand the worst case here seems to be the HZ/2 afterprepare_auth; others are HZ/8, HZ/20 and HZ/50; not "seconds".
Quoted 6 lines
So I would start with a simple
msleep()for implementation simplicity and then enhance that in a follow up commit (if needed)...Regards,
Bjorn
The worst wait time could be 5 seconds if the downstream device is a REPEATER. The maximum retry time is set to 100 and the delay for each time is HZ/20, then the maximum wait time before abort will be 5 seconds. As you suggested, I can use the flag to notify the retry process to abort earlier in case this work needs to be canceled which can reduce the delay to HZ/20 then. Or as Rob's suggestion to wait for hpd event.
Thanks,
Jilai
PATCH 2/2 drm/msm/hdmi: add hdmi hdcp support (V2)
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.
--- drivers/gpu/drm/msm/Makefile | 1 + drivers/gpu/drm/msm/hdmi/hdmi.c | 45 +- drivers/gpu/drm/msm/hdmi/hdmi.h | 31 + drivers/gpu/drm/msm/hdmi/hdmi_audio.c | 1 - drivers/gpu/drm/msm/hdmi/hdmi_bridge.c | 8 +- drivers/gpu/drm/msm/hdmi/hdmi_connector.c | 7 +- drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c | 1445 +++++++++++++++++++++++++++++ 7 files changed, 1530 insertions(+), 8 deletions(-) create mode 100644 drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
drivers/gpu/drm/msm/Makefile +1 -0
@@ -12,6 +12,7 @@ msm-y := \ hdmi/hdmi_audio.o \ hdmi/hdmi_bridge.o \ hdmi/hdmi_connector.o \ + hdmi/hdmi_hdcp.o \ hdmi/hdmi_i2c.o \ hdmi/hdmi_phy_8960.o \ hdmi/hdmi_phy_8x60.o \
drivers/gpu/drm/msm/hdmi/hdmi.c +42 -3
130 lines not on this page · raw message
drivers/gpu/drm/msm/hdmi/hdmi.h +31 -0
@@ -37,6 +37,8 @@ struct hdmi_audio {int rate; }; +struct hdmi_hdcp_ctrl ; +struct hdmi {struct drm_device *dev;struct platform_device *pdev;
@@ -51,6 +53,8 @@ struct hdmi {unsigned long int pixclock;void __iomem *mmio; +void __iomem *qfprom_mmio; +phys_addr_t mmio_phy_addr;struct regulator **hpd_regs;struct regulator **pwr_regs;
@@ -68,12 +72,25 @@ struct hdmi {bool hdmi_mode;/* are we in hdmi mode? */ int irq; +struct workqueue_struct *workq; + +struct hdmi_hdcp_ctrl *hdcp_ctrl; + +/* +* spinlock to protect registers shared by different execution +* REG_HDMI_CTRL +* REG_HDMI_DDC_ARBITRATION +* REG_HDMI_HDCP_INT_CTRL +* REG_HDMI_HPD_CTRL +*/ +spinlock_t reg_lock; };/* platform config data (ie. from DT, or pdata) */ struct hdmi_platform_config {struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);const char *mmio_name; +const char *qfprom_mmio_name;/* regulators that need to be on for hpd: */ const char **hpd_reg_names;
@@ -109,6 +126,11 @@ static inline u32 hdmi_read(struct hdmi *hdmi, u32 reg)return msm_readl (hdmi->mmio + reg); } +static inline u32 hdmi_qfprom_read (struct hdmi *hdmi,u32 reg) +{ +return msm_readl (hdmi->qfprom_mmio + reg); +} +/* * The phy appears to be different, for example between 8960 and 8x60, * so split the phy related functions out and load the correct one at
@@ -162,4 +184,13 @@ void hdmi_i2c_irq(struct i2c_adapter *i2c);void hdmi_i2c_destroy (struct i2c_adapter *i2c);struct i2c_adapter *hdmi_i2c_init (struct hdmi *hdmi); +/* +* hdcp +*/ +struct hdmi_hdcp_ctrl *hdmi_hdcp_init (struct hdmi *hdmi); +void hdmi_hdcp_destroy (struct hdmi *hdmi); +void hdmi_hdcp_on (struct hdmi_hdcp_ctrl *hdcp_ctrl); +void hdmi_hdcp_off (struct hdmi_hdcp_ctrl *hdcp_ctrl); +void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl); +#endif /* __HDMI_CONNECTOR_H__ */
drivers/gpu/drm/msm/hdmi/hdmi_audio.c +0 -1
@@ -203,7 +203,6 @@ int hdmi_audio_update(struct hdmi *hdmi) audio_config |=HDMI_AUDIO_CFG_FIFO_WATERMARK (4 ); audio_config |=HDMI_AUDIO_CFG_ENGINE_ENABLE ; }else { -hdmi_write (hdmi,REG_HDMI_GC ,HDMI_GC_MUTE ); acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_CONT ; acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_SEND ; vbi_pkt_ctrl &= ~HDMI_VBI_PKT_CTRL_GC_ENABLE ;
drivers/gpu/drm/msm/hdmi/hdmi_bridge.c +6 -2
@@ -105,6 +105,9 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge) phy->funcs->powerup (phy, hdmi->pixclock);hdmi_set_mode (hdmi, true); + +if (hdmi->hdcp_ctrl) +hdmi_hdcp_on (hdmi->hdcp_ctrl); }static void hdmi_bridge_enable (struct drm_bridge *bridge)
@@ -121,6 +124,9 @@ static void hdmi_bridge_post_disable(struct drm_bridge *bridge)struct hdmi *hdmi = hdmi_bridge->hdmi;struct hdmi_phy *phy = hdmi->phy; +if (hdmi->hdcp_ctrl) +hdmi_hdcp_off (hdmi->hdcp_ctrl); +DBG ("power down" );hdmi_set_mode (hdmi, false); phy->funcs->powerdown (phy);
@@ -145,8 +151,6 @@ static void hdmi_bridge_mode_set(struct drm_bridge *bridge, hdmi->pixclock = mode->clock *1000 ; - hdmi->hdmi_mode =drm_match_cea_mode (mode) >1 ; - hstart = mode->htotal - mode->hsync_start; hend = mode->htotal - mode->hsync_start + mode->hdisplay;
drivers/gpu/drm/msm/hdmi/hdmi_connector.c +5 -2
@@ -140,6 +140,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector)struct hdmi_phy *phy = hdmi->phy;uint32_t hpd_ctrl;int i, ret; +unsigned long flags;for (i =0 ; i < config->hpd_reg_cnt; i++) { ret =regulator_enable (hdmi->hpd_regs[i]);
@@ -185,6 +186,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) HDMI_HPD_INT_CTRL_INT_EN);/* set timeout to 4.1ms (max) for hardware debounce */ +spin_lock_irqsave (&hdmi->reg_lock, flags); hpd_ctrl =hdmi_read (hdmi,REG_HDMI_HPD_CTRL ); hpd_ctrl |=HDMI_HPD_CTRL_TIMEOUT (0x1fff );
@@ -193,6 +195,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) ~HDMI_HPD_CTRL_ENABLE & hpd_ctrl);hdmi_write (hdmi,REG_HDMI_HPD_CTRL ,HDMI_HPD_CTRL_ENABLE | hpd_ctrl); +spin_unlock_irqrestore (&hdmi->reg_lock, flags);return 0 ;
@@ -239,7 +242,6 @@ hotplug_work(struct work_struct *work)void hdmi_connector_irq (struct drm_connector *connector) {struct hdmi_connector *hdmi_connector =to_hdmi_connector (connector); -struct msm_drm_private *priv = connector->dev->dev_private;struct hdmi *hdmi = hdmi_connector->hdmi;uint32_t hpd_int_status, hpd_int_ctrl;
@@ -263,7 +265,7 @@ void hdmi_connector_irq(struct drm_connector *connector) hpd_int_ctrl |=HDMI_HPD_INT_CTRL_INT_CONNECT ;hdmi_write (hdmi,REG_HDMI_HPD_INT_CTRL , hpd_int_ctrl); -queue_work (priv->wq, &hdmi_connector->hpd_work); +queue_work (hdmi->workq, &hdmi_connector->hpd_work); } }
@@ -339,6 +341,7 @@ static int hdmi_connector_get_modes(struct drm_connector *connector)hdmi_write (hdmi,REG_HDMI_CTRL , hdmi_ctrl); + hdmi->hdmi_mode =drm_detect_hdmi_monitor (edid);drm_mode_connector_update_edid_property (connector, edid);if (edid) {
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +1445 -0
1,445 lines not on this page · raw message
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH 2/2] drm/msm/hdmi: add hdmi hdcp support (V2)
Quoted 6 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.
Looks cleaner and the SCM parts look good now.
But the ddc communication still makes me wonder, see below.
[..]
Quoted 1 line
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +0
-0
[..]
Quoted 26 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +26
-0+ +static int hdmi_ddc_read (struct hdmi *hdmi,u16 addr,u8 offset, +u8 *data,u16 data_len) +{ +int rc; +int retry =5 ; +struct i2c_msg msgs[] = { + { + .addr = addr >>1 , + .flags =0 , + .len =1 , + .buf = &offset, + }, { + .addr = addr >>1 , + .flags =I2C_M_RD , + .len = data_len, + .buf = data, + } + }; + +DBG ("Start DDC read" ); +retry: + rc =i2c_transfer (hdmi->i2c, msgs,2 ); + + retry--; +if (rc ==2 )
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 129
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ rc =0 ; + else if (retry > 0) + goto retry; + else + rc = -EIO; + + DBG("End DDC read %d", rc); + + return rc; +}
Looking back and forth at this, to me this really looks like i2c_smbus_read_i2c_block_data().
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
Quoted 2 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +2
-0+ +#define HDCP_DDC_WRITE_MAX_BYTE_NUM 32
This matches I2C_SMBUS_BLOCK_MAX, indicating further that there's something in common here.
Quoted 30 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +30
-0+ +static int hdmi_ddc_write (struct hdmi *hdmi,u16 addr,u8 offset, +u8 *data,u16 data_len) +{ +int rc; +int retry =10 ; +u8 buf[HDCP_DDC_WRITE_MAX_BYTE_NUM ]; +struct i2c_msg msgs[] = { + { + .addr = addr >>1 , + .flags =0 , + .len =1 , + } + }; + +DBG ("Start DDC write" ); +if (data_len > (HDCP_DDC_WRITE_MAX_BYTE_NUM -1 )) { +pr_err ("%s: write size too big\n" , __func__); +return -ERANGE ; + } + + buf[0 ] = offset; +memcpy (&buf[1 ], data, data_len); + msgs[0 ].buf = buf; + msgs[0 ].len = data_len +1 ; +retry: + rc =i2c_transfer (hdmi->i2c, msgs,1 ); + + retry--; +if (rc ==1 )
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 171
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+ rc =0 ; + else if (retry > 0) + goto retry; + else + rc = -EIO; + + DBG("End DDC write %d", rc); + + return rc; +}
And this looks like i2c_smbus_write_i2c_block_data()
Quoted 1 line
+
[..]
Quoted 18 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +18
-0+ +static int hdmi_hdcp_send_aksv_an (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +u32 link0_aksv_0, link0_aksv_1; +u32 link0_an[2 ]; +u8 aksv[5 ]; + +/* Read An0 and An1 */ + link0_an[0 ] =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA5 ); + link0_an[1 ] =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA6 ); + +/* Read AKSV */ + link0_aksv_0 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA3 ); + link0_aksv_1 =hdmi_read (hdmi,REG_HDMI_HDCP_RCVPORT_DATA4 ); + +DBG ("Link ASKV=%08x%08x" , link0_aksv_0, link0_aksv_1);
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 688
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* Copy An and AKSV to byte arrays for transmission */ + aksv[0 ] = link0_aksv_0 &0xFF ; + aksv[1 ] = (link0_aksv_0 >>8 ) &0xFF ; + aksv[2 ] = (link0_aksv_0 >>16 ) &0xFF ; + aksv[3 ] = (link0_aksv_0 >>24 ) &0xFF ; + aksv[4 ] = link0_aksv_1 &0xFF ; + +/* Write An to offset 0x18 */ + rc =hdmi_ddc_write (hdmi,HDCP_PORT_ADDR ,0x18 , (u8 *)link0_an, + (u16 )sizeof (link0_an));
rc = i2c_smbus_write_i2c_block_data(hdmi->i2c, 0x18, sizeof(link0_an), link0_an);
if (rc < 0) {
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 696
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +8
-0+if (rc) { +pr_err ("%s:An write failed\n" , __func__); +return rc; + } +DBG ("Link0-An=%08x%08x" , link0_an[0 ], link0_an[1 ]); + +/* Write AKSV to offset 0x10 */ + rc =hdmi_ddc_write (hdmi,HDCP_PORT_ADDR ,0x10 , aksv,5 );
rc = i2c_smbus_write_i2c_block_data(hdmi->i2c, 0x10, sizeof(aksv), aksv); if (rc < 0) {
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+if (rc) { +pr_err ("%s:AKSV write failed\n" , __func__); +return rc; + } +DBG ("Link0-AKSV=%02x%08x" , link0_aksv_1 &0xFF , link0_aksv_0); + +return 0 ; +} +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 715
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+static int hdmi_hdcp_recv_bksv (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +u8 bksv[5 ]; +u32 reg[2 ], data[2 ]; + +/* Read BKSV at offset 0x00 */ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x00 , bksv,5 ); +if (rc) {
You should be able to replace this with:
rc = i2c_smbus_read_i2c_block_data(hdmi->i2c, 0x0, 5, bksv); if (rc < 0) {
Quoted 26 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +26
-0+pr_err ("%s:BKSV read failed\n" , __func__); +return rc; + } + + hdcp_ctrl->bksv_lsb = bksv[0 ] | (bksv[1 ] <<8 ) | + (bksv[2 ] <<16 ) | (bksv[3 ] <<24 ); + hdcp_ctrl->bksv_msb = bksv[4 ]; +DBG (":BKSV=%02x%08x" , hdcp_ctrl->bksv_msb, hdcp_ctrl->bksv_lsb); + +/* check there are 20 ones in BKSV */ +if ((hweight32 (hdcp_ctrl->bksv_lsb) +hweight32 (hdcp_ctrl->bksv_msb)) + !=20 ) { +pr_err (": BKSV doesn't have 20 1's and 20 0's\n" ); +pr_err (": BKSV chk fail. BKSV=%02x%02x%02x%02x%02x\n" , + bksv[4 ], bksv[3 ], bksv[2 ], bksv[1 ], bksv[0 ]); +return -EINVAL ; + } + +/* Write BKSV read from sink to HDCP registers */ + reg[0 ] =REG_HDMI_HDCP_RCVPORT_DATA0 ; + data[0 ] = hdcp_ctrl->bksv_lsb; + reg[1 ] =REG_HDMI_HDCP_RCVPORT_DATA1 ; + data[1 ] = hdcp_ctrl->bksv_msb; + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, reg, data,2 ); + +return rc;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 751
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+} + +static int hdmi_hdcp_recv_bcaps (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc =0 ; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +u32 reg, data; +u8 bcaps; + + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x40 , &bcaps,1 );
int bcaps;
bcaps = i2c_smbus_read_byte_data(hdmi->i2c, 0x40); if (bcaps < 0) {
Quoted 17 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +17
-0+if (rc) { +pr_err ("%s:BCAPS read failed\n" , __func__); +return rc; + } +DBG ("BCAPS=%02x" , bcaps); + +/* receiver (0), repeater (1) */ + hdcp_ctrl->ds_type = (bcaps &BIT (6 )) ?DS_REPEATER :DS_RECEIVER ; + +/* Write BCAPS to the hardware */ + reg =REG_HDMI_HDCP_RCVPORT_DATA12 ; + data = (u32 )bcaps; + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, ®, &data,1 ); + +return rc; +} +
[..]
Quoted 8 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +8
-0+ +/* read R0' from sink and pass it to HDCP engine */ +static int hdmi_hdcp_auth_part1_recv_r0 (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +int rc =0 ; +u8 buf[2 ]; +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 838
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+/* +* HDCP Compliance Test case 1A-01: +* Wait here at least 100ms before reading R0' +*/ + rc =hdmi_hdcp_msleep (hdcp_ctrl,125 ,AUTH_ABORT_EV ); +if (rc) +return rc; + +/* Read R0' at offset 0x08 */ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x08 , buf,2 );
rc = i2c_smbus_read_word_data(hdmi->i2c, 0x8);
if (rc < 0) {
}
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 847
Quoted 9 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +9
-0+if (rc) { +pr_err ("%s:R0' read failed\n" , __func__); +return rc; + } +DBG ("R0'=%02x%02x" , buf[1 ], buf[0 ]); + +/* Write R0' to HDCP registers and check to see if it is a match */ +hdmi_write (hdmi,REG_HDMI_HDCP_RCVPORT_DATA2_0 , + (((u32 )buf[1 ]) <<8 ) | buf[0 ]);
hdmi_write(hdmi, REG_HDMI_HDCP_RCVPORT_DATA2_0, rc);
Quoted 4 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +4
-0+ +return 0 ; +} +
[..]
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 891
Quoted 13 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +13
-0+ +static int hdmi_hdcp_recv_check_bstatus (struct hdmi_hdcp_ctrl *hdcp_ctrl, +u16 *pbstatus) +{ +int rc; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +bool max_devs_exceeded = false, max_cascade_exceeded = false; +u32 repeater_cascade_depth =0 , down_stream_devices =0 ; +u16 bstatus; +u8 buf[2 ]; + +/* Read BSTATUS at offset 0x41 */ + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x41 , buf,2 );
rc = i2c_smbus_read_word_data(hdmi->i2c, 0x41);
if (rc < 0) {
}
*pbstatus = bstatus = rc;
Quoted 63 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +63
-0+if (rc) { +pr_err ("%s: BSTATUS read failed\n" , __func__); + goto error; + } + *pbstatus = bstatus = (buf[1 ] <<8 ) | buf[0 ]; + + + down_stream_devices = bstatus &0x7F ; + repeater_cascade_depth = (bstatus >>8 ) &0x7 ; + max_devs_exceeded = (bstatus &BIT (7 )) ? true : false; + max_cascade_exceeded = (bstatus &BIT (11 )) ? true : false; + +if (down_stream_devices ==0 ) { +/* +* If no downstream devices are attached to the repeater +* then part II fails. +* todo: The other approach would be to continue PART II. +*/ +pr_err ("%s: No downstream devices\n" , __func__); + rc = -EINVAL ; + goto error; + } + +/* +* HDCP Compliance 1B-05: +* Check if no. of devices connected to repeater +* exceed max_devices_connected from bit 7 of Bstatus. +*/ +if (max_devs_exceeded) { +pr_err ("%s: no. of devs connected exceeds max allowed" , + __func__); + rc = -EINVAL ; + goto error; + } + +/* +* HDCP Compliance 1B-06: +* Check if no. of cascade connected to repeater +* exceed max_cascade_connected from bit 11 of Bstatus. +*/ +if (max_cascade_exceeded) { +pr_err ("%s: no. of cascade conn exceeds max allowed" , + __func__); + rc = -EINVAL ; + goto error; + } + +error: + hdcp_ctrl->dev_count = down_stream_devices; + hdcp_ctrl->max_cascade_exceeded = max_cascade_exceeded; + hdcp_ctrl->max_dev_exceeded = max_devs_exceeded; + hdcp_ctrl->depth = repeater_cascade_depth; +return rc; +} + +static int hdmi_hdcp_auth_part2_wait_ksv_fifo_ready ( +struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +u32 reg, data; +u32 timeout_count; +u16 bstatus;
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 964
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+u8 bcaps; + +/* +* Wait until READY bit is set in BCAPS, as per HDCP specifications +* maximum permitted time to check for READY bit is five seconds. +*/ + timeout_count =100 ; + do { + /* Read BCAPS at offset 0x40 */ + rc = hdmi_ddc_read(hdmi, HDCP_PORT_ADDR, 0x40, &bcaps, 1);
rc = i2c_smbus_read_byte_data(hdmi->i2c, 0x40);
if (rc < 0) {
}
bcaps = rc;
Quoted 54 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +54
-0+if (rc) { +pr_err ("%s: BCAPS read failed\n" , __func__); +return rc; + } + +if (bcaps &BIT (5 )) +break ; + + timeout_count--; +if (!timeout_count) { +pr_err ("%s: Wait KSV fifo ready timedout" , __func__); +return -ETIMEDOUT ; + } + + rc =hdmi_hdcp_msleep (hdcp_ctrl,20 ,AUTH_ABORT_EV ); +if (rc) +return rc; + }while (1 ); + + rc =hdmi_hdcp_recv_check_bstatus (hdcp_ctrl, &bstatus); +if (rc) { +pr_err ("%s: bstatus error\n" , __func__); +return rc; + } + +/* Write BSTATUS and BCAPS to HDCP registers */ + reg =REG_HDMI_HDCP_RCVPORT_DATA12 ; + data = bcaps | (bstatus <<8 ); + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, ®, &data,1 ); +if (rc) { +pr_err ("%s: BSTATUS write failed\n" , __func__); +return rc; + } + +return 0 ; +} + +/* +* hdcp authenticating part 2: 2nd +* read ksv fifo from sink +* transfer V' from sink to HDCP engine +* reset SHA engine +*/ +static int hdmi_hdcp_transfer_v_h (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +struct hdmi *hdmi = hdcp_ctrl->hdmi; +int rc =0 ; +struct hdmi_hdcp_reg_data reg_data[] = { + {REG_HDMI_HDCP_RCVPORT_DATA7 ,0x20 ,"V' H0" }, + {REG_HDMI_HDCP_RCVPORT_DATA8 ,0x24 ,"V' H1" }, + {REG_HDMI_HDCP_RCVPORT_DATA9 ,0x28 ,"V' H2" }, + {REG_HDMI_HDCP_RCVPORT_DATA10 ,0x2C ,"V' H3" }, + {REG_HDMI_HDCP_RCVPORT_DATA11 ,0x30 ,"V' H4" }, + };
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1028
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+struct hdmi_hdcp_reg_data *rd; +u32 size =ARRAY_SIZE (reg_data); +u32 reg[ARRAY_SIZE (reg_data)]; +u32 data[ARRAY_SIZE (reg_data)]; +int i; + +for (i =0 ; i < size; i++) { + rd = ®_data[i]; + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR , + rd->off, (u8 *)&data[i], (u16 )sizeof (data[i]));
rc = i2c_smbus_read_i2c_block_data(hdmi->i2c, rd->off, sizeof(u32), &data[i]); if (rc < 0) {
Quoted 15 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +15
-0+if (rc) { +pr_err ("%s: Read %s failed\n" , __func__, rd->name); + goto error; + } + +DBG ("%s =%x" , rd->name, data[i]); + reg[i] = reg_data[i].reg_id; + } + + rc =hdmi_hdcp_scm_wr (hdcp_ctrl, reg, data, size); + +error: +return rc; +} +
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1053
Quoted 10 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +10
-0+static int hdmi_hdcp_recv_ksv_fifo (struct hdmi_hdcp_ctrl *hdcp_ctrl) +{ +int rc; +struct hdmi *hdmi = hdcp_ctrl->hdmi; +u32 ksv_bytes; + + ksv_bytes =5 * hdcp_ctrl->dev_count; + + rc =hdmi_ddc_read (hdmi,HDCP_PORT_ADDR ,0x43 , + hdcp_ctrl->ksv_list, ksv_bytes);
rc = i2c_smbus_read_i2c_block_data(hdmi->i2c, 0x43, ksv_bytes, hdcp_ctrl->ksv_list);
if (rc < 0) {
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 1059
Quoted 6 lines
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c +6
-0+if (rc) +pr_err ("%s: KSV FIFO read failed\n" , __func__); + +return rc; +} +
Maybe I'm missundersanding how smbus or ddc works, please let me know what you think.
Regards,
Bjorn
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Re: [PATCH 2/2] drm/msm/hdmi: add hdmi hdcp support (V2)
Quoted 11 lines · Bjorn Andersson
Quoted 6 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.Looks cleaner and the SCM parts look good now.
But the ddc communication still makes me wonder, see below.
Rob made me aware about the fact that the hdmi driver is both implementing a driver for the i2c controller and now for the hdcp client and hence doesn't have an i2c_client handle.
So unless this is redesigned to be split in a separate i2c client driver we probably have to have the ddc functions like this.
I'm fine with this as is for now.
Regards,
Bjorn
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Re: [PATCH 2/2] drm/msm/hdmi: add hdmi hdcp support (V2)
Quoted 13 lines · Bjorn Andersson
Quoted 11 lines · Bjorn Andersson
Quoted 6 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.Looks cleaner and the SCM parts look good now.
But the ddc communication still makes me wonder, see below.
Quoted 9 lines
Rob made me aware about the fact that the hdmi driver is both implementing a driver for the i2c controller and now for the hdcp client and hence doesn't have an
i2c_clienthandle.So unless this is redesigned to be split in a separate i2c client driver we probably have to have the ddc functions like this.
I'm fine with this as is for now.
After digging some more in the i2c stack I found others using i2c_new_dummy() to create a "dummy" i2c client from and adaptor and an address.
By introducing that we could make hdmi->i2c an actual i2c_client and use the client api in here.
Regards,
Bjorn
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel
Re: [PATCH 2/2] drm/msm/hdmi: add hdmi hdcp support (V2)
There is one issue to use i2c_smbus_XX functions:i2c_smbus_read_i2c_block_data has limitation with the maximum count I2C_SMBUS_BLOCK_MAX.
But in function hdmi_hdcp_recv_ksv_fifo, since the downstream ksv_fifo size will exceed this limitation and must be read in a single transaction, we can't use this function then.
Quoted 34 lines · Bjorn Andersson
Quoted 14 lines · Bjorn Andersson
Quoted 8 lines
Quoted 6 lines · Jilai Wang
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.Quoted 4 lines
Looks cleaner and the SCM parts look good now.
But the ddc communication still makes me wonder, see below.
Quoted 9 lines
Rob made me aware about the fact that the hdmi driver is both implementing a driver for the i2c controller and now for the hdcp client and hence doesn't have an
i2c_clienthandle.So unless this is redesigned to be split in a separate i2c client driver we probably have to have the ddc functions like this.
I'm fine with this as is for now.
After digging some more in the i2c stack I found others using
i2c_new_dummy()to create a "dummy" i2c client from and adaptor and an address.
By introducing that we could makehdmi->i2can actuali2c_clientand use the client api in here.Regards,
Bjorn
Re: [PATCH 2/2] drm/msm/hdmi: add hdmi hdcp support (V2)
Quoted 7 lines · On Wed, Feb 11, 2015 at 10:59 AM, <[email protected]> wrote:
There is one issue to use
i2c_smbus_XXfunctions:i2c_smbus_read_i2c_block_datahas limitation with the maximum countI2C_SMBUS_BLOCK_MAX.
But in functionhdmi_hdcp_recv_ksv_fifo, since the downstreamksv_fifosize will exceed this limitation and must be read in a single transaction, we can't use this function then.
That's interesting, because we have the same problem in the Synaptics driver, where we want to read more than 32 bytes with a method that follows the smbus flow.
Wolfram, do you have any input on making i2c_smbus* functions work for larger accesses? Or should we just conclude that it's not "smbus" and open code this in the various places?
Regards,
Bjorn
PATCH 1/1 drm/msm/hdmi: add hdmi hdcp support (V3)
Add HDMI HDCP support including HDCP PartI/II/III authentication.
V1: Initial Change
V2: Address Bjorn&Rob's comments
Refactor the authentication process to use single work instead of multiple work for different authentication stages.
V3: Update to align with qcom SCM api.
--- drivers/gpu/drm/msm/Makefile | 1 + drivers/gpu/drm/msm/hdmi/hdmi.c | 45 +- drivers/gpu/drm/msm/hdmi/hdmi.h | 31 + drivers/gpu/drm/msm/hdmi/hdmi_audio.c | 1 - drivers/gpu/drm/msm/hdmi/hdmi_bridge.c | 8 +- drivers/gpu/drm/msm/hdmi/hdmi_connector.c | 7 +- drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c | 1437 +++++++++++++++++++++++++++++ 7 files changed, 1522 insertions(+), 8 deletions(-) create mode 100644 drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c
drivers/gpu/drm/msm/Makefile +1 -0
@@ -9,6 +9,7 @@ msm-y := \ hdmi/hdmi_audio.o \ hdmi/hdmi_bridge.o \ hdmi/hdmi_connector.o \ + hdmi/hdmi_hdcp.o \ hdmi/hdmi_i2c.o \ hdmi/hdmi_phy_8960.o \ hdmi/hdmi_phy_8x60.o \
drivers/gpu/drm/msm/hdmi/hdmi.c +42 -3
130 lines not on this page · raw message
drivers/gpu/drm/msm/hdmi/hdmi.h +31 -0
@@ -37,6 +37,8 @@ struct hdmi_audio {int rate; }; +struct hdmi_hdcp_ctrl ; +struct hdmi {struct drm_device *dev;struct platform_device *pdev;
@@ -51,6 +53,8 @@ struct hdmi {unsigned long int pixclock;void __iomem *mmio; +void __iomem *qfprom_mmio; +phys_addr_t mmio_phy_addr;struct regulator **hpd_regs;struct regulator **pwr_regs;
@@ -68,12 +72,25 @@ struct hdmi {bool hdmi_mode;/* are we in hdmi mode? */ int irq; +struct workqueue_struct *workq; + +struct hdmi_hdcp_ctrl *hdcp_ctrl; + +/* +* spinlock to protect registers shared by different execution +* REG_HDMI_CTRL +* REG_HDMI_DDC_ARBITRATION +* REG_HDMI_HDCP_INT_CTRL +* REG_HDMI_HPD_CTRL +*/ +spinlock_t reg_lock; };/* platform config data (ie. from DT, or pdata) */ struct hdmi_platform_config {struct hdmi_phy *(*phy_init)(struct hdmi *hdmi);const char *mmio_name; +const char *qfprom_mmio_name;/* regulators that need to be on for hpd: */ const char **hpd_reg_names;
@@ -109,6 +126,11 @@ static inline u32 hdmi_read(struct hdmi *hdmi, u32 reg)return msm_readl (hdmi->mmio + reg); } +static inline u32 hdmi_qfprom_read (struct hdmi *hdmi,u32 reg) +{ +return msm_readl (hdmi->qfprom_mmio + reg); +} +/* * The phy appears to be different, for example between 8960 and 8x60, * so split the phy related functions out and load the correct one at
@@ -163,4 +185,13 @@ void hdmi_i2c_irq(struct i2c_adapter *i2c);void hdmi_i2c_destroy (struct i2c_adapter *i2c);struct i2c_adapter *hdmi_i2c_init (struct hdmi *hdmi); +/* +* hdcp +*/ +struct hdmi_hdcp_ctrl *hdmi_hdcp_init (struct hdmi *hdmi); +void hdmi_hdcp_destroy (struct hdmi *hdmi); +void hdmi_hdcp_on (struct hdmi_hdcp_ctrl *hdcp_ctrl); +void hdmi_hdcp_off (struct hdmi_hdcp_ctrl *hdcp_ctrl); +void hdmi_hdcp_irq (struct hdmi_hdcp_ctrl *hdcp_ctrl); +#endif /* __HDMI_CONNECTOR_H__ */
drivers/gpu/drm/msm/hdmi/hdmi_audio.c +0 -1
@@ -203,7 +203,6 @@ int hdmi_audio_update(struct hdmi *hdmi) audio_config |=HDMI_AUDIO_CFG_FIFO_WATERMARK (4 ); audio_config |=HDMI_AUDIO_CFG_ENGINE_ENABLE ; }else { -hdmi_write (hdmi,REG_HDMI_GC ,HDMI_GC_MUTE ); acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_CONT ; acr_pkt_ctrl &= ~HDMI_ACR_PKT_CTRL_SEND ; vbi_pkt_ctrl &= ~HDMI_VBI_PKT_CTRL_GC_ENABLE ;
drivers/gpu/drm/msm/hdmi/hdmi_bridge.c +6 -2
@@ -102,6 +102,9 @@ static void hdmi_bridge_pre_enable(struct drm_bridge *bridge) phy->funcs->powerup (phy, hdmi->pixclock);hdmi_set_mode (hdmi, true); + +if (hdmi->hdcp_ctrl) +hdmi_hdcp_on (hdmi->hdcp_ctrl); }static void hdmi_bridge_enable (struct drm_bridge *bridge)
@@ -118,6 +121,9 @@ static void hdmi_bridge_post_disable(struct drm_bridge *bridge)struct hdmi *hdmi = hdmi_bridge->hdmi;struct hdmi_phy *phy = hdmi->phy; +if (hdmi->hdcp_ctrl) +hdmi_hdcp_off (hdmi->hdcp_ctrl); +DBG ("power down" );hdmi_set_mode (hdmi, false); phy->funcs->powerdown (phy);
@@ -142,8 +148,6 @@ static void hdmi_bridge_mode_set(struct drm_bridge *bridge, hdmi->pixclock = mode->clock *1000 ; - hdmi->hdmi_mode =drm_match_cea_mode (mode) >1 ; - hstart = mode->htotal - mode->hsync_start; hend = mode->htotal - mode->hsync_start + mode->hdisplay;
drivers/gpu/drm/msm/hdmi/hdmi_connector.c +5 -2
@@ -140,6 +140,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector)struct hdmi_phy *phy = hdmi->phy;uint32_t hpd_ctrl;int i, ret; +unsigned long flags;for (i =0 ; i < config->hpd_reg_cnt; i++) { ret =regulator_enable (hdmi->hpd_regs[i]);
@@ -185,6 +186,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) HDMI_HPD_INT_CTRL_INT_EN);/* set timeout to 4.1ms (max) for hardware debounce */ +spin_lock_irqsave (&hdmi->reg_lock, flags); hpd_ctrl =hdmi_read (hdmi,REG_HDMI_HPD_CTRL ); hpd_ctrl |=HDMI_HPD_CTRL_TIMEOUT (0x1fff );
@@ -193,6 +195,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) ~HDMI_HPD_CTRL_ENABLE & hpd_ctrl);hdmi_write (hdmi,REG_HDMI_HPD_CTRL ,HDMI_HPD_CTRL_ENABLE | hpd_ctrl); +spin_unlock_irqrestore (&hdmi->reg_lock, flags);return 0 ;
@@ -239,7 +242,6 @@ hotplug_work(struct work_struct *work)void hdmi_connector_irq (struct drm_connector *connector) {struct hdmi_connector *hdmi_connector =to_hdmi_connector (connector); -struct msm_drm_private *priv = connector->dev->dev_private;struct hdmi *hdmi = hdmi_connector->hdmi;uint32_t hpd_int_status, hpd_int_ctrl;
@@ -263,7 +265,7 @@ void hdmi_connector_irq(struct drm_connector *connector) hpd_int_ctrl |=HDMI_HPD_INT_CTRL_INT_CONNECT ;hdmi_write (hdmi,REG_HDMI_HPD_INT_CTRL , hpd_int_ctrl); -queue_work (priv->wq, &hdmi_connector->hpd_work); +queue_work (hdmi->workq, &hdmi_connector->hpd_work); } }
@@ -339,6 +341,7 @@ static int hdmi_connector_get_modes(struct drm_connector *connector)hdmi_write (hdmi,REG_HDMI_CTRL , hdmi_ctrl); + hdmi->hdmi_mode =drm_detect_hdmi_monitor (edid);drm_mode_connector_update_edid_property (connector, edid);if (edid) {
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +1437 -0
1,437 lines not on this page · raw message
Signature · 7 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c line 945
Quoted 2 lines · Jilai Wang
drivers/gpu/drm/msm/hdmi/hdmi_hdcp.c new file +2
-0+/* Enable HDCP Encryption */ +hdmi_write (hdmi,REG_HDMI_HDCP_CTRL ,BIT (0 ) |BIT (8 ));
btw, as Bjron mentioned, there are a lot of these open coded BIT(n).. but from a quick check, the first two or three I looked at, we already have the appropriate defines in the rnndb generated headers, to instead do:
/* Enable HDCP Encryption */
hdmi_write(hdmi, REG_HDMI_HDCP_CTRL,
HDMI_HDCP_CTRL_ENABLE |
HDMI_HDCP_CTRL_ENCRYPTION_ENABLE);that seems somewhat more readable to me ;-)
BR,
-R
_______________________________________________
dri-devel mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/dri-devel