|
|
@@ -12,13 +12,16 @@
|
|
|
#include <linux/kernel.h>
|
|
|
#include <linux/module.h>
|
|
|
#include <linux/mutex.h>
|
|
|
+#include <linux/power_supply.h>
|
|
|
#include <linux/proc_fs.h>
|
|
|
#include <linux/sched/clock.h>
|
|
|
#include <linux/seq_file.h>
|
|
|
#include <linux/slab.h>
|
|
|
#include <linux/spinlock.h>
|
|
|
#include <linux/usb/pd.h>
|
|
|
+#include <linux/usb/pd_ado.h>
|
|
|
#include <linux/usb/pd_bdo.h>
|
|
|
+#include <linux/usb/pd_ext_sdb.h>
|
|
|
#include <linux/usb/pd_vdo.h>
|
|
|
#include <linux/usb/role.h>
|
|
|
#include <linux/usb/tcpm.h>
|
|
|
@@ -48,6 +51,7 @@
|
|
|
S(SNK_DISCOVERY_DEBOUNCE_DONE), \
|
|
|
S(SNK_WAIT_CAPABILITIES), \
|
|
|
S(SNK_NEGOTIATE_CAPABILITIES), \
|
|
|
+ S(SNK_NEGOTIATE_PPS_CAPABILITIES), \
|
|
|
S(SNK_TRANSITION_SINK), \
|
|
|
S(SNK_TRANSITION_SINK_VBUS), \
|
|
|
S(SNK_READY), \
|
|
|
@@ -112,6 +116,11 @@
|
|
|
S(SNK_TRYWAIT_VBUS), \
|
|
|
S(BIST_RX), \
|
|
|
\
|
|
|
+ S(GET_STATUS_SEND), \
|
|
|
+ S(GET_STATUS_SEND_TIMEOUT), \
|
|
|
+ S(GET_PPS_STATUS_SEND), \
|
|
|
+ S(GET_PPS_STATUS_SEND_TIMEOUT), \
|
|
|
+ \
|
|
|
S(ERROR_RECOVERY), \
|
|
|
S(PORT_RESET), \
|
|
|
S(PORT_RESET_WAIT_OFF)
|
|
|
@@ -142,6 +151,7 @@ enum pd_msg_request {
|
|
|
PD_MSG_NONE = 0,
|
|
|
PD_MSG_CTRL_REJECT,
|
|
|
PD_MSG_CTRL_WAIT,
|
|
|
+ PD_MSG_CTRL_NOT_SUPP,
|
|
|
PD_MSG_DATA_SINK_CAP,
|
|
|
PD_MSG_DATA_SOURCE_CAP,
|
|
|
};
|
|
|
@@ -167,6 +177,16 @@ struct pd_mode_data {
|
|
|
struct typec_altmode_desc altmode_desc[SVID_DISCOVERY_MAX];
|
|
|
};
|
|
|
|
|
|
+struct pd_pps_data {
|
|
|
+ u32 min_volt;
|
|
|
+ u32 max_volt;
|
|
|
+ u32 max_curr;
|
|
|
+ u32 out_volt;
|
|
|
+ u32 op_curr;
|
|
|
+ bool supported;
|
|
|
+ bool active;
|
|
|
+};
|
|
|
+
|
|
|
struct tcpm_port {
|
|
|
struct device *dev;
|
|
|
|
|
|
@@ -235,6 +255,7 @@ struct tcpm_port {
|
|
|
struct completion swap_complete;
|
|
|
int swap_status;
|
|
|
|
|
|
+ unsigned int negotiated_rev;
|
|
|
unsigned int message_id;
|
|
|
unsigned int caps_count;
|
|
|
unsigned int hard_reset_count;
|
|
|
@@ -257,15 +278,18 @@ struct tcpm_port {
|
|
|
u32 snk_vdo[VDO_MAX_OBJECTS];
|
|
|
unsigned int nr_snk_vdo;
|
|
|
|
|
|
- unsigned int max_snk_mv;
|
|
|
- unsigned int max_snk_ma;
|
|
|
- unsigned int max_snk_mw;
|
|
|
unsigned int operating_snk_mw;
|
|
|
+ bool update_sink_caps;
|
|
|
|
|
|
/* Requested current / voltage */
|
|
|
u32 current_limit;
|
|
|
u32 supply_voltage;
|
|
|
|
|
|
+ /* Used to export TA voltage and current */
|
|
|
+ struct power_supply *psy;
|
|
|
+ struct power_supply_desc psy_desc;
|
|
|
+ enum power_supply_usb_type usb_type;
|
|
|
+
|
|
|
u32 bist_request;
|
|
|
|
|
|
/* PD state for Vendor Defined Messages */
|
|
|
@@ -277,8 +301,13 @@ struct tcpm_port {
|
|
|
/* VDO to retry if UFP responder replied busy */
|
|
|
u32 vdo_retry;
|
|
|
|
|
|
- /* Alternate mode data */
|
|
|
+ /* PPS */
|
|
|
+ struct pd_pps_data pps_data;
|
|
|
+ struct completion pps_complete;
|
|
|
+ bool pps_pending;
|
|
|
+ int pps_status;
|
|
|
|
|
|
+ /* Alternate mode data */
|
|
|
struct pd_mode_data mode_data;
|
|
|
struct typec_altmode *partner_altmode[SVID_DISCOVERY_MAX];
|
|
|
struct typec_altmode *port_altmode[SVID_DISCOVERY_MAX];
|
|
|
@@ -496,6 +525,16 @@ static void tcpm_log_source_caps(struct tcpm_port *port)
|
|
|
pdo_max_voltage(pdo),
|
|
|
pdo_max_power(pdo));
|
|
|
break;
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo) == APDO_TYPE_PPS)
|
|
|
+ scnprintf(msg, sizeof(msg),
|
|
|
+ "%u-%u mV, %u mA",
|
|
|
+ pdo_pps_apdo_min_voltage(pdo),
|
|
|
+ pdo_pps_apdo_max_voltage(pdo),
|
|
|
+ pdo_pps_apdo_max_current(pdo));
|
|
|
+ else
|
|
|
+ strcpy(msg, "undefined APDO");
|
|
|
+ break;
|
|
|
default:
|
|
|
strcpy(msg, "undefined");
|
|
|
break;
|
|
|
@@ -793,11 +832,13 @@ static int tcpm_pd_send_source_caps(struct tcpm_port *port)
|
|
|
msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id, 0);
|
|
|
} else {
|
|
|
msg.header = PD_HEADER_LE(PD_DATA_SOURCE_CAP,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id,
|
|
|
port->nr_src_pdo);
|
|
|
}
|
|
|
@@ -818,11 +859,13 @@ static int tcpm_pd_send_sink_caps(struct tcpm_port *port)
|
|
|
msg.header = PD_HEADER_LE(PD_CTRL_REJECT,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id, 0);
|
|
|
} else {
|
|
|
msg.header = PD_HEADER_LE(PD_DATA_SINK_CAP,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id,
|
|
|
port->nr_snk_pdo);
|
|
|
}
|
|
|
@@ -1189,6 +1232,7 @@ static void vdm_run_state_machine(struct tcpm_port *port)
|
|
|
msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id, port->vdo_count);
|
|
|
for (i = 0; i < port->vdo_count; i++)
|
|
|
msg.payload[i] = cpu_to_le32(port->vdo_data[i]);
|
|
|
@@ -1260,6 +1304,8 @@ enum pdo_err {
|
|
|
PDO_ERR_FIXED_NOT_SORTED,
|
|
|
PDO_ERR_VARIABLE_BATT_NOT_SORTED,
|
|
|
PDO_ERR_DUPE_PDO,
|
|
|
+ PDO_ERR_PPS_APDO_NOT_SORTED,
|
|
|
+ PDO_ERR_DUPE_PPS_APDO,
|
|
|
};
|
|
|
|
|
|
static const char * const pdo_err_msg[] = {
|
|
|
@@ -1275,6 +1321,10 @@ static const char * const pdo_err_msg[] = {
|
|
|
" err: Variable/Battery supply pdos should be in increasing order of their minimum voltage",
|
|
|
[PDO_ERR_DUPE_PDO] =
|
|
|
" err: Variable/Batt supply pdos cannot have same min/max voltage",
|
|
|
+ [PDO_ERR_PPS_APDO_NOT_SORTED] =
|
|
|
+ " err: Programmable power supply apdos should be in increasing order of their maximum voltage",
|
|
|
+ [PDO_ERR_DUPE_PPS_APDO] =
|
|
|
+ " err: Programmable power supply apdos cannot have same min/max voltage and max current",
|
|
|
};
|
|
|
|
|
|
static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo,
|
|
|
@@ -1324,6 +1374,26 @@ static enum pdo_err tcpm_caps_err(struct tcpm_port *port, const u32 *pdo,
|
|
|
pdo_min_voltage(pdo[i - 1])))
|
|
|
return PDO_ERR_DUPE_PDO;
|
|
|
break;
|
|
|
+ /*
|
|
|
+ * The Programmable Power Supply APDOs, if present,
|
|
|
+ * shall be sent in Maximum Voltage order;
|
|
|
+ * lowest to highest.
|
|
|
+ */
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo[i]) != APDO_TYPE_PPS)
|
|
|
+ break;
|
|
|
+
|
|
|
+ if (pdo_pps_apdo_max_current(pdo[i]) <
|
|
|
+ pdo_pps_apdo_max_current(pdo[i - 1]))
|
|
|
+ return PDO_ERR_PPS_APDO_NOT_SORTED;
|
|
|
+ else if (pdo_pps_apdo_min_voltage(pdo[i]) ==
|
|
|
+ pdo_pps_apdo_min_voltage(pdo[i - 1]) &&
|
|
|
+ pdo_pps_apdo_max_voltage(pdo[i]) ==
|
|
|
+ pdo_pps_apdo_max_voltage(pdo[i - 1]) &&
|
|
|
+ pdo_pps_apdo_max_current(pdo[i]) ==
|
|
|
+ pdo_pps_apdo_max_current(pdo[i - 1]))
|
|
|
+ return PDO_ERR_DUPE_PPS_APDO;
|
|
|
+ break;
|
|
|
default:
|
|
|
tcpm_log_force(port, " Unknown pdo type");
|
|
|
}
|
|
|
@@ -1349,11 +1419,48 @@ static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo,
|
|
|
/*
|
|
|
* PD (data, control) command handling functions
|
|
|
*/
|
|
|
+static inline enum tcpm_state ready_state(struct tcpm_port *port)
|
|
|
+{
|
|
|
+ if (port->pwr_role == TYPEC_SOURCE)
|
|
|
+ return SRC_READY;
|
|
|
+ else
|
|
|
+ return SNK_READY;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_pd_send_control(struct tcpm_port *port,
|
|
|
+ enum pd_ctrl_msg_type type);
|
|
|
+
|
|
|
+static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload,
|
|
|
+ int cnt)
|
|
|
+{
|
|
|
+ u32 p0 = le32_to_cpu(payload[0]);
|
|
|
+ unsigned int type = usb_pd_ado_type(p0);
|
|
|
+
|
|
|
+ if (!type) {
|
|
|
+ tcpm_log(port, "Alert message received with no type");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Just handling non-battery alerts for now */
|
|
|
+ if (!(type & USB_PD_ADO_TYPE_BATT_STATUS_CHANGE)) {
|
|
|
+ switch (port->state) {
|
|
|
+ case SRC_READY:
|
|
|
+ case SNK_READY:
|
|
|
+ tcpm_set_state(port, GET_STATUS_SEND, 0);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_queue_message(port, PD_MSG_CTRL_WAIT);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
static void tcpm_pd_data_request(struct tcpm_port *port,
|
|
|
const struct pd_message *msg)
|
|
|
{
|
|
|
enum pd_data_msg_type type = pd_header_type_le(msg->header);
|
|
|
unsigned int cnt = pd_header_cnt_le(msg->header);
|
|
|
+ unsigned int rev = pd_header_rev_le(msg->header);
|
|
|
unsigned int i;
|
|
|
|
|
|
switch (type) {
|
|
|
@@ -1371,6 +1478,17 @@ static void tcpm_pd_data_request(struct tcpm_port *port,
|
|
|
tcpm_validate_caps(port, port->source_caps,
|
|
|
port->nr_source_caps);
|
|
|
|
|
|
+ /*
|
|
|
+ * Adjust revision in subsequent message headers, as required,
|
|
|
+ * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
|
|
|
+ * support Rev 1.0 so just do nothing in that scenario.
|
|
|
+ */
|
|
|
+ if (rev == PD_REV10)
|
|
|
+ break;
|
|
|
+
|
|
|
+ if (rev < PD_MAX_REV)
|
|
|
+ port->negotiated_rev = rev;
|
|
|
+
|
|
|
/*
|
|
|
* This message may be received even if VBUS is not
|
|
|
* present. This is quite unexpected; see USB PD
|
|
|
@@ -1392,6 +1510,20 @@ static void tcpm_pd_data_request(struct tcpm_port *port,
|
|
|
tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
|
|
|
break;
|
|
|
}
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Adjust revision in subsequent message headers, as required,
|
|
|
+ * to comply with 6.2.1.1.5 of the USB PD 3.0 spec. We don't
|
|
|
+ * support Rev 1.0 so just reject in that scenario.
|
|
|
+ */
|
|
|
+ if (rev == PD_REV10) {
|
|
|
+ tcpm_queue_message(port, PD_MSG_CTRL_REJECT);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (rev < PD_MAX_REV)
|
|
|
+ port->negotiated_rev = rev;
|
|
|
+
|
|
|
port->sink_request = le32_to_cpu(msg->payload[0]);
|
|
|
tcpm_set_state(port, SRC_NEGOTIATE_CAPABILITIES, 0);
|
|
|
break;
|
|
|
@@ -1410,12 +1542,29 @@ static void tcpm_pd_data_request(struct tcpm_port *port,
|
|
|
tcpm_set_state(port, BIST_RX, 0);
|
|
|
}
|
|
|
break;
|
|
|
+ case PD_DATA_ALERT:
|
|
|
+ tcpm_handle_alert(port, msg->payload, cnt);
|
|
|
+ break;
|
|
|
+ case PD_DATA_BATT_STATUS:
|
|
|
+ case PD_DATA_GET_COUNTRY_INFO:
|
|
|
+ /* Currently unsupported */
|
|
|
+ tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
|
|
|
+ break;
|
|
|
default:
|
|
|
tcpm_log(port, "Unhandled data message type %#x", type);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+static void tcpm_pps_complete(struct tcpm_port *port, int result)
|
|
|
+{
|
|
|
+ if (port->pps_pending) {
|
|
|
+ port->pps_status = result;
|
|
|
+ port->pps_pending = false;
|
|
|
+ complete(&port->pps_complete);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
static void tcpm_pd_ctrl_request(struct tcpm_port *port,
|
|
|
const struct pd_message *msg)
|
|
|
{
|
|
|
@@ -1483,6 +1632,7 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
|
|
|
break;
|
|
|
case PD_CTRL_REJECT:
|
|
|
case PD_CTRL_WAIT:
|
|
|
+ case PD_CTRL_NOT_SUPP:
|
|
|
switch (port->state) {
|
|
|
case SNK_NEGOTIATE_CAPABILITIES:
|
|
|
/* USB PD specification, Figure 8-43 */
|
|
|
@@ -1492,6 +1642,14 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
|
|
|
next_state = SNK_WAIT_CAPABILITIES;
|
|
|
tcpm_set_state(port, next_state, 0);
|
|
|
break;
|
|
|
+ case SNK_NEGOTIATE_PPS_CAPABILITIES:
|
|
|
+ /* Revert data back from any requested PPS updates */
|
|
|
+ port->pps_data.out_volt = port->supply_voltage;
|
|
|
+ port->pps_data.op_curr = port->current_limit;
|
|
|
+ port->pps_status = (type == PD_CTRL_WAIT ?
|
|
|
+ -EAGAIN : -EOPNOTSUPP);
|
|
|
+ tcpm_set_state(port, SNK_READY, 0);
|
|
|
+ break;
|
|
|
case DR_SWAP_SEND:
|
|
|
port->swap_status = (type == PD_CTRL_WAIT ?
|
|
|
-EAGAIN : -EOPNOTSUPP);
|
|
|
@@ -1514,6 +1672,13 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
|
|
|
case PD_CTRL_ACCEPT:
|
|
|
switch (port->state) {
|
|
|
case SNK_NEGOTIATE_CAPABILITIES:
|
|
|
+ port->pps_data.active = false;
|
|
|
+ tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
|
|
|
+ break;
|
|
|
+ case SNK_NEGOTIATE_PPS_CAPABILITIES:
|
|
|
+ port->pps_data.active = true;
|
|
|
+ port->supply_voltage = port->pps_data.out_volt;
|
|
|
+ port->current_limit = port->pps_data.op_curr;
|
|
|
tcpm_set_state(port, SNK_TRANSITION_SINK, 0);
|
|
|
break;
|
|
|
case SOFT_RESET_SEND:
|
|
|
@@ -1587,12 +1752,75 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
|
|
|
break;
|
|
|
}
|
|
|
break;
|
|
|
+ case PD_CTRL_GET_SOURCE_CAP_EXT:
|
|
|
+ case PD_CTRL_GET_STATUS:
|
|
|
+ case PD_CTRL_FR_SWAP:
|
|
|
+ case PD_CTRL_GET_PPS_STATUS:
|
|
|
+ case PD_CTRL_GET_COUNTRY_CODES:
|
|
|
+ /* Currently not supported */
|
|
|
+ tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
|
|
|
+ break;
|
|
|
default:
|
|
|
tcpm_log(port, "Unhandled ctrl message type %#x", type);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
|
|
|
+ const struct pd_message *msg)
|
|
|
+{
|
|
|
+ enum pd_ext_msg_type type = pd_header_type_le(msg->header);
|
|
|
+ unsigned int data_size = pd_ext_header_data_size_le(msg->ext_msg.header);
|
|
|
+
|
|
|
+ if (!(msg->ext_msg.header && PD_EXT_HDR_CHUNKED)) {
|
|
|
+ tcpm_log(port, "Unchunked extended messages unsupported");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (data_size > PD_EXT_MAX_CHUNK_DATA) {
|
|
|
+ tcpm_log(port, "Chunk handling not yet supported");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+ case PD_EXT_STATUS:
|
|
|
+ /*
|
|
|
+ * If PPS related events raised then get PPS status to clear
|
|
|
+ * (see USB PD 3.0 Spec, 6.5.2.4)
|
|
|
+ */
|
|
|
+ if (msg->ext_msg.data[USB_PD_EXT_SDB_EVENT_FLAGS] &
|
|
|
+ USB_PD_EXT_SDB_PPS_EVENTS)
|
|
|
+ tcpm_set_state(port, GET_PPS_STATUS_SEND, 0);
|
|
|
+ else
|
|
|
+ tcpm_set_state(port, ready_state(port), 0);
|
|
|
+ break;
|
|
|
+ case PD_EXT_PPS_STATUS:
|
|
|
+ /*
|
|
|
+ * For now the PPS status message is used to clear events
|
|
|
+ * and nothing more.
|
|
|
+ */
|
|
|
+ tcpm_set_state(port, ready_state(port), 0);
|
|
|
+ break;
|
|
|
+ case PD_EXT_SOURCE_CAP_EXT:
|
|
|
+ case PD_EXT_GET_BATT_CAP:
|
|
|
+ case PD_EXT_GET_BATT_STATUS:
|
|
|
+ case PD_EXT_BATT_CAP:
|
|
|
+ case PD_EXT_GET_MANUFACTURER_INFO:
|
|
|
+ case PD_EXT_MANUFACTURER_INFO:
|
|
|
+ case PD_EXT_SECURITY_REQUEST:
|
|
|
+ case PD_EXT_SECURITY_RESPONSE:
|
|
|
+ case PD_EXT_FW_UPDATE_REQUEST:
|
|
|
+ case PD_EXT_FW_UPDATE_RESPONSE:
|
|
|
+ case PD_EXT_COUNTRY_INFO:
|
|
|
+ case PD_EXT_COUNTRY_CODES:
|
|
|
+ tcpm_queue_message(port, PD_MSG_CTRL_NOT_SUPP);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Unhandled extended message type %#x", type);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
static void tcpm_pd_rx_handler(struct work_struct *work)
|
|
|
{
|
|
|
struct pd_rx_event *event = container_of(work,
|
|
|
@@ -1633,7 +1861,9 @@ static void tcpm_pd_rx_handler(struct work_struct *work)
|
|
|
"Data role mismatch, initiating error recovery");
|
|
|
tcpm_set_state(port, ERROR_RECOVERY, 0);
|
|
|
} else {
|
|
|
- if (cnt)
|
|
|
+ if (msg->header & PD_HEADER_EXT_HDR)
|
|
|
+ tcpm_pd_ext_msg_request(port, msg);
|
|
|
+ else if (cnt)
|
|
|
tcpm_pd_data_request(port, msg);
|
|
|
else
|
|
|
tcpm_pd_ctrl_request(port, msg);
|
|
|
@@ -1668,6 +1898,7 @@ static int tcpm_pd_send_control(struct tcpm_port *port,
|
|
|
memset(&msg, 0, sizeof(msg));
|
|
|
msg.header = PD_HEADER_LE(type, port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id, 0);
|
|
|
|
|
|
return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
|
|
|
@@ -1693,6 +1924,9 @@ static bool tcpm_send_queued_message(struct tcpm_port *port)
|
|
|
case PD_MSG_CTRL_REJECT:
|
|
|
tcpm_pd_send_control(port, PD_CTRL_REJECT);
|
|
|
break;
|
|
|
+ case PD_MSG_CTRL_NOT_SUPP:
|
|
|
+ tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
|
|
|
+ break;
|
|
|
case PD_MSG_DATA_SINK_CAP:
|
|
|
tcpm_pd_send_sink_caps(port);
|
|
|
break;
|
|
|
@@ -1772,84 +2006,254 @@ static int tcpm_pd_check_request(struct tcpm_port *port)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-static int tcpm_pd_select_pdo(struct tcpm_port *port)
|
|
|
+#define min_power(x, y) min(pdo_max_power(x), pdo_max_power(y))
|
|
|
+#define min_current(x, y) min(pdo_max_current(x), pdo_max_current(y))
|
|
|
+
|
|
|
+static int tcpm_pd_select_pdo(struct tcpm_port *port, int *sink_pdo,
|
|
|
+ int *src_pdo)
|
|
|
{
|
|
|
- unsigned int i, max_mw = 0, max_mv = 0;
|
|
|
+ unsigned int i, j, max_src_mv = 0, min_src_mv = 0, max_mw = 0,
|
|
|
+ max_mv = 0, src_mw = 0, src_ma = 0, max_snk_mv = 0,
|
|
|
+ min_snk_mv = 0;
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
+ port->pps_data.supported = false;
|
|
|
+ port->usb_type = POWER_SUPPLY_USB_TYPE_PD;
|
|
|
+
|
|
|
/*
|
|
|
- * Select the source PDO providing the most power while staying within
|
|
|
- * the board's voltage limits. Prefer PDO providing exp
|
|
|
+ * Select the source PDO providing the most power which has a
|
|
|
+ * matchig sink cap.
|
|
|
*/
|
|
|
for (i = 0; i < port->nr_source_caps; i++) {
|
|
|
u32 pdo = port->source_caps[i];
|
|
|
enum pd_pdo_type type = pdo_type(pdo);
|
|
|
- unsigned int mv, ma, mw;
|
|
|
|
|
|
- if (type == PDO_TYPE_FIXED)
|
|
|
- mv = pdo_fixed_voltage(pdo);
|
|
|
- else
|
|
|
- mv = pdo_min_voltage(pdo);
|
|
|
+ switch (type) {
|
|
|
+ case PDO_TYPE_FIXED:
|
|
|
+ max_src_mv = pdo_fixed_voltage(pdo);
|
|
|
+ min_src_mv = max_src_mv;
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_BATT:
|
|
|
+ case PDO_TYPE_VAR:
|
|
|
+ max_src_mv = pdo_max_voltage(pdo);
|
|
|
+ min_src_mv = pdo_min_voltage(pdo);
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo) == APDO_TYPE_PPS) {
|
|
|
+ port->pps_data.supported = true;
|
|
|
+ port->usb_type =
|
|
|
+ POWER_SUPPLY_USB_TYPE_PD_PPS;
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Invalid source PDO type, ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
|
|
|
- if (type == PDO_TYPE_BATT) {
|
|
|
- mw = pdo_max_power(pdo);
|
|
|
- } else {
|
|
|
- ma = min(pdo_max_current(pdo),
|
|
|
- port->max_snk_ma);
|
|
|
- mw = ma * mv / 1000;
|
|
|
+ switch (type) {
|
|
|
+ case PDO_TYPE_FIXED:
|
|
|
+ case PDO_TYPE_VAR:
|
|
|
+ src_ma = pdo_max_current(pdo);
|
|
|
+ src_mw = src_ma * min_src_mv / 1000;
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_BATT:
|
|
|
+ src_mw = pdo_max_power(pdo);
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ continue;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Invalid source PDO type, ignoring");
|
|
|
+ continue;
|
|
|
}
|
|
|
|
|
|
- /* Perfer higher voltages if available */
|
|
|
- if ((mw > max_mw || (mw == max_mw && mv > max_mv)) &&
|
|
|
- mv <= port->max_snk_mv) {
|
|
|
- ret = i;
|
|
|
- max_mw = mw;
|
|
|
- max_mv = mv;
|
|
|
+ for (j = 0; j < port->nr_snk_pdo; j++) {
|
|
|
+ pdo = port->snk_pdo[j];
|
|
|
+
|
|
|
+ switch (pdo_type(pdo)) {
|
|
|
+ case PDO_TYPE_FIXED:
|
|
|
+ max_snk_mv = pdo_fixed_voltage(pdo);
|
|
|
+ min_snk_mv = max_snk_mv;
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_BATT:
|
|
|
+ case PDO_TYPE_VAR:
|
|
|
+ max_snk_mv = pdo_max_voltage(pdo);
|
|
|
+ min_snk_mv = pdo_min_voltage(pdo);
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ continue;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Invalid sink PDO type, ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (max_src_mv <= max_snk_mv &&
|
|
|
+ min_src_mv >= min_snk_mv) {
|
|
|
+ /* Prefer higher voltages if available */
|
|
|
+ if ((src_mw == max_mw && min_src_mv > max_mv) ||
|
|
|
+ src_mw > max_mw) {
|
|
|
+ *src_pdo = i;
|
|
|
+ *sink_pdo = j;
|
|
|
+ max_mw = src_mw;
|
|
|
+ max_mv = min_src_mv;
|
|
|
+ ret = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
+#define min_pps_apdo_current(x, y) \
|
|
|
+ min(pdo_pps_apdo_max_current(x), pdo_pps_apdo_max_current(y))
|
|
|
+
|
|
|
+static unsigned int tcpm_pd_select_pps_apdo(struct tcpm_port *port)
|
|
|
+{
|
|
|
+ unsigned int i, j, max_mw = 0, max_mv = 0;
|
|
|
+ unsigned int min_src_mv, max_src_mv, src_ma, src_mw;
|
|
|
+ unsigned int min_snk_mv, max_snk_mv, snk_ma;
|
|
|
+ u32 pdo;
|
|
|
+ unsigned int src_pdo = 0, snk_pdo = 0;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Select the source PPS APDO providing the most power while staying
|
|
|
+ * within the board's limits. We skip the first PDO as this is always
|
|
|
+ * 5V 3A.
|
|
|
+ */
|
|
|
+ for (i = 1; i < port->nr_source_caps; ++i) {
|
|
|
+ pdo = port->source_caps[i];
|
|
|
+
|
|
|
+ switch (pdo_type(pdo)) {
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
|
|
|
+ tcpm_log(port, "Not PPS APDO (source), ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ min_src_mv = pdo_pps_apdo_min_voltage(pdo);
|
|
|
+ max_src_mv = pdo_pps_apdo_max_voltage(pdo);
|
|
|
+ src_ma = pdo_pps_apdo_max_current(pdo);
|
|
|
+ src_mw = (src_ma * max_src_mv) / 1000;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Now search through the sink PDOs to find a matching
|
|
|
+ * PPS APDO. Again skip the first sink PDO as this will
|
|
|
+ * always be 5V 3A.
|
|
|
+ */
|
|
|
+ for (j = i; j < port->nr_snk_pdo; j++) {
|
|
|
+ pdo = port->snk_pdo[j];
|
|
|
+
|
|
|
+ switch (pdo_type(pdo)) {
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
|
|
|
+ tcpm_log(port,
|
|
|
+ "Not PPS APDO (sink), ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ min_snk_mv =
|
|
|
+ pdo_pps_apdo_min_voltage(pdo);
|
|
|
+ max_snk_mv =
|
|
|
+ pdo_pps_apdo_max_voltage(pdo);
|
|
|
+ snk_ma =
|
|
|
+ pdo_pps_apdo_max_current(pdo);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_log(port,
|
|
|
+ "Not APDO type (sink), ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (max_src_mv <= max_snk_mv &&
|
|
|
+ min_src_mv >= min_snk_mv) {
|
|
|
+ /* Prefer higher voltages if available */
|
|
|
+ if ((src_mw == max_mw &&
|
|
|
+ min_src_mv > max_mv) ||
|
|
|
+ src_mw > max_mw) {
|
|
|
+ src_pdo = i;
|
|
|
+ snk_pdo = j;
|
|
|
+ max_mw = src_mw;
|
|
|
+ max_mv = max_src_mv;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Not APDO type (source), ignoring");
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (src_pdo) {
|
|
|
+ pdo = port->source_caps[src_pdo];
|
|
|
+
|
|
|
+ port->pps_data.min_volt = pdo_pps_apdo_min_voltage(pdo);
|
|
|
+ port->pps_data.max_volt = pdo_pps_apdo_max_voltage(pdo);
|
|
|
+ port->pps_data.max_curr =
|
|
|
+ min_pps_apdo_current(pdo, port->snk_pdo[snk_pdo]);
|
|
|
+ port->pps_data.out_volt =
|
|
|
+ min(pdo_pps_apdo_max_voltage(pdo), port->pps_data.out_volt);
|
|
|
+ port->pps_data.op_curr =
|
|
|
+ min(port->pps_data.max_curr, port->pps_data.op_curr);
|
|
|
+ }
|
|
|
+
|
|
|
+ return src_pdo;
|
|
|
+}
|
|
|
+
|
|
|
static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo)
|
|
|
{
|
|
|
unsigned int mv, ma, mw, flags;
|
|
|
unsigned int max_ma, max_mw;
|
|
|
enum pd_pdo_type type;
|
|
|
- int index;
|
|
|
- u32 pdo;
|
|
|
+ u32 pdo, matching_snk_pdo;
|
|
|
+ int src_pdo_index = 0;
|
|
|
+ int snk_pdo_index = 0;
|
|
|
+ int ret;
|
|
|
|
|
|
- index = tcpm_pd_select_pdo(port);
|
|
|
- if (index < 0)
|
|
|
- return -EINVAL;
|
|
|
- pdo = port->source_caps[index];
|
|
|
+ ret = tcpm_pd_select_pdo(port, &snk_pdo_index, &src_pdo_index);
|
|
|
+ if (ret < 0)
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ pdo = port->source_caps[src_pdo_index];
|
|
|
+ matching_snk_pdo = port->snk_pdo[snk_pdo_index];
|
|
|
type = pdo_type(pdo);
|
|
|
|
|
|
- if (type == PDO_TYPE_FIXED)
|
|
|
+ switch (type) {
|
|
|
+ case PDO_TYPE_FIXED:
|
|
|
mv = pdo_fixed_voltage(pdo);
|
|
|
- else
|
|
|
+ break;
|
|
|
+ case PDO_TYPE_BATT:
|
|
|
+ case PDO_TYPE_VAR:
|
|
|
mv = pdo_min_voltage(pdo);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Invalid PDO selected!");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
|
|
|
- /* Select maximum available current within the board's power limit */
|
|
|
+ /* Select maximum available current within the sink pdo's limit */
|
|
|
if (type == PDO_TYPE_BATT) {
|
|
|
- mw = pdo_max_power(pdo);
|
|
|
- ma = 1000 * min(mw, port->max_snk_mw) / mv;
|
|
|
+ mw = min_power(pdo, matching_snk_pdo);
|
|
|
+ ma = 1000 * mw / mv;
|
|
|
} else {
|
|
|
- ma = min(pdo_max_current(pdo),
|
|
|
- 1000 * port->max_snk_mw / mv);
|
|
|
+ ma = min_current(pdo, matching_snk_pdo);
|
|
|
+ mw = ma * mv / 1000;
|
|
|
}
|
|
|
- ma = min(ma, port->max_snk_ma);
|
|
|
|
|
|
flags = RDO_USB_COMM | RDO_NO_SUSPEND;
|
|
|
|
|
|
/* Set mismatch bit if offered power is less than operating power */
|
|
|
- mw = ma * mv / 1000;
|
|
|
max_ma = ma;
|
|
|
max_mw = mw;
|
|
|
if (mw < port->operating_snk_mw) {
|
|
|
flags |= RDO_CAP_MISMATCH;
|
|
|
- max_mw = port->operating_snk_mw;
|
|
|
- max_ma = max_mw * 1000 / mv;
|
|
|
+ if (type == PDO_TYPE_BATT &&
|
|
|
+ (pdo_max_power(matching_snk_pdo) > pdo_max_power(pdo)))
|
|
|
+ max_mw = pdo_max_power(matching_snk_pdo);
|
|
|
+ else if (pdo_max_current(matching_snk_pdo) >
|
|
|
+ pdo_max_current(pdo))
|
|
|
+ max_ma = pdo_max_current(matching_snk_pdo);
|
|
|
}
|
|
|
|
|
|
tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
|
|
|
@@ -1858,16 +2262,16 @@ static int tcpm_pd_build_request(struct tcpm_port *port, u32 *rdo)
|
|
|
port->polarity);
|
|
|
|
|
|
if (type == PDO_TYPE_BATT) {
|
|
|
- *rdo = RDO_BATT(index + 1, mw, max_mw, flags);
|
|
|
+ *rdo = RDO_BATT(src_pdo_index + 1, mw, max_mw, flags);
|
|
|
|
|
|
tcpm_log(port, "Requesting PDO %d: %u mV, %u mW%s",
|
|
|
- index, mv, mw,
|
|
|
+ src_pdo_index, mv, mw,
|
|
|
flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
|
|
|
} else {
|
|
|
- *rdo = RDO_FIXED(index + 1, ma, max_ma, flags);
|
|
|
+ *rdo = RDO_FIXED(src_pdo_index + 1, ma, max_ma, flags);
|
|
|
|
|
|
tcpm_log(port, "Requesting PDO %d: %u mV, %u mA%s",
|
|
|
- index, mv, ma,
|
|
|
+ src_pdo_index, mv, ma,
|
|
|
flags & RDO_CAP_MISMATCH ? " [mismatch]" : "");
|
|
|
}
|
|
|
|
|
|
@@ -1891,6 +2295,105 @@ static int tcpm_pd_send_request(struct tcpm_port *port)
|
|
|
msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
|
|
|
port->pwr_role,
|
|
|
port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
+ port->message_id, 1);
|
|
|
+ msg.payload[0] = cpu_to_le32(rdo);
|
|
|
+
|
|
|
+ return tcpm_pd_transmit(port, TCPC_TX_SOP, &msg);
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_pd_build_pps_request(struct tcpm_port *port, u32 *rdo)
|
|
|
+{
|
|
|
+ unsigned int out_mv, op_ma, op_mw, min_mv, max_mv, max_ma, flags;
|
|
|
+ enum pd_pdo_type type;
|
|
|
+ unsigned int src_pdo_index;
|
|
|
+ u32 pdo;
|
|
|
+
|
|
|
+ src_pdo_index = tcpm_pd_select_pps_apdo(port);
|
|
|
+ if (!src_pdo_index)
|
|
|
+ return -EOPNOTSUPP;
|
|
|
+
|
|
|
+ pdo = port->source_caps[src_pdo_index];
|
|
|
+ type = pdo_type(pdo);
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+ case PDO_TYPE_APDO:
|
|
|
+ if (pdo_apdo_type(pdo) != APDO_TYPE_PPS) {
|
|
|
+ tcpm_log(port, "Invalid APDO selected!");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+ min_mv = port->pps_data.min_volt;
|
|
|
+ max_mv = port->pps_data.max_volt;
|
|
|
+ max_ma = port->pps_data.max_curr;
|
|
|
+ out_mv = port->pps_data.out_volt;
|
|
|
+ op_ma = port->pps_data.op_curr;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tcpm_log(port, "Invalid PDO selected!");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
+ flags = RDO_USB_COMM | RDO_NO_SUSPEND;
|
|
|
+
|
|
|
+ op_mw = (op_ma * out_mv) / 1000;
|
|
|
+ if (op_mw < port->operating_snk_mw) {
|
|
|
+ /*
|
|
|
+ * Try raising current to meet power needs. If that's not enough
|
|
|
+ * then try upping the voltage. If that's still not enough
|
|
|
+ * then we've obviously chosen a PPS APDO which really isn't
|
|
|
+ * suitable so abandon ship.
|
|
|
+ */
|
|
|
+ op_ma = (port->operating_snk_mw * 1000) / out_mv;
|
|
|
+ if ((port->operating_snk_mw * 1000) % out_mv)
|
|
|
+ ++op_ma;
|
|
|
+ op_ma += RDO_PROG_CURR_MA_STEP - (op_ma % RDO_PROG_CURR_MA_STEP);
|
|
|
+
|
|
|
+ if (op_ma > max_ma) {
|
|
|
+ op_ma = max_ma;
|
|
|
+ out_mv = (port->operating_snk_mw * 1000) / op_ma;
|
|
|
+ if ((port->operating_snk_mw * 1000) % op_ma)
|
|
|
+ ++out_mv;
|
|
|
+ out_mv += RDO_PROG_VOLT_MV_STEP -
|
|
|
+ (out_mv % RDO_PROG_VOLT_MV_STEP);
|
|
|
+
|
|
|
+ if (out_mv > max_mv) {
|
|
|
+ tcpm_log(port, "Invalid PPS APDO selected!");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ tcpm_log(port, "cc=%d cc1=%d cc2=%d vbus=%d vconn=%s polarity=%d",
|
|
|
+ port->cc_req, port->cc1, port->cc2, port->vbus_source,
|
|
|
+ port->vconn_role == TYPEC_SOURCE ? "source" : "sink",
|
|
|
+ port->polarity);
|
|
|
+
|
|
|
+ *rdo = RDO_PROG(src_pdo_index + 1, out_mv, op_ma, flags);
|
|
|
+
|
|
|
+ tcpm_log(port, "Requesting APDO %d: %u mV, %u mA",
|
|
|
+ src_pdo_index, out_mv, op_ma);
|
|
|
+
|
|
|
+ port->pps_data.op_curr = op_ma;
|
|
|
+ port->pps_data.out_volt = out_mv;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_pd_send_pps_request(struct tcpm_port *port)
|
|
|
+{
|
|
|
+ struct pd_message msg;
|
|
|
+ int ret;
|
|
|
+ u32 rdo;
|
|
|
+
|
|
|
+ ret = tcpm_pd_build_pps_request(port, &rdo);
|
|
|
+ if (ret < 0)
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ memset(&msg, 0, sizeof(msg));
|
|
|
+ msg.header = PD_HEADER_LE(PD_DATA_REQUEST,
|
|
|
+ port->pwr_role,
|
|
|
+ port->data_role,
|
|
|
+ port->negotiated_rev,
|
|
|
port->message_id, 1);
|
|
|
msg.payload[0] = cpu_to_le32(rdo);
|
|
|
|
|
|
@@ -2077,6 +2580,7 @@ static void tcpm_reset_port(struct tcpm_port *port)
|
|
|
tcpm_typec_disconnect(port);
|
|
|
port->attached = false;
|
|
|
port->pd_capable = false;
|
|
|
+ port->pps_data.supported = false;
|
|
|
|
|
|
/*
|
|
|
* First Rx ID should be 0; set this to a sentinel of -1 so that
|
|
|
@@ -2094,6 +2598,11 @@ static void tcpm_reset_port(struct tcpm_port *port)
|
|
|
tcpm_set_attached_state(port, false);
|
|
|
port->try_src_count = 0;
|
|
|
port->try_snk_count = 0;
|
|
|
+ port->supply_voltage = 0;
|
|
|
+ port->current_limit = 0;
|
|
|
+ port->usb_type = POWER_SUPPLY_USB_TYPE_C;
|
|
|
+
|
|
|
+ power_supply_changed(port->psy);
|
|
|
}
|
|
|
|
|
|
static void tcpm_detach(struct tcpm_port *port)
|
|
|
@@ -2181,14 +2690,6 @@ static inline enum tcpm_state hard_reset_state(struct tcpm_port *port)
|
|
|
return SNK_UNATTACHED;
|
|
|
}
|
|
|
|
|
|
-static inline enum tcpm_state ready_state(struct tcpm_port *port)
|
|
|
-{
|
|
|
- if (port->pwr_role == TYPEC_SOURCE)
|
|
|
- return SRC_READY;
|
|
|
- else
|
|
|
- return SNK_READY;
|
|
|
-}
|
|
|
-
|
|
|
static inline enum tcpm_state unattached_state(struct tcpm_port *port)
|
|
|
{
|
|
|
if (port->port_type == TYPEC_PORT_DRP) {
|
|
|
@@ -2338,6 +2839,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
typec_set_pwr_opmode(port->typec_port, opmode);
|
|
|
port->pwr_opmode = TYPEC_PWR_MODE_USB;
|
|
|
port->caps_count = 0;
|
|
|
+ port->negotiated_rev = PD_MAX_REV;
|
|
|
port->message_id = 0;
|
|
|
port->rx_msgid = -1;
|
|
|
port->explicit_contract = false;
|
|
|
@@ -2398,6 +2900,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
|
|
|
tcpm_swap_complete(port, 0);
|
|
|
tcpm_typec_connect(port);
|
|
|
+
|
|
|
tcpm_check_send_discover(port);
|
|
|
/*
|
|
|
* 6.3.5
|
|
|
@@ -2421,6 +2924,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
case SNK_UNATTACHED:
|
|
|
if (!port->non_pd_role_swap)
|
|
|
tcpm_swap_complete(port, -ENOTCONN);
|
|
|
+ tcpm_pps_complete(port, -ENOTCONN);
|
|
|
tcpm_snk_detach(port);
|
|
|
if (tcpm_start_drp_toggling(port)) {
|
|
|
tcpm_set_state(port, DRP_TOGGLING, 0);
|
|
|
@@ -2510,6 +3014,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
port->cc2 : port->cc1);
|
|
|
typec_set_pwr_opmode(port->typec_port, opmode);
|
|
|
port->pwr_opmode = TYPEC_PWR_MODE_USB;
|
|
|
+ port->negotiated_rev = PD_MAX_REV;
|
|
|
port->message_id = 0;
|
|
|
port->rx_msgid = -1;
|
|
|
port->explicit_contract = false;
|
|
|
@@ -2580,6 +3085,24 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
PD_T_SENDER_RESPONSE);
|
|
|
}
|
|
|
break;
|
|
|
+ case SNK_NEGOTIATE_PPS_CAPABILITIES:
|
|
|
+ ret = tcpm_pd_send_pps_request(port);
|
|
|
+ if (ret < 0) {
|
|
|
+ port->pps_status = ret;
|
|
|
+ /*
|
|
|
+ * If this was called due to updates to sink
|
|
|
+ * capabilities, and pps is no longer valid, we should
|
|
|
+ * safely fall back to a standard PDO.
|
|
|
+ */
|
|
|
+ if (port->update_sink_caps)
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
|
|
|
+ else
|
|
|
+ tcpm_set_state(port, SNK_READY, 0);
|
|
|
+ } else {
|
|
|
+ tcpm_set_state_cond(port, hard_reset_state(port),
|
|
|
+ PD_T_SENDER_RESPONSE);
|
|
|
+ }
|
|
|
+ break;
|
|
|
case SNK_TRANSITION_SINK:
|
|
|
case SNK_TRANSITION_SINK_VBUS:
|
|
|
tcpm_set_state(port, hard_reset_state(port),
|
|
|
@@ -2587,6 +3110,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
break;
|
|
|
case SNK_READY:
|
|
|
port->try_snk_count = 0;
|
|
|
+ port->update_sink_caps = false;
|
|
|
if (port->explicit_contract) {
|
|
|
typec_set_pwr_opmode(port->typec_port,
|
|
|
TYPEC_PWR_MODE_PD);
|
|
|
@@ -2596,6 +3120,10 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
tcpm_swap_complete(port, 0);
|
|
|
tcpm_typec_connect(port);
|
|
|
tcpm_check_send_discover(port);
|
|
|
+ tcpm_pps_complete(port, port->pps_status);
|
|
|
+
|
|
|
+ power_supply_changed(port->psy);
|
|
|
+
|
|
|
break;
|
|
|
|
|
|
/* Accessory states */
|
|
|
@@ -2642,6 +3170,7 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON);
|
|
|
break;
|
|
|
case SNK_HARD_RESET_SINK_OFF:
|
|
|
+ memset(&port->pps_data, 0, sizeof(port->pps_data));
|
|
|
tcpm_set_vconn(port, false);
|
|
|
tcpm_set_charge(port, false);
|
|
|
tcpm_set_roles(port, false, TYPEC_SINK, TYPEC_DEVICE);
|
|
|
@@ -2860,8 +3389,25 @@ static void run_state_machine(struct tcpm_port *port)
|
|
|
/* Always switch to unattached state */
|
|
|
tcpm_set_state(port, unattached_state(port), 0);
|
|
|
break;
|
|
|
+ case GET_STATUS_SEND:
|
|
|
+ tcpm_pd_send_control(port, PD_CTRL_GET_STATUS);
|
|
|
+ tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT,
|
|
|
+ PD_T_SENDER_RESPONSE);
|
|
|
+ break;
|
|
|
+ case GET_STATUS_SEND_TIMEOUT:
|
|
|
+ tcpm_set_state(port, ready_state(port), 0);
|
|
|
+ break;
|
|
|
+ case GET_PPS_STATUS_SEND:
|
|
|
+ tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS);
|
|
|
+ tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT,
|
|
|
+ PD_T_SENDER_RESPONSE);
|
|
|
+ break;
|
|
|
+ case GET_PPS_STATUS_SEND_TIMEOUT:
|
|
|
+ tcpm_set_state(port, ready_state(port), 0);
|
|
|
+ break;
|
|
|
case ERROR_RECOVERY:
|
|
|
tcpm_swap_complete(port, -EPROTO);
|
|
|
+ tcpm_pps_complete(port, -EPROTO);
|
|
|
tcpm_set_state(port, PORT_RESET, 0);
|
|
|
break;
|
|
|
case PORT_RESET:
|
|
|
@@ -3444,6 +3990,162 @@ static int tcpm_try_role(const struct typec_capability *cap, int role)
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
+static int tcpm_pps_set_op_curr(struct tcpm_port *port, u16 op_curr)
|
|
|
+{
|
|
|
+ unsigned int target_mw;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ mutex_lock(&port->swap_lock);
|
|
|
+ mutex_lock(&port->lock);
|
|
|
+
|
|
|
+ if (!port->pps_data.active) {
|
|
|
+ ret = -EOPNOTSUPP;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (port->state != SNK_READY) {
|
|
|
+ ret = -EAGAIN;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (op_curr > port->pps_data.max_curr) {
|
|
|
+ ret = -EINVAL;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ target_mw = (op_curr * port->pps_data.out_volt) / 1000;
|
|
|
+ if (target_mw < port->operating_snk_mw) {
|
|
|
+ ret = -EINVAL;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ reinit_completion(&port->pps_complete);
|
|
|
+ port->pps_data.op_curr = op_curr;
|
|
|
+ port->pps_status = 0;
|
|
|
+ port->pps_pending = true;
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0);
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+
|
|
|
+ if (!wait_for_completion_timeout(&port->pps_complete,
|
|
|
+ msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
|
|
|
+ ret = -ETIMEDOUT;
|
|
|
+ else
|
|
|
+ ret = port->pps_status;
|
|
|
+
|
|
|
+ goto swap_unlock;
|
|
|
+
|
|
|
+port_unlock:
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+swap_unlock:
|
|
|
+ mutex_unlock(&port->swap_lock);
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_pps_set_out_volt(struct tcpm_port *port, u16 out_volt)
|
|
|
+{
|
|
|
+ unsigned int target_mw;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ mutex_lock(&port->swap_lock);
|
|
|
+ mutex_lock(&port->lock);
|
|
|
+
|
|
|
+ if (!port->pps_data.active) {
|
|
|
+ ret = -EOPNOTSUPP;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (port->state != SNK_READY) {
|
|
|
+ ret = -EAGAIN;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (out_volt < port->pps_data.min_volt ||
|
|
|
+ out_volt > port->pps_data.max_volt) {
|
|
|
+ ret = -EINVAL;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ target_mw = (port->pps_data.op_curr * out_volt) / 1000;
|
|
|
+ if (target_mw < port->operating_snk_mw) {
|
|
|
+ ret = -EINVAL;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ reinit_completion(&port->pps_complete);
|
|
|
+ port->pps_data.out_volt = out_volt;
|
|
|
+ port->pps_status = 0;
|
|
|
+ port->pps_pending = true;
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0);
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+
|
|
|
+ if (!wait_for_completion_timeout(&port->pps_complete,
|
|
|
+ msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
|
|
|
+ ret = -ETIMEDOUT;
|
|
|
+ else
|
|
|
+ ret = port->pps_status;
|
|
|
+
|
|
|
+ goto swap_unlock;
|
|
|
+
|
|
|
+port_unlock:
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+swap_unlock:
|
|
|
+ mutex_unlock(&port->swap_lock);
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_pps_activate(struct tcpm_port *port, bool activate)
|
|
|
+{
|
|
|
+ int ret = 0;
|
|
|
+
|
|
|
+ mutex_lock(&port->swap_lock);
|
|
|
+ mutex_lock(&port->lock);
|
|
|
+
|
|
|
+ if (!port->pps_data.supported) {
|
|
|
+ ret = -EOPNOTSUPP;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Trying to deactivate PPS when already deactivated so just bail */
|
|
|
+ if (!port->pps_data.active && !activate)
|
|
|
+ goto port_unlock;
|
|
|
+
|
|
|
+ if (port->state != SNK_READY) {
|
|
|
+ ret = -EAGAIN;
|
|
|
+ goto port_unlock;
|
|
|
+ }
|
|
|
+
|
|
|
+ reinit_completion(&port->pps_complete);
|
|
|
+ port->pps_status = 0;
|
|
|
+ port->pps_pending = true;
|
|
|
+
|
|
|
+ /* Trigger PPS request or move back to standard PDO contract */
|
|
|
+ if (activate) {
|
|
|
+ port->pps_data.out_volt = port->supply_voltage;
|
|
|
+ port->pps_data.op_curr = port->current_limit;
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0);
|
|
|
+ } else {
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
|
|
|
+ }
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+
|
|
|
+ if (!wait_for_completion_timeout(&port->pps_complete,
|
|
|
+ msecs_to_jiffies(PD_PPS_CTRL_TIMEOUT)))
|
|
|
+ ret = -ETIMEDOUT;
|
|
|
+ else
|
|
|
+ ret = port->pps_status;
|
|
|
+
|
|
|
+ goto swap_unlock;
|
|
|
+
|
|
|
+port_unlock:
|
|
|
+ mutex_unlock(&port->lock);
|
|
|
+swap_unlock:
|
|
|
+ mutex_unlock(&port->swap_lock);
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
static void tcpm_init(struct tcpm_port *port)
|
|
|
{
|
|
|
enum typec_cc_status cc1, cc2;
|
|
|
@@ -3569,9 +4271,6 @@ EXPORT_SYMBOL_GPL(tcpm_update_source_capabilities);
|
|
|
|
|
|
int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
|
|
|
unsigned int nr_pdo,
|
|
|
- unsigned int max_snk_mv,
|
|
|
- unsigned int max_snk_ma,
|
|
|
- unsigned int max_snk_mw,
|
|
|
unsigned int operating_snk_mw)
|
|
|
{
|
|
|
if (tcpm_validate_caps(port, pdo, nr_pdo))
|
|
|
@@ -3579,17 +4278,19 @@ int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
|
|
|
|
|
|
mutex_lock(&port->lock);
|
|
|
port->nr_snk_pdo = tcpm_copy_pdos(port->snk_pdo, pdo, nr_pdo);
|
|
|
- port->max_snk_mv = max_snk_mv;
|
|
|
- port->max_snk_ma = max_snk_ma;
|
|
|
- port->max_snk_mw = max_snk_mw;
|
|
|
port->operating_snk_mw = operating_snk_mw;
|
|
|
+ port->update_sink_caps = true;
|
|
|
|
|
|
switch (port->state) {
|
|
|
case SNK_NEGOTIATE_CAPABILITIES:
|
|
|
+ case SNK_NEGOTIATE_PPS_CAPABILITIES:
|
|
|
case SNK_READY:
|
|
|
case SNK_TRANSITION_SINK:
|
|
|
case SNK_TRANSITION_SINK_VBUS:
|
|
|
- tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
|
|
|
+ if (port->pps_data.active)
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_PPS_CAPABILITIES, 0);
|
|
|
+ else
|
|
|
+ tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
@@ -3599,6 +4300,230 @@ int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
|
|
|
}
|
|
|
EXPORT_SYMBOL_GPL(tcpm_update_sink_capabilities);
|
|
|
|
|
|
+/* Power Supply access to expose source power information */
|
|
|
+enum tcpm_psy_online_states {
|
|
|
+ TCPM_PSY_OFFLINE = 0,
|
|
|
+ TCPM_PSY_FIXED_ONLINE,
|
|
|
+ TCPM_PSY_PROG_ONLINE,
|
|
|
+};
|
|
|
+
|
|
|
+static enum power_supply_property tcpm_psy_props[] = {
|
|
|
+ POWER_SUPPLY_PROP_USB_TYPE,
|
|
|
+ POWER_SUPPLY_PROP_ONLINE,
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_MIN,
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_MAX,
|
|
|
+ POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
+ POWER_SUPPLY_PROP_CURRENT_MAX,
|
|
|
+ POWER_SUPPLY_PROP_CURRENT_NOW,
|
|
|
+};
|
|
|
+
|
|
|
+static int tcpm_psy_get_online(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ if (port->vbus_charge) {
|
|
|
+ if (port->pps_data.active)
|
|
|
+ val->intval = TCPM_PSY_PROG_ONLINE;
|
|
|
+ else
|
|
|
+ val->intval = TCPM_PSY_FIXED_ONLINE;
|
|
|
+ } else {
|
|
|
+ val->intval = TCPM_PSY_OFFLINE;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_voltage_min(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ if (port->pps_data.active)
|
|
|
+ val->intval = port->pps_data.min_volt * 1000;
|
|
|
+ else
|
|
|
+ val->intval = port->supply_voltage * 1000;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_voltage_max(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ if (port->pps_data.active)
|
|
|
+ val->intval = port->pps_data.max_volt * 1000;
|
|
|
+ else
|
|
|
+ val->intval = port->supply_voltage * 1000;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_voltage_now(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ val->intval = port->supply_voltage * 1000;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_current_max(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ if (port->pps_data.active)
|
|
|
+ val->intval = port->pps_data.max_curr * 1000;
|
|
|
+ else
|
|
|
+ val->intval = port->current_limit * 1000;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_current_now(struct tcpm_port *port,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ val->intval = port->current_limit * 1000;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_get_prop(struct power_supply *psy,
|
|
|
+ enum power_supply_property psp,
|
|
|
+ union power_supply_propval *val)
|
|
|
+{
|
|
|
+ struct tcpm_port *port = power_supply_get_drvdata(psy);
|
|
|
+ int ret = 0;
|
|
|
+
|
|
|
+ switch (psp) {
|
|
|
+ case POWER_SUPPLY_PROP_USB_TYPE:
|
|
|
+ val->intval = port->usb_type;
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_ONLINE:
|
|
|
+ ret = tcpm_psy_get_online(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_MIN:
|
|
|
+ ret = tcpm_psy_get_voltage_min(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_MAX:
|
|
|
+ ret = tcpm_psy_get_voltage_max(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
|
+ ret = tcpm_psy_get_voltage_now(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_CURRENT_MAX:
|
|
|
+ ret = tcpm_psy_get_current_max(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_CURRENT_NOW:
|
|
|
+ ret = tcpm_psy_get_current_now(port, val);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ ret = -EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_set_online(struct tcpm_port *port,
|
|
|
+ const union power_supply_propval *val)
|
|
|
+{
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ switch (val->intval) {
|
|
|
+ case TCPM_PSY_FIXED_ONLINE:
|
|
|
+ ret = tcpm_pps_activate(port, false);
|
|
|
+ break;
|
|
|
+ case TCPM_PSY_PROG_ONLINE:
|
|
|
+ ret = tcpm_pps_activate(port, true);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ ret = -EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_set_prop(struct power_supply *psy,
|
|
|
+ enum power_supply_property psp,
|
|
|
+ const union power_supply_propval *val)
|
|
|
+{
|
|
|
+ struct tcpm_port *port = power_supply_get_drvdata(psy);
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ switch (psp) {
|
|
|
+ case POWER_SUPPLY_PROP_ONLINE:
|
|
|
+ ret = tcpm_psy_set_online(port, val);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
|
+ if (val->intval < port->pps_data.min_volt * 1000 ||
|
|
|
+ val->intval > port->pps_data.max_volt * 1000)
|
|
|
+ ret = -EINVAL;
|
|
|
+ else
|
|
|
+ ret = tcpm_pps_set_out_volt(port, val->intval / 1000);
|
|
|
+ break;
|
|
|
+ case POWER_SUPPLY_PROP_CURRENT_NOW:
|
|
|
+ if (val->intval > port->pps_data.max_curr * 1000)
|
|
|
+ ret = -EINVAL;
|
|
|
+ else
|
|
|
+ ret = tcpm_pps_set_op_curr(port, val->intval / 1000);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ ret = -EINVAL;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static int tcpm_psy_prop_writeable(struct power_supply *psy,
|
|
|
+ enum power_supply_property psp)
|
|
|
+{
|
|
|
+ switch (psp) {
|
|
|
+ case POWER_SUPPLY_PROP_ONLINE:
|
|
|
+ case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
|
+ case POWER_SUPPLY_PROP_CURRENT_NOW:
|
|
|
+ return 1;
|
|
|
+ default:
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static enum power_supply_usb_type tcpm_psy_usb_types[] = {
|
|
|
+ POWER_SUPPLY_USB_TYPE_C,
|
|
|
+ POWER_SUPPLY_USB_TYPE_PD,
|
|
|
+ POWER_SUPPLY_USB_TYPE_PD_PPS,
|
|
|
+};
|
|
|
+
|
|
|
+static const char *tcpm_psy_name_prefix = "tcpm-source-psy-";
|
|
|
+
|
|
|
+static int devm_tcpm_psy_register(struct tcpm_port *port)
|
|
|
+{
|
|
|
+ struct power_supply_config psy_cfg = {};
|
|
|
+ const char *port_dev_name = dev_name(port->dev);
|
|
|
+ size_t psy_name_len = strlen(tcpm_psy_name_prefix) +
|
|
|
+ strlen(port_dev_name) + 1;
|
|
|
+ char *psy_name;
|
|
|
+
|
|
|
+ psy_cfg.drv_data = port;
|
|
|
+ psy_name = devm_kzalloc(port->dev, psy_name_len, GFP_KERNEL);
|
|
|
+ if (!psy_name)
|
|
|
+ return -ENOMEM;
|
|
|
+
|
|
|
+ snprintf(psy_name, psy_name_len, "%s%s", tcpm_psy_name_prefix,
|
|
|
+ port_dev_name);
|
|
|
+ port->psy_desc.name = psy_name;
|
|
|
+ port->psy_desc.type = POWER_SUPPLY_TYPE_USB,
|
|
|
+ port->psy_desc.usb_types = tcpm_psy_usb_types;
|
|
|
+ port->psy_desc.num_usb_types = ARRAY_SIZE(tcpm_psy_usb_types);
|
|
|
+ port->psy_desc.properties = tcpm_psy_props,
|
|
|
+ port->psy_desc.num_properties = ARRAY_SIZE(tcpm_psy_props),
|
|
|
+ port->psy_desc.get_property = tcpm_psy_get_prop,
|
|
|
+ port->psy_desc.set_property = tcpm_psy_set_prop,
|
|
|
+ port->psy_desc.property_is_writeable = tcpm_psy_prop_writeable,
|
|
|
+
|
|
|
+ port->usb_type = POWER_SUPPLY_USB_TYPE_C;
|
|
|
+
|
|
|
+ port->psy = devm_power_supply_register(port->dev, &port->psy_desc,
|
|
|
+ &psy_cfg);
|
|
|
+
|
|
|
+ return PTR_ERR_OR_ZERO(port->psy);
|
|
|
+}
|
|
|
+
|
|
|
struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
|
|
|
{
|
|
|
struct tcpm_port *port;
|
|
|
@@ -3631,6 +4556,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
|
|
|
|
|
|
init_completion(&port->tx_complete);
|
|
|
init_completion(&port->swap_complete);
|
|
|
+ init_completion(&port->pps_complete);
|
|
|
tcpm_debugfs_init(port);
|
|
|
|
|
|
if (tcpm_validate_caps(port, tcpc->config->src_pdo,
|
|
|
@@ -3647,9 +4573,6 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
|
|
|
port->nr_snk_vdo = tcpm_copy_vdos(port->snk_vdo, tcpc->config->snk_vdo,
|
|
|
tcpc->config->nr_snk_vdo);
|
|
|
|
|
|
- port->max_snk_mv = tcpc->config->max_snk_mv;
|
|
|
- port->max_snk_ma = tcpc->config->max_snk_ma;
|
|
|
- port->max_snk_mw = tcpc->config->max_snk_mw;
|
|
|
port->operating_snk_mw = tcpc->config->operating_snk_mw;
|
|
|
if (!tcpc->config->try_role_hw)
|
|
|
port->try_role = tcpc->config->default_role;
|
|
|
@@ -3660,7 +4583,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
|
|
|
port->typec_caps.type = tcpc->config->type;
|
|
|
port->typec_caps.data = tcpc->config->data;
|
|
|
port->typec_caps.revision = 0x0120; /* Type-C spec release 1.2 */
|
|
|
- port->typec_caps.pd_revision = 0x0200; /* USB-PD spec release 2.0 */
|
|
|
+ port->typec_caps.pd_revision = 0x0300; /* USB-PD spec release 3.0 */
|
|
|
port->typec_caps.dr_set = tcpm_dr_set;
|
|
|
port->typec_caps.pr_set = tcpm_pr_set;
|
|
|
port->typec_caps.vconn_set = tcpm_vconn_set;
|
|
|
@@ -3676,6 +4599,10 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
|
|
|
goto out_destroy_wq;
|
|
|
}
|
|
|
|
|
|
+ err = devm_tcpm_psy_register(port);
|
|
|
+ if (err)
|
|
|
+ goto out_destroy_wq;
|
|
|
+
|
|
|
port->typec_port = typec_register_port(port->dev, &port->typec_caps);
|
|
|
if (IS_ERR(port->typec_port)) {
|
|
|
err = PTR_ERR(port->typec_port);
|
Sebastian Reichel