tpm: spi: fix stopwatch implementation bug
[depthcharge.git] / src / drivers / tpm / spi.c
1 /*
2  * Copyright 2016 The Chromium OS Authors. All rights reserved.
3  * Use of this source code is governed by a BSD-style license that can be
4  * found in the LICENSE file.
5  *
6  * This is a driver for a SPI interfaced TPM2 device.
7  *
8  * It assumes that the required SPI interface has been initialized before the
9  * driver is started. A 'sruct spi_slave' pointer passed at initialization is
10  * used to direct traffic to the correct SPI interface. This dirver does not
11  * provide a way to instantiate multiple TPM devices. Also, to keep things
12  * simple, the driver unconditionally uses of TPM locality zero.
13  *
14  * References to documentation are based on the TCG issued "TPM Profile (PTP)
15  * Specification Revision 00.43".
16  */
17
18 #include <libpayload.h>
19
20 #include "spi.h"
21
22 /************************************************************/
23 /*  Plumbing to make porting of the coreboot driver easier. */
24 struct spi_slave {};
25 enum {
26         false = 0,
27         true
28 };
29
30 struct tpm2_info {
31         uint16_t vendor_id;
32         uint16_t device_id;
33         uint16_t revision;
34 };
35
36 struct stopwatch {
37         u64 start;
38         u64 expires;
39 };
40 static void stopwatch_init_usecs_expire(struct stopwatch *sw, long us)
41 {
42         sw->start = timer_us(0);
43         sw->expires = us;
44 }
45
46 static int stopwatch_expired(struct stopwatch *sw)
47 {
48         return timer_us(sw->start) > sw->expires;
49 }
50
51 /*
52  * Use static driver structure, we're not going to have multiple TPM devices
53  * on board.
54  */
55 static SpiTpm spi_tpm;
56
57 static int spi_claim_bus(struct spi_slave *unused)
58 {
59         return spi_tpm.bus->start(spi_tpm.bus);
60 }
61
62 static void spi_release_bus(struct spi_slave *unused)
63 {
64         spi_tpm.bus->stop(spi_tpm.bus);
65 }
66
67 static int spi_xfer(struct spi_slave *unused, const void *dout,
68                     unsigned bytesout, void *din, unsigned bytesin)
69 {
70         unsigned count;
71
72         count = bytesin;
73         if (bytesin < bytesout)
74                 count = bytesout;
75         else
76                 count = bytesin;
77
78         return spi_tpm.bus->transfer(spi_tpm.bus, din, dout, count);
79 }
80
81 static uint32_t read_be32(const void *ptr)
82 {
83         uint32_t result;
84
85         memcpy(&result, ptr, sizeof(result));
86         return be32toh(result);
87 }
88
89 /*********************************************************/
90 /*   Coreboot driver with as little changes as possible. */
91
92
93 #define TPM_LOCALITY_0_SPI_BASE 0x00d40000
94
95 /* Assorted TPM2 registers for interface type FIFO. */
96 #define TPM_ACCESS_REG    (TPM_LOCALITY_0_SPI_BASE + 0)
97 #define TPM_STS_REG       (TPM_LOCALITY_0_SPI_BASE + 0x18)
98 #define TPM_DATA_FIFO_REG (TPM_LOCALITY_0_SPI_BASE + 0x24)
99 #define TPM_DID_VID_REG   (TPM_LOCALITY_0_SPI_BASE + 0xf00)
100 #define TPM_RID_REG       (TPM_LOCALITY_0_SPI_BASE + 0xf04)
101
102 /* SPI Interface descriptor used by the driver. */
103 struct tpm_spi_if {
104         struct spi_slave *slave;
105         int (*cs_assert)(struct spi_slave *slave);
106         void (*cs_deassert)(struct spi_slave *slave);
107         int  (*xfer)(struct spi_slave *slave, const void *dout,
108                      unsigned bytesout, void *din,
109                      unsigned bytesin);
110 };
111
112 /* Use the common SPI driver wrapper as the interface callbacks. */
113 static struct tpm_spi_if tpm_if = {
114         .cs_assert = spi_claim_bus,
115         .cs_deassert = spi_release_bus,
116         .xfer = spi_xfer
117 };
118
119 /* Cached TPM device identification. */
120 struct tpm2_info tpm_info;
121
122 /*
123  * TODO(vbendeb): make CONFIG_DEBUG_TPM an int to allow different level of
124  * debug traces. Right now it is either 0 or 1.
125  */
126 static const int debug_level_ = 1;
127
128 /* Locality management bits (in TPM_ACCESS_REG) */
129 enum tpm_access_bits {
130         tpm_reg_valid_sts = (1 << 7),
131         active_locality = (1 << 5),
132         request_use = (1 << 1),
133         tpm_establishment = (1 << 0),
134 };
135
136 /*
137  * Variuous fields of the TPM status register, arguably the most important
138  * register when interfacing to a TPM.
139  */
140 enum tpm_sts_bits {
141         tpm_family_shift = 26,
142         tpm_family_mask = ((1 << 2) - 1),  /* 2 bits wide. */
143         tpm_family_tpm2 = 1,
144         reset_establishment_bit = (1 << 25),
145         command_cancel = (1 << 24),
146         burst_count_shift = 8,
147         burst_count_mask = ((1 << 16) - 1),  /* 16 bits wide. */
148         sts_valid = (1 << 7),
149         command_ready = (1 << 6),
150         tpm_go = (1 << 5),
151         data_avail = (1 << 4),
152         expect = (1 << 3),
153         self_test_done = (1 << 2),
154         response_retry = (1 << 1),
155 };
156
157 /*
158  * SPI frame header for TPM transactions is 4 bytes in size, it is described
159  * in section "6.4.6 Spi Bit Protocol".
160  */
161 typedef struct {
162         unsigned char body[4];
163 } spi_frame_header;
164
165 /*
166  * Each TPM2 SPI transaction starts the same: CS is asserted, the 4 byte
167  * header is sent to the TPM, the master waits til TPM is ready to continue.
168  */
169 static void start_transaction(int read_write, size_t bytes, unsigned addr)
170 {
171         spi_frame_header header;
172         uint8_t byte;
173         int i;
174
175         /*
176          * Give it 10 ms. TODO(vbendeb): remove this once cr50 SPS TPM driver
177          * performance is fixed.
178          */
179         mdelay(10);
180
181         /*
182          * The first byte of the frame header encodes the transaction type
183          * (read or write) and transfer size (set to lentgh - 1), limited to
184          * 64 bytes.
185          */
186         header.body[0] = (read_write ? 0x80 : 0) | 0x40 | (bytes - 1);
187
188         /* The rest of the frame header is the TPM register address. */
189         for (i = 0; i < 3; i++)
190                 header.body[i + 1] = (addr >> (8 * (2 - i))) & 0xff;
191
192         /* CS assert wakes up the slave. */
193         tpm_if.cs_assert(tpm_if.slave);
194
195         /*
196          * The TCG TPM over SPI specification introduces the notion of SPI
197          * flow control (Section "6.4.5 Flow Control").
198          *
199          * Again, the slave (TPM device) expects each transaction to start
200          * with a 4 byte header trasmitted by master. The header indicates if
201          * the master needs to read or write a register, and the register
202          * address.
203          *
204          * If the slave needs to stall the transaction (for instance it is not
205          * ready to send the register value to the master), it sets the MOSI
206          * line to 0 during the last clock of the 4 byte header. In this case
207          * the master is supposed to start polling the SPI bus, one byte at
208          * time, until the last bit in the received byte (transferred during
209          * the last clock of the byte) is set to 1.
210          *
211          * Due to some SPI controllers' shortcomings (Rockchip comes to
212          * mind...) we trasmit the 4 byte header without checking the byte
213          * transmitted by the TPM during the transaction's last byte.
214          *
215          * We know that cr50 is guaranteed to set the flow control bit to 0
216          * during the header transfer, but real TPM2 might be fast enough not
217          * to require to stall the master, this would present an issue.
218          * crosbug.com/p/52132 has been opened to track this.
219          */
220         tpm_if.xfer(tpm_if.slave, header.body, sizeof(header.body), NULL, 0);
221
222         /* Now poll the bus until TPM removes the stall bit. */
223         do {
224                 tpm_if.xfer(tpm_if.slave, NULL, 0, &byte, 1);
225         } while (!(byte & 1));
226 }
227
228 /*
229  * Print out the contents of a buffer, if debug is enabled. Skip registers
230  * other than FIFO, unless debug_level_ is 2.
231  */
232 static void trace_dump(const char *prefix, uint32_t reg,
233                        size_t bytes, const uint8_t *buffer,
234                        int force)
235 {
236         static char prev_prefix;
237         static unsigned prev_reg;
238         static int current_char;
239         const int BYTES_PER_LINE = 32;
240
241         if (!force) {
242                 if (!debug_level_)
243                         return;
244
245                 if ((debug_level_ < 2) && (reg != TPM_DATA_FIFO_REG))
246                         return;
247         }
248
249         /*
250          * Do not print register address again if the last dump print was for
251          * that register.
252          */
253         if ((prev_prefix != *prefix) || (prev_reg != reg)) {
254                 prev_prefix = *prefix;
255                 prev_reg = reg;
256                 printf("\n%s %2.2x:", prefix, reg);
257                 current_char = 0;
258         }
259
260         if ((reg != TPM_DATA_FIFO_REG) && (bytes == 4)) {
261                 /*
262                  * This must be a regular register address, print the 32 bit
263                  * value.
264                  */
265                 printf(" %8.8x", *(const uint32_t *)buffer);
266         } else {
267                 int i;
268
269                 /*
270                  * Data read from or written to FIFO or not in 4 byte
271                  * quantiites is printed byte at a time.
272                  */
273                 for (i = 0; i < bytes; i++) {
274                         if (current_char && !(current_char % BYTES_PER_LINE)) {
275                                 printf("\n     ");
276                                 current_char = 0;
277                         }
278                         current_char++;
279                         printf(" %2.2x", buffer[i]);
280                 }
281         }
282 }
283
284 /*
285  * Once transaction is initiated and the TPM indicated that it is ready to go,
286  * write the actual bytes to the register.
287  */
288 static void write_bytes(const void *buffer, size_t bytes)
289 {
290         tpm_if.xfer(tpm_if.slave, buffer, bytes, NULL, 0);
291 }
292
293 /*
294  * Once transaction is initiated and the TPM indicated that it is ready to go,
295  * read the actual bytes from the register.
296  */
297 static void read_bytes(void *buffer, size_t bytes)
298 {
299         tpm_if.xfer(tpm_if.slave, NULL, 0, buffer, bytes);
300 }
301
302 /*
303  * To write a register, start transaction, transfer data to the TPM, deassert
304  * CS when done.
305  *
306  * Returns one to indicate success, zero (not yet implemented) to indicate
307  * failure.
308  */
309 static int tpm2_write_reg(unsigned reg_number, const void *buffer, size_t bytes)
310 {
311         trace_dump("W", reg_number, bytes, buffer, 0);
312         start_transaction(false, bytes, reg_number);
313         write_bytes(buffer, bytes);
314         tpm_if.cs_deassert(tpm_if.slave);
315         return 1;
316 }
317
318 /*
319  * To read a register, start transaction, transfer data from the TPM, deassert
320  * CS when done.
321  *
322  * Returns one to indicate success, zero (not yet implemented) to indicate
323  * failure.
324  */
325 static int tpm2_read_reg(unsigned reg_number, void *buffer, size_t bytes)
326 {
327         start_transaction(true, bytes, reg_number);
328         read_bytes(buffer, bytes);
329         tpm_if.cs_deassert(tpm_if.slave);
330         trace_dump("R", reg_number, bytes, buffer, 0);
331         return 1;
332 }
333
334 /*
335  * Status register is accessed often, wrap reading and writing it into
336  * dedicated functions.
337  */
338 static int read_tpm_sts(uint32_t *status)
339 {
340         return tpm2_read_reg(TPM_STS_REG, status, sizeof(*status));
341 }
342
343 static int write_tpm_sts(uint32_t status)
344 {
345         return tpm2_write_reg(TPM_STS_REG, &status, sizeof(status));
346 }
347
348 /*
349  * The TPM may limit the transaction bytes count (burst count) below the 64
350  * bytes max. The current value is available as a field of the status
351  * register.
352  */
353 static uint32_t get_burst_count(void)
354 {
355         uint32_t status;
356
357         read_tpm_sts(&status);
358         return (status >> burst_count_shift) & burst_count_mask;
359 }
360
361 static int tpm2_init(SpiOps *spi_ops)
362 {
363         uint32_t did_vid, status;
364         uint8_t cmd;
365
366         tpm2_read_reg(TPM_DID_VID_REG, &did_vid, sizeof(did_vid));
367
368         /* Try claiming locality zero. */
369         tpm2_read_reg(TPM_ACCESS_REG, &cmd, sizeof(cmd));
370         if ((cmd & (active_locality & tpm_reg_valid_sts)) ==
371             (active_locality & tpm_reg_valid_sts)) {
372                 /*
373                  * Locality active - maybe reset line is not connected?
374                  * Release the locality and try again
375                  */
376                 cmd = active_locality;
377                 tpm2_write_reg(TPM_ACCESS_REG, &cmd, sizeof(cmd));
378                 tpm2_read_reg(TPM_ACCESS_REG, &cmd, sizeof(cmd));
379         }
380
381         /* The tpm_establishment bit can be either set or not, ignore it. */
382         if ((cmd & ~tpm_establishment) != tpm_reg_valid_sts) {
383                 printf("invalid reset status: %#x\n", cmd);
384                 return -1;
385         }
386
387         cmd = request_use;
388         tpm2_write_reg(TPM_ACCESS_REG, &cmd, sizeof(cmd));
389         tpm2_read_reg(TPM_ACCESS_REG, &cmd, sizeof(cmd));
390         if ((cmd &  ~tpm_establishment) !=
391             (tpm_reg_valid_sts | active_locality)) {
392                 printf("failed to claim locality 0, status: %#x\n",
393                        cmd);
394                 return -1;
395         }
396
397         read_tpm_sts(&status);
398         if (((status >> tpm_family_shift) & tpm_family_mask) !=
399             tpm_family_tpm2) {
400                 printf("unexpected TPM family value, status: %#x\n",
401                        status);
402                 return -1;
403         }
404
405         /*
406          * Locality claimed, read the revision value and set up the tpm_info
407          * structure.
408          */
409         tpm2_read_reg(TPM_RID_REG, &cmd, sizeof(cmd));
410         tpm_info.vendor_id = did_vid & 0xffff;
411         tpm_info.device_id = did_vid >> 16;
412         tpm_info.revision = cmd;
413
414         printf("Connected to device vid:did:rid of %4.4x:%4.4x:%2.2x\n",
415                tpm_info.vendor_id, tpm_info.device_id, tpm_info.revision);
416
417         return 0;
418 }
419
420 /*
421  * This is in seconds, certain TPM commands, like key generation, can take
422  * long time to complete.
423  *
424  * Returns one to indicate success, zero (not yet implemented) to indicate
425  * failure.
426  */
427 #define MAX_STATUS_TIMEOUT 120
428 static int wait_for_status(uint32_t status_mask, uint32_t status_expected)
429 {
430         uint32_t status;
431         struct stopwatch sw;
432
433         stopwatch_init_usecs_expire(&sw, MAX_STATUS_TIMEOUT * 1000 * 1000);
434         do {
435                 udelay(1000);
436                 if (stopwatch_expired(&sw)) {
437                         printf("failed to get expected status %x\n",
438                                status_expected);
439                         return false;
440                 }
441                 read_tpm_sts(&status);
442         } while ((status & status_mask) != status_expected);
443
444         return 1;
445 }
446
447 enum fifo_transfer_direction {
448         fifo_transmit = 0,
449         fifo_receive = 1
450 };
451
452 /* Union allows to avoid casting away 'const' on transmit buffers. */
453 union fifo_transfer_buffer {
454         uint8_t *rx_buffer;
455         const uint8_t *tx_buffer;
456 };
457
458 /*
459  * Transfer requested number of bytes to or from TPM FIFO, accounting for the
460  * current burst count value.
461  */
462 static void fifo_transfer(size_t transfer_size,
463                           union fifo_transfer_buffer buffer,
464                           enum fifo_transfer_direction direction)
465 {
466         size_t transaction_size;
467         size_t burst_count;
468         size_t handled_so_far = 0;
469
470         do {
471                 do {
472                         /* Could be zero when TPM is busy. */
473                         burst_count = get_burst_count();
474                 } while (!burst_count);
475
476                 transaction_size = transfer_size - handled_so_far;
477                 transaction_size = MIN(transaction_size, burst_count);
478
479                 /*
480                  * The SPI frame header does not allow to pass more than 64
481                  * bytes.
482                  */
483                 transaction_size = MIN(transaction_size, 64);
484
485                 if (direction == fifo_receive)
486                         tpm2_read_reg(TPM_DATA_FIFO_REG,
487                                       buffer.rx_buffer + handled_so_far,
488                                       transaction_size);
489                 else
490                         tpm2_write_reg(TPM_DATA_FIFO_REG,
491                                        buffer.tx_buffer + handled_so_far,
492                                        transaction_size);
493
494                 handled_so_far += transaction_size;
495
496         } while (handled_so_far != transfer_size);
497 }
498
499 static size_t tpm2_process_command(const void *tpm2_command,
500                                    size_t command_size,
501                                    void *tpm2_response,
502                                    size_t max_response)
503 {
504         uint32_t status;
505         uint32_t expected_status_bits;
506         size_t payload_size;
507         size_t bytes_to_go;
508         const uint8_t *cmd_body = tpm2_command;
509         uint8_t *rsp_body = tpm2_response;
510         union fifo_transfer_buffer fifo_buffer;
511         const int HEADER_SIZE = 6;
512
513         /* Skip the two byte tag, read the size field. */
514         payload_size = read_be32(cmd_body + 2);
515
516         /* Sanity check. */
517         if (payload_size != command_size) {
518                 printf("Command size mismatch: encoded %zd != requested %zd\n",
519                        payload_size, command_size);
520                 trace_dump("W", TPM_DATA_FIFO_REG, command_size, cmd_body, 1);
521                 printf("\n");
522                 return 0;
523         }
524
525         /* Let the TPM know that the command is coming. */
526         write_tpm_sts(command_ready);
527
528         /*
529          * Tpm commands and responses written to and read from the FIFO
530          * register (0x24) are datagrams of variable size, prepended by a 6
531          * byte header.
532          *
533          * The specification description of the state machine is a bit vague,
534          * but from experience it looks like there is no need to wait for the
535          * sts.expect bit to be set, at least with the 9670 and cr50 devices.
536          * Just write the command into FIFO, making sure not to exceed the
537          * burst count or the maximum PDU size, whatever is smaller.
538          */
539         fifo_buffer.tx_buffer = cmd_body;
540         fifo_transfer(command_size, fifo_buffer, fifo_transmit);
541
542         /* Now tell the TPM it can start processing the command. */
543         write_tpm_sts(tpm_go);
544
545         /* Now wait for it to report that the response is ready. */
546         expected_status_bits = sts_valid | data_avail;
547         if (!wait_for_status(expected_status_bits, expected_status_bits)) {
548                 /*
549                  * If timed out, which should never happen, let's at least
550                  * print out the offending command.
551                  */
552                 trace_dump("W", TPM_DATA_FIFO_REG, command_size, cmd_body, 1);
553                 printf("\n");
554                 return 0;
555         }
556
557         /*
558          * The response is ready, let's read it. First we read the FIFO
559          * payload header, to see how much data to expect. The response header
560          * size is fixed to six bytes, the total payload size is stored in
561          * network order in the last four bytes.
562          */
563         tpm2_read_reg(TPM_DATA_FIFO_REG, rsp_body, HEADER_SIZE);
564
565         /* Find out the total payload size, skipping the two byte tag. */
566         payload_size = read_be32(rsp_body + 2);
567
568         if (payload_size > max_response) {
569                 /*
570                  * TODO(vbendeb): at least drain the FIFO here or somehow let
571                  * the TPM know that the response can be dropped.
572                  */
573                 printf(" tpm response too long (%zd bytes)",
574                        payload_size);
575                 return 0;
576         }
577
578         /*
579          * Now let's read all but the last byte in the FIFO to make sure the
580          * status register is showing correct flow control bits: 'more data'
581          * until the last byte and then 'no more data' once the last byte is
582          * read.
583          */
584         bytes_to_go = payload_size - 1 - HEADER_SIZE;
585         fifo_buffer.rx_buffer = rsp_body + HEADER_SIZE;
586         fifo_transfer(bytes_to_go, fifo_buffer, fifo_receive);
587
588         /* Verify that there is still data to read. */
589         read_tpm_sts(&status);
590         if ((status & expected_status_bits) != expected_status_bits) {
591                 printf("unexpected intermediate status %#x\n",
592                        status);
593                 return 0;
594         }
595
596         /* Read the last byte of the PDU. */
597         tpm2_read_reg(TPM_DATA_FIFO_REG, rsp_body + payload_size - 1, 1);
598
599         /* Terminate the dump, if enabled. */
600         if (debug_level_)
601                 printf("\n");
602
603         /* Verify that 'data available' is not asseretd any more. */
604         read_tpm_sts(&status);
605         if ((status & expected_status_bits) != sts_valid) {
606                 printf("unexpected final status %#x\n", status);
607                 return 0;
608         }
609
610         /* Move the TPM back to idle state. */
611         write_tpm_sts(command_ready);
612
613         return payload_size;
614 }
615
616 /*********************************************************/
617 /* Depthcharge interface to the coreboot SPI TPM driver. */
618
619 static int tpm_initialized;
620 static int tpm_cleanup(CleanupFunc *cleanup, CleanupType type)
621 {
622         printf("%s: add release locality here.\n", __func__);
623         return 0;
624 }
625
626 static int xmit_wrapper(struct TpmOps *me,
627                         const uint8_t *sendbuf,
628                         size_t send_size,
629                         uint8_t *recvbuf,
630                         size_t *recv_len)
631 {
632         size_t response_size;
633         SpiTpm *tpm = container_of(me, SpiTpm, ops);
634
635         if (!tpm_initialized) {
636                 if (tpm2_init(tpm->bus))
637                         return -1;
638
639                 list_insert_after(&spi_tpm.cleanup.list_node, &cleanup_funcs);
640                 tpm_initialized = 1;
641         }
642
643         response_size = tpm2_process_command(sendbuf,
644                                              send_size, recvbuf, *recv_len);
645         if (response_size) {
646                 *recv_len = response_size;
647                 return 0;
648         }
649
650         return -1;
651 }
652
653 SpiTpm *new_tpm_spi(SpiOps *bus)
654 {
655         spi_tpm.ops.xmit = xmit_wrapper;
656         spi_tpm.bus = bus;
657         spi_tpm.cleanup.cleanup = tpm_cleanup;
658         spi_tpm.cleanup.types = CleanupOnReboot | CleanupOnPowerOff |
659                 CleanupOnHandoff | CleanupOnLegacy;
660         return &spi_tpm;
661 }