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
 35static 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
 99int 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';
210Out:
211	kfree(pia);
212	return 0;
213}