| /* SPDX-License-Identifier: GPL-2.0-only */ |
| |
| #include <console/console.h> |
| #include <string.h> |
| #include <delay.h> |
| #include <stdlib.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 */ |
| |
| 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_kcs_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; |
| } |
| |
| static void 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; |
| |
| offset = offset * OFFSET_LENGTH_MULTIPLIER; |
| if (!offset) |
| return; |
| 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; |
| } |
| 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; |
| } |
| |
| /* 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__); |
| goto out; |
| } |
| if (checksum(data_ptr, length)) { |
| printk(BIOS_ERR, "Bad FRU board info checksum.\n"); |
| goto out; |
| } |
| /* Read manufacturer string, bit[5:0] is the string length. */ |
| length = NUM_DATA_BYTES(data_ptr[BOARD_MAN_TYPE_LEN_OFFSET]); |
| data_ptr += BOARD_MAN_TYPE_LEN_OFFSET; |
| if (length > 0) { |
| info->manufacturer = malloc(length + 1); |
| if (!info->manufacturer) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "manufacturer.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->manufacturer, length)) |
| free(info->manufacturer); |
| } |
| |
| /* Read product name string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->product_name = malloc(length+1); |
| if (!info->product_name) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "product_name.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->product_name, length)) |
| free(info->product_name); |
| } |
| |
| /* Read serial number string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->serial_number = malloc(length + 1); |
| if (!info->serial_number) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "serial_number.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->serial_number, length)) |
| free(info->serial_number); |
| } |
| |
| /* Read part number string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->part_number = malloc(length + 1); |
| if (!info->part_number) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "part_number.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->part_number, length)) |
| free(info->part_number); |
| } |
| |
| out: |
| free(data_ptr); |
| } |
| |
| static void 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; |
| |
| offset = offset * OFFSET_LENGTH_MULTIPLIER; |
| if (!offset) |
| return; |
| |
| 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; |
| } |
| 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; |
| } |
| |
| /* 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__); |
| goto out; |
| } |
| if (checksum(data_ptr, length)) { |
| printk(BIOS_ERR, "Bad FRU product info checksum.\n"); |
| goto out; |
| } |
| /* Read manufacturer string, bit[5:0] is the string length. */ |
| length = NUM_DATA_BYTES(data_ptr[PRODUCT_MAN_TYPE_LEN_OFFSET]); |
| data_ptr += PRODUCT_MAN_TYPE_LEN_OFFSET; |
| if (length > 0) { |
| info->manufacturer = malloc(length + 1); |
| if (!info->manufacturer) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "manufacturer.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->manufacturer, length)) |
| free(info->manufacturer); |
| } |
| |
| /* Read product_name string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->product_name = malloc(length + 1); |
| if (!info->product_name) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "product_name.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->product_name, length)) |
| free(info->product_name); |
| } |
| |
| /* Read product part/model number. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->product_partnumber = malloc(length + 1); |
| if (!info->product_partnumber) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "product_partnumber.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->product_partnumber, length)) |
| free(info->product_partnumber); |
| } |
| |
| /* Read product version string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->product_version = malloc(length + 1); |
| if (!info->product_version) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "product_version.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->product_version, length)) |
| free(info->product_version); |
| } |
| |
| /* Read serial number string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->serial_number = malloc(length + 1); |
| if (!info->serial_number) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "serial_number.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->serial_number, length)) |
| free(info->serial_number); |
| } |
| |
| /* Read asset tag string. */ |
| data_ptr += length + 1; |
| length = NUM_DATA_BYTES(data_ptr[0]); |
| if (length > 0) { |
| info->asset_tag = malloc(length + 1); |
| if (!info->asset_tag) { |
| printk(BIOS_ERR, "%s failed to malloc %d bytes for " |
| "asset_tag.\n", __func__, length + 1); |
| goto out; |
| } |
| if (!data2str((const uint8_t *)data_ptr, info->asset_tag, length)) |
| free(info->asset_tag); |
| } |
| |
| out: |
| free(data_ptr); |
| } |
| |
| 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); |
| /* ToDo: Add read_fru_chassis_info_area(). */ |
| } |
| |
| 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; |
| /* ToDo: Add case for CHASSIS_INFO_AREA. */ |
| default: |
| printk(BIOS_ERR, "Invalid fru_area: %d\n", fru_area); |
| break; |
| } |
| } |