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
|
/* Copyright 2022 The ChromiumOS Authors
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <atomic.h>
#include <zephyr/drivers/espi.h>
#include <x86_non_dsx_common_pwrseq_sm_handler.h>
#include "signal_vw.h"
#define MY_COMPAT intel_ap_pwrseq_vw
#if HAS_VW_SIGNALS
/*
* A callback must be registered on the ESPI device (for the
* bus events that are required to be handled) that calls
* power_signal_espi_cb().
*
* This registration is done in a common ESPI initialisation module so
* that there is no possibility of missing events.
*/
LOG_MODULE_DECLARE(ap_pwrseq, CONFIG_AP_PWRSEQ_LOG_LEVEL);
#define INIT_ESPI_SIGNAL(id) \
{ \
.espi_signal = DT_STRING_UPPER_TOKEN(id, virtual_wire), \
.signal = PWR_SIGNAL_ENUM(id), \
.invert = DT_PROP(id, vw_invert), \
},
/*
* Struct containing the eSPI virtual wire config.
*/
struct vw_config {
uint8_t espi_signal; /* associated VW signal */
uint8_t signal; /* power signal */
bool invert; /* Invert the signal value */
};
const static struct vw_config vw_config[] = { DT_FOREACH_STATUS_OKAY(
MY_COMPAT, INIT_ESPI_SIGNAL) };
/*
* Current signal value.
*/
static atomic_t signal_data;
/*
* Mask of valid signals. A signal is considered valid once an
* initial value has been received for it.
*/
static atomic_t signal_valid;
#define espi_dev DEVICE_DT_GET(DT_CHOSEN(intel_ap_pwrseq_espi))
BUILD_ASSERT(ARRAY_SIZE(vw_config) <= (sizeof(atomic_t) * 8));
/*
* Set the value of the VW signal, and optionally
* call the power signal interrupt handling.
*/
static void vw_set(int index, int data, bool notify)
{
bool value = vw_config[index].invert ? !data : !!data;
atomic_set_bit_to(&signal_data, index, value);
atomic_set_bit(&signal_valid, index);
if (notify) {
power_signal_interrupt(vw_config[index].signal, value);
}
}
/*
* Update all the VW signals.
*/
static void vw_update_all(bool notify)
{
for (int i = 0; i < ARRAY_SIZE(vw_config); i++) {
uint8_t vw_value;
if (espi_receive_vwire(espi_dev, vw_config[i].espi_signal,
&vw_value) == 0) {
vw_set(i, vw_value, notify);
}
}
}
void power_signal_espi_cb(const struct device *dev, struct espi_callback *cb,
struct espi_event event)
{
LOG_DBG("ESPI event type 0x%x %d:%d", event.evt_type, event.evt_details,
event.evt_data);
switch (event.evt_type) {
default:
__ASSERT(0, "ESPI unknown event type: %d", event.evt_type);
break;
case ESPI_BUS_EVENT_CHANNEL_READY:
/* Virtual wire channel status change */
if (event.evt_details == ESPI_CHANNEL_VWIRE) {
if (event.evt_data) {
/* If now ready, update all the signals */
vw_update_all(true);
} else {
/* If not ready, invalidate the signals */
atomic_clear(&signal_valid);
}
}
break;
case ESPI_BUS_EVENT_VWIRE_RECEIVED:
for (int i = 0; i < ARRAY_SIZE(vw_config); i++) {
if (event.evt_details == vw_config[i].espi_signal) {
vw_set(i, event.evt_data, true);
}
}
break;
}
}
int power_signal_vw_get(enum pwr_sig_vw vw)
{
if (vw < 0 || vw >= ARRAY_SIZE(vw_config) ||
!atomic_test_bit(&signal_valid, vw)) {
return -EINVAL;
}
return atomic_test_bit(&signal_data, vw);
}
void power_signal_vw_init(void)
{
/*
* Check whether the bus is ready, and if so,
* initialise the current values of the signals.
*/
if (espi_get_channel_status(espi_dev, ESPI_CHANNEL_VWIRE)) {
vw_update_all(false);
}
}
#endif /* HAS_VW_SIGNALS */
|
