2 * Copyright (C) 2014 Intel Corporation
5 * Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
7 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
9 * This device driver implements the TPM interface as defined in
10 * the TCG CRB 2.0 TPM specification.
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; version 2
18 #include <linux/acpi.h>
19 #include <linux/highmem.h>
20 #include <linux/rculist.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
25 #define ACPI_SIG_TPM2 "TPM2"
27 static const u8 CRB_ACPI_START_UUID
[] = {
28 /* 0000 */ 0xAB, 0x6C, 0xBF, 0x6B, 0x63, 0x54, 0x14, 0x47,
29 /* 0008 */ 0xB7, 0xCD, 0xF0, 0x20, 0x3C, 0x03, 0x68, 0xD4
33 CRB_ACPI_START_REVISION_ID
= 1,
34 CRB_ACPI_START_INDEX
= 1,
38 CRB_CA_REQ_GO_IDLE
= BIT(0),
39 CRB_CA_REQ_CMD_READY
= BIT(1),
43 CRB_CA_STS_ERROR
= BIT(0),
44 CRB_CA_STS_TPM_IDLE
= BIT(1),
48 CRB_START_INVOKE
= BIT(0),
52 CRB_CANCEL_INVOKE
= BIT(0),
55 struct crb_control_area
{
70 CRB_STS_COMPLETE
= BIT(0),
74 CRB_FL_ACPI_START
= BIT(0),
75 CRB_FL_CRB_START
= BIT(1),
82 struct crb_control_area __iomem
*cca
;
87 static SIMPLE_DEV_PM_OPS(crb_pm
, tpm_pm_suspend
, tpm_pm_resume
);
89 static u8
crb_status(struct tpm_chip
*chip
)
91 struct crb_priv
*priv
= chip
->vendor
.priv
;
94 if ((ioread32(&priv
->cca
->start
) & CRB_START_INVOKE
) !=
96 sts
|= CRB_STS_COMPLETE
;
101 static int crb_recv(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
103 struct crb_priv
*priv
= chip
->vendor
.priv
;
104 unsigned int expected
;
110 if (ioread32(&priv
->cca
->sts
) & CRB_CA_STS_ERROR
)
113 memcpy_fromio(buf
, priv
->rsp
, 6);
114 expected
= be32_to_cpup((__be32
*) &buf
[2]);
116 if (expected
> count
)
119 memcpy_fromio(&buf
[6], &priv
->rsp
[6], expected
- 6);
124 static int crb_do_acpi_start(struct tpm_chip
*chip
)
126 union acpi_object
*obj
;
129 obj
= acpi_evaluate_dsm(chip
->acpi_dev_handle
,
131 CRB_ACPI_START_REVISION_ID
,
132 CRB_ACPI_START_INDEX
,
136 rc
= obj
->integer
.value
== 0 ? 0 : -ENXIO
;
141 static int crb_send(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
143 struct crb_priv
*priv
= chip
->vendor
.priv
;
146 if (len
> ioread32(&priv
->cca
->cmd_size
)) {
148 "invalid command count value %x %zx\n",
150 (size_t) ioread32(&priv
->cca
->cmd_size
));
154 memcpy_toio(priv
->cmd
, buf
, len
);
156 /* Make sure that cmd is populated before issuing start. */
159 if (priv
->flags
& CRB_FL_CRB_START
)
160 iowrite32(cpu_to_le32(CRB_START_INVOKE
), &priv
->cca
->start
);
162 if (priv
->flags
& CRB_FL_ACPI_START
)
163 rc
= crb_do_acpi_start(chip
);
168 static void crb_cancel(struct tpm_chip
*chip
)
170 struct crb_priv
*priv
= chip
->vendor
.priv
;
172 iowrite32(cpu_to_le32(CRB_CANCEL_INVOKE
), &priv
->cca
->cancel
);
174 /* Make sure that cmd is populated before issuing cancel. */
177 if ((priv
->flags
& CRB_FL_ACPI_START
) && crb_do_acpi_start(chip
))
178 dev_err(&chip
->dev
, "ACPI Start failed\n");
180 iowrite32(0, &priv
->cca
->cancel
);
183 static bool crb_req_canceled(struct tpm_chip
*chip
, u8 status
)
185 struct crb_priv
*priv
= chip
->vendor
.priv
;
186 u32 cancel
= ioread32(&priv
->cca
->cancel
);
188 return (cancel
& CRB_CANCEL_INVOKE
) == CRB_CANCEL_INVOKE
;
191 static const struct tpm_class_ops tpm_crb
= {
192 .status
= crb_status
,
195 .cancel
= crb_cancel
,
196 .req_canceled
= crb_req_canceled
,
197 .req_complete_mask
= CRB_STS_COMPLETE
,
198 .req_complete_val
= CRB_STS_COMPLETE
,
201 static int crb_init(struct acpi_device
*device
, struct crb_priv
*priv
)
203 struct tpm_chip
*chip
;
206 chip
= tpmm_chip_alloc(&device
->dev
, &tpm_crb
);
208 return PTR_ERR(chip
);
210 chip
->vendor
.priv
= priv
;
211 chip
->acpi_dev_handle
= device
->handle
;
212 chip
->flags
= TPM_CHIP_FLAG_TPM2
;
214 rc
= tpm_get_timeouts(chip
);
218 rc
= tpm2_do_selftest(chip
);
222 return tpm_chip_register(chip
);
225 static int crb_check_resource(struct acpi_resource
*ares
, void *data
)
227 struct crb_priv
*priv
= data
;
230 if (acpi_dev_resource_memory(ares
, &res
)) {
232 priv
->res
.name
= NULL
;
238 static void __iomem
*crb_map_res(struct device
*dev
, struct crb_priv
*priv
,
241 struct resource new_res
= {
243 .end
= start
+ size
- 1,
244 .flags
= IORESOURCE_MEM
,
247 /* Detect a 64 bit address on a 32 bit system */
248 if (start
!= new_res
.start
)
249 return ERR_PTR(-EINVAL
);
251 if (!resource_contains(&priv
->res
, &new_res
))
252 return devm_ioremap_resource(dev
, &new_res
);
254 return priv
->iobase
+ (new_res
.start
- priv
->res
.start
);
257 static int crb_map_io(struct acpi_device
*device
, struct crb_priv
*priv
,
258 struct acpi_table_tpm2
*buf
)
260 struct list_head resources
;
261 struct device
*dev
= &device
->dev
;
265 INIT_LIST_HEAD(&resources
);
266 ret
= acpi_dev_get_resources(device
, &resources
, crb_check_resource
,
270 acpi_dev_free_resource_list(&resources
);
272 if (resource_type(&priv
->res
) != IORESOURCE_MEM
) {
274 FW_BUG
"TPM2 ACPI table does not define a memory resource\n");
278 priv
->iobase
= devm_ioremap_resource(dev
, &priv
->res
);
279 if (IS_ERR(priv
->iobase
))
280 return PTR_ERR(priv
->iobase
);
282 priv
->cca
= crb_map_res(dev
, priv
, buf
->control_address
, 0x1000);
283 if (IS_ERR(priv
->cca
))
284 return PTR_ERR(priv
->cca
);
286 pa
= ((u64
) ioread32(&priv
->cca
->cmd_pa_high
) << 32) |
287 (u64
) ioread32(&priv
->cca
->cmd_pa_low
);
288 priv
->cmd
= crb_map_res(dev
, priv
, pa
, ioread32(&priv
->cca
->cmd_size
));
289 if (IS_ERR(priv
->cmd
))
290 return PTR_ERR(priv
->cmd
);
292 memcpy_fromio(&pa
, &priv
->cca
->rsp_pa
, 8);
293 pa
= le64_to_cpu(pa
);
294 priv
->rsp
= crb_map_res(dev
, priv
, pa
, ioread32(&priv
->cca
->rsp_size
));
295 return PTR_ERR_OR_ZERO(priv
->rsp
);
298 static int crb_acpi_add(struct acpi_device
*device
)
300 struct acpi_table_tpm2
*buf
;
301 struct crb_priv
*priv
;
302 struct device
*dev
= &device
->dev
;
307 status
= acpi_get_table(ACPI_SIG_TPM2
, 1,
308 (struct acpi_table_header
**) &buf
);
309 if (ACPI_FAILURE(status
) || buf
->header
.length
< sizeof(*buf
)) {
310 dev_err(dev
, FW_BUG
"failed to get TPM2 ACPI table\n");
314 /* Should the FIFO driver handle this? */
315 sm
= buf
->start_method
;
316 if (sm
== ACPI_TPM2_MEMORY_MAPPED
)
319 priv
= devm_kzalloc(dev
, sizeof(struct crb_priv
), GFP_KERNEL
);
323 /* The reason for the extra quirk is that the PTT in 4th Gen Core CPUs
324 * report only ACPI start but in practice seems to require both
325 * ACPI start and CRB start.
327 if (sm
== ACPI_TPM2_COMMAND_BUFFER
|| sm
== ACPI_TPM2_MEMORY_MAPPED
||
328 !strcmp(acpi_device_hid(device
), "MSFT0101"))
329 priv
->flags
|= CRB_FL_CRB_START
;
331 if (sm
== ACPI_TPM2_START_METHOD
||
332 sm
== ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD
)
333 priv
->flags
|= CRB_FL_ACPI_START
;
335 rc
= crb_map_io(device
, priv
, buf
);
339 return crb_init(device
, priv
);
342 static int crb_acpi_remove(struct acpi_device
*device
)
344 struct device
*dev
= &device
->dev
;
345 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
347 if (chip
->flags
& TPM_CHIP_FLAG_TPM2
)
348 tpm2_shutdown(chip
, TPM2_SU_CLEAR
);
350 tpm_chip_unregister(chip
);
355 static struct acpi_device_id crb_device_ids
[] = {
359 MODULE_DEVICE_TABLE(acpi
, crb_device_ids
);
361 static struct acpi_driver crb_acpi_driver
= {
363 .ids
= crb_device_ids
,
366 .remove
= crb_acpi_remove
,
373 module_acpi_driver(crb_acpi_driver
);
374 MODULE_AUTHOR("Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>");
375 MODULE_DESCRIPTION("TPM2 Driver");
376 MODULE_VERSION("0.1");
377 MODULE_LICENSE("GPL");