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

Commit 6df8497e authored by qctecmdr's avatar qctecmdr Committed by Gerrit - the friendly Code Review server
Browse files

Merge "diag: Add memory device support for multiple devices"

parents ffae756f d5b6a08f

drivers/char/diag/diag_debugfs.c

+4 −4
Original line number Diff line number Diff line
@@ -81,12 +81,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[0],

		driver->rsp_buf_busy,

		driver->hdlc_disabled,

		driver->time_sync_enabled,

		driver->md_session_mode,

		driver->md_session_mask,

		driver->md_session_mode[0],

		driver->md_session_mask[0],

		driver->uses_time_api,

		driver->supports_pd_buffering,

		driver->supports_diagid_v2_feature_mask);
@@ -241,7 +241,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[0],

		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
@@ -102,7 +102,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;
@@ -142,6 +143,7 @@ static void diag_send_log_mask_update(uint8_t peripheral, 
	struct diag_log_mask_t *mask = NULL;

	struct diagfwd_info *fwd_info = NULL;

	struct diag_multisim_masks *ms_ptr = NULL;

	int proc = DIAG_LOCAL_PROC;



	if (peripheral >= NUM_PERIPHERALS)

		return;
@@ -155,16 +157,18 @@ static void diag_send_log_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]->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");
@@ -319,6 +323,7 @@ static void diag_send_event_mask_update(uint8_t peripheral, int sub_index, 
	struct diag_mask_info *mask_info = NULL;

	struct diagfwd_info *fwd_info = NULL;

	struct diag_multisim_masks *ms_ptr = 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",
@@ -338,16 +343,18 @@ static void diag_send_event_mask_update(uint8_t peripheral, int sub_index, 


	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");
@@ -476,6 +483,7 @@ static void diag_send_msg_mask_update(uint8_t peripheral, int first, int last, 
	struct diagfwd_info *fwd_info = NULL;

	struct diag_md_session_t *md_session_info = NULL;

	struct diag_multisim_masks *ms_ptr = NULL;

	int proc = DIAG_LOCAL_PROC;



	if (peripheral >= NUM_PERIPHERALS)

		return;
@@ -489,20 +497,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

+58 −9
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

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

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

 */



#include <linux/slab.h>
@@ -87,7 +87,18 @@ 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;
@@ -126,7 +137,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;
@@ -140,17 +186,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];
@@ -249,14 +298,14 @@ int diag_md_copy_to_user(char __user *buf, int *pret, size_t buf_size, 
			if (peripheral < 0)

				goto drop_data;

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

drivers/char/diag/diag_memorydevice.h

+3 −14
Original line number Diff line number Diff line
@@ -4,20 +4,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_SMUX		(DIAG_MD_BRIDGE_BASE + 2)

#define DIAG_MD_BRIDGE_LAST	(DIAG_MD_BRIDGE_BASE + 3)



#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;
@@ -44,6 +31,8 @@ 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);

drivers/char/diag/diag_mux.c

+44 −32
Original line number Diff line number Diff line
@@ -31,6 +31,8 @@ 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

};
@@ -38,6 +40,8 @@ static struct diag_logger_ops usb_log_ops = { 
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,
@@ -45,6 +49,7 @@ static struct diag_logger_ops md_log_ops = { 


int diag_mux_init(void)

{

	int proc;

	diag_mux = kzalloc(sizeof(struct diag_mux_state_t),

			 GFP_KERNEL);

	if (!diag_mux)
@@ -64,9 +69,11 @@ int diag_mux_init(void) 
	 */

	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;

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

		diag_mux->logger[proc] = &usb_logger;

		diag_mux->mux_mask[proc] = 0;

		diag_mux->mode[proc] = DIAG_USB_MODE;

	}

	return 0;

}
@@ -114,10 +121,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);
@@ -135,15 +142,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 {
@@ -193,17 +205,17 @@ 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);

	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;
@@ -218,14 +230,14 @@ int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) 


	switch (*req_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;
@@ -234,39 +246,39 @@ int diag_mux_switch_logging(int *req_mode, int *peripheral_mask) 
		return -EINVAL;

	}



	switch (diag_mux->mode) {

	switch (diag_mux->mode[proc]) {

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

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

		} else if (*req_mode == DIAG_MULTI_MODE) {

			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_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;

}