path: root/src/drivers/ipmi/ipmi_fru.c

/* SPDX-License-Identifier: GPL-2.0-only */

#include <console/console.h>
#include <string.h>
#include <delay.h>
#include <stdlib.h>

#include "ipmi_if.h"
#include "ipmi_ops.h"

#define MAX_FRU_BUSY_RETRY 5
#define READ_FRU_DATA_RETRY_INTERVAL_MS 30 /* From IPMI spec v2.0 rev 1.1 */
#define OFFSET_LENGTH_MULTIPLIER 8 /* offsets/lengths are multiples of 8 */
#define NUM_DATA_BYTES(t) (t & 0x3f) /* Encoded in type/length byte */
#define FRU_END_OF_FIELDS 0xc1 /* type/length byte encoded to indicate no more info fields */

static enum cb_err ipmi_read_fru(const int port, struct ipmi_read_fru_data_req *req,
			uint8_t *fru_data)
{
	int ret;
	uint8_t total_size;
	uint16_t offset = 0;
	struct ipmi_read_fru_data_rsp rsp;
	int retry_count = 0;

	if (req == NULL || fru_data == NULL) {
		printk(BIOS_ERR, "%s failed, null pointer parameter\n",
			 __func__);
		return CB_ERR;
	}

	total_size = req->count;
	do {
		if (req->count > CONFIG_IPMI_FRU_SINGLE_RW_SZ)
			req->count = CONFIG_IPMI_FRU_SINGLE_RW_SZ;

		while (retry_count <= MAX_FRU_BUSY_RETRY) {
			ret = ipmi_message(port, IPMI_NETFN_STORAGE, 0x0,
					IPMI_READ_FRU_DATA, (const unsigned char *)req,
					sizeof(*req), (unsigned char *)&rsp, sizeof(rsp));
			if (rsp.resp.completion_code == 0x81) {
				/* Device is busy */
				if (retry_count == MAX_FRU_BUSY_RETRY) {
					printk(BIOS_ERR, "IPMI: %s command failed, "
						"device busy timeout\n", __func__);
					return CB_ERR;
				}
				printk(BIOS_ERR, "IPMI: FRU device is busy, "
					"retry count:%d\n", retry_count);
				retry_count++;
				mdelay(READ_FRU_DATA_RETRY_INTERVAL_MS);
			} else if (ret < sizeof(struct ipmi_rsp) || rsp.resp.completion_code) {
				printk(BIOS_ERR, "IPMI: %s command failed (ret=%d resp=0x%x)\n",
					__func__, ret, rsp.resp.completion_code);
				return CB_ERR;
			}
			break;
		}
		retry_count = 0;
		memcpy(fru_data + offset, rsp.data, rsp.count);
		offset += rsp.count;
		total_size -= rsp.count;
		req->fru_offset += rsp.count;
		req->count = total_size;
	} while (total_size > 0);

	return CB_SUCCESS;
}

/* data: data to check, offset: offset to checksum. */
static uint8_t checksum(uint8_t *data, int offset)
{
	uint8_t c = 0;
	for (; offset > 0; offset--, data++)
		c += *data;
	return -c;
}

static uint8_t data2str(const uint8_t *frudata, char *stringdata, uint8_t length)
{
	uint8_t type;

	/* bit[7:6] is the type code. */
	type = ((frudata[0] & 0xc0) >> 6);
	if (type != ASCII_8BIT) {
		printk(BIOS_ERR, "%s typecode %d is unsupported, FRU string only "
			"supports 8-bit ASCII + Latin 1 for now.\n", __func__, type);
		return 0;
	}
	/* In the spec the string data is always the next byte to the type/length byte. */
	memcpy(stringdata, frudata + 1, length);
	stringdata[length] = '\0';
	return length;
}

/*
 * Read data string from data_ptr and store it to string, return the
 * length of the string or 0 when it's failed.
 */
static int read_data_string(const uint8_t *data_ptr, char **string)
{
	uint8_t length;

	length = NUM_DATA_BYTES(data_ptr[0]);
	if (length == 0) {
		printk(BIOS_DEBUG, "%s:%d - failed due to length is zero\n", __func__,
			__LINE__);
		return 0;
	}

	*string = malloc(length + 1);
	if (!*string) {
		printk(BIOS_ERR, "%s failed to malloc %d bytes for string data.\n", __func__,
			length + 1);
		return 0;
	}
	if (!data2str((const uint8_t *)data_ptr, *string, length)) {
		printk(BIOS_ERR, "%s:%d - data2str failed\n", __func__, __LINE__);
		free(*string);
		return 0;
	}

	return length;
}

static enum cb_err read_fru_chassis_info_area(const int port, const uint8_t id,
				uint8_t offset, struct fru_chassis_info *info)
{
	uint8_t length;
	struct ipmi_read_fru_data_req req;
	uint8_t *data_ptr, *end, *custom_data_ptr;
	int ret = CB_SUCCESS;

	if (!offset)
		return CB_ERR;

	offset = offset * OFFSET_LENGTH_MULTIPLIER;
	req.fru_device_id = id;
	/* Read Chassis Info Area length first. */
	req.fru_offset = offset + 1;
	req.count = sizeof(length);
	if (ipmi_read_fru(port, &req, &length) != CB_SUCCESS || !length) {
		printk(BIOS_ERR, "%s failed, length: %d\n", __func__, length);
		return CB_ERR;
	}
	length = length * OFFSET_LENGTH_MULTIPLIER;
	data_ptr = (uint8_t *)malloc(length);
	if (!data_ptr) {
		printk(BIOS_ERR, "malloc %d bytes for chassis info failed\n", length);
		return CB_ERR;
	}
	end = data_ptr + length;
	/* Read Chassis Info Area data. */
	req.fru_offset = offset;
	req.count = length;
	if (ipmi_read_fru(port, &req, data_ptr) != CB_SUCCESS) {
		printk(BIOS_ERR, "%s failed to read fru\n", __func__);
		ret = CB_ERR;
		goto out;
	}
	if (checksum(data_ptr, length)) {
		printk(BIOS_ERR, "Bad FRU chassis info checksum.\n");
		ret = CB_ERR;
		goto out;
	}
	/* Read chassis type. */
	info->chassis_type = data_ptr[CHASSIS_TYPE_OFFSET];

	printk(BIOS_DEBUG, "Read chassis part number string.\n");
	length = read_data_string(data_ptr + CHASSIS_TYPE_OFFSET + 1,
		&info->chassis_partnumber);

	printk(BIOS_DEBUG, "Read chassis serial number string.\n");
	data_ptr += CHASSIS_TYPE_OFFSET + 1 + length + 1;
	length = read_data_string(data_ptr, &info->serial_number);

	printk(BIOS_DEBUG, "Read custom chassis info fields.\n");
	data_ptr += length + 1;
	/* Check how many valid custom fields first. */
	info->custom_count = 0;
	custom_data_ptr = data_ptr;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0)
			info->custom_count++;
		data_ptr += length + 1;
	}
	if (!info->custom_count)
		goto out;

	info->chassis_custom = malloc(info->custom_count * sizeof(char *));
	if (!info->chassis_custom) {
		printk(BIOS_ERR, "%s failed to malloc %zu bytes for "
			"chassis custom data array.\n", __func__,
			info->custom_count * sizeof(char *));
		ret = CB_ERR;
		goto out;
	}

	/* Start reading custom chassis data. */
	data_ptr = custom_data_ptr;
	int count = 0;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0) {
			length = read_data_string(data_ptr, info->chassis_custom + count);
			count++;
		}
		data_ptr += length + 1;
	}

out:
	free(data_ptr);
	return ret;
}

static enum cb_err read_fru_board_info_area(const int port, const uint8_t id,
				uint8_t offset, struct fru_board_info *info)
{
	uint8_t length;
	struct ipmi_read_fru_data_req req;
	uint8_t *data_ptr, *end, *custom_data_ptr;
	int ret = CB_SUCCESS;

	if (!offset)
		return CB_ERR;

	offset = offset * OFFSET_LENGTH_MULTIPLIER;
	req.fru_device_id = id;
	/* Read Board Info Area length first. */
	req.fru_offset = offset + 1;
	req.count = sizeof(length);
	if (ipmi_read_fru(port, &req, &length) != CB_SUCCESS || !length) {
		printk(BIOS_ERR, "%s failed, length: %d\n", __func__, length);
		return CB_ERR;
	}
	length = length * OFFSET_LENGTH_MULTIPLIER;
	data_ptr = (uint8_t *)malloc(length);
	if (!data_ptr) {
		printk(BIOS_ERR, "malloc %d bytes for board info failed\n", length);
		return CB_ERR;
	}
	end = data_ptr + length;
	/* Read Board Info Area data. */
	req.fru_offset = offset;
	req.count = length;
	if (ipmi_read_fru(port, &req, data_ptr) != CB_SUCCESS) {
		printk(BIOS_ERR, "%s failed to read fru\n", __func__);
		ret = CB_ERR;
		goto out;
	}
	if (checksum(data_ptr, length)) {
		printk(BIOS_ERR, "Bad FRU board info checksum.\n");
		ret = CB_ERR;
		goto out;
	}
	printk(BIOS_DEBUG, "Read board manufacturer string\n");
	length = read_data_string(data_ptr + BOARD_MAN_TYPE_LEN_OFFSET,
		&info->manufacturer);

	printk(BIOS_DEBUG, "Read board product name string.\n");
	data_ptr += BOARD_MAN_TYPE_LEN_OFFSET + length + 1;
	length = read_data_string(data_ptr, &info->product_name);

	printk(BIOS_DEBUG, "Read board serial number string.\n");
	data_ptr += length + 1;
	length = read_data_string(data_ptr, &info->serial_number);

	printk(BIOS_DEBUG, "Read board part number string.\n");
	data_ptr += length + 1;
	length = read_data_string(data_ptr, &info->part_number);

	printk(BIOS_DEBUG, "Read board FRU file ID string.\n");
	data_ptr += length + 1;
	length = read_data_string(data_ptr, &info->fru_file_id);

	/* Check how many valid custom fields first. */
	data_ptr += length + 1;
	info->custom_count = 0;
	custom_data_ptr = data_ptr;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0)
			info->custom_count++;
		data_ptr += length + 1;
	}
	if (!info->custom_count)
		goto out;

	info->board_custom = malloc(info->custom_count * sizeof(char *));
	if (!info->board_custom) {
		printk(BIOS_ERR, "%s failed to malloc %zu bytes for "
			"board custom data array.\n", __func__,
			info->custom_count * sizeof(char *));
		ret = CB_ERR;
		goto out;
	}

	/* Start reading custom board data. */
	data_ptr = custom_data_ptr;
	int count = 0;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0) {
			length = read_data_string(data_ptr, info->board_custom + count);
			count++;
		}
		data_ptr += length + 1;
	}

out:
	free(data_ptr);
	return ret;
}

static enum cb_err read_fru_product_info_area(const int port, const uint8_t id,
				uint8_t offset, struct fru_product_info *info)
{
	uint8_t length;
	struct ipmi_read_fru_data_req req;
	uint8_t *data_ptr, *end, *custom_data_ptr;
	int ret = CB_SUCCESS;

	if (!offset)
		return CB_ERR;

	offset = offset * OFFSET_LENGTH_MULTIPLIER;
	req.fru_device_id = id;
	/* Read Product Info Area length first. */
	req.fru_offset = offset + 1;
	req.count = sizeof(length);
	if (ipmi_read_fru(port, &req, &length) != CB_SUCCESS || !length) {
		printk(BIOS_ERR, "%s failed, length: %d\n", __func__, length);
		return CB_ERR;
	}
	length = length * OFFSET_LENGTH_MULTIPLIER;
	data_ptr = (uint8_t *)malloc(length);
	if (!data_ptr) {
		printk(BIOS_ERR, "malloc %d bytes for product info failed\n", length);
		return CB_ERR;
	}
	end = data_ptr + length;
	/* Read Product Info Area data. */
	req.fru_offset = offset;
	req.count = length;
	if (ipmi_read_fru(port, &req, data_ptr) != CB_SUCCESS) {
		printk(BIOS_ERR, "%s failed to read fru\n", __func__);
		ret = CB_ERR;
		goto out;
	}
	if (checksum(data_ptr, length)) {
		printk(BIOS_ERR, "Bad FRU product info checksum.\n");
		ret = CB_ERR;
		goto out;
	}
	printk(BIOS_DEBUG, "Read product manufacturer string.\n");
	length = read_data_string(data_ptr + PRODUCT_MAN_TYPE_LEN_OFFSET,
		&info->manufacturer);

	data_ptr += PRODUCT_MAN_TYPE_LEN_OFFSET + length + 1;
	printk(BIOS_DEBUG, "Read product_name string.\n");
	length = read_data_string(data_ptr, &info->product_name);

	data_ptr += length + 1;
	printk(BIOS_DEBUG, "Read product part/model number.\n");
	length = read_data_string(data_ptr, &info->product_partnumber);

	data_ptr += length + 1;
	printk(BIOS_DEBUG, "Read product version string.\n");
	length = read_data_string(data_ptr, &info->product_version);

	data_ptr += length + 1;
	printk(BIOS_DEBUG, "Read serial number string.\n");
	length = read_data_string(data_ptr, &info->serial_number);

	data_ptr += length + 1;
	printk(BIOS_DEBUG, "Read asset tag string.\n");
	length = read_data_string(data_ptr, &info->asset_tag);

	printk(BIOS_DEBUG, "Read product FRU file ID string.\n");
	data_ptr += length + 1;
	length = read_data_string(data_ptr, &info->fru_file_id);

	/* Check how many valid custom fields first. */
	data_ptr += length + 1;
	info->custom_count = 0;
	custom_data_ptr = data_ptr;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0)
			info->custom_count++;
		data_ptr += length + 1;
	}
	if (!info->custom_count)
		goto out;

	info->product_custom = malloc(info->custom_count * sizeof(char *));
	if (!info->product_custom) {
		printk(BIOS_ERR, "%s failed to malloc %zu bytes for "
			"product custom data array.\n", __func__,
			info->custom_count * sizeof(char *));
		ret = CB_ERR;
		goto out;
	}

	/* Start reading custom product data. */
	data_ptr = custom_data_ptr;
	int count = 0;
	while ((data_ptr < end) && ((data_ptr[0] != FRU_END_OF_FIELDS))) {
		length = NUM_DATA_BYTES(data_ptr[0]);
		if (length > 0) {
			length = read_data_string(data_ptr, info->product_custom + count);
			count++;
		}
		data_ptr += length + 1;
	}

out:
	free(data_ptr);
	return ret;
}

void read_fru_areas(const int port, const uint8_t id, uint16_t offset,
			struct fru_info_str *fru_info_str)
{
	struct ipmi_read_fru_data_req req;
	struct ipmi_fru_common_hdr fru_common_hdr;

	/* Set all the char pointers to 0 first, to avoid mainboard
	 * overwriting SMBIOS string with any non-NULL char pointer
	 * by accident. */
	memset(fru_info_str, 0, sizeof(*fru_info_str));
	req.fru_device_id = id;
	req.fru_offset = offset;
	req.count = sizeof(fru_common_hdr);
	/* Read FRU common header first */
	if (ipmi_read_fru(port, &req, (uint8_t *)&fru_common_hdr) == CB_SUCCESS) {
		if (checksum((uint8_t *)&fru_common_hdr, sizeof(fru_common_hdr))) {
			printk(BIOS_ERR, "Bad FRU common header checksum.\n");
			return;
		}
		printk(BIOS_DEBUG, "FRU common header: format_version: %x\n"
			"product_area_offset: %x\n"
			"board_area_offset: %x\n"
			"chassis_area_offset: %x\n",
			fru_common_hdr.format_version,
			fru_common_hdr.product_area_offset,
			fru_common_hdr.board_area_offset,
			fru_common_hdr.chassis_area_offset);
	} else {
		printk(BIOS_ERR, "Read FRU common header failed\n");
		return;
	}

	read_fru_product_info_area(port, id, fru_common_hdr.product_area_offset,
		&fru_info_str->prod_info);
	read_fru_board_info_area(port, id, fru_common_hdr.board_area_offset,
		&fru_info_str->board_info);
	read_fru_chassis_info_area(port, id, fru_common_hdr.chassis_area_offset,
		&fru_info_str->chassis_info);
}

void read_fru_one_area(const int port, const uint8_t id, uint16_t offset,
			struct fru_info_str *fru_info_str, enum fru_area fru_area)
{
	struct ipmi_read_fru_data_req req;
	struct ipmi_fru_common_hdr fru_common_hdr;

	req.fru_device_id = id;
	req.fru_offset = offset;
	req.count = sizeof(fru_common_hdr);
	if (ipmi_read_fru(port, &req, (uint8_t *)&fru_common_hdr) == CB_SUCCESS) {
		if (checksum((uint8_t *)&fru_common_hdr, sizeof(fru_common_hdr))) {
			printk(BIOS_ERR, "Bad FRU common header checksum.\n");
			return;
		}
		printk(BIOS_DEBUG, "FRU common header: format_version: %x\n"
			"product_area_offset: %x\n"
			"board_area_offset: %x\n"
			"chassis_area_offset: %x\n",
			fru_common_hdr.format_version,
			fru_common_hdr.product_area_offset,
			fru_common_hdr.board_area_offset,
			fru_common_hdr.chassis_area_offset);
	} else {
		printk(BIOS_ERR, "Read FRU common header failed\n");
		return;
	}

	switch (fru_area) {
	case PRODUCT_INFO_AREA:
		memset(&fru_info_str->prod_info, 0, sizeof(fru_info_str->prod_info));
		read_fru_product_info_area(port, id, fru_common_hdr.product_area_offset,
			&fru_info_str->prod_info);
		break;
	case BOARD_INFO_AREA:
		memset(&fru_info_str->board_info, 0, sizeof(fru_info_str->board_info));
		read_fru_board_info_area(port, id, fru_common_hdr.board_area_offset,
			&fru_info_str->board_info);
		break;
	case CHASSIS_INFO_AREA:
		memset(&fru_info_str->chassis_info, 0, sizeof(fru_info_str->chassis_info));
		read_fru_chassis_info_area(port, id, fru_common_hdr.chassis_area_offset,
			&fru_info_str->chassis_info);
		break;
	default:
		printk(BIOS_ERR, "Invalid fru_area: %d\n", fru_area);
		break;
	}
}

void print_fru_areas(struct fru_info_str *fru_info_str)
{
	int count = 0;
	if (fru_info_str == NULL) {
		printk(BIOS_ERR, "FRU data is null pointer\n");
		return;
	}
	struct fru_product_info prod_info = fru_info_str->prod_info;
	struct fru_board_info board_info = fru_info_str->board_info;
	struct fru_chassis_info chassis_info = fru_info_str->chassis_info;

	printk(BIOS_DEBUG, "Printing Product Info Area...\n");
	if (prod_info.manufacturer != NULL)
		printk(BIOS_DEBUG, "manufacturer: %s\n", prod_info.manufacturer);
	if (prod_info.product_name != NULL)
		printk(BIOS_DEBUG, "product name: %s\n", prod_info.product_name);
	if (prod_info.product_partnumber != NULL)
		printk(BIOS_DEBUG, "product part number: %s\n", prod_info.product_partnumber);
	if (prod_info.product_version != NULL)
		printk(BIOS_DEBUG, "product version: %s\n", prod_info.product_version);
	if (prod_info.serial_number != NULL)
		printk(BIOS_DEBUG, "serial number: %s\n", prod_info.serial_number);
	if (prod_info.asset_tag != NULL)
		printk(BIOS_DEBUG, "asset tag: %s\n", prod_info.asset_tag);
	if (prod_info.fru_file_id != NULL)
		printk(BIOS_DEBUG, "FRU file ID: %s\n", prod_info.fru_file_id);

	for (count = 0; count < prod_info.custom_count; count++) {
		if (*(prod_info.product_custom + count) != NULL)
			printk(BIOS_DEBUG, "product custom data %i: %s\n", count,
				*(prod_info.product_custom + count));
	}

	printk(BIOS_DEBUG, "Printing Board Info Area...\n");
	if (board_info.manufacturer != NULL)
		printk(BIOS_DEBUG, "manufacturer: %s\n", board_info.manufacturer);
	if (board_info.product_name != NULL)
		printk(BIOS_DEBUG, "product name: %s\n", board_info.product_name);
	if (board_info.serial_number != NULL)
		printk(BIOS_DEBUG, "serial number: %s\n", board_info.serial_number);
	if (board_info.part_number != NULL)
		printk(BIOS_DEBUG, "part number: %s\n", board_info.part_number);
	if (board_info.fru_file_id != NULL)
		printk(BIOS_DEBUG, "FRU file ID: %s\n", board_info.fru_file_id);

	for (count = 0; count < board_info.custom_count; count++) {
		if (*(board_info.board_custom + count) != NULL)
			printk(BIOS_DEBUG, "board custom data %i: %s\n", count,
				*(board_info.board_custom + count));
	}

	printk(BIOS_DEBUG, "Printing Chassis Info Area...\n");
	printk(BIOS_DEBUG, "chassis type: 0x%x\n", chassis_info.chassis_type);
	if (chassis_info.chassis_partnumber != NULL)
		printk(BIOS_DEBUG, "part number: %s\n", chassis_info.chassis_partnumber);
	if (chassis_info.serial_number != NULL)
		printk(BIOS_DEBUG, "serial number: %s\n", chassis_info.serial_number);

	for (count = 0; count < chassis_info.custom_count; count++) {
		if (*(chassis_info.chassis_custom + count) != NULL)
			printk(BIOS_DEBUG, "chassis custom data %i: %s\n", count,
				*(chassis_info.chassis_custom + count));
	}
}