diff options
| -rw-r--r-- | board/dingdong/usb_pd_config.h | 3 | ||||
| -rw-r--r-- | board/hoho/usb_pd_config.h | 3 | ||||
| -rw-r--r-- | board/zinger/usb_pd_config.h | 4 | ||||
| -rw-r--r-- | common/usb_pd_protocol.c | 338 | ||||
| -rw-r--r-- | include/usb_pd.h | 21 | ||||
| -rw-r--r-- | test/usb_pd.c | 39 |
6 files changed, 279 insertions, 129 deletions
diff --git a/board/dingdong/usb_pd_config.h b/board/dingdong/usb_pd_config.h index ba6e545a3f..db46d83b73 100644 --- a/board/dingdong/usb_pd_config.h +++ b/board/dingdong/usb_pd_config.h @@ -120,7 +120,8 @@ static inline void pd_set_host_mode(int port, int enable) {} static inline int pd_adc_read(int port, int cc) { - return adc_read_channel(ADC_CH_CC1_PD); + /* only one CC line, assume other one is always low */ + return (cc == 0) ? adc_read_channel(ADC_CH_CC1_PD) : 0; } static inline int pd_snk_is_vbus_provided(int port) diff --git a/board/hoho/usb_pd_config.h b/board/hoho/usb_pd_config.h index ba6e545a3f..db46d83b73 100644 --- a/board/hoho/usb_pd_config.h +++ b/board/hoho/usb_pd_config.h @@ -120,7 +120,8 @@ static inline void pd_set_host_mode(int port, int enable) {} static inline int pd_adc_read(int port, int cc) { - return adc_read_channel(ADC_CH_CC1_PD); + /* only one CC line, assume other one is always low */ + return (cc == 0) ? adc_read_channel(ADC_CH_CC1_PD) : 0; } static inline int pd_snk_is_vbus_provided(int port) diff --git a/board/zinger/usb_pd_config.h b/board/zinger/usb_pd_config.h index c22e68858d..0456a24652 100644 --- a/board/zinger/usb_pd_config.h +++ b/board/zinger/usb_pd_config.h @@ -107,8 +107,8 @@ static inline void pd_tx_init(void) static inline int pd_adc_read(int port, int cc) { - /* only one CC line */ - return adc_read_channel(ADC_CH_CC1_PD); + /* only one CC line, assume other one is always high */ + return (cc == 0) ? adc_read_channel(ADC_CH_CC1_PD) : 4096; } /* 3.0A DFP : no-connect voltage is 2.45V */ diff --git a/common/usb_pd_protocol.c b/common/usb_pd_protocol.c index fdacae05f9..9db9b8bd75 100644 --- a/common/usb_pd_protocol.c +++ b/common/usb_pd_protocol.c @@ -132,7 +132,8 @@ static const uint8_t dec4b5b[] = { #define PD_HARD_RESET (PD_RST1 | (PD_RST1 << 5) |\ (PD_RST1 << 10) | (PD_RST2 << 15)) -/* Polarity is based 'DFP Perspective' (see table USB Type-C Cable and Connector +/* + * Polarity is based 'DFP Perspective' (see table USB Type-C Cable and Connector * Specification) * * CC1 CC2 STATE POSITION @@ -140,25 +141,35 @@ static const uint8_t dec4b5b[] = { * open open NC N/A * Rd open UFP attached 1 * open Rd UFP attached 2 - * open Ra pwr cable no UFP 1 - * Ra open pwr cable no UFP 2 + * open Ra pwr cable no UFP N/A + * Ra open pwr cable no UFP N/A * Rd Ra pwr cable & UFP 1 * Ra Rd pwr cable & UFP 2 * Rd Rd dbg accessory N/A * Ra Ra audio accessory N/A * * Note, V(Rd) > V(Ra) - * TODO(crosbug.com/p/31197): Need to identify necessary polarity switching for - * debug dongle. - * */ #ifndef PD_SRC_RD_THRESHOLD #define PD_SRC_RD_THRESHOLD 200 /* mV */ #endif #define CC_RA(cc) (cc < PD_SRC_RD_THRESHOLD) -#define CC_RD(cc) ((cc > PD_SRC_RD_THRESHOLD) && (cc < PD_SRC_VNC)) -#define GET_POLARITY(cc1, cc2) (CC_RD(cc2) || CC_RA(cc1)) -#define IS_CABLE(cc1, cc2) (CC_RD(cc1) || CC_RD(cc2)) +#define CC_RD(cc) ((cc >= PD_SRC_RD_THRESHOLD) && (cc < PD_SRC_VNC)) +#define CC_NC(cc) (cc >= PD_SRC_VNC) +#define DFP_GET_POLARITY(cc1, cc2) (CC_RD(cc2)) + +/* + * Polarity based on 'UFP Perspective'. + * + * CC1 CC2 STATE POSITION + * ---------------------------------------- + * open open NC N/A + * Rp open DFP attached 1 + * open Rp DFP attached 2 + * Rp Rp Accessory attached N/A + */ +#define CC_RP(cc) (cc >= PD_SNK_VA) +#define UFP_GET_POLARITY(cc1, cc2) (CC_RP(cc2)) /* * Type C power source charge current limits are identified by their cc @@ -214,8 +225,9 @@ static int pd_src_cap_cnt[PD_PORT_COUNT]; #define PD_FLAGS_EXPLICIT_CONTRACT (1 << 6) /* explicit pwr contract in place */ #define PD_FLAGS_SFT_RST_DIS_COMM (1 << 7) /* disable comms after soft reset */ #define PD_FLAGS_PREVIOUS_PD_CONN (1 << 8) /* previously PD connected */ -#define PD_FLAGS_CHECK_PR_ROLE (1 << 9)/* check power role in READY */ -#define PD_FLAGS_CHECK_DR_ROLE (1 << 10) /* check data role in READY */ +#define PD_FLAGS_CHECK_PR_ROLE (1 << 9) /* check power role in READY */ +#define PD_FLAGS_CHECK_DR_ROLE (1 << 10)/* check data role in READY */ +#define PD_FLAGS_CURR_LIM_INIT (1 << 11)/* input curr limit initialized */ /* Flags to clear on a disconnect */ #define PD_FLAGS_RESET_ON_DISCONNECT_MASK (PD_FLAGS_PARTNER_DR_POWER | \ PD_FLAGS_PARTNER_DR_DATA | \ @@ -248,6 +260,10 @@ static struct pd_protocol { uint64_t timeout; /* Time for source recovery after hard reset */ uint64_t src_recover; + /* Time for CC debounce end */ + uint64_t cc_debounce; + /* The cc state */ + enum pd_cc_states cc_state; /* Error sending message and message was dropped */ int8_t send_error; @@ -292,12 +308,14 @@ struct mutex pd_crc_lock; static const char * const pd_state_names[] = { "DISABLED", #ifdef CONFIG_USB_PD_DUAL_ROLE - "SUSPENDED", "SNK_DISCONNECTED", "SNK_HARD_RESET_RECOVER", + "SUSPENDED", "SNK_DISCONNECTED", "SNK_DISCONNECTED_DEBOUNCE", + "SNK_HARD_RESET_RECOVER", "SNK_DISCOVERY", "SNK_REQUESTED", "SNK_TRANSITION", "SNK_READY", "SNK_DR_SWAP", "SNK_SWAP_INIT", "SNK_SWAP_SNK_DISABLE", "SNK_SWAP_SRC_DISABLE", "SNK_SWAP_STANDBY", "SNK_SWAP_COMPLETE", #endif /* CONFIG_USB_PD_DUAL_ROLE */ - "SRC_DISCONNECTED", "SRC_HARD_RESET_RECOVER", "SRC_STARTUP", + "SRC_DISCONNECTED", "SRC_DISCONNECTED_DEBOUNCE", "SRC_ACCESSORY", + "SRC_HARD_RESET_RECOVER", "SRC_STARTUP", "SRC_DISCOVERY", "SRC_NEGOCIATE", "SRC_ACCEPTED", "SRC_POWERED", "SRC_TRANSITION", "SRC_READY", "SRC_GET_SNK_CAP", "SRC_DR_SWAP", #ifdef CONFIG_USB_PD_DUAL_ROLE @@ -334,10 +352,13 @@ int pd_is_connected(int port) #ifdef CONFIG_USB_PD_DUAL_ROLE /* Check if sink is connected */ if (pd[port].power_role == PD_ROLE_SINK) - return pd[port].task_state != PD_STATE_SNK_DISCONNECTED; + return pd[port].task_state != PD_STATE_SNK_DISCONNECTED && + pd[port].task_state != PD_STATE_SNK_DISCONNECTED_DEBOUNCE; #endif /* Must be a source */ - return pd[port].task_state != PD_STATE_SRC_DISCONNECTED; + return pd[port].task_state != PD_STATE_SRC_DISCONNECTED && + pd[port].task_state != PD_STATE_SRC_DISCONNECTED_DEBOUNCE && + pd[port].task_state != PD_STATE_SRC_ACCESSORY; } static inline void set_state(int port, enum pd_states next_state) @@ -1649,13 +1670,13 @@ void pd_task(void) int snk_hard_reset_vbus_off = 0; #endif #ifdef CONFIG_CHARGE_MANAGER - static int initialized[PD_PORT_COUNT]; int typec_curr = 0, typec_curr_change = 0; #endif /* CONFIG_CHARGE_MANAGER */ #endif /* CONFIG_USB_PD_DUAL_ROLE */ enum pd_states this_state; + enum pd_cc_states new_cc_state; timestamp_t now; - int caps_count = 0, src_connected = 0, hard_reset_sent = 0; + int caps_count = 0, hard_reset_sent = 0; /* Initialize TX pins and put them in Hi-Z */ pd_tx_init(); @@ -1735,35 +1756,29 @@ void pd_task(void) /* Vnc monitoring */ cc1_volt = pd_adc_read(port, 0); cc2_volt = pd_adc_read(port, 1); - if ((cc1_volt < PD_SRC_VNC) || - (cc2_volt < PD_SRC_VNC)) { - pd[port].polarity = - GET_POLARITY(cc1_volt, cc2_volt); - pd_select_polarity(port, pd[port].polarity); - /* initial data role for source is DFP */ - pd_set_data_role(port, PD_ROLE_DFP); - /* Set to USB SS initially */ + if (!CC_NC(cc1_volt) || !CC_NC(cc2_volt)) { #ifdef CONFIG_USBC_SS_MUX + /* + * Set to USB SS based on current plarity + * (might change after the debounce). + */ board_set_usb_mux(port, TYPEC_MUX_USB, - pd[port].polarity); + DFP_GET_POLARITY(cc1_volt, + cc2_volt)); #endif /* Enable VBUS */ if (pd_set_power_supply_ready(port)) { #ifdef CONFIG_USBC_SS_MUX board_set_usb_mux(port, TYPEC_MUX_NONE, - pd[port].polarity); + DFP_GET_POLARITY( + cc1_volt, + cc2_volt)); #endif break; } - -#ifdef CONFIG_USBC_VCONN - pd_set_vconn(port, pd[port].polarity, 1); -#endif - - pd[port].flags |= PD_FLAGS_CHECK_PR_ROLE | - PD_FLAGS_CHECK_DR_ROLE; - hard_reset_count = 0; - set_state(port, PD_STATE_SRC_STARTUP); + pd[port].cc_state = PD_CC_NONE; + set_state(port, + PD_STATE_SRC_DISCONNECTED_DEBOUNCE); } #ifdef CONFIG_USB_PD_DUAL_ROLE /* Swap roles if time expired or VBUS is present */ @@ -1780,6 +1795,88 @@ void pd_task(void) } #endif break; + case PD_STATE_SRC_DISCONNECTED_DEBOUNCE: + timeout = 20*MSEC; + cc1_volt = pd_adc_read(port, 0); + cc2_volt = pd_adc_read(port, 1); + + if (CC_NC(cc1_volt) && CC_NC(cc2_volt)) { + /* No connection any more, remove VBUS */ + pd_power_supply_reset(port); + set_state(port, PD_STATE_SRC_DISCONNECTED); + timeout = 5*MSEC; + break; + } else if (CC_RA(cc1_volt) && CC_RA(cc2_volt)) { + /* Audio accessory */ + new_cc_state = PD_CC_AUDIO_ACC; + } else if (CC_RD(cc1_volt) && CC_RD(cc2_volt)) { + /* Debug accessory */ + new_cc_state = PD_CC_DEBUG_ACC; + } else if (CC_RD(cc1_volt) || CC_RD(cc2_volt)) { + /* UFP attached */ + new_cc_state = PD_CC_UFP_ATTACHED; + } else { + /* Powered cable, no UFP */ + new_cc_state = PD_CC_NO_UFP; + } + + /* Debounce the cc state */ + if (new_cc_state != pd[port].cc_state) { + pd[port].cc_debounce = get_time().val + + PD_T_CC_DEBOUNCE; + pd[port].cc_state = new_cc_state; + break; + } else if (get_time().val < pd[port].cc_debounce) { + break; + } + + /* Debounce complete */ + /* UFP is attached */ + if (new_cc_state == PD_CC_UFP_ATTACHED) { + pd[port].polarity = + DFP_GET_POLARITY(cc1_volt, cc2_volt); + pd_select_polarity(port, pd[port].polarity); +#ifdef CONFIG_USBC_SS_MUX + board_set_usb_mux(port, TYPEC_MUX_USB, + pd[port].polarity); +#endif + /* initial data role for source is DFP */ + pd_set_data_role(port, PD_ROLE_DFP); + +#ifdef CONFIG_USBC_VCONN + pd_set_vconn(port, pd[port].polarity, 1); +#endif + + pd[port].flags |= PD_FLAGS_CHECK_PR_ROLE | + PD_FLAGS_CHECK_DR_ROLE; + hard_reset_count = 0; + timeout = 5*MSEC; + set_state(port, PD_STATE_SRC_STARTUP); + } + /* Accessory is attached */ + else if (new_cc_state == PD_CC_AUDIO_ACC || + new_cc_state == PD_CC_DEBUG_ACC) { + /* Remove VBUS */ + pd_power_supply_reset(port); + set_state(port, PD_STATE_SRC_ACCESSORY); + } + break; + case PD_STATE_SRC_ACCESSORY: + /* Combined audio / debug accessory state */ + timeout = 100*MSEC; + + cc1_volt = pd_adc_read(port, 0); + cc2_volt = pd_adc_read(port, 1); + + /* If accessory becomes detached */ + if ((pd[port].cc_state == PD_CC_AUDIO_ACC && + (!CC_RA(cc1_volt) || !CC_RA(cc2_volt))) || + (pd[port].cc_state == PD_CC_DEBUG_ACC && + (!CC_RD(cc1_volt) || !CC_RD(cc2_volt)))) { + set_state(port, PD_STATE_SRC_DISCONNECTED); + timeout = 10*MSEC; + } + break; case PD_STATE_SRC_HARD_RESET_RECOVER: /* Do not continue until hard reset recovery time */ if (get_time().val < pd[port].src_recover) { @@ -1805,21 +1902,25 @@ void pd_task(void) pd[port].flags |= PD_FLAGS_DATA_SWAPPED; /* reset various counters */ caps_count = 0; - src_connected = 0; pd[port].msg_id = 0; set_state_timeout( port, + /* + * delay for power supply to start up. + * subtract out debounce time if coming + * from debounce state since vbus is + * on during debounce. + */ get_time().val + - PD_POWER_SUPPLY_TRANSITION_DELAY, + PD_POWER_SUPPLY_TRANSITION_DELAY - + (pd[port].last_state == + PD_STATE_SRC_DISCONNECTED_DEBOUNCE + ? PD_T_CC_DEBOUNCE : 0), PD_STATE_SRC_DISCOVERY); } break; case PD_STATE_SRC_DISCOVERY: if (pd[port].last_state != pd[port].task_state) { -#ifdef CONFIG_USB_PD_DUAL_ROLE - /* Keep VBUS up for the hold period */ - next_role_swap = get_time().val + PD_T_DRP_HOLD; -#endif /* * If we have had PD connection with this port * partner, then start NoResponseTimer. @@ -1834,21 +1935,6 @@ void pd_task(void) PD_STATE_SRC_DISCONNECTED); } - /* - * While we were enabling VBUS, other side could have - * toggled roles, so now wait until other side settles - * on UFP, before sending source cap. - */ - if (!src_connected) { - cc1_volt = pd_adc_read(port, pd[port].polarity); - if (cc1_volt < PD_SRC_VNC) { - src_connected = 1; - } else { - timeout = 10*MSEC; - break; - } - } - /* Send source cap some minimum number of times */ if (caps_count < PD_CAPS_COUNT) { /* Query capabilites of the other side */ @@ -2096,59 +2182,41 @@ void pd_task(void) case PD_STATE_SNK_DISCONNECTED: timeout = 10*MSEC; - /* Source connection monitoring */ + /* + * Source connection monitoring + * Note, if we just turned VBUS off, we may still see + * VBUS present, but that should be safe because we + * will wait in the debounce state until vbus is + * removed. + */ if (pd_snk_is_vbus_provided(port)) { - cc1_volt = pd_adc_read(port, 0); - cc2_volt = pd_adc_read(port, 1); - if ((cc1_volt >= PD_SNK_VA) || - (cc2_volt >= PD_SNK_VA)) { - pd[port].polarity = - GET_POLARITY(cc1_volt, - cc2_volt); - pd_select_polarity(port, - pd[port].polarity); - /* reset message ID on connection */ - pd[port].msg_id = 0; - /* initial data role for sink is UFP */ - pd_set_data_role(port, PD_ROLE_UFP); -#ifdef CONFIG_CHARGE_MANAGER - initialized[port] = 1; - typec_curr = get_typec_current_limit( - pd[port].polarity ? cc2_volt : - cc1_volt); - typec_set_input_current_limit( - port, typec_curr, TYPE_C_VOLTAGE); -#endif - hard_reset_count = 0; - pd[port].flags |= - PD_FLAGS_CHECK_PR_ROLE | - PD_FLAGS_CHECK_DR_ROLE; - set_state(port, PD_STATE_SNK_DISCOVERY); - timeout = 10*MSEC; - hook_call_deferred( - pd_usb_billboard_deferred, - PD_T_AME); - break; - } + pd[port].cc_state = PD_CC_NONE; + hard_reset_count = 0; + set_state(port, + PD_STATE_SNK_DISCONNECTED_DEBOUNCE); + break; } #ifdef CONFIG_CHARGE_MANAGER /* - * Set charge limit to zero if we have yet to set - * a limit for this port. + * If no VBUS, set charge limit to zero if we have + * yet to set a limit for this port. */ - if (!initialized[port]) { - initialized[port] = 1; + if (!(pd[port].flags & PD_FLAGS_CURR_LIM_INIT)) { + pd[port].flags |= PD_FLAGS_CURR_LIM_INIT; typec_set_input_current_limit(port, 0, 0); pd_set_input_current_limit(port, 0, 0); } #endif /* - * If no source detected, reset hard reset counter and - * check for role swap + * If no source detected, check for role toggle. + * Do not role toggle if Rp is detected. */ + cc1_volt = pd_adc_read(port, 0); + cc2_volt = pd_adc_read(port, 1); if (drp_state == PD_DRP_TOGGLE_ON && - get_time().val >= next_role_swap) { + get_time().val >= next_role_swap && + !CC_RP(cc1_volt) && !CC_RP(cc2_volt)) { /* Swap roles to source */ pd[port].power_role = PD_ROLE_SOURCE; set_state(port, PD_STATE_SRC_DISCONNECTED); @@ -2159,6 +2227,60 @@ void pd_task(void) timeout = 2*MSEC; } break; + case PD_STATE_SNK_DISCONNECTED_DEBOUNCE: + if (!pd_snk_is_vbus_provided(port)) { + /* No connection any more */ + set_state(port, PD_STATE_SNK_DISCONNECTED); + timeout = 5*MSEC; + break; + } + + timeout = 20*MSEC; + cc1_volt = pd_adc_read(port, 0); + cc2_volt = pd_adc_read(port, 1); + if (!CC_RP(cc1_volt) && !CC_RP(cc2_volt)) + /* Accessory */ + new_cc_state = PD_CC_ACC_PRESENT; + else + /* DFP attached */ + new_cc_state = PD_CC_DFP_ATTACHED; + + /* Debounce the cc state */ + if (new_cc_state != pd[port].cc_state) { + pd[port].cc_debounce = get_time().val + + PD_T_CC_DEBOUNCE; + pd[port].cc_state = new_cc_state; + break; + } else if (get_time().val < pd[port].cc_debounce) { + break; + } + + /* Debounce complete */ + if (new_cc_state == PD_CC_DFP_ATTACHED) { + pd[port].polarity = + UFP_GET_POLARITY(cc1_volt, cc2_volt); + pd_select_polarity(port, pd[port].polarity); + /* reset message ID on connection */ + pd[port].msg_id = 0; + /* initial data role for sink is UFP */ + pd_set_data_role(port, PD_ROLE_UFP); +#ifdef CONFIG_CHARGE_MANAGER + pd[port].flags |= PD_FLAGS_CURR_LIM_INIT; + typec_curr = get_typec_current_limit( + pd[port].polarity ? cc2_volt : + cc1_volt); + typec_set_input_current_limit( + port, typec_curr, TYPE_C_VOLTAGE); +#endif + pd[port].flags |= PD_FLAGS_CHECK_PR_ROLE | + PD_FLAGS_CHECK_DR_ROLE; + set_state(port, PD_STATE_SNK_DISCOVERY); + timeout = 10*MSEC; + hook_call_deferred( + pd_usb_billboard_deferred, + PD_T_AME); + } + break; case PD_STATE_SNK_HARD_RESET_RECOVER: if (pd[port].last_state != pd[port].task_state) pd[port].flags |= PD_FLAGS_DATA_SWAPPED; @@ -2245,7 +2367,7 @@ void pd_task(void) * we guarantee this is revised below. */ if (pd[port].last_state != - PD_STATE_SNK_DISCONNECTED) + PD_STATE_SNK_DISCONNECTED_DEBOUNCE) typec_curr = 0; #endif } @@ -2533,22 +2655,14 @@ void pd_task(void) if (!pd_is_connected(port) || pd_is_power_swapping(port)) continue; #endif - if (pd[port].power_role == PD_ROLE_SOURCE && - pd[port].task_state != PD_STATE_SRC_STARTUP) { + if (pd[port].power_role == PD_ROLE_SOURCE) { /* Source: detect disconnect by monitoring CC */ cc1_volt = pd_adc_read(port, pd[port].polarity); -#ifdef CONFIG_USB_PD_DUAL_ROLE - if (cc1_volt > PD_SRC_VNC && - get_time().val >= next_role_swap) { - /* Stay a source port for lock period */ - next_role_swap = get_time().val + PD_T_DRP_LOCK; -#else - if (cc1_volt > PD_SRC_VNC) { -#endif + if (CC_NC(cc1_volt)) { pd_power_supply_reset(port); set_state(port, PD_STATE_SRC_DISCONNECTED); /* Debouncing */ - timeout = 50*MSEC; + timeout = 10*MSEC; } } #ifdef CONFIG_USB_PD_DUAL_ROLE @@ -2586,7 +2700,7 @@ static void dual_role_on(void) int i; pd_set_dual_role(PD_DRP_TOGGLE_ON); - CPRINTS("chipset -> S0, enable dual-role toggling"); + CPRINTS("chipset -> S0"); for (i = 0; i < PD_PORT_COUNT; i++) { #ifdef CONFIG_CHARGE_MANAGER @@ -2601,7 +2715,7 @@ DECLARE_HOOK(HOOK_CHIPSET_RESUME, dual_role_on, HOOK_PRIO_DEFAULT); static void dual_role_off(void) { pd_set_dual_role(PD_DRP_TOGGLE_OFF); - CPRINTS("chipset -> S3, disable dual-role toggling"); + CPRINTS("chipset -> S3"); } DECLARE_HOOK(HOOK_CHIPSET_SUSPEND, dual_role_off, HOOK_PRIO_DEFAULT); DECLARE_HOOK(HOOK_CHIPSET_STARTUP, dual_role_off, HOOK_PRIO_DEFAULT); @@ -2609,7 +2723,7 @@ DECLARE_HOOK(HOOK_CHIPSET_STARTUP, dual_role_off, HOOK_PRIO_DEFAULT); static void dual_role_force_sink(void) { pd_set_dual_role(PD_DRP_FORCE_SINK); - CPRINTS("chipset -> S5, force dual-role port to sink"); + CPRINTS("chipset -> S5"); } DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, dual_role_force_sink, HOOK_PRIO_DEFAULT); diff --git a/include/usb_pd.h b/include/usb_pd.h index 7220f74d7d..67c049dcf0 100644 --- a/include/usb_pd.h +++ b/include/usb_pd.h @@ -122,8 +122,8 @@ enum pd_errors { #define PD_T_PS_SOURCE_ON (480*MSEC) /* between 390ms and 480ms */ #define PD_T_PS_SOURCE_OFF (920*MSEC) /* between 750ms and 920ms */ #define PD_T_PS_HARD_RESET (15*MSEC) /* between 10ms and 20ms */ -#define PD_T_DRP_HOLD (120*MSEC) /* between 100ms and 150ms */ -#define PD_T_DRP_LOCK (120*MSEC) /* between 100ms and 150ms */ +#define PD_T_ERROR_RECOVERY (25*MSEC) /* 25ms */ +#define PD_T_CC_DEBOUNCE (50*MSEC) /* between ??ms and ??ms */ /* DRP_SNK + DRP_SRC must be between 50ms and 100ms with 30%-70% duty cycle */ #define PD_T_DRP_SNK (40*MSEC) /* toggle time for sink DRP */ #define PD_T_DRP_SRC (30*MSEC) /* toggle time for source DRP */ @@ -569,6 +569,7 @@ enum pd_states { #ifdef CONFIG_USB_PD_DUAL_ROLE PD_STATE_SUSPENDED, PD_STATE_SNK_DISCONNECTED, + PD_STATE_SNK_DISCONNECTED_DEBOUNCE, PD_STATE_SNK_HARD_RESET_RECOVER, PD_STATE_SNK_DISCOVERY, PD_STATE_SNK_REQUESTED, @@ -584,6 +585,8 @@ enum pd_states { #endif /* CONFIG_USB_PD_DUAL_ROLE */ PD_STATE_SRC_DISCONNECTED, + PD_STATE_SRC_DISCONNECTED_DEBOUNCE, + PD_STATE_SRC_ACCESSORY, PD_STATE_SRC_HARD_RESET_RECOVER, PD_STATE_SRC_STARTUP, PD_STATE_SRC_DISCOVERY, @@ -612,6 +615,20 @@ enum pd_states { PD_STATE_COUNT, }; +enum pd_cc_states { + PD_CC_NONE, + + /* From DFP perspective */ + PD_CC_NO_UFP, + PD_CC_AUDIO_ACC, + PD_CC_DEBUG_ACC, + PD_CC_UFP_ATTACHED, + + /* From UFP perspective */ + PD_CC_ACC_PRESENT, + PD_CC_DFP_ATTACHED +}; + #ifdef CONFIG_USB_PD_DUAL_ROLE enum pd_dual_role_states { PD_DRP_TOGGLE_ON, diff --git a/test/usb_pd.c b/test/usb_pd.c index 9da5bfc85c..4fb38d1916 100644 --- a/test/usb_pd.c +++ b/test/usb_pd.c @@ -17,21 +17,37 @@ struct pd_port_t { int host_mode; - int cc_volt[2]; /* -1 for Hi-Z */ int has_vbus; int msg_tx_id; int msg_rx_id; int polarity; + int partner_role; /* -1 for none */ + int partner_polarity; } pd_port[PD_PORT_COUNT]; /* Mock functions */ int pd_adc_read(int port, int cc) { - int val = pd_port[port].cc_volt[cc]; - if (val == -1) - return pd_port[port].host_mode ? 3000 : 0; - return val; + if (pd_port[port].host_mode && + pd_port[port].partner_role == PD_ROLE_SINK) + /* we are source connected to sink, return Rd/Open */ + return (pd_port[port].partner_polarity == cc) ? 400 : 3000; + else if (!pd_port[port].host_mode && + pd_port[port].partner_role == PD_ROLE_SOURCE) + /* we are sink connected to source, return Rp/Open */ + return (pd_port[port].partner_polarity == cc) ? 1700 : 0; + else if (pd_port[port].host_mode && + pd_port[port].partner_role == PD_ROLE_SINK) + /* both sources */ + return 3000; + else if (!pd_port[port].host_mode && + pd_port[port].partner_role == PD_ROLE_SOURCE) + /* both sinks */ + return 0; + + /* should never get here */ + return 0; } int pd_snk_is_vbus_provided(int port) @@ -72,7 +88,7 @@ static void init_ports(void) for (i = 0; i < PD_PORT_COUNT; ++i) { pd_port[i].host_mode = 0; - pd_port[i].cc_volt[0] = pd_port[i].cc_volt[1] = -1; + pd_port[i].partner_role = -1; pd_port[i].has_vbus = 0; } } @@ -126,20 +142,21 @@ static int verify_goodcrc(int port, int role, int id) static void plug_in_source(int port, int polarity) { pd_port[port].has_vbus = 1; - pd_port[port].cc_volt[polarity] = 3000; + pd_port[port].partner_role = PD_ROLE_SOURCE; + pd_port[port].partner_polarity = polarity; } static void plug_in_sink(int port, int polarity) { pd_port[port].has_vbus = 0; - pd_port[port].cc_volt[polarity] = 400; /* V_rd */ + pd_port[port].partner_role = PD_ROLE_SINK; + pd_port[port].partner_polarity = polarity; } static void unplug(int port) { pd_port[port].has_vbus = 0; - pd_port[port].cc_volt[0] = -1; - pd_port[port].cc_volt[1] = -1; + pd_port[port].partner_role = -1; task_wake(PORT_TO_TASK_ID(port)); usleep(30 * MSEC); } @@ -150,7 +167,7 @@ static int test_request(void) plug_in_source(0, 0); task_wake(PORT_TO_TASK_ID(0)); - task_wait_event(100 * MSEC); + task_wait_event(2 * PD_T_CC_DEBOUNCE + 100 * MSEC); TEST_ASSERT(pd_port[0].polarity == 0); /* We're in SNK_DISCOVERY now. Let's send the source cap. */ |