Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 348df8db301d9fa01fb51e5eaca1e9f3b27bd4c8

Authored by Jason Gunthorpe
Committed by Kent Yoder
1 parent c584af1926
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

TPM: Switch to __packed instead of __attribute__((packed)) 

This seems to be preferred these days.

Signed-off-by: Jason Gunthorpe <jgunthorpe@obsidianresearch.com>
Reviewed-by: Peter Huewe <peterhuewe@gmx.de>
Signed-off-by: Kent Yoder <key@linux.vnet.ibm.com>

Showing 2 changed files with 21 additions and 21 deletions Inline Diff

drivers/char/tpm/tpm.h
Diff comments   View file @ 348df8d
1 /* 1 /*
2 * Copyright (C) 2004 IBM Corporation 2 * Copyright (C) 2004 IBM Corporation
3 * 3 *
4 * Authors: 4 * Authors:
5 * Leendert van Doorn <leendert@watson.ibm.com> 5 * Leendert van Doorn <leendert@watson.ibm.com>
6 * Dave Safford <safford@watson.ibm.com> 6 * Dave Safford <safford@watson.ibm.com>
7 * Reiner Sailer <sailer@watson.ibm.com> 7 * Reiner Sailer <sailer@watson.ibm.com>
8 * Kylene Hall <kjhall@us.ibm.com> 8 * Kylene Hall <kjhall@us.ibm.com>
9 * 9 *
10 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 10 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
11 * 11 *
12 * Device driver for TCG/TCPA TPM (trusted platform module). 12 * Device driver for TCG/TCPA TPM (trusted platform module).
13 * Specifications at www.trustedcomputinggroup.org 13 * Specifications at www.trustedcomputinggroup.org
14 * 14 *
15 * This program is free software; you can redistribute it and/or 15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as 16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation, version 2 of the 17 * published by the Free Software Foundation, version 2 of the
18 * License. 18 * License.
19 * 19 *
20 */ 20 */
21 #include <linux/module.h> 21 #include <linux/module.h>
22 #include <linux/delay.h> 22 #include <linux/delay.h>
23 #include <linux/fs.h> 23 #include <linux/fs.h>
24 #include <linux/mutex.h> 24 #include <linux/mutex.h>
25 #include <linux/sched.h> 25 #include <linux/sched.h>
26 #include <linux/miscdevice.h> 26 #include <linux/miscdevice.h>
27 #include <linux/platform_device.h> 27 #include <linux/platform_device.h>
28 #include <linux/io.h> 28 #include <linux/io.h>
29 #include <linux/tpm.h> 29 #include <linux/tpm.h>
30 30
31 enum tpm_const { 31 enum tpm_const {
32 TPM_MINOR = 224, /* officially assigned */ 32 TPM_MINOR = 224, /* officially assigned */
33 TPM_BUFSIZE = 4096, 33 TPM_BUFSIZE = 4096,
34 TPM_NUM_DEVICES = 256, 34 TPM_NUM_DEVICES = 256,
35 }; 35 };
36 36
37 enum tpm_timeout { 37 enum tpm_timeout {
38 TPM_TIMEOUT = 5, /* msecs */ 38 TPM_TIMEOUT = 5, /* msecs */
39 }; 39 };
40 40
41 /* TPM addresses */ 41 /* TPM addresses */
42 enum tpm_addr { 42 enum tpm_addr {
43 TPM_SUPERIO_ADDR = 0x2E, 43 TPM_SUPERIO_ADDR = 0x2E,
44 TPM_ADDR = 0x4E, 44 TPM_ADDR = 0x4E,
45 }; 45 };
46 46
47 #define TPM_WARN_DOING_SELFTEST 0x802 47 #define TPM_WARN_DOING_SELFTEST 0x802
48 #define TPM_ERR_DEACTIVATED 0x6 48 #define TPM_ERR_DEACTIVATED 0x6
49 #define TPM_ERR_DISABLED 0x7 49 #define TPM_ERR_DISABLED 0x7
50 #define TPM_ERR_INVALID_POSTINIT 38 50 #define TPM_ERR_INVALID_POSTINIT 38
51 51
52 #define TPM_HEADER_SIZE 10 52 #define TPM_HEADER_SIZE 10
53 extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr, 53 extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr,
54 char *); 54 char *);
55 extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr, 55 extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr,
56 char *); 56 char *);
57 extern ssize_t tpm_show_caps(struct device *, struct device_attribute *attr, 57 extern ssize_t tpm_show_caps(struct device *, struct device_attribute *attr,
58 char *); 58 char *);
59 extern ssize_t tpm_show_caps_1_2(struct device *, struct device_attribute *attr, 59 extern ssize_t tpm_show_caps_1_2(struct device *, struct device_attribute *attr,
60 char *); 60 char *);
61 extern ssize_t tpm_store_cancel(struct device *, struct device_attribute *attr, 61 extern ssize_t tpm_store_cancel(struct device *, struct device_attribute *attr,
62 const char *, size_t); 62 const char *, size_t);
63 extern ssize_t tpm_show_enabled(struct device *, struct device_attribute *attr, 63 extern ssize_t tpm_show_enabled(struct device *, struct device_attribute *attr,
64 char *); 64 char *);
65 extern ssize_t tpm_show_active(struct device *, struct device_attribute *attr, 65 extern ssize_t tpm_show_active(struct device *, struct device_attribute *attr,
66 char *); 66 char *);
67 extern ssize_t tpm_show_owned(struct device *, struct device_attribute *attr, 67 extern ssize_t tpm_show_owned(struct device *, struct device_attribute *attr,
68 char *); 68 char *);
69 extern ssize_t tpm_show_temp_deactivated(struct device *, 69 extern ssize_t tpm_show_temp_deactivated(struct device *,
70 struct device_attribute *attr, char *); 70 struct device_attribute *attr, char *);
71 extern ssize_t tpm_show_durations(struct device *, 71 extern ssize_t tpm_show_durations(struct device *,
72 struct device_attribute *attr, char *); 72 struct device_attribute *attr, char *);
73 extern ssize_t tpm_show_timeouts(struct device *, 73 extern ssize_t tpm_show_timeouts(struct device *,
74 struct device_attribute *attr, char *); 74 struct device_attribute *attr, char *);
75 75
76 struct tpm_chip; 76 struct tpm_chip;
77 77
78 struct tpm_vendor_specific { 78 struct tpm_vendor_specific {
79 const u8 req_complete_mask; 79 const u8 req_complete_mask;
80 const u8 req_complete_val; 80 const u8 req_complete_val;
81 const u8 req_canceled; 81 const u8 req_canceled;
82 void __iomem *iobase; /* ioremapped address */ 82 void __iomem *iobase; /* ioremapped address */
83 unsigned long base; /* TPM base address */ 83 unsigned long base; /* TPM base address */
84 84
85 int irq; 85 int irq;
86 int probed_irq; 86 int probed_irq;
87 87
88 int region_size; 88 int region_size;
89 int have_region; 89 int have_region;
90 90
91 int (*recv) (struct tpm_chip *, u8 *, size_t); 91 int (*recv) (struct tpm_chip *, u8 *, size_t);
92 int (*send) (struct tpm_chip *, u8 *, size_t); 92 int (*send) (struct tpm_chip *, u8 *, size_t);
93 void (*cancel) (struct tpm_chip *); 93 void (*cancel) (struct tpm_chip *);
94 u8 (*status) (struct tpm_chip *); 94 u8 (*status) (struct tpm_chip *);
95 void (*release) (struct device *); 95 void (*release) (struct device *);
96 struct miscdevice miscdev; 96 struct miscdevice miscdev;
97 struct attribute_group *attr_group; 97 struct attribute_group *attr_group;
98 struct list_head list; 98 struct list_head list;
99 int locality; 99 int locality;
100 unsigned long timeout_a, timeout_b, timeout_c, timeout_d; /* jiffies */ 100 unsigned long timeout_a, timeout_b, timeout_c, timeout_d; /* jiffies */
101 bool timeout_adjusted; 101 bool timeout_adjusted;
102 unsigned long duration[3]; /* jiffies */ 102 unsigned long duration[3]; /* jiffies */
103 bool duration_adjusted; 103 bool duration_adjusted;
104 void *data; 104 void *data;
105 105
106 wait_queue_head_t read_queue; 106 wait_queue_head_t read_queue;
107 wait_queue_head_t int_queue; 107 wait_queue_head_t int_queue;
108 }; 108 };
109 109
110 #define TPM_VID_INTEL 0x8086 110 #define TPM_VID_INTEL 0x8086
111 111
112 struct tpm_chip { 112 struct tpm_chip {
113 struct device *dev; /* Device stuff */ 113 struct device *dev; /* Device stuff */
114 114
115 int dev_num; /* /dev/tpm# */ 115 int dev_num; /* /dev/tpm# */
116 unsigned long is_open; /* only one allowed */ 116 unsigned long is_open; /* only one allowed */
117 int time_expired; 117 int time_expired;
118 118
119 /* Data passed to and from the tpm via the read/write calls */ 119 /* Data passed to and from the tpm via the read/write calls */
120 u8 *data_buffer; 120 u8 *data_buffer;
121 atomic_t data_pending; 121 atomic_t data_pending;
122 struct mutex buffer_mutex; 122 struct mutex buffer_mutex;
123 123
124 struct timer_list user_read_timer; /* user needs to claim result */ 124 struct timer_list user_read_timer; /* user needs to claim result */
125 struct work_struct work; 125 struct work_struct work;
126 struct mutex tpm_mutex; /* tpm is processing */ 126 struct mutex tpm_mutex; /* tpm is processing */
127 127
128 struct tpm_vendor_specific vendor; 128 struct tpm_vendor_specific vendor;
129 129
130 struct dentry **bios_dir; 130 struct dentry **bios_dir;
131 131
132 struct list_head list; 132 struct list_head list;
133 void (*release) (struct device *); 133 void (*release) (struct device *);
134 }; 134 };
135 135
136 #define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor) 136 #define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor)
137 137
138 static inline void tpm_chip_put(struct tpm_chip *chip) 138 static inline void tpm_chip_put(struct tpm_chip *chip)
139 { 139 {
140 module_put(chip->dev->driver->owner); 140 module_put(chip->dev->driver->owner);
141 } 141 }
142 142
143 static inline int tpm_read_index(int base, int index) 143 static inline int tpm_read_index(int base, int index)
144 { 144 {
145 outb(index, base); 145 outb(index, base);
146 return inb(base+1) & 0xFF; 146 return inb(base+1) & 0xFF;
147 } 147 }
148 148
149 static inline void tpm_write_index(int base, int index, int value) 149 static inline void tpm_write_index(int base, int index, int value)
150 { 150 {
151 outb(index, base); 151 outb(index, base);
152 outb(value & 0xFF, base+1); 152 outb(value & 0xFF, base+1);
153 } 153 }
154 struct tpm_input_header { 154 struct tpm_input_header {
155 __be16 tag; 155 __be16 tag;
156 __be32 length; 156 __be32 length;
157 __be32 ordinal; 157 __be32 ordinal;
158 }__attribute__((packed)); 158 } __packed;
159 159
160 struct tpm_output_header { 160 struct tpm_output_header {
161 __be16 tag; 161 __be16 tag;
162 __be32 length; 162 __be32 length;
163 __be32 return_code; 163 __be32 return_code;
164 }__attribute__((packed)); 164 } __packed;
165 165
166 struct stclear_flags_t { 166 struct stclear_flags_t {
167 __be16 tag; 167 __be16 tag;
168 u8 deactivated; 168 u8 deactivated;
169 u8 disableForceClear; 169 u8 disableForceClear;
170 u8 physicalPresence; 170 u8 physicalPresence;
171 u8 physicalPresenceLock; 171 u8 physicalPresenceLock;
172 u8 bGlobalLock; 172 u8 bGlobalLock;
173 }__attribute__((packed)); 173 } __packed;
174 174
175 struct tpm_version_t { 175 struct tpm_version_t {
176 u8 Major; 176 u8 Major;
177 u8 Minor; 177 u8 Minor;
178 u8 revMajor; 178 u8 revMajor;
179 u8 revMinor; 179 u8 revMinor;
180 }__attribute__((packed)); 180 } __packed;
181 181
182 struct tpm_version_1_2_t { 182 struct tpm_version_1_2_t {
183 __be16 tag; 183 __be16 tag;
184 u8 Major; 184 u8 Major;
185 u8 Minor; 185 u8 Minor;
186 u8 revMajor; 186 u8 revMajor;
187 u8 revMinor; 187 u8 revMinor;
188 }__attribute__((packed)); 188 } __packed;
189 189
190 struct timeout_t { 190 struct timeout_t {
191 __be32 a; 191 __be32 a;
192 __be32 b; 192 __be32 b;
193 __be32 c; 193 __be32 c;
194 __be32 d; 194 __be32 d;
195 }__attribute__((packed)); 195 } __packed;
196 196
197 struct duration_t { 197 struct duration_t {
198 __be32 tpm_short; 198 __be32 tpm_short;
199 __be32 tpm_medium; 199 __be32 tpm_medium;
200 __be32 tpm_long; 200 __be32 tpm_long;
201 }__attribute__((packed)); 201 } __packed;
202 202
203 struct permanent_flags_t { 203 struct permanent_flags_t {
204 __be16 tag; 204 __be16 tag;
205 u8 disable; 205 u8 disable;
206 u8 ownership; 206 u8 ownership;
207 u8 deactivated; 207 u8 deactivated;
208 u8 readPubek; 208 u8 readPubek;
209 u8 disableOwnerClear; 209 u8 disableOwnerClear;
210 u8 allowMaintenance; 210 u8 allowMaintenance;
211 u8 physicalPresenceLifetimeLock; 211 u8 physicalPresenceLifetimeLock;
212 u8 physicalPresenceHWEnable; 212 u8 physicalPresenceHWEnable;
213 u8 physicalPresenceCMDEnable; 213 u8 physicalPresenceCMDEnable;
214 u8 CEKPUsed; 214 u8 CEKPUsed;
215 u8 TPMpost; 215 u8 TPMpost;
216 u8 TPMpostLock; 216 u8 TPMpostLock;
217 u8 FIPS; 217 u8 FIPS;
218 u8 operator; 218 u8 operator;
219 u8 enableRevokeEK; 219 u8 enableRevokeEK;
220 u8 nvLocked; 220 u8 nvLocked;
221 u8 readSRKPub; 221 u8 readSRKPub;
222 u8 tpmEstablished; 222 u8 tpmEstablished;
223 u8 maintenanceDone; 223 u8 maintenanceDone;
224 u8 disableFullDALogicInfo; 224 u8 disableFullDALogicInfo;
225 }__attribute__((packed)); 225 } __packed;
226 226
227 typedef union { 227 typedef union {
228 struct permanent_flags_t perm_flags; 228 struct permanent_flags_t perm_flags;
229 struct stclear_flags_t stclear_flags; 229 struct stclear_flags_t stclear_flags;
230 bool owned; 230 bool owned;
231 __be32 num_pcrs; 231 __be32 num_pcrs;
232 struct tpm_version_t tpm_version; 232 struct tpm_version_t tpm_version;
233 struct tpm_version_1_2_t tpm_version_1_2; 233 struct tpm_version_1_2_t tpm_version_1_2;
234 __be32 manufacturer_id; 234 __be32 manufacturer_id;
235 struct timeout_t timeout; 235 struct timeout_t timeout;
236 struct duration_t duration; 236 struct duration_t duration;
237 } cap_t; 237 } cap_t;
238 238
239 struct tpm_getcap_params_in { 239 struct tpm_getcap_params_in {
240 __be32 cap; 240 __be32 cap;
241 __be32 subcap_size; 241 __be32 subcap_size;
242 __be32 subcap; 242 __be32 subcap;
243 }__attribute__((packed)); 243 } __packed;
244 244
245 struct tpm_getcap_params_out { 245 struct tpm_getcap_params_out {
246 __be32 cap_size; 246 __be32 cap_size;
247 cap_t cap; 247 cap_t cap;
248 }__attribute__((packed)); 248 } __packed;
249 249
250 struct tpm_readpubek_params_out { 250 struct tpm_readpubek_params_out {
251 u8 algorithm[4]; 251 u8 algorithm[4];
252 u8 encscheme[2]; 252 u8 encscheme[2];
253 u8 sigscheme[2]; 253 u8 sigscheme[2];
254 __be32 paramsize; 254 __be32 paramsize;
255 u8 parameters[12]; /*assuming RSA*/ 255 u8 parameters[12]; /*assuming RSA*/
256 __be32 keysize; 256 __be32 keysize;
257 u8 modulus[256]; 257 u8 modulus[256];
258 u8 checksum[20]; 258 u8 checksum[20];
259 }__attribute__((packed)); 259 } __packed;
260 260
261 typedef union { 261 typedef union {
262 struct tpm_input_header in; 262 struct tpm_input_header in;
263 struct tpm_output_header out; 263 struct tpm_output_header out;
264 } tpm_cmd_header; 264 } tpm_cmd_header;
265 265
266 #define TPM_DIGEST_SIZE 20 266 #define TPM_DIGEST_SIZE 20
267 struct tpm_pcrread_out { 267 struct tpm_pcrread_out {
268 u8 pcr_result[TPM_DIGEST_SIZE]; 268 u8 pcr_result[TPM_DIGEST_SIZE];
269 }__attribute__((packed)); 269 } __packed;
270 270
271 struct tpm_pcrread_in { 271 struct tpm_pcrread_in {
272 __be32 pcr_idx; 272 __be32 pcr_idx;
273 }__attribute__((packed)); 273 } __packed;
274 274
275 struct tpm_pcrextend_in { 275 struct tpm_pcrextend_in {
276 __be32 pcr_idx; 276 __be32 pcr_idx;
277 u8 hash[TPM_DIGEST_SIZE]; 277 u8 hash[TPM_DIGEST_SIZE];
278 }__attribute__((packed)); 278 } __packed;
279 279
280 /* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18 280 /* 128 bytes is an arbitrary cap. This could be as large as TPM_BUFSIZE - 18
281 * bytes, but 128 is still a relatively large number of random bytes and 281 * bytes, but 128 is still a relatively large number of random bytes and
282 * anything much bigger causes users of struct tpm_cmd_t to start getting 282 * anything much bigger causes users of struct tpm_cmd_t to start getting
283 * compiler warnings about stack frame size. */ 283 * compiler warnings about stack frame size. */
284 #define TPM_MAX_RNG_DATA 128 284 #define TPM_MAX_RNG_DATA 128
285 285
286 struct tpm_getrandom_out { 286 struct tpm_getrandom_out {
287 __be32 rng_data_len; 287 __be32 rng_data_len;
288 u8 rng_data[TPM_MAX_RNG_DATA]; 288 u8 rng_data[TPM_MAX_RNG_DATA];
289 }__attribute__((packed)); 289 } __packed;
290 290
291 struct tpm_getrandom_in { 291 struct tpm_getrandom_in {
292 __be32 num_bytes; 292 __be32 num_bytes;
293 }__attribute__((packed)); 293 } __packed;
294 294
295 struct tpm_startup_in { 295 struct tpm_startup_in {
296 __be16 startup_type; 296 __be16 startup_type;
297 } __packed; 297 } __packed;
298 298
299 typedef union { 299 typedef union {
300 struct tpm_getcap_params_out getcap_out; 300 struct tpm_getcap_params_out getcap_out;
301 struct tpm_readpubek_params_out readpubek_out; 301 struct tpm_readpubek_params_out readpubek_out;
302 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; 302 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)];
303 struct tpm_getcap_params_in getcap_in; 303 struct tpm_getcap_params_in getcap_in;
304 struct tpm_pcrread_in pcrread_in; 304 struct tpm_pcrread_in pcrread_in;
305 struct tpm_pcrread_out pcrread_out; 305 struct tpm_pcrread_out pcrread_out;
306 struct tpm_pcrextend_in pcrextend_in; 306 struct tpm_pcrextend_in pcrextend_in;
307 struct tpm_getrandom_in getrandom_in; 307 struct tpm_getrandom_in getrandom_in;
308 struct tpm_getrandom_out getrandom_out; 308 struct tpm_getrandom_out getrandom_out;
309 struct tpm_startup_in startup_in; 309 struct tpm_startup_in startup_in;
310 } tpm_cmd_params; 310 } tpm_cmd_params;
311 311
312 struct tpm_cmd_t { 312 struct tpm_cmd_t {
313 tpm_cmd_header header; 313 tpm_cmd_header header;
314 tpm_cmd_params params; 314 tpm_cmd_params params;
315 }__attribute__((packed)); 315 } __packed;
316 316
317 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *); 317 ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *);
318 318
319 extern int tpm_get_timeouts(struct tpm_chip *); 319 extern int tpm_get_timeouts(struct tpm_chip *);
320 extern void tpm_gen_interrupt(struct tpm_chip *); 320 extern void tpm_gen_interrupt(struct tpm_chip *);
321 extern int tpm_do_selftest(struct tpm_chip *); 321 extern int tpm_do_selftest(struct tpm_chip *);
322 extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32); 322 extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32);
323 extern struct tpm_chip* tpm_register_hardware(struct device *, 323 extern struct tpm_chip* tpm_register_hardware(struct device *,
324 const struct tpm_vendor_specific *); 324 const struct tpm_vendor_specific *);
325 extern int tpm_open(struct inode *, struct file *); 325 extern int tpm_open(struct inode *, struct file *);
326 extern int tpm_release(struct inode *, struct file *); 326 extern int tpm_release(struct inode *, struct file *);
327 extern void tpm_dev_vendor_release(struct tpm_chip *); 327 extern void tpm_dev_vendor_release(struct tpm_chip *);
328 extern ssize_t tpm_write(struct file *, const char __user *, size_t, 328 extern ssize_t tpm_write(struct file *, const char __user *, size_t,
329 loff_t *); 329 loff_t *);
330 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *); 330 extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
331 extern void tpm_remove_hardware(struct device *); 331 extern void tpm_remove_hardware(struct device *);
332 extern int tpm_pm_suspend(struct device *); 332 extern int tpm_pm_suspend(struct device *);
333 extern int tpm_pm_resume(struct device *); 333 extern int tpm_pm_resume(struct device *);
334 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long, 334 extern int wait_for_tpm_stat(struct tpm_chip *, u8, unsigned long,
335 wait_queue_head_t *); 335 wait_queue_head_t *);
336 336
337 #ifdef CONFIG_ACPI 337 #ifdef CONFIG_ACPI
338 extern int tpm_add_ppi(struct kobject *); 338 extern int tpm_add_ppi(struct kobject *);
339 extern void tpm_remove_ppi(struct kobject *); 339 extern void tpm_remove_ppi(struct kobject *);
340 #else 340 #else
341 static inline int tpm_add_ppi(struct kobject *parent) 341 static inline int tpm_add_ppi(struct kobject *parent)
342 { 342 {
343 return 0; 343 return 0;
344 } 344 }
345 345
346 static inline void tpm_remove_ppi(struct kobject *parent) 346 static inline void tpm_remove_ppi(struct kobject *parent)
347 { 347 {
348 } 348 }
349 #endif 349 #endif
350 350
drivers/char/tpm/tpm_acpi.c
Diff comments   View file @ 348df8d
1 /* 1 /*
2 * Copyright (C) 2005 IBM Corporation 2 * Copyright (C) 2005 IBM Corporation
3 * 3 *
4 * Authors: 4 * Authors:
5 * Seiji Munetoh <munetoh@jp.ibm.com> 5 * Seiji Munetoh <munetoh@jp.ibm.com>
6 * Stefan Berger <stefanb@us.ibm.com> 6 * Stefan Berger <stefanb@us.ibm.com>
7 * Reiner Sailer <sailer@watson.ibm.com> 7 * Reiner Sailer <sailer@watson.ibm.com>
8 * Kylene Hall <kjhall@us.ibm.com> 8 * Kylene Hall <kjhall@us.ibm.com>
9 * 9 *
10 * Maintained by: <tpmdd-devel@lists.sourceforge.net> 10 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
11 * 11 *
12 * Access to the eventlog extended by the TCG BIOS of PC platform 12 * Access to the eventlog extended by the TCG BIOS of PC platform
13 * 13 *
14 * This program is free software; you can redistribute it and/or 14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License 15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version. 17 * 2 of the License, or (at your option) any later version.
18 * 18 *
19 */ 19 */
20 20
21 #include <linux/seq_file.h> 21 #include <linux/seq_file.h>
22 #include <linux/fs.h> 22 #include <linux/fs.h>
23 #include <linux/security.h> 23 #include <linux/security.h>
24 #include <linux/module.h> 24 #include <linux/module.h>
25 #include <linux/slab.h> 25 #include <linux/slab.h>
26 #include <acpi/acpi.h> 26 #include <acpi/acpi.h>
27 27
28 #include "tpm.h" 28 #include "tpm.h"
29 #include "tpm_eventlog.h" 29 #include "tpm_eventlog.h"
30 30
31 struct acpi_tcpa { 31 struct acpi_tcpa {
32 struct acpi_table_header hdr; 32 struct acpi_table_header hdr;
33 u16 platform_class; 33 u16 platform_class;
34 union { 34 union {
35 struct client_hdr { 35 struct client_hdr {
36 u32 log_max_len __attribute__ ((packed)); 36 u32 log_max_len __packed;
37 u64 log_start_addr __attribute__ ((packed)); 37 u64 log_start_addr __packed;
38 } client; 38 } client;
39 struct server_hdr { 39 struct server_hdr {
40 u16 reserved; 40 u16 reserved;
41 u64 log_max_len __attribute__ ((packed)); 41 u64 log_max_len __packed;
42 u64 log_start_addr __attribute__ ((packed)); 42 u64 log_start_addr __packed;
43 } server; 43 } server;
44 }; 44 };
45 }; 45 };
46 46
47 /* read binary bios log */ 47 /* read binary bios log */
48 int read_log(struct tpm_bios_log *log) 48 int read_log(struct tpm_bios_log *log)
49 { 49 {
50 struct acpi_tcpa *buff; 50 struct acpi_tcpa *buff;
51 acpi_status status; 51 acpi_status status;
52 void __iomem *virt; 52 void __iomem *virt;
53 u64 len, start; 53 u64 len, start;
54 54
55 if (log->bios_event_log != NULL) { 55 if (log->bios_event_log != NULL) {
56 printk(KERN_ERR 56 printk(KERN_ERR
57 "%s: ERROR - Eventlog already initialized\n", 57 "%s: ERROR - Eventlog already initialized\n",
58 __func__); 58 __func__);
59 return -EFAULT; 59 return -EFAULT;
60 } 60 }
61 61
62 /* Find TCPA entry in RSDT (ACPI_LOGICAL_ADDRESSING) */ 62 /* Find TCPA entry in RSDT (ACPI_LOGICAL_ADDRESSING) */
63 status = acpi_get_table(ACPI_SIG_TCPA, 1, 63 status = acpi_get_table(ACPI_SIG_TCPA, 1,
64 (struct acpi_table_header **)&buff); 64 (struct acpi_table_header **)&buff);
65 65
66 if (ACPI_FAILURE(status)) { 66 if (ACPI_FAILURE(status)) {
67 printk(KERN_ERR "%s: ERROR - Could not get TCPA table\n", 67 printk(KERN_ERR "%s: ERROR - Could not get TCPA table\n",
68 __func__); 68 __func__);
69 return -EIO; 69 return -EIO;
70 } 70 }
71 71
72 switch(buff->platform_class) { 72 switch(buff->platform_class) {
73 case BIOS_SERVER: 73 case BIOS_SERVER:
74 len = buff->server.log_max_len; 74 len = buff->server.log_max_len;
75 start = buff->server.log_start_addr; 75 start = buff->server.log_start_addr;
76 break; 76 break;
77 case BIOS_CLIENT: 77 case BIOS_CLIENT:
78 default: 78 default:
79 len = buff->client.log_max_len; 79 len = buff->client.log_max_len;
80 start = buff->client.log_start_addr; 80 start = buff->client.log_start_addr;
81 break; 81 break;
82 } 82 }
83 if (!len) { 83 if (!len) {
84 printk(KERN_ERR "%s: ERROR - TCPA log area empty\n", __func__); 84 printk(KERN_ERR "%s: ERROR - TCPA log area empty\n", __func__);
85 return -EIO; 85 return -EIO;
86 } 86 }
87 87
88 /* malloc EventLog space */ 88 /* malloc EventLog space */
89 log->bios_event_log = kmalloc(len, GFP_KERNEL); 89 log->bios_event_log = kmalloc(len, GFP_KERNEL);
90 if (!log->bios_event_log) { 90 if (!log->bios_event_log) {
91 printk("%s: ERROR - Not enough Memory for BIOS measurements\n", 91 printk("%s: ERROR - Not enough Memory for BIOS measurements\n",
92 __func__); 92 __func__);
93 return -ENOMEM; 93 return -ENOMEM;
94 } 94 }
95 95
96 log->bios_event_log_end = log->bios_event_log + len; 96 log->bios_event_log_end = log->bios_event_log + len;
97 97
98 virt = acpi_os_map_memory(start, len); 98 virt = acpi_os_map_memory(start, len);
99 if (!virt) { 99 if (!virt) {
100 kfree(log->bios_event_log); 100 kfree(log->bios_event_log);
101 printk("%s: ERROR - Unable to map memory\n", __func__); 101 printk("%s: ERROR - Unable to map memory\n", __func__);
102 return -EIO; 102 return -EIO;
103 } 103 }
104 104
105 memcpy_fromio(log->bios_event_log, virt, len); 105 memcpy_fromio(log->bios_event_log, virt, len);
106 106
107 acpi_os_unmap_memory(virt, len); 107 acpi_os_unmap_memory(virt, len);
108 return 0; 108 return 0;
109 } 109 }
110 110