1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
31enum tpm_timeout {
32 TPM_TIMEOUT = 5,
33};
34
35
36enum tpm_addr {
37 TPM_SUPERIO_ADDR = 0x2E,
38 TPM_ADDR = 0x4E,
39};
40
41extern ssize_t tpm_show_pubek(struct device *, struct device_attribute *attr,
42 char *);
43extern ssize_t tpm_show_pcrs(struct device *, struct device_attribute *attr,
44 char *);
45extern ssize_t tpm_show_caps(struct device *, struct device_attribute *attr,
46 char *);
47extern ssize_t tpm_show_caps_1_2(struct device *, struct device_attribute *attr,
48 char *);
49extern ssize_t tpm_store_cancel(struct device *, struct device_attribute *attr,
50 const char *, size_t);
51extern ssize_t tpm_show_enabled(struct device *, struct device_attribute *attr,
52 char *);
53extern ssize_t tpm_show_active(struct device *, struct device_attribute *attr,
54 char *);
55extern ssize_t tpm_show_owned(struct device *, struct device_attribute *attr,
56 char *);
57extern ssize_t tpm_show_temp_deactivated(struct device *,
58 struct device_attribute *attr, char *);
59
60struct tpm_chip;
61
62struct tpm_vendor_specific {
63 const u8 req_complete_mask;
64 const u8 req_complete_val;
65 const u8 req_canceled;
66 void __iomem *iobase;
67 unsigned long base;
68
69 int irq;
70
71 int region_size;
72 int have_region;
73
74 int (*recv) (struct tpm_chip *, u8 *, size_t);
75 int (*send) (struct tpm_chip *, u8 *, size_t);
76 void (*cancel) (struct tpm_chip *);
77 u8 (*status) (struct tpm_chip *);
78 void (*release) (struct device *);
79 struct miscdevice miscdev;
80 struct attribute_group *attr_group;
81 struct list_head list;
82 int locality;
83 unsigned long timeout_a, timeout_b, timeout_c, timeout_d;
84 unsigned long duration[3];
85
86 wait_queue_head_t read_queue;
87 wait_queue_head_t int_queue;
88};
89
90struct tpm_chip {
91 struct device *dev;
92
93 int dev_num;
94 unsigned long is_open;
95 int time_expired;
96
97
98 u8 *data_buffer;
99 atomic_t data_pending;
100 struct mutex buffer_mutex;
101
102 struct timer_list user_read_timer;
103 struct work_struct work;
104 struct mutex tpm_mutex;
105
106 struct tpm_vendor_specific vendor;
107
108 struct dentry **bios_dir;
109
110 struct list_head list;
111 void (*release) (struct device *);
112};
113
114#define to_tpm_chip(n) container_of(n, struct tpm_chip, vendor)
115
116static inline int tpm_read_index(int base, int index)
117{
118 outb(index, base);
119 return inb(base+1) & 0xFF;
120}
121
122static inline void tpm_write_index(int base, int index, int value)
123{
124 outb(index, base);
125 outb(value & 0xFF, base+1);
126}
127struct tpm_input_header {
128 __be16 tag;
129 __be32 length;
130 __be32 ordinal;
131}__attribute__((packed));
132
133struct tpm_output_header {
134 __be16 tag;
135 __be32 length;
136 __be32 return_code;
137}__attribute__((packed));
138
139struct stclear_flags_t {
140 __be16 tag;
141 u8 deactivated;
142 u8 disableForceClear;
143 u8 physicalPresence;
144 u8 physicalPresenceLock;
145 u8 bGlobalLock;
146}__attribute__((packed));
147
148struct tpm_version_t {
149 u8 Major;
150 u8 Minor;
151 u8 revMajor;
152 u8 revMinor;
153}__attribute__((packed));
154
155struct tpm_version_1_2_t {
156 __be16 tag;
157 u8 Major;
158 u8 Minor;
159 u8 revMajor;
160 u8 revMinor;
161}__attribute__((packed));
162
163struct timeout_t {
164 __be32 a;
165 __be32 b;
166 __be32 c;
167 __be32 d;
168}__attribute__((packed));
169
170struct duration_t {
171 __be32 tpm_short;
172 __be32 tpm_medium;
173 __be32 tpm_long;
174}__attribute__((packed));
175
176struct permanent_flags_t {
177 __be16 tag;
178 u8 disable;
179 u8 ownership;
180 u8 deactivated;
181 u8 readPubek;
182 u8 disableOwnerClear;
183 u8 allowMaintenance;
184 u8 physicalPresenceLifetimeLock;
185 u8 physicalPresenceHWEnable;
186 u8 physicalPresenceCMDEnable;
187 u8 CEKPUsed;
188 u8 TPMpost;
189 u8 TPMpostLock;
190 u8 FIPS;
191 u8 operator;
192 u8 enableRevokeEK;
193 u8 nvLocked;
194 u8 readSRKPub;
195 u8 tpmEstablished;
196 u8 maintenanceDone;
197 u8 disableFullDALogicInfo;
198}__attribute__((packed));
199
200typedef union {
201 struct permanent_flags_t perm_flags;
202 struct stclear_flags_t stclear_flags;
203 bool owned;
204 __be32 num_pcrs;
205 struct tpm_version_t tpm_version;
206 struct tpm_version_1_2_t tpm_version_1_2;
207 __be32 manufacturer_id;
208 struct timeout_t timeout;
209 struct duration_t duration;
210} cap_t;
211
212struct tpm_getcap_params_in {
213 __be32 cap;
214 __be32 subcap_size;
215 __be32 subcap;
216}__attribute__((packed));
217
218struct tpm_getcap_params_out {
219 __be32 cap_size;
220 cap_t cap;
221}__attribute__((packed));
222
223struct tpm_readpubek_params_out {
224 u8 algorithm[4];
225 u8 encscheme[2];
226 u8 sigscheme[2];
227 u8 parameters[12];
228 __be32 keysize;
229 u8 modulus[256];
230 u8 checksum[20];
231}__attribute__((packed));
232
233typedef union {
234 struct tpm_input_header in;
235 struct tpm_output_header out;
236} tpm_cmd_header;
237
238#define TPM_DIGEST_SIZE 20
239struct tpm_pcrread_out {
240 u8 pcr_result[TPM_DIGEST_SIZE];
241}__attribute__((packed));
242
243struct tpm_pcrread_in {
244 __be32 pcr_idx;
245}__attribute__((packed));
246
247struct tpm_pcrextend_in {
248 __be32 pcr_idx;
249 u8 hash[TPM_DIGEST_SIZE];
250}__attribute__((packed));
251
252typedef union {
253 struct tpm_getcap_params_out getcap_out;
254 struct tpm_readpubek_params_out readpubek_out;
255 u8 readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)];
256 struct tpm_getcap_params_in getcap_in;
257 struct tpm_pcrread_in pcrread_in;
258 struct tpm_pcrread_out pcrread_out;
259 struct tpm_pcrextend_in pcrextend_in;
260} tpm_cmd_params;
261
262struct tpm_cmd_t {
263 tpm_cmd_header header;
264 tpm_cmd_params params;
265}__attribute__((packed));
266
267ssize_t tpm_getcap(struct device *, __be32, cap_t *, const char *);
268
269extern void tpm_get_timeouts(struct tpm_chip *);
270extern void tpm_gen_interrupt(struct tpm_chip *);
271extern void tpm_continue_selftest(struct tpm_chip *);
272extern unsigned long tpm_calc_ordinal_duration(struct tpm_chip *, u32);
273extern struct tpm_chip* tpm_register_hardware(struct device *,
274 const struct tpm_vendor_specific *);
275extern int tpm_open(struct inode *, struct file *);
276extern int tpm_release(struct inode *, struct file *);
277extern void tpm_dev_vendor_release(struct tpm_chip *);
278extern ssize_t tpm_write(struct file *, const char __user *, size_t,
279 loff_t *);
280extern ssize_t tpm_read(struct file *, char __user *, size_t, loff_t *);
281extern void tpm_remove_hardware(struct device *);
282extern int tpm_pm_suspend(struct device *, pm_message_t);
283extern int tpm_pm_resume(struct device *);
284
285#ifdef CONFIG_ACPI
286extern struct dentry ** tpm_bios_log_setup(char *);
287extern void tpm_bios_log_teardown(struct dentry **);
288#else
289static inline struct dentry ** tpm_bios_log_setup(char *name)
290{
291 return NULL;
292}
293static inline void tpm_bios_log_teardown(struct dentry **dir)
294{
295}
296#endif
297
