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
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
/* Copyright 2014 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "adc.h"
#include "common.h"
#include "console.h"
#include "dma.h"
#include "gpio.h"
#include "hooks.h"
#include "hwtimer.h"
#include "injector.h"
#include "registers.h"
#include "system.h"
#include "task.h"
#include "timer.h"
#include "usb_pd.h"
#include "usb_pd_config.h"
#include "util.h"
/* PD packet text tracing state : TRACE_MODE_OFF/RAW/ON */
int trace_mode;
/* The FSM is waiting for the following command (0 == None) */
uint8_t expected_cmd;
static const char * const ctrl_msg_name[] = {
[0] = "RSVD-C0",
[PD_CTRL_GOOD_CRC] = "GOODCRC",
[PD_CTRL_GOTO_MIN] = "GOTOMIN",
[PD_CTRL_ACCEPT] = "ACCEPT",
[PD_CTRL_REJECT] = "REJECT",
[PD_CTRL_PING] = "PING",
[PD_CTRL_PS_RDY] = "PSRDY",
[PD_CTRL_GET_SOURCE_CAP] = "GSRCCAP",
[PD_CTRL_GET_SINK_CAP] = "GSNKCAP",
[PD_CTRL_DR_SWAP] = "DRSWAP",
[PD_CTRL_PR_SWAP] = "PRSWAP",
[PD_CTRL_VCONN_SWAP] = "VCONNSW",
[PD_CTRL_WAIT] = "WAIT",
[PD_CTRL_SOFT_RESET] = "SFT-RST",
[14] = "RSVD-C14",
[15] = "RSVD-C15",
};
static const char * const data_msg_name[] = {
[0] = "RSVD-D0",
[PD_DATA_SOURCE_CAP] = "SRCCAP",
[PD_DATA_REQUEST] = "REQUEST",
[PD_DATA_BIST] = "BIST",
[PD_DATA_SINK_CAP] = "SNKCAP",
/* 5-14 Reserved */
[PD_DATA_VENDOR_DEF] = "VDM",
};
static const char * const svdm_cmd_name[] = {
[CMD_DISCOVER_IDENT] = "DISCID",
[CMD_DISCOVER_SVID] = "DISCSVID",
[CMD_DISCOVER_MODES] = "DISCMODE",
[CMD_ENTER_MODE] = "ENTER",
[CMD_EXIT_MODE] = "EXIT",
[CMD_ATTENTION] = "ATTN",
[CMD_DP_STATUS] = "DPSTAT",
[CMD_DP_CONFIG] = "DPCFG",
};
static const char * const svdm_cmdt_name[] = {
[CMDT_INIT] = "INI",
[CMDT_RSP_ACK] = "ACK",
[CMDT_RSP_NAK] = "NAK",
[CMDT_RSP_BUSY] = "BSY",
};
static void print_pdo(uint32_t word)
{
if ((word & PDO_TYPE_MASK) == PDO_TYPE_BATTERY)
ccprintf(" %dmV/%dmW", ((word>>10)&0x3ff)*50,
(word&0x3ff)*250);
else
ccprintf(" %dmV/%dmA", ((word>>10)&0x3ff)*50,
(word&0x3ff)*10);
}
static void print_rdo(uint32_t word)
{
ccprintf("{%d} %08x", RDO_POS(word), word);
}
static void print_vdo(int idx, uint32_t word)
{
if (idx == 0 && (word & VDO_SVDM_TYPE)) {
const char *cmd = svdm_cmd_name[PD_VDO_CMD(word)];
const char *cmdt = svdm_cmdt_name[PD_VDO_CMDT(word)];
uint16_t vid = PD_VDO_VID(word);
if (!cmd)
cmd = "????";
ccprintf(" V%04x:%s,%s:%08x", vid, cmd, cmdt, word);
} else {
ccprintf(" %08x", word);
}
}
static void print_packet(int head, uint32_t *payload)
{
int i;
int cnt = PD_HEADER_CNT(head);
int typ = PD_HEADER_TYPE(head);
int id = PD_HEADER_ID(head);
const char *name;
const char *prole;
if (trace_mode == TRACE_MODE_RAW) {
ccprintf("%pT[%04x]", PRINTF_TIMESTAMP_NOW, head);
for (i = 0; i < cnt; i++)
ccprintf(" %08x", payload[i]);
ccputs("\n");
return;
}
name = cnt ? data_msg_name[typ] : ctrl_msg_name[typ];
prole = head & (PD_ROLE_SOURCE << 8) ? "SRC" : "SNK";
ccprintf("%pT %s/%d [%04x]%s",
PRINTF_TIMESTAMP_NOW, prole, id, head, name);
if (!cnt) { /* Control message : we are done */
ccputs("\n");
return;
}
/* Print payload for data message */
for (i = 0; i < cnt; i++)
switch (typ) {
case PD_DATA_SOURCE_CAP:
case PD_DATA_SINK_CAP:
print_pdo(payload[i]);
break;
case PD_DATA_REQUEST:
print_rdo(payload[i]);
break;
case PD_DATA_BIST:
ccprintf("mode %d cnt %04x", payload[i] >> 28,
payload[i] & 0xffff);
break;
case PD_DATA_VENDOR_DEF:
print_vdo(i, payload[i]);
break;
default:
ccprintf(" %08x", payload[i]);
}
ccputs("\n");
}
static void print_error(enum pd_rx_errors err)
{
if (err == PD_RX_ERR_INVAL)
ccprintf("%pT TMOUT\n", PRINTF_TIMESTAMP_NOW);
else if (err == PD_RX_ERR_HARD_RESET)
ccprintf("%pT HARD-RST\n", PRINTF_TIMESTAMP_NOW);
else if (err == PD_RX_ERR_UNSUPPORTED_SOP)
ccprintf("%pT SOP*\n", PRINTF_TIMESTAMP_NOW);
else
ccprintf("ERR %d\n", err);
}
/* keep track of RX edge timing in order to trigger receive */
static timestamp_t rx_edge_ts[2][PD_RX_TRANSITION_COUNT];
static int rx_edge_ts_idx[2];
void rx_event(void)
{
int pending, i;
int next_idx;
pending = STM32_EXTI_PR;
/* Iterate over the 2 CC lines */
for (i = 0; i < 2; i++) {
if (pending & (1 << (21 + i))) {
rx_edge_ts[i][rx_edge_ts_idx[i]].val = get_time().val;
next_idx = (rx_edge_ts_idx[i] ==
PD_RX_TRANSITION_COUNT - 1) ?
0 : rx_edge_ts_idx[i] + 1;
/*
* If we have seen enough edges in a certain amount of
* time, then trigger RX start.
*/
if ((rx_edge_ts[i][rx_edge_ts_idx[i]].val -
rx_edge_ts[i][next_idx].val)
< PD_RX_TRANSITION_WINDOW) {
/* acquire the message only on the active CC */
STM32_COMP_CSR &= ~(i ? STM32_COMP_CMP1EN
: STM32_COMP_CMP2EN);
/* start sampling */
pd_rx_start(0);
/*
* ignore the comparator IRQ until we are done
* with current message
*/
pd_rx_disable_monitoring(0);
/* trigger the analysis in the task */
#ifdef HAS_TASK_SNIFFER
task_set_event(TASK_ID_SNIFFER, 1 << i);
#endif
/* start reception only one CC line */
break;
} else {
/* do not trigger RX start, just clear int */
STM32_EXTI_PR = EXTI_COMP_MASK(0);
}
rx_edge_ts_idx[i] = next_idx;
}
}
}
#ifdef HAS_TASK_SNIFFER
DECLARE_IRQ(STM32_IRQ_COMP, rx_event, 1);
#endif
void trace_packets(void)
{
int head;
uint32_t payload[7];
#ifdef HAS_TASK_SNIFFER
/* Disable sniffer DMA configuration */
dma_disable(STM32_DMAC_CH6);
dma_disable(STM32_DMAC_CH7);
task_disable_irq(STM32_IRQ_DMA_CHANNEL_4_7);
/* remove TIM1 CH1/2/3 DMA remapping */
STM32_SYSCFG_CFGR1 &= ~BIT(28);
#endif
/* "classical" PD RX configuration */
pd_hw_init_rx(0);
pd_select_polarity(0, 0);
/* detect messages on both CCx lines */
STM32_COMP_CSR |= STM32_COMP_CMP2EN | STM32_COMP_CMP1EN;
/* Enable the RX interrupts */
pd_rx_enable_monitoring(0);
while (1) {
task_wait_event(-1);
if (trace_mode == TRACE_MODE_OFF)
break;
/* incoming packet processing */
head = pd_analyze_rx(0, payload);
pd_rx_complete(0);
/* re-enabled detection on both CCx lines */
STM32_COMP_CSR |= STM32_COMP_CMP2EN | STM32_COMP_CMP1EN;
pd_rx_enable_monitoring(0);
/* print the last packet content */
if (head > 0)
print_packet(head, payload);
else
print_error(head);
if (head > 0 && expected_cmd == PD_HEADER_TYPE(head))
task_wake(TASK_ID_CONSOLE);
}
task_disable_irq(STM32_IRQ_COMP);
/* Disable tracer DMA configuration */
dma_disable(STM32_DMAC_CH2);
/* Put back : sniffer RX hardware configuration */
#ifdef HAS_TASK_SNIFFER
sniffer_init();
#endif
}
int expect_packet(int pol, uint8_t cmd, uint32_t timeout_us)
{
uint32_t evt;
expected_cmd = cmd;
evt = task_wait_event(timeout_us);
return !(evt == TASK_EVENT_TIMER);
}
void set_trace_mode(int mode)
{
/* No change */
if (mode == trace_mode)
return;
trace_mode = mode;
/* kick the task to take into account the new value */
#ifdef HAS_TASK_SNIFFER
task_wake(TASK_ID_SNIFFER);
#endif
}
|
