blob: 2b480c2960bbdd7a7e2db3b6130f10b74c086c7f [file] [log] [blame]
Marcel Selhorstebb81fd2005-07-27 11:45:12 -07001/*
2 * Description:
3 * Device Driver for the Infineon Technologies
Marcel Selhorstf9abb022005-08-05 11:59:33 -07004 * SLD 9630 TT 1.1 and SLB 9635 TT 1.2 Trusted Platform Module
Marcel Selhorstebb81fd2005-07-27 11:45:12 -07005 * Specifications at www.trustedcomputinggroup.org
6 *
Rajiv Andradecbb2d5e2012-04-24 11:19:58 -03007 * Copyright (C) 2005, Marcel Selhorst <tpmdd@selhorst.net>
8 * Sirrix AG - security technologies <tpmdd@sirrix.com> and
Marcel Selhorstebb81fd2005-07-27 11:45:12 -07009 * Applied Data Security Group, Ruhr-University Bochum, Germany
Justin P. Mattock631dd1a2010-10-18 11:03:14 +020010 * Project-Homepage: http://www.trust.rub.de/projects/linux-device-driver-infineon-tpm/
Marcel Selhorstebb81fd2005-07-27 11:45:12 -070011 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation, version 2 of the
15 * License.
Marcel Selhorstebb81fd2005-07-27 11:45:12 -070016 */
17
Randy Dunlap397c7182006-04-22 02:39:18 -070018#include <linux/init.h>
Marcel Selhorstf9abb022005-08-05 11:59:33 -070019#include <linux/pnp.h>
Marcel Selhorstebb81fd2005-07-27 11:45:12 -070020#include "tpm.h"
21
22/* Infineon specific definitions */
23/* maximum number of WTX-packages */
24#define TPM_MAX_WTX_PACKAGES 50
25/* msleep-Time for WTX-packages */
26#define TPM_WTX_MSLEEP_TIME 20
27/* msleep-Time --> Interval to check status register */
28#define TPM_MSLEEP_TIME 3
29/* gives number of max. msleep()-calls before throwing timeout */
30#define TPM_MAX_TRIES 5000
Marcel Selhorstf9abb022005-08-05 11:59:33 -070031#define TPM_INFINEON_DEV_VEN_VALUE 0x15D1
32
Alex Williamsond954e8e2007-05-08 00:25:55 -070033#define TPM_INF_IO_PORT 0x0
34#define TPM_INF_IO_MEM 0x1
35
36#define TPM_INF_ADDR 0x0
37#define TPM_INF_DATA 0x1
38
39struct tpm_inf_dev {
40 int iotype;
41
Marcel Selhorst93716b92010-02-10 13:56:32 -080042 void __iomem *mem_base; /* MMIO ioremap'd addr */
43 unsigned long map_base; /* phys MMIO base */
44 unsigned long map_size; /* MMIO region size */
45 unsigned int index_off; /* index register offset */
Alex Williamsond954e8e2007-05-08 00:25:55 -070046
Marcel Selhorst93716b92010-02-10 13:56:32 -080047 unsigned int data_regs; /* Data registers */
Alex Williamsond954e8e2007-05-08 00:25:55 -070048 unsigned int data_size;
49
50 unsigned int config_port; /* IO Port config index reg */
51 unsigned int config_size;
52};
53
54static struct tpm_inf_dev tpm_dev;
55
56static inline void tpm_data_out(unsigned char data, unsigned char offset)
57{
58 if (tpm_dev.iotype == TPM_INF_IO_PORT)
59 outb(data, tpm_dev.data_regs + offset);
60 else
61 writeb(data, tpm_dev.mem_base + tpm_dev.data_regs + offset);
62}
63
64static inline unsigned char tpm_data_in(unsigned char offset)
65{
66 if (tpm_dev.iotype == TPM_INF_IO_PORT)
67 return inb(tpm_dev.data_regs + offset);
68 else
69 return readb(tpm_dev.mem_base + tpm_dev.data_regs + offset);
70}
71
72static inline void tpm_config_out(unsigned char data, unsigned char offset)
73{
74 if (tpm_dev.iotype == TPM_INF_IO_PORT)
75 outb(data, tpm_dev.config_port + offset);
76 else
77 writeb(data, tpm_dev.mem_base + tpm_dev.index_off + offset);
78}
79
80static inline unsigned char tpm_config_in(unsigned char offset)
81{
82 if (tpm_dev.iotype == TPM_INF_IO_PORT)
83 return inb(tpm_dev.config_port + offset);
84 else
85 return readb(tpm_dev.mem_base + tpm_dev.index_off + offset);
86}
Marcel Selhorstebb81fd2005-07-27 11:45:12 -070087
88/* TPM header definitions */
89enum infineon_tpm_header {
90 TPM_VL_VER = 0x01,
91 TPM_VL_CHANNEL_CONTROL = 0x07,
92 TPM_VL_CHANNEL_PERSONALISATION = 0x0A,
93 TPM_VL_CHANNEL_TPM = 0x0B,
94 TPM_VL_CONTROL = 0x00,
95 TPM_INF_NAK = 0x15,
96 TPM_CTRL_WTX = 0x10,
97 TPM_CTRL_WTX_ABORT = 0x18,
98 TPM_CTRL_WTX_ABORT_ACK = 0x18,
99 TPM_CTRL_ERROR = 0x20,
100 TPM_CTRL_CHAININGACK = 0x40,
101 TPM_CTRL_CHAINING = 0x80,
102 TPM_CTRL_DATA = 0x04,
103 TPM_CTRL_DATA_CHA = 0x84,
104 TPM_CTRL_DATA_CHA_ACK = 0xC4
105};
106
107enum infineon_tpm_register {
108 WRFIFO = 0x00,
109 RDFIFO = 0x01,
110 STAT = 0x02,
111 CMD = 0x03
112};
113
114enum infineon_tpm_command_bits {
115 CMD_DIS = 0x00,
116 CMD_LP = 0x01,
117 CMD_RES = 0x02,
118 CMD_IRQC = 0x06
119};
120
121enum infineon_tpm_status_bits {
122 STAT_XFE = 0x00,
123 STAT_LPA = 0x01,
124 STAT_FOK = 0x02,
125 STAT_TOK = 0x03,
126 STAT_IRQA = 0x06,
127 STAT_RDA = 0x07
128};
129
130/* some outgoing values */
131enum infineon_tpm_values {
132 CHIP_ID1 = 0x20,
133 CHIP_ID2 = 0x21,
Andrew Morton3dcce8e2005-07-27 11:45:14 -0700134 TPM_DAR = 0x30,
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700135 RESET_LP_IRQC_DISABLE = 0x41,
136 ENABLE_REGISTER_PAIR = 0x55,
137 IOLIMH = 0x60,
138 IOLIML = 0x61,
139 DISABLE_REGISTER_PAIR = 0xAA,
140 IDVENL = 0xF1,
141 IDVENH = 0xF2,
142 IDPDL = 0xF3,
143 IDPDH = 0xF4
144};
145
146static int number_of_wtx;
147
148static int empty_fifo(struct tpm_chip *chip, int clear_wrfifo)
149{
150 int status;
151 int check = 0;
152 int i;
153
154 if (clear_wrfifo) {
155 for (i = 0; i < 4096; i++) {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700156 status = tpm_data_in(WRFIFO);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700157 if (status == 0xff) {
158 if (check == 5)
159 break;
160 else
161 check++;
162 }
163 }
164 }
165 /* Note: The values which are currently in the FIFO of the TPM
166 are thrown away since there is no usage for them. Usually,
167 this has nothing to say, since the TPM will give its answer
168 immediately or will be aborted anyway, so the data here is
169 usually garbage and useless.
170 We have to clean this, because the next communication with
171 the TPM would be rubbish, if there is still some old data
172 in the Read FIFO.
173 */
174 i = 0;
175 do {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700176 status = tpm_data_in(RDFIFO);
177 status = tpm_data_in(STAT);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700178 i++;
179 if (i == TPM_MAX_TRIES)
180 return -EIO;
181 } while ((status & (1 << STAT_RDA)) != 0);
182 return 0;
183}
184
185static int wait(struct tpm_chip *chip, int wait_for_bit)
186{
187 int status;
188 int i;
189 for (i = 0; i < TPM_MAX_TRIES; i++) {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700190 status = tpm_data_in(STAT);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700191 /* check the status-register if wait_for_bit is set */
192 if (status & 1 << wait_for_bit)
193 break;
194 msleep(TPM_MSLEEP_TIME);
195 }
196 if (i == TPM_MAX_TRIES) { /* timeout occurs */
197 if (wait_for_bit == STAT_XFE)
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800198 dev_err(chip->dev, "Timeout in wait(STAT_XFE)\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700199 if (wait_for_bit == STAT_RDA)
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800200 dev_err(chip->dev, "Timeout in wait(STAT_RDA)\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700201 return -EIO;
202 }
203 return 0;
204};
205
206static void wait_and_send(struct tpm_chip *chip, u8 sendbyte)
207{
208 wait(chip, STAT_XFE);
Alex Williamsond954e8e2007-05-08 00:25:55 -0700209 tpm_data_out(sendbyte, WRFIFO);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700210}
211
212 /* Note: WTX means Waiting-Time-Extension. Whenever the TPM needs more
213 calculation time, it sends a WTX-package, which has to be acknowledged
214 or aborted. This usually occurs if you are hammering the TPM with key
215 creation. Set the maximum number of WTX-packages in the definitions
216 above, if the number is reached, the waiting-time will be denied
217 and the TPM command has to be resend.
218 */
219
220static void tpm_wtx(struct tpm_chip *chip)
221{
222 number_of_wtx++;
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800223 dev_info(chip->dev, "Granting WTX (%02d / %02d)\n",
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700224 number_of_wtx, TPM_MAX_WTX_PACKAGES);
225 wait_and_send(chip, TPM_VL_VER);
226 wait_and_send(chip, TPM_CTRL_WTX);
227 wait_and_send(chip, 0x00);
228 wait_and_send(chip, 0x00);
229 msleep(TPM_WTX_MSLEEP_TIME);
230}
231
232static void tpm_wtx_abort(struct tpm_chip *chip)
233{
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800234 dev_info(chip->dev, "Aborting WTX\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700235 wait_and_send(chip, TPM_VL_VER);
236 wait_and_send(chip, TPM_CTRL_WTX_ABORT);
237 wait_and_send(chip, 0x00);
238 wait_and_send(chip, 0x00);
239 number_of_wtx = 0;
240 msleep(TPM_WTX_MSLEEP_TIME);
241}
242
243static int tpm_inf_recv(struct tpm_chip *chip, u8 * buf, size_t count)
244{
245 int i;
246 int ret;
247 u32 size = 0;
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800248 number_of_wtx = 0;
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700249
250recv_begin:
251 /* start receiving header */
252 for (i = 0; i < 4; i++) {
253 ret = wait(chip, STAT_RDA);
254 if (ret)
255 return -EIO;
Alex Williamsond954e8e2007-05-08 00:25:55 -0700256 buf[i] = tpm_data_in(RDFIFO);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700257 }
258
259 if (buf[0] != TPM_VL_VER) {
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800260 dev_err(chip->dev,
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700261 "Wrong transport protocol implementation!\n");
262 return -EIO;
263 }
264
265 if (buf[1] == TPM_CTRL_DATA) {
266 /* size of the data received */
267 size = ((buf[2] << 8) | buf[3]);
268
269 for (i = 0; i < size; i++) {
270 wait(chip, STAT_RDA);
Alex Williamsond954e8e2007-05-08 00:25:55 -0700271 buf[i] = tpm_data_in(RDFIFO);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700272 }
273
274 if ((size == 0x6D00) && (buf[1] == 0x80)) {
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800275 dev_err(chip->dev, "Error handling on vendor layer!\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700276 return -EIO;
277 }
278
279 for (i = 0; i < size; i++)
280 buf[i] = buf[i + 6];
281
282 size = size - 6;
283 return size;
284 }
285
286 if (buf[1] == TPM_CTRL_WTX) {
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800287 dev_info(chip->dev, "WTX-package received\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700288 if (number_of_wtx < TPM_MAX_WTX_PACKAGES) {
289 tpm_wtx(chip);
290 goto recv_begin;
291 } else {
292 tpm_wtx_abort(chip);
293 goto recv_begin;
294 }
295 }
296
297 if (buf[1] == TPM_CTRL_WTX_ABORT_ACK) {
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800298 dev_info(chip->dev, "WTX-abort acknowledged\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700299 return size;
300 }
301
302 if (buf[1] == TPM_CTRL_ERROR) {
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800303 dev_err(chip->dev, "ERROR-package received:\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700304 if (buf[4] == TPM_INF_NAK)
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800305 dev_err(chip->dev,
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700306 "-> Negative acknowledgement"
307 " - retransmit command!\n");
308 return -EIO;
309 }
310 return -EIO;
311}
312
313static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count)
314{
315 int i;
316 int ret;
317 u8 count_high, count_low, count_4, count_3, count_2, count_1;
318
319 /* Disabling Reset, LP and IRQC */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700320 tpm_data_out(RESET_LP_IRQC_DISABLE, CMD);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700321
322 ret = empty_fifo(chip, 1);
323 if (ret) {
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800324 dev_err(chip->dev, "Timeout while clearing FIFO\n");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700325 return -EIO;
326 }
327
328 ret = wait(chip, STAT_XFE);
329 if (ret)
330 return -EIO;
331
332 count_4 = (count & 0xff000000) >> 24;
333 count_3 = (count & 0x00ff0000) >> 16;
334 count_2 = (count & 0x0000ff00) >> 8;
335 count_1 = (count & 0x000000ff);
336 count_high = ((count + 6) & 0xffffff00) >> 8;
337 count_low = ((count + 6) & 0x000000ff);
338
339 /* Sending Header */
340 wait_and_send(chip, TPM_VL_VER);
341 wait_and_send(chip, TPM_CTRL_DATA);
342 wait_and_send(chip, count_high);
343 wait_and_send(chip, count_low);
344
345 /* Sending Data Header */
346 wait_and_send(chip, TPM_VL_VER);
347 wait_and_send(chip, TPM_VL_CHANNEL_TPM);
348 wait_and_send(chip, count_4);
349 wait_and_send(chip, count_3);
350 wait_and_send(chip, count_2);
351 wait_and_send(chip, count_1);
352
353 /* Sending Data */
354 for (i = 0; i < count; i++) {
355 wait_and_send(chip, buf[i]);
356 }
357 return count;
358}
359
360static void tpm_inf_cancel(struct tpm_chip *chip)
361{
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700362 /*
363 Since we are using the legacy mode to communicate
364 with the TPM, we have no cancel functions, but have
365 a workaround for interrupting the TPM through WTX.
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700366 */
367}
368
Kylene Jo Hallb4ed3e32005-10-30 15:03:23 -0800369static u8 tpm_inf_status(struct tpm_chip *chip)
370{
Alex Williamsond954e8e2007-05-08 00:25:55 -0700371 return tpm_data_in(STAT);
Kylene Jo Hallb4ed3e32005-10-30 15:03:23 -0800372}
373
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700374static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
375static DEVICE_ATTR(pcrs, S_IRUGO, tpm_show_pcrs, NULL);
376static DEVICE_ATTR(caps, S_IRUGO, tpm_show_caps, NULL);
377static DEVICE_ATTR(cancel, S_IWUSR | S_IWGRP, NULL, tpm_store_cancel);
378
379static struct attribute *inf_attrs[] = {
380 &dev_attr_pubek.attr,
381 &dev_attr_pcrs.attr,
382 &dev_attr_caps.attr,
383 &dev_attr_cancel.attr,
384 NULL,
385};
386
387static struct attribute_group inf_attr_grp = {.attrs = inf_attrs };
388
Arjan van de Ven62322d22006-07-03 00:24:21 -0700389static const struct file_operations inf_ops = {
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700390 .owner = THIS_MODULE,
391 .llseek = no_llseek,
392 .open = tpm_open,
393 .read = tpm_read,
394 .write = tpm_write,
395 .release = tpm_release,
396};
397
Marcel Selhorste496f5402006-04-22 02:38:42 -0700398static const struct tpm_vendor_specific tpm_inf = {
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700399 .recv = tpm_inf_recv,
400 .send = tpm_inf_send,
401 .cancel = tpm_inf_cancel,
Kylene Jo Hallb4ed3e32005-10-30 15:03:23 -0800402 .status = tpm_inf_status,
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700403 .req_complete_mask = 0,
404 .req_complete_val = 0,
405 .attr_group = &inf_attr_grp,
406 .miscdev = {.fops = &inf_ops,},
407};
408
Marcel Selhorst93716b92010-02-10 13:56:32 -0800409static const struct pnp_device_id tpm_inf_pnp_tbl[] = {
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700410 /* Infineon TPMs */
411 {"IFX0101", 0},
412 {"IFX0102", 0},
413 {"", 0}
414};
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800415
Marcel Selhorst93716b92010-02-10 13:56:32 -0800416MODULE_DEVICE_TABLE(pnp, tpm_inf_pnp_tbl);
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700417
Bill Pembertonafc6d362012-11-19 13:22:42 -0500418static int tpm_inf_pnp_probe(struct pnp_dev *dev,
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800419 const struct pnp_device_id *dev_id)
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700420{
421 int rc = 0;
422 u8 iol, ioh;
423 int vendorid[2];
424 int version[2];
425 int productid[2];
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700426 char chipname[20];
Marcel Selhorste496f5402006-04-22 02:38:42 -0700427 struct tpm_chip *chip;
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700428
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800429 /* read IO-ports through PnP */
430 if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
431 !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700432
Marcel Selhorst93716b92010-02-10 13:56:32 -0800433 tpm_dev.iotype = TPM_INF_IO_PORT;
Alex Williamsond954e8e2007-05-08 00:25:55 -0700434
435 tpm_dev.config_port = pnp_port_start(dev, 0);
436 tpm_dev.config_size = pnp_port_len(dev, 0);
437 tpm_dev.data_regs = pnp_port_start(dev, 1);
438 tpm_dev.data_size = pnp_port_len(dev, 1);
439 if ((tpm_dev.data_size < 4) || (tpm_dev.config_size < 2)) {
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800440 rc = -EINVAL;
441 goto err_last;
442 }
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800443 dev_info(&dev->dev, "Found %s with ID %s\n",
444 dev->name, dev_id->id);
Alex Williamsond954e8e2007-05-08 00:25:55 -0700445 if (!((tpm_dev.data_regs >> 8) & 0xff)) {
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800446 rc = -EINVAL;
447 goto err_last;
448 }
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800449 /* publish my base address and request region */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700450 if (request_region(tpm_dev.data_regs, tpm_dev.data_size,
451 "tpm_infineon0") == NULL) {
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800452 rc = -EINVAL;
453 goto err_last;
454 }
Alex Williamsond954e8e2007-05-08 00:25:55 -0700455 if (request_region(tpm_dev.config_port, tpm_dev.config_size,
456 "tpm_infineon0") == NULL) {
457 release_region(tpm_dev.data_regs, tpm_dev.data_size);
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800458 rc = -EINVAL;
459 goto err_last;
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800460 }
Alex Williamsond954e8e2007-05-08 00:25:55 -0700461 } else if (pnp_mem_valid(dev, 0) &&
Marcel Selhorst93716b92010-02-10 13:56:32 -0800462 !(pnp_mem_flags(dev, 0) & IORESOURCE_DISABLED)) {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700463
Marcel Selhorst93716b92010-02-10 13:56:32 -0800464 tpm_dev.iotype = TPM_INF_IO_MEM;
Alex Williamsond954e8e2007-05-08 00:25:55 -0700465
466 tpm_dev.map_base = pnp_mem_start(dev, 0);
467 tpm_dev.map_size = pnp_mem_len(dev, 0);
468
469 dev_info(&dev->dev, "Found %s with ID %s\n",
470 dev->name, dev_id->id);
471
472 /* publish my base address and request region */
473 if (request_mem_region(tpm_dev.map_base, tpm_dev.map_size,
474 "tpm_infineon0") == NULL) {
475 rc = -EINVAL;
476 goto err_last;
477 }
478
479 tpm_dev.mem_base = ioremap(tpm_dev.map_base, tpm_dev.map_size);
480 if (tpm_dev.mem_base == NULL) {
481 release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
482 rc = -EINVAL;
483 goto err_last;
484 }
485
486 /*
487 * The only known MMIO based Infineon TPM system provides
488 * a single large mem region with the device config
489 * registers at the default TPM_ADDR. The data registers
490 * seem like they could be placed anywhere within the MMIO
491 * region, but lets just put them at zero offset.
492 */
493 tpm_dev.index_off = TPM_ADDR;
494 tpm_dev.data_regs = 0x0;
Marcel Selhorste8a65012005-09-03 15:54:20 -0700495 } else {
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800496 rc = -EINVAL;
497 goto err_last;
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700498 }
499
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700500 /* query chip for its vendor, its version number a.s.o. */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700501 tpm_config_out(ENABLE_REGISTER_PAIR, TPM_INF_ADDR);
502 tpm_config_out(IDVENL, TPM_INF_ADDR);
503 vendorid[1] = tpm_config_in(TPM_INF_DATA);
504 tpm_config_out(IDVENH, TPM_INF_ADDR);
505 vendorid[0] = tpm_config_in(TPM_INF_DATA);
506 tpm_config_out(IDPDL, TPM_INF_ADDR);
507 productid[1] = tpm_config_in(TPM_INF_DATA);
508 tpm_config_out(IDPDH, TPM_INF_ADDR);
509 productid[0] = tpm_config_in(TPM_INF_DATA);
510 tpm_config_out(CHIP_ID1, TPM_INF_ADDR);
511 version[1] = tpm_config_in(TPM_INF_DATA);
512 tpm_config_out(CHIP_ID2, TPM_INF_ADDR);
513 version[0] = tpm_config_in(TPM_INF_DATA);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700514
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700515 switch ((productid[0] << 8) | productid[1]) {
516 case 6:
Marcel Selhorste8a65012005-09-03 15:54:20 -0700517 snprintf(chipname, sizeof(chipname), " (SLD 9630 TT 1.1)");
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700518 break;
519 case 11:
Marcel Selhorste8a65012005-09-03 15:54:20 -0700520 snprintf(chipname, sizeof(chipname), " (SLB 9635 TT 1.2)");
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700521 break;
522 default:
Marcel Selhorste8a65012005-09-03 15:54:20 -0700523 snprintf(chipname, sizeof(chipname), " (unknown chip)");
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700524 break;
525 }
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700526
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700527 if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) {
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700528
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700529 /* configure TPM with IO-ports */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700530 tpm_config_out(IOLIMH, TPM_INF_ADDR);
531 tpm_config_out((tpm_dev.data_regs >> 8) & 0xff, TPM_INF_DATA);
532 tpm_config_out(IOLIML, TPM_INF_ADDR);
533 tpm_config_out((tpm_dev.data_regs & 0xff), TPM_INF_DATA);
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700534
535 /* control if IO-ports are set correctly */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700536 tpm_config_out(IOLIMH, TPM_INF_ADDR);
537 ioh = tpm_config_in(TPM_INF_DATA);
538 tpm_config_out(IOLIML, TPM_INF_ADDR);
539 iol = tpm_config_in(TPM_INF_DATA);
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700540
Alex Williamsond954e8e2007-05-08 00:25:55 -0700541 if ((ioh << 8 | iol) != tpm_dev.data_regs) {
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800542 dev_err(&dev->dev,
Alex Williamsond954e8e2007-05-08 00:25:55 -0700543 "Could not set IO-data registers to 0x%x\n",
544 tpm_dev.data_regs);
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800545 rc = -EIO;
546 goto err_release_region;
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700547 }
548
549 /* activate register */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700550 tpm_config_out(TPM_DAR, TPM_INF_ADDR);
551 tpm_config_out(0x01, TPM_INF_DATA);
552 tpm_config_out(DISABLE_REGISTER_PAIR, TPM_INF_ADDR);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700553
554 /* disable RESET, LP and IRQC */
Alex Williamsond954e8e2007-05-08 00:25:55 -0700555 tpm_data_out(RESET_LP_IRQC_DISABLE, CMD);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700556
557 /* Finally, we're done, print some infos */
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800558 dev_info(&dev->dev, "TPM found: "
Alex Williamsond954e8e2007-05-08 00:25:55 -0700559 "config base 0x%lx, "
560 "data base 0x%lx, "
Marcel Selhorste496f5402006-04-22 02:38:42 -0700561 "chip version 0x%02x%02x, "
562 "vendor id 0x%x%x (Infineon), "
563 "product id 0x%02x%02x"
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700564 "%s\n",
Alex Williamsond954e8e2007-05-08 00:25:55 -0700565 tpm_dev.iotype == TPM_INF_IO_PORT ?
Marcel Selhorst93716b92010-02-10 13:56:32 -0800566 tpm_dev.config_port :
567 tpm_dev.map_base + tpm_dev.index_off,
Alex Williamsond954e8e2007-05-08 00:25:55 -0700568 tpm_dev.iotype == TPM_INF_IO_PORT ?
Marcel Selhorst93716b92010-02-10 13:56:32 -0800569 tpm_dev.data_regs :
570 tpm_dev.map_base + tpm_dev.data_regs,
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700571 version[0], version[1],
572 vendorid[0], vendorid[1],
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700573 productid[0], productid[1], chipname);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700574
Alex Williamsond954e8e2007-05-08 00:25:55 -0700575 if (!(chip = tpm_register_hardware(&dev->dev, &tpm_inf)))
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800576 goto err_release_region;
Alex Williamsond954e8e2007-05-08 00:25:55 -0700577
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700578 return 0;
579 } else {
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800580 rc = -ENODEV;
581 goto err_release_region;
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700582 }
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800583
584err_release_region:
Alex Williamsond954e8e2007-05-08 00:25:55 -0700585 if (tpm_dev.iotype == TPM_INF_IO_PORT) {
586 release_region(tpm_dev.data_regs, tpm_dev.data_size);
587 release_region(tpm_dev.config_port, tpm_dev.config_size);
588 } else {
589 iounmap(tpm_dev.mem_base);
590 release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
591 }
Marcel Selhorst8c9e8772006-02-17 13:52:41 -0800592
593err_last:
594 return rc;
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700595}
596
Bill Pemberton39af33f2012-11-19 13:26:26 -0500597static void tpm_inf_pnp_remove(struct pnp_dev *dev)
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800598{
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800599 struct tpm_chip *chip = pnp_get_drvdata(dev);
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800600
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800601 if (chip) {
Alex Williamsond954e8e2007-05-08 00:25:55 -0700602 if (tpm_dev.iotype == TPM_INF_IO_PORT) {
603 release_region(tpm_dev.data_regs, tpm_dev.data_size);
604 release_region(tpm_dev.config_port,
605 tpm_dev.config_size);
606 } else {
607 iounmap(tpm_dev.mem_base);
608 release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
609 }
Marcel Selhorst93716b92010-02-10 13:56:32 -0800610 tpm_dev_vendor_release(chip);
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800611 tpm_remove_hardware(chip->dev);
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800612 }
Kylene Jo Halle659a3f2005-10-30 15:03:24 -0800613}
614
Marcel Selhorst93716b92010-02-10 13:56:32 -0800615static int tpm_inf_pnp_suspend(struct pnp_dev *dev, pm_message_t pm_state)
616{
617 struct tpm_chip *chip = pnp_get_drvdata(dev);
618 int rc;
619 if (chip) {
620 u8 savestate[] = {
621 0, 193, /* TPM_TAG_RQU_COMMAND */
622 0, 0, 0, 10, /* blob length (in bytes) */
623 0, 0, 0, 152 /* TPM_ORD_SaveState */
624 };
625 dev_info(&dev->dev, "saving TPM state\n");
626 rc = tpm_inf_send(chip, savestate, sizeof(savestate));
627 if (rc < 0) {
628 dev_err(&dev->dev, "error while saving TPM state\n");
629 return rc;
630 }
631 }
632 return 0;
633}
634
635static int tpm_inf_pnp_resume(struct pnp_dev *dev)
636{
637 /* Re-configure TPM after suspending */
638 tpm_config_out(ENABLE_REGISTER_PAIR, TPM_INF_ADDR);
639 tpm_config_out(IOLIMH, TPM_INF_ADDR);
640 tpm_config_out((tpm_dev.data_regs >> 8) & 0xff, TPM_INF_DATA);
641 tpm_config_out(IOLIML, TPM_INF_ADDR);
642 tpm_config_out((tpm_dev.data_regs & 0xff), TPM_INF_DATA);
643 /* activate register */
644 tpm_config_out(TPM_DAR, TPM_INF_ADDR);
645 tpm_config_out(0x01, TPM_INF_DATA);
646 tpm_config_out(DISABLE_REGISTER_PAIR, TPM_INF_ADDR);
647 /* disable RESET, LP and IRQC */
648 tpm_data_out(RESET_LP_IRQC_DISABLE, CMD);
649 return tpm_pm_resume(&dev->dev);
650}
651
Randy Dunlape1d42c92008-02-06 01:38:06 -0800652static struct pnp_driver tpm_inf_pnp_driver = {
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800653 .name = "tpm_inf_pnp",
Marcel Selhorst93716b92010-02-10 13:56:32 -0800654 .id_table = tpm_inf_pnp_tbl,
Marcel Selhorst1b8333b2005-10-30 15:03:27 -0800655 .probe = tpm_inf_pnp_probe,
Marcel Selhorst93716b92010-02-10 13:56:32 -0800656 .suspend = tpm_inf_pnp_suspend,
657 .resume = tpm_inf_pnp_resume,
Bill Pemberton164dce82012-11-19 13:19:57 -0500658 .remove = tpm_inf_pnp_remove
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700659};
660
661static int __init init_inf(void)
662{
Randy Dunlape1d42c92008-02-06 01:38:06 -0800663 return pnp_register_driver(&tpm_inf_pnp_driver);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700664}
665
666static void __exit cleanup_inf(void)
667{
Randy Dunlape1d42c92008-02-06 01:38:06 -0800668 pnp_unregister_driver(&tpm_inf_pnp_driver);
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700669}
670
671module_init(init_inf);
672module_exit(cleanup_inf);
673
Rajiv Andradecbb2d5e2012-04-24 11:19:58 -0300674MODULE_AUTHOR("Marcel Selhorst <tpmdd@sirrix.com>");
Marcel Selhorstf9abb022005-08-05 11:59:33 -0700675MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
Marcel Selhorst93716b92010-02-10 13:56:32 -0800676MODULE_VERSION("1.9.2");
Marcel Selhorstebb81fd2005-07-27 11:45:12 -0700677MODULE_LICENSE("GPL");