]> git.sur5r.net Git - u-boot/blob - lib/tpm-common.c
Merge branch 'master' of git://git.denx.de/u-boot-samsung
[u-boot] / lib / tpm-common.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2013 The Chromium OS Authors.
4  * Coypright (c) 2013 Guntermann & Drunck GmbH
5  */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <asm/unaligned.h>
10 #include <tpm-common.h>
11 #include "tpm-utils.h"
12
13 int pack_byte_string(u8 *str, size_t size, const char *format, ...)
14 {
15         va_list args;
16         size_t offset = 0, length = 0;
17         u8 *data = NULL;
18         u32 value = 0;
19
20         va_start(args, format);
21         for (; *format; format++) {
22                 switch (*format) {
23                 case 'b':
24                         offset = va_arg(args, size_t);
25                         value = va_arg(args, int);
26                         length = 1;
27                         break;
28                 case 'w':
29                         offset = va_arg(args, size_t);
30                         value = va_arg(args, int);
31                         length = 2;
32                         break;
33                 case 'd':
34                         offset = va_arg(args, size_t);
35                         value = va_arg(args, u32);
36                         length = 4;
37                         break;
38                 case 's':
39                         offset = va_arg(args, size_t);
40                         data = va_arg(args, u8 *);
41                         length = va_arg(args, u32);
42                         break;
43                 default:
44                         debug("Couldn't recognize format string\n");
45                         va_end(args);
46                         return -1;
47                 }
48
49                 if (offset + length > size) {
50                         va_end(args);
51                         return -1;
52                 }
53
54                 switch (*format) {
55                 case 'b':
56                         str[offset] = value;
57                         break;
58                 case 'w':
59                         put_unaligned_be16(value, str + offset);
60                         break;
61                 case 'd':
62                         put_unaligned_be32(value, str + offset);
63                         break;
64                 case 's':
65                         memcpy(str + offset, data, length);
66                         break;
67                 }
68         }
69         va_end(args);
70
71         return 0;
72 }
73
74 int unpack_byte_string(const u8 *str, size_t size, const char *format, ...)
75 {
76         va_list args;
77         size_t offset = 0, length = 0;
78         u8 *ptr8 = NULL;
79         u16 *ptr16 = NULL;
80         u32 *ptr32 = NULL;
81
82         va_start(args, format);
83         for (; *format; format++) {
84                 switch (*format) {
85                 case 'b':
86                         offset = va_arg(args, size_t);
87                         ptr8 = va_arg(args, u8 *);
88                         length = 1;
89                         break;
90                 case 'w':
91                         offset = va_arg(args, size_t);
92                         ptr16 = va_arg(args, u16 *);
93                         length = 2;
94                         break;
95                 case 'd':
96                         offset = va_arg(args, size_t);
97                         ptr32 = va_arg(args, u32 *);
98                         length = 4;
99                         break;
100                 case 's':
101                         offset = va_arg(args, size_t);
102                         ptr8 = va_arg(args, u8 *);
103                         length = va_arg(args, u32);
104                         break;
105                 default:
106                         va_end(args);
107                         debug("Couldn't recognize format string\n");
108                         return -1;
109                 }
110
111                 if (offset + length > size) {
112                         va_end(args);
113                         return -1;
114                 }
115
116                 switch (*format) {
117                 case 'b':
118                         *ptr8 = str[offset];
119                         break;
120                 case 'w':
121                         *ptr16 = get_unaligned_be16(str + offset);
122                         break;
123                 case 'd':
124                         *ptr32 = get_unaligned_be32(str + offset);
125                         break;
126                 case 's':
127                         memcpy(ptr8, str + offset, length);
128                         break;
129                 }
130         }
131         va_end(args);
132
133         return 0;
134 }
135
136 u32 tpm_command_size(const void *command)
137 {
138         const size_t command_size_offset = 2;
139
140         return get_unaligned_be32(command + command_size_offset);
141 }
142
143 u32 tpm_return_code(const void *response)
144 {
145         const size_t return_code_offset = 6;
146
147         return get_unaligned_be32(response + return_code_offset);
148 }
149
150 u32 tpm_sendrecv_command(const void *command, void *response, size_t *size_ptr)
151 {
152         struct udevice *dev;
153         int err, ret;
154         u8 response_buffer[COMMAND_BUFFER_SIZE];
155         size_t response_length;
156         int i;
157
158         if (response) {
159                 response_length = *size_ptr;
160         } else {
161                 response = response_buffer;
162                 response_length = sizeof(response_buffer);
163         }
164
165         ret = uclass_first_device_err(UCLASS_TPM, &dev);
166         if (ret)
167                 return ret;
168         err = tpm_xfer(dev, command, tpm_command_size(command),
169                        response, &response_length);
170
171         if (err < 0)
172                 return err;
173
174         if (size_ptr)
175                 *size_ptr = response_length;
176
177         ret = tpm_return_code(response);
178
179         log(LOGC_NONE, LOGL_DEBUG, "TPM response [ret:%d]: ", ret);
180         for (i = 0; i < response_length; i++)
181                 log(LOGC_NONE, LOGL_DEBUG, "%02x ", ((u8 *)response)[i]);
182         log(LOGC_NONE, LOGL_DEBUG, "\n");
183
184         return ret;
185 }
186
187 int tpm_init(void)
188 {
189         struct udevice *dev;
190         int err;
191
192         err = uclass_first_device_err(UCLASS_TPM, &dev);
193         if (err)
194                 return err;
195
196         return tpm_open(dev);
197 }