diag: Build Mask Centralization (a39838b5) · Commits · e / devices / android_kernel_sony_msm8994

drivers/char/diag/diag_debugfs.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -109,6 +109,9 @@ static ssize_t diag_dbgfs_read_status(struct file file, char __user ubuf,
		"Received Feature mask from Modem: %d\n"
		"Received Feature mask from LPASS: %d\n"
		"Received Feature mask from WCNSS: %d\n"
		"Mask Centralization Support on Modem: %d\n"
		"Mask Centralization Support on LPASS: %d\n"
		"Mask Centralization Support on WCNSS: %d\n"
		"logging_mode: %d\n"
		"rsp_in_busy: %d\n",
		driver->smd_data[MODEM_DATA].ch,
		@@ -179,6 +182,9 @@ static ssize_t diag_dbgfs_read_status(struct file file, char __user ubuf,
		driver->rcvd_feature_mask[MODEM_DATA],
		driver->rcvd_feature_mask[LPASS_DATA],
		driver->rcvd_feature_mask[WCNSS_DATA],
		driver->mask_centralization[MODEM_DATA],
		driver->mask_centralization[LPASS_DATA],
		driver->mask_centralization[WCNSS_DATA],
		driver->logging_mode,
		driver->rsp_buf_busy);

drivers/char/diag/diag_masks.c

+60 −16

Original line number	Diff line number	Diff line
		@@ -62,12 +62,14 @@ static int diag_apps_responds(void)
		{
		/*
		* Apps processor should respond to mask commands only if the
		* Modem channel is up and the feature mask is received from
		* Modem.
		* Modem channel is up, the feature mask is received from Modem
		* and if Modem supports Mask Centralization.
		*/
		if (chk_apps_only()) {
		if (driver->smd_data[MODEM_DATA].ch &&
		driver->rcvd_feature_mask[MODEM_DATA]) {
		if (driver->mask_centralization[MODEM_DATA])
		return 1;
		return 0;
		}
		return 1;
		@@ -83,6 +85,7 @@ static void diag_send_log_mask_update(struct diag_smd_info *smd_info,
		int send_once = 0;
		int header_len = sizeof(struct diag_ctrl_log_mask);
		uint8_t *buf = log_mask.update_buf;
		uint8_t *temp = NULL;
		uint32_t mask_size = 0;
		struct diag_ctrl_log_mask ctrl_pkt;
		struct diag_log_mask_t mask = (struct diag_log_mask_t )log_mask.ptr;
		@@ -134,11 +137,16 @@ static void diag_send_log_mask_update(struct diag_smd_info *smd_info,
		ctrl_pkt.data_len = LOG_MASK_CTRL_HEADER_LEN + mask_size;

		if (header_len + mask_size > log_mask.update_buf_len) {
		pr_err("diag: In %s, invalid log mask size %d, buf_len: %d, equip_id: %d\n",
		__func__, mask_size,
		log_mask.update_buf_len, equip_id);
		temp = krealloc(buf, header_len + mask_size,
		GFP_KERNEL);
		if (!temp) {
		pr_err("diag: Unable to realloc log update buffer, new size: %d, equip_id: %d\n",
		header_len + mask_size, equip_id);
		break;
		}
		log_mask.update_buf = temp;
		log_mask.update_buf_len = header_len + mask_size;
		}

		memcpy(buf, &ctrl_pkt, header_len);
		if (mask_size > 0)
		@@ -159,10 +167,12 @@ static void diag_send_log_mask_update(struct diag_smd_info *smd_info,
		static void diag_send_event_mask_update(struct diag_smd_info *smd_info)
		{
		uint8_t *buf = event_mask.update_buf;
		uint8_t *temp = NULL;
		struct diag_ctrl_event_mask header;
		int num_bytes = EVENT_COUNT_TO_BYTES(driver->last_event_id);
		int write_len = 0;
		int err = 0;
		int temp_len = 0;

		if (num_bytes <= 0 \|\| num_bytes > driver->event_mask_size) {
		pr_debug("diag: In %s, invalid event mask length %d\n",
		@@ -197,9 +207,15 @@ static void diag_send_event_mask_update(struct diag_smd_info *smd_info)
		header.event_config = 1;
		header.event_mask_size = num_bytes;
		if (num_bytes + sizeof(header) > event_mask.update_buf_len) {
		pr_err("diag: In %s, invalid event mask length %d\n",
		__func__, num_bytes);
		temp_len = num_bytes + sizeof(header);
		temp = krealloc(buf, temp_len, GFP_KERNEL);
		if (!temp) {
		pr_err("diag: Unable to realloc event mask update buffer\n");
		goto err;
		} else {
		event_mask.update_buf = temp;
		event_mask.update_buf_len = temp_len;
		}
		}
		memcpy(buf + sizeof(header), event_mask.ptr, num_bytes);
		write_len += num_bytes;
		@@ -228,7 +244,9 @@ static void diag_send_msg_mask_update(struct diag_smd_info *smd_info,
		int i;
		int err = 0;
		int header_len = sizeof(struct diag_ctrl_msg_mask);
		int temp_len = 0;
		uint8_t *buf = msg_mask.update_buf;
		uint8_t *temp = NULL;
		uint32_t mask_size = 0;
		struct diag_msg_mask_t mask = (struct diag_msg_mask_t )msg_mask.ptr;
		struct diag_ctrl_msg_mask header;
		@@ -264,8 +282,26 @@ static void diag_send_msg_mask_update(struct diag_smd_info *smd_info,
		continue;
		}

		if (msg_mask.status == DIAG_CTRL_MASK_VALID)
		if (msg_mask.status == DIAG_CTRL_MASK_VALID) {
		mask_size = mask->ssid_last - mask->ssid_first + 1;
		temp_len = mask_size * sizeof(uint32_t);
		if (temp_len + header_len <= msg_mask.update_buf_len)
		goto proceed;
		temp = krealloc(msg_mask.update_buf, temp_len,
		GFP_KERNEL);
		if (!temp) {
		pr_err("diag: In %s, unable to realloc msg_mask update buffer\n",
		__func__);
		mask_size = (msg_mask.update_buf_len -
		header_len) / sizeof(uint32_t);
		} else {
		msg_mask.update_buf = temp;
		msg_mask.update_buf_len = temp_len;
		pr_debug("diag: In %s, successfully reallocated msg_mask update buffer to len: %d\n",
		__func__, msg_mask.update_buf_len);
		}
		}
		proceed:
		header.cmd_type = DIAG_CTRL_MSG_F3_MASK;
		header.status = msg_mask.status;
		header.stream_id = 1;
		@@ -276,11 +312,6 @@ static void diag_send_msg_mask_update(struct diag_smd_info *smd_info,
		mask_size *= sizeof(uint32_t);
		header.data_len = MSG_MASK_CTRL_HEADER_LEN + mask_size;
		memcpy(buf, &header, header_len);
		if (mask_size + header_len > msg_mask.update_buf_len) {
		pr_err("diag: In %s, invalid length for msg mask update buffer %d\n",
		__func__, mask_size + header_len);
		break;
		}
		if (mask_size > 0)
		memcpy(buf + header_len, mask->ptr, mask_size);

		@@ -331,6 +362,7 @@ static void diag_send_feature_mask_update(struct diag_smd_info *smd_info)
		DIAG_SET_FEATURE_MASK(F_DIAG_REQ_RSP_SUPPORT);
		if (driver->supports_apps_hdlc_encoding)
		DIAG_SET_FEATURE_MASK(F_DIAG_APPS_HDLC_ENCODE);
		DIAG_SET_FEATURE_MASK(F_DIAG_MASK_CENTRALIZATION);
		memcpy(buf + header_size, &feature_bytes, FEATURE_MASK_LEN);
		total_len = header_size + FEATURE_MASK_LEN;

		@@ -1220,6 +1252,7 @@ static int __diag_mask_init(struct diag_mask_info *mask_info, int mask_len,
		static int diag_msg_mask_init(void)
		{
		int err = 0;
		int i;

		err = __diag_mask_init(&msg_mask, MSG_MASK_SIZE, APPS_BUF_SIZE);
		if (err)
		@@ -1231,6 +1264,9 @@ static int diag_msg_mask_init(void)
		}
		driver->msg_mask = &msg_mask;

		for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++)
		driver->max_ssid_count[i] = 0;

		return 0;
		}

		@@ -1283,6 +1319,7 @@ static void diag_build_time_mask_exit(void)
		static int diag_log_mask_init(void)
		{
		int err = 0;
		int i;

		err = __diag_mask_init(&log_mask, LOG_MASK_SIZE, APPS_BUF_SIZE);
		if (err)
		@@ -1292,6 +1329,9 @@ static int diag_log_mask_init(void)
		return err;
		driver->log_mask = &log_mask;

		for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++)
		driver->num_equip_id[i] = 0;

		return 0;
		}

		@@ -1313,6 +1353,7 @@ static void diag_log_mask_exit(void)
		static int diag_event_mask_init(void)
		{
		int err = 0;
		int i;

		err = __diag_mask_init(&event_mask, EVENT_MASK_SIZE, APPS_BUF_SIZE);
		if (err)
		@@ -1321,6 +1362,9 @@ static int diag_event_mask_init(void)
		driver->last_event_id = APPS_EVENT_LAST_ID;
		driver->event_mask = &event_mask;

		for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++)
		driver->num_event_id[i] = 0;

		return 0;
		}

drivers/char/diag/diagchar.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -443,6 +443,7 @@ struct diagchar_dev {
		int separate_cmdrsp[NUM_SMD_CONTROL_CHANNELS];
		unsigned char *usb_buf_out;
		uint8_t peripheral_feature[NUM_SMD_CONTROL_CHANNELS][FEATURE_MASK_LEN];
		uint8_t mask_centralization[NUM_SMD_CONTROL_CHANNELS];
		unsigned char *apps_rsp_buf;
		unsigned char *user_space_data_buf;
		/* buffer for updating mask to peripherals */
		@@ -499,6 +500,10 @@ struct diagchar_dev {
		uint8_t msg_mask_tbl_count;
		uint16_t event_mask_size;
		uint16_t last_event_id;
		/* Variables for Mask Centralization */
		uint16_t num_event_id[NUM_SMD_CONTROL_CHANNELS];
		uint32_t num_equip_id[NUM_SMD_CONTROL_CHANNELS];
		uint32_t max_ssid_count[NUM_SMD_CONTROL_CHANNELS];
		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		/* common for all bridges */
		struct work_struct diag_connect_work;

drivers/char/diag/diagfwd_cntl.c

+298 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include "diagfwd_hsic.h"
		#include "diag_dci.h"
		#include "diagmem.h"
		#include "diag_masks.h"

		#define FEATURE_SUPPORTED(x) ((feature_mask << (i * 8)) & (1 << x))

		@@ -236,6 +237,288 @@ static void process_incoming_feature_mask(uint8_t *buf, uint32_t len,
		process_hdlc_encoding_feature(smd_info);
		if (FEATURE_SUPPORTED(F_DIAG_STM))
		enable_stm_feature(smd_info);
		if (FEATURE_SUPPORTED(F_DIAG_MASK_CENTRALIZATION))
		driver->mask_centralization[smd_info->peripheral] = 1;
		}
		}

		static void process_last_event_report(uint8_t *buf, uint32_t len,
		struct diag_smd_info *smd_info)
		{
		struct diag_ctrl_last_event_report *header = NULL;
		uint8_t *ptr = buf;
		uint8_t *temp = NULL;
		uint32_t pkt_len = sizeof(uint32_t) + sizeof(uint16_t);
		uint16_t event_size = 0;

		if (!buf \|\| !smd_info \|\| len != pkt_len)
		return;

		mutex_lock(&event_mask.lock);
		header = (struct diag_ctrl_last_event_report *)ptr;
		event_size = ((header->event_last_id / 8) + 1);
		if (event_size >= driver->event_mask_size) {
		pr_debug("diag: In %s, receiving event mask size more that Apps can handle\n",
		__func__);
		temp = krealloc(driver->event_mask->ptr, event_size,
		GFP_KERNEL);
		if (!temp) {
		pr_err("diag: In %s, unable to reallocate event mask to support events from %d\n",
		__func__, smd_info->peripheral);
		goto err;
		}
		driver->event_mask->ptr = temp;
		driver->event_mask_size = event_size;
		}

		driver->num_event_id[smd_info->peripheral] = header->event_last_id;
		if (header->event_last_id > driver->last_event_id)
		driver->last_event_id = header->event_last_id;
		err:
		mutex_unlock(&event_mask.lock);
		}

		static void process_log_range_report(uint8_t *buf, uint32_t len,
		struct diag_smd_info *smd_info)
		{
		int i;
		int read_len = 0;
		int peripheral = 0;
		int header_len = sizeof(struct diag_ctrl_log_range_report);
		uint8_t *ptr = buf;
		uint8_t *temp = NULL;
		uint32_t mask_size;
		struct diag_ctrl_log_range_report *header = NULL;
		struct diag_ctrl_log_range *log_range = NULL;
		struct diag_log_mask_t *mask_ptr = NULL;

		if (!buf \|\| !smd_info \|\| len < 0)
		return;

		peripheral = smd_info->peripheral;
		header = (struct diag_ctrl_log_range_report *)ptr;
		ptr += header_len;
		read_len += header_len;

		mutex_lock(&log_mask.lock);
		driver->num_equip_id[peripheral] = header->num_ranges;
		for (i = 0; i < header->num_ranges && read_len < len; i++) {
		log_range = (struct diag_ctrl_log_range *)ptr;
		ptr += sizeof(struct diag_ctrl_log_range);
		read_len += sizeof(struct diag_ctrl_log_range);

		if (log_range->equip_id >= MAX_EQUIP_ID) {
		pr_err("diag: receiving log equip id %d more than supported equip id: %d from peripheral: %d\n",
		log_range->equip_id, MAX_EQUIP_ID, peripheral);
		continue;
		}
		mask_ptr = (struct diag_log_mask_t *)log_mask.ptr;
		mask_ptr = &mask_ptr[log_range->equip_id];
		mask_size = LOG_ITEMS_TO_SIZE(log_range->num_items);
		if (mask_size < mask_ptr->range)
		goto proceed;

		temp = krealloc(mask_ptr->ptr, mask_size, GFP_KERNEL);
		if (!temp) {
		pr_err("diag: In %s, Unable to reallocate log mask ptr to size: %d, equip_id: %d\n",
		__func__, mask_size, log_range->equip_id);
		continue;
		}
		mask_ptr->ptr = temp;
		mask_ptr->range = mask_size;
		proceed:
		if (log_range->num_items > mask_ptr->num_items)
		mask_ptr->num_items = log_range->num_items;
		}
		mutex_unlock(&log_mask.lock);
		}

		static int update_msg_mask_tbl_entry(struct diag_msg_mask_t *mask,
		struct diag_ssid_range_t *range)
		{
		uint32_t temp_range;
		uint32_t *temp = NULL;

		if (!mask \|\| !range)
		return -EIO;
		if (range->ssid_last < range->ssid_first) {
		pr_err("diag: In %s, invalid ssid range, first: %d, last: %d\n",
		__func__, range->ssid_first, range->ssid_last);
		return -EINVAL;
		}
		if (range->ssid_last >= mask->ssid_last) {
		temp_range = range->ssid_last - mask->ssid_first + 1;
		temp = krealloc(mask->ptr, temp_range * sizeof(uint32_t),
		GFP_KERNEL);
		if (!temp)
		return -ENOMEM;
		mask->ptr = temp;
		mask->ssid_last = range->ssid_last;
		mask->range = temp_range;
		}

		return 0;
		}

		static void process_ssid_range_report(uint8_t *buf, uint32_t len,
		struct diag_smd_info *smd_info)
		{
		int i;
		int j;
		int read_len = 0;
		int found = 0;
		int new_size = 0;
		int err = 0;
		struct diag_ctrl_ssid_range_report *header = NULL;
		struct diag_ssid_range_t *ssid_range = NULL;
		int header_len = sizeof(struct diag_ctrl_ssid_range_report);
		struct diag_msg_mask_t *mask_ptr = NULL;
		uint8_t *ptr = buf;
		uint8_t *temp = NULL;
		uint32_t min_len = header_len - sizeof(struct diag_ctrl_pkt_header_t);

		if (!buf \|\| !smd_info \|\| len < min_len)
		return;

		header = (struct diag_ctrl_ssid_range_report *)ptr;
		ptr += header_len;
		read_len += header_len;

		mutex_lock(&msg_mask.lock);
		driver->max_ssid_count[smd_info->peripheral] = header->count;
		for (i = 0; i < header->count && read_len < len; i++) {
		ssid_range = (struct diag_ssid_range_t *)ptr;
		ptr += sizeof(struct diag_ssid_range_t);
		read_len += sizeof(struct diag_ssid_range_t);
		mask_ptr = (struct diag_msg_mask_t *)msg_mask.ptr;
		found = 0;
		for (j = 0; j < driver->msg_mask_tbl_count; j++, mask_ptr++) {
		if (mask_ptr->ssid_first != ssid_range->ssid_first)
		continue;
		err = update_msg_mask_tbl_entry(mask_ptr, ssid_range);
		if (err == -ENOMEM) {
		pr_err("diag: In %s, unable to increase the msg mask table range\n",
		__func__);
		}
		found = 1;
		break;
		}

		if (found)
		continue;

		new_size = (driver->msg_mask_tbl_count + 1) *
		sizeof(struct diag_msg_mask_t);
		temp = krealloc(msg_mask.ptr, new_size, GFP_KERNEL);
		if (!temp) {
		pr_err("diag: In %s, Unable to add new ssid table to msg mask, ssid first: %d, last: %d\n",
		__func__, ssid_range->ssid_first,
		ssid_range->ssid_last);
		continue;
		}
		msg_mask.ptr = temp;
		err = diag_create_msg_mask_table_entry(mask_ptr, ssid_range);
		if (err) {
		pr_err("diag: In %s, Unable to create a new msg mask table entry, first: %d last: %d err: %d\n",
		__func__, ssid_range->ssid_first,
		ssid_range->ssid_last, err);
		continue;
		}
		driver->msg_mask_tbl_count += 1;
		}
		mutex_unlock(&msg_mask.lock);
		}

		static void diag_build_time_mask_update(uint8_t *buf,
		struct diag_ssid_range_t *range)
		{
		int i;
		int j;
		int num_items = 0;
		int err = 0;
		int found = 0;
		int new_size = 0;
		uint8_t *temp = NULL;
		uint32_t mask_ptr = (uint32_t )buf;
		uint32_t *dest_ptr = NULL;
		struct diag_msg_mask_t *build_mask = NULL;

		if (!range \|\| !buf)
		return;

		if (range->ssid_last < range->ssid_first) {
		pr_err("diag: In %s, invalid ssid range, first: %d, last: %d\n",
		__func__, range->ssid_first, range->ssid_last);
		return;
		}

		build_mask = (struct diag_msg_mask_t *)(driver->build_time_mask->ptr);
		num_items = range->ssid_last - range->ssid_first + 1;

		mutex_lock(&driver->build_time_mask->lock);
		for (i = 0; i < driver->msg_mask_tbl_count; i++, build_mask++) {
		if (build_mask->ssid_first != range->ssid_first)
		continue;
		found = 1;
		err = update_msg_mask_tbl_entry(build_mask, range);
		if (err == -ENOMEM) {
		pr_err("diag: In %s, unable to increase the msg build mask table range\n",
		__func__);
		}
		dest_ptr = build_mask->ptr;
		for (j = 0; j < build_mask->range; j++, mask_ptr++, dest_ptr++)
		(uint32_t )dest_ptr \|= *mask_ptr;
		break;
		}

		if (found)
		goto end;
		new_size = (driver->msg_mask_tbl_count + 1) *
		sizeof(struct diag_msg_mask_t);
		temp = krealloc(driver->build_time_mask->ptr, new_size, GFP_KERNEL);
		if (!temp) {
		pr_err("diag: In %s, unable to create a new entry for build time mask\n",
		__func__);
		goto end;
		}
		driver->build_time_mask->ptr = temp;
		err = diag_create_msg_mask_table_entry(build_mask, range);
		if (err) {
		pr_err("diag: In %s, Unable to create a new msg mask table entry, err: %d\n",
		__func__, err);
		goto end;
		}
		driver->msg_mask_tbl_count += 1;
		end:
		mutex_unlock(&driver->build_time_mask->lock);
		}

		static void process_build_mask_report(uint8_t *buf, uint32_t len,
		struct diag_smd_info *smd_info)
		{
		int i;
		int read_len = 0;
		int num_items = 0;
		int header_len = sizeof(struct diag_ctrl_build_mask_report);
		uint8_t *ptr = buf;
		struct diag_ctrl_build_mask_report *header = NULL;
		struct diag_ssid_range_t *range = NULL;

		if (!buf \|\| !smd_info \|\| len < header_len)
		return;

		header = (struct diag_ctrl_build_mask_report *)ptr;
		ptr += header_len;
		read_len += header_len;

		for (i = 0; i < header->count && read_len < len; i++) {
		range = (struct diag_ssid_range_t *)ptr;
		ptr += sizeof(struct diag_ssid_range_t);
		read_len += sizeof(struct diag_ssid_range_t);
		num_items = range->ssid_last - range->ssid_first + 1;
		diag_build_time_mask_update(ptr, range);
		ptr += num_items * sizeof(uint32_t);
		read_len += num_items * sizeof(uint32_t);
		}
		}

		@@ -262,6 +545,21 @@ int diag_process_smd_cntl_read_data(struct diag_smd_info smd_info, void buf,
		process_incoming_feature_mask(ptr, ctrl_pkt->len,
		smd_info);
		break;
		case DIAG_CTRL_MSG_LAST_EVENT_REPORT:
		process_last_event_report(ptr, ctrl_pkt->len,
		smd_info);
		break;
		case DIAG_CTRL_MSG_LOG_RANGE_REPORT:
		process_log_range_report(ptr, ctrl_pkt->len, smd_info);
		break;
		case DIAG_CTRL_MSG_SSID_RANGE_REPORT:
		process_ssid_range_report(ptr, ctrl_pkt->len,
		smd_info);
		break;
		case DIAG_CTRL_MSG_BUILD_MASK_REPORT:
		process_build_mask_report(ptr, ctrl_pkt->len,
		smd_info);
		break;
		default:
		pr_debug("diag: Control packet %d not supported\n",
		ctrl_pkt->pkt_id);

drivers/char/diag/diagfwd_cntl.h

+39 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,10 @@
		#define DIAG_CTRL_MSG_EVENT_MASK_WITH_PRESET_ID 15
		#define DIAG_CTRL_MSG_F3_MASK_WITH_PRESET_ID 16
		#define DIAG_CTRL_MSG_DCI_CONNECTION_STATUS 20
		#define DIAG_CTRL_MSG_LAST DIAG_CTRL_MSG_DCI_CONNECTION_STATUS
		#define DIAG_CTRL_MSG_LAST_EVENT_REPORT 22
		#define DIAG_CTRL_MSG_LOG_RANGE_REPORT 23
		#define DIAG_CTRL_MSG_SSID_RANGE_REPORT 24
		#define DIAG_CTRL_MSG_BUILD_MASK_REPORT 25

		/*
		* Feature Mask Definitions: Feature mask is used to sepcify Diag features
		@@ -53,6 +56,7 @@
		#define F_DIAG_REQ_RSP_SUPPORT 4
		#define F_DIAG_APPS_HDLC_ENCODE 6
		#define F_DIAG_STM 9
		#define F_DIAG_MASK_CENTRALIZATION 11

		#define ENABLE_SEPARATE_CMDRSP 1
		#define DISABLE_SEPARATE_CMDRSP 0
		@@ -158,6 +162,40 @@ struct diag_ctrl_dci_status {
		uint8_t count;
		} __packed;

		struct diag_ctrl_last_event_report {
		uint32_t pkt_id;
		uint32_t len;
		uint32_t version;
		uint16_t event_last_id;
		} __packed;

		struct diag_ctrl_log_range_report {
		uint32_t pkt_id;
		uint32_t len;
		uint32_t version;
		uint32_t last_equip_id;
		uint32_t num_ranges;
		} __packed;

		struct diag_ctrl_log_range {
		uint32_t equip_id;
		uint32_t num_items;
		} __packed;

		struct diag_ctrl_ssid_range_report {
		uint32_t pkt_id;
		uint32_t len;
		uint32_t version;
		uint32_t count;
		} __packed;

		struct diag_ctrl_build_mask_report {
		uint32_t pkt_id;
		uint32_t len;
		uint32_t version;
		uint32_t count;
		} __packed;

		int diagfwd_cntl_init(void);
		void diagfwd_cntl_exit(void);
		void diag_read_smd_cntl_work_fn(struct work_struct *);