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

Commit aa5f90f2 authored by Ravi Aravamudhan's avatar Ravi Aravamudhan Committed by Gerrit - the friendly Code Review server
Browse files

diag: Add checks before sending real time mask updates 



Check peripheral buffering state before sending real time
control packet. Do not send real time update if one of the peripherals
is in buffering mode.

Change-Id: Ie8f59e8709f71a4b5c23c33a07174d2325e8fafb
Signed-off-by: default avatarRavi Aravamudhan <aravamud@codeaurora.org>
parent 7193533b

drivers/char/diag/diagchar.h

+1 −0
Original line number Diff line number Diff line
@@ -491,6 +491,7 @@ struct diagchar_dev { 
	struct diagfwd_info *diagfwd_dci_cmd[NUM_PERIPHERALS];

	struct diag_feature_t feature[NUM_PERIPHERALS];

	struct diag_buffering_mode_t buffering_mode[NUM_PERIPHERALS];

	uint8_t buffering_flag[NUM_PERIPHERALS];

	struct mutex mode_lock;

	unsigned char *user_space_data_buf;

	uint8_t user_space_data_busy;

drivers/char/diag/diagchar_core.c

+7 −0
Original line number Diff line number Diff line
@@ -1450,6 +1450,13 @@ static int diag_ioctl_set_buffering_mode(unsigned long ioarg) 
	if (copy_from_user(&params, (void __user *)ioarg, sizeof(params)))

		return -EFAULT;



	if (params.peripheral >= NUM_PERIPHERALS)

		return -EINVAL;



	mutex_lock(&driver->mode_lock);

	driver->buffering_flag[params.peripheral] = 1;

	mutex_unlock(&driver->mode_lock);



	return diag_send_peripheral_buffering_mode(&params);

}

drivers/char/diag/diagfwd_cntl.c

+30 −2
Original line number Diff line number Diff line
@@ -954,7 +954,7 @@ void diag_real_time_work_fn(struct work_struct *work) 
}

#endif



int diag_send_real_time_update(uint8_t peripheral, int real_time)

static int __diag_send_real_time_update(uint8_t peripheral, int real_time)

{

	char buf[sizeof(struct diag_ctrl_msg_diagmode)];

	int msg_size = sizeof(struct diag_ctrl_msg_diagmode);
@@ -993,6 +993,23 @@ int diag_send_real_time_update(uint8_t peripheral, int real_time) 
	return err;

}



int diag_send_real_time_update(uint8_t peripheral, int real_time)

{

	int i;



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

		if (!driver->buffering_flag[i])

			continue;

		/*

		 * One of the peripherals is in buffering mode. Don't set

		 * the RT value.

		 */

		return -EINVAL;

	}



	return __diag_send_real_time_update(peripheral, real_time);

}



int diag_send_peripheral_buffering_mode(struct diag_buffering_mode_t *params)

{

	int err = 0;
@@ -1009,6 +1026,9 @@ int diag_send_peripheral_buffering_mode(struct diag_buffering_mode_t *params) 
		return -EINVAL;

	}



	if (!driver->buffering_flag[peripheral])

		return -EINVAL;



	switch (params->mode) {

	case DIAG_BUFFERING_MODE_STREAMING:

		mode = MODE_REALTIME;
@@ -1026,6 +1046,7 @@ int diag_send_peripheral_buffering_mode(struct diag_buffering_mode_t *params) 
	if (!driver->feature[peripheral].peripheral_buffering) {

		pr_debug("diag: In %s, peripheral %d doesn't support buffering\n",

			 __func__, peripheral);

		driver->buffering_flag[peripheral] = 0;

		return -EIO;

	}
@@ -1057,7 +1078,7 @@ int diag_send_peripheral_buffering_mode(struct diag_buffering_mode_t *params) 
		       __func__, peripheral, err);

		goto fail;

	}

	err = diag_send_real_time_update(peripheral, mode);

	err = __diag_send_real_time_update(peripheral, mode);

	if (err) {

		pr_err("diag: In %s, unable to send mode update to peripheral %d, mode: %d, err: %d\n",

		       __func__, peripheral, mode, err);
@@ -1067,6 +1088,8 @@ int diag_send_peripheral_buffering_mode(struct diag_buffering_mode_t *params) 
	driver->buffering_mode[peripheral].mode = params->mode;

	driver->buffering_mode[peripheral].low_wm_val = params->low_wm_val;

	driver->buffering_mode[peripheral].high_wm_val = params->high_wm_val;

	if (mode == DIAG_BUFFERING_MODE_STREAMING)

		driver->buffering_flag[peripheral] = 0;

fail:

	mutex_unlock(&driver->mode_lock);

	return err;
@@ -1248,11 +1271,16 @@ int diag_send_buffering_wm_values(uint8_t peripheral, 


int diagfwd_cntl_init(void)

{

	uint8_t peripheral = 0;



	reg_dirty = 0;

	driver->polling_reg_flag = 0;

	driver->log_on_demand_support = 1;

	driver->stm_peripheral = 0;

	driver->close_transport = 0;

	for (peripheral = 0; peripheral < NUM_PERIPHERALS; peripheral++)

		driver->buffering_flag[peripheral] = 0;



	mutex_init(&driver->cntl_lock);

	INIT_WORK(&(driver->stm_update_work), diag_stm_update_work_fn);

	INIT_WORK(&(driver->mask_update_work), diag_mask_update_work_fn);