]>
Commit | Line | Data |
---|---|---|
8f0605cc SB |
1 | /* |
2 | * QEMU TPM Backend | |
3 | * | |
4 | * Copyright IBM, Corp. 2013 | |
5 | * | |
6 | * Authors: | |
7 | * Stefan Berger <stefanb@us.ibm.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
10 | * See the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #ifndef _QEMU_TPM_H | |
14 | #define _QEMU_TPM_H | |
15 | ||
16 | #include "qom/object.h" | |
17 | #include "qemu-common.h" | |
18 | #include "qapi/error.h" | |
19 | #include "qapi-types.h" | |
20 | #include "qemu/option.h" | |
bdee56f5 | 21 | #include "sysemu/tpm.h" |
8f0605cc SB |
22 | |
23 | #define TYPE_TPM_BACKEND "tpm-backend" | |
24 | #define TPM_BACKEND(obj) \ | |
25 | OBJECT_CHECK(TPMBackend, (obj), TYPE_TPM_BACKEND) | |
26 | #define TPM_BACKEND_GET_CLASS(obj) \ | |
27 | OBJECT_GET_CLASS(TPMBackendClass, (obj), TYPE_TPM_BACKEND) | |
28 | #define TPM_BACKEND_CLASS(klass) \ | |
29 | OBJECT_CLASS_CHECK(TPMBackendClass, (klass), TYPE_TPM_BACKEND) | |
30 | ||
31 | typedef struct TPMBackendClass TPMBackendClass; | |
32 | typedef struct TPMBackend TPMBackend; | |
33 | ||
34 | typedef struct TPMDriverOps TPMDriverOps; | |
35 | ||
36 | struct TPMBackendClass { | |
37 | ObjectClass parent_class; | |
38 | ||
39 | const TPMDriverOps *ops; | |
40 | ||
41 | void (*opened)(TPMBackend *s, Error **errp); | |
42 | }; | |
43 | ||
44 | struct TPMBackend { | |
45 | Object parent; | |
46 | ||
47 | /*< protected >*/ | |
48 | bool opened; | |
49 | ||
50 | char *id; | |
51 | enum TpmModel fe_model; | |
52 | char *path; | |
53 | char *cancel_path; | |
54 | const TPMDriverOps *ops; | |
55 | ||
56 | QLIST_ENTRY(TPMBackend) list; | |
57 | }; | |
58 | ||
bdee56f5 PB |
59 | typedef void (TPMRecvDataCB)(TPMState *, uint8_t locty); |
60 | ||
61 | typedef struct TPMSizedBuffer { | |
62 | uint32_t size; | |
63 | uint8_t *buffer; | |
64 | } TPMSizedBuffer; | |
65 | ||
66 | struct TPMDriverOps { | |
67 | enum TpmType type; | |
68 | /* get a descriptive text of the backend to display to the user */ | |
69 | const char *(*desc)(void); | |
70 | ||
71 | TPMBackend *(*create)(QemuOpts *opts, const char *id); | |
72 | void (*destroy)(TPMBackend *t); | |
73 | ||
74 | /* initialize the backend */ | |
75 | int (*init)(TPMBackend *t, TPMState *s, TPMRecvDataCB *datacb); | |
76 | /* start up the TPM on the backend */ | |
77 | int (*startup_tpm)(TPMBackend *t); | |
78 | /* returns true if nothing will ever answer TPM requests */ | |
79 | bool (*had_startup_error)(TPMBackend *t); | |
80 | ||
81 | size_t (*realloc_buffer)(TPMSizedBuffer *sb); | |
82 | ||
83 | void (*deliver_request)(TPMBackend *t); | |
84 | ||
85 | void (*reset)(TPMBackend *t); | |
86 | ||
87 | void (*cancel_cmd)(TPMBackend *t); | |
88 | ||
89 | bool (*get_tpm_established_flag)(TPMBackend *t); | |
90 | }; | |
91 | ||
8f0605cc SB |
92 | |
93 | /** | |
94 | * tpm_backend_get_type: | |
95 | * @s: the backend | |
96 | * | |
97 | * Returns the TpmType of the backend. | |
98 | */ | |
99 | enum TpmType tpm_backend_get_type(TPMBackend *s); | |
100 | ||
101 | /** | |
102 | * tpm_backend_get_desc: | |
103 | * @s: the backend | |
104 | * | |
105 | * Returns a human readable description of the backend. | |
106 | */ | |
107 | const char *tpm_backend_get_desc(TPMBackend *s); | |
108 | ||
109 | /** | |
110 | * tpm_backend_destroy: | |
111 | * @s: the backend to destroy | |
112 | */ | |
113 | void tpm_backend_destroy(TPMBackend *s); | |
114 | ||
115 | /** | |
116 | * tpm_backend_init: | |
117 | * @s: the backend to initialized | |
118 | * @state: TPMState | |
119 | * @datacb: callback for sending data to frontend | |
120 | * | |
121 | * Initialize the backend with the given variables. | |
122 | * | |
123 | * Returns 0 on success. | |
124 | */ | |
125 | int tpm_backend_init(TPMBackend *s, TPMState *state, | |
126 | TPMRecvDataCB *datacb); | |
127 | ||
128 | /** | |
129 | * tpm_backend_startup_tpm: | |
130 | * @s: the backend whose TPM support is to be started | |
131 | * | |
132 | * Returns 0 on success. | |
133 | */ | |
134 | int tpm_backend_startup_tpm(TPMBackend *s); | |
135 | ||
136 | /** | |
137 | * tpm_backend_had_startup_error: | |
138 | * @s: the backend to query for a statup error | |
139 | * | |
140 | * Check whether the backend had an error during startup. Returns | |
141 | * false if no error occurred and the backend can be used, true | |
142 | * otherwise. | |
143 | */ | |
144 | bool tpm_backend_had_startup_error(TPMBackend *s); | |
145 | ||
146 | /** | |
147 | * tpm_backend_realloc_buffer: | |
148 | * @s: the backend | |
149 | * @sb: the TPMSizedBuffer to re-allocated to the size suitable for the | |
150 | * backend. | |
151 | * | |
152 | * This function returns the size of the allocated buffer | |
153 | */ | |
154 | size_t tpm_backend_realloc_buffer(TPMBackend *s, TPMSizedBuffer *sb); | |
155 | ||
156 | /** | |
157 | * tpm_backend_deliver_request: | |
158 | * @s: the backend to send the request to | |
159 | * | |
160 | * Send a request to the backend. The backend will then send the request | |
161 | * to the TPM implementation. | |
162 | */ | |
163 | void tpm_backend_deliver_request(TPMBackend *s); | |
164 | ||
165 | /** | |
166 | * tpm_backend_reset: | |
167 | * @s: the backend to reset | |
168 | * | |
169 | * Reset the backend into a well defined state with all previous errors | |
170 | * reset. | |
171 | */ | |
172 | void tpm_backend_reset(TPMBackend *s); | |
173 | ||
174 | /** | |
175 | * tpm_backend_cancel_cmd: | |
176 | * @s: the backend | |
177 | * | |
178 | * Cancel any ongoing command being processed by the TPM implementation | |
179 | * on behalf of the QEMU guest. | |
180 | */ | |
181 | void tpm_backend_cancel_cmd(TPMBackend *s); | |
182 | ||
183 | /** | |
184 | * tpm_backend_get_tpm_established_flag: | |
185 | * @s: the backend | |
186 | * | |
187 | * Get the TPM establishment flag. This function may be called very | |
188 | * frequently by the frontend since for example in the TIS implementation | |
189 | * this flag is part of a register. | |
190 | */ | |
191 | bool tpm_backend_get_tpm_established_flag(TPMBackend *s); | |
192 | ||
193 | /** | |
194 | * tpm_backend_open: | |
195 | * @s: the backend to open | |
196 | * @errp: a pointer to return the #Error object if an error occurs. | |
197 | * | |
198 | * This function will open the backend if it is not already open. Calling this | |
199 | * function on an already opened backend will not result in an error. | |
200 | */ | |
201 | void tpm_backend_open(TPMBackend *s, Error **errp); | |
202 | ||
bdee56f5 PB |
203 | TPMBackend *qemu_find_tpm(const char *id); |
204 | ||
205 | const TPMDriverOps *tpm_get_backend_driver(const char *type); | |
206 | int tpm_register_model(enum TpmModel model); | |
207 | int tpm_register_driver(const TPMDriverOps *tdo); | |
208 | ||
8f0605cc | 209 | #endif |