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

Commit 2d0a1ff7 authored by Sreelakshmi Gownipalli's avatar Sreelakshmi Gownipalli Committed by Gerrit - the friendly Code Review server
Browse files

diag: Add memory device support for multiple devices 



Add support to start separate instance for each device in
memory device mode.

Change-Id: I6bc83874b2f9acc3dad18d01dc2634dd47e8cfcb
Signed-off-by: default avatarSreelakshmi Gownipalli <sgownipa@codeaurora.org>
parent c2795af5

drivers/char/diag/diag_debugfs.c

+4 −4
Original line number Diff line number Diff line
@@ -89,12 +89,12 @@ static ssize_t diag_dbgfs_read_status(struct file *file, char __user *ubuf, 
		driver->supports_apps_hdlc_encoding,

		driver->supports_apps_header_untagging,

		driver->supports_sockets,

		driver->logging_mode,

		driver->logging_mode[DIAG_LOCAL_PROC],

		driver->rsp_buf_busy,

		driver->hdlc_disabled,

		driver->time_sync_enabled,

		driver->md_session_mode,

		driver->md_session_mask,

		driver->md_session_mode[DIAG_LOCAL_PROC],

		driver->md_session_mask[DIAG_LOCAL_PROC],

		driver->uses_time_api,

		driver->supports_pd_buffering);
@@ -246,7 +246,7 @@ static ssize_t diag_dbgfs_read_power(struct file *file, char __user *ubuf, 
		driver->num_dci_client,

		driver->md_ws.ref_count,

		driver->md_ws.copy_count,

		driver->logging_mode,

		driver->logging_mode[DIAG_LOCAL_PROC],

		driver->diag_dev->power.wakeup->active_count,

		driver->diag_dev->power.wakeup->relax_count);

drivers/char/diag/diag_masks.c

+38 −27
Original line number Diff line number Diff line
@@ -69,7 +69,8 @@ static int diag_check_update(int md_peripheral, int pid) 
	mutex_lock(&driver->md_session_lock);

	info = diag_md_session_get_pid(pid);

	ret = (!info || (info &&

		(info->peripheral_mask & MD_PERIPHERAL_MASK(md_peripheral))));

		(info->peripheral_mask[DIAG_LOCAL_PROC] &

		MD_PERIPHERAL_MASK(md_peripheral))));

	mutex_unlock(&driver->md_session_lock);



	return ret;
@@ -106,6 +107,7 @@ static void diag_send_log_mask_update(uint8_t peripheral, int equip_id) 
	struct diag_mask_info *mask_info = NULL;

	struct diag_log_mask_t *mask = NULL;

	struct diagfwd_info *fwd_info = NULL;

	int proc = DIAG_LOCAL_PROC;



	if (peripheral >= NUM_PERIPHERALS)

		return;
@@ -119,16 +121,18 @@ static void diag_send_log_mask_update(uint8_t peripheral, int equip_id) 


	MD_PERIPHERAL_PD_MASK(TYPE_CNTL, peripheral, pd_mask);



	if (driver->md_session_mask != 0) {

		if (driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[peripheral])

	if (driver->md_session_mask[proc] != 0) {

		if (driver->md_session_mask[proc] &

			MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[proc][peripheral])

				mask_info =

				driver->md_session_map[peripheral]->log_mask;

		} else if (driver->md_session_mask & pd_mask) {

			upd = diag_mask_to_pd_value(driver->md_session_mask);

			if (upd && driver->md_session_map[upd])

			driver->md_session_map[proc][peripheral]->log_mask;

		} else if (driver->md_session_mask[proc] & pd_mask) {

			upd =

			diag_mask_to_pd_value(driver->md_session_mask[proc]);

			if (upd && driver->md_session_map[proc][upd])

				mask_info =

				driver->md_session_map[upd]->log_mask;

				driver->md_session_map[proc][upd]->log_mask;

		} else {

			DIAG_LOG(DIAG_DEBUG_MASKS,

			"asking for mask update with unknown session mask\n");
@@ -233,6 +237,7 @@ static void diag_send_event_mask_update(uint8_t peripheral) 
	struct diag_ctrl_event_mask header;

	struct diag_mask_info *mask_info = NULL;

	struct diagfwd_info *fwd_info = NULL;

	int proc = DIAG_LOCAL_PROC;



	if (num_bytes <= 0 || num_bytes > driver->event_mask_size) {

		pr_debug("diag: In %s, invalid event mask length %d\n",
@@ -252,16 +257,18 @@ static void diag_send_event_mask_update(uint8_t peripheral) 


	MD_PERIPHERAL_PD_MASK(TYPE_CNTL, peripheral, pd_mask);



	if (driver->md_session_mask != 0) {

		if (driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[peripheral])

	if (driver->md_session_mask[proc] != 0) {

		if (driver->md_session_mask[proc] &

			MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[proc][peripheral])

				mask_info =

				driver->md_session_map[peripheral]->event_mask;

		} else if (driver->md_session_mask & pd_mask) {

			upd = diag_mask_to_pd_value(driver->md_session_mask);

			if (upd && driver->md_session_map[upd])

			driver->md_session_map[proc][peripheral]->event_mask;

		} else if (driver->md_session_mask[proc] & pd_mask) {

			upd =

			diag_mask_to_pd_value(driver->md_session_mask[proc]);

			if (upd && driver->md_session_map[proc][upd])

				mask_info =

				driver->md_session_map[upd]->event_mask;

				driver->md_session_map[proc][upd]->event_mask;

		} else {

			DIAG_LOG(DIAG_DEBUG_MASKS,

			"asking for mask update with unknown session mask\n");
@@ -343,6 +350,7 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last) 
	struct diag_ctrl_msg_mask header;

	struct diagfwd_info *fwd_info = NULL;

	struct diag_md_session_t *md_session_info = NULL;

	int proc = DIAG_LOCAL_PROC;



	if (peripheral >= NUM_PERIPHERALS)

		return;
@@ -356,20 +364,23 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last) 


	MD_PERIPHERAL_PD_MASK(TYPE_CNTL, peripheral, pd_mask);



	if (driver->md_session_mask != 0) {

		if (driver->md_session_mask & MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[peripheral]) {

	if (driver->md_session_mask[proc] != 0) {

		if (driver->md_session_mask[proc] &

			MD_PERIPHERAL_MASK(peripheral)) {

			if (driver->md_session_map[proc][peripheral]) {

				mask_info =

				driver->md_session_map[peripheral]->msg_mask;

			driver->md_session_map[proc][peripheral]->msg_mask;

				md_session_info =

					driver->md_session_map[peripheral];

				driver->md_session_map[proc][peripheral];

			}

		} else if (driver->md_session_mask & pd_mask) {

			upd = diag_mask_to_pd_value(driver->md_session_mask);

			if (upd && driver->md_session_map[upd]) {

		} else if (driver->md_session_mask[proc] & pd_mask) {

			upd =

			diag_mask_to_pd_value(driver->md_session_mask[proc]);

			if (upd && driver->md_session_map[proc][upd]) {

				mask_info =

				driver->md_session_map[upd]->msg_mask;

				md_session_info = driver->md_session_map[upd];

				driver->md_session_map[proc][upd]->msg_mask;

				md_session_info =

				driver->md_session_map[proc][upd];

			}

		} else {

			DIAG_LOG(DIAG_DEBUG_MASKS,

drivers/char/diag/diag_memorydevice.c

+56 −34
Original line number Diff line number Diff line
@@ -86,7 +86,17 @@ void diag_md_open_all(void) 
			ch->ops->open(ch->ctx, DIAG_MEMORY_DEVICE_MODE);

	}

}

void diag_md_open_device(int id)

{

	struct diag_md_info *ch = NULL;



	ch = &diag_md[id];

	if (!ch->md_info_inited)

		return;

	if (ch->ops && ch->ops->open)

		ch->ops->open(ch->ctx, DIAG_MEMORY_DEVICE_MODE);



}

void diag_md_close_all(void)

{

	int i, j;
@@ -125,7 +135,42 @@ void diag_md_close_all(void) 


	diag_ws_reset(DIAG_WS_MUX);

}

void diag_md_close_device(int id)

{

	int  j;

	unsigned long flags;

	struct diag_md_info *ch = NULL;

	struct diag_buf_tbl_t *entry = NULL;



	ch = &diag_md[id];

	if (!ch->md_info_inited)

		return;



	if (ch->ops && ch->ops->close)

		ch->ops->close(ch->ctx, DIAG_MEMORY_DEVICE_MODE);



	/*

	 * When we close the Memory device mode, make sure we flush the

	 * internal buffers in the table so that there are no stale

	 * entries.

	 */

	spin_lock_irqsave(&ch->lock, flags);

	for (j = 0; j < ch->num_tbl_entries; j++) {

		entry = &ch->tbl[j];

		if (entry->len <= 0)

			continue;

		if (ch->ops && ch->ops->write_done)

			ch->ops->write_done(entry->buf, entry->len,

					    entry->ctx,

					    DIAG_MEMORY_DEVICE_MODE);

		entry->buf = NULL;

		entry->len = 0;

		entry->ctx = 0;

	}

	spin_unlock_irqrestore(&ch->lock, flags);



	diag_ws_reset(DIAG_WS_MUX);

}

int diag_md_write(int id, unsigned char *buf, int len, int ctx)

{

	int i, peripheral, pid = 0;
@@ -139,17 +184,20 @@ int diag_md_write(int id, unsigned char *buf, int len, int ctx) 


	if (!buf || len < 0)

		return -EINVAL;



	if (id == DIAG_LOCAL_PROC) {

		peripheral = diag_md_get_peripheral(ctx);

		if (peripheral < 0)

			return -EINVAL;



	} else {

		peripheral = 0;

	}

	mutex_lock(&driver->md_session_lock);

	session_info = diag_md_session_get_peripheral(peripheral);

	session_info = diag_md_session_get_peripheral(id, peripheral);

	if (!session_info) {

		mutex_unlock(&driver->md_session_lock);

		return -EIO;

	}



	pid = session_info->pid;



	ch = &diag_md[id];
@@ -254,14 +302,14 @@ int diag_md_copy_to_user(char __user *buf, int *pret, size_t buf_size, 
			}

			spin_unlock_irqrestore(&ch->lock, flags);

			session_info =

			diag_md_session_get_peripheral(peripheral);

			diag_md_session_get_peripheral(i, peripheral);

			if (!session_info)

				goto drop_data;



			if (session_info && info &&

				(session_info->pid != info->pid))

				continue;

			if ((info && (info->peripheral_mask &

			if ((info && (info->peripheral_mask[i] &

			    MD_PERIPHERAL_MASK(peripheral)) == 0))

				goto drop_data;

			pid_struct = find_get_pid(session_info->pid);
@@ -394,32 +442,6 @@ int diag_md_close_peripheral(int id, uint8_t peripheral) 
	return 0;

}



int diag_md_close_device(int id)

{

	int i;

	uint8_t found = 0;

	unsigned long flags;

	struct diag_md_info *ch = NULL;

	struct diag_buf_tbl_t *entry = NULL;



	if (id < 0 || id >= NUM_DIAG_MD_DEV || id >= DIAG_NUM_PROC)

		return -EINVAL;



	ch = &diag_md[id];

	if (!ch || !ch->md_info_inited)

		return -EINVAL;



	spin_lock_irqsave(&ch->lock, flags);

	for (i = 0; i < ch->num_tbl_entries && !found; i++) {

		entry = &ch->tbl[i];

		entry->buf = NULL;

		entry->len = 0;

		entry->ctx = 0;

	}

	spin_unlock_irqrestore(&ch->lock, flags);

	return 0;

}



int diag_md_init(void)

{

	int i, j;

drivers/char/diag/diag_memorydevice.h

+3 −15
Original line number Diff line number Diff line
@@ -12,19 +12,7 @@ 


#ifndef DIAG_MEMORYDEVICE_H

#define DIAG_MEMORYDEVICE_H



#define DIAG_MD_LOCAL		0

#define DIAG_MD_LOCAL_LAST	1

#define DIAG_MD_BRIDGE_BASE	DIAG_MD_LOCAL_LAST

#define DIAG_MD_MDM		(DIAG_MD_BRIDGE_BASE)

#define DIAG_MD_MDM2		(DIAG_MD_BRIDGE_BASE + 1)

#define DIAG_MD_BRIDGE_LAST	(DIAG_MD_BRIDGE_BASE + 2)



#ifndef CONFIG_DIAGFWD_BRIDGE_CODE

#define NUM_DIAG_MD_DEV		DIAG_MD_LOCAL_LAST

#else

#define NUM_DIAG_MD_DEV		DIAG_MD_BRIDGE_LAST

#endif

#include "diagchar.h"



struct diag_buf_tbl_t {

	unsigned char *buf;
@@ -51,11 +39,11 @@ void diag_md_exit(void); 
void diag_md_mdm_exit(void);

void diag_md_open_all(void);

void diag_md_close_all(void);

void diag_md_open_device(int id);

void diag_md_close_device(int id);

int diag_md_register(int id, int ctx, struct diag_mux_ops *ops);

int diag_md_close_peripheral(int id, uint8_t peripheral);

int diag_md_write(int id, unsigned char *buf, int len, int ctx);

int diag_md_copy_to_user(char __user *buf, int *pret, size_t buf_size,

			 struct diag_md_session_t *info);

int diag_md_close_device(int id);



#endif

drivers/char/diag/diag_mux.c

+75 −63
Original line number Diff line number Diff line
@@ -40,23 +40,27 @@ static struct diag_logger_ops usb_log_ops = { 
	.open = diag_usb_connect_all,

	.close = diag_usb_disconnect_all,

	.queue_read = diag_usb_queue_read,

	.open_device = diag_usb_connect_device,

	.close_device = diag_usb_disconnect_device,

	.write = diag_usb_write,

	.close_peripheral = NULL,

	.close_device = NULL

	.close_peripheral = NULL

};



static struct diag_logger_ops md_log_ops = {

	.open = diag_md_open_all,

	.close = diag_md_close_all,

	.open_device = diag_md_open_device,

	.close_device = diag_md_close_device,

	.queue_read = NULL,

	.write = diag_md_write,

	.close_peripheral = diag_md_close_peripheral,

	.close_device = diag_md_close_device

};



static struct diag_logger_ops pcie_log_ops = {

	.open = diag_pcie_connect_all,

	.close = diag_pcie_disconnect_all,

	.open_device = diag_pcie_connect_device,

	.close_device = diag_pcie_disconnect_device,

	.queue_read = NULL,

	.write = diag_pcie_write,

	.close_peripheral = NULL
@@ -64,6 +68,7 @@ static struct diag_logger_ops pcie_log_ops = { 


int diag_mux_init(void)

{

	int proc;

	diag_mux = kzalloc(sizeof(struct diag_mux_state_t),

			 GFP_KERNEL);

	if (!diag_mux)
@@ -85,18 +90,20 @@ int diag_mux_init(void) 
	 */

	diag_mux->usb_ptr = &usb_logger;

	diag_mux->md_ptr = &md_logger;

	for (proc = 0; proc < NUM_MUX_PROC; proc++) {

		switch (driver->pcie_transport_def) {

		case DIAG_ROUTE_TO_PCIE:

		diag_mux->logger = &pcie_logger;

		diag_mux->mode = DIAG_PCIE_MODE;

			diag_mux->logger[proc] = &pcie_logger;

			diag_mux->mode[proc] = DIAG_PCIE_MODE;

			break;

		case DIAG_ROUTE_TO_USB:

		default:

		diag_mux->logger = &usb_logger;

		diag_mux->mode = DIAG_USB_MODE;

			diag_mux->logger[proc] = &usb_logger;

			diag_mux->mode[proc] = DIAG_USB_MODE;

			break;

		}

	diag_mux->mux_mask = 0;

		diag_mux->mux_mask[proc] = 0;

	}

	return 0;

}
@@ -183,10 +190,10 @@ int diag_mux_queue_read(int proc) 
	if (!diag_mux)

		return -EIO;



	if (diag_mux->mode == DIAG_MULTI_MODE)

	if (diag_mux->mode[proc] == DIAG_MULTI_MODE)

		logger = diag_mux->usb_ptr;

	else

		logger = diag_mux->logger;

		logger = diag_mux->logger[proc];



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

		return logger->log_ops->queue_read(proc);
@@ -204,15 +211,20 @@ int diag_mux_write(int proc, unsigned char *buf, int len, int ctx) 
		return -EINVAL;

	if (!diag_mux)

		return -EIO;



	if (proc == DIAG_LOCAL_PROC) {

		peripheral = diag_md_get_peripheral(ctx);

		if (peripheral < 0) {

			DIAG_LOG(DIAG_DEBUG_PERIPHERALS,

			"diag: invalid peripheral = %d\n", peripheral);

				"diag:%s:%d invalid peripheral = %d\n",

				__func__, __LINE__, peripheral);

			return -EINVAL;

		}



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

	} else {

		peripheral = 0;

	}



	if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask[proc]) {

		logger = diag_mux->md_ptr;

		log_sink = DIAG_MEMORY_DEVICE_MODE;

	} else {
@@ -271,10 +283,10 @@ int diag_mux_close_peripheral(int proc, uint8_t peripheral) 
	if (!diag_mux)

		return -EIO;



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

	if (MD_PERIPHERAL_MASK(peripheral) & diag_mux->mux_mask[proc])

		logger = diag_mux->md_ptr;

	else

		logger = diag_mux->logger;

		logger = diag_mux->logger[proc];



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

		return logger->log_ops->close_peripheral(proc, peripheral);
@@ -288,14 +300,14 @@ int diag_mux_close_device(int proc) 
	if (!diag_mux)

		return -EIO;



	logger = diag_mux->logger;

	logger = diag_mux->logger[proc];



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

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

		logger->log_ops->close_device(proc);

	return 0;

}



int diag_mux_switch_logging(int *req_mode, int *peripheral_mask)

int diag_mux_switch_logging(int proc, int *req_mode, int *peripheral_mask)

{

	unsigned int new_mask = 0;
@@ -311,14 +323,14 @@ int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) 
	switch (*req_mode) {

	case DIAG_PCIE_MODE:

	case DIAG_USB_MODE:

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

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

		if (new_mask != DIAG_CON_NONE)

			*req_mode = DIAG_MULTI_MODE;

		if (new_mask == DIAG_CON_ALL)

			*req_mode = DIAG_MEMORY_DEVICE_MODE;

		break;

	case DIAG_MEMORY_DEVICE_MODE:

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

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

		if (new_mask != DIAG_CON_ALL)

			*req_mode = DIAG_MULTI_MODE;

		break;
@@ -327,68 +339,68 @@ int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) 
		return -EINVAL;

	}



	switch (diag_mux->mode) {

	switch (diag_mux->mode[proc]) {

	case DIAG_PCIE_MODE:

		if (*req_mode == DIAG_MEMORY_DEVICE_MODE) {

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

			diag_mux->logger = diag_mux->md_ptr;

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

			diag_mux->pcie_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->md_ptr;

			diag_mux->md_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_USB_MODE) {

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

			diag_mux->logger = diag_mux->usb_ptr;

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

			diag_mux->pcie_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->usb_ptr;

			diag_mux->usb_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_MULTI_MODE) {

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

			diag_mux->logger = NULL;

			diag_mux->md_ptr->log_ops->open_device(proc);

			diag_mux->logger[proc] = NULL;

		}

		break;

	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();

			diag_mux->usb_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->md_ptr;

			diag_mux->md_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_PCIE_MODE) {

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

			diag_mux->logger = diag_mux->pcie_ptr;

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

			diag_mux->usb_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->pcie_ptr;

			diag_mux->pcie_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_MULTI_MODE) {

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

			diag_mux->logger = NULL;

			diag_mux->md_ptr->log_ops->open_device(proc);

			diag_mux->logger[proc] = 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();

			diag_mux->md_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->usb_ptr;

			diag_mux->usb_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_PCIE_MODE) {

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

			diag_mux->logger = diag_mux->pcie_ptr;

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

			diag_mux->md_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->pcie_ptr;

			diag_mux->pcie_ptr->log_ops->open_device(proc);

		} else if (*req_mode == DIAG_MULTI_MODE) {

			if (driver->pcie_transport_def == DIAG_ROUTE_TO_PCIE ||

				driver->transport_set == DIAG_ROUTE_TO_PCIE)

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

				diag_mux->pcie_ptr->log_ops->open_device(proc);

			else

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

			diag_mux->logger = NULL;

				diag_mux->usb_ptr->log_ops->open_device(proc);

			diag_mux->logger[proc] = 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;

			diag_mux->md_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->usb_ptr;

		} else if (*req_mode == DIAG_PCIE_MODE) {

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

			diag_mux->logger = diag_mux->pcie_ptr;

			diag_mux->md_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->pcie_ptr;

		} else if (*req_mode == DIAG_MEMORY_DEVICE_MODE) {

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

			diag_mux->logger = diag_mux->md_ptr;

			diag_mux->usb_ptr->log_ops->close_device(proc);

			diag_mux->logger[proc] = diag_mux->md_ptr;

		}

		break;

	}

	diag_mux->mode = *req_mode;

	diag_mux->mux_mask = new_mask;

	diag_mux->mode[proc] = *req_mode;

	diag_mux->mux_mask[proc] = new_mask;

	*peripheral_mask = new_mask;

	return 0;

}