Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 18c177fc authored by Ravi Aravamudhan's avatar Ravi Aravamudhan
Browse files

diag: Add support for peripheral buffering modes 



Diag on the peripherals has support to buffer diag data and drain
them as and when required. This patchset adds support on the apps
processor to enable different buffering modes on the peripherals.

Change-Id: I07b9ffe36dfc5c90ac0d8a8da91922e1127aed58
Signed-off-by: default avatarRavi Aravamudhan <aravamud@codeaurora.org>
parent 648cfa62

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++) {