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
|
/* SPDX-License-Identifier: GPL-2.0-only */
/* This file is part of the coreboot project. */
#include <device/mmio.h>
#include <cpu/x86/msr.h>
#include <cbfs.h>
#include <region_file.h>
#include <timer.h>
#include <device/pci_def.h>
#include <bootstate.h>
#include <console/console.h>
#include <device/pci_ops.h>
#include <amdblocks/psp.h>
#include <soc/iomap.h>
#include <soc/northbridge.h>
#include "psp_def.h"
static const char *psp_status_nobase = "error: PSP BAR3 not assigned";
static const char *psp_status_halted = "error: PSP in halted state";
static const char *psp_status_recovery = "error: PSP recovery required";
static const char *psp_status_errcmd = "error sending command";
static const char *psp_status_init_timeout = "error: PSP init timeout";
static const char *psp_status_cmd_timeout = "error: PSP command timeout";
static const char *psp_status_noerror = "";
static const char *status_to_string(int err)
{
switch (err) {
case -PSPSTS_NOBASE:
return psp_status_nobase;
case -PSPSTS_HALTED:
return psp_status_halted;
case -PSPSTS_RECOVERY:
return psp_status_recovery;
case -PSPSTS_SEND_ERROR:
return psp_status_errcmd;
case -PSPSTS_INIT_TIMEOUT:
return psp_status_init_timeout;
case -PSPSTS_CMD_TIMEOUT:
return psp_status_cmd_timeout;
default:
return psp_status_noerror;
}
}
static u32 rd_mbox_sts(struct psp_mbox *mbox)
{
return read32(&mbox->mbox_status);
}
static void wr_mbox_cmd(struct psp_mbox *mbox, u32 cmd)
{
write32(&mbox->mbox_command, cmd);
}
static u32 rd_mbox_cmd(struct psp_mbox *mbox)
{
return read32(&mbox->mbox_command);
}
static void wr_mbox_cmd_resp(struct psp_mbox *mbox, void *buffer)
{
write64(&mbox->cmd_response, (uintptr_t)buffer);
}
static u32 rd_resp_sts(struct mbox_default_buffer *buffer)
{
return read32(&buffer->header.status);
}
static int wait_initialized(struct psp_mbox *mbox)
{
struct stopwatch sw;
stopwatch_init_msecs_expire(&sw, PSP_INIT_TIMEOUT);
do {
if (rd_mbox_sts(mbox) & STATUS_INITIALIZED)
return 0;
} while (!stopwatch_expired(&sw));
return -PSPSTS_INIT_TIMEOUT;
}
static int wait_command(struct psp_mbox *mbox)
{
struct stopwatch sw;
stopwatch_init_msecs_expire(&sw, PSP_CMD_TIMEOUT);
do {
if (!rd_mbox_cmd(mbox))
return 0;
} while (!stopwatch_expired(&sw));
return -PSPSTS_CMD_TIMEOUT;
}
static int send_psp_command(u32 command, void *buffer)
{
struct psp_mbox *mbox = soc_get_mbox_address();
if (!mbox)
return -PSPSTS_NOBASE;
/* check for PSP error conditions */
if (rd_mbox_sts(mbox) & STATUS_HALT)
return -PSPSTS_HALTED;
if (rd_mbox_sts(mbox) & STATUS_RECOVERY)
return -PSPSTS_RECOVERY;
/* PSP must be finished with init and ready to accept a command */
if (wait_initialized(mbox))
return -PSPSTS_INIT_TIMEOUT;
if (wait_command(mbox))
return -PSPSTS_CMD_TIMEOUT;
/* set address of command-response buffer and write command register */
wr_mbox_cmd_resp(mbox, buffer);
wr_mbox_cmd(mbox, command);
/* PSP clears command register when complete */
if (wait_command(mbox))
return -PSPSTS_CMD_TIMEOUT;
/* check delivery status */
if (rd_mbox_sts(mbox) & (STATUS_ERROR | STATUS_TERMINATED))
return -PSPSTS_SEND_ERROR;
return 0;
}
/*
* Print meaningful status to the console. Caller only passes a pointer to a
* buffer if it's expected to contain its own status.
*/
static void print_cmd_status(int cmd_status, struct mbox_default_buffer *buffer)
{
if (buffer && rd_resp_sts(buffer))
printk(BIOS_DEBUG, "buffer status=0x%x ", rd_resp_sts(buffer));
if (cmd_status)
printk(BIOS_DEBUG, "%s\n", status_to_string(cmd_status));
else
printk(BIOS_DEBUG, "OK\n");
}
/*
* Notify the PSP that DRAM is present. Upon receiving this command, the PSP
* will load its OS into fenced DRAM that is not accessible to the x86 cores.
*/
int psp_notify_dram(void)
{
int cmd_status;
struct mbox_default_buffer buffer = {
.header = {
.size = sizeof(buffer)
}
};
printk(BIOS_DEBUG, "PSP: Notify that DRAM is available... ");
cmd_status = send_psp_command(MBOX_BIOS_CMD_DRAM_INFO, &buffer);
/* buffer's status shouldn't change but report it if it does */
print_cmd_status(cmd_status, &buffer);
return cmd_status;
}
/*
* Notify the PSP that the system is completing the boot process. Upon
* receiving this command, the PSP will only honor commands where the buffer
* is in SMM space.
*/
static void psp_notify_boot_done(void *unused)
{
int cmd_status;
struct mbox_default_buffer buffer = {
.header = {
.size = sizeof(buffer)
}
};
printk(BIOS_DEBUG, "PSP: Notify that POST is finishing... ");
cmd_status = send_psp_command(MBOX_BIOS_CMD_BOOT_DONE, &buffer);
/* buffer's status shouldn't change but report it if it does */
print_cmd_status(cmd_status, &buffer);
}
/*
* Tell the PSP to load a firmware blob from a location in the BIOS image.
*/
int psp_load_named_blob(enum psp_blob_type type, const char *name)
{
int cmd_status;
u32 command;
void *blob;
struct cbfsf cbfs_file;
struct region_device rdev;
switch (type) {
case BLOB_SMU_FW:
command = MBOX_BIOS_CMD_SMU_FW;
break;
case BLOB_SMU_FW2:
command = MBOX_BIOS_CMD_SMU_FW2;
break;
default:
printk(BIOS_ERR, "BUG: Invalid PSP blob type %x\n", type);
return -PSPSTS_INVALID_BLOB;
}
/* type can only be BLOB_SMU_FW or BLOB_SMU_FW2 here, so don't re-check for this */
if (!CONFIG(SOC_AMD_PSP_SELECTABLE_SMU_FW)) {
printk(BIOS_ERR, "BUG: Selectable firmware is not supported\n");
return -PSPSTS_UNSUPPORTED;
}
if (cbfs_boot_locate(&cbfs_file, name, NULL)) {
printk(BIOS_ERR, "BUG: Cannot locate blob for PSP loading\n");
return -PSPSTS_INVALID_NAME;
}
cbfs_file_data(&rdev, &cbfs_file);
blob = rdev_mmap_full(&rdev);
if (!blob) {
printk(BIOS_ERR, "BUG: Cannot map blob for PSP loading\n");
return -PSPSTS_INVALID_NAME;
}
printk(BIOS_DEBUG, "PSP: Load blob type %x from @%p... ", type, blob);
/* Blob commands use the buffer registers as data, not pointer to buf */
cmd_status = send_psp_command(command, blob);
print_cmd_status(cmd_status, NULL);
rdev_munmap(&rdev, blob);
return cmd_status;
}
BOOT_STATE_INIT_ENTRY(BS_PAYLOAD_BOOT, BS_ON_ENTRY,
psp_notify_boot_done, NULL);
|
