nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

typec: tcpm: Add support for sink PPS related messages

Browse source 
This commit adds sink side support for Get_Status, Status,
Get_PPS_Status and PPS_Status handling. As there's the
potential for a partner to respond with Not_Supported,
handling of this message is also added. Sending of
Not_Supported is added to handle messagescreceived but not
yet handled.

Signed-off-by: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
Acked-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Adam Thomson 2018-04-23 15:11:01 +01:00 committed by Greg Kroah-Hartman
parent f2a8aa053c
commit 64f7c494a3
1 changed files with 134 additions and 9 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

143
drivers/usb/typec/tcpm.c
View file

@ -19,7 +19,9 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/usb/pd.h> #include <linux/usb/pd.h>
#include <linux/usb/pd_ado.h>
#include <linux/usb/pd_bdo.h> #include <linux/usb/pd_bdo.h>
#include <linux/usb/pd_ext_sdb.h>
#include <linux/usb/pd_vdo.h> #include <linux/usb/pd_vdo.h>
#include <linux/usb/role.h> #include <linux/usb/role.h>
#include <linux/usb/tcpm.h> #include <linux/usb/tcpm.h>
@ -114,6 +116,11 @@
S(SNK_TRYWAIT_VBUS), \ S(SNK_TRYWAIT_VBUS), \
S(BIST_RX), \ 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(ERROR_RECOVERY), \
S(PORT_RESET), \ S(PORT_RESET), \
S(PORT_RESET_WAIT_OFF) S(PORT_RESET_WAIT_OFF)
@ -144,6 +151,7 @@ enum pd_msg_request {
PD_MSG_NONE = 0, PD_MSG_NONE = 0,
PD_MSG_CTRL_REJECT, PD_MSG_CTRL_REJECT,
PD_MSG_CTRL_WAIT, PD_MSG_CTRL_WAIT,
PD_MSG_CTRL_NOT_SUPP,
PD_MSG_DATA_SINK_CAP, PD_MSG_DATA_SINK_CAP,
PD_MSG_DATA_SOURCE_CAP, PD_MSG_DATA_SOURCE_CAP,
}; };
@ -1411,10 +1419,42 @@ static int tcpm_validate_caps(struct tcpm_port *port, const u32 *pdo,
/* /*
* PD (data, control) command handling functions * 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, static int tcpm_pd_send_control(struct tcpm_port *port,
enum pd_ctrl_msg_type type); 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, static void tcpm_pd_data_request(struct tcpm_port *port,
const struct pd_message *msg) const struct pd_message *msg)
{ {
@ -1502,6 +1542,14 @@ static void tcpm_pd_data_request(struct tcpm_port *port,
tcpm_set_state(port, BIST_RX, 0); tcpm_set_state(port, BIST_RX, 0);
} }
break; 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: default:
tcpm_log(port, "Unhandled data message type %#x", type); tcpm_log(port, "Unhandled data message type %#x", type);
break; break;
@ -1584,6 +1632,7 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
break; break;
case PD_CTRL_REJECT: case PD_CTRL_REJECT:
case PD_CTRL_WAIT: case PD_CTRL_WAIT:
case PD_CTRL_NOT_SUPP:
switch (port->state) { switch (port->state) {
case SNK_NEGOTIATE_CAPABILITIES: case SNK_NEGOTIATE_CAPABILITIES:
/* USB PD specification, Figure 8-43 */ /* USB PD specification, Figure 8-43 */
@ -1703,12 +1752,75 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port,
break; break;
} }
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: default:
tcpm_log(port, "Unhandled ctrl message type %#x", type); tcpm_log(port, "Unhandled ctrl message type %#x", type);
break; 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) static void tcpm_pd_rx_handler(struct work_struct *work)
{ {
struct pd_rx_event *event = container_of(work, struct pd_rx_event *event = container_of(work,
@ -1749,7 +1861,9 @@ static void tcpm_pd_rx_handler(struct work_struct *work)
"Data role mismatch, initiating error recovery"); "Data role mismatch, initiating error recovery");
tcpm_set_state(port, ERROR_RECOVERY, 0); tcpm_set_state(port, ERROR_RECOVERY, 0);
} else { } 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); tcpm_pd_data_request(port, msg);
else else
tcpm_pd_ctrl_request(port, msg); tcpm_pd_ctrl_request(port, msg);
@ -1810,6 +1924,9 @@ static bool tcpm_send_queued_message(struct tcpm_port *port)
case PD_MSG_CTRL_REJECT: case PD_MSG_CTRL_REJECT:
tcpm_pd_send_control(port, PD_CTRL_REJECT); tcpm_pd_send_control(port, PD_CTRL_REJECT);
break; break;
case PD_MSG_CTRL_NOT_SUPP:
tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
break;
case PD_MSG_DATA_SINK_CAP: case PD_MSG_DATA_SINK_CAP:
tcpm_pd_send_sink_caps(port); tcpm_pd_send_sink_caps(port);
break; break;
@ -2572,14 +2689,6 @@ static inline enum tcpm_state hard_reset_state(struct tcpm_port *port)
return SNK_UNATTACHED; 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) static inline enum tcpm_state unattached_state(struct tcpm_port *port)
{ {
if (port->port_type == TYPEC_PORT_DRP) { if (port->port_type == TYPEC_PORT_DRP) {
@ -3279,6 +3388,22 @@ static void run_state_machine(struct tcpm_port *port)
/* Always switch to unattached state */ /* Always switch to unattached state */
tcpm_set_state(port, unattached_state(port), 0); tcpm_set_state(port, unattached_state(port), 0);
break; 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: case ERROR_RECOVERY:
tcpm_swap_complete(port, -EPROTO); tcpm_swap_complete(port, -EPROTO);
tcpm_pps_complete(port, -EPROTO); tcpm_pps_complete(port, -EPROTO);