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

Commit 517107c5 authored by Chris Lew's avatar Chris Lew
Browse files

diag: Add support for multi connection logging 



This change adds support to route On-Device logging and
USB logging traffic per peripheral. A peripherals'
traffic can go to either endpoint but not both. The
mux layer has a peripheral state and the mode switching
logic has multi mode support.

CRs-Fixed: 1004236
Change-Id: I54fef744bdf08a346e4aef22c1280e928cdaf5d2
Signed-off-by: default avatarChris Lew <clew@codeaurora.org>
parent 57b7f613

drivers/char/diag/diag_mux.c

+99 −21
Original line number Diff line number Diff line 
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.

/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -23,11 +23,13 @@ 
#include <linux/spinlock.h>

#include <linux/ratelimit.h>

#include "diagchar.h"

#include "diagfwd.h"

#include "diag_mux.h"

#include "diag_usb.h"

#include "diag_memorydevice.h"



struct diag_logger_t *logger;



struct diag_mux_state_t *diag_mux;

static struct diag_logger_t usb_logger;

static struct diag_logger_t md_logger;
@@ -49,11 +51,11 @@ static struct diag_logger_ops md_log_ops = { 


int diag_mux_init()

{

	logger = kzalloc(NUM_MUX_PROC * sizeof(struct diag_logger_t),

	diag_mux = kzalloc(sizeof(struct diag_mux_state_t),

			 GFP_KERNEL);

	if (!logger)

	if (!diag_mux)

		return -ENOMEM;

	kmemleak_not_leak(logger);

	kmemleak_not_leak(diag_mux);



	usb_logger.mode = DIAG_USB_MODE;

	usb_logger.log_ops = &usb_log_ops;
@@ -66,13 +68,17 @@ int diag_mux_init() 
	 * Set USB logging as the default logger. This is the mode

	 * Diag should be in when it initializes.

	 */

	logger = &usb_logger;

	diag_mux->usb_ptr = &usb_logger;

	diag_mux->md_ptr = &md_logger;

	diag_mux->logger = &usb_logger;

	diag_mux->mux_mask = 0;

	diag_mux->mode = DIAG_USB_MODE;

	return 0;

}



void diag_mux_exit()

{

	kfree(logger);

	kfree(diag_mux);

}



int diag_mux_register(int proc, int ctx, struct diag_mux_ops *ops)
@@ -106,19 +112,43 @@ int diag_mux_register(int proc, int ctx, struct diag_mux_ops *ops) 


int diag_mux_queue_read(int proc)

{

	struct diag_logger_t *logger = NULL;



	if (proc < 0 || proc >= NUM_MUX_PROC)

		return -EINVAL;

	if (!logger)

	if (!diag_mux)

		return -EIO;

	if (logger->log_ops && logger->log_ops->queue_read)



	if (diag_mux->mode == DIAG_MULTI_MODE)

		logger = diag_mux->usb_ptr;

	else

		logger = diag_mux->logger;



	if (logger && logger->log_ops && logger->log_ops->queue_read)

		return logger->log_ops->queue_read(proc);



	return 0;

}



int diag_mux_write(int proc, unsigned char *buf, int len, int ctx)

{

	struct diag_logger_t *logger = NULL;

	int peripheral;



	if (proc < 0 || proc >= NUM_MUX_PROC)

		return -EINVAL;

	if (!diag_mux)

		return -EIO;



	peripheral = GET_BUF_PERIPHERAL(ctx);

	if (peripheral > NUM_PERIPHERALS)

		return -EINVAL;



	if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask)

		logger = diag_mux->md_ptr;

	else

		logger = diag_mux->usb_ptr;



	if (logger && logger->log_ops && logger->log_ops->write)

		return logger->log_ops->write(proc, buf, len, ctx);

	return 0;
@@ -126,38 +156,86 @@ int diag_mux_write(int proc, unsigned char *buf, int len, int ctx) 


int diag_mux_close_peripheral(int proc, uint8_t peripheral)

{

	struct diag_logger_t *logger = NULL;

	if (proc < 0 || proc >= NUM_MUX_PROC)

		return -EINVAL;

	/* Peripheral should account for Apps data as well */

	if (peripheral > NUM_PERIPHERALS)

		return -EINVAL;

	if (!diag_mux)

		return -EIO;



	if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask)

		logger = diag_mux->md_ptr;

	else

		logger = diag_mux->logger;



	if (logger && logger->log_ops && logger->log_ops->close_peripheral)

		return logger->log_ops->close_peripheral(proc, peripheral);

	return 0;

}



int diag_mux_switch_logging(int new_mode)

int diag_mux_switch_logging(int *req_mode, int *peripheral_mask)

{

	struct diag_logger_t *new_logger = NULL;

	unsigned int new_mask = 0;



	switch (new_mode) {

	if (!req_mode)

		return -EINVAL;



	if (*peripheral_mask <= 0 || *peripheral_mask > DIAG_CON_ALL) {

		pr_err("diag: mask %d in %s\n", *peripheral_mask, __func__);

		return -EINVAL;

	}



	switch (*req_mode) {

	case DIAG_USB_MODE:

		new_logger = &usb_logger;

		new_mask = ~(*peripheral_mask) & diag_mux->mux_mask;

		if (new_mask != DIAG_CON_NONE)

			*req_mode = DIAG_MULTI_MODE;

		break;

	case DIAG_MEMORY_DEVICE_MODE:

		new_logger = &md_logger;

		new_mask = (*peripheral_mask) | diag_mux->mux_mask;

		if (new_mask != DIAG_CON_ALL)

			*req_mode = DIAG_MULTI_MODE;

		break;

	default:

		pr_err("diag: Invalid mode %d in %s\n", new_mode, __func__);

		pr_err("diag: Invalid mode %d in %s\n", *req_mode, __func__);

		return -EINVAL;

	}



	if (logger) {

		logger->log_ops->close();

		logger = new_logger;

		logger->log_ops->open();

	switch (diag_mux->mode) {

	case DIAG_USB_MODE:

		if (*req_mode == DIAG_MEMORY_DEVICE_MODE) {

			diag_mux->usb_ptr->log_ops->close();

			diag_mux->logger = diag_mux->md_ptr;

			diag_mux->md_ptr->log_ops->open();

		} else if (*req_mode == DIAG_MULTI_MODE) {

			diag_mux->md_ptr->log_ops->open();

			diag_mux->logger = NULL;

		}



		break;

	case DIAG_MEMORY_DEVICE_MODE:

		if (*req_mode == DIAG_USB_MODE) {

			diag_mux->md_ptr->log_ops->close();

			diag_mux->logger = diag_mux->usb_ptr;

			diag_mux->usb_ptr->log_ops->open();

		} else if (*req_mode == DIAG_MULTI_MODE) {

			diag_mux->usb_ptr->log_ops->open();

			diag_mux->logger = NULL;

		}

		break;

	case DIAG_MULTI_MODE:

		if (*req_mode == DIAG_USB_MODE) {

			diag_mux->md_ptr->log_ops->close();

			diag_mux->logger = diag_mux->usb_ptr;

		} else if (*req_mode == DIAG_MEMORY_DEVICE_MODE) {

			diag_mux->usb_ptr->log_ops->close();

			diag_mux->logger = diag_mux->md_ptr;

		}

		break;

	}

	diag_mux->mode = *req_mode;

	diag_mux->mux_mask = new_mask;

	*peripheral_mask = new_mask;

	return 0;

}

drivers/char/diag/diag_mux.h

+12 −3
Original line number Diff line number Diff line 
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.

/* Copyright (c) 2014-2016, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -13,6 +13,14 @@ 
#define DIAG_MUX_H

#include "diagchar.h"



struct diag_mux_state_t {

	struct diag_logger_t *logger;

	struct diag_logger_t *usb_ptr;

	struct diag_logger_t *md_ptr;

	unsigned int mux_mask;

	unsigned int mode;

};



struct diag_mux_ops {

	int (*open)(int id, int mode);

	int (*close)(int id, int mode);
@@ -24,6 +32,7 @@ struct diag_mux_ops { 
#define DIAG_USB_MODE			0

#define DIAG_MEMORY_DEVICE_MODE		1

#define DIAG_NO_LOGGING_MODE		2

#define DIAG_MULTI_MODE			3



#define DIAG_MUX_LOCAL		0

#define DIAG_MUX_LOCAL_LAST	1
@@ -53,7 +62,7 @@ struct diag_logger_t { 
	struct diag_logger_ops *log_ops;

};



extern struct diag_logger_t *logger;

extern struct diag_mux_state_t *diag_mux;



int diag_mux_init(void);

void diag_mux_exit(void);
@@ -63,5 +72,5 @@ int diag_mux_write(int proc, unsigned char *buf, int len, int ctx); 
int diag_mux_close_peripheral(int proc, uint8_t peripheral);

int diag_mux_open_all(struct diag_logger_t *logger);

int diag_mux_close_all(void);

int diag_mux_switch_logging(int new_mode);

int diag_mux_switch_logging(int *new_mode, int *peripheral_mask);

#endif

drivers/char/diag/diagchar.h

+11 −7
Original line number Diff line number Diff line
@@ -64,6 +64,10 @@ 
#define DIAG_CON_LPASS		(0x0004)	/* Bit mask for LPASS */

#define DIAG_CON_WCNSS		(0x0008)	/* Bit mask for WCNSS */

#define DIAG_CON_SENSORS	(0x0010)	/* Bit mask for Sensors */

#define DIAG_CON_NONE		(0x0000)	/* Bit mask for No SS*/

#define DIAG_CON_ALL		(DIAG_CON_APSS | DIAG_CON_MPSS \

				| DIAG_CON_LPASS | DIAG_CON_WCNSS \

				| DIAG_CON_SENSORS)



#define DIAG_STM_MODEM	0x01

#define DIAG_STM_LPASS	0x02
@@ -158,8 +162,7 @@ 
#define FEATURE_MASK_LEN	2



#define DIAG_MD_NONE			0

#define DIAG_MD_NORMAL			1

#define DIAG_MD_PERIPHERAL		2

#define DIAG_MD_PERIPHERAL		1



/*

 * The status bit masks when received in a signal handler are to be
@@ -562,6 +565,7 @@ struct diagchar_dev { 
	uint32_t dci_pkt_length;

	int in_busy_dcipktdata;

	int logging_mode;

	int logging_mask;

	int mask_check;

	uint32_t md_session_mask;

	uint8_t md_session_mode;

drivers/char/diag/diagchar_core.c

+172 −145
Original line number Diff line number Diff line
@@ -369,6 +369,24 @@ fail: 
	return -ENOMEM;

}



static uint32_t diag_translate_kernel_to_user_mask(uint32_t peripheral_mask)

{

	uint32_t ret = 0;



	if (peripheral_mask & MD_PERIPHERAL_MASK(APPS_DATA))

		ret |= DIAG_CON_APSS;

	if (peripheral_mask & MD_PERIPHERAL_MASK(PERIPHERAL_MODEM))

		ret |= DIAG_CON_MPSS;

	if (peripheral_mask & MD_PERIPHERAL_MASK(PERIPHERAL_LPASS))

		ret |= DIAG_CON_LPASS;

	if (peripheral_mask & MD_PERIPHERAL_MASK(PERIPHERAL_WCNSS))

		ret |= DIAG_CON_WCNSS;

	if (peripheral_mask & MD_PERIPHERAL_MASK(PERIPHERAL_SENSORS))

		ret |= DIAG_CON_SENSORS;



	return ret;

}



static void diag_close_logging_process(const int pid)

{

	int i;
@@ -388,7 +406,8 @@ static void diag_close_logging_process(const int pid) 


	params.req_mode = USB_MODE;

	params.mode_param = 0;

	params.peripheral_mask = 0;

	params.peripheral_mask =

		diag_translate_kernel_to_user_mask(session_peripheral_mask);

	mutex_lock(&driver->diagchar_mutex);

	diag_switch_logging(&params);

	mutex_unlock(&driver->diagchar_mutex);
@@ -417,7 +436,8 @@ static int diag_remove_client_entry(struct file *file) 


	diagpriv_data = file->private_data;



	/* clean up any DCI registrations, if this is a DCI client

	/*

	 * clean up any DCI registrations, if this is a DCI client

	 * This will specially help in case of ungraceful exit of any DCI client

	 * This call will remove any pending registrations of such client

	 */
@@ -1148,19 +1168,10 @@ int diag_md_session_create(int mode, int peripheral_mask, int proc) 
	struct diag_md_session_t *new_session = NULL;



	/*

	 * If there is any session running in Normal mode

	 * we cannot start a new  session . If there is a

	 * session running in Peripheral mode we cannot

	 * start a new session in  NORMAL mode. If a session is

	 * running with a peripheral mask and a new session

	 * request comes in with same peripheral mask value

	 * then return invalid param

	 * If a session is running with a peripheral mask and a new session

	 * request comes in with same peripheral mask value then return

	 * invalid param

	 */

	if (driver->md_session_mode == DIAG_MD_NORMAL)

		return -EINVAL;

	if (driver->md_session_mode == DIAG_MD_PERIPHERAL

	    && mode == DIAG_MD_NORMAL)

		return -EINVAL;

	if (driver->md_session_mode == DIAG_MD_PERIPHERAL &&

	    (driver->md_session_mask & peripheral_mask) != 0)

		return -EINVAL;
@@ -1176,32 +1187,6 @@ int diag_md_session_create(int mode, int peripheral_mask, int proc) 
	new_session->pid = current->tgid;

	new_session->task = current;



	if (mode == DIAG_MD_NORMAL) {

		new_session->log_mask = &log_mask;

		new_session->event_mask = &event_mask;

		new_session->msg_mask = &msg_mask;

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

			if (driver->md_session_map[i] != NULL) {

				DIAG_LOG(DIAG_DEBUG_USERSPACE,

					 "another instance present for %d\n",

					 i);

				err = -EEXIST;

				goto fail_normal;

			}

			new_session->peripheral_mask |= MD_PERIPHERAL_MASK(i);

			driver->md_session_mask |= MD_PERIPHERAL_MASK(i);

			driver->md_session_map[i] = new_session;

		}

		driver->md_session_mode = DIAG_MD_NORMAL;

		setup_timer(&new_session->hdlc_reset_timer,

			diag_md_hdlc_reset_timer_func,

			new_session->pid);

		DIAG_LOG(DIAG_DEBUG_USERSPACE,

			 "created session in normal mode\n");

		mutex_unlock(&driver->md_session_lock);

		return 0;

	}



	new_session->log_mask = kzalloc(sizeof(struct diag_mask_info),

					GFP_KERNEL);

	if (!new_session->log_mask) {
@@ -1251,10 +1236,11 @@ int diag_md_session_create(int mode, int peripheral_mask, int proc) 
		new_session->peripheral_mask |= MD_PERIPHERAL_MASK(i);

		driver->md_session_map[i] = new_session;

		driver->md_session_mask |= MD_PERIPHERAL_MASK(i);

	}

	setup_timer(&new_session->hdlc_reset_timer,

		diag_md_hdlc_reset_timer_func,

		new_session->pid);

	}



	driver->md_session_mode = DIAG_MD_PERIPHERAL;

	mutex_unlock(&driver->md_session_lock);

	DIAG_LOG(DIAG_DEBUG_USERSPACE,
@@ -1271,7 +1257,6 @@ fail_peripheral: 
	diag_msg_mask_free(new_session->msg_mask);

	kfree(new_session->msg_mask);

	new_session->msg_mask = NULL;

fail_normal:

	kfree(new_session);

	new_session = NULL;

	mutex_unlock(&driver->md_session_lock);
@@ -1292,8 +1277,7 @@ static void diag_md_session_close(struct diag_md_session_t *session_info) 
			continue;

		driver->md_session_map[i] = NULL;

		driver->md_session_mask &= ~session_info->peripheral_mask;

		if (driver->md_session_mode == DIAG_MD_NORMAL)

			continue;

	}

	diag_log_mask_free(session_info->log_mask);

	kfree(session_info->log_mask);

	session_info->log_mask = NULL;
@@ -1304,7 +1288,6 @@ static void diag_md_session_close(struct diag_md_session_t *session_info) 
	kfree(session_info->event_mask);

	session_info->event_mask = NULL;

	del_timer(&session_info->hdlc_reset_timer);

	}



	for (i = 0; i < NUM_MD_SESSIONS && !found; i++) {

		if (driver->md_session_map[i] != NULL)
@@ -1337,113 +1320,157 @@ struct diag_md_session_t *diag_md_session_get_peripheral(uint8_t peripheral) 
	return driver->md_session_map[peripheral];

}



static int diag_md_peripheral_switch(struct diag_md_session_t *session_info,

				int peripheral_mask, int req_mode) {

	int i, bit = 0;



	if (!session_info)

		return -EINVAL;

	if (req_mode != DIAG_USB_MODE || req_mode != DIAG_MEMORY_DEVICE_MODE)

		return -EINVAL;



	/*

	 * check that md_session_map for i == session_info,

	 * if not then race condition occurred and bail

	 */

	mutex_lock(&driver->md_session_lock);

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

		bit = MD_PERIPHERAL_MASK(i) & peripheral_mask;

		if (!bit)

			continue;

		if (req_mode == DIAG_USB_MODE) {

			if (driver->md_session_map[i] != session_info) {

				mutex_unlock(&driver->md_session_lock);

				return -EINVAL;

			}

			driver->md_session_map[i] = NULL;

			driver->md_session_mask &= ~bit;

			session_info->peripheral_mask &= ~bit;



		} else {

			if (driver->md_session_map[i] != NULL) {

				mutex_unlock(&driver->md_session_lock);

				return -EINVAL;

			}

			driver->md_session_map[i] = session_info;

			driver->md_session_mask |= bit;

			session_info->peripheral_mask |= bit;



		}

	}



	driver->md_session_mode = DIAG_MD_PERIPHERAL;

	mutex_unlock(&driver->md_session_lock);

	DIAG_LOG(DIAG_DEBUG_USERSPACE, "Changed Peripherals:0x%x to mode:%d\n",

		peripheral_mask, req_mode);

}



static int diag_md_session_check(int curr_mode, int req_mode,

				 const struct diag_logging_mode_param_t *param,

				 uint8_t *change_mode)

{

	int err = 0;

	int i, bit = 0, err = 0;

	int change_mask = 0;

	struct diag_md_session_t *session_info = NULL;



	if (!param || !change_mode)

		return -EIO;



	*change_mode = 1;

	*change_mode = 0;



	switch (curr_mode) {

	case DIAG_USB_MODE:

	case DIAG_MEMORY_DEVICE_MODE:

	case DIAG_MULTI_MODE:

		break;

	default:

		return -EINVAL;

	}



	switch (req_mode) {

	case DIAG_USB_MODE:

	case DIAG_MEMORY_DEVICE_MODE:

		break;

	default:

	if (req_mode != DIAG_USB_MODE && req_mode != DIAG_MEMORY_DEVICE_MODE)

		return -EINVAL;

	}



	if (curr_mode == DIAG_USB_MODE) {

	if (req_mode == DIAG_USB_MODE) {

			/*

			 * This case tries to change from USB mode to USB mode.

			 * There is no change required. Return success.

			 */

			*change_mode = 0;

		if (curr_mode == DIAG_USB_MODE)

			return 0;

		if (driver->md_session_mode == DIAG_MD_NONE

		    && driver->md_session_mask == 0 && driver->logging_mask) {

			*change_mode = 1;

			return 0;

		}



		/*

		 * If there is no other mdlog process, return success.

		 * Check if the peripheral interested in is active.

		 * curr_mode is either DIAG_MULTI_MODE or DIAG_MD_MODE

		 * Check if requested peripherals are already in usb mode

		 */

		if (param->mode_param == DIAG_MD_NORMAL) {

			err = diag_md_session_create(DIAG_MD_NORMAL, 0,

						     DIAG_LOCAL_PROC);

			return err;

		} else if (param->mode_param == DIAG_MD_PERIPHERAL &&

			   (!(driver->md_session_mask &

			      param->peripheral_mask))) {

			err = diag_md_session_create(DIAG_MD_PERIPHERAL,

						     param->peripheral_mask,

						     DIAG_LOCAL_PROC);

			return err;

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

			bit = MD_PERIPHERAL_MASK(i) & param->peripheral_mask;

			if (!bit)

				continue;

			if (bit & driver->logging_mask)

				change_mask |= bit;

		}

		DIAG_LOG(DIAG_DEBUG_USERSPACE,

			 "an instance of mdlog is active\n");

		*change_mode = 0;

		return -EINVAL;

	} else if (curr_mode == DIAG_MEMORY_DEVICE_MODE) {

		if (req_mode == DIAG_USB_MODE) {

			if (driver->md_session_mask != 0 &&

				driver->md_session_mode == DIAG_MD_PERIPHERAL) {

		if (!change_mask)

			return 0;



		/*

				 * An instance of mdlog is still running, Return

				 * error.

		 * Change is needed. Check if this md_session has set all the

		 * requested peripherals. If another md session set a requested

		 * peripheral then we cannot switch that peripheral to USB.

		 * If this session owns all the requested peripherals, then

		 * call function to switch the modes/masks for the md_session

		 */

		session_info = diag_md_session_get_pid(current->tgid);

		if (!session_info) {

			*change_mode = 1;

			return 0;

		}

		if ((change_mask & session_info->peripheral_mask)

							!= change_mask) {

			DIAG_LOG(DIAG_DEBUG_USERSPACE,

					 "another instance running\n");

				*change_mode = 0;

			    "Another MD Session owns a requested peripheral\n");

			return -EINVAL;

		}

			session_info = diag_md_session_get_pid(current->tgid);

		*change_mode = 1;



		/* If all peripherals are being set to USB Mode, call close */

		if (~change_mask & session_info->peripheral_mask) {

			err = diag_md_peripheral_switch(session_info,

					change_mask, DIAG_USB_MODE);

		} else

			diag_md_session_close(session_info);

			return 0;

		}



		if (param->mode_param == DIAG_MD_NORMAL) {

		return err;



	} else if (req_mode == DIAG_MEMORY_DEVICE_MODE) {

		/*

			 * The new client is asking for MD_NORMAL. We're

			 * already in memory device mode - this must be

			 * set by another active process. Return error

			 * for this new client.

		 * Get bit mask that represents what peripherals already have

		 * been set. Check that requested peripherals already set are

		 * owned by this md session

		 */

		change_mask = driver->md_session_mask & param->peripheral_mask;

		session_info = diag_md_session_get_pid(current->tgid);



		if (session_info) {

			if ((session_info->peripheral_mask & change_mask)

							!= change_mask) {

				DIAG_LOG(DIAG_DEBUG_USERSPACE,

				 "unable to switch logging mode\n");

			*change_mode = 0;

				    "Another MD Session owns a requested peripheral\n");

				return -EINVAL;

		} else if (param->mode_param == DIAG_MD_PERIPHERAL) {

			if (driver->md_session_mask & param->peripheral_mask) {

				/*

				 * The new client is asking for a

				 * specific peripheral. This case checks

				 * if a client is exercising this

				 * peripheral already. Return error

				 * if the peripheral is already in use.

				 */

			}

			err = diag_md_peripheral_switch(session_info,

					change_mask, DIAG_USB_MODE);

		} else {

			if (change_mask) {

				DIAG_LOG(DIAG_DEBUG_USERSPACE,

					 "another instance running\n");

				*change_mode = 0;

				    "Another MD Session owns a requested peripheral\n");

				return -EINVAL;

			}

			err = diag_md_session_create(DIAG_MD_PERIPHERAL,

						     param->peripheral_mask,

						     DIAG_LOCAL_PROC);

			*change_mode = 0;

			return err;

				param->peripheral_mask, DIAG_LOCAL_PROC);

		}

		*change_mode = 1;

		return err;

	}

	return -EINVAL;

}
@@ -1477,17 +1504,14 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) 
	if (!param)

		return -EINVAL;



	if (param->mode_param == DIAG_MD_PERIPHERAL &&

	    param->peripheral_mask == 0) {

	if (!param->peripheral_mask) {

		DIAG_LOG(DIAG_DEBUG_USERSPACE,

			 "asking for peripehral mode with no mask being set\n");

			"asking for mode switch with no peripheral mask set\n");

		return -EINVAL;

	}



	if (param->mode_param == DIAG_MD_PERIPHERAL) {

	peripheral_mask = diag_translate_mask(param->peripheral_mask);

	param->peripheral_mask = peripheral_mask;

	}



	switch (param->req_mode) {

	case CALLBACK_MODE:
@@ -1507,8 +1531,8 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) 


	curr_mode = driver->logging_mode;

	DIAG_LOG(DIAG_DEBUG_USERSPACE,

		 "request to switch logging from: %d to %d\n",

		 curr_mode, new_mode);

		"request to switch logging from %d mask:%0x to %d mask:%0x\n",

		curr_mode, driver->md_session_mask, new_mode, peripheral_mask);



	err = diag_md_session_check(curr_mode, new_mode, param, &do_switch);

	if (err) {
@@ -1525,7 +1549,7 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) 
	}



	diag_ws_reset(DIAG_WS_MUX);

	err = diag_mux_switch_logging(new_mode);

	err = diag_mux_switch_logging(&new_mode, &peripheral_mask);

	if (err) {

		pr_err("diag: In %s, unable to switch mode from %d to %d, err: %d\n",

		       __func__, curr_mode, new_mode, err);
@@ -1533,7 +1557,11 @@ static int diag_switch_logging(struct diag_logging_mode_param_t *param) 
		goto fail;

	}

	driver->logging_mode = new_mode;

	driver->logging_mask = peripheral_mask;

	DIAG_LOG(DIAG_DEBUG_USERSPACE,

		"Switch logging to %d mask:%0x\n", new_mode, peripheral_mask);



	/* Update to take peripheral_mask */

	if (new_mode != DIAG_MEMORY_DEVICE_MODE) {

		diag_update_real_time_vote(DIAG_PROC_MEMORY_DEVICE,

					   MODE_REALTIME, ALL_PROC);
@@ -1839,10 +1867,8 @@ static int diag_ioctl_register_callback(unsigned long ioarg) 
		return -EINVAL;

	}



	if (driver->md_session_mode == DIAG_MD_NORMAL ||

	    driver->md_session_mode == DIAG_MD_PERIPHERAL) {

	if (driver->md_session_mode == DIAG_MD_PERIPHERAL)

		return -EIO;

	}



	return err;

}
@@ -2737,7 +2763,8 @@ static ssize_t diagchar_read(struct file *file, char __user *buf, size_t count, 
	mutex_lock(&driver->diagchar_mutex);



	if ((driver->data_ready[index] & USER_SPACE_DATA_TYPE) &&

	    (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE)) {

	    (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE ||

	     driver->logging_mode == DIAG_MULTI_MODE)) {

		pr_debug("diag: process woken up\n");

		/*Copy the type of data being passed*/

		data_type = driver->data_ready[index] & USER_SPACE_DATA_TYPE;

drivers/char/diag/diagfwd.c

+15 −9
Original line number Diff line number Diff line
@@ -236,7 +236,7 @@ void chk_logging_wakeup(void) 
		 * index as all the indices point to the same session

		 * structure.

		 */

		if (driver->md_session_mode == DIAG_MD_NORMAL && j == 0)

		if ((driver->md_session_mask == DIAG_CON_ALL) && (j == 0))

			break;

	}

}
@@ -280,7 +280,8 @@ static void pack_rsp_and_send(unsigned char *buf, int len) 
		 * for responses. Make sure we don't miss previous wakeups for

		 * draining responses when we are in Memory Device Mode.

		 */

		if (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE)

		if (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE ||

				driver->logging_mode == DIAG_MULTI_MODE)

			chk_logging_wakeup();

	}

	if (driver->rsp_buf_busy) {
@@ -348,7 +349,8 @@ static void encode_rsp_and_send(unsigned char *buf, int len) 
		 * for responses. Make sure we don't miss previous wakeups for

		 * draining responses when we are in Memory Device Mode.

		 */

		if (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE)

		if (driver->logging_mode == DIAG_MEMORY_DEVICE_MODE ||

				driver->logging_mode == DIAG_MULTI_MODE)

			chk_logging_wakeup();

	}
@@ -921,8 +923,13 @@ int diag_process_apps_pkt(unsigned char *buf, int len, 
			if (MD_PERIPHERAL_MASK(reg_item->proc) &

				info->peripheral_mask)

				write_len = diag_send_data(reg_item, buf, len);

		} else

		} else {

			if (MD_PERIPHERAL_MASK(reg_item->proc) &

				driver->logging_mask)

				diag_send_error_rsp(buf, len);

			else

				write_len = diag_send_data(reg_item, buf, len);

		}

		mutex_unlock(&driver->cmd_reg_mutex);

		return write_len;

	}
@@ -1230,10 +1237,9 @@ static int diagfwd_mux_close(int id, int mode) 
		return -EINVAL;

	}



	if ((mode == DIAG_USB_MODE &&

	     driver->logging_mode == DIAG_MEMORY_DEVICE_MODE) ||

	    (mode == DIAG_MEMORY_DEVICE_MODE &&

	     driver->logging_mode == DIAG_USB_MODE)) {

	if ((driver->logging_mode == DIAG_MULTI_MODE &&

		driver->md_session_mode == DIAG_MD_NONE) ||

		(driver->md_session_mode == DIAG_MD_PERIPHERAL)) {

		/*

		 * In this case the channel must not be closed. This case

		 * indicates that the USB is removed but there is a client