1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
/* Copyright 2015 The ChromiumOS Authors
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "common.h"
#include "anx7447.h"
#include "console.h"
#include "gpio.h"
#include "hooks.h"
#include "registers.h"
#include "system.h"
#include "task.h"
#include "timer.h"
#include "util.h"
#include "usb_mux.h"
#include "usb_pd.h"
#include "usb_pd_pdo.h"
#define CPRINTF(format, args...) cprintf(CC_USBPD, format, ##args)
#define CPRINTS(format, args...) cprints(CC_USBPD, format, ##args)
/* Used to fake VBUS presence since no GPIO is available to read VBUS */
static int vbus_present;
#if defined(CONFIG_USB_PD_TCPM_MUX) && defined(CONFIG_USB_PD_TCPM_ANX7447)
const struct usb_mux_chain usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = {
{
.mux =
&(const struct usb_mux){
.usb_port = 0,
.driver = &anx7447_usb_mux_driver,
.hpd_update = &anx7447_tcpc_update_hpd_status,
},
},
};
#endif
#ifdef CONFIG_USB_PD_TCPM_ANX7447
int pd_set_power_supply_ready(int port)
{
/* Disable charging */
anx7447_board_charging_enable(port, 0);
/* Provide VBUS */
gpio_set_level(GPIO_VBUS_PMIC_CTRL, 1);
anx7447_set_power_supply_ready(port);
/* notify host of power info change */
CPRINTS("Enable VBUS, port%d", port);
return EC_SUCCESS;
}
void pd_power_supply_reset(int port)
{
/* Disable VBUS */
anx7447_power_supply_reset(port);
gpio_set_level(GPIO_VBUS_PMIC_CTRL, 0);
CPRINTS("Disable VBUS, port%d", port);
/* Enable charging */
anx7447_board_charging_enable(port, 1);
}
#else
int pd_set_power_supply_ready(int port)
{
/* Turn on the "up" LED when we output VBUS */
gpio_set_level(GPIO_LED_U, 1);
CPRINTS("Power supply ready/%d", port);
return EC_SUCCESS; /* we are ready */
}
void pd_power_supply_reset(int port)
{
/* Turn off the "up" LED when we shutdown VBUS */
gpio_set_level(GPIO_LED_U, 0);
/* Disable VBUS */
CPRINTS("Disable VBUS", port);
}
#endif /* CONFIG_USB_PD_TCPM_ANX7447 */
void pd_set_input_current_limit(int port, uint32_t max_ma,
uint32_t supply_voltage)
{
CPRINTS("USBPD current limit port %d max %d mA %d mV", port, max_ma,
supply_voltage);
/* do some LED coding of the power we can sink */
if (max_ma) {
if (supply_voltage > 6500)
gpio_set_level(GPIO_LED_R, 1);
else
gpio_set_level(GPIO_LED_L, 1);
} else {
gpio_set_level(GPIO_LED_L, 0);
gpio_set_level(GPIO_LED_R, 0);
}
}
__override void typec_set_input_current_limit(int port, uint32_t max_ma,
uint32_t supply_voltage)
{
CPRINTS("TYPEC current limit port %d max %d mA %d mV", port, max_ma,
supply_voltage);
gpio_set_level(GPIO_LED_R, !!max_ma);
}
void button_event(enum gpio_signal signal)
{
vbus_present = !vbus_present;
CPRINTS("VBUS %d", vbus_present);
}
static int command_vbus_toggle(int argc, const char **argv)
{
vbus_present = !vbus_present;
CPRINTS("VBUS %d", vbus_present);
return EC_SUCCESS;
}
DECLARE_CONSOLE_COMMAND(vbus, command_vbus_toggle, "", "Toggle VBUS detected");
int pd_snk_is_vbus_provided(int port)
{
return vbus_present;
}
__override int pd_check_data_swap(int port, enum pd_data_role data_role)
{
/* Always allow data swap */
return 1;
}
#ifdef CONFIG_USBC_VCONN_SWAP
int pd_check_vconn_swap(int port)
{
/*
* Allow vconn swap as long as we are acting as a dual role device,
* otherwise assume our role is fixed (not in S0 or console command
* to fix our role).
*/
return pd_get_dual_role(port) == PD_DRP_TOGGLE_ON;
}
#endif
__override void pd_check_pr_role(int port, enum pd_power_role pr_role,
int flags)
{
}
__override void pd_check_dr_role(int port, enum pd_data_role dr_role, int flags)
{
}
/* ----------------- Vendor Defined Messages ------------------ */
const uint32_t vdo_idh = VDO_IDH(1, /* data caps as USB host */
0, /* data caps as USB device */
IDH_PTYPE_PERIPH, 0, /* supports alt modes */
0x0000);
const uint32_t vdo_product = VDO_PRODUCT(0x0000, 0x0000);
static int svdm_response_identity(int port, uint32_t *payload)
{
payload[VDO_I(IDH)] = vdo_idh;
payload[VDO_I(CSTAT)] = VDO_CSTAT(0);
payload[VDO_I(PRODUCT)] = vdo_product;
return VDO_I(PRODUCT) + 1;
}
__override const struct svdm_response svdm_rsp = {
.identity = &svdm_response_identity,
.svids = NULL,
.modes = NULL,
};
#ifdef CONFIG_USB_PD_ALT_MODE_DFP
__override void svdm_safe_dp_mode(int port)
{
/* make DP interface safe until configure */
dp_flags[port] = 0;
/*
* board_set_usb_mux(port, USB_PD_MUX_NONE,
* polarity_rm_dts(pd_get_polarity(port)));
*/
}
__override int svdm_dp_config(int port, uint32_t *payload)
{
int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
int pin_mode = pd_dfp_dp_get_pin_mode(port, dp_status[port]);
mux_state_t mux_state = USB_PD_MUX_NONE;
CPRINTS("pin_mode = %d", pin_mode);
if (!pin_mode)
return 0;
switch (pin_mode) {
case MODE_DP_PIN_A:
case MODE_DP_PIN_C:
case MODE_DP_PIN_E:
mux_state |= USB_PD_MUX_DP_ENABLED;
break;
case MODE_DP_PIN_B:
case MODE_DP_PIN_D:
case MODE_DP_PIN_F:
mux_state |= USB_PD_MUX_DOCK;
break;
}
usb_mux_set(port, mux_state, USB_SWITCH_CONNECT,
polarity_rm_dts(pd_get_polarity(port)));
/*
* board_set_usb_mux(port, USB_PD_MUX_DP_ENABLED,
* polarity_rm_dts(pd_get_polarity(port)));
*/
payload[0] =
VDO(USB_SID_DISPLAYPORT, 1, CMD_DP_CONFIG | VDO_OPOS(opos));
payload[1] = VDO_DP_CFG(pin_mode, /* pin mode */
1, /* DPv1.3 signaling */
2); /* UFP connected */
return 2;
}
__override void svdm_dp_post_config(int port)
{
dp_flags[port] |= DP_FLAGS_DP_ON;
if (!(dp_flags[port] & DP_FLAGS_HPD_HI_PENDING))
return;
usb_mux_hpd_update(port,
USB_PD_MUX_HPD_LVL | USB_PD_MUX_HPD_IRQ_DEASSERTED);
}
__override int svdm_dp_attention(int port, uint32_t *payload)
{
int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]);
int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]);
mux_state_t mux_state =
(lvl ? USB_PD_MUX_HPD_LVL : USB_PD_MUX_HPD_LVL_DEASSERTED) |
(irq ? USB_PD_MUX_HPD_IRQ : USB_PD_MUX_HPD_IRQ_DEASSERTED);
/* Note: Usage is deprecated, use usb_mux_hpd_update instead */
CPRINTS("Attention: 0x%x", payload[1]);
usb_mux_hpd_update(port, mux_state);
dp_status[port] = payload[1];
/* ack */
return 1;
}
__override void svdm_exit_dp_mode(int port)
{
usb_mux_hpd_update(port, USB_PD_MUX_HPD_LVL_DEASSERTED |
USB_PD_MUX_HPD_IRQ_DEASSERTED);
}
#endif /* CONFIG_USB_PD_ALT_MODE_DFP */
|
