Merge "diag: Add support for peripheral buffering modes" (f491a063) · Commits · e / devices / android_kernel_sony_msm8994

drivers/char/diag/diag_debugfs.c

+16 −0

Original line number	Diff line number	Diff line
		@@ -169,6 +169,14 @@ static ssize_t diag_dbgfs_read_status(struct file file, char __user ubuf,
		"Mask Centralization Support on LPASS: %d\n"
		"Mask Centralization Support on WCNSS: %d\n"
		"Mask Centralization Support on SENSORS: %d\n"
		"Buffering Mode Support on Modem: %d\n"
		"Buffering Mode Support on LPASS: %d\n"
		"Buffering Mode Support on WCNSS: %d\n"
		"Buffering Mode Support on SENSORS: %d\n"
		"Buffering Mode on Modem: %d\n"
		"Buffering Mode on LPASS: %d\n"
		"Buffering Mode on WCNSS: %d\n"
		"Buffering Mode on SENSORS: %d\n"
		"logging_mode: %d\n"
		"rsp_in_busy: %d\n",
		driver->smd_data[MODEM_DATA].ch,
		@@ -293,6 +301,14 @@ static ssize_t diag_dbgfs_read_status(struct file file, char __user ubuf,
		driver->mask_centralization[LPASS_DATA],
		driver->mask_centralization[WCNSS_DATA],
		driver->mask_centralization[SENSORS_DATA],
		driver->peripheral_buffering_support[MODEM_DATA],
		driver->peripheral_buffering_support[LPASS_DATA],
		driver->peripheral_buffering_support[WCNSS_DATA],
		driver->peripheral_buffering_support[SENSORS_DATA],
		driver->buffering_mode[MODEM_DATA].mode,
		driver->buffering_mode[LPASS_DATA].mode,
		driver->buffering_mode[WCNSS_DATA].mode,
		driver->buffering_mode[SENSORS_DATA].mode,
		driver->logging_mode,
		driver->rsp_buf_busy);

drivers/char/diag/diag_masks.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -1469,9 +1469,12 @@ void diag_mask_update_fn(struct work_struct *work)
		diag_send_log_mask_update(smd_info, ALL_EQUIP_ID);
		diag_send_event_mask_update(smd_info);

		if (smd_info->notify_context == SMD_EVENT_OPEN)
		if (smd_info->notify_context == SMD_EVENT_OPEN) {
		diag_send_diag_mode_update_by_smd(smd_info,
		driver->real_time_mode[DIAG_LOCAL_PROC]);
		diag_send_peripheral_buffering_mode(
		&driver->buffering_mode[smd_info->peripheral]);
		}

		smd_info->notify_context = 0;
		}

drivers/char/diag/diagchar.h

+23 −2

Original line number	Diff line number	Diff line
		@@ -118,8 +118,19 @@
		#define DIAG_STATUS_OPEN (0x00010000) /* DCI channel open status mask */
		#define DIAG_STATUS_CLOSED (0x00020000) /* DCI channel closed status mask */

		#define MODE_REALTIME 1
		#define MODE_NONREALTIME 0
		#define MODE_REALTIME 1
		#define MODE_UNKNOWN 2

		#define DIAG_BUFFERING_MODE_STREAMING 0
		#define DIAG_BUFFERING_MODE_THRESHOLD 1
		#define DIAG_BUFFERING_MODE_CIRCULAR 2

		#define DIAG_MIN_WM_VAL 0
		#define DIAG_MAX_WM_VAL 100

		#define DEFAULT_LOW_WM_VAL 15
		#define DEFAULT_HIGH_WM_VAL 85

		#define NUM_SMD_DATA_CHANNELS 4
		#define NUM_SMD_CONTROL_CHANNELS NUM_SMD_DATA_CHANNELS
		@@ -244,6 +255,13 @@ struct real_time_query_t {
		int proc;
		} __packed;

		struct diag_buffering_mode_t {
		uint8_t peripheral;
		uint8_t mode;
		uint8_t high_wm_val;
		uint8_t low_wm_val;
		} __packed;

		struct diag_ws_ref_t {
		int ref_count;
		int copy_count;
		@@ -395,6 +413,9 @@ struct diagchar_dev {
		int separate_cmdrsp[NUM_SMD_CONTROL_CHANNELS];
		uint8_t peripheral_feature[NUM_SMD_CONTROL_CHANNELS][FEATURE_MASK_LEN];
		uint8_t mask_centralization[NUM_SMD_CONTROL_CHANNELS];
		uint8_t peripheral_buffering_support[NUM_SMD_CONTROL_CHANNELS];
		struct diag_buffering_mode_t buffering_mode[NUM_SMD_CONTROL_CHANNELS];
		struct mutex mode_lock;
		unsigned char *apps_rsp_buf;
		unsigned char *user_space_data_buf;
		uint8_t user_space_data_busy;

drivers/char/diag/diagchar_core.c

+79 −14

Original line number	Diff line number	Diff line
		@@ -1071,7 +1071,7 @@ static int diag_ioctl_vote_real_time(unsigned long ioarg)

		static int diag_ioctl_get_real_time(unsigned long ioarg)
		{
		int result = -EINVAL;
		int i;
		int retry_count = 0;
		int timer = 0;
		struct real_time_query_t rt_query;
		@@ -1090,22 +1090,75 @@ static int diag_ioctl_get_real_time(unsigned long ioarg)
		for (timer = 0; timer < 5; timer++)
		usleep_range(10000, 10100);
		} else {
		if (rt_query.proc < 0 \|\|
		rt_query.proc >= DIAG_NUM_PROC) {
		pr_err("diag: Invalid proc %d in %s\n",
		rt_query.proc, __func__);
		break;
		}
		}

		if (driver->real_time_update_busy > 0)
		return -EAGAIN;

		if (rt_query.proc < 0 \|\| rt_query.proc >= DIAG_NUM_PROC) {
		pr_err("diag: Invalid proc %d in %s\n", rt_query.proc,
		__func__);
		return -EINVAL;
		}
		rt_query.real_time =
		driver->real_time_mode[rt_query.proc];
		rt_query.real_time = driver->real_time_mode[rt_query.proc];
		/*
		* For the local processor, if any of the peripherals is in buffering
		* mode, overwrite the value of real time with UNKNOWN_MODE
		*/
		if (rt_query.proc == DIAG_LOCAL_PROC) {
		for (i = 0; i < NUM_SMD_CONTROL_CHANNELS; i++) {
		if (!driver->peripheral_buffering_support[i])
		continue;
		switch (driver->buffering_mode[i].mode) {
		case DIAG_BUFFERING_MODE_CIRCULAR:
		case DIAG_BUFFERING_MODE_THRESHOLD:
		rt_query.real_time = MODE_UNKNOWN;
		break;
		}
		}
		}

		if (copy_to_user((void __user *)ioarg, &rt_query,
		sizeof(struct real_time_query_t)))
		return -EFAULT;
		result = 0;
		break;

		return 0;
		}

		static int diag_ioctl_set_buffering_mode(unsigned long ioarg)
		{
		struct diag_buffering_mode_t params;

		if (copy_from_user(&params, (void __user *)ioarg, sizeof(params)))
		return -EFAULT;

		return diag_send_peripheral_buffering_mode(&params);
		}
		return result;

		static int diag_ioctl_peripheral_drain_immediate(unsigned long ioarg)
		{
		uint8_t peripheral;
		struct diag_smd_info *smd_info = NULL;

		if (copy_from_user(&peripheral, (void __user *)ioarg, sizeof(uint8_t)))
		return -EFAULT;

		if (peripheral > LAST_PERIPHERAL) {
		pr_err("diag: In %s, invalid peripheral %d\n", __func__,
		peripheral);
		return -EINVAL;
		}

		if (!driver->peripheral_buffering_support[peripheral]) {
		pr_err("diag: In %s, peripheral %d doesn't support buffering\n",
		__func__, peripheral);
		return -EIO;
		}

		smd_info = &driver->smd_cntl[peripheral];
		return diag_send_peripheral_drain_immediate(smd_info);
		}

		static int diag_ioctl_dci_support(unsigned long ioarg)
		@@ -1228,6 +1281,12 @@ long diagchar_compat_ioctl(struct file *filp,
		case DIAG_IOCTL_GET_REAL_TIME:
		result = diag_ioctl_get_real_time(ioarg);
		break;
		case DIAG_IOCTL_PERIPHERAL_BUF_CONFIG:
		result = diag_ioctl_set_buffering_mode(ioarg);
		break;
		case DIAG_IOCTL_PERIPHERAL_BUF_DRAIN:
		result = diag_ioctl_peripheral_drain_immediate(ioarg);
		break;
		}
		return result;
		}
		@@ -1319,6 +1378,12 @@ long diagchar_ioctl(struct file *filp,
		case DIAG_IOCTL_GET_REAL_TIME:
		result = diag_ioctl_get_real_time(ioarg);
		break;
		case DIAG_IOCTL_PERIPHERAL_BUF_CONFIG:
		result = diag_ioctl_set_buffering_mode(ioarg);
		break;
		case DIAG_IOCTL_PERIPHERAL_BUF_DRAIN:
		result = diag_ioctl_peripheral_drain_immediate(ioarg);
		break;
		}
		return result;
		}

drivers/char/diag/diagfwd.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -2027,6 +2027,7 @@ int diagfwd_init(void)
		driver->supports_apps_hdlc_encoding = 1;
		mutex_init(&driver->diag_hdlc_mutex);
		mutex_init(&driver->diag_cntl_mutex);
		mutex_init(&driver->mode_lock);
		driver->encoded_rsp_buf = kzalloc(HDLC_OUT_BUF_SIZE, GFP_KERNEL);
		if (!driver->encoded_rsp_buf)
		goto err;
		@@ -2040,6 +2041,11 @@ int diagfwd_init(void)
		driver->separate_cmdrsp[i] = 0;
		driver->peripheral_supports_stm[i] = DISABLE_STM;
		driver->rcvd_feature_mask[i] = 0;
		driver->peripheral_buffering_support[i] = 0;
		driver->buffering_mode[i].peripheral = i;
		driver->buffering_mode[i].mode = DIAG_BUFFERING_MODE_STREAMING;
		driver->buffering_mode[i].high_wm_val = DEFAULT_HIGH_WM_VAL;
		driver->buffering_mode[i].low_wm_val = DEFAULT_LOW_WM_VAL;
		}

		for (i = 0; i < NUM_STM_PROCESSORS; i++) {