10 files changed, 937 insertions, 0 deletions

diff --git a/plugins/solidigm/solidigm-telemetry/cod.c b/plugins/solidigm/solidigm-telemetry/cod.c
new file mode 100644
index 0000000..be5685b
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/cod.c
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+#include "common.h"
+#include "cod.h"
+
+const char *oemDataMapDesc[] = {
+	"Media Read Count", //Uid 0x00
+	"Host Read count",  //Uid 0x01
+	"Media Write Count",  //Uid 0x02
+	"Host Write Count",  //Uid 0x03
+	"Device Model", // 0x04
+	"Serial Number", // 0x05
+	"Firmware Revision", // 0x06
+	"Drive Status", // 0x07
+	"Minimum Temperature", // 0x08
+	"Maximum Temperature", // 0x09
+	"Power Loss Protection Status", // 0x0a
+	"Lifetime Unsafe Shutdown Count", // 0x0b
+	"Lifetime Power Cycle Count", // 0x0c
+	"Minimum Read Latency", // 0x0d
+	"Maximum Read Latency", // 0x0e
+	"Average Read Latency", // 0x0f
+	"Minimum Write Latency", // 0x10
+	"Maximum Write Latency", // 0x11
+	"Average Write Latency", // 0x12
+	"Grown Defects Count", // 0x13
+	"DQS Recovery Count", // 0x14
+	"Program Fail Count", // 0x15
+	"Erase Fail Count",  // 0x16
+	"Defrag Writes in Progress Count",  // 0x17
+	"Total Defrag Writes Count",  // 0x18
+	"Max Die Offline Number",  // 0x19
+	"Current Die Offline Number",  // 0x1A
+	"XOR Enable Status",  // 0x1B
+	"Media Life Used",  // 0x1C
+	"Uncorrectable Error Count",  // 0x1D
+	"Current Wear Range Delta", // 0x1E
+	"Read Errors Corrected by XOR", // 0x1F
+	"Background Data Refresh", // 0x20
+	"Pmic Vin History Data 1 Min", // 0x21
+	"Pmic Vin History Data 1 Max", // 0x22
+	"Pmic Vin History Data 1 Avg", // 0x23
+	"Pmic Vin History Data 2 Min", // 0x24
+	"Pmic Vin History Data 2 Max", // 0x25
+	"Pmic Vin History Data 2 Avg", // 0x26
+	"Pmic Vin History Data Total Readings", // 0x27
+	"All Time Current Max Wear Level", // 0x28
+	"Media Wear Remaining", // 0x29
+	"Total Non-Defrag Writes",  // 0x2A
+	"Number of sectors relocated in reaction to an error" //Uid 0x2B = 43
+};
+
+static const char * getOemDataMapDescription(__u32 id)
+{
+	if (id < (sizeof(oemDataMapDesc) / sizeof(oemDataMapDesc[0]))) {
+		return oemDataMapDesc[id];
+	}
+	return "unknown";
+}
+
+#define OEMSIGNATURE 0x504D4443
+
+#pragma pack(push, cod, 1)
+struct cod_header
+{
+	uint32_t versionMajor;
+	uint32_t versionMinor;
+	uint32_t Signature;      //!Fixed signature value (0x504D4443) for identification and validation
+	uint32_t MapSizeInBytes; //!Total size of the map data structure in bytes
+	uint32_t EntryCount;     //!Total number of entries in the entry list
+	uint8_t Reserved[12];
+};
+
+struct cod_item
+{
+	uint32_t DataFieldMapUid;       //!The data field unique identifier value
+	uint32_t reserved1 : 8;
+	uint32_t dataFieldType : 8;
+	uint32_t issigned : 1;
+	uint32_t bigEndian : 1;
+	uint32_t dataInvalid : 1;
+	uint32_t reserved2 : 13;
+	uint32_t DataFieldSizeInBytes;
+	uint8_t Reserved1[4];
+	uint64_t DataFieldOffset;
+	uint8_t Reserved2[8];
+};
+
+struct cod_map
+{
+	struct cod_header header;
+	struct cod_item items[];
+};
+
+#pragma pack(pop, cod)
+
+void solidigm_telemetry_log_cod_parse(struct telemetry_log *tl)
+{
+	enum cod_field_type
+	{
+		INTEGER,
+		FLOAT,
+		STRING,
+		TWO_BYTE_ASCII,
+		FOUR_BYTE_ASCII,
+
+		UNKNOWN = 0xFF,
+	};
+	json_object *telemetry_header = NULL;
+	json_object *COD_offset = NULL;
+	json_object *reason_id = NULL;
+
+	if (!json_object_object_get_ex(tl->root, "telemetryHeader", &telemetry_header))
+		return;
+	if (!json_object_object_get_ex(telemetry_header, "reasonIdentifier", &reason_id))
+		return;
+	if  (!json_object_object_get_ex(reason_id, "OemDataMapOffset", &COD_offset))
+		return;
+
+	__u64 offset = json_object_get_int(COD_offset);
+
+	if  (offset ==  0) {
+		return;
+	}
+
+	if ((offset + sizeof(struct cod_header)) > tl->log_size) {
+		SOLIDIGM_LOG_WARNING("Warning: COD map header out of bounds.");
+		return;
+	}
+
+	const struct cod_map *data = (struct cod_map *) (((__u8 *)tl->log ) + offset);
+
+	uint32_t signature = be32_to_cpu(data->header.Signature);
+	if ( signature != OEMSIGNATURE){
+		SOLIDIGM_LOG_WARNING("Warning: Unsupported COD data signature %x!", signature);
+		return;
+	}
+	if ((offset + data->header.MapSizeInBytes) > tl->log_size){
+		SOLIDIGM_LOG_WARNING("Warning: COD map data out of bounds.");
+		return;
+	}
+
+	json_object *cod = json_create_object();
+	json_object_object_add(tl->root, "cod", cod);
+
+	for (int i =0 ; i < data->header.EntryCount; i++) {
+		if ((offset + sizeof(struct cod_header) + (i + 1) * sizeof(struct cod_item)) >
+		tl->log_size){
+			SOLIDIGM_LOG_WARNING("Warning: COD data out of bounds at item %d!", i);
+			return;
+		}
+		struct cod_item item = data->items[i];
+		if (item.DataFieldOffset + item.DataFieldOffset > tl->log_size) {
+			continue;
+		}
+		if (item.dataInvalid) {
+			continue;
+		}
+		uint8_t *val = ((uint8_t *)tl->log )+ item.DataFieldOffset;
+		const char *key =  getOemDataMapDescription(item.DataFieldMapUid);
+		switch(item.dataFieldType){
+			case(INTEGER):
+				if (item.issigned) {
+					json_object_object_add(cod, key,
+						json_object_new_int64(le64_to_cpu(*(uint64_t *)val)));
+				} else {
+					json_object_add_value_uint64(cod, key, le64_to_cpu(*(uint64_t *)val));
+				}
+				break;
+			case(FLOAT):
+				json_object_add_value_float(cod, key, *(float *) val);
+				break;
+			case(STRING):
+				json_object_object_add(cod, key,
+					json_object_new_string_len((const char *)val, item.DataFieldSizeInBytes));
+				break;
+			case(TWO_BYTE_ASCII):
+				json_object_object_add(cod, key,
+					json_object_new_string_len((const char *)val,2));
+				break;
+			case(FOUR_BYTE_ASCII):
+				json_object_object_add(cod, key,
+					json_object_new_string_len((const char *)val, 4));
+				break;
+			default:
+				SOLIDIGM_LOG_WARNING("Warning: Unknown COD field type (%d)", item.DataFieldMapUid);
+				
+		}
+	}
+}
diff --git a/plugins/solidigm/solidigm-telemetry/cod.h b/plugins/solidigm/solidigm-telemetry/cod.h
new file mode 100644
index 0000000..032ccdc
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/cod.h
@@ -0,0 +1,9 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "telemetry-log.h"
+void solidigm_telemetry_log_cod_parse(struct telemetry_log *tl);
diff --git a/plugins/solidigm/solidigm-telemetry/config.c b/plugins/solidigm/solidigm-telemetry/config.c
new file mode 100644
index 0000000..781d786
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/config.c
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+#include <stdbool.h>
+#include "util/json.h"
+#include <stdio.h>
+
+// max 16 bit unsigned integer nummber 65535
+#define MAX_16BIT_NUM_AS_STRING_SIZE  6
+
+static bool config_get_by_version(const json_object *obj, int version_major,
+				  int version_minor, json_object **value)
+{
+	char str_key[MAX_16BIT_NUM_AS_STRING_SIZE];
+	char str_subkey[MAX_16BIT_NUM_AS_STRING_SIZE];
+
+	snprintf(str_key, sizeof(str_key), "%d", version_major);
+	snprintf(str_subkey, sizeof(str_subkey), "%d", version_minor);
+	json_object *major_obj = NULL;
+
+	if (!json_object_object_get_ex(obj, str_key, &major_obj))
+		return false;
+	if  (!json_object_object_get_ex(major_obj, str_subkey, value))
+		return false;
+	return value != NULL;
+}
+
+bool solidigm_config_get_by_token_version(const json_object *obj, int token_id,
+					  int version_major, int version_minor,
+					  json_object **value)
+{
+	json_object *token_obj = NULL;
+	char str_key[MAX_16BIT_NUM_AS_STRING_SIZE];
+
+	snprintf(str_key, sizeof(str_key), "%d", token_id);
+	if (!json_object_object_get_ex(obj, str_key, &token_obj))
+		return false;
+	if  (!config_get_by_version(token_obj, version_major, version_minor, value))
+		return false;
+	return value != NULL;
+}
diff --git a/plugins/solidigm/solidigm-telemetry/config.h b/plugins/solidigm/solidigm-telemetry/config.h
new file mode 100644
index 0000000..bea84fb
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/config.h
@@ -0,0 +1,10 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+#include <stdbool.h>
+#include "util/json.h"
+
+bool solidigm_config_get_by_token_version(const json_object *obj, int key, int subkey, int subsubkey, json_object **value);
diff --git a/plugins/solidigm/solidigm-telemetry/data-area.c b/plugins/solidigm/solidigm-telemetry/data-area.c
new file mode 100644
index 0000000..7233e8f
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/data-area.c
@@ -0,0 +1,424 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "common.h"
+#include "data-area.h"
+#include "config.h"
+#include <ctype.h>
+
+#define SIGNED_INT_PREFIX "int"
+#define BITS_IN_BYTE 8
+
+#define MAX_WARNING_SIZE 1024
+
+static bool telemetry_log_get_value(const struct telemetry_log *tl,
+				    uint32_t offset_bit, uint32_t size_bit,
+				    bool is_signed, json_object **val_obj)
+{
+	uint32_t offset_bit_from_byte;
+	uint32_t additional_size_byte;
+	uint32_t offset_byte;
+	uint32_t val;
+
+	if (size_bit == 0) {
+		char err_msg[MAX_WARNING_SIZE];
+
+		snprintf(err_msg, MAX_WARNING_SIZE,
+			 "Value with size_bit=0 not supported.");
+		*val_obj = json_object_new_string(err_msg);
+
+		return false;
+	}
+	additional_size_byte = (size_bit - 1) ? (size_bit - 1) / BITS_IN_BYTE : 0;
+	offset_byte = offset_bit / BITS_IN_BYTE;
+
+	if (offset_byte > (tl->log_size - additional_size_byte)) {
+		char err_msg[MAX_WARNING_SIZE];
+
+		snprintf(err_msg, MAX_WARNING_SIZE,
+			"Value offset greater than binary size (%u > %zu).",
+			 offset_byte, tl->log_size);
+		*val_obj = json_object_new_string(err_msg);
+
+		return false;
+	}
+
+	offset_bit_from_byte = offset_bit - (offset_byte * BITS_IN_BYTE);
+
+	if ((size_bit + offset_bit_from_byte) > (sizeof(uint64_t) * BITS_IN_BYTE)) {
+		char err_msg[MAX_WARNING_SIZE];
+
+		snprintf(err_msg, MAX_WARNING_SIZE,
+			 "Value crossing 64 bit, byte aligned bounday, "
+			 "not supported. size_bit=%u, offset_bit_from_byte=%u.",
+			  size_bit, offset_bit_from_byte);
+		*val_obj = json_object_new_string(err_msg);
+
+		return false;
+	}
+
+	val = *(uint64_t *)(((char *)tl->log) + offset_byte);
+	val >>= offset_bit_from_byte;
+	if (size_bit < 64)
+		val &= (1ULL << size_bit) - 1;
+	if (is_signed) {
+		if (val >> (size_bit - 1))
+			val |= -1ULL << size_bit;
+		*val_obj = json_object_new_int64(val);
+	} else {
+		*val_obj = json_object_new_uint64(val);
+	}
+
+	return true;
+}
+
+static int telemetry_log_structure_parse(const struct telemetry_log *tl,
+					 json_object *struct_def,
+					 size_t parent_offset_bit,
+					 json_object *output,
+					 json_object *metadata)
+{
+	json_object *obj_arraySizeArray = NULL;
+	json_object *obj = NULL;
+	json_object *obj_memberList;
+	json_object *major_dimension;
+	json_object *sub_output;
+	bool is_enumeration = false;
+	bool has_member_list;
+	const char *type = "";
+	const char *name;
+	size_t array_rank;
+	size_t offset_bit;
+	size_t size_bit;
+	uint32_t linear_array_pos_bit;
+
+	if (!json_object_object_get_ex(struct_def, "name", &obj)) {
+		SOLIDIGM_LOG_WARNING("Warning: Structure definition missing property 'name': %s",
+				     json_object_to_json_string(struct_def));
+		return  -1;
+	}
+
+	name = json_object_get_string(obj);
+
+	if (metadata) {
+		json_object_get(obj);
+		json_object_object_add(metadata, "objName", obj);
+	}
+
+	if (json_object_object_get_ex(struct_def, "type", &obj))
+		type = json_object_get_string(obj);
+
+	if (!json_object_object_get_ex(struct_def, "offsetBit", &obj)) {
+		SOLIDIGM_LOG_WARNING("Warning: Structure definition missing "
+				     "property 'offsetBit': %s",
+				     json_object_to_json_string(struct_def));
+		return  -1;
+	}
+
+	offset_bit = json_object_get_uint64(obj);
+
+	if (!json_object_object_get_ex(struct_def, "sizeBit", &obj)) {
+		SOLIDIGM_LOG_WARNING("Warning: Structure definition missing "
+				     "property 'sizeBit': %s",
+				     json_object_to_json_string(struct_def));
+		return  -1;
+	}
+
+	size_bit = json_object_get_uint64(obj);
+
+	if (json_object_object_get_ex(struct_def, "enum", &obj))
+		is_enumeration = json_object_get_boolean(obj);
+
+	has_member_list = json_object_object_get_ex(struct_def,
+						    "memberList",
+						    &obj_memberList);
+
+	if (!json_object_object_get_ex(struct_def, "arraySize",
+				       &obj_arraySizeArray)) {
+		SOLIDIGM_LOG_WARNING("Warning: Structure definition missing "
+				     "property 'arraySize': %s",
+				     json_object_to_json_string(struct_def));
+		return  -1;
+	}
+
+	array_rank = json_object_array_length(obj_arraySizeArray);
+	if (array_rank == 0) {
+		SOLIDIGM_LOG_WARNING("Warning: Structure property 'arraySize' "
+				     "don't support flexible array: %s",
+				     json_object_to_json_string(struct_def));
+		return -1;
+	}
+	uint32_t array_size_dimension[array_rank];
+
+	for (size_t i = 0; i < array_rank; i++) {
+		json_object *dimension = json_object_array_get_idx(obj_arraySizeArray, i);
+
+		array_size_dimension[i] = json_object_get_uint64(dimension);
+		major_dimension = dimension;
+	}
+	if (array_rank > 1) {
+		uint32_t linear_pos_per_index = array_size_dimension[0];
+		uint32_t prev_index_offset_bit = 0;
+		json_object *dimension_output;
+
+		for (int i = 1; i < (array_rank - 1); i++)
+			linear_pos_per_index *= array_size_dimension[i];
+
+		dimension_output = json_create_array();
+		if (json_object_get_type(output) == json_type_array)
+			json_object_array_add(output, dimension_output);
+		else
+			json_object_add_value_array(output, name, dimension_output);
+
+		/*
+		 * Make sure major_dimension object will not be
+		 * deleted from memory when deleted from array
+		 */
+		json_object_get(major_dimension);
+		json_object_array_del_idx(obj_arraySizeArray, array_rank - 1, 1);
+
+		for (int i = 0 ; i < array_size_dimension[0]; i++) {
+			json_object *sub_array = json_create_array();
+			size_t offset;
+
+			offset = parent_offset_bit + prev_index_offset_bit;
+
+			json_object_array_add(dimension_output, sub_array);
+			telemetry_log_structure_parse(tl, struct_def,
+						      offset, sub_array, NULL);
+			prev_index_offset_bit += linear_pos_per_index * size_bit;
+		}
+
+		json_object_array_put_idx(obj_arraySizeArray, array_rank - 1,
+					  major_dimension);
+
+		return 0;
+	}
+
+	linear_array_pos_bit = 0;
+	sub_output = output;
+
+	if (array_size_dimension[0] > 1) {
+		sub_output = json_create_array();
+		if (json_object_get_type(output) == json_type_array)
+			json_object_array_add(output, sub_output);
+		else
+			json_object_add_value_array(output, name, sub_output);
+	}
+
+	for (uint32_t j = 0; j < array_size_dimension[0]; j++) {
+		if (is_enumeration || !has_member_list) {
+			bool is_signed = !strncmp(type, SIGNED_INT_PREFIX, sizeof(SIGNED_INT_PREFIX)-1);
+			json_object *val_obj;
+			size_t offset;
+
+			offset = parent_offset_bit + offset_bit + linear_array_pos_bit;
+			if (telemetry_log_get_value(tl, offset, size_bit, is_signed, &val_obj)) {
+				if (array_size_dimension[0] > 1)
+					json_object_array_put_idx(sub_output, j, val_obj);
+				else
+					json_object_object_add(sub_output, name, val_obj);
+			} else {
+				SOLIDIGM_LOG_WARNING("Warning: %s From property '%s', "
+						     "array index %u, structure definition: %s",
+						     json_object_get_string(val_obj),
+						     name, j, json_object_to_json_string(struct_def));
+				json_free_object(val_obj);
+			}
+		} else {
+			json_object *sub_sub_output = json_object_new_object();
+			int num_members;
+
+			if (array_size_dimension[0] > 1)
+				json_object_array_put_idx(sub_output, j, sub_sub_output);
+			else
+				json_object_add_value_object(sub_output, name, sub_sub_output);
+
+			num_members = json_object_array_length(obj_memberList);
+			for (int k = 0; k < num_members; k++) {
+				json_object *member = json_object_array_get_idx(obj_memberList, k);
+				size_t offset;
+
+				offset = parent_offset_bit + offset_bit + linear_array_pos_bit;
+				telemetry_log_structure_parse(tl, member, offset,
+							      sub_sub_output, NULL);
+			}
+		}
+		linear_array_pos_bit += size_bit;
+	}
+	return 0;
+}
+
+static int telemetry_log_data_area_get_offset(const struct telemetry_log *tl,
+					      enum nvme_telemetry_da da,
+					      uint32_t *offset, uint32_t *size)
+{
+	uint32_t offset_blocks = 1;
+	uint32_t last_block = tl->log->dalb1;
+	uint32_t last;
+
+	switch (da) {
+	case NVME_TELEMETRY_DA_1:
+		offset_blocks = 1;
+		last_block = tl->log->dalb1;
+		break;
+	case NVME_TELEMETRY_DA_2:
+		offset_blocks = tl->log->dalb1 + 1;
+		last_block = tl->log->dalb2;
+		break;
+	case NVME_TELEMETRY_DA_3:
+		offset_blocks = tl->log->dalb2 + 1;
+		last_block = tl->log->dalb3;
+		break;
+	case NVME_TELEMETRY_DA_4:
+		offset_blocks = tl->log->dalb3 + 1;
+		last_block = tl->log->dalb4;
+		break;
+	default:
+		return -1;
+	}
+
+	*offset = offset_blocks * NVME_LOG_TELEM_BLOCK_SIZE;
+	last = (last_block + 1) * NVME_LOG_TELEM_BLOCK_SIZE;
+	*size = last - *offset;
+	if ((*offset > tl->log_size) || (last > tl->log_size) || (last <= *offset)) {
+		SOLIDIGM_LOG_WARNING("Warning: Data Area %d don't fit this Telemetry log.", da);
+		return -1;
+	}
+
+	return 0;
+}
+
+struct toc_item {
+	uint32_t OffsetBytes;
+	uint32_t ContentSizeBytes;
+};
+
+struct data_area_header {
+	uint8_t versionMajor;
+	uint8_t versionMinor;
+	uint16_t TableOfContentsCount;
+	uint32_t DataAreaSize;
+	uint8_t Reserved[8];
+};
+
+struct table_of_contents {
+	struct data_area_header header;
+	struct toc_item items[];
+};
+
+struct telemetry_object_header {
+	uint16_t versionMajor;
+	uint16_t versionMinor;
+	uint32_t Token;
+	uint8_t CoreId;
+	uint8_t Reserved[3];
+};
+
+
+static void telemetry_log_data_area_toc_parse(const struct telemetry_log *tl,
+					      enum nvme_telemetry_da da,
+					      json_object *toc_array,
+					      json_object *tele_obj_array)
+{
+
+	const struct telemetry_object_header *header;
+	const struct table_of_contents *toc;
+	char *payload;
+	uint32_t da_offset;
+	uint32_t da_size;
+
+	if (telemetry_log_data_area_get_offset(tl, da, &da_offset, &da_size))
+		return;
+
+	toc = (struct table_of_contents *)(((char *)tl->log) + da_offset);
+	payload = (char *) tl->log;
+
+	for (int i = 0; i < toc->header.TableOfContentsCount; i++) {
+		json_object *structure_definition = NULL;
+		json_object *toc_item;
+		uint32_t obj_offset;
+		bool has_struct;
+
+		if ((char *)&toc->items[i] > (((char *)toc) + da_size - sizeof(const struct toc_item))) {
+			SOLIDIGM_LOG_WARNING("Warning: Data Area %d, "
+					     "Table of Contents item %d "
+					     "crossed Data Area size.", da, i);
+			return;
+		}
+
+		obj_offset = toc->items[i].OffsetBytes;
+		if ((obj_offset + sizeof(const struct telemetry_object_header)) > da_size) {
+			SOLIDIGM_LOG_WARNING("Warning: Data Area %d, item %d "
+					     "data, crossed Data Area size.", da, i);
+			continue;
+		}
+
+		toc_item = json_create_object();
+		json_object_array_add(toc_array, toc_item);
+		json_object_add_value_uint(toc_item, "dataArea", da);
+		json_object_add_value_uint(toc_item, "dataAreaIndex", i);
+		json_object_add_value_uint(toc_item, "dataAreaOffset", obj_offset);
+		json_object_add_value_uint(toc_item, "fileOffset", obj_offset + da_offset);
+		json_object_add_value_uint(toc_item, "size", toc->items[i].ContentSizeBytes);
+
+		header = (const struct telemetry_object_header *) (payload + da_offset + obj_offset);
+		json_object_add_value_uint(toc_item, "telemMajor", header->versionMajor);
+		json_object_add_value_uint(toc_item, "telemMinor", header->versionMinor);
+		json_object_add_value_uint(toc_item, "objectId", header->Token);
+		json_object_add_value_uint(toc_item, "mediaBankId", header->CoreId);
+
+		has_struct = solidigm_config_get_by_token_version(tl->configuration,
+							          header->Token,
+								  header->versionMajor,
+								  header->versionMinor,
+								  &structure_definition);
+
+		if (has_struct) {
+			json_object *tele_obj_item = json_create_object();
+
+			json_object_array_add(tele_obj_array, tele_obj_item);
+			json_object_get(toc_item);
+			json_object_add_value_object(tele_obj_item, "metadata", toc_item);
+			json_object *parsed_struct = json_object_new_object();
+
+			json_object_add_value_object(tele_obj_item, "objectData", parsed_struct);
+			json_object *obj_hasTelemObjHdr = NULL;
+			uint32_t header_offset = sizeof(const struct telemetry_object_header);
+			uint32_t file_offset;
+
+			if (json_object_object_get_ex(structure_definition,
+						      "hasTelemObjHdr",
+						       &obj_hasTelemObjHdr)) {
+				bool hasHeader = json_object_get_boolean(obj_hasTelemObjHdr);
+
+				if (hasHeader)
+					header_offset = 0;
+			}
+
+			file_offset = da_offset + obj_offset + header_offset;
+			telemetry_log_structure_parse(tl, structure_definition,
+						      BITS_IN_BYTE * file_offset,
+						      parsed_struct, toc_item);
+		}
+	}
+}
+
+int solidigm_telemetry_log_data_areas_parse(const struct telemetry_log *tl,
+					    enum nvme_telemetry_da last_da)
+{
+	json_object *tele_obj_array = json_create_array();
+	json_object *toc_array = json_create_array();
+
+	json_object_add_value_array(tl->root, "tableOfContents", toc_array);
+	json_object_add_value_array(tl->root, "telemetryObjects", tele_obj_array);
+
+	for (enum nvme_telemetry_da da = NVME_TELEMETRY_DA_1; da <= last_da; da++)
+		telemetry_log_data_area_toc_parse(tl, da, toc_array, tele_obj_array);
+
+	return 0;
+}
diff --git a/plugins/solidigm/solidigm-telemetry/data-area.h b/plugins/solidigm/solidigm-telemetry/data-area.h
new file mode 100644
index 0000000..095eb64
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/data-area.h
@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+#include "common.h"
+#include "telemetry-log.h"
+
+int solidigm_telemetry_log_data_areas_parse(const struct telemetry_log *tl,
+					    enum nvme_telemetry_da last_da);
diff --git a/plugins/solidigm/solidigm-telemetry/header.c b/plugins/solidigm/solidigm-telemetry/header.c
new file mode 100644
index 0000000..72b2d97
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/header.c
@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "common.h"
+#include "header.h"
+
+#pragma pack(push, reason_indentifier, 1)
+struct reason_indentifier_1_0
+{
+	uint16_t versionMajor;
+	uint16_t versionMinor;
+	uint32_t reasonCode;		//! 0 denotes no issue. All other values denote a potential issue.
+	char DriveStatus[20];		//! Drive Status String (for example: "Healthy", "*BAD_CONTEXT_2020")
+	char FirmwareVersion[12];	//! Similar to IdentifyController.FR
+	char BootloaderVersion[12];	//! Bootloader version string
+	char SerialNumber[20];		//! Device serial number
+	uint8_t Reserved[56];		//! Reserved for future usage
+};
+static_assert(sizeof(const struct reason_indentifier_1_0) ==
+	      MEMBER_SIZE(struct nvme_telemetry_log, rsnident),
+	      "Size mismatch for reason_indentifier_1_0");
+
+struct reason_indentifier_1_1
+{
+	uint16_t versionMajor;
+	uint16_t versionMinor;
+	uint32_t reasonCode;		//! 0 denotes no issue. All other values denote a potential issue.
+	char DriveStatus[20];		//! Drive Status String (for example: "Healthy", "*BAD_CONTEXT_2020")
+	char FirmwareVersion[12];	//! Similar to IdentifyController.FR
+	char BootloaderVersion[12];	//! Bootloader version string
+	char SerialNumber[20];		//! Device serial number
+	uint64_t OemDataMapOffset;	//! Customer Data Map Object Log Offset
+	uint8_t TelemetryMajorVersion;	//! Shadow of version in TOC
+	uint8_t TelemetryMinorVersion;	//! Shadow of version in TOC
+	uint8_t Reserved[46];		//! Reserved for future usage
+};
+static_assert(sizeof(const struct reason_indentifier_1_1) ==
+	      MEMBER_SIZE(struct nvme_telemetry_log, rsnident),
+	      "Size mismatch for reason_indentifier_1_1");
+
+struct reason_indentifier_1_2
+{
+	uint16_t versionMajor;
+	uint16_t versionMinor;
+	uint32_t reasonCode;		//! 0 denotes no issue. All other values denote a potential issue.
+	char DriveStatus[20];		//! Drive Status String (for example: "Healthy", "*BAD_CONTEXT_2020")
+	uint8_t Reserved1[24];		//! pad over Fields removed from version 1.1
+	char SerialNumber[20];		//! Device serial number
+	uint64_t OemDataMapOffset;	//! Customer Data Map Object Log Offset
+	uint8_t TelemetryMajorVersion;	//! Shadow of version in TOC
+	uint8_t TelemetryMinorVersion;	//! Shadow of version in TOC
+	uint8_t ProductFamilyId;
+	uint8_t Reserved2[5];		//! Reserved for future usage
+	uint8_t DualPortReserved[40];	//! Reserved for dual port
+};
+static_assert(sizeof(const struct reason_indentifier_1_2) ==
+	      MEMBER_SIZE(struct nvme_telemetry_log, rsnident),
+	      "Size mismatch for reason_indentifier_1_2");
+#pragma pack(pop, reason_indentifier)
+
+static void telemetry_log_reason_id_parse1_0_ext(const struct telemetry_log *tl,
+						 json_object *reason_id)
+{
+	const struct reason_indentifier_1_0 *ri;
+	json_object *reserved;
+
+	ri = (struct reason_indentifier_1_0 *) tl->log->rsnident;
+	json_object_object_add(reason_id, "FirmwareVersion", json_object_new_string_len(ri->FirmwareVersion, sizeof(ri->FirmwareVersion)));
+	json_object_object_add(reason_id, "BootloaderVersion", json_object_new_string_len(ri->BootloaderVersion, sizeof(ri->BootloaderVersion)));
+	json_object_object_add(reason_id, "SerialNumber", json_object_new_string_len(ri->SerialNumber, sizeof(ri->SerialNumber)));
+
+	reserved = json_create_array();
+	json_object_add_value_array(reason_id, "Reserved", reserved);
+	for ( int i=0; i < sizeof(ri->Reserved); i++) {
+		json_object *val = json_object_new_int(ri->Reserved[i]);
+		json_object_array_add(reserved, val);
+	}
+}
+
+static void telemetry_log_reason_id_parse1_1_ext(const struct telemetry_log *tl,
+						 json_object *reason_id)
+{
+	const struct reason_indentifier_1_1 *ri;
+	json_object *reserved;
+
+	ri = (struct reason_indentifier_1_1 *) tl->log->rsnident;
+	json_object_object_add(reason_id, "FirmwareVersion", json_object_new_string_len(ri->FirmwareVersion, sizeof(ri->FirmwareVersion)));
+	json_object_object_add(reason_id, "BootloaderVersion", json_object_new_string_len(ri->BootloaderVersion, sizeof(ri->BootloaderVersion)));
+	json_object_object_add(reason_id, "SerialNumber", json_object_new_string_len(ri->SerialNumber, sizeof(ri->SerialNumber)));
+	json_object_add_value_uint64(reason_id, "OemDataMapOffset", le64_to_cpu(ri->OemDataMapOffset));
+	json_object_add_value_uint(reason_id, "TelemetryMajorVersion", le16_to_cpu(ri->TelemetryMajorVersion));
+	json_object_add_value_uint(reason_id, "TelemetryMinorVersion", le16_to_cpu(ri->TelemetryMinorVersion));
+
+	reserved = json_create_array();
+	json_object_add_value_array(reason_id, "Reserved", reserved);
+	for (int i = 0; i < sizeof(ri->Reserved); i++) {
+		json_object *val = json_object_new_int(ri->Reserved[i]);
+		json_object_array_add(reserved, val);
+	}
+}
+
+static void telemetry_log_reason_id_parse1_2_ext(const struct telemetry_log *tl,
+						 json_object *reason_id)
+{
+	const struct reason_indentifier_1_2 *ri;
+	json_object *dp_reserved;
+	json_object *reserved;
+
+	ri = (struct reason_indentifier_1_2 *) tl->log->rsnident;
+
+	json_object_object_add(reason_id, "SerialNumber", json_object_new_string_len(ri->SerialNumber, sizeof(ri->SerialNumber)));
+	json_object_add_value_uint64(reason_id, "OemDataMapOffset", le64_to_cpu(ri->OemDataMapOffset));
+	json_object_add_value_uint(reason_id, "TelemetryMajorVersion", le16_to_cpu(ri->TelemetryMajorVersion));
+	json_object_add_value_uint(reason_id, "TelemetryMinorVersion", le16_to_cpu(ri->TelemetryMinorVersion));
+	json_object_add_value_uint(reason_id, "ProductFamilyId", ri->ProductFamilyId);
+
+	reserved = json_create_array();
+	json_object_add_value_array(reason_id, "Reserved2", reserved);
+	for (int i = 0; i < sizeof(ri->Reserved2); i++) {
+		json_object *val = json_object_new_int(ri->Reserved2[i]);
+		json_object_array_add(reserved, val);
+	}
+
+	dp_reserved = json_create_array();
+	json_object_add_value_array(reason_id, "DualPortReserved", dp_reserved);
+	for (int i = 0; i < sizeof(ri->DualPortReserved); i++) {
+		json_object *val =  json_object_new_int(ri->DualPortReserved[i]);
+		json_object_array_add(dp_reserved, val);
+	}
+}
+
+static void solidigm_telemetry_log_reason_id_parse(const struct telemetry_log *tl, json_object *reason_id)
+{
+	const struct reason_indentifier_1_0 *ri1_0 =
+		(struct reason_indentifier_1_0 *) tl->log->rsnident;
+	__u16 version_major = le16_to_cpu(ri1_0->versionMajor);
+	__u16 version_minor = le16_to_cpu(ri1_0->versionMinor);
+
+	json_object_add_value_uint(reason_id, "versionMajor", version_major);
+	json_object_add_value_uint(reason_id, "versionMinor", version_minor);
+	json_object_add_value_uint(reason_id, "reasonCode", le32_to_cpu(ri1_0->reasonCode));
+	json_object_add_value_object(reason_id, "DriveStatus", json_object_new_string_len(ri1_0->DriveStatus, sizeof(ri1_0->DriveStatus)));
+	if (version_major == 1) {
+		switch (version_minor) {
+			case 0:
+				telemetry_log_reason_id_parse1_0_ext(tl, reason_id);
+				break;
+			case 1:
+				telemetry_log_reason_id_parse1_1_ext(tl, reason_id);
+				break;
+			default:
+				telemetry_log_reason_id_parse1_2_ext(tl, reason_id);
+		}
+	}
+}
+
+bool solidigm_telemetry_log_header_parse(const struct telemetry_log *tl)
+{
+	const struct nvme_telemetry_log *log;
+	json_object *ieee_oui_id;
+	json_object *reason_id;
+	json_object *header;
+
+	if (tl->log_size < sizeof(const struct nvme_telemetry_log)) {
+		SOLIDIGM_LOG_WARNING("Telemetry log too short.");
+		return false;
+	}
+
+	header = json_create_object();
+
+	json_object_object_add(tl->root, "telemetryHeader", header);
+	log = tl->log;
+
+	json_object_add_value_uint(header, "logIdentifier", log->lpi);
+	ieee_oui_id = json_create_array();
+
+	json_object_object_add(header, "ieeeOuiIdentifier", ieee_oui_id);
+	for (int i = 0; i < sizeof(log->ieee); i++) {
+		json_object *val = json_object_new_int(log->ieee[i]);
+
+		json_object_array_add(ieee_oui_id, val);
+	}
+	json_object_add_value_uint(header, "dataArea1LastBlock", log->dalb1);
+	json_object_add_value_uint(header, "dataArea2LastBlock", log->dalb2);
+	json_object_add_value_uint(header, "dataArea3LastBlock", log->dalb3);
+	json_object_add_value_uint(header, "hostInitiatedDataGeneration", log->hostdgn);
+	json_object_add_value_uint(header, "controllerInitiatedDataAvailable", log->ctrlavail);
+	json_object_add_value_uint(header, "controllerInitiatedDataGeneration", log->ctrldgn);
+
+	reason_id = json_create_object();
+	json_object_add_value_object(header, "reasonIdentifier", reason_id);
+	solidigm_telemetry_log_reason_id_parse(tl, reason_id);
+
+	return true;
+}
diff --git a/plugins/solidigm/solidigm-telemetry/header.h b/plugins/solidigm/solidigm-telemetry/header.h
new file mode 100644
index 0000000..027af55
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/header.h
@@ -0,0 +1,9 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "telemetry-log.h"
+bool solidigm_telemetry_log_header_parse(const struct telemetry_log *tl);
diff --git a/plugins/solidigm/solidigm-telemetry/meson.build b/plugins/solidigm/solidigm-telemetry/meson.build
new file mode 100644
index 0000000..53ab452
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/meson.build
@@ -0,0 +1,6 @@
+sources += [
+  'plugins/solidigm/solidigm-telemetry/cod.c',
+  'plugins/solidigm/solidigm-telemetry/header.c',
+  'plugins/solidigm/solidigm-telemetry/config.c',
+  'plugins/solidigm/solidigm-telemetry/data-area.c',
+]
diff --git a/plugins/solidigm/solidigm-telemetry/telemetry-log.h b/plugins/solidigm/solidigm-telemetry/telemetry-log.h
new file mode 100644
index 0000000..ef4ec5d
--- /dev/null
+++ b/plugins/solidigm/solidigm-telemetry/telemetry-log.h
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright (c) 2022 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#ifndef _SOLIDIGM_TELEMETRY_LOG_H
+#define _SOLIDIGM_TELEMETRY_LOG_H
+
+#include "libnvme.h"
+#include "util/json.h"
+#include <assert.h>
+
+#if !defined __cplusplus
+#define static_assert _Static_assert
+#endif
+
+#define VA_ARGS(...), ##__VA_ARGS__
+#define SOLIDIGM_LOG_WARNING(format, ...) fprintf(stderr, format"\n" VA_ARGS(__VA_ARGS__))
+
+#define MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+
+struct telemetry_log {
+	struct nvme_telemetry_log *log;
+	size_t log_size;
+	json_object *root;
+	json_object *configuration;
+};
+
+#endif /* _SOLIDIGM_TELEMETRY_LOG_H */
\ No newline at end of file