util/inteltool/pcr.c

   1 /* inteltool - dump all registers on an Intel CPU + chipset based system */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <stdint.h>
   7 #include <stdbool.h>
   8 #include <inttypes.h>
   9 #include <assert.h>
  10 #include "pcr.h"
  11
  12 const uint8_t *sbbar = NULL;
  13
  14 uint32_t read_pcr32(const uint8_t port, const uint16_t offset)
  15 {
  16         assert(sbbar);
  17         return *(const uint32_t *)(sbbar + (port << 16) + offset);
  18 }
  19
  20 static void print_pcr_port(const uint8_t port)
  21 {
  22         size_t i = 0;
  23         uint32_t last_reg = 0;
  24         bool last_printed = true;
  25
  26         printf("PCR port offset: 0x%06zx\n\n", (size_t)port << 16);
  27
  28         for (i = 0; i < PCR_PORT_SIZE; i += 4) {
  29                 const uint32_t reg = read_pcr32(port, i);
  30                 const bool rep = i && last_reg == reg;
  31                 if (!rep) {
  32                         if (!last_printed)
  33                                 printf("*\n");
  34                         printf("0x%04zx: 0x%08"PRIx32"\n", i, reg);
  35                 }
  36
  37                 last_reg = reg;
  38                 last_printed = !rep;
  39         }
  40         if (!last_printed)
  41                 printf("*\n");
  42 }
  43
  44 void print_pcr_ports(struct pci_dev *const sb,
  45                      const uint8_t *const ports, const size_t count)
  46 {
  47         size_t i;
  48
  49         pcr_init(sb);
  50
  51         for (i = 0; i < count; ++i) {
  52                 printf("\n========== PCR 0x%02x ==========\n\n", ports[i]);
  53                 print_pcr_port(ports[i]);
  54         }
  55 }
  56
  57 void pcr_init(struct pci_dev *const sb)
  58 {
  59         bool error_exit = false;
  60         bool p2sb_revealed = false;
  61         struct pci_dev *p2sb;
  62         bool use_p2sb = true;
  63         pciaddr_t sbbar_phys;
  64
  65         if (sbbar)
  66                 return;
  67
  68         switch (sb->device_id) {
  69         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_PRE:
  70         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_PRE:
  71         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_BASE_SKL:
  72         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_Y_PREM_SKL:
  73         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_PREM_SKL:
  74         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_BASE_KBL:
  75         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_PREM_KBL:
  76         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_Y_PREM_KBL:
  77         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_IHDCP_BASE:
  78         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_U_IHDCP_PREM:
  79         case PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_Y_IHDCP_PREM:
  80         case PCI_DEVICE_ID_INTEL_H110:
  81         case PCI_DEVICE_ID_INTEL_H170:
  82         case PCI_DEVICE_ID_INTEL_Z170:
  83         case PCI_DEVICE_ID_INTEL_Q170:
  84         case PCI_DEVICE_ID_INTEL_Q150:
  85         case PCI_DEVICE_ID_INTEL_B150:
  86         case PCI_DEVICE_ID_INTEL_C236:
  87         case PCI_DEVICE_ID_INTEL_C232:
  88         case PCI_DEVICE_ID_INTEL_QM170:
  89         case PCI_DEVICE_ID_INTEL_HM170:
  90         case PCI_DEVICE_ID_INTEL_CM236:
  91         case PCI_DEVICE_ID_INTEL_HM175:
  92         case PCI_DEVICE_ID_INTEL_QM175:
  93         case PCI_DEVICE_ID_INTEL_CM238:
  94         case PCI_DEVICE_ID_INTEL_C621:
  95         case PCI_DEVICE_ID_INTEL_C621A:
  96         case PCI_DEVICE_ID_INTEL_C622:
  97         case PCI_DEVICE_ID_INTEL_C624:
  98         case PCI_DEVICE_ID_INTEL_C625:
  99         case PCI_DEVICE_ID_INTEL_C626:
 100         case PCI_DEVICE_ID_INTEL_C627:
 101         case PCI_DEVICE_ID_INTEL_C628:
 102         case PCI_DEVICE_ID_INTEL_C629:
 103         case PCI_DEVICE_ID_INTEL_C624_SUPER:
 104         case PCI_DEVICE_ID_INTEL_C627_SUPER_1:
 105         case PCI_DEVICE_ID_INTEL_C621_SUPER:
 106         case PCI_DEVICE_ID_INTEL_C627_SUPER_2:
 107         case PCI_DEVICE_ID_INTEL_C628_SUPER:
 108         case PCI_DEVICE_ID_INTEL_DNV_LPC:
 109                 p2sb = pci_get_dev(sb->access, 0, 0, 0x1f, 1);
 110                 break;
 111         case PCI_DEVICE_ID_INTEL_APL_LPC:
 112                 p2sb = pci_get_dev(sb->access, 0, 0, 0x0d, 0);
 113                 break;
 114         case PCI_DEVICE_ID_INTEL_H310:
 115         case PCI_DEVICE_ID_INTEL_H370:
 116         case PCI_DEVICE_ID_INTEL_Z390:
 117         case PCI_DEVICE_ID_INTEL_Q370:
 118         case PCI_DEVICE_ID_INTEL_B360:
 119         case PCI_DEVICE_ID_INTEL_C246:
 120         case PCI_DEVICE_ID_INTEL_C242:
 121         case PCI_DEVICE_ID_INTEL_QM370:
 122         case PCI_DEVICE_ID_INTEL_HM370:
 123         case PCI_DEVICE_ID_INTEL_CM246:
 124         case PCI_DEVICE_ID_INTEL_CANNONPOINT_LP_U_PREM:
 125         case PCI_DEVICE_ID_INTEL_COMETPOINT_LP_U_PREM:
 126         case PCI_DEVICE_ID_INTEL_COMETPOINT_LP_U_BASE:
 127         case PCI_DEVICE_ID_INTEL_ICELAKE_LP_U:
 128                 sbbar_phys = 0xfd000000;
 129                 use_p2sb = false;
 130                 break;
 131         default:
 132                 perror("Unknown LPC device.");
 133                 exit(1);
 134         }
 135
 136         if (use_p2sb) {
 137                 if (!p2sb) {
 138                         perror("Can't allocate device node for P2SB.");
 139                         exit(1);
 140                 }
 141
 142                 /* do not fill bases here, libpci refuses to refill later */
 143                 pci_fill_info(p2sb, PCI_FILL_IDENT);
 144                 if (p2sb->vendor_id == 0xffff && p2sb->device_id == 0xffff) {
 145                         printf("Trying to reveal Primary to Sideband Bridge "
 146                                "(P2SB),\nlet's hope the OS doesn't mind... ");
 147                         /* Do not use pci_write_long(). Bytes
 148                            surrounding 0xe0 must be maintained. */
 149                         pci_write_byte(p2sb, 0xe0 + 1, 0);
 150
 151                         pci_fill_info(p2sb, PCI_FILL_IDENT | PCI_FILL_RESCAN);
 152                         if (p2sb->vendor_id != 0xffff ||
 153                             p2sb->device_id != 0xffff) {
 154                                 printf("done.\n");
 155                                 p2sb_revealed = true;
 156                         } else {
 157                                 printf("failed.\n");
 158                                 exit(1);
 159                         }
 160                 }
 161                 pci_fill_info(p2sb, PCI_FILL_BASES | PCI_FILL_CLASS);
 162
 163                 sbbar_phys = p2sb->base_addr[0] & ~0xfULL;
 164         }
 165
 166         printf("SBREG_BAR = 0x%08"PRIx64" (MEM)\n\n", (uint64_t)sbbar_phys);
 167         sbbar = map_physical(sbbar_phys, SBBAR_SIZE);
 168         if (sbbar == NULL) {
 169                 perror("Error mapping SBREG_BAR");
 170                 error_exit = true;
 171         }
 172
 173         if (use_p2sb) {
 174                 if (p2sb_revealed) {
 175                         printf("Hiding Primary to Sideband Bridge (P2SB).\n");
 176                         pci_write_byte(p2sb, 0xe0 + 1, 1);
 177                 }
 178                 pci_free_dev(p2sb);
 179         }
 180
 181         if (error_exit)
 182                 exit(1);
 183 }
 184
 185 void pcr_cleanup(void)
 186 {
 187         if (sbbar)
 188                 unmap_physical((void *)sbbar, SBBAR_SIZE);
 189 }