1 /* 2 * Copyright 2019 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 #include <linux/pci.h> 24 25 #include "amdgpu.h" 26 #include "amdgpu_i2c.h" 27 #include "smu_v11_0_i2c.h" 28 #include "atom.h" 29 #include "amdgpu_fru_eeprom.h" 30 #include "amdgpu_eeprom.h" 31 32 #define FRU_EEPROM_MADDR_6 0x60000 33 #define FRU_EEPROM_MADDR_8 0x80000 34 35 static bool is_fru_eeprom_supported(struct amdgpu_device *adev, u32 *fru_addr) 36 { 37 /* Only server cards have the FRU EEPROM 38 * TODO: See if we can figure this out dynamically instead of 39 * having to parse VBIOS versions. 40 */ 41 struct atom_context *atom_ctx = adev->mode_info.atom_context; 42 43 /* The i2c access is blocked on VF 44 * TODO: Need other way to get the info 45 */ 46 if (amdgpu_sriov_vf(adev)) 47 return false; 48 49 /* The default I2C EEPROM address of the FRU. 50 */ 51 if (fru_addr) 52 *fru_addr = FRU_EEPROM_MADDR_8; 53 54 /* VBIOS is of the format ###-DXXXYYYY-##. For SKU identification, 55 * we can use just the "DXXX" portion. If there were more models, we 56 * could convert the 3 characters to a hex integer and use a switch 57 * for ease/speed/readability. For now, 2 string comparisons are 58 * reasonable and not too expensive 59 */ 60 switch (adev->asic_type) { 61 case CHIP_VEGA20: 62 /* D161 and D163 are the VG20 server SKUs */ 63 if (strnstr(atom_ctx->vbios_pn, "D161", 64 sizeof(atom_ctx->vbios_pn)) || 65 strnstr(atom_ctx->vbios_pn, "D163", 66 sizeof(atom_ctx->vbios_pn))) { 67 if (fru_addr) 68 *fru_addr = FRU_EEPROM_MADDR_6; 69 return true; 70 } else { 71 return false; 72 } 73 case CHIP_ALDEBARAN: 74 /* All Aldebaran SKUs have an FRU */ 75 if (!strnstr(atom_ctx->vbios_pn, "D673", 76 sizeof(atom_ctx->vbios_pn))) 77 if (fru_addr) 78 *fru_addr = FRU_EEPROM_MADDR_6; 79 return true; 80 case CHIP_SIENNA_CICHLID: 81 if (strnstr(atom_ctx->vbios_pn, "D603", 82 sizeof(atom_ctx->vbios_pn))) { 83 if (strnstr(atom_ctx->vbios_pn, "D603GLXE", 84 sizeof(atom_ctx->vbios_pn))) { 85 return false; 86 } 87 88 if (fru_addr) 89 *fru_addr = FRU_EEPROM_MADDR_6; 90 return true; 91 92 } else { 93 return false; 94 } 95 default: 96 return false; 97 } 98 } 99 100 int amdgpu_fru_get_product_info(struct amdgpu_device *adev) 101 { 102 unsigned char buf[8], *pia; 103 u32 addr, fru_addr; 104 int size, len; 105 u8 csum; 106 107 if (!is_fru_eeprom_supported(adev, &fru_addr)) 108 return 0; 109 110 /* If algo exists, it means that the i2c_adapter's initialized */ 111 if (!adev->pm.fru_eeprom_i2c_bus || !adev->pm.fru_eeprom_i2c_bus->algo) { 112 DRM_WARN("Cannot access FRU, EEPROM accessor not initialized"); 113 return -ENODEV; 114 } 115 116 /* Read the IPMI Common header */ 117 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, fru_addr, buf, 118 sizeof(buf)); 119 if (len != 8) { 120 DRM_ERROR("Couldn't read the IPMI Common Header: %d", len); 121 return len < 0 ? len : -EIO; 122 } 123 124 if (buf[0] != 1) { 125 DRM_ERROR("Bad IPMI Common Header version: 0x%02x", buf[0]); 126 return -EIO; 127 } 128 129 for (csum = 0; len > 0; len--) 130 csum += buf[len - 1]; 131 if (csum) { 132 DRM_ERROR("Bad IPMI Common Header checksum: 0x%02x", csum); 133 return -EIO; 134 } 135 136 /* Get the offset to the Product Info Area (PIA). */ 137 addr = buf[4] * 8; 138 if (!addr) 139 return 0; 140 141 /* Get the absolute address to the PIA. */ 142 addr += fru_addr; 143 144 /* Read the header of the PIA. */ 145 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, addr, buf, 3); 146 if (len != 3) { 147 DRM_ERROR("Couldn't read the Product Info Area header: %d", len); 148 return len < 0 ? len : -EIO; 149 } 150 151 if (buf[0] != 1) { 152 DRM_ERROR("Bad IPMI Product Info Area version: 0x%02x", buf[0]); 153 return -EIO; 154 } 155 156 size = buf[1] * 8; 157 pia = kzalloc(size, GFP_KERNEL); 158 if (!pia) 159 return -ENOMEM; 160 161 /* Read the whole PIA. */ 162 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, addr, pia, size); 163 if (len != size) { 164 kfree(pia); 165 DRM_ERROR("Couldn't read the Product Info Area: %d", len); 166 return len < 0 ? len : -EIO; 167 } 168 169 for (csum = 0; size > 0; size--) 170 csum += pia[size - 1]; 171 if (csum) { 172 DRM_ERROR("Bad Product Info Area checksum: 0x%02x", csum); 173 return -EIO; 174 } 175 176 /* Now extract useful information from the PIA. 177 * 178 * Skip the Manufacturer Name at [3] and go directly to 179 * the Product Name field. 180 */ 181 addr = 3 + 1 + (pia[3] & 0x3F); 182 if (addr + 1 >= len) 183 goto Out; 184 memcpy(adev->product_name, pia + addr + 1, 185 min_t(size_t, 186 sizeof(adev->product_name), 187 pia[addr] & 0x3F)); 188 adev->product_name[sizeof(adev->product_name) - 1] = '\0'; 189 190 /* Go to the Product Part/Model Number field. */ 191 addr += 1 + (pia[addr] & 0x3F); 192 if (addr + 1 >= len) 193 goto Out; 194 memcpy(adev->product_number, pia + addr + 1, 195 min_t(size_t, 196 sizeof(adev->product_number), 197 pia[addr] & 0x3F)); 198 adev->product_number[sizeof(adev->product_number) - 1] = '\0'; 199 200 /* Go to the Product Version field. */ 201 addr += 1 + (pia[addr] & 0x3F); 202 203 /* Go to the Product Serial Number field. */ 204 addr += 1 + (pia[addr] & 0x3F); 205 if (addr + 1 >= len) 206 goto Out; 207 memcpy(adev->serial, pia + addr + 1, min_t(size_t, 208 sizeof(adev->serial), 209 pia[addr] & 0x3F)); 210 adev->serial[sizeof(adev->serial) - 1] = '\0'; 211 Out: 212 kfree(pia); 213 return 0; 214 } 215