Merge "diag: Change implementation of Diag masks" (3c37a681) · Commits · e / devices / android_kernel_sony_msm8994

drivers/char/diag/diag_dci.c

+18 −16

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

		static struct timer_list dci_drain_timer;
		static int dci_timer_in_progress;
		@@ -1979,9 +1980,9 @@ int diag_send_dci_event_mask_remote(int token)
		dci_header.cmd_code = DCI_CONTROL_PKT_CODE;

		event_mask.cmd_type = DIAG_CTRL_MSG_EVENT_MASK;
		event_mask.data_len = 7 + DCI_EVENT_MASK_SIZE;
		event_mask.data_len = EVENT_MASK_CTRL_HEADER_LEN + DCI_EVENT_MASK_SIZE;
		event_mask.stream_id = DCI_MASK_STREAM;
		event_mask.status = 3; /* status for valid mask */
		event_mask.status = DIAG_CTRL_MASK_VALID;
		event_mask.event_config = 0; /* event config */
		event_mask.event_mask_size = DCI_EVENT_MASK_SIZE;
		for (i = 0; i < DCI_EVENT_MASK_SIZE; i++) {
		@@ -2013,27 +2014,28 @@ int diag_send_dci_event_mask_remote(int token)

		int diag_send_dci_event_mask(int token)
		{
		void *buf = driver->buf_event_mask_update;
		void *buf = event_mask.update_buf;
		struct diag_ctrl_event_mask header;
		int header_size = sizeof(struct diag_ctrl_event_mask);
		int ret = DIAG_DCI_NO_ERROR, err = DIAG_DCI_NO_ERROR, i;
		unsigned char *event_mask_ptr = dci_ops_tbl[DCI_LOCAL_PROC].
		event_mask_composite;

		mutex_lock(&driver->diag_cntl_mutex);
		mutex_lock(&event_mask.lock);
		/* send event mask update */
		driver->event_mask->cmd_type = DIAG_CTRL_MSG_EVENT_MASK;
		driver->event_mask->data_len = 7 + DCI_EVENT_MASK_SIZE;
		driver->event_mask->stream_id = DCI_MASK_STREAM;
		driver->event_mask->status = 3; /* status for valid mask */
		driver->event_mask->event_config = 0; /* event config */
		driver->event_mask->event_mask_size = DCI_EVENT_MASK_SIZE;
		header.cmd_type = DIAG_CTRL_MSG_EVENT_MASK;
		header.data_len = EVENT_MASK_CTRL_HEADER_LEN + DCI_EVENT_MASK_SIZE;
		header.stream_id = DCI_MASK_STREAM;
		header.status = DIAG_CTRL_MASK_VALID;
		header.event_config = 0; /* event config */
		header.event_mask_size = DCI_EVENT_MASK_SIZE;
		for (i = 0; i < DCI_EVENT_MASK_SIZE; i++) {
		if (event_mask_ptr[i] != 0) {
		driver->event_mask->event_config = 1;
		header.event_config = 1;
		break;
		}
		}
		memcpy(buf, driver->event_mask, header_size);
		memcpy(buf, &header, header_size);
		memcpy(buf+header_size, event_mask_ptr, DCI_EVENT_MASK_SIZE);
		for (i = 0; i < NUM_SMD_DCI_CHANNELS; i++) {
		/*
		@@ -2048,7 +2050,7 @@ int diag_send_dci_event_mask(int token)
		if (err != DIAG_DCI_NO_ERROR)
		ret = DIAG_DCI_SEND_DATA_FAIL;
		}
		mutex_unlock(&driver->diag_cntl_mutex);
		mutex_unlock(&event_mask.lock);

		return ret;
		}
		@@ -2192,13 +2194,13 @@ int diag_send_dci_log_mask_remote(int token)

		int diag_send_dci_log_mask(int token)
		{
		void *buf = driver->buf_log_mask_update;
		void *buf = log_mask.update_buf;
		int write_len = 0;
		uint8_t *log_mask_ptr = dci_ops_tbl[DCI_LOCAL_PROC].log_mask_composite;
		int i, j, ret = DIAG_DCI_NO_ERROR, err = DIAG_DCI_NO_ERROR;
		int updated;

		mutex_lock(&driver->diag_cntl_mutex);
		mutex_lock(&log_mask.lock);
		for (i = 0; i < 16; i++) {
		updated = 1;
		/* Dirty bit is set don't update the mask for this equip id */
		@@ -2226,7 +2228,7 @@ int diag_send_dci_log_mask(int token)
		(log_mask_ptr+1) = 0; / clear dirty byte */
		log_mask_ptr += 514;
		}
		mutex_unlock(&driver->diag_cntl_mutex);
		mutex_unlock(&log_mask.lock);

		return ret;
		}

drivers/char/diag/diag_masks.c

+1375 −770

File changed.

Preview size limit exceeded, changes collapsed.

drivers/char/diag/diag_masks.h

+134 −7

Original line number	Diff line number	Diff line
		@@ -18,17 +18,144 @@
		struct diag_log_mask_t {
		uint8_t equip_id;
		uint32_t num_items;
		uint8_t ptr[MAX_ITEMS_PER_EQUIP_ID];
		uint32_t range;
		uint8_t *ptr;
		} __packed;

		void diag_send_event_mask_update(struct diag_smd_info *smd_info, int num_bytes);
		void diag_send_msg_mask_update(struct diag_smd_info *smd_info, int ssid_first,
		int ssid_last, int proc);
		void diag_send_log_mask_update(struct diag_smd_info *smd_info, int);
		struct diag_ssid_range_t {
		uint16_t ssid_first;
		uint16_t ssid_last;
		} __packed;

		struct diag_msg_mask_t {
		uint32_t ssid_first;
		uint32_t ssid_last;
		uint32_t range;
		uint32_t *ptr;
		} __packed;

		struct diag_log_config_req_t {
		uint8_t cmd_code;
		uint8_t padding[3];
		uint32_t sub_cmd;
		uint32_t equip_id;
		uint32_t num_items;
		} __packed;

		struct diag_log_config_rsp_t {
		uint8_t cmd_code;
		uint8_t padding[3];
		uint32_t sub_cmd;
		uint32_t status;
		} __packed;

		struct diag_log_config_set_rsp_t {
		uint8_t cmd_code;
		uint8_t padding[3];
		uint32_t sub_cmd;
		uint32_t status;
		uint32_t equip_id;
		uint32_t num_items;
		} __packed;

		struct diag_log_on_demand_rsp_t {
		uint8_t cmd_code;
		uint16_t log_code;
		uint8_t status;
		} __packed;

		struct diag_event_report_t {
		uint8_t cmd_code;
		uint16_t padding;
		} __packed;

		struct diag_event_mask_config_t {
		uint8_t cmd_code;
		uint8_t status;
		uint16_t padding;
		uint16_t num_bits;
		} __packed;

		struct diag_msg_config_rsp_t {
		uint8_t cmd_code;
		uint8_t sub_cmd;
		uint8_t status;
		uint8_t padding;
		uint32_t rt_mask;
		} __packed;

		struct diag_msg_ssid_query_t {
		uint8_t cmd_code;
		uint8_t sub_cmd;
		uint8_t status;
		uint8_t padding;
		uint32_t count;
		} __packed;

		struct diag_build_mask_req_t {
		uint8_t cmd_code;
		uint8_t sub_cmd;
		uint16_t ssid_first;
		uint16_t ssid_last;
		} __packed;

		struct diag_msg_build_mask_t {
		uint8_t cmd_code;
		uint8_t sub_cmd;
		uint16_t ssid_first;
		uint16_t ssid_last;
		uint8_t status;
		uint8_t padding;
		} __packed;

		struct diag_msg_mask_userspace_t {
		uint32_t ssid_first;
		uint32_t ssid_last;
		uint32_t range;
		} __packed;

		struct diag_log_mask_userspace_t {
		uint8_t equip_id;
		uint32_t num_items;
		} __packed;

		#define MAX_EQUIP_ID 16
		#define MSG_MASK_SIZE (MSG_MASK_TBL_CNT * sizeof(struct diag_msg_mask_t))
		#define LOG_MASK_SIZE (MAX_EQUIP_ID * sizeof(struct diag_log_mask_t))
		#define EVENT_MASK_SIZE 512
		#define MAX_ITEMS_PER_EQUIP_ID 512

		#define LOG_MASK_CTRL_HEADER_LEN 11
		#define MSG_MASK_CTRL_HEADER_LEN 11
		#define EVENT_MASK_CTRL_HEADER_LEN 7

		#define LOG_STATUS_SUCCESS 0
		#define LOG_STATUS_INVALID 1
		#define LOG_STATUS_FAIL 2

		#define MSG_STATUS_FAIL 0
		#define MSG_STATUS_SUCCESS 1

		#define EVENT_STATUS_SUCCESS 1
		#define EVENT_STATUS_FAIL 0

		#define DIAG_CTRL_MASK_INVALID 0
		#define DIAG_CTRL_MASK_ALL_DISABLED 1
		#define DIAG_CTRL_MASK_ALL_ENABLED 2
		#define DIAG_CTRL_MASK_VALID 3

		extern struct diag_mask_info msg_mask;
		extern struct diag_mask_info msg_bt_mask;
		extern struct diag_mask_info log_mask;
		extern struct diag_mask_info event_mask;

		void diag_mask_update_fn(struct work_struct *work);
		void diag_send_feature_mask_update(struct diag_smd_info *smd_info);
		int diag_process_apps_masks(unsigned char *buf, int len);
		int diag_masks_init(void);
		void diag_masks_exit(void);
		extern int diag_event_num_bytes;

		extern int diag_create_msg_mask_table_entry(struct diag_msg_mask_t *msg_mask,
		struct diag_ssid_range_t *range);
		extern int diag_copy_to_user_msg_mask(char __user *buf, size_t count);
		extern int diag_copy_to_user_log_mask(char __user *buf, size_t count);
		#endif

drivers/char/diag/diagchar.h

+44 −26

Original line number	Diff line number	Diff line
		@@ -82,18 +82,7 @@
		#define HSIC_2_DATA 5
		#define SMUX_DATA 10
		#define APPS_PROC 1
		/*
		* Each row contains First (uint32_t), Last (uint32_t), Actual
		* last (uint32_t) values along with the range of SSIDs
		* (MAX_SSID_PER_RANGE*uint32_t).
		* And there are MSG_MASK_TBL_CNT rows.
		*/
		#define MSG_MASK_SIZE ((MAX_SSID_PER_RANGE+3) * 4 * MSG_MASK_TBL_CNT)
		#define MAX_EQUIP_ID 16
		#define MAX_ITEMS_PER_EQUIP_ID 512
		#define LOG_MASK_ITEM_SIZE (5 + MAX_ITEMS_PER_EQUIP_ID)
		#define LOG_MASK_SIZE (MAX_EQUIP_ID * LOG_MASK_ITEM_SIZE)
		#define EVENT_MASK_SIZE 1000

		#define USER_SPACE_DATA 8192
		#define PKT_SIZE 4096

		@@ -117,8 +106,13 @@
		#define DIAG_CMD_VERSION 0
		#define DIAG_CMD_DOWNLOAD 0x3A
		#define DIAG_CMD_DIAG_SUBSYS 0x4B
		#define DIAG_CMD_LOG_CONFIG 0x73
		#define DIAG_CMD_LOG_ON_DMND 0x78
		#define DIAG_CMD_EXT_BUILD 0x7c
		#define DIAG_CMD_MSG_CONFIG 0x7D
		#define DIAG_CMD_GET_EVENT_MASK 0x81
		#define DIAG_CMD_SET_EVENT_MASK 0x82
		#define DIAG_CMD_EVENT_TOGGLE 0x60

		#define DIAG_SS_DIAG 0x12
		#define DIAG_SS_PARAMS 0x32
		@@ -129,6 +123,17 @@
		#define DIAG_DEL_RSP_WRAP 0x04
		#define DIAG_DEL_RSP_WRAP_CNT 0x05

		#define DIAG_CMD_OP_LOG_DISABLE 0
		#define DIAG_CMD_OP_GET_LOG_RANGE 1
		#define DIAG_CMD_OP_SET_LOG_MASK 3
		#define DIAG_CMD_OP_GET_LOG_MASK 4

		#define DIAG_CMD_OP_GET_SSID_RANGE 1
		#define DIAG_CMD_OP_GET_BUILD_MASK 2
		#define DIAG_CMD_OP_GET_MSG_MASK 3
		#define DIAG_CMD_OP_SET_MSG_MASK 4
		#define DIAG_CMD_OP_SET_ALL_MSG_MASK 5

		#define BAD_PARAM_RESPONSE_MESSAGE 20

		#define MODE_CMD 41
		@@ -287,6 +292,25 @@ struct diag_request {
		};
		#endif

		/*
		* High level structure for storing Diag masks.
		*
		* @ptr: Pointer to the buffer that stores the masks
		* @mask_len: Length of the buffer pointed by ptr
		* @update_buf: Buffer for performing mask updates to peripherals
		* @update_buf_len: Length of the buffer pointed by buf
		* @status: status of the mask - all enable, disabled, valid
		* @lock: To protect access to the mask variables
		*/
		struct diag_mask_info {
		uint8_t *ptr;
		int mask_len;
		uint8_t *update_buf;
		int update_buf_len;
		uint8_t status;
		struct mutex lock;
		};

		struct diag_smd_info {
		int peripheral; /* The peripheral this smd channel communicates with */
		int type; /* The type of smd channel (data, control, dci) */
		@@ -404,10 +428,6 @@ struct diagchar_dev {
		int used;
		/* Buffers for masks */
		struct mutex diag_cntl_mutex;
		struct diag_ctrl_event_mask *event_mask;
		struct diag_ctrl_log_mask *log_mask;
		struct diag_ctrl_msg_mask *msg_mask;
		struct mutex log_mask_mutex;
		/* Members for Sending response */
		unsigned char *encoded_rsp_buf;
		uint8_t rsp_buf_busy;
		@@ -426,9 +446,6 @@ struct diagchar_dev {
		unsigned char *apps_rsp_buf;
		unsigned char *user_space_data_buf;
		/* buffer for updating mask to peripherals */
		unsigned char *buf_msg_mask_update;
		unsigned char *buf_log_mask_update;
		unsigned char *buf_event_mask_update;
		unsigned char *buf_feature_mask_update;
		int read_len_legacy;
		struct mutex diag_hdlc_mutex;
		@@ -456,12 +473,6 @@ struct diagchar_dev {
		struct workqueue_struct *diag_usb_wq;
		struct work_struct diag_drain_work;
		struct workqueue_struct *diag_cntl_wq;
		uint8_t *msg_masks;
		uint8_t msg_status;
		uint8_t *log_masks;
		uint8_t log_status;
		uint8_t *event_masks;
		uint8_t event_status;
		uint8_t log_on_demand_support;
		struct diag_master_table *table;
		uint8_t *pkt_buf;
		@@ -480,7 +491,14 @@ struct diagchar_dev {
		struct diag_ws_ref_t dci_ws;
		struct diag_ws_ref_t md_ws;
		spinlock_t ws_lock;

		/* Pointers to Diag Masks */
		struct diag_mask_info *msg_mask;
		struct diag_mask_info *log_mask;
		struct diag_mask_info *event_mask;
		struct diag_mask_info *build_time_mask;
		uint8_t msg_mask_tbl_count;
		uint16_t event_mask_size;
		uint16_t last_event_id;
		#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
		/* common for all bridges */
		struct work_struct diag_connect_work;

drivers/char/diag/diagchar_core.c

+11 −8

Original line number	Diff line number	Diff line
		@@ -1371,6 +1371,7 @@ static ssize_t diagchar_read(struct file file, char __user buf, size_t count,
		int remote_token;
		int exit_stat;
		int copy_data = 0;
		int write_len = 0;
		unsigned long flags;

		for (i = 0; i < driver->num_clients; i++)
		@@ -1548,9 +1549,10 @@ drop:
		if (driver->data_ready[index] & MSG_MASKS_TYPE) {
		/Copy the type of data being passed/
		data_type = driver->data_ready[index] & MSG_MASKS_TYPE;
		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);
		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->msg_masks),
		MSG_MASK_SIZE);
		COPY_USER_SPACE_OR_EXIT(buf, data_type, sizeof(int));
		write_len = diag_copy_to_user_msg_mask(buf + ret, count);
		if (write_len > 0)
		ret += write_len;
		driver->data_ready[index] ^= MSG_MASKS_TYPE;
		goto exit;
		}
		@@ -1559,8 +1561,8 @@ drop:
		/Copy the type of data being passed/
		data_type = driver->data_ready[index] & EVENT_MASKS_TYPE;
		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);
		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->event_masks),
		EVENT_MASK_SIZE);
		COPY_USER_SPACE_OR_EXIT(buf+4, *(event_mask.ptr),
		event_mask.mask_len);
		driver->data_ready[index] ^= EVENT_MASKS_TYPE;
		goto exit;
		}
		@@ -1568,9 +1570,10 @@ drop:
		if (driver->data_ready[index] & LOG_MASKS_TYPE) {
		/Copy the type of data being passed/
		data_type = driver->data_ready[index] & LOG_MASKS_TYPE;
		COPY_USER_SPACE_OR_EXIT(buf, data_type, 4);
		COPY_USER_SPACE_OR_EXIT(buf+4, *(driver->log_masks),
		LOG_MASK_SIZE);
		COPY_USER_SPACE_OR_EXIT(buf, data_type, sizeof(int));
		write_len = diag_copy_to_user_log_mask(buf + ret, count);
		if (write_len > 0)
		ret += write_len;
		driver->data_ready[index] ^= LOG_MASKS_TYPE;
		goto exit;
		}