iotrace.c 3.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2014 Google, Inc.
  4. */
  5. #define IOTRACE_IMPL
  6. #include <common.h>
  7. #include <mapmem.h>
  8. #include <time.h>
  9. #include <asm/io.h>
  10. #include <u-boot/crc.h>
  11. DECLARE_GLOBAL_DATA_PTR;
  12. /**
  13. * struct iotrace - current trace status and checksum
  14. *
  15. * @start: Start address of iotrace buffer
  16. * @size: Actual size of iotrace buffer in bytes
  17. * @needed_size: Needed of iotrace buffer in bytes
  18. * @offset: Current write offset into iotrace buffer
  19. * @region_start: Address of IO region to trace
  20. * @region_size: Size of region to trace. if 0 will trace all address space
  21. * @crc32: Current value of CRC chceksum of trace records
  22. * @enabled: true if enabled, false if disabled
  23. */
  24. static struct iotrace {
  25. ulong start;
  26. ulong size;
  27. ulong needed_size;
  28. ulong offset;
  29. ulong region_start;
  30. ulong region_size;
  31. u32 crc32;
  32. bool enabled;
  33. } iotrace;
  34. static void add_record(int flags, const void *ptr, ulong value)
  35. {
  36. struct iotrace_record srec, *rec = &srec;
  37. /*
  38. * We don't support iotrace before relocation. Since the trace buffer
  39. * is set up by a command, it can't be enabled at present. To change
  40. * this we would need to set the iotrace buffer at build-time. See
  41. * lib/trace.c for how this might be done if you are interested.
  42. */
  43. if (!(gd->flags & GD_FLG_RELOC) || !iotrace.enabled)
  44. return;
  45. if (iotrace.region_size)
  46. if ((ulong)ptr < iotrace.region_start ||
  47. (ulong)ptr > iotrace.region_start + iotrace.region_size)
  48. return;
  49. /* Store it if there is room */
  50. if (iotrace.offset + sizeof(*rec) < iotrace.size) {
  51. rec = (struct iotrace_record *)map_sysmem(
  52. iotrace.start + iotrace.offset,
  53. sizeof(value));
  54. } else {
  55. WARN_ONCE(1, "WARNING: iotrace buffer exhausted, please check needed length using \"iotrace stats\"\n");
  56. iotrace.needed_size += sizeof(struct iotrace_record);
  57. return;
  58. }
  59. rec->timestamp = timer_get_us();
  60. rec->flags = flags;
  61. rec->addr = map_to_sysmem(ptr);
  62. rec->value = value;
  63. /* Update our checksum */
  64. iotrace.crc32 = crc32(iotrace.crc32, (unsigned char *)rec,
  65. sizeof(*rec));
  66. iotrace.needed_size += sizeof(struct iotrace_record);
  67. iotrace.offset += sizeof(struct iotrace_record);
  68. }
  69. u32 iotrace_readl(const void *ptr)
  70. {
  71. u32 v;
  72. v = readl(ptr);
  73. add_record(IOT_32 | IOT_READ, ptr, v);
  74. return v;
  75. }
  76. void iotrace_writel(ulong value, void *ptr)
  77. {
  78. add_record(IOT_32 | IOT_WRITE, ptr, value);
  79. writel(value, ptr);
  80. }
  81. u16 iotrace_readw(const void *ptr)
  82. {
  83. u32 v;
  84. v = readw(ptr);
  85. add_record(IOT_16 | IOT_READ, ptr, v);
  86. return v;
  87. }
  88. void iotrace_writew(ulong value, void *ptr)
  89. {
  90. add_record(IOT_16 | IOT_WRITE, ptr, value);
  91. writew(value, ptr);
  92. }
  93. u8 iotrace_readb(const void *ptr)
  94. {
  95. u32 v;
  96. v = readb(ptr);
  97. add_record(IOT_8 | IOT_READ, ptr, v);
  98. return v;
  99. }
  100. void iotrace_writeb(ulong value, void *ptr)
  101. {
  102. add_record(IOT_8 | IOT_WRITE, ptr, value);
  103. writeb(value, ptr);
  104. }
  105. void iotrace_reset_checksum(void)
  106. {
  107. iotrace.crc32 = 0;
  108. }
  109. u32 iotrace_get_checksum(void)
  110. {
  111. return iotrace.crc32;
  112. }
  113. void iotrace_set_region(ulong start, ulong size)
  114. {
  115. iotrace.region_start = start;
  116. iotrace.region_size = size;
  117. }
  118. void iotrace_reset_region(void)
  119. {
  120. iotrace.region_start = 0;
  121. iotrace.region_size = 0;
  122. }
  123. void iotrace_get_region(ulong *start, ulong *size)
  124. {
  125. *start = iotrace.region_start;
  126. *size = iotrace.region_size;
  127. }
  128. void iotrace_set_enabled(int enable)
  129. {
  130. iotrace.enabled = enable;
  131. }
  132. int iotrace_get_enabled(void)
  133. {
  134. return iotrace.enabled;
  135. }
  136. void iotrace_set_buffer(ulong start, ulong size)
  137. {
  138. iotrace.start = start;
  139. iotrace.size = size;
  140. iotrace.offset = 0;
  141. iotrace.crc32 = 0;
  142. }
  143. void iotrace_get_buffer(ulong *start, ulong *size, ulong *needed_size, ulong *offset, ulong *count)
  144. {
  145. *start = iotrace.start;
  146. *size = iotrace.size;
  147. *needed_size = iotrace.needed_size;
  148. *offset = iotrace.offset;
  149. *count = iotrace.offset / sizeof(struct iotrace_record);
  150. }