From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-1286548-1524492785-2-16499339986341273 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no ("Email failed DMARC policy for domain") X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, FROM_WORDY 2.5, HEADER_FROM_DIFFERENT_DOMAINS 0.25, MAILING_LIST_MULTI -1, ME_NOAUTH 0.01, RCVD_IN_DNSWL_HI -5, LANGUAGES roensk.us-ascii, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='US', FromHeader='com', MailFrom='org', XOriginatingCountry='GB' X-Spam-charsets: X-IgnoreVacation: yes ("Email failed DMARC policy for domain") X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: linux-usb-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=fm2; t= 1524492784; b=VbKVA5Ou4koaw0Vlsu3046ESpKSKwOIuBSIdi3lcp8Zcy6zYU7 7cn2TTw976g9Injfsb5pyC6b0VOPXK6dWEHUcROsF02603PDjmGAfevkaBhmh+sZ YtAElfe1sz2JsHVewAeDz1tsg/V/Sw9Z48Olr5eUNcIKnMJWqC5Eon7RwK/QykUj IIoV1V6SQjVraaJA7atcz3wkjOr5soXeGHCOSnA9B6UDeEEOSrFI2QcKB0Ckwpea l45GMB1FXWWgpMSWSE9r40tm8l7mLlDDvhwLBZ2yULQ9+xt6RRdM2l/+A+NmIgcC bC37tWaHVOrEJ/o00Lz6ViSW9b72taigX63Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=message-id:in-reply-to:references:from :date:subject:to:cc:mime-version:content-type:sender:list-id; s= fm2; t=1524492784; bh=RtA4WvprojRa0jowVfcWen+om8axqCMBLm/9SaSwMP Y=; b=qjVEg8w9iONIHld9P/9nYUWWUf3VAOwSG0LEEc4EggOfzZjRa1GqRs5e7w Sl7bd0JDwvT9a//+etYJ0Vunv0u0N8GZmejrjh8liuE8/6oYES/y8oddTcqR4fKy /jdLPykt/SRu/Pw4kir3iwkL6I9UtT+MHBHOZ+bkvTb0qGkoWCxtr0C5kEOsbONb 1T6acODo7IhHwFY9Ij70EH4ObfbolmVSA7poykqbwdeSjJKBMEzDoa1tFW0B/v3x U4AzLo+6lAmHgX5jCpXD2z56SPv1KKr0xNZuUw/KHQm+M/U05LfeyZjZWhYUYwQz AFFSZcJT1/4gJmmXcvpZaDuqG95Q== ARC-Authentication-Results: i=1; mx4.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=fail (p=none,has-list-id=yes,d=none) header.from=diasemi.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=diasemi.com header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 Authentication-Results: mx4.messagingengine.com; arc=none (no signatures found); dkim=none (no signatures found); dmarc=fail (p=none,has-list-id=yes,d=none) header.from=diasemi.com; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=diasemi.com header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 X-ME-VSCategory: clean X-CM-Envelope: MS4wfKoVSaXIb0d4aHN5RW07kYk2kfh/GbfylQLyY1OiuZJuXcWv6JU5aPOeenV0faEls7XBMq8DuL+XfbzIyR6nHQe4wfAu4aqkaPfMTJ6+HEyu+m20HhKK B+L+G6aERRfqNDgI2EqTmqQm5T3mmbXlqYS2lKxeKOKceE4zL6EmiILHBwOtc6bPF/O2iadDB3sHzuqe17wV8HtDlPYkAndsfYbRWVd9011UNOuyuDB7/mIZ X-CM-Analysis: v=2.3 cv=JLoVTfCb c=1 sm=1 tr=0 a=UK1r566ZdBxH71SXbqIOeA==:117 a=UK1r566ZdBxH71SXbqIOeA==:17 a=QRjQRLzp78EA:10 a=Kd1tUaAdevIA:10 a=X3a0BiUdAAAA:8 a=QyXUC8HyAAAA:8 a=_jlGtV7tAAAA:8 a=VwQbUJbxAAAA:8 a=0YxI6ZFVX9mkkzgxLIQA:9 a=x8gzFH9gYPwA:10 a=aWu3muFgq6otJbhCXpL5:22 a=nlm17XC03S6CtCLSeiRr:22 a=AjGcO6oz07-iQ99wixmX:22 X-ME-CMScore: 0 X-ME-CMCategory: none Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755543AbeDWOLO (ORCPT ); Mon, 23 Apr 2018 10:11:14 -0400 Received: from mail1.bemta5.messagelabs.com ([195.245.231.149]:14397 "EHLO mail1.bemta5.messagelabs.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755494AbeDWOLD (ORCPT ); Mon, 23 Apr 2018 10:11:03 -0400 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFupileJIrShJLcpLzFFi42KJ27nUWLfs5d0 og0et4hbNi9ezWbw5Pp3Jomv1ThaLa8d6mSwu75rDZvG59wijxaJlrcwWTxaeYbI4vbvEgdNj 06pONo95JwM99s9dw+6x8d0OJo/3+66yeez83sDu8XmTXAB7FGtmXlJ+RQJrRv+MFawFRy0r9 t9ewtrAeNCgi5GLQ0hgPaPEiilnmboYOYGcCokbVyaygdi8ApkSCw9NA4tzCrhLdE/6yAZR4y Zxue0NI4jNJmAhMfnEA7A4i4CqxPT9P8HiwgJ+Eu0919lAFogIvGeU+PT4AwtIglmgTqL391s WiAWCEidnPoGKS0gcfPGCGWKBgcTpBY1gcQkBe4np768CxTmAbH2JxmOxEGFDie+zvkGVmEvc P9zFNoFRcBaSqbOQTF3AyLSKUb04tagstUjXVC+pKDM9oyQ3MTNH19DAVC83tbg4MT01JzGpW C85P3cTIzBGGIBgB+OXfudDjJIcTEqivJbn70YJ8SXlp1RmJBZnxBeV5qQWH2KU4eBQkuCteA GUEyxKTU+tSMvMAUYrTFqCg0dJhDcOJM1bXJCYW5yZDpE6xWjM8W33zl5mjn839/cyC7Hk5ee lSonzuoKUCoCUZpTmwQ2CJZFLjLJSwryMQKcJ8RSkFuVmlqDKv2IU52BUEuYtAZnCk5lXArfv FdApTECndEjeATmlJBEhJdXAGCvsn7l15gnznh1/PxtXTC8u25nC+Gx59G1hg5sbiu8e4H3Gw ZN+4cAdgecFYo3n28TjdFy3n7y4I2KPjuz5m88SG8RcnA8kmMgWbPnVrKzO4PFIfvKEXYw3fF cITX6oozrnt5weT+r6A5xMe/pn7Ux+GhHa17C4zHva2dXrv9y4LHHCWdWgV4mlOCPRUIu5qDg RAAdIlJ4dAwAA X-Env-Sender: Adam.Thomson.Opensource@diasemi.com X-Msg-Ref: server-15.tower-178.messagelabs.com!1524492661!118034431!1 X-Originating-IP: [94.185.165.51] X-SYMC-ESS-Client-Auth: outbound-route-from=pass X-StarScan-Received: X-StarScan-Version: 9.9.15; banners=-,-,- X-VirusChecked: Checked Message-ID: <53be031004d3178dca11aaba38dbe4de2ac0c0d9.1524490253.git.Adam.Thomson.Opensource@diasemi.com> In-Reply-To: References: From: Adam Thomson Date: Mon, 23 Apr 2018 15:11:01 +0100 Subject: [PATCH v8 6/6] typec: tcpm: Add support for sink PPS related messages To: Heikki Krogerus , Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li CC: , , , MIME-Version: 1.0 Content-Type: text/plain X-KSE-AttachmentFiltering-Interceptor-Info: protection disabled X-KSE-ServerInfo: sw-ex-cashub01.diasemi.com, 9 X-KSE-Antivirus-Interceptor-Info: scan successful X-KSE-Antivirus-Info: Clean, bases: 23/04/2018 11:44:00 Sender: linux-usb-owner@vger.kernel.org X-Mailing-List: linux-usb@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: 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 Acked-by: Heikki Krogerus Reviewed-by: Guenter Roeck --- drivers/usb/typec/tcpm.c | 143 ++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 134 insertions(+), 9 deletions(-) diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c index 7547097..4483dc4 100644 --- a/drivers/usb/typec/tcpm.c +++ b/drivers/usb/typec/tcpm.c @@ -19,7 +19,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -114,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) @@ -144,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, }; @@ -1411,10 +1419,42 @@ 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) { @@ -1502,6 +1542,14 @@ 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; @@ -1584,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 */ @@ -1703,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, @@ -1749,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); @@ -1810,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; @@ -2572,14 +2689,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) { @@ -3279,6 +3388,22 @@ 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); -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v8,6/6] typec: tcpm: Add support for sink PPS related messages From: "Opensource \[Adam Thomson\]" Message-Id: <53be031004d3178dca11aaba38dbe4de2ac0c0d9.1524490253.git.Adam.Thomson.Opensource@diasemi.com> Date: Mon, 23 Apr 2018 15:11:01 +0100 To: Heikki Krogerus , Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li Cc: linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-ID: VGhpcyBjb21taXQgYWRkcyBzaW5rIHNpZGUgc3VwcG9ydCBmb3IgR2V0X1N0YXR1cywgU3RhdHVz LApHZXRfUFBTX1N0YXR1cyBhbmQgUFBTX1N0YXR1cyBoYW5kbGluZy4gQXMgdGhlcmUncyB0aGUK cG90ZW50aWFsIGZvciBhIHBhcnRuZXIgdG8gcmVzcG9uZCB3aXRoIE5vdF9TdXBwb3J0ZWQsCmhh bmRsaW5nIG9mIHRoaXMgbWVzc2FnZSBpcyBhbHNvIGFkZGVkLiBTZW5kaW5nIG9mCk5vdF9TdXBw b3J0ZWQgaXMgYWRkZWQgdG8gaGFuZGxlIG1lc3NhZ2VzY3JlY2VpdmVkIGJ1dCBub3QKeWV0IGhh bmRsZWQuCgpTaWduZWQtb2ZmLWJ5OiBBZGFtIFRob21zb24gPEFkYW0uVGhvbXNvbi5PcGVuc291 cmNlQGRpYXNlbWkuY29tPgpBY2tlZC1ieTogSGVpa2tpIEtyb2dlcnVzIDxoZWlra2kua3JvZ2Vy dXNAbGludXguaW50ZWwuY29tPgpSZXZpZXdlZC1ieTogR3VlbnRlciBSb2VjayA8bGludXhAcm9l Y2stdXMubmV0PgotLS0KIGRyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYyB8IDE0MyArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLQogMSBmaWxlIGNoYW5nZWQsIDEz NCBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNi L3R5cGVjL3RjcG0uYyBiL2RyaXZlcnMvdXNiL3R5cGVjL3RjcG0uYwppbmRleCA3NTQ3MDk3Li40 NDgzZGM0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi90eXBlYy90Y3BtLmMKKysrIGIvZHJpdmVy cy91c2IvdHlwZWMvdGNwbS5jCkBAIC0xOSw3ICsxOSw5IEBACiAjaW5jbHVkZSA8bGludXgvc2xh Yi5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL3Bk Lmg+CisjaW5jbHVkZSA8bGludXgvdXNiL3BkX2Fkby5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi9w ZF9iZG8uaD4KKyNpbmNsdWRlIDxsaW51eC91c2IvcGRfZXh0X3NkYi5oPgogI2luY2x1ZGUgPGxp bnV4L3VzYi9wZF92ZG8uaD4KICNpbmNsdWRlIDxsaW51eC91c2Ivcm9sZS5oPgogI2luY2x1ZGUg PGxpbnV4L3VzYi90Y3BtLmg+CkBAIC0xMTQsNiArMTE2LDExIEBACiAJUyhTTktfVFJZV0FJVF9W QlVTKSwJCQlcCiAJUyhCSVNUX1JYKSwJCQkJXAogCQkJCQkJXAorCVMoR0VUX1NUQVRVU19TRU5E KSwJCQlcCisJUyhHRVRfU1RBVFVTX1NFTkRfVElNRU9VVCksCQlcCisJUyhHRVRfUFBTX1NUQVRV U19TRU5EKSwJCQlcCisJUyhHRVRfUFBTX1NUQVRVU19TRU5EX1RJTUVPVVQpLAkJXAorCQkJCQkJ XAogCVMoRVJST1JfUkVDT1ZFUlkpLAkJCVwKIAlTKFBPUlRfUkVTRVQpLAkJCQlcCiAJUyhQT1JU X1JFU0VUX1dBSVRfT0ZGKQpAQCAtMTQ0LDYgKzE1MSw3IEBAIGVudW0gcGRfbXNnX3JlcXVlc3Qg ewogCVBEX01TR19OT05FID0gMCwKIAlQRF9NU0dfQ1RSTF9SRUpFQ1QsCiAJUERfTVNHX0NUUkxf V0FJVCwKKwlQRF9NU0dfQ1RSTF9OT1RfU1VQUCwKIAlQRF9NU0dfREFUQV9TSU5LX0NBUCwKIAlQ RF9NU0dfREFUQV9TT1VSQ0VfQ0FQLAogfTsKQEAgLTE0MTEsMTAgKzE0MTksNDIgQEAgc3RhdGlj IGludCB0Y3BtX3ZhbGlkYXRlX2NhcHMoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwgY29uc3QgdTMy ICpwZG8sCiAvKgogICogUEQgKGRhdGEsIGNvbnRyb2wpIGNvbW1hbmQgaGFuZGxpbmcgZnVuY3Rp b25zCiAgKi8KK3N0YXRpYyBpbmxpbmUgZW51bSB0Y3BtX3N0YXRlIHJlYWR5X3N0YXRlKHN0cnVj dCB0Y3BtX3BvcnQgKnBvcnQpCit7CisJaWYgKHBvcnQtPnB3cl9yb2xlID09IFRZUEVDX1NPVVJD RSkKKwkJcmV0dXJuIFNSQ19SRUFEWTsKKwllbHNlCisJCXJldHVybiBTTktfUkVBRFk7Cit9CiAK IHN0YXRpYyBpbnQgdGNwbV9wZF9zZW5kX2NvbnRyb2woc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwK IAkJCQllbnVtIHBkX2N0cmxfbXNnX3R5cGUgdHlwZSk7CiAKK3N0YXRpYyB2b2lkIHRjcG1faGFu ZGxlX2FsZXJ0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsIGNvbnN0IF9fbGUzMiAqcGF5bG9hZCwK KwkJCSAgICAgIGludCBjbnQpCit7CisJdTMyIHAwID0gbGUzMl90b19jcHUocGF5bG9hZFswXSk7 CisJdW5zaWduZWQgaW50IHR5cGUgPSB1c2JfcGRfYWRvX3R5cGUocDApOworCisJaWYgKCF0eXBl KSB7CisJCXRjcG1fbG9nKHBvcnQsICJBbGVydCBtZXNzYWdlIHJlY2VpdmVkIHdpdGggbm8gdHlw ZSIpOworCQlyZXR1cm47CisJfQorCisJLyogSnVzdCBoYW5kbGluZyBub24tYmF0dGVyeSBhbGVy dHMgZm9yIG5vdyAqLworCWlmICghKHR5cGUgJiBVU0JfUERfQURPX1RZUEVfQkFUVF9TVEFUVVNf Q0hBTkdFKSkgeworCQlzd2l0Y2ggKHBvcnQtPnN0YXRlKSB7CisJCWNhc2UgU1JDX1JFQURZOgor CQljYXNlIFNOS19SRUFEWToKKwkJCXRjcG1fc2V0X3N0YXRlKHBvcnQsIEdFVF9TVEFUVVNfU0VO RCwgMCk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXRjcG1fcXVldWVfbWVzc2FnZShwb3J0 LCBQRF9NU0dfQ1RSTF9XQUlUKTsKKwkJCWJyZWFrOworCQl9CisJfQorfQorCiBzdGF0aWMgdm9p ZCB0Y3BtX3BkX2RhdGFfcmVxdWVzdChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LAogCQkJCSBjb25z dCBzdHJ1Y3QgcGRfbWVzc2FnZSAqbXNnKQogewpAQCAtMTUwMiw2ICsxNTQyLDE0IEBAIHN0YXRp YyB2b2lkIHRjcG1fcGRfZGF0YV9yZXF1ZXN0KHN0cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCiAJCQl0 Y3BtX3NldF9zdGF0ZShwb3J0LCBCSVNUX1JYLCAwKTsKIAkJfQogCQlicmVhazsKKwljYXNlIFBE X0RBVEFfQUxFUlQ6CisJCXRjcG1faGFuZGxlX2FsZXJ0KHBvcnQsIG1zZy0+cGF5bG9hZCwgY250 KTsKKwkJYnJlYWs7CisJY2FzZSBQRF9EQVRBX0JBVFRfU1RBVFVTOgorCWNhc2UgUERfREFUQV9H RVRfQ09VTlRSWV9JTkZPOgorCQkvKiBDdXJyZW50bHkgdW5zdXBwb3J0ZWQgKi8KKwkJdGNwbV9x dWV1ZV9tZXNzYWdlKHBvcnQsIFBEX01TR19DVFJMX05PVF9TVVBQKTsKKwkJYnJlYWs7CiAJZGVm YXVsdDoKIAkJdGNwbV9sb2cocG9ydCwgIlVuaGFuZGxlZCBkYXRhIG1lc3NhZ2UgdHlwZSAlI3gi LCB0eXBlKTsKIAkJYnJlYWs7CkBAIC0xNTg0LDYgKzE2MzIsNyBAQCBzdGF0aWMgdm9pZCB0Y3Bt X3BkX2N0cmxfcmVxdWVzdChzdHJ1Y3QgdGNwbV9wb3J0ICpwb3J0LAogCQlicmVhazsKIAljYXNl IFBEX0NUUkxfUkVKRUNUOgogCWNhc2UgUERfQ1RSTF9XQUlUOgorCWNhc2UgUERfQ1RSTF9OT1Rf U1VQUDoKIAkJc3dpdGNoIChwb3J0LT5zdGF0ZSkgewogCQljYXNlIFNOS19ORUdPVElBVEVfQ0FQ QUJJTElUSUVTOgogCQkJLyogVVNCIFBEIHNwZWNpZmljYXRpb24sIEZpZ3VyZSA4LTQzICovCkBA IC0xNzAzLDEyICsxNzUyLDc1IEBAIHN0YXRpYyB2b2lkIHRjcG1fcGRfY3RybF9yZXF1ZXN0KHN0 cnVjdCB0Y3BtX3BvcnQgKnBvcnQsCiAJCQlicmVhazsKIAkJfQogCQlicmVhazsKKwljYXNlIFBE X0NUUkxfR0VUX1NPVVJDRV9DQVBfRVhUOgorCWNhc2UgUERfQ1RSTF9HRVRfU1RBVFVTOgorCWNh c2UgUERfQ1RSTF9GUl9TV0FQOgorCWNhc2UgUERfQ1RSTF9HRVRfUFBTX1NUQVRVUzoKKwljYXNl IFBEX0NUUkxfR0VUX0NPVU5UUllfQ09ERVM6CisJCS8qIEN1cnJlbnRseSBub3Qgc3VwcG9ydGVk ICovCisJCXRjcG1fcXVldWVfbWVzc2FnZShwb3J0LCBQRF9NU0dfQ1RSTF9OT1RfU1VQUCk7CisJ CWJyZWFrOwogCWRlZmF1bHQ6CiAJCXRjcG1fbG9nKHBvcnQsICJVbmhhbmRsZWQgY3RybCBtZXNz YWdlIHR5cGUgJSN4IiwgdHlwZSk7CiAJCWJyZWFrOwogCX0KIH0KIAorc3RhdGljIHZvaWQgdGNw bV9wZF9leHRfbXNnX3JlcXVlc3Qoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCwKKwkJCQkgICAgY29u c3Qgc3RydWN0IHBkX21lc3NhZ2UgKm1zZykKK3sKKwllbnVtIHBkX2V4dF9tc2dfdHlwZSB0eXBl ID0gcGRfaGVhZGVyX3R5cGVfbGUobXNnLT5oZWFkZXIpOworCXVuc2lnbmVkIGludCBkYXRhX3Np emUgPSBwZF9leHRfaGVhZGVyX2RhdGFfc2l6ZV9sZShtc2ctPmV4dF9tc2cuaGVhZGVyKTsKKwor CWlmICghKG1zZy0+ZXh0X21zZy5oZWFkZXIgJiYgUERfRVhUX0hEUl9DSFVOS0VEKSkgeworCQl0 Y3BtX2xvZyhwb3J0LCAiVW5jaHVua2VkIGV4dGVuZGVkIG1lc3NhZ2VzIHVuc3VwcG9ydGVkIik7 CisJCXJldHVybjsKKwl9CisKKwlpZiAoZGF0YV9zaXplID4gUERfRVhUX01BWF9DSFVOS19EQVRB KSB7CisJCXRjcG1fbG9nKHBvcnQsICJDaHVuayBoYW5kbGluZyBub3QgeWV0IHN1cHBvcnRlZCIp OworCQlyZXR1cm47CisJfQorCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBQRF9FWFRfU1RBVFVT OgorCQkvKgorCQkgKiBJZiBQUFMgcmVsYXRlZCBldmVudHMgcmFpc2VkIHRoZW4gZ2V0IFBQUyBz dGF0dXMgdG8gY2xlYXIKKwkJICogKHNlZSBVU0IgUEQgMy4wIFNwZWMsIDYuNS4yLjQpCisJCSAq LworCQlpZiAobXNnLT5leHRfbXNnLmRhdGFbVVNCX1BEX0VYVF9TREJfRVZFTlRfRkxBR1NdICYK KwkJICAgIFVTQl9QRF9FWFRfU0RCX1BQU19FVkVOVFMpCisJCQl0Y3BtX3NldF9zdGF0ZShwb3J0 LCBHRVRfUFBTX1NUQVRVU19TRU5ELCAwKTsKKwkJZWxzZQorCQkJdGNwbV9zZXRfc3RhdGUocG9y dCwgcmVhZHlfc3RhdGUocG9ydCksIDApOworCQlicmVhazsKKwljYXNlIFBEX0VYVF9QUFNfU1RB VFVTOgorCQkvKgorCQkgKiBGb3Igbm93IHRoZSBQUFMgc3RhdHVzIG1lc3NhZ2UgaXMgdXNlZCB0 byBjbGVhciBldmVudHMKKwkJICogYW5kIG5vdGhpbmcgbW9yZS4KKwkJICovCisJCXRjcG1fc2V0 X3N0YXRlKHBvcnQsIHJlYWR5X3N0YXRlKHBvcnQpLCAwKTsKKwkJYnJlYWs7CisJY2FzZSBQRF9F WFRfU09VUkNFX0NBUF9FWFQ6CisJY2FzZSBQRF9FWFRfR0VUX0JBVFRfQ0FQOgorCWNhc2UgUERf RVhUX0dFVF9CQVRUX1NUQVRVUzoKKwljYXNlIFBEX0VYVF9CQVRUX0NBUDoKKwljYXNlIFBEX0VY VF9HRVRfTUFOVUZBQ1RVUkVSX0lORk86CisJY2FzZSBQRF9FWFRfTUFOVUZBQ1RVUkVSX0lORk86 CisJY2FzZSBQRF9FWFRfU0VDVVJJVFlfUkVRVUVTVDoKKwljYXNlIFBEX0VYVF9TRUNVUklUWV9S RVNQT05TRToKKwljYXNlIFBEX0VYVF9GV19VUERBVEVfUkVRVUVTVDoKKwljYXNlIFBEX0VYVF9G V19VUERBVEVfUkVTUE9OU0U6CisJY2FzZSBQRF9FWFRfQ09VTlRSWV9JTkZPOgorCWNhc2UgUERf RVhUX0NPVU5UUllfQ09ERVM6CisJCXRjcG1fcXVldWVfbWVzc2FnZShwb3J0LCBQRF9NU0dfQ1RS TF9OT1RfU1VQUCk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXRjcG1fbG9nKHBvcnQsICJVbmhh bmRsZWQgZXh0ZW5kZWQgbWVzc2FnZSB0eXBlICUjeCIsIHR5cGUpOworCQlicmVhazsKKwl9Cit9 CisKIHN0YXRpYyB2b2lkIHRjcG1fcGRfcnhfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndv cmspCiB7CiAJc3RydWN0IHBkX3J4X2V2ZW50ICpldmVudCA9IGNvbnRhaW5lcl9vZih3b3JrLApA QCAtMTc0OSw3ICsxODYxLDkgQEAgc3RhdGljIHZvaWQgdGNwbV9wZF9yeF9oYW5kbGVyKHN0cnVj dCB3b3JrX3N0cnVjdCAqd29yaykKIAkJCQkgIkRhdGEgcm9sZSBtaXNtYXRjaCwgaW5pdGlhdGlu ZyBlcnJvciByZWNvdmVyeSIpOwogCQkJdGNwbV9zZXRfc3RhdGUocG9ydCwgRVJST1JfUkVDT1ZF UlksIDApOwogCQl9IGVsc2UgewotCQkJaWYgKGNudCkKKwkJCWlmIChtc2ctPmhlYWRlciAmIFBE X0hFQURFUl9FWFRfSERSKQorCQkJCXRjcG1fcGRfZXh0X21zZ19yZXF1ZXN0KHBvcnQsIG1zZyk7 CisJCQllbHNlIGlmIChjbnQpCiAJCQkJdGNwbV9wZF9kYXRhX3JlcXVlc3QocG9ydCwgbXNnKTsK IAkJCWVsc2UKIAkJCQl0Y3BtX3BkX2N0cmxfcmVxdWVzdChwb3J0LCBtc2cpOwpAQCAtMTgxMCw2 ICsxOTI0LDkgQEAgc3RhdGljIGJvb2wgdGNwbV9zZW5kX3F1ZXVlZF9tZXNzYWdlKHN0cnVjdCB0 Y3BtX3BvcnQgKnBvcnQpCiAJCWNhc2UgUERfTVNHX0NUUkxfUkVKRUNUOgogCQkJdGNwbV9wZF9z ZW5kX2NvbnRyb2wocG9ydCwgUERfQ1RSTF9SRUpFQ1QpOwogCQkJYnJlYWs7CisJCWNhc2UgUERf TVNHX0NUUkxfTk9UX1NVUFA6CisJCQl0Y3BtX3BkX3NlbmRfY29udHJvbChwb3J0LCBQRF9DVFJM X05PVF9TVVBQKTsKKwkJCWJyZWFrOwogCQljYXNlIFBEX01TR19EQVRBX1NJTktfQ0FQOgogCQkJ dGNwbV9wZF9zZW5kX3NpbmtfY2Fwcyhwb3J0KTsKIAkJCWJyZWFrOwpAQCAtMjU3MiwxNCArMjY4 OSw2IEBAIHN0YXRpYyBpbmxpbmUgZW51bSB0Y3BtX3N0YXRlIGhhcmRfcmVzZXRfc3RhdGUoc3Ry dWN0IHRjcG1fcG9ydCAqcG9ydCkKIAlyZXR1cm4gU05LX1VOQVRUQUNIRUQ7CiB9CiAKLXN0YXRp YyBpbmxpbmUgZW51bSB0Y3BtX3N0YXRlIHJlYWR5X3N0YXRlKHN0cnVjdCB0Y3BtX3BvcnQgKnBv cnQpCi17Ci0JaWYgKHBvcnQtPnB3cl9yb2xlID09IFRZUEVDX1NPVVJDRSkKLQkJcmV0dXJuIFNS Q19SRUFEWTsKLQllbHNlCi0JCXJldHVybiBTTktfUkVBRFk7Ci19Ci0KIHN0YXRpYyBpbmxpbmUg ZW51bSB0Y3BtX3N0YXRlIHVuYXR0YWNoZWRfc3RhdGUoc3RydWN0IHRjcG1fcG9ydCAqcG9ydCkK IHsKIAlpZiAocG9ydC0+cG9ydF90eXBlID09IFRZUEVDX1BPUlRfRFJQKSB7CkBAIC0zMjc5LDYg KzMzODgsMjIgQEAgc3RhdGljIHZvaWQgcnVuX3N0YXRlX21hY2hpbmUoc3RydWN0IHRjcG1fcG9y dCAqcG9ydCkKIAkJLyogQWx3YXlzIHN3aXRjaCB0byB1bmF0dGFjaGVkIHN0YXRlICovCiAJCXRj cG1fc2V0X3N0YXRlKHBvcnQsIHVuYXR0YWNoZWRfc3RhdGUocG9ydCksIDApOwogCQlicmVhazsK KwljYXNlIEdFVF9TVEFUVVNfU0VORDoKKwkJdGNwbV9wZF9zZW5kX2NvbnRyb2wocG9ydCwgUERf Q1RSTF9HRVRfU1RBVFVTKTsKKwkJdGNwbV9zZXRfc3RhdGUocG9ydCwgR0VUX1NUQVRVU19TRU5E X1RJTUVPVVQsCisJCQkgICAgICAgUERfVF9TRU5ERVJfUkVTUE9OU0UpOworCQlicmVhazsKKwlj YXNlIEdFVF9TVEFUVVNfU0VORF9USU1FT1VUOgorCQl0Y3BtX3NldF9zdGF0ZShwb3J0LCByZWFk eV9zdGF0ZShwb3J0KSwgMCk7CisJCWJyZWFrOworCWNhc2UgR0VUX1BQU19TVEFUVVNfU0VORDoK KwkJdGNwbV9wZF9zZW5kX2NvbnRyb2wocG9ydCwgUERfQ1RSTF9HRVRfUFBTX1NUQVRVUyk7CisJ CXRjcG1fc2V0X3N0YXRlKHBvcnQsIEdFVF9QUFNfU1RBVFVTX1NFTkRfVElNRU9VVCwKKwkJCSAg ICAgICBQRF9UX1NFTkRFUl9SRVNQT05TRSk7CisJCWJyZWFrOworCWNhc2UgR0VUX1BQU19TVEFU VVNfU0VORF9USU1FT1VUOgorCQl0Y3BtX3NldF9zdGF0ZShwb3J0LCByZWFkeV9zdGF0ZShwb3J0 KSwgMCk7CisJCWJyZWFrOwogCWNhc2UgRVJST1JfUkVDT1ZFUlk6CiAJCXRjcG1fc3dhcF9jb21w bGV0ZShwb3J0LCAtRVBST1RPKTsKIAkJdGNwbV9wcHNfY29tcGxldGUocG9ydCwgLUVQUk9UTyk7 Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: Adam Thomson Subject: [PATCH v8 6/6] typec: tcpm: Add support for sink PPS related messages Date: Mon, 23 Apr 2018 15:11:01 +0100 Message-ID: <53be031004d3178dca11aaba38dbe4de2ac0c0d9.1524490253.git.Adam.Thomson.Opensource@diasemi.com> References: Mime-Version: 1.0 Content-Type: text/plain Return-path: In-Reply-To: Sender: linux-kernel-owner@vger.kernel.org To: Heikki Krogerus , Guenter Roeck , Greg Kroah-Hartman , Sebastian Reichel , Hans de Goede , Jun Li Cc: linux-usb@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, support.opensource@diasemi.com List-Id: linux-pm@vger.kernel.org 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 Acked-by: Heikki Krogerus Reviewed-by: Guenter Roeck --- drivers/usb/typec/tcpm.c | 143 ++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 134 insertions(+), 9 deletions(-) diff --git a/drivers/usb/typec/tcpm.c b/drivers/usb/typec/tcpm.c index 7547097..4483dc4 100644 --- a/drivers/usb/typec/tcpm.c +++ b/drivers/usb/typec/tcpm.c @@ -19,7 +19,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -114,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) @@ -144,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, }; @@ -1411,10 +1419,42 @@ 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) { @@ -1502,6 +1542,14 @@ 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; @@ -1584,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 */ @@ -1703,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, @@ -1749,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); @@ -1810,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; @@ -2572,14 +2689,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) { @@ -3279,6 +3388,22 @@ 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); -- 1.9.1