drivers/usb/typec/ucsi/displayport.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * UCSI DisplayPort Alternate Mode Support
  *
  * Copyright (C) 2018, Intel Corporation
  * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
  */

 #include <linux/usb/typec_dp.h>
 #include <linux/usb/pd_vdo.h>

 #include "ucsi.h"

 #define UCSI_CMD_SET_NEW_CAM(_con_num_, _enter_, _cam_, _am_)		\
 	 (UCSI_SET_NEW_CAM | ((_con_num_) << 16) | ((_enter_) << 23) |	\
 	  ((_cam_) << 24) | ((u64)(_am_) << 32))

 struct ucsi_dp {
 	struct typec_displayport_data data;
 	struct ucsi_connector *con;
 	struct typec_altmode *alt;
 	struct work_struct work;
 	int offset;

 	bool override;
 	bool initialized;

 	u32 header;
 	u32 *vdo_data;
 	u8 vdo_size;
 };

 /*
  * Note. Alternate mode control is optional feature in UCSI. It means that even
  * if the system supports alternate modes, the OS may not be aware of them.
  *
  * In most cases however, the OS will be able to see the supported alternate
  * modes, but it may still not be able to configure them, not even enter or exit
  * them. That is because UCSI defines alt mode details and alt mode "overriding"
  * as separate options.
  *
  * In case alt mode details are supported, but overriding is not, the driver
  * will still display the supported pin assignments and configuration, but any
  * changes the user attempts to do will lead into failure with return value of
  * -EOPNOTSUPP.
  */

 static int ucsi_displayport_enter(struct typec_altmode *alt, u32 *vdo)
 {
 	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
 	struct ucsi *ucsi = dp->con->ucsi;
 	int svdm_version;
 	u64 command;
 	u8 cur = 0;
 	int ret;

 	mutex_lock(&dp->con->lock);

 	if (!dp->override && dp->initialized) {
 		const struct typec_altmode *p = typec_altmode_get_partner(alt);

 		dev_warn(&p->dev,
 			 "firmware doesn't support alternate mode overriding\n");
 		ret = -EOPNOTSUPP;
 		goto err_unlock;
 	}

 	command = UCSI_GET_CURRENT_CAM | UCSI_CONNECTOR_NUMBER(dp->con->num);
 	ret = ucsi_send_command(ucsi, command, &cur, sizeof(cur));
 	if (ret < 0) {
 		if (ucsi->version > 0x0100)
 			goto err_unlock;
 		cur = 0xff;
 	}

 	if (cur != 0xff) {
 		ret = dp->con->port_altmode[cur] == alt ? 0 : -EBUSY;
 		goto err_unlock;
 	}

 	/*
 	 * We can't send the New CAM command yet to the PPM as it needs the
 	 * configuration value as well. Pretending that we have now entered the
 	 * mode, and letting the alt mode driver continue.
 	 */

 	svdm_version = typec_altmode_get_svdm_version(alt);
 	if (svdm_version < 0) {
 		ret = svdm_version;
 		goto err_unlock;
 	}

 	dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, CMD_ENTER_MODE);
 	dp->header |= VDO_OPOS(USB_TYPEC_DP_MODE);
 	dp->header |= VDO_CMDT(CMDT_RSP_ACK);

 	dp->vdo_data = NULL;
 	dp->vdo_size = 1;

 	schedule_work(&dp->work);
 	ret = 0;
 err_unlock:
 	mutex_unlock(&dp->con->lock);

 	return ret;
 }

 static int ucsi_displayport_exit(struct typec_altmode *alt)
 {
 	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
 	int svdm_version;
 	u64 command;
 	int ret = 0;

 	mutex_lock(&dp->con->lock);

 	if (!dp->override) {
 		const struct typec_altmode *p = typec_altmode_get_partner(alt);

 		dev_warn(&p->dev,
 			 "firmware doesn't support alternate mode overriding\n");
 		ret = -EOPNOTSUPP;
 		goto out_unlock;
 	}

 	command = UCSI_CMD_SET_NEW_CAM(dp->con->num, 0, dp->offset, 0);
 	ret = ucsi_send_command(dp->con->ucsi, command, NULL, 0);
 	if (ret < 0)
 		goto out_unlock;

 	svdm_version = typec_altmode_get_svdm_version(alt);
 	if (svdm_version < 0) {
 		ret = svdm_version;
 		goto out_unlock;
 	}

 	dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, CMD_EXIT_MODE);
 	dp->header |= VDO_OPOS(USB_TYPEC_DP_MODE);
 	dp->header |= VDO_CMDT(CMDT_RSP_ACK);

 	dp->vdo_data = NULL;
 	dp->vdo_size = 1;

 	schedule_work(&dp->work);

 out_unlock:
 	mutex_unlock(&dp->con->lock);

 	return ret;
 }

 /*
  * We do not actually have access to the Status Update VDO, so we have to guess
  * things.
  */
 static int ucsi_displayport_status_update(struct ucsi_dp *dp)
 {
 	u32 cap = dp->alt->vdo;

 	dp->data.status = DP_STATUS_ENABLED;

 	/*
 	 * If pin assignement D is supported, claiming always
 	 * that Multi-function is preferred.
 	 */
 	if (DP_CAP_CAPABILITY(cap) & DP_CAP_UFP_D) {
 		dp->data.status |= DP_STATUS_CON_UFP_D;

 		if (DP_CAP_UFP_D_PIN_ASSIGN(cap) & BIT(DP_PIN_ASSIGN_D))
 			dp->data.status |= DP_STATUS_PREFER_MULTI_FUNC;
 	} else {
 		dp->data.status |= DP_STATUS_CON_DFP_D;

 		if (DP_CAP_DFP_D_PIN_ASSIGN(cap) & BIT(DP_PIN_ASSIGN_D))
 			dp->data.status |= DP_STATUS_PREFER_MULTI_FUNC;
 	}

 	dp->vdo_data = &dp->data.status;
 	dp->vdo_size = 2;

 	return 0;
 }

 static int ucsi_displayport_configure(struct ucsi_dp *dp)
 {
 	u32 pins = DP_CONF_GET_PIN_ASSIGN(dp->data.conf);
 	u64 command;

 	if (!dp->override)
 		return 0;

 	command = UCSI_CMD_SET_NEW_CAM(dp->con->num, 1, dp->offset, pins);

 	return ucsi_send_command(dp->con->ucsi, command, NULL, 0);
 }

 static int ucsi_displayport_vdm(struct typec_altmode *alt,
 				u32 header, const u32 *data, int count)
 {
 	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
 	int cmd_type = PD_VDO_CMDT(header);
 	int cmd = PD_VDO_CMD(header);
 	int svdm_version;

 	mutex_lock(&dp->con->lock);

 	if (!dp->override && dp->initialized) {
 		const struct typec_altmode *p = typec_altmode_get_partner(alt);

 		dev_warn(&p->dev,
 			 "firmware doesn't support alternate mode overriding\n");
 		mutex_unlock(&dp->con->lock);
 		return -EOPNOTSUPP;
 	}

 	svdm_version = typec_altmode_get_svdm_version(alt);
 	if (svdm_version < 0) {
 		mutex_unlock(&dp->con->lock);
 		return svdm_version;
 	}

 	switch (cmd_type) {
 	case CMDT_INIT:
 		if (PD_VDO_SVDM_VER(header) < svdm_version) {
 			typec_partner_set_svdm_version(dp->con->partner, PD_VDO_SVDM_VER(header));
 			svdm_version = PD_VDO_SVDM_VER(header);
 		}

 		dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, cmd);
 		dp->header |= VDO_OPOS(USB_TYPEC_DP_MODE);

 		switch (cmd) {
 		case DP_CMD_STATUS_UPDATE:
 			if (ucsi_displayport_status_update(dp))
 				dp->header |= VDO_CMDT(CMDT_RSP_NAK);
 			else
 				dp->header |= VDO_CMDT(CMDT_RSP_ACK);
 			break;
 		case DP_CMD_CONFIGURE:
 			dp->data.conf = *data;
 			if (ucsi_displayport_configure(dp)) {
 				dp->header |= VDO_CMDT(CMDT_RSP_NAK);
 			} else {
 				dp->header |= VDO_CMDT(CMDT_RSP_ACK);
 				if (dp->initialized)
 					ucsi_altmode_update_active(dp->con);
 				else
 					dp->initialized = true;
 			}
 			break;
 		default:
 			dp->header |= VDO_CMDT(CMDT_RSP_ACK);
 			break;
 		}

 		schedule_work(&dp->work);
 		break;
 	default:
 		break;
 	}

 	mutex_unlock(&dp->con->lock);

 	return 0;
 }

 static const struct typec_altmode_ops ucsi_displayport_ops = {
 	.enter = ucsi_displayport_enter,
 	.exit = ucsi_displayport_exit,
 	.vdm = ucsi_displayport_vdm,
 };

 static void ucsi_displayport_work(struct work_struct *work)
 {
 	struct ucsi_dp *dp = container_of(work, struct ucsi_dp, work);
 	int ret;

 	mutex_lock(&dp->con->lock);

 	ret = typec_altmode_vdm(dp->alt, dp->header,
 				dp->vdo_data, dp->vdo_size);
 	if (ret)
 		dev_err(&dp->alt->dev, "VDM 0x%x failed\n", dp->header);

 	dp->vdo_data = NULL;
 	dp->vdo_size = 0;
 	dp->header = 0;

 	mutex_unlock(&dp->con->lock);
 }

 void ucsi_displayport_remove_partner(struct typec_altmode *alt)
 {
 	struct ucsi_dp *dp;

 	if (!alt)
 		return;

 	dp = typec_altmode_get_drvdata(alt);
 	if (!dp)
 		return;

 	dp->data.conf = 0;
 	dp->data.status = 0;
 	dp->initialized = false;
 }

 struct typec_altmode *ucsi_register_displayport(struct ucsi_connector *con,
 						bool override, int offset,
 						struct typec_altmode_desc *desc)
 {
 	u8 all_assignments = BIT(DP_PIN_ASSIGN_C) | BIT(DP_PIN_ASSIGN_D) |
 			     BIT(DP_PIN_ASSIGN_E);
 	struct typec_altmode *alt;
 	struct ucsi_dp *dp;

 	/* We can't rely on the firmware with the capabilities. */
 	desc->vdo |= DP_CAP_DP_SIGNALING | DP_CAP_RECEPTACLE;

 	/* Claiming that we support all pin assignments */
 	desc->vdo |= all_assignments << 8;
 	desc->vdo |= all_assignments << 16;

 	alt = typec_port_register_altmode(con->port, desc);
 	if (IS_ERR(alt))
 		return alt;

 	dp = devm_kzalloc(&alt->dev, sizeof(*dp), GFP_KERNEL);
 	if (!dp) {
 		typec_unregister_altmode(alt);
 		return ERR_PTR(-ENOMEM);
 	}

 	INIT_WORK(&dp->work, ucsi_displayport_work);
 	dp->override = override;
 	dp->offset = offset;
 	dp->con = con;
 	dp->alt = alt;

 	alt->ops = &ucsi_displayport_ops;
 	typec_altmode_set_drvdata(alt, dp);

 	return alt;
 }
	// SPDX-License-Identifier: GPL-2.0
	/*
	* UCSI DisplayPort Alternate Mode Support
	*
	* Copyright (C) 2018, Intel Corporation
	* Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
	*/

	#include <linux/usb/typec_dp.h>
	#include <linux/usb/pd_vdo.h>

	#include "ucsi.h"

	#define UCSI_CMD_SET_NEW_CAM(_con_num_, _enter_, _cam_, _am_) \
	(UCSI_SET_NEW_CAM \| ((_con_num_) << 16) \| ((_enter_) << 23) \| \
	((_cam_) << 24) \| ((u64)(_am_) << 32))

	struct ucsi_dp {
	struct typec_displayport_data data;
	struct ucsi_connector *con;
	struct typec_altmode *alt;
	struct work_struct work;
	int offset;

	bool override;
	bool initialized;

	u32 header;
	u32 *vdo_data;
	u8 vdo_size;
	};

	/*
	* Note. Alternate mode control is optional feature in UCSI. It means that even
	* if the system supports alternate modes, the OS may not be aware of them.
	*
	* In most cases however, the OS will be able to see the supported alternate
	* modes, but it may still not be able to configure them, not even enter or exit
	* them. That is because UCSI defines alt mode details and alt mode "overriding"
	* as separate options.
	*
	* In case alt mode details are supported, but overriding is not, the driver
	* will still display the supported pin assignments and configuration, but any
	* changes the user attempts to do will lead into failure with return value of
	* -EOPNOTSUPP.
	*/

	static int ucsi_displayport_enter(struct typec_altmode alt, u32 vdo)
	{
	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
	struct ucsi *ucsi = dp->con->ucsi;
	int svdm_version;
	u64 command;
	u8 cur = 0;
	int ret;

	mutex_lock(&dp->con->lock);

	if (!dp->override && dp->initialized) {
	const struct typec_altmode *p = typec_altmode_get_partner(alt);

	dev_warn(&p->dev,
	"firmware doesn't support alternate mode overriding\n");
	ret = -EOPNOTSUPP;
	goto err_unlock;
	}

	command = UCSI_GET_CURRENT_CAM \| UCSI_CONNECTOR_NUMBER(dp->con->num);
	ret = ucsi_send_command(ucsi, command, &cur, sizeof(cur));
	if (ret < 0) {
	if (ucsi->version > 0x0100)
	goto err_unlock;
	cur = 0xff;
	}

	if (cur != 0xff) {
	ret = dp->con->port_altmode[cur] == alt ? 0 : -EBUSY;
	goto err_unlock;
	}

	/*
	* We can't send the New CAM command yet to the PPM as it needs the
	* configuration value as well. Pretending that we have now entered the
	* mode, and letting the alt mode driver continue.
	*/

	svdm_version = typec_altmode_get_svdm_version(alt);
	if (svdm_version < 0) {
	ret = svdm_version;
	goto err_unlock;
	}

	dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, CMD_ENTER_MODE);
	dp->header \|= VDO_OPOS(USB_TYPEC_DP_MODE);
	dp->header \|= VDO_CMDT(CMDT_RSP_ACK);

	dp->vdo_data = NULL;
	dp->vdo_size = 1;

	schedule_work(&dp->work);
	ret = 0;
	err_unlock:
	mutex_unlock(&dp->con->lock);

	return ret;
	}

	static int ucsi_displayport_exit(struct typec_altmode *alt)
	{
	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
	int svdm_version;
	u64 command;
	int ret = 0;

	mutex_lock(&dp->con->lock);

	if (!dp->override) {
	const struct typec_altmode *p = typec_altmode_get_partner(alt);

	dev_warn(&p->dev,
	"firmware doesn't support alternate mode overriding\n");
	ret = -EOPNOTSUPP;
	goto out_unlock;
	}

	command = UCSI_CMD_SET_NEW_CAM(dp->con->num, 0, dp->offset, 0);
	ret = ucsi_send_command(dp->con->ucsi, command, NULL, 0);
	if (ret < 0)
	goto out_unlock;

	svdm_version = typec_altmode_get_svdm_version(alt);
	if (svdm_version < 0) {
	ret = svdm_version;
	goto out_unlock;
	}

	dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, CMD_EXIT_MODE);
	dp->header \|= VDO_OPOS(USB_TYPEC_DP_MODE);
	dp->header \|= VDO_CMDT(CMDT_RSP_ACK);

	dp->vdo_data = NULL;
	dp->vdo_size = 1;

	schedule_work(&dp->work);

	out_unlock:
	mutex_unlock(&dp->con->lock);

	return ret;
	}

	/*
	* We do not actually have access to the Status Update VDO, so we have to guess
	* things.
	*/
	static int ucsi_displayport_status_update(struct ucsi_dp *dp)
	{
	u32 cap = dp->alt->vdo;

	dp->data.status = DP_STATUS_ENABLED;

	/*
	* If pin assignement D is supported, claiming always
	* that Multi-function is preferred.
	*/
	if (DP_CAP_CAPABILITY(cap) & DP_CAP_UFP_D) {
	dp->data.status \|= DP_STATUS_CON_UFP_D;

	if (DP_CAP_UFP_D_PIN_ASSIGN(cap) & BIT(DP_PIN_ASSIGN_D))
	dp->data.status \|= DP_STATUS_PREFER_MULTI_FUNC;
	} else {
	dp->data.status \|= DP_STATUS_CON_DFP_D;

	if (DP_CAP_DFP_D_PIN_ASSIGN(cap) & BIT(DP_PIN_ASSIGN_D))
	dp->data.status \|= DP_STATUS_PREFER_MULTI_FUNC;
	}

	dp->vdo_data = &dp->data.status;
	dp->vdo_size = 2;

	return 0;
	}

	static int ucsi_displayport_configure(struct ucsi_dp *dp)
	{
	u32 pins = DP_CONF_GET_PIN_ASSIGN(dp->data.conf);
	u64 command;

	if (!dp->override)
	return 0;

	command = UCSI_CMD_SET_NEW_CAM(dp->con->num, 1, dp->offset, pins);

	return ucsi_send_command(dp->con->ucsi, command, NULL, 0);
	}

	static int ucsi_displayport_vdm(struct typec_altmode *alt,
	u32 header, const u32 *data, int count)
	{
	struct ucsi_dp *dp = typec_altmode_get_drvdata(alt);
	int cmd_type = PD_VDO_CMDT(header);
	int cmd = PD_VDO_CMD(header);
	int svdm_version;

	mutex_lock(&dp->con->lock);

	if (!dp->override && dp->initialized) {
	const struct typec_altmode *p = typec_altmode_get_partner(alt);

	dev_warn(&p->dev,
	"firmware doesn't support alternate mode overriding\n");
	mutex_unlock(&dp->con->lock);
	return -EOPNOTSUPP;
	}

	svdm_version = typec_altmode_get_svdm_version(alt);
	if (svdm_version < 0) {
	mutex_unlock(&dp->con->lock);
	return svdm_version;
	}

	switch (cmd_type) {
	case CMDT_INIT:
	if (PD_VDO_SVDM_VER(header) < svdm_version) {
	typec_partner_set_svdm_version(dp->con->partner, PD_VDO_SVDM_VER(header));
	svdm_version = PD_VDO_SVDM_VER(header);
	}

	dp->header = VDO(USB_TYPEC_DP_SID, 1, svdm_version, cmd);
	dp->header \|= VDO_OPOS(USB_TYPEC_DP_MODE);

	switch (cmd) {
	case DP_CMD_STATUS_UPDATE:
	if (ucsi_displayport_status_update(dp))
	dp->header \|= VDO_CMDT(CMDT_RSP_NAK);
	else
	dp->header \|= VDO_CMDT(CMDT_RSP_ACK);
	break;
	case DP_CMD_CONFIGURE:
	dp->data.conf = *data;
	if (ucsi_displayport_configure(dp)) {
	dp->header \|= VDO_CMDT(CMDT_RSP_NAK);
	} else {
	dp->header \|= VDO_CMDT(CMDT_RSP_ACK);
	if (dp->initialized)
	ucsi_altmode_update_active(dp->con);
	else
	dp->initialized = true;
	}
	break;
	default:
	dp->header \|= VDO_CMDT(CMDT_RSP_ACK);
	break;
	}

	schedule_work(&dp->work);
	break;
	default:
	break;
	}

	mutex_unlock(&dp->con->lock);

	return 0;
	}

	static const struct typec_altmode_ops ucsi_displayport_ops = {
	.enter = ucsi_displayport_enter,
	.exit = ucsi_displayport_exit,
	.vdm = ucsi_displayport_vdm,
	};

	static void ucsi_displayport_work(struct work_struct *work)
	{
	struct ucsi_dp *dp = container_of(work, struct ucsi_dp, work);
	int ret;

	mutex_lock(&dp->con->lock);

	ret = typec_altmode_vdm(dp->alt, dp->header,
	dp->vdo_data, dp->vdo_size);
	if (ret)
	dev_err(&dp->alt->dev, "VDM 0x%x failed\n", dp->header);

	dp->vdo_data = NULL;
	dp->vdo_size = 0;
	dp->header = 0;

	mutex_unlock(&dp->con->lock);
	}

	void ucsi_displayport_remove_partner(struct typec_altmode *alt)
	{
	struct ucsi_dp *dp;

	if (!alt)
	return;

	dp = typec_altmode_get_drvdata(alt);
	if (!dp)
	return;

	dp->data.conf = 0;
	dp->data.status = 0;
	dp->initialized = false;
	}

	struct typec_altmode ucsi_register_displayport(struct ucsi_connector con,
	bool override, int offset,
	struct typec_altmode_desc *desc)
	{
	u8 all_assignments = BIT(DP_PIN_ASSIGN_C) \| BIT(DP_PIN_ASSIGN_D) \|
	BIT(DP_PIN_ASSIGN_E);
	struct typec_altmode *alt;
	struct ucsi_dp *dp;

	/* We can't rely on the firmware with the capabilities. */
	desc->vdo \|= DP_CAP_DP_SIGNALING \| DP_CAP_RECEPTACLE;

	/* Claiming that we support all pin assignments */
	desc->vdo \|= all_assignments << 8;
	desc->vdo \|= all_assignments << 16;

	alt = typec_port_register_altmode(con->port, desc);
	if (IS_ERR(alt))
	return alt;

	dp = devm_kzalloc(&alt->dev, sizeof(*dp), GFP_KERNEL);
	if (!dp) {
	typec_unregister_altmode(alt);
	return ERR_PTR(-ENOMEM);
	}

	INIT_WORK(&dp->work, ucsi_displayport_work);
	dp->override = override;
	dp->offset = offset;
	dp->con = con;
	dp->alt = alt;

	alt->ops = &ucsi_displayport_ops;
	typec_altmode_set_drvdata(alt, dp);

	return alt;
	}