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),
81 struct crb_control_area __iomem
*cca
;
86 static SIMPLE_DEV_PM_OPS(crb_pm
, tpm_pm_suspend
, tpm_pm_resume
);
88 static u8
crb_status(struct tpm_chip
*chip
)
90 struct crb_priv
*priv
= dev_get_drvdata(&chip
->dev
);
93 if ((ioread32(&priv
->cca
->start
) & CRB_START_INVOKE
) !=
95 sts
|= CRB_STS_COMPLETE
;
100 static int crb_recv(struct tpm_chip
*chip
, u8
*buf
, size_t count
)
102 struct crb_priv
*priv
= dev_get_drvdata(&chip
->dev
);
103 unsigned int expected
;
109 if (ioread32(&priv
->cca
->sts
) & CRB_CA_STS_ERROR
)
112 memcpy_fromio(buf
, priv
->rsp
, 6);
113 expected
= be32_to_cpup((__be32
*) &buf
[2]);
115 if (expected
> count
)
118 memcpy_fromio(&buf
[6], &priv
->rsp
[6], expected
- 6);
123 static int crb_do_acpi_start(struct tpm_chip
*chip
)
125 union acpi_object
*obj
;
128 obj
= acpi_evaluate_dsm(chip
->acpi_dev_handle
,
130 CRB_ACPI_START_REVISION_ID
,
131 CRB_ACPI_START_INDEX
,
135 rc
= obj
->integer
.value
== 0 ? 0 : -ENXIO
;
140 static int crb_send(struct tpm_chip
*chip
, u8
*buf
, size_t len
)
142 struct crb_priv
*priv
= dev_get_drvdata(&chip
->dev
);
145 /* Zero the cancel register so that the next command will not get
148 iowrite32(0, &priv
->cca
->cancel
);
150 if (len
> ioread32(&priv
->cca
->cmd_size
)) {
152 "invalid command count value %x %zx\n",
154 (size_t) ioread32(&priv
->cca
->cmd_size
));
158 memcpy_toio(priv
->cmd
, buf
, len
);
160 /* Make sure that cmd is populated before issuing start. */
163 if (priv
->flags
& CRB_FL_CRB_START
)
164 iowrite32(cpu_to_le32(CRB_START_INVOKE
), &priv
->cca
->start
);
166 if (priv
->flags
& CRB_FL_ACPI_START
)
167 rc
= crb_do_acpi_start(chip
);
172 static void crb_cancel(struct tpm_chip
*chip
)
174 struct crb_priv
*priv
= dev_get_drvdata(&chip
->dev
);
176 iowrite32(cpu_to_le32(CRB_CANCEL_INVOKE
), &priv
->cca
->cancel
);
178 /* Make sure that cmd is populated before issuing cancel. */
181 if ((priv
->flags
& CRB_FL_ACPI_START
) && crb_do_acpi_start(chip
))
182 dev_err(&chip
->dev
, "ACPI Start failed\n");
185 static bool crb_req_canceled(struct tpm_chip
*chip
, u8 status
)
187 struct crb_priv
*priv
= dev_get_drvdata(&chip
->dev
);
188 u32 cancel
= ioread32(&priv
->cca
->cancel
);
190 return (cancel
& CRB_CANCEL_INVOKE
) == CRB_CANCEL_INVOKE
;
193 static const struct tpm_class_ops tpm_crb
= {
194 .flags
= TPM_OPS_AUTO_STARTUP
,
195 .status
= crb_status
,
198 .cancel
= crb_cancel
,
199 .req_canceled
= crb_req_canceled
,
200 .req_complete_mask
= CRB_STS_COMPLETE
,
201 .req_complete_val
= CRB_STS_COMPLETE
,
204 static int crb_init(struct acpi_device
*device
, struct crb_priv
*priv
)
206 struct tpm_chip
*chip
;
208 chip
= tpmm_chip_alloc(&device
->dev
, &tpm_crb
);
210 return PTR_ERR(chip
);
212 dev_set_drvdata(&chip
->dev
, priv
);
213 chip
->acpi_dev_handle
= device
->handle
;
214 chip
->flags
= TPM_CHIP_FLAG_TPM2
;
216 return tpm_chip_register(chip
);
219 static int crb_check_resource(struct acpi_resource
*ares
, void *data
)
221 struct resource
*io_res
= data
;
224 if (acpi_dev_resource_memory(ares
, &res
)) {
232 static void __iomem
*crb_map_res(struct device
*dev
, struct crb_priv
*priv
,
233 struct resource
*io_res
, u64 start
, u32 size
)
235 struct resource new_res
= {
237 .end
= start
+ size
- 1,
238 .flags
= IORESOURCE_MEM
,
241 /* Detect a 64 bit address on a 32 bit system */
242 if (start
!= new_res
.start
)
243 return (void __iomem
*) ERR_PTR(-EINVAL
);
245 if (!resource_contains(io_res
, &new_res
))
246 return devm_ioremap_resource(dev
, &new_res
);
248 return priv
->iobase
+ (new_res
.start
- io_res
->start
);
251 static int crb_map_io(struct acpi_device
*device
, struct crb_priv
*priv
,
252 struct acpi_table_tpm2
*buf
)
254 struct list_head resources
;
255 struct resource io_res
;
256 struct device
*dev
= &device
->dev
;
263 INIT_LIST_HEAD(&resources
);
264 ret
= acpi_dev_get_resources(device
, &resources
, crb_check_resource
,
268 acpi_dev_free_resource_list(&resources
);
270 if (resource_type(&io_res
) != IORESOURCE_MEM
) {
272 FW_BUG
"TPM2 ACPI table does not define a memory resource\n");
276 priv
->iobase
= devm_ioremap_resource(dev
, &io_res
);
277 if (IS_ERR(priv
->iobase
))
278 return PTR_ERR(priv
->iobase
);
280 priv
->cca
= crb_map_res(dev
, priv
, &io_res
, buf
->control_address
,
281 sizeof(struct crb_control_area
));
282 if (IS_ERR(priv
->cca
))
283 return PTR_ERR(priv
->cca
);
285 cmd_pa
= ((u64
) ioread32(&priv
->cca
->cmd_pa_high
) << 32) |
286 (u64
) ioread32(&priv
->cca
->cmd_pa_low
);
287 cmd_size
= ioread32(&priv
->cca
->cmd_size
);
288 priv
->cmd
= crb_map_res(dev
, priv
, &io_res
, cmd_pa
, cmd_size
);
289 if (IS_ERR(priv
->cmd
))
290 return PTR_ERR(priv
->cmd
);
292 memcpy_fromio(&rsp_pa
, &priv
->cca
->rsp_pa
, 8);
293 rsp_pa
= le64_to_cpu(rsp_pa
);
294 rsp_size
= ioread32(&priv
->cca
->rsp_size
);
296 if (cmd_pa
!= rsp_pa
) {
297 priv
->rsp
= crb_map_res(dev
, priv
, &io_res
, rsp_pa
, rsp_size
);
298 return PTR_ERR_OR_ZERO(priv
->rsp
);
301 /* According to the PTP specification, overlapping command and response
302 * buffer sizes must be identical.
304 if (cmd_size
!= rsp_size
) {
305 dev_err(dev
, FW_BUG
"overlapping command and response buffer sizes are not identical");
309 priv
->rsp
= priv
->cmd
;
313 static int crb_acpi_add(struct acpi_device
*device
)
315 struct acpi_table_tpm2
*buf
;
316 struct crb_priv
*priv
;
317 struct device
*dev
= &device
->dev
;
322 status
= acpi_get_table(ACPI_SIG_TPM2
, 1,
323 (struct acpi_table_header
**) &buf
);
324 if (ACPI_FAILURE(status
) || buf
->header
.length
< sizeof(*buf
)) {
325 dev_err(dev
, FW_BUG
"failed to get TPM2 ACPI table\n");
329 /* Should the FIFO driver handle this? */
330 sm
= buf
->start_method
;
331 if (sm
== ACPI_TPM2_MEMORY_MAPPED
)
334 priv
= devm_kzalloc(dev
, sizeof(struct crb_priv
), GFP_KERNEL
);
338 /* The reason for the extra quirk is that the PTT in 4th Gen Core CPUs
339 * report only ACPI start but in practice seems to require both
340 * ACPI start and CRB start.
342 if (sm
== ACPI_TPM2_COMMAND_BUFFER
|| sm
== ACPI_TPM2_MEMORY_MAPPED
||
343 !strcmp(acpi_device_hid(device
), "MSFT0101"))
344 priv
->flags
|= CRB_FL_CRB_START
;
346 if (sm
== ACPI_TPM2_START_METHOD
||
347 sm
== ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD
)
348 priv
->flags
|= CRB_FL_ACPI_START
;
350 rc
= crb_map_io(device
, priv
, buf
);
354 return crb_init(device
, priv
);
357 static int crb_acpi_remove(struct acpi_device
*device
)
359 struct device
*dev
= &device
->dev
;
360 struct tpm_chip
*chip
= dev_get_drvdata(dev
);
362 tpm_chip_unregister(chip
);
367 static struct acpi_device_id crb_device_ids
[] = {
371 MODULE_DEVICE_TABLE(acpi
, crb_device_ids
);
373 static struct acpi_driver crb_acpi_driver
= {
375 .ids
= crb_device_ids
,
378 .remove
= crb_acpi_remove
,
385 module_acpi_driver(crb_acpi_driver
);
386 MODULE_AUTHOR("Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>");
387 MODULE_DESCRIPTION("TPM2 Driver");
388 MODULE_VERSION("0.1");
389 MODULE_LICENSE("GPL");