|
@@ -48,23 +48,10 @@ enum policy_engine_state {
|
48
|
48
|
PESinkSourceUnresponsive
|
49
|
49
|
};
|
50
|
50
|
|
51
|
|
-/* The received message we're currently working with */
|
52
|
|
-static union pd_msg *policy_engine_message = NULL;
|
53
|
|
-/* The most recent Request from the DPM */
|
54
|
|
-static union pd_msg *last_dpm_request = NULL;
|
55
|
|
-/* Whether or not the source capabilities match our required power */
|
56
|
|
-static bool capability_match = false;
|
57
|
|
-/* Whether or not we have an explicit contract */
|
58
|
|
-static bool explicit_contract = false;
|
59
|
|
-/* Whether or not we're receiving minimum power*/
|
60
|
|
-static bool min_power = false;
|
61
|
|
-/* Keep track of how many hard resets we've sent */
|
62
|
|
-static int hard_reset_counter = 0;
|
63
|
|
-
|
64
|
51
|
static enum policy_engine_state pe_sink_startup(struct pdb_config *cfg)
|
65
|
52
|
{
|
66
|
53
|
/* We don't have an explicit contract currently */
|
67
|
|
- explicit_contract = false;
|
|
54
|
+ cfg->pe._explicit_contract = false;
|
68
|
55
|
/* Tell the DPM that we've started negotiations */
|
69
|
56
|
cfg->dpm.pd_start(cfg);
|
70
|
57
|
|
|
@@ -107,21 +94,21 @@ static enum policy_engine_state pe_sink_wait_cap(struct pdb_config *cfg)
|
107
|
94
|
/* If we got a message */
|
108
|
95
|
if (evt & PDB_EVT_PE_MSG_RX) {
|
109
|
96
|
/* Get the message */
|
110
|
|
- if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
|
|
97
|
+ if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &cfg->pe._message, TIME_IMMEDIATE) == MSG_OK) {
|
111
|
98
|
/* If we got a Source_Capabilities message, read it. */
|
112
|
|
- if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
|
113
|
|
- && PD_NUMOBJ_GET(policy_engine_message) > 0) {
|
|
99
|
+ if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOURCE_CAPABILITIES
|
|
100
|
+ && PD_NUMOBJ_GET(cfg->pe._message) > 0) {
|
114
|
101
|
return PESinkEvalCap;
|
115
|
102
|
/* If the message was a Soft_Reset, do the soft reset procedure */
|
116
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
|
117
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
118
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
119
|
|
- policy_engine_message = NULL;
|
|
103
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOFT_RESET
|
|
104
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
105
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
106
|
+ cfg->pe._message = NULL;
|
120
|
107
|
return PESinkSoftReset;
|
121
|
108
|
/* If we got an unexpected message, reset */
|
122
|
109
|
} else {
|
123
|
110
|
/* Free the received message */
|
124
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
|
111
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
125
|
112
|
return PESinkHardReset;
|
126
|
113
|
}
|
127
|
114
|
}
|
|
@@ -134,16 +121,16 @@ static enum policy_engine_state pe_sink_wait_cap(struct pdb_config *cfg)
|
134
|
121
|
static enum policy_engine_state pe_sink_eval_cap(struct pdb_config *cfg)
|
135
|
122
|
{
|
136
|
123
|
/* Get a message object for the request if we don't have one already */
|
137
|
|
- if (last_dpm_request == NULL) {
|
138
|
|
- last_dpm_request = chPoolAlloc(&pdb_msg_pool);
|
|
124
|
+ if (cfg->pe._last_dpm_request == NULL) {
|
|
125
|
+ cfg->pe._last_dpm_request = chPoolAlloc(&pdb_msg_pool);
|
139
|
126
|
}
|
140
|
127
|
/* Ask the DPM what to request */
|
141
|
|
- capability_match = cfg->dpm.evaluate_capability(cfg, policy_engine_message,
|
142
|
|
- last_dpm_request);
|
|
128
|
+ cfg->dpm.evaluate_capability(cfg, cfg->pe._message,
|
|
129
|
+ cfg->pe._last_dpm_request);
|
143
|
130
|
/* It's up to the DPM to free the Source_Capabilities message, which it can
|
144
|
131
|
* do whenever it sees fit. Just remove our reference to it since we won't
|
145
|
132
|
* know when it's no longer valid. */
|
146
|
|
- policy_engine_message = NULL;
|
|
133
|
+ cfg->pe._message = NULL;
|
147
|
134
|
|
148
|
135
|
return PESinkSelectCap;
|
149
|
136
|
}
|
|
@@ -151,7 +138,7 @@ static enum policy_engine_state pe_sink_eval_cap(struct pdb_config *cfg)
|
151
|
138
|
static enum policy_engine_state pe_sink_select_cap(struct pdb_config *cfg)
|
152
|
139
|
{
|
153
|
140
|
/* Transmit the request */
|
154
|
|
- chMBPost(&cfg->prl.tx_mailbox, (msg_t) last_dpm_request, TIME_IMMEDIATE);
|
|
141
|
+ chMBPost(&cfg->prl.tx_mailbox, (msg_t) cfg->pe._last_dpm_request, TIME_IMMEDIATE);
|
155
|
142
|
chEvtSignal(cfg->prl.tx_thread, PDB_EVT_PRLTX_MSG_TX);
|
156
|
143
|
eventmask_t evt = chEvtWaitAny(PDB_EVT_PE_TX_DONE | PDB_EVT_PE_TX_ERR
|
157
|
144
|
| PDB_EVT_PE_RESET);
|
|
@@ -178,46 +165,46 @@ static enum policy_engine_state pe_sink_select_cap(struct pdb_config *cfg)
|
178
|
165
|
}
|
179
|
166
|
|
180
|
167
|
/* Get the response message */
|
181
|
|
- if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
|
|
168
|
+ if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &cfg->pe._message, TIME_IMMEDIATE) == MSG_OK) {
|
182
|
169
|
/* If the source accepted our request, wait for the new power */
|
183
|
|
- if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
|
184
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
|
170
|
+ if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_ACCEPT
|
|
171
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
185
|
172
|
/* Transition to Sink Standby if necessary */
|
186
|
173
|
cfg->dpm.transition_standby(cfg);
|
187
|
174
|
|
188
|
|
- min_power = false;
|
|
175
|
+ cfg->pe._min_power = false;
|
189
|
176
|
|
190
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
191
|
|
- policy_engine_message = NULL;
|
|
177
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
178
|
+ cfg->pe._message = NULL;
|
192
|
179
|
return PESinkTransitionSink;
|
193
|
180
|
/* If the message was a Soft_Reset, do the soft reset procedure */
|
194
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
|
195
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
196
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
197
|
|
- policy_engine_message = NULL;
|
|
181
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOFT_RESET
|
|
182
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
183
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
184
|
+ cfg->pe._message = NULL;
|
198
|
185
|
return PESinkSoftReset;
|
199
|
186
|
/* If the message was Wait or Reject */
|
200
|
|
- } else if ((PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_REJECT
|
201
|
|
- || PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_WAIT)
|
202
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
|
187
|
+ } else if ((PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_REJECT
|
|
188
|
+ || PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_WAIT)
|
|
189
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
203
|
190
|
/* If we don't have an explicit contract, wait for capabilities */
|
204
|
|
- if (!explicit_contract) {
|
205
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
206
|
|
- policy_engine_message = NULL;
|
|
191
|
+ if (!cfg->pe._explicit_contract) {
|
|
192
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
193
|
+ cfg->pe._message = NULL;
|
207
|
194
|
return PESinkWaitCap;
|
208
|
195
|
/* If we do have an explicit contract, go to the ready state */
|
209
|
196
|
} else {
|
210
|
197
|
/* If we got here from a Wait message, we Should run
|
211
|
198
|
* SinkRequestTimer in the Ready state. */
|
212
|
|
- min_power = (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_WAIT);
|
|
199
|
+ cfg->pe._min_power = (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_WAIT);
|
213
|
200
|
|
214
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
215
|
|
- policy_engine_message = NULL;
|
|
201
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
202
|
+ cfg->pe._message = NULL;
|
216
|
203
|
return PESinkReady;
|
217
|
204
|
}
|
218
|
205
|
} else {
|
219
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
220
|
|
- policy_engine_message = NULL;
|
|
206
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
207
|
+ cfg->pe._message = NULL;
|
221
|
208
|
return PESinkSendSoftReset;
|
222
|
209
|
}
|
223
|
210
|
}
|
|
@@ -239,20 +226,20 @@ static enum policy_engine_state pe_sink_transition_sink(struct pdb_config *cfg)
|
239
|
226
|
}
|
240
|
227
|
|
241
|
228
|
/* If we received a message, read it */
|
242
|
|
- if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
|
|
229
|
+ if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &cfg->pe._message, TIME_IMMEDIATE) == MSG_OK) {
|
243
|
230
|
/* If we got a PS_RDY, handle it */
|
244
|
|
- if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PS_RDY
|
245
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
|
231
|
+ if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_PS_RDY
|
|
232
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
246
|
233
|
/* We just finished negotiating an explicit contract */
|
247
|
|
- explicit_contract = true;
|
|
234
|
+ cfg->pe._explicit_contract = true;
|
248
|
235
|
|
249
|
236
|
/* Set the output appropriately */
|
250
|
|
- if (!min_power) {
|
|
237
|
+ if (!cfg->pe._min_power) {
|
251
|
238
|
cfg->dpm.transition_requested(cfg);
|
252
|
239
|
}
|
253
|
240
|
|
254
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
255
|
|
- policy_engine_message = NULL;
|
|
241
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
242
|
+ cfg->pe._message = NULL;
|
256
|
243
|
return PESinkReady;
|
257
|
244
|
/* If there was a protocol error, send a hard reset */
|
258
|
245
|
} else {
|
|
@@ -261,8 +248,8 @@ static enum policy_engine_state pe_sink_transition_sink(struct pdb_config *cfg)
|
261
|
248
|
*/
|
262
|
249
|
cfg->dpm.transition_default(cfg);
|
263
|
250
|
|
264
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
265
|
|
- policy_engine_message = NULL;
|
|
251
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
252
|
+ cfg->pe._message = NULL;
|
266
|
253
|
return PESinkHardReset;
|
267
|
254
|
}
|
268
|
255
|
}
|
|
@@ -275,7 +262,7 @@ static enum policy_engine_state pe_sink_ready(struct pdb_config *cfg)
|
275
|
262
|
eventmask_t evt;
|
276
|
263
|
|
277
|
264
|
/* Wait for an event */
|
278
|
|
- if (min_power) {
|
|
265
|
+ if (cfg->pe._min_power) {
|
279
|
266
|
evt = chEvtWaitAnyTimeout(PDB_EVT_PE_MSG_RX | PDB_EVT_PE_RESET
|
280
|
267
|
| PDB_EVT_PE_I_OVRTEMP | PDB_EVT_PE_GET_SOURCE_CAP
|
281
|
268
|
| PDB_EVT_PE_NEW_POWER, PD_T_SINK_REQUEST);
|
|
@@ -306,9 +293,9 @@ static enum policy_engine_state pe_sink_ready(struct pdb_config *cfg)
|
306
|
293
|
* design of this firmware. */
|
307
|
294
|
if (evt & PDB_EVT_PE_NEW_POWER) {
|
308
|
295
|
/* Make sure we're evaluating NULL capabilities to use the old ones */
|
309
|
|
- if (policy_engine_message != NULL) {
|
310
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
311
|
|
- policy_engine_message = NULL;
|
|
296
|
+ if (cfg->pe._message != NULL) {
|
|
297
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
298
|
+ cfg->pe._message = NULL;
|
312
|
299
|
}
|
313
|
300
|
return PESinkEvalCap;
|
314
|
301
|
}
|
|
@@ -321,94 +308,94 @@ static enum policy_engine_state pe_sink_ready(struct pdb_config *cfg)
|
321
|
308
|
|
322
|
309
|
/* If we received a message */
|
323
|
310
|
if (evt & PDB_EVT_PE_MSG_RX) {
|
324
|
|
- if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
|
|
311
|
+ if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &cfg->pe._message, TIME_IMMEDIATE) == MSG_OK) {
|
325
|
312
|
/* Ignore vendor-defined messages */
|
326
|
|
- if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_VENDOR_DEFINED
|
327
|
|
- && PD_NUMOBJ_GET(policy_engine_message) > 0) {
|
328
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
329
|
|
- policy_engine_message = NULL;
|
|
313
|
+ if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_VENDOR_DEFINED
|
|
314
|
+ && PD_NUMOBJ_GET(cfg->pe._message) > 0) {
|
|
315
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
316
|
+ cfg->pe._message = NULL;
|
330
|
317
|
return PESinkReady;
|
331
|
318
|
/* Ignore Ping messages */
|
332
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PING
|
333
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
334
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
335
|
|
- policy_engine_message = NULL;
|
|
319
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_PING
|
|
320
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
321
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
322
|
+ cfg->pe._message = NULL;
|
336
|
323
|
return PESinkReady;
|
337
|
324
|
/* Reject DR_Swap messages */
|
338
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_DR_SWAP
|
339
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
340
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
341
|
|
- policy_engine_message = NULL;
|
|
325
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_DR_SWAP
|
|
326
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
327
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
328
|
+ cfg->pe._message = NULL;
|
342
|
329
|
return PESinkSendReject;
|
343
|
330
|
/* Reject Get_Source_Cap messages */
|
344
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GET_SOURCE_CAP
|
345
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
346
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
347
|
|
- policy_engine_message = NULL;
|
|
331
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_GET_SOURCE_CAP
|
|
332
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
333
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
334
|
+ cfg->pe._message = NULL;
|
348
|
335
|
return PESinkSendReject;
|
349
|
336
|
/* Reject PR_Swap messages */
|
350
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_PR_SWAP
|
351
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
352
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
353
|
|
- policy_engine_message = NULL;
|
|
337
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_PR_SWAP
|
|
338
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
339
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
340
|
+ cfg->pe._message = NULL;
|
354
|
341
|
return PESinkSendReject;
|
355
|
342
|
/* Reject VCONN_Swap messages */
|
356
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_VCONN_SWAP
|
357
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
358
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
359
|
|
- policy_engine_message = NULL;
|
|
343
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_VCONN_SWAP
|
|
344
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
345
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
346
|
+ cfg->pe._message = NULL;
|
360
|
347
|
return PESinkSendReject;
|
361
|
348
|
/* Reject Request messages */
|
362
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_REQUEST
|
363
|
|
- && PD_NUMOBJ_GET(policy_engine_message) > 0) {
|
364
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
365
|
|
- policy_engine_message = NULL;
|
|
349
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_REQUEST
|
|
350
|
+ && PD_NUMOBJ_GET(cfg->pe._message) > 0) {
|
|
351
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
352
|
+ cfg->pe._message = NULL;
|
366
|
353
|
return PESinkSendReject;
|
367
|
354
|
/* Reject Sink_Capabilities messages */
|
368
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SINK_CAPABILITIES
|
369
|
|
- && PD_NUMOBJ_GET(policy_engine_message) > 0) {
|
370
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
371
|
|
- policy_engine_message = NULL;
|
|
355
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SINK_CAPABILITIES
|
|
356
|
+ && PD_NUMOBJ_GET(cfg->pe._message) > 0) {
|
|
357
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
358
|
+ cfg->pe._message = NULL;
|
372
|
359
|
return PESinkSendReject;
|
373
|
360
|
/* Handle GotoMin messages */
|
374
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GOTOMIN
|
375
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
|
361
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_GOTOMIN
|
|
362
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
376
|
363
|
if (cfg->dpm.giveback_enabled(cfg)) {
|
377
|
364
|
/* Transition to the minimum current level */
|
378
|
365
|
cfg->dpm.transition_min(cfg);
|
379
|
|
- min_power = true;
|
|
366
|
+ cfg->pe._min_power = true;
|
380
|
367
|
|
381
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
382
|
|
- policy_engine_message = NULL;
|
|
368
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
369
|
+ cfg->pe._message = NULL;
|
383
|
370
|
return PESinkTransitionSink;
|
384
|
371
|
} else {
|
385
|
372
|
/* We don't support GiveBack, so send a Reject */
|
386
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
387
|
|
- policy_engine_message = NULL;
|
|
373
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
374
|
+ cfg->pe._message = NULL;
|
388
|
375
|
return PESinkSendReject;
|
389
|
376
|
}
|
390
|
377
|
/* Evaluate new Source_Capabilities */
|
391
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOURCE_CAPABILITIES
|
392
|
|
- && PD_NUMOBJ_GET(policy_engine_message) > 0) {
|
|
378
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOURCE_CAPABILITIES
|
|
379
|
+ && PD_NUMOBJ_GET(cfg->pe._message) > 0) {
|
393
|
380
|
/* Don't free the message: we need to keep the
|
394
|
381
|
* Source_Capabilities message so we can evaluate it. */
|
395
|
382
|
return PESinkEvalCap;
|
396
|
383
|
/* Give sink capabilities when asked */
|
397
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_GET_SINK_CAP
|
398
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
399
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
400
|
|
- policy_engine_message = NULL;
|
|
384
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_GET_SINK_CAP
|
|
385
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
386
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
387
|
+ cfg->pe._message = NULL;
|
401
|
388
|
return PESinkGiveSinkCap;
|
402
|
389
|
/* If the message was a Soft_Reset, do the soft reset procedure */
|
403
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
|
404
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
405
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
406
|
|
- policy_engine_message = NULL;
|
|
390
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOFT_RESET
|
|
391
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
392
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
393
|
+ cfg->pe._message = NULL;
|
407
|
394
|
return PESinkSoftReset;
|
408
|
395
|
/* If we got an unknown message, send a soft reset */
|
409
|
396
|
} else {
|
410
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
411
|
|
- policy_engine_message = NULL;
|
|
397
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
398
|
+ cfg->pe._message = NULL;
|
412
|
399
|
return PESinkSendSoftReset;
|
413
|
400
|
}
|
414
|
401
|
}
|
|
@@ -477,7 +464,7 @@ static enum policy_engine_state pe_sink_hard_reset(struct pdb_config *cfg)
|
477
|
464
|
{
|
478
|
465
|
/* If we've already sent the maximum number of hard resets, assume the
|
479
|
466
|
* source is unresponsive. */
|
480
|
|
- if (hard_reset_counter > PD_N_HARD_RESET_COUNT) {
|
|
467
|
+ if (cfg->pe._hard_reset_counter > PD_N_HARD_RESET_COUNT) {
|
481
|
468
|
return PESinkSourceUnresponsive;
|
482
|
469
|
}
|
483
|
470
|
|
|
@@ -486,14 +473,14 @@ static enum policy_engine_state pe_sink_hard_reset(struct pdb_config *cfg)
|
486
|
473
|
chEvtWaitAny(PDB_EVT_PE_HARD_SENT);
|
487
|
474
|
|
488
|
475
|
/* Increment HardResetCounter */
|
489
|
|
- hard_reset_counter++;
|
|
476
|
+ cfg->pe._hard_reset_counter++;
|
490
|
477
|
|
491
|
478
|
return PESinkTransitionDefault;
|
492
|
479
|
}
|
493
|
480
|
|
494
|
481
|
static enum policy_engine_state pe_sink_transition_default(struct pdb_config *cfg)
|
495
|
482
|
{
|
496
|
|
- explicit_contract = false;
|
|
483
|
+ cfg->pe._explicit_contract = false;
|
497
|
484
|
|
498
|
485
|
/* Tell the DPM to transition to default power */
|
499
|
486
|
cfg->dpm.transition_default(cfg);
|
|
@@ -578,23 +565,23 @@ static enum policy_engine_state pe_sink_send_soft_reset(struct pdb_config *cfg)
|
578
|
565
|
}
|
579
|
566
|
|
580
|
567
|
/* Get the response message */
|
581
|
|
- if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &policy_engine_message, TIME_IMMEDIATE) == MSG_OK) {
|
|
568
|
+ if (chMBFetch(&cfg->pe.mailbox, (msg_t *) &cfg->pe._message, TIME_IMMEDIATE) == MSG_OK) {
|
582
|
569
|
/* If the source accepted our soft reset, wait for capabilities. */
|
583
|
|
- if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_ACCEPT
|
584
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
585
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
586
|
|
- policy_engine_message = NULL;
|
|
570
|
+ if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_ACCEPT
|
|
571
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
572
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
573
|
+ cfg->pe._message = NULL;
|
587
|
574
|
return PESinkWaitCap;
|
588
|
575
|
/* If the message was a Soft_Reset, do the soft reset procedure */
|
589
|
|
- } else if (PD_MSGTYPE_GET(policy_engine_message) == PD_MSGTYPE_SOFT_RESET
|
590
|
|
- && PD_NUMOBJ_GET(policy_engine_message) == 0) {
|
591
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
592
|
|
- policy_engine_message = NULL;
|
|
576
|
+ } else if (PD_MSGTYPE_GET(cfg->pe._message) == PD_MSGTYPE_SOFT_RESET
|
|
577
|
+ && PD_NUMOBJ_GET(cfg->pe._message) == 0) {
|
|
578
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
579
|
+ cfg->pe._message = NULL;
|
593
|
580
|
return PESinkSoftReset;
|
594
|
581
|
/* Otherwise, send a hard reset */
|
595
|
582
|
} else {
|
596
|
|
- chPoolFree(&pdb_msg_pool, policy_engine_message);
|
597
|
|
- policy_engine_message = NULL;
|
|
583
|
+ chPoolFree(&pdb_msg_pool, cfg->pe._message);
|
|
584
|
+ cfg->pe._message = NULL;
|
598
|
585
|
return PESinkHardReset;
|
599
|
586
|
}
|
600
|
587
|
}
|