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