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_version, "D161", 64 sizeof(atom_ctx->vbios_version)) || 65 strnstr(atom_ctx->vbios_version, "D163", 66 sizeof(atom_ctx->vbios_version))) { 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_version, "D673", 76 sizeof(atom_ctx->vbios_version))) 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_version, "D603", 82 sizeof(atom_ctx->vbios_version))) { 83 if (strnstr(atom_ctx->vbios_version, "D603GLXE", 84 sizeof(atom_ctx->vbios_version))) { 85 return false; 86 } else { 87 if (fru_addr) 88 *fru_addr = FRU_EEPROM_MADDR_6; 89 return true; 90 } 91 } else { 92 return false; 93 } 94 default: 95 return false; 96 } 97 } 98 99 int amdgpu_fru_get_product_info(struct amdgpu_device *adev) 100 { 101 unsigned char buf[8], *pia; 102 u32 addr, fru_addr; 103 int size, len; 104 u8 csum; 105 106 if (!is_fru_eeprom_supported(adev, &fru_addr)) 107 return 0; 108 109 /* If algo exists, it means that the i2c_adapter's initialized */ 110 if (!adev->pm.fru_eeprom_i2c_bus || !adev->pm.fru_eeprom_i2c_bus->algo) { 111 DRM_WARN("Cannot access FRU, EEPROM accessor not initialized"); 112 return -ENODEV; 113 } 114 115 /* Read the IPMI Common header */ 116 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, fru_addr, buf, 117 sizeof(buf)); 118 if (len != 8) { 119 DRM_ERROR("Couldn't read the IPMI Common Header: %d", len); 120 return len < 0 ? len : -EIO; 121 } 122 123 if (buf[0] != 1) { 124 DRM_ERROR("Bad IPMI Common Header version: 0x%02x", buf[0]); 125 return -EIO; 126 } 127 128 for (csum = 0; len > 0; len--) 129 csum += buf[len - 1]; 130 if (csum) { 131 DRM_ERROR("Bad IPMI Common Header checksum: 0x%02x", csum); 132 return -EIO; 133 } 134 135 /* Get the offset to the Product Info Area (PIA). */ 136 addr = buf[4] * 8; 137 if (!addr) 138 return 0; 139 140 /* Get the absolute address to the PIA. */ 141 addr += fru_addr; 142 143 /* Read the header of the PIA. */ 144 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, addr, buf, 3); 145 if (len != 3) { 146 DRM_ERROR("Couldn't read the Product Info Area header: %d", len); 147 return len < 0 ? len : -EIO; 148 } 149 150 if (buf[0] != 1) { 151 DRM_ERROR("Bad IPMI Product Info Area version: 0x%02x", buf[0]); 152 return -EIO; 153 } 154 155 size = buf[1] * 8; 156 pia = kzalloc(size, GFP_KERNEL); 157 if (!pia) 158 return -ENOMEM; 159 160 /* Read the whole PIA. */ 161 len = amdgpu_eeprom_read(adev->pm.fru_eeprom_i2c_bus, addr, pia, size); 162 if (len != size) { 163 kfree(pia); 164 DRM_ERROR("Couldn't read the Product Info Area: %d", len); 165 return len < 0 ? len : -EIO; 166 } 167 168 for (csum = 0; size > 0; size--) 169 csum += pia[size - 1]; 170 if (csum) { 171 DRM_ERROR("Bad Product Info Area checksum: 0x%02x", csum); 172 return -EIO; 173 } 174 175 /* Now extract useful information from the PIA. 176 * 177 * Skip the Manufacturer Name at [3] and go directly to 178 * the Product Name field. 179 */ 180 addr = 3 + 1 + (pia[3] & 0x3F); 181 if (addr + 1 >= len) 182 goto Out; 183 memcpy(adev->product_name, pia + addr + 1, 184 min_t(size_t, 185 sizeof(adev->product_name), 186 pia[addr] & 0x3F)); 187 adev->product_name[sizeof(adev->product_name) - 1] = '\0'; 188 189 /* Go to the Product Part/Model Number field. */ 190 addr += 1 + (pia[addr] & 0x3F); 191 if (addr + 1 >= len) 192 goto Out; 193 memcpy(adev->product_number, pia + addr + 1, 194 min_t(size_t, 195 sizeof(adev->product_number), 196 pia[addr] & 0x3F)); 197 adev->product_number[sizeof(adev->product_number) - 1] = '\0'; 198 199 /* Go to the Product Version field. */ 200 addr += 1 + (pia[addr] & 0x3F); 201 202 /* Go to the Product Serial Number field. */ 203 addr += 1 + (pia[addr] & 0x3F); 204 if (addr + 1 >= len) 205 goto Out; 206 memcpy(adev->serial, pia + addr + 1, min_t(size_t, 207 sizeof(adev->serial), 208 pia[addr] & 0x3F)); 209 adev->serial[sizeof(adev->serial) - 1] = '\0'; 210 Out: 211 kfree(pia); 212 return 0; 213 } 214