diff options
Diffstat (limited to 'drivers/char/tpm')
-rw-r--r-- | drivers/char/tpm/Kconfig | 14 | ||||
-rw-r--r-- | drivers/char/tpm/Makefile | 2 | ||||
-rw-r--r-- | drivers/char/tpm/tpm_infineon.c | 533 |
3 files changed, 548 insertions, 1 deletions
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig index 7a969778915a..79e9832ef1f3 100644 --- a/drivers/char/tpm/Kconfig +++ b/drivers/char/tpm/Kconfig | |||
@@ -17,6 +17,8 @@ config TCG_TPM | |||
17 | obtained at: <http://sourceforge.net/projects/trousers>. To | 17 | obtained at: <http://sourceforge.net/projects/trousers>. To |
18 | compile this driver as a module, choose M here; the module | 18 | compile this driver as a module, choose M here; the module |
19 | will be called tpm. If unsure, say N. | 19 | will be called tpm. If unsure, say N. |
20 | Note: For more TPM drivers enable CONFIG_PNP, CONFIG_ACPI_BUS | ||
21 | and CONFIG_PNPACPI. | ||
20 | 22 | ||
21 | config TCG_NSC | 23 | config TCG_NSC |
22 | tristate "National Semiconductor TPM Interface" | 24 | tristate "National Semiconductor TPM Interface" |
@@ -35,5 +37,17 @@ config TCG_ATMEL | |||
35 | will be accessible from within Linux. To compile this driver | 37 | will be accessible from within Linux. To compile this driver |
36 | as a module, choose M here; the module will be called tpm_atmel. | 38 | as a module, choose M here; the module will be called tpm_atmel. |
37 | 39 | ||
40 | config TCG_INFINEON | ||
41 | tristate "Infineon Technologies TPM Interface" | ||
42 | depends on TCG_TPM && PNPACPI | ||
43 | ---help--- | ||
44 | If you have a TPM security chip from Infineon Technologies | ||
45 | (either SLD 9630 TT 1.1 or SLB 9635 TT 1.2) say Yes and it | ||
46 | will be accessible from within Linux. | ||
47 | To compile this driver as a module, choose M here; the module | ||
48 | will be called tpm_infineon. | ||
49 | Further information on this driver and the supported hardware | ||
50 | can be found at http://www.prosec.rub.de/tpm | ||
51 | |||
38 | endmenu | 52 | endmenu |
39 | 53 | ||
diff --git a/drivers/char/tpm/Makefile b/drivers/char/tpm/Makefile index 736d3df266f5..2392e404e8d1 100644 --- a/drivers/char/tpm/Makefile +++ b/drivers/char/tpm/Makefile | |||
@@ -4,4 +4,4 @@ | |||
4 | obj-$(CONFIG_TCG_TPM) += tpm.o | 4 | obj-$(CONFIG_TCG_TPM) += tpm.o |
5 | obj-$(CONFIG_TCG_NSC) += tpm_nsc.o | 5 | obj-$(CONFIG_TCG_NSC) += tpm_nsc.o |
6 | obj-$(CONFIG_TCG_ATMEL) += tpm_atmel.o | 6 | obj-$(CONFIG_TCG_ATMEL) += tpm_atmel.o |
7 | 7 | obj-$(CONFIG_TCG_INFINEON) += tpm_infineon.o | |
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c new file mode 100644 index 000000000000..dc8c540391fd --- /dev/null +++ b/drivers/char/tpm/tpm_infineon.c | |||
@@ -0,0 +1,533 @@ | |||
1 | /* | ||
2 | * Description: | ||
3 | * Device Driver for the Infineon Technologies | ||
4 | * SLD 9630 TT 1.1 and SLB 9635 TT 1.2 Trusted Platform Module | ||
5 | * Specifications at www.trustedcomputinggroup.org | ||
6 | * | ||
7 | * Copyright (C) 2005, Marcel Selhorst <selhorst@crypto.rub.de> | ||
8 | * Applied Data Security Group, Ruhr-University Bochum, Germany | ||
9 | * Project-Homepage: http://www.prosec.rub.de/tpm | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU General Public License as | ||
13 | * published by the Free Software Foundation, version 2 of the | ||
14 | * License. | ||
15 | */ | ||
16 | |||
17 | #include <acpi/acpi_bus.h> | ||
18 | #include <linux/pnp.h> | ||
19 | #include "tpm.h" | ||
20 | |||
21 | /* Infineon specific definitions */ | ||
22 | /* maximum number of WTX-packages */ | ||
23 | #define TPM_MAX_WTX_PACKAGES 50 | ||
24 | /* msleep-Time for WTX-packages */ | ||
25 | #define TPM_WTX_MSLEEP_TIME 20 | ||
26 | /* msleep-Time --> Interval to check status register */ | ||
27 | #define TPM_MSLEEP_TIME 3 | ||
28 | /* gives number of max. msleep()-calls before throwing timeout */ | ||
29 | #define TPM_MAX_TRIES 5000 | ||
30 | #define TPM_INFINEON_DEV_VEN_VALUE 0x15D1 | ||
31 | |||
32 | /* These values will be filled after ACPI-call */ | ||
33 | static int TPM_INF_DATA = 0; | ||
34 | static int TPM_INF_ADDR = 0; | ||
35 | |||
36 | /* TPM header definitions */ | ||
37 | enum infineon_tpm_header { | ||
38 | TPM_VL_VER = 0x01, | ||
39 | TPM_VL_CHANNEL_CONTROL = 0x07, | ||
40 | TPM_VL_CHANNEL_PERSONALISATION = 0x0A, | ||
41 | TPM_VL_CHANNEL_TPM = 0x0B, | ||
42 | TPM_VL_CONTROL = 0x00, | ||
43 | TPM_INF_NAK = 0x15, | ||
44 | TPM_CTRL_WTX = 0x10, | ||
45 | TPM_CTRL_WTX_ABORT = 0x18, | ||
46 | TPM_CTRL_WTX_ABORT_ACK = 0x18, | ||
47 | TPM_CTRL_ERROR = 0x20, | ||
48 | TPM_CTRL_CHAININGACK = 0x40, | ||
49 | TPM_CTRL_CHAINING = 0x80, | ||
50 | TPM_CTRL_DATA = 0x04, | ||
51 | TPM_CTRL_DATA_CHA = 0x84, | ||
52 | TPM_CTRL_DATA_CHA_ACK = 0xC4 | ||
53 | }; | ||
54 | |||
55 | enum infineon_tpm_register { | ||
56 | WRFIFO = 0x00, | ||
57 | RDFIFO = 0x01, | ||
58 | STAT = 0x02, | ||
59 | CMD = 0x03 | ||
60 | }; | ||
61 | |||
62 | enum infineon_tpm_command_bits { | ||
63 | CMD_DIS = 0x00, | ||
64 | CMD_LP = 0x01, | ||
65 | CMD_RES = 0x02, | ||
66 | CMD_IRQC = 0x06 | ||
67 | }; | ||
68 | |||
69 | enum infineon_tpm_status_bits { | ||
70 | STAT_XFE = 0x00, | ||
71 | STAT_LPA = 0x01, | ||
72 | STAT_FOK = 0x02, | ||
73 | STAT_TOK = 0x03, | ||
74 | STAT_IRQA = 0x06, | ||
75 | STAT_RDA = 0x07 | ||
76 | }; | ||
77 | |||
78 | /* some outgoing values */ | ||
79 | enum infineon_tpm_values { | ||
80 | CHIP_ID1 = 0x20, | ||
81 | CHIP_ID2 = 0x21, | ||
82 | TPM_DAR = 0x30, | ||
83 | RESET_LP_IRQC_DISABLE = 0x41, | ||
84 | ENABLE_REGISTER_PAIR = 0x55, | ||
85 | IOLIMH = 0x60, | ||
86 | IOLIML = 0x61, | ||
87 | DISABLE_REGISTER_PAIR = 0xAA, | ||
88 | IDVENL = 0xF1, | ||
89 | IDVENH = 0xF2, | ||
90 | IDPDL = 0xF3, | ||
91 | IDPDH = 0xF4 | ||
92 | }; | ||
93 | |||
94 | static int number_of_wtx; | ||
95 | |||
96 | static int empty_fifo(struct tpm_chip *chip, int clear_wrfifo) | ||
97 | { | ||
98 | int status; | ||
99 | int check = 0; | ||
100 | int i; | ||
101 | |||
102 | if (clear_wrfifo) { | ||
103 | for (i = 0; i < 4096; i++) { | ||
104 | status = inb(chip->vendor->base + WRFIFO); | ||
105 | if (status == 0xff) { | ||
106 | if (check == 5) | ||
107 | break; | ||
108 | else | ||
109 | check++; | ||
110 | } | ||
111 | } | ||
112 | } | ||
113 | /* Note: The values which are currently in the FIFO of the TPM | ||
114 | are thrown away since there is no usage for them. Usually, | ||
115 | this has nothing to say, since the TPM will give its answer | ||
116 | immediately or will be aborted anyway, so the data here is | ||
117 | usually garbage and useless. | ||
118 | We have to clean this, because the next communication with | ||
119 | the TPM would be rubbish, if there is still some old data | ||
120 | in the Read FIFO. | ||
121 | */ | ||
122 | i = 0; | ||
123 | do { | ||
124 | status = inb(chip->vendor->base + RDFIFO); | ||
125 | status = inb(chip->vendor->base + STAT); | ||
126 | i++; | ||
127 | if (i == TPM_MAX_TRIES) | ||
128 | return -EIO; | ||
129 | } while ((status & (1 << STAT_RDA)) != 0); | ||
130 | return 0; | ||
131 | } | ||
132 | |||
133 | static int wait(struct tpm_chip *chip, int wait_for_bit) | ||
134 | { | ||
135 | int status; | ||
136 | int i; | ||
137 | for (i = 0; i < TPM_MAX_TRIES; i++) { | ||
138 | status = inb(chip->vendor->base + STAT); | ||
139 | /* check the status-register if wait_for_bit is set */ | ||
140 | if (status & 1 << wait_for_bit) | ||
141 | break; | ||
142 | msleep(TPM_MSLEEP_TIME); | ||
143 | } | ||
144 | if (i == TPM_MAX_TRIES) { /* timeout occurs */ | ||
145 | if (wait_for_bit == STAT_XFE) | ||
146 | dev_err(&chip->pci_dev->dev, | ||
147 | "Timeout in wait(STAT_XFE)\n"); | ||
148 | if (wait_for_bit == STAT_RDA) | ||
149 | dev_err(&chip->pci_dev->dev, | ||
150 | "Timeout in wait(STAT_RDA)\n"); | ||
151 | return -EIO; | ||
152 | } | ||
153 | return 0; | ||
154 | }; | ||
155 | |||
156 | static void wait_and_send(struct tpm_chip *chip, u8 sendbyte) | ||
157 | { | ||
158 | wait(chip, STAT_XFE); | ||
159 | outb(sendbyte, chip->vendor->base + WRFIFO); | ||
160 | } | ||
161 | |||
162 | /* Note: WTX means Waiting-Time-Extension. Whenever the TPM needs more | ||
163 | calculation time, it sends a WTX-package, which has to be acknowledged | ||
164 | or aborted. This usually occurs if you are hammering the TPM with key | ||
165 | creation. Set the maximum number of WTX-packages in the definitions | ||
166 | above, if the number is reached, the waiting-time will be denied | ||
167 | and the TPM command has to be resend. | ||
168 | */ | ||
169 | |||
170 | static void tpm_wtx(struct tpm_chip *chip) | ||
171 | { | ||
172 | number_of_wtx++; | ||
173 | dev_info(&chip->pci_dev->dev, "Granting WTX (%02d / %02d)\n", | ||
174 | number_of_wtx, TPM_MAX_WTX_PACKAGES); | ||
175 | wait_and_send(chip, TPM_VL_VER); | ||
176 | wait_and_send(chip, TPM_CTRL_WTX); | ||
177 | wait_and_send(chip, 0x00); | ||
178 | wait_and_send(chip, 0x00); | ||
179 | msleep(TPM_WTX_MSLEEP_TIME); | ||
180 | } | ||
181 | |||
182 | static void tpm_wtx_abort(struct tpm_chip *chip) | ||
183 | { | ||
184 | dev_info(&chip->pci_dev->dev, "Aborting WTX\n"); | ||
185 | wait_and_send(chip, TPM_VL_VER); | ||
186 | wait_and_send(chip, TPM_CTRL_WTX_ABORT); | ||
187 | wait_and_send(chip, 0x00); | ||
188 | wait_and_send(chip, 0x00); | ||
189 | number_of_wtx = 0; | ||
190 | msleep(TPM_WTX_MSLEEP_TIME); | ||
191 | } | ||
192 | |||
193 | static int tpm_inf_recv(struct tpm_chip *chip, u8 * buf, size_t count) | ||
194 | { | ||
195 | int i; | ||
196 | int ret; | ||
197 | u32 size = 0; | ||
198 | |||
199 | recv_begin: | ||
200 | /* start receiving header */ | ||
201 | for (i = 0; i < 4; i++) { | ||
202 | ret = wait(chip, STAT_RDA); | ||
203 | if (ret) | ||
204 | return -EIO; | ||
205 | buf[i] = inb(chip->vendor->base + RDFIFO); | ||
206 | } | ||
207 | |||
208 | if (buf[0] != TPM_VL_VER) { | ||
209 | dev_err(&chip->pci_dev->dev, | ||
210 | "Wrong transport protocol implementation!\n"); | ||
211 | return -EIO; | ||
212 | } | ||
213 | |||
214 | if (buf[1] == TPM_CTRL_DATA) { | ||
215 | /* size of the data received */ | ||
216 | size = ((buf[2] << 8) | buf[3]); | ||
217 | |||
218 | for (i = 0; i < size; i++) { | ||
219 | wait(chip, STAT_RDA); | ||
220 | buf[i] = inb(chip->vendor->base + RDFIFO); | ||
221 | } | ||
222 | |||
223 | if ((size == 0x6D00) && (buf[1] == 0x80)) { | ||
224 | dev_err(&chip->pci_dev->dev, | ||
225 | "Error handling on vendor layer!\n"); | ||
226 | return -EIO; | ||
227 | } | ||
228 | |||
229 | for (i = 0; i < size; i++) | ||
230 | buf[i] = buf[i + 6]; | ||
231 | |||
232 | size = size - 6; | ||
233 | return size; | ||
234 | } | ||
235 | |||
236 | if (buf[1] == TPM_CTRL_WTX) { | ||
237 | dev_info(&chip->pci_dev->dev, "WTX-package received\n"); | ||
238 | if (number_of_wtx < TPM_MAX_WTX_PACKAGES) { | ||
239 | tpm_wtx(chip); | ||
240 | goto recv_begin; | ||
241 | } else { | ||
242 | tpm_wtx_abort(chip); | ||
243 | goto recv_begin; | ||
244 | } | ||
245 | } | ||
246 | |||
247 | if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) { | ||
248 | dev_info(&chip->pci_dev->dev, "WTX-abort acknowledged\n"); | ||
249 | return size; | ||
250 | } | ||
251 | |||
252 | if (buf[1] == TPM_CTRL_ERROR) { | ||
253 | dev_err(&chip->pci_dev->dev, "ERROR-package received:\n"); | ||
254 | if (buf[4] == TPM_INF_NAK) | ||
255 | dev_err(&chip->pci_dev->dev, | ||
256 | "-> Negative acknowledgement" | ||
257 | " - retransmit command!\n"); | ||
258 | return -EIO; | ||
259 | } | ||
260 | return -EIO; | ||
261 | } | ||
262 | |||
263 | static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count) | ||
264 | { | ||
265 | int i; | ||
266 | int ret; | ||
267 | u8 count_high, count_low, count_4, count_3, count_2, count_1; | ||
268 | |||
269 | /* Disabling Reset, LP and IRQC */ | ||
270 | outb(RESET_LP_IRQC_DISABLE, chip->vendor->base + CMD); | ||
271 | |||
272 | ret = empty_fifo(chip, 1); | ||
273 | if (ret) { | ||
274 | dev_err(&chip->pci_dev->dev, "Timeout while clearing FIFO\n"); | ||
275 | return -EIO; | ||
276 | } | ||
277 | |||
278 | ret = wait(chip, STAT_XFE); | ||
279 | if (ret) | ||
280 | return -EIO; | ||
281 | |||
282 | count_4 = (count & 0xff000000) >> 24; | ||
283 | count_3 = (count & 0x00ff0000) >> 16; | ||
284 | count_2 = (count & 0x0000ff00) >> 8; | ||
285 | count_1 = (count & 0x000000ff); | ||
286 | count_high = ((count + 6) & 0xffffff00) >> 8; | ||
287 | count_low = ((count + 6) & 0x000000ff); | ||
288 | |||
289 | /* Sending Header */ | ||
290 | wait_and_send(chip, TPM_VL_VER); | ||
291 | wait_and_send(chip, TPM_CTRL_DATA); | ||
292 | wait_and_send(chip, count_high); | ||
293 | wait_and_send(chip, count_low); | ||
294 | |||
295 | /* Sending Data Header */ | ||
296 | wait_and_send(chip, TPM_VL_VER); | ||
297 | wait_and_send(chip, TPM_VL_CHANNEL_TPM); | ||
298 | wait_and_send(chip, count_4); | ||
299 | wait_and_send(chip, count_3); | ||
300 | wait_and_send(chip, count_2); | ||
301 | wait_and_send(chip, count_1); | ||
302 | |||
303 | /* Sending Data */ | ||
304 | for (i = 0; i < count; i++) { | ||
305 | wait_and_send(chip, buf[i]); | ||
306 | } | ||
307 | return count; | ||
308 | } | ||
309 | |||
310 | static void tpm_inf_cancel(struct tpm_chip *chip) | ||
311 | { | ||
312 | /* | ||
313 | Since we are using the legacy mode to communicate | ||
314 | with the TPM, we have no cancel functions, but have | ||
315 | a workaround for interrupting the TPM through WTX. | ||
316 | */ | ||
317 | } | ||
318 | |||
319 | static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL); | ||
320 | static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL); | ||
321 | static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL); | ||
322 | static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel); | ||
323 | |||
324 | static struct attribute *inf_attrs[] = { | ||
325 | &dev_attr_pubek.attr, | ||
326 | &dev_attr_pcrs.attr, | ||
327 | &dev_attr_caps.attr, | ||
328 | &dev_attr_cancel.attr, | ||
329 | NULL, | ||
330 | }; | ||
331 | |||
332 | static struct attribute_group inf_attr_grp = {.attrs = inf_attrs }; | ||
333 | |||
334 | static struct file_operations inf_ops = { | ||
335 | .owner = THIS_MODULE, | ||
336 | .llseek = no_llseek, | ||
337 | .open = tpm_open, | ||
338 | .read = tpm_read, | ||
339 | .write = tpm_write, | ||
340 | .release = tpm_release, | ||
341 | }; | ||
342 | |||
343 | static struct tpm_vendor_specific tpm_inf = { | ||
344 | .recv = tpm_inf_recv, | ||
345 | .send = tpm_inf_send, | ||
346 | .cancel = tpm_inf_cancel, | ||
347 | .req_complete_mask = 0, | ||
348 | .req_complete_val = 0, | ||
349 | .attr_group = &inf_attr_grp, | ||
350 | .miscdev = {.fops = &inf_ops,}, | ||
351 | }; | ||
352 | |||
353 | static const struct pnp_device_id tpm_pnp_tbl[] = { | ||
354 | /* Infineon TPMs */ | ||
355 | {"IFX0101", 0}, | ||
356 | {"IFX0102", 0}, | ||
357 | {"", 0} | ||
358 | }; | ||
359 | |||
360 | static int __devinit tpm_inf_acpi_probe(struct pnp_dev *dev, | ||
361 | const struct pnp_device_id *dev_id) | ||
362 | { | ||
363 | TPM_INF_ADDR = (pnp_port_start(dev, 0) & 0xff); | ||
364 | TPM_INF_DATA = ((TPM_INF_ADDR + 1) & 0xff); | ||
365 | tpm_inf.base = pnp_port_start(dev, 1); | ||
366 | dev_info(&dev->dev, "Found %s with ID %s\n", | ||
367 | dev->name, dev_id->id); | ||
368 | if (!((tpm_inf.base >> 8) & 0xff)) | ||
369 | tpm_inf.base = 0; | ||
370 | return 0; | ||
371 | } | ||
372 | |||
373 | static struct pnp_driver tpm_inf_pnp = { | ||
374 | .name = "tpm_inf_pnp", | ||
375 | .id_table = tpm_pnp_tbl, | ||
376 | .probe = tpm_inf_acpi_probe, | ||
377 | }; | ||
378 | |||
379 | static int __devinit tpm_inf_probe(struct pci_dev *pci_dev, | ||
380 | const struct pci_device_id *pci_id) | ||
381 | { | ||
382 | int rc = 0; | ||
383 | u8 iol, ioh; | ||
384 | int vendorid[2]; | ||
385 | int version[2]; | ||
386 | int productid[2]; | ||
387 | char chipname[20]; | ||
388 | |||
389 | if (pci_enable_device(pci_dev)) | ||
390 | return -EIO; | ||
391 | |||
392 | dev_info(&pci_dev->dev, "LPC-bus found at 0x%x\n", pci_id->device); | ||
393 | |||
394 | /* read IO-ports from ACPI */ | ||
395 | pnp_register_driver(&tpm_inf_pnp); | ||
396 | pnp_unregister_driver(&tpm_inf_pnp); | ||
397 | |||
398 | /* Make sure, we have received valid config ports */ | ||
399 | if (!TPM_INF_ADDR) { | ||
400 | pci_disable_device(pci_dev); | ||
401 | return -EIO; | ||
402 | } | ||
403 | |||
404 | /* query chip for its vendor, its version number a.s.o. */ | ||
405 | outb(ENABLE_REGISTER_PAIR, TPM_INF_ADDR); | ||
406 | outb(IDVENL, TPM_INF_ADDR); | ||
407 | vendorid[1] = inb(TPM_INF_DATA); | ||
408 | outb(IDVENH, TPM_INF_ADDR); | ||
409 | vendorid[0] = inb(TPM_INF_DATA); | ||
410 | outb(IDPDL, TPM_INF_ADDR); | ||
411 | productid[1] = inb(TPM_INF_DATA); | ||
412 | outb(IDPDH, TPM_INF_ADDR); | ||
413 | productid[0] = inb(TPM_INF_DATA); | ||
414 | outb(CHIP_ID1, TPM_INF_ADDR); | ||
415 | version[1] = inb(TPM_INF_DATA); | ||
416 | outb(CHIP_ID2, TPM_INF_ADDR); | ||
417 | version[0] = inb(TPM_INF_DATA); | ||
418 | |||
419 | switch ((productid[0] << 8) | productid[1]) { | ||
420 | case 6: | ||
421 | sprintf(chipname, " (SLD 9630 TT 1.1)"); | ||
422 | break; | ||
423 | case 11: | ||
424 | sprintf(chipname, " (SLB 9635 TT 1.2)"); | ||
425 | break; | ||
426 | default: | ||
427 | sprintf(chipname, " (unknown chip)"); | ||
428 | break; | ||
429 | } | ||
430 | chipname[19] = 0; | ||
431 | |||
432 | if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) { | ||
433 | |||
434 | if (tpm_inf.base == 0) { | ||
435 | dev_err(&pci_dev->dev, "No IO-ports found!\n"); | ||
436 | pci_disable_device(pci_dev); | ||
437 | return -EIO; | ||
438 | } | ||
439 | /* configure TPM with IO-ports */ | ||
440 | outb(IOLIMH, TPM_INF_ADDR); | ||
441 | outb(((tpm_inf.base >> 8) & 0xff), TPM_INF_DATA); | ||
442 | outb(IOLIML, TPM_INF_ADDR); | ||
443 | outb((tpm_inf.base & 0xff), TPM_INF_DATA); | ||
444 | |||
445 | /* control if IO-ports are set correctly */ | ||
446 | outb(IOLIMH, TPM_INF_ADDR); | ||
447 | ioh = inb(TPM_INF_DATA); | ||
448 | outb(IOLIML, TPM_INF_ADDR); | ||
449 | iol = inb(TPM_INF_DATA); | ||
450 | |||
451 | if ((ioh << 8 | iol) != tpm_inf.base) { | ||
452 | dev_err(&pci_dev->dev, | ||
453 | "Could not set IO-ports to %04x\n", | ||
454 | tpm_inf.base); | ||
455 | pci_disable_device(pci_dev); | ||
456 | return -EIO; | ||
457 | } | ||
458 | |||
459 | /* activate register */ | ||
460 | outb(TPM_DAR, TPM_INF_ADDR); | ||
461 | outb(0x01, TPM_INF_DATA); | ||
462 | outb(DISABLE_REGISTER_PAIR, TPM_INF_ADDR); | ||
463 | |||
464 | /* disable RESET, LP and IRQC */ | ||
465 | outb(RESET_LP_IRQC_DISABLE, tpm_inf.base + CMD); | ||
466 | |||
467 | /* Finally, we're done, print some infos */ | ||
468 | dev_info(&pci_dev->dev, "TPM found: " | ||
469 | "config base 0x%x, " | ||
470 | "io base 0x%x, " | ||
471 | "chip version %02x%02x, " | ||
472 | "vendor id %x%x (Infineon), " | ||
473 | "product id %02x%02x" | ||
474 | "%s\n", | ||
475 | TPM_INF_ADDR, | ||
476 | tpm_inf.base, | ||
477 | version[0], version[1], | ||
478 | vendorid[0], vendorid[1], | ||
479 | productid[0], productid[1], chipname); | ||
480 | |||
481 | rc = tpm_register_hardware(pci_dev, &tpm_inf); | ||
482 | if (rc < 0) { | ||
483 | pci_disable_device(pci_dev); | ||
484 | return -ENODEV; | ||
485 | } | ||
486 | return 0; | ||
487 | } else { | ||
488 | dev_info(&pci_dev->dev, "No Infineon TPM found!\n"); | ||
489 | pci_disable_device(pci_dev); | ||
490 | return -ENODEV; | ||
491 | } | ||
492 | } | ||
493 | |||
494 | static struct pci_device_id tpm_pci_tbl[] __devinitdata = { | ||
495 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0)}, | ||
496 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12)}, | ||
497 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0)}, | ||
498 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12)}, | ||
499 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0)}, | ||
500 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0)}, | ||
501 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1)}, | ||
502 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2)}, | ||
503 | {0,} | ||
504 | }; | ||
505 | |||
506 | MODULE_DEVICE_TABLE(pci, tpm_pci_tbl); | ||
507 | |||
508 | static struct pci_driver inf_pci_driver = { | ||
509 | .name = "tpm_inf", | ||
510 | .id_table = tpm_pci_tbl, | ||
511 | .probe = tpm_inf_probe, | ||
512 | .remove = __devexit_p(tpm_remove), | ||
513 | .suspend = tpm_pm_suspend, | ||
514 | .resume = tpm_pm_resume, | ||
515 | }; | ||
516 | |||
517 | static int __init init_inf(void) | ||
518 | { | ||
519 | return pci_register_driver(&inf_pci_driver); | ||
520 | } | ||
521 | |||
522 | static void __exit cleanup_inf(void) | ||
523 | { | ||
524 | pci_unregister_driver(&inf_pci_driver); | ||
525 | } | ||
526 | |||
527 | module_init(init_inf); | ||
528 | module_exit(cleanup_inf); | ||
529 | |||
530 | MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>"); | ||
531 | MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2"); | ||
532 | MODULE_VERSION("1.5"); | ||
533 | MODULE_LICENSE("GPL"); | ||