tpm-common.c 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013 The Chromium OS Authors.
  4. * Coypright (c) 2013 Guntermann & Drunck GmbH
  5. */
  6. #define LOG_CATEGORY UCLASS_TPM
  7. #include <common.h>
  8. #include <dm.h>
  9. #include <asm/unaligned.h>
  10. #include <tpm-common.h>
  11. #include "tpm-utils.h"
  12. enum tpm_version tpm_get_version(struct udevice *dev)
  13. {
  14. struct tpm_chip_priv *priv = dev_get_uclass_priv(dev);
  15. return priv->version;
  16. }
  17. int pack_byte_string(u8 *str, size_t size, const char *format, ...)
  18. {
  19. va_list args;
  20. size_t offset = 0, length = 0;
  21. u8 *data = NULL;
  22. u32 value = 0;
  23. va_start(args, format);
  24. for (; *format; format++) {
  25. switch (*format) {
  26. case 'b':
  27. offset = va_arg(args, size_t);
  28. value = va_arg(args, int);
  29. length = 1;
  30. break;
  31. case 'w':
  32. offset = va_arg(args, size_t);
  33. value = va_arg(args, int);
  34. length = 2;
  35. break;
  36. case 'd':
  37. offset = va_arg(args, size_t);
  38. value = va_arg(args, u32);
  39. length = 4;
  40. break;
  41. case 's':
  42. offset = va_arg(args, size_t);
  43. data = va_arg(args, u8 *);
  44. length = va_arg(args, u32);
  45. break;
  46. default:
  47. debug("Couldn't recognize format string\n");
  48. va_end(args);
  49. return -1;
  50. }
  51. if (offset + length > size) {
  52. va_end(args);
  53. return -1;
  54. }
  55. switch (*format) {
  56. case 'b':
  57. str[offset] = value;
  58. break;
  59. case 'w':
  60. put_unaligned_be16(value, str + offset);
  61. break;
  62. case 'd':
  63. put_unaligned_be32(value, str + offset);
  64. break;
  65. case 's':
  66. memcpy(str + offset, data, length);
  67. break;
  68. }
  69. }
  70. va_end(args);
  71. return 0;
  72. }
  73. int unpack_byte_string(const u8 *str, size_t size, const char *format, ...)
  74. {
  75. va_list args;
  76. size_t offset = 0, length = 0;
  77. u8 *ptr8 = NULL;
  78. u16 *ptr16 = NULL;
  79. u32 *ptr32 = NULL;
  80. va_start(args, format);
  81. for (; *format; format++) {
  82. switch (*format) {
  83. case 'b':
  84. offset = va_arg(args, size_t);
  85. ptr8 = va_arg(args, u8 *);
  86. length = 1;
  87. break;
  88. case 'w':
  89. offset = va_arg(args, size_t);
  90. ptr16 = va_arg(args, u16 *);
  91. length = 2;
  92. break;
  93. case 'd':
  94. offset = va_arg(args, size_t);
  95. ptr32 = va_arg(args, u32 *);
  96. length = 4;
  97. break;
  98. case 's':
  99. offset = va_arg(args, size_t);
  100. ptr8 = va_arg(args, u8 *);
  101. length = va_arg(args, u32);
  102. break;
  103. default:
  104. va_end(args);
  105. debug("Couldn't recognize format string\n");
  106. return -1;
  107. }
  108. if (offset + length > size) {
  109. va_end(args);
  110. log_err("Failed to read: size=%zd, offset=%zx, len=%zx\n",
  111. size, offset, length);
  112. return -1;
  113. }
  114. switch (*format) {
  115. case 'b':
  116. *ptr8 = str[offset];
  117. break;
  118. case 'w':
  119. *ptr16 = get_unaligned_be16(str + offset);
  120. break;
  121. case 'd':
  122. *ptr32 = get_unaligned_be32(str + offset);
  123. break;
  124. case 's':
  125. memcpy(ptr8, str + offset, length);
  126. break;
  127. }
  128. }
  129. va_end(args);
  130. return 0;
  131. }
  132. u32 tpm_command_size(const void *command)
  133. {
  134. const size_t command_size_offset = 2;
  135. return get_unaligned_be32(command + command_size_offset);
  136. }
  137. u32 tpm_return_code(const void *response)
  138. {
  139. const size_t return_code_offset = 6;
  140. return get_unaligned_be32(response + return_code_offset);
  141. }
  142. u32 tpm_sendrecv_command(struct udevice *dev, const void *command,
  143. void *response, size_t *size_ptr)
  144. {
  145. int err, ret;
  146. u8 response_buffer[COMMAND_BUFFER_SIZE];
  147. size_t response_length;
  148. int i;
  149. if (response) {
  150. response_length = *size_ptr;
  151. } else {
  152. response = response_buffer;
  153. response_length = sizeof(response_buffer);
  154. }
  155. err = tpm_xfer(dev, command, tpm_command_size(command),
  156. response, &response_length);
  157. if (err < 0)
  158. return err;
  159. if (size_ptr)
  160. *size_ptr = response_length;
  161. ret = tpm_return_code(response);
  162. log_debug("TPM response [ret:%d]: ", ret);
  163. for (i = 0; i < response_length; i++)
  164. log_debug("%02x ", ((u8 *)response)[i]);
  165. log_debug("\n");
  166. return ret;
  167. }
  168. int tpm_init(struct udevice *dev)
  169. {
  170. return tpm_open(dev);
  171. }