path: root/drivers/soc/qcom/pmic_glink_altmode.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
 * Copyright (c) 2022, Linaro Ltd
 */
#include <linux/auxiliary_bus.h>
#include <linux/bitfield.h>
#include <linux/cleanup.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/mutex.h>
#include <linux/property.h>
#include <linux/soc/qcom/pdr.h>
#include <drm/bridge/aux-bridge.h>

#include <linux/usb/pd.h>
#include <linux/usb/typec_altmode.h>
#include <linux/usb/typec_dp.h>
#include <linux/usb/typec_mux.h>
#include <linux/usb/typec_retimer.h>
#include <linux/usb/typec_tbt.h>

#include <linux/soc/qcom/pmic_glink.h>

#define PMIC_GLINK_MAX_PORTS	3

#define USBC_SC8180X_NOTIFY_IND	0x13
#define USBC_CMD_WRITE_REQ      0x15
#define USBC_NOTIFY_IND		0x16

#define ALTMODE_PAN_EN		0x10
#define ALTMODE_PAN_ACK		0x11

struct usbc_write_req {
	struct pmic_glink_hdr   hdr;
	__le32 cmd;
	__le32 arg;
	__le32 reserved;
};

struct usbc_sc8280x_dp_data {
	u8 pin_assignment : 6;
	u8 hpd_state : 1;
	u8 hpd_irq : 1;
	u8 res[7];
};

/* Used for both TBT and USB4 notifications */
struct usbc_sc8280x_tbt_data {
	u8 usb_speed : 3;
	u8 cable_type : 3;
	/* This field is NOP on USB4, all cables support rounded rates by spec */
	u8 rounded_cable : 1;
	u8 power_limited : 1;
	u8 res[11];
};

struct usbc_notify {
	struct pmic_glink_hdr hdr;
	u8 port_idx;
	u8 orientation;
	u8 mux_ctrl;
#define MUX_CTRL_STATE_NO_CONN			0
#define MUX_CTRL_STATE_USB3_ONLY		1
#define MUX_CTRL_STATE_DP4LN			2
#define MUX_CTRL_STATE_USB3_DP			3
#define MUX_CTRL_STATE_TUNNELING		4

	u8 res;
	__le16 vid;
	__le16 svid;
	union usbc_sc8280x_extended_data {
		struct usbc_sc8280x_dp_data dp;
		struct usbc_sc8280x_tbt_data tbt;
	} extended_data;
};

struct usbc_sc8180x_notify {
	struct pmic_glink_hdr hdr;
	__le32 notification;
	__le32 reserved[2];
};

enum pmic_glink_altmode_pin_assignment {
	DPAM_HPD_OUT,
	DPAM_HPD_A,
	DPAM_HPD_B,
	DPAM_HPD_C,
	DPAM_HPD_D,
	DPAM_HPD_E,
	DPAM_HPD_F,
};

struct pmic_glink_altmode;

#define work_to_altmode_port(w) container_of((w), struct pmic_glink_altmode_port, work)

struct pmic_glink_altmode_port {
	struct pmic_glink_altmode *altmode;
	unsigned int index;

	struct typec_switch *typec_switch;
	struct typec_mux *typec_mux;
	struct typec_mux_state state;
	struct typec_retimer *typec_retimer;
	struct typec_retimer_state retimer_state;
	struct typec_altmode dp_alt;
	struct typec_altmode tbt_alt;

	struct work_struct work;

	struct auxiliary_device *bridge;

	enum typec_orientation orientation;
	u16 svid;
	struct usbc_sc8280x_tbt_data tbt_data;
	u8 dp_data;
	u8 mode;
	u8 hpd_state;
	u8 hpd_irq;
	u8 mux_ctrl;
};

#define work_to_altmode(w) container_of((w), struct pmic_glink_altmode, enable_work)

struct pmic_glink_altmode {
	struct device *dev;

	unsigned int owner_id;

	/* To synchronize WRITE_REQ acks */
	struct mutex lock;

	struct completion pan_ack;
	struct pmic_glink_client *client;

	struct work_struct enable_work;

	struct pmic_glink_altmode_port ports[PMIC_GLINK_MAX_PORTS];
};

static int pmic_glink_altmode_request(struct pmic_glink_altmode *altmode, u32 cmd, u32 arg)
{
	struct usbc_write_req req = {};
	unsigned long left;
	int ret;

	/*
	 * The USBC_CMD_WRITE_REQ ack doesn't identify the request, so wait for
	 * one ack at a time.
	 */
	guard(mutex)(&altmode->lock);

	req.hdr.owner = cpu_to_le32(altmode->owner_id);
	req.hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP);
	req.hdr.opcode = cpu_to_le32(USBC_CMD_WRITE_REQ);
	req.cmd = cpu_to_le32(cmd);
	req.arg = cpu_to_le32(arg);

	ret = pmic_glink_send(altmode->client, &req, sizeof(req));
	if (ret) {
		dev_err(altmode->dev, "failed to send altmode request: %#x (%d)\n", cmd, ret);
		return ret;
	}

	left = wait_for_completion_timeout(&altmode->pan_ack, 5 * HZ);
	if (!left) {
		dev_err(altmode->dev, "timeout waiting for altmode request ack for: %#x\n", cmd);
		return -ETIMEDOUT;
	}

	return 0;
}

static void pmic_glink_altmode_enable_dp(struct pmic_glink_altmode *altmode,
					 struct pmic_glink_altmode_port *port,
					 u8 mode, bool hpd_state,
					 bool hpd_irq)
{
	struct typec_displayport_data dp_data = {};
	int ret;

	dp_data.status = DP_STATUS_ENABLED;
	if (hpd_state)
		dp_data.status |= DP_STATUS_HPD_STATE;
	if (hpd_irq)
		dp_data.status |= DP_STATUS_IRQ_HPD;
	dp_data.conf = DP_CONF_SET_PIN_ASSIGN(mode);

	port->state.alt = &port->dp_alt;
	port->state.data = &dp_data;
	port->state.mode = TYPEC_MODAL_STATE(mode);

	ret = typec_mux_set(port->typec_mux, &port->state);
	if (ret)
		dev_err(altmode->dev, "failed to switch mux to DP: %d\n", ret);

	port->retimer_state.alt = &port->dp_alt;
	port->retimer_state.data = &dp_data;
	port->retimer_state.mode = TYPEC_MODAL_STATE(mode);

	ret = typec_retimer_set(port->typec_retimer, &port->retimer_state);
	if (ret)
		dev_err(altmode->dev, "failed to setup retimer to DP: %d\n", ret);
}

static void pmic_glink_altmode_enable_tbt(struct pmic_glink_altmode *altmode,
					  struct pmic_glink_altmode_port *port)
{
	struct usbc_sc8280x_tbt_data *tbt = &port->tbt_data;
	struct typec_thunderbolt_data tbt_data = {};
	u32 cable_speed;
	int ret;

	/* Device Discover Mode VDO */
	tbt_data.device_mode = TBT_MODE;
	tbt_data.device_mode |= TBT_SET_ADAPTER(TBT_ADAPTER_TBT3);

	/* Cable Discover Mode VDO */
	tbt_data.cable_mode = TBT_MODE;

	if (tbt->usb_speed == 0) {
		cable_speed = TBT_CABLE_USB3_PASSIVE;
	} else if (tbt->usb_speed == 1) {
		cable_speed