Commit | Line | Data |
---|---|---|
000a07b0 JG |
1 | /* |
2 | * Copyright (C) 2004 IBM Corporation | |
3 | * Authors: | |
4 | * Leendert van Doorn <leendert@watson.ibm.com> | |
5 | * Dave Safford <safford@watson.ibm.com> | |
6 | * Reiner Sailer <sailer@watson.ibm.com> | |
7 | * Kylene Hall <kjhall@us.ibm.com> | |
8 | * | |
1e3b73a9 JG |
9 | * Copyright (C) 2013 Obsidian Research Corp |
10 | * Jason Gunthorpe <jgunthorpe@obsidianresearch.com> | |
11 | * | |
000a07b0 JG |
12 | * sysfs filesystem inspection interface to the TPM |
13 | * | |
14 | * This program is free software; you can redistribute it and/or | |
15 | * modify it under the terms of the GNU General Public License as | |
16 | * published by the Free Software Foundation, version 2 of the | |
17 | * License. | |
18 | * | |
19 | */ | |
20 | #include <linux/device.h> | |
21 | #include "tpm.h" | |
22 | ||
000a07b0 JG |
23 | #define READ_PUBEK_RESULT_SIZE 314 |
24 | #define TPM_ORD_READPUBEK cpu_to_be32(124) | |
25 | static struct tpm_input_header tpm_readpubek_header = { | |
26 | .tag = TPM_TAG_RQU_COMMAND, | |
27 | .length = cpu_to_be32(30), | |
28 | .ordinal = TPM_ORD_READPUBEK | |
29 | }; | |
1e3b73a9 JG |
30 | static ssize_t pubek_show(struct device *dev, struct device_attribute *attr, |
31 | char *buf) | |
000a07b0 JG |
32 | { |
33 | u8 *data; | |
34 | struct tpm_cmd_t tpm_cmd; | |
35 | ssize_t err; | |
36 | int i, rc; | |
37 | char *str = buf; | |
38 | ||
39 | struct tpm_chip *chip = dev_get_drvdata(dev); | |
40 | ||
41 | tpm_cmd.header.in = tpm_readpubek_header; | |
87155b73 JS |
42 | err = tpm_transmit_cmd(chip, &tpm_cmd, READ_PUBEK_RESULT_SIZE, |
43 | "attempting to read the PUBEK"); | |
000a07b0 JG |
44 | if (err) |
45 | goto out; | |
46 | ||
47 | /* | |
48 | ignore header 10 bytes | |
49 | algorithm 32 bits (1 == RSA ) | |
50 | encscheme 16 bits | |
51 | sigscheme 16 bits | |
52 | parameters (RSA 12->bytes: keybit, #primes, expbit) | |
53 | keylenbytes 32 bits | |
54 | 256 byte modulus | |
55 | ignore checksum 20 bytes | |
56 | */ | |
57 | data = tpm_cmd.params.readpubek_out_buffer; | |
58 | str += | |
59 | sprintf(str, | |
60 | "Algorithm: %02X %02X %02X %02X\n" | |
61 | "Encscheme: %02X %02X\n" | |
62 | "Sigscheme: %02X %02X\n" | |
63 | "Parameters: %02X %02X %02X %02X " | |
64 | "%02X %02X %02X %02X " | |
65 | "%02X %02X %02X %02X\n" | |
66 | "Modulus length: %d\n" | |
67 | "Modulus:\n", | |
68 | data[0], data[1], data[2], data[3], | |
69 | data[4], data[5], | |
70 | data[6], data[7], | |
71 | data[12], data[13], data[14], data[15], | |
72 | data[16], data[17], data[18], data[19], | |
73 | data[20], data[21], data[22], data[23], | |
74 | be32_to_cpu(*((__be32 *) (data + 24)))); | |
75 | ||
76 | for (i = 0; i < 256; i++) { | |
77 | str += sprintf(str, "%02X ", data[i + 28]); | |
78 | if ((i + 1) % 16 == 0) | |
79 | str += sprintf(str, "\n"); | |
80 | } | |
81 | out: | |
82 | rc = str - buf; | |
83 | return rc; | |
84 | } | |
1e3b73a9 | 85 | static DEVICE_ATTR_RO(pubek); |
000a07b0 | 86 | |
1e3b73a9 JG |
87 | static ssize_t pcrs_show(struct device *dev, struct device_attribute *attr, |
88 | char *buf) | |
000a07b0 JG |
89 | { |
90 | cap_t cap; | |
91 | u8 digest[TPM_DIGEST_SIZE]; | |
92 | ssize_t rc; | |
93 | int i, j, num_pcrs; | |
94 | char *str = buf; | |
95 | struct tpm_chip *chip = dev_get_drvdata(dev); | |
96 | ||
97 | rc = tpm_getcap(dev, TPM_CAP_PROP_PCR, &cap, | |
98 | "attempting to determine the number of PCRS"); | |
99 | if (rc) | |
100 | return 0; | |
101 | ||
102 | num_pcrs = be32_to_cpu(cap.num_pcrs); | |
103 | for (i = 0; i < num_pcrs; i++) { | |
104 | rc = tpm_pcr_read_dev(chip, i, digest); | |
105 | if (rc) | |
106 | break; | |
107 | str += sprintf(str, "PCR-%02d: ", i); | |
108 | for (j = 0; j < TPM_DIGEST_SIZE; j++) | |
109 | str += sprintf(str, "%02X ", digest[j]); | |
110 | str += sprintf(str, "\n"); | |
111 | } | |
112 | return str - buf; | |
113 | } | |
1e3b73a9 | 114 | static DEVICE_ATTR_RO(pcrs); |
000a07b0 | 115 | |
1e3b73a9 JG |
116 | static ssize_t enabled_show(struct device *dev, struct device_attribute *attr, |
117 | char *buf) | |
000a07b0 JG |
118 | { |
119 | cap_t cap; | |
120 | ssize_t rc; | |
121 | ||
122 | rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap, | |
123 | "attempting to determine the permanent enabled state"); | |
124 | if (rc) | |
125 | return 0; | |
126 | ||
127 | rc = sprintf(buf, "%d\n", !cap.perm_flags.disable); | |
128 | return rc; | |
129 | } | |
1e3b73a9 | 130 | static DEVICE_ATTR_RO(enabled); |
000a07b0 | 131 | |
5f64822d | 132 | static ssize_t active_show(struct device *dev, struct device_attribute *attr, |
1e3b73a9 | 133 | char *buf) |
000a07b0 JG |
134 | { |
135 | cap_t cap; | |
136 | ssize_t rc; | |
137 | ||
138 | rc = tpm_getcap(dev, TPM_CAP_FLAG_PERM, &cap, | |
139 | "attempting to determine the permanent active state"); | |
140 | if (rc) | |
141 | return 0; | |
142 | ||
143 | rc = sprintf(buf, "%d\n", !cap.perm_flags.deactivated); | |
144 | return rc; | |
145 | } | |
1e3b73a9 | 146 | static DEVICE_ATTR_RO(active); |
000a07b0 | 147 | |
1e3b73a9 JG |
148 | static ssize_t owned_show(struct device *dev, struct device_attribute *attr, |
149 | char *buf) | |
000a07b0 JG |
150 | { |
151 | cap_t cap; | |
152 | ssize_t rc; | |
153 | ||
154 | rc = tpm_getcap(dev, TPM_CAP_PROP_OWNER, &cap, | |
155 | "attempting to determine the owner state"); | |
156 | if (rc) | |
157 | return 0; | |
158 | ||
159 | rc = sprintf(buf, "%d\n", cap.owned); | |
160 | return rc; | |
161 | } | |
1e3b73a9 | 162 | static DEVICE_ATTR_RO(owned); |
000a07b0 | 163 | |
1e3b73a9 JG |
164 | static ssize_t temp_deactivated_show(struct device *dev, |
165 | struct device_attribute *attr, char *buf) | |
000a07b0 JG |
166 | { |
167 | cap_t cap; | |
168 | ssize_t rc; | |
169 | ||
170 | rc = tpm_getcap(dev, TPM_CAP_FLAG_VOL, &cap, | |
171 | "attempting to determine the temporary state"); | |
172 | if (rc) | |
173 | return 0; | |
174 | ||
175 | rc = sprintf(buf, "%d\n", cap.stclear_flags.deactivated); | |
176 | return rc; | |
177 | } | |
1e3b73a9 | 178 | static DEVICE_ATTR_RO(temp_deactivated); |
000a07b0 | 179 | |
1e3b73a9 JG |
180 | static ssize_t caps_show(struct device *dev, struct device_attribute *attr, |
181 | char *buf) | |
000a07b0 JG |
182 | { |
183 | cap_t cap; | |
184 | ssize_t rc; | |
185 | char *str = buf; | |
186 | ||
187 | rc = tpm_getcap(dev, TPM_CAP_PROP_MANUFACTURER, &cap, | |
188 | "attempting to determine the manufacturer"); | |
189 | if (rc) | |
190 | return 0; | |
191 | str += sprintf(str, "Manufacturer: 0x%x\n", | |
192 | be32_to_cpu(cap.manufacturer_id)); | |
193 | ||
194 | /* Try to get a TPM version 1.2 TPM_CAP_VERSION_INFO */ | |
195 | rc = tpm_getcap(dev, CAP_VERSION_1_2, &cap, | |
196 | "attempting to determine the 1.2 version"); | |
197 | if (!rc) { | |
198 | str += sprintf(str, | |
199 | "TCG version: %d.%d\nFirmware version: %d.%d\n", | |
200 | cap.tpm_version_1_2.Major, | |
201 | cap.tpm_version_1_2.Minor, | |
202 | cap.tpm_version_1_2.revMajor, | |
203 | cap.tpm_version_1_2.revMinor); | |
204 | } else { | |
205 | /* Otherwise just use TPM_STRUCT_VER */ | |
206 | rc = tpm_getcap(dev, CAP_VERSION_1_1, &cap, | |
207 | "attempting to determine the 1.1 version"); | |
208 | if (rc) | |
209 | return 0; | |
210 | str += sprintf(str, | |
211 | "TCG version: %d.%d\nFirmware version: %d.%d\n", | |
212 | cap.tpm_version.Major, | |
213 | cap.tpm_version.Minor, | |
214 | cap.tpm_version.revMajor, | |
215 | cap.tpm_version.revMinor); | |
216 | } | |
217 | ||
218 | return str - buf; | |
219 | } | |
1e3b73a9 | 220 | static DEVICE_ATTR_RO(caps); |
000a07b0 | 221 | |
1e3b73a9 JG |
222 | static ssize_t cancel_store(struct device *dev, struct device_attribute *attr, |
223 | const char *buf, size_t count) | |
000a07b0 JG |
224 | { |
225 | struct tpm_chip *chip = dev_get_drvdata(dev); | |
226 | if (chip == NULL) | |
227 | return 0; | |
228 | ||
5f82e9f0 | 229 | chip->ops->cancel(chip); |
000a07b0 JG |
230 | return count; |
231 | } | |
1e3b73a9 | 232 | static DEVICE_ATTR_WO(cancel); |
000a07b0 | 233 | |
1e3b73a9 JG |
234 | static ssize_t durations_show(struct device *dev, struct device_attribute *attr, |
235 | char *buf) | |
000a07b0 JG |
236 | { |
237 | struct tpm_chip *chip = dev_get_drvdata(dev); | |
238 | ||
239 | if (chip->vendor.duration[TPM_LONG] == 0) | |
240 | return 0; | |
241 | ||
242 | return sprintf(buf, "%d %d %d [%s]\n", | |
243 | jiffies_to_usecs(chip->vendor.duration[TPM_SHORT]), | |
244 | jiffies_to_usecs(chip->vendor.duration[TPM_MEDIUM]), | |
245 | jiffies_to_usecs(chip->vendor.duration[TPM_LONG]), | |
246 | chip->vendor.duration_adjusted | |
247 | ? "adjusted" : "original"); | |
248 | } | |
1e3b73a9 | 249 | static DEVICE_ATTR_RO(durations); |
000a07b0 | 250 | |
1e3b73a9 JG |
251 | static ssize_t timeouts_show(struct device *dev, struct device_attribute *attr, |
252 | char *buf) | |
000a07b0 JG |
253 | { |
254 | struct tpm_chip *chip = dev_get_drvdata(dev); | |
255 | ||
256 | return sprintf(buf, "%d %d %d %d [%s]\n", | |
257 | jiffies_to_usecs(chip->vendor.timeout_a), | |
258 | jiffies_to_usecs(chip->vendor.timeout_b), | |
259 | jiffies_to_usecs(chip->vendor.timeout_c), | |
260 | jiffies_to_usecs(chip->vendor.timeout_d), | |
261 | chip->vendor.timeout_adjusted | |
262 | ? "adjusted" : "original"); | |
263 | } | |
1e3b73a9 JG |
264 | static DEVICE_ATTR_RO(timeouts); |
265 | ||
266 | static struct attribute *tpm_dev_attrs[] = { | |
267 | &dev_attr_pubek.attr, | |
268 | &dev_attr_pcrs.attr, | |
269 | &dev_attr_enabled.attr, | |
270 | &dev_attr_active.attr, | |
271 | &dev_attr_owned.attr, | |
272 | &dev_attr_temp_deactivated.attr, | |
273 | &dev_attr_caps.attr, | |
274 | &dev_attr_cancel.attr, | |
275 | &dev_attr_durations.attr, | |
276 | &dev_attr_timeouts.attr, | |
277 | NULL, | |
278 | }; | |
279 | ||
280 | static const struct attribute_group tpm_dev_group = { | |
281 | .attrs = tpm_dev_attrs, | |
282 | }; | |
283 | ||
284 | int tpm_sysfs_add_device(struct tpm_chip *chip) | |
285 | { | |
286 | int err; | |
71ed848f | 287 | err = sysfs_create_group(&chip->pdev->kobj, |
1e3b73a9 JG |
288 | &tpm_dev_group); |
289 | ||
290 | if (err) | |
71ed848f | 291 | dev_err(chip->pdev, |
1e3b73a9 JG |
292 | "failed to create sysfs attributes, %d\n", err); |
293 | return err; | |
294 | } | |
295 | ||
296 | void tpm_sysfs_del_device(struct tpm_chip *chip) | |
297 | { | |
71ed848f | 298 | sysfs_remove_group(&chip->pdev->kobj, &tpm_dev_group); |
1e3b73a9 | 299 | } |