android_kernel_samsung_sm8650-modules/msm/synx/ipclite.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2021-2023, Qualcomm Innovation Center, Inc. All rights reserved.
 */
#define pr_fmt(fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__

#include <linux/module.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/irqdomain.h>
#include <linux/platform_device.h>

#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <asm/memory.h>
#include <linux/sizes.h>

#include <linux/hwspinlock.h>
#include <linux/qcom_scm.h>

#include <linux/sysfs.h>

#include "ipclite_client.h"
#include "ipclite.h"

#define GLOBAL_ATOMICS_ENABLED	1
#define GLOBAL_ATOMICS_DISABLED	0
#define FIFO_FULL_RESERVE 8
#define FIFO_ALIGNMENT 8

static struct ipclite_info *ipclite;
static struct ipclite_client synx_client;
static struct ipclite_client test_client;
static struct ipclite_hw_mutex_ops *ipclite_hw_mutex;
static struct ipclite_debug_info *ipclite_dbg_info;
static struct ipclite_debug_struct *ipclite_dbg_struct;
static struct ipclite_debug_inmem_buf *ipclite_dbg_inmem;
static struct mutex ssr_mutex;
static struct kobject *sysfs_kobj;

static uint32_t enabled_hosts;
static uint32_t partitions;
static u32 global_atomic_support = GLOBAL_ATOMICS_ENABLED;
static uint32_t ipclite_debug_level = IPCLITE_ERR | IPCLITE_WARN | IPCLITE_INFO;
static uint32_t ipclite_debug_control = IPCLITE_DMESG_LOG, ipclite_debug_dump;

static inline bool is_host_enabled(uint32_t host)
{
	return (1U & (enabled_hosts >> host));
}

static inline bool is_loopback_except_apps(uint32_t h0, uint32_t h1)
{
	return (h0 == h1 && h0 != IPCMEM_APPS);
}

static void IPCLITE_OS_INMEM_LOG(const char *psztStr, ...)
{
	uint32_t local_index = 0;
	va_list pArgs;

	va_start(pArgs, psztStr);

	/* Incrementing the index atomically and storing the index in local variable */
	local_index = ipclite_global_atomic_inc((ipclite_atomic_int32_t *)
							&ipclite_dbg_info->debug_log_index);
	local_index %= IPCLITE_LOG_BUF_SIZE;

	/* Writes data on the index location */
	vsnprintf(ipclite_dbg_inmem->IPCLITELog[local_index], IPCLITE_LOG_MSG_SIZE, psztStr, pArgs);

	va_end(pArgs);
}

static void ipclite_dump_debug_struct(void)
{
	int i, host;
	struct ipclite_debug_struct *temp_dbg_struct;

	/* Check if debug structures are initialized */
	if (!ipclite_dbg_info || !ipclite_dbg_struct) {
		pr_err("Debug Structures not initialized\n");
		return;
	}

	/* Check if debug structures are enabled before printing */
	if (!(ipclite_debug_control & IPCLITE_DBG_STRUCT)) {
		pr_err("Debug Structures not enabled\n");
		return;
	}

	/* Dumping the debug structures */
	pr_info("------------------- Dumping IPCLite Debug Structure -------------------\n");

	for (host = 0; host < IPCMEM_NUM_HOSTS; host++) {
		if (!is_host_enabled(host))
			continue;
		temp_dbg_struct = (struct ipclite_debug_struct *)
					(((char *)ipclite_dbg_struct) +
					(sizeof(*temp_dbg_struct) * host));

		pr_info("---------- Host ID: %d dbg_mem:%p ----------\n",
				host, temp_dbg_struct);
		pr_info("Total Signals Sent : %d Total Signals Received : %d\n",
				temp_dbg_struct->dbg_info_overall.total_numsig_sent,
				temp_dbg_struct->dbg_info_overall.total_numsig_recv);
		pr_info("Last Signal Sent to Host ID : %d Last Signal Received from Host ID : %d\n",
				temp_dbg_struct->dbg_info_overall.last_sent_host_id,
				temp_dbg_struct->dbg_info_overall.last_recv_host_id);
		pr_info("Last Signal ID Sent : %d Last Signal ID Received : %d\n",
				temp_dbg_struct->dbg_info_overall.last_sigid_sent,
				temp_dbg_struct->dbg_info_overall.last_sigid_recv);

		for (i = 0; i < IPCMEM_NUM_HOSTS; i++) {
			if (!is_host_enabled(i))
				continue;
			pr_info("----------> Host ID : %d Host ID : %d\n", host, i);
			pr_info("No. of Messages Sent : %d No. of Messages Received : %d\n",
			temp_dbg_struct->dbg_info_host[i].numsig_sent,
			temp_dbg_struct->dbg_info_host[i].numsig_recv);
			pr_info("No. of Interrupts Received : %d\n",
			temp_dbg_struct->dbg_info_host[i].num_intr);
			pr_info("TX Write Index : %d TX Read Index : %d\n",
			temp_dbg_struct->dbg_info_host[i].tx_wr_index,
			temp_dbg_struct->dbg_info_host[i].tx_rd_index);
			pr_info("TX Write Index[0] : %d TX Read Index[0] : %d\n",
			temp_dbg_struct->dbg_info_host[i].prev_tx_wr_index[0],
			temp_dbg_struct->dbg_info_host[i].prev_tx_rd_index[0]);
			pr_info("TX Write Index[1] : %d TX Read Index[1] : %d\n",
			temp_dbg_struct->dbg_info_host[i].prev_tx_wr_index[1],
			temp_dbg_struct->dbg_info_host[i].prev_tx_rd_index[1]);
			pr_info("RX Write Index : %d RX Read Index : %d\n",
			temp_dbg_struct->dbg_info_host[i].rx_wr_index,
			temp_dbg_struct->dbg_info_host[i].rx_rd_index);
			pr_info("RX Write Index[0] : %d RX Read Index[0] : %d\n",
			temp_dbg_struct->dbg_info_host[i].prev_rx_wr_index[0],
			temp_dbg_struct->dbg_info_host[i].prev_rx_rd_index[0]);
			pr_info("RX Write Index[1] : %d RX Read Index[1] : %d\n",
			temp_dbg_struct->dbg_info_host[i].prev_rx_wr_index[1],
			temp_dbg_struct->dbg_info_host[i].prev_rx_rd_index[1]);
		}
	}
	return;
}

static void ipclite_dump_inmem_logs(void)
{
	int i;
	uint32_t local_index = 0;

	/* Check if debug and inmem structures are initialized */
	if (!ipclite_dbg_info || !ipclite_dbg_inmem) {
		pr_err("Debug structures not initialized\n");
		return;
	}

	/* Check if debug structures are enabled before printing */
	if (!(ipclite_debug_control & IPCLITE_INMEM_LOG)) {
		pr_err("In-Memory Logs not enabled\n");
		return;
	}

	/* Dumping the debug in-memory logs */
	pr_info("------------------- Dumping In-Memory Logs -------------------\n");

	/* Storing the index atomically in local variable */
	local_index = ipclite_global_atomic_load_u32((ipclite_atomic_uint32_t *)
							&ipclite_dbg_info->debug_log_index);

	/* Printing from current index till the end of buffer */
	for (i = local_index % IPCLITE_LOG_BUF_SIZE; i < IPCLITE_LOG_BUF_SIZE; i++) {
		if (ipclite_dbg_inmem->IPCLITELog[i][0])
			pr_info("%s\n", ipclite_dbg_inmem->IPCLITELog[i]);
	}

	/* Printing from 0th index to current-1 index */
	for (i = 0; i < local_index % IPCLITE_LOG_BUF_SIZE; i++) {
		if (ipclite_dbg_inmem->IPCLITELog[i][0])
			pr_info("%s\n", ipclite_dbg_inmem->IPCLITELog[i]);
	}

	return;
}

static void ipclite_hw_mutex_acquire(void)
{
	int32_t ret;

	if (ipclite != NULL) {
		if (!global_atomic_support) {
			ret = hwspin_lock_timeout_irqsave(ipclite->hwlock,
					HWSPINLOCK_TIMEOUT,
					&ipclite->ipclite_hw_mutex->flags);
			if (ret) {
				IPCLITE_OS_LOG(IPCLITE_ERR, "Hw mutex lock acquire failed\n");
				return;
			}

			ipclite->ipcmem.toc_data.host_info->hwlock_owner = IPCMEM_APPS;

			IPCLITE_OS_LOG(IPCLITE_DBG, "Hw mutex lock acquired\n");
		}
	}
}

static void ipclite_hw_mutex_release(void)
{
	if (ipclite != NULL) {
		if (!global_atomic_support) {
			ipclite->ipcmem.toc_data.host_info->hwlock_owner = IPCMEM_INVALID_HOST;
			hwspin_unlock_irqrestore(ipclite->hwlock,
				&ipclite->ipclite_hw_mutex->flags);
			IPCLITE_OS_LOG(IPCLITE_DBG, "Hw mutex lock release\n");
		}
	}
}

void ipclite_atomic_init_u32(ipclite_atomic_uint32_t *addr, uint32_t data)
{
	atomic_set(addr, data);
}
EXPORT_SYMBOL(ipclite_atomic_init_u32);

void ipclite_atomic_init_i32(ipclite_atomic_int32_t *addr, int32_t data)
{
	atomic_set(addr, data);
}
EXPORT_SYMBOL(ipclite_atomic_init_i32);

void ipclite_global_atomic_store_u32(ipclite_atomic_uint32_t *addr, uint32_t data)
{
	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	atomic_set(addr, data);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();
}
EXPORT_SYMBOL(ipclite_global_atomic_store_u32);

void ipclite_global_atomic_store_i32(ipclite_atomic_int32_t *addr, int32_t data)
{
	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	atomic_set(addr, data);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();
}
EXPORT_SYMBOL(ipclite_global_atomic_store_i32);

uint32_t ipclite_global_atomic_load_u32(ipclite_atomic_uint32_t *addr)
{
	uint32_t ret;

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_read(addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_atomic_load_u32);

int32_t ipclite_global_atomic_load_i32(ipclite_atomic_int32_t *addr)
{
	int32_t ret;

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_read(addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_atomic_load_i32);

uint32_t ipclite_global_test_and_set_bit(uint32_t nr, ipclite_atomic_uint32_t *addr)
{
	uint32_t ret;
	uint32_t mask = (1 << nr);

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_fetch_or(mask, addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_test_and_set_bit);

uint32_t ipclite_global_test_and_clear_bit(uint32_t nr, ipclite_atomic_uint32_t *addr)
{
	uint32_t ret;
	uint32_t mask = (1 << nr);

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_fetch_and(~mask, addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_test_and_clear_bit);

int32_t ipclite_global_atomic_inc(ipclite_atomic_int32_t *addr)
{
	int32_t ret = 0;

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_fetch_add(1, addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_atomic_inc);

int32_t ipclite_global_atomic_dec(ipclite_atomic_int32_t *addr)
{
	int32_t ret = 0;

	/* callback to acquire hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->acquire();

	ret = atomic_fetch_sub(1, addr);

	/* callback to release hw mutex lock if atomic support is not enabled */
	ipclite->ipclite_hw_mutex->release();

	return ret;
}
EXPORT_SYMBOL(ipclite_global_atomic_dec);

static size_t ipcmem_rx_avail(struct ipclite_fifo *rx_fifo)
{
	size_t len;
	u32 head;
	u32 tail;

	head = le32_to_cpu(*rx_fifo->head);
	tail = le32_to_cpu(*rx_fifo->tail);

	IPCLITE_OS_LOG(IPCLITE_DBG, "head=%d, tail=%d\n", head, tail);

	if (head < tail)
		len = rx_fifo->length - tail + head;
	else
		len = head - tail;

	if (WARN_ON_ONCE(len > rx_fifo->length))
		len = 0;

	IPCLITE_OS_LOG(IPCLITE_DBG, "len=%d\n", len);

	return len;
}

static void ipcmem_rx_peak(struct ipclite_fifo *rx_fifo,
			       void *data, size_t count)
{
	size_t len;
	u32 tail;

	tail = le32_to_cpu(*rx_fifo->tail);

	if (WARN_ON_ONCE(tail > rx_fifo->length))
		return;

	if (tail >= rx_fifo->length)
		tail -= rx_fifo->length;

	len = min_t(size_t, count, rx_fifo->length - tail);
	if (len)
		memcpy_fromio(data, rx_fifo->fifo + tail, len);

	if (len != count)
		memcpy_fromio(data + len, rx_fifo->fifo, (count - len));
}

static void ipcmem_rx_advance(struct ipclite_fifo *rx_fifo,
				  size_t count, uint32_t core_id)
{
	u32 tail;

	tail = le32_to_cpu(*rx_fifo->tail);

	tail += count;
	if (tail >= rx_fifo->length)
		tail %= rx_fifo->length;

	*rx_fifo->tail = cpu_to_le32(tail);

	/* Storing the debug data in debug structures */
	if (ipclite_debug_control & IPCLITE_DBG_STRUCT) {
		ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_wr_index[1] =
				ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_wr_index[0];
		ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_wr_index[0] =
				ipclite_dbg_struct->dbg_info_host[core_id].rx_wr_index;
		ipclite_dbg_struct->dbg_info_host[core_id].rx_wr_index = *rx_fifo->head;

		ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_rd_index[1] =
				ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_rd_index[0];
		ipclite_dbg_struct->dbg_info_host[core_id].prev_rx_rd_index[0] =
				ipclite_dbg_struct->dbg_info_host[core_id].rx_rd_index;
		ipclite_dbg_struct->dbg_info_host[core_id].rx_rd_index = *rx_fifo->tail;

		ipclite_dbg_struct->dbg_info_overall.total_numsig_recv++;
		ipclite_dbg_struct->dbg_info_host[core_id].numsig_recv++;
	}
}

static size_t ipcmem_tx_avail(struct ipclite_fifo *tx_fifo)
{
	u32 head;
	u32 tail;
	u32 avail;

	head = le32_to_cpu(*tx_fifo->head);
	tail = le32_to_cpu(*tx_fifo->tail);

	if (tail <= head)
		avail = tx_fifo->length - head + tail;
	else
		avail = tail - head;

	if (avail < FIFO_FULL_RESERVE)
		avail = 0;
	else
		avail -= FIFO_FULL_RESERVE;

	if (WARN_ON_ONCE(avail > tx_fifo->length))
		avail = 0;

	return avail;
}

static unsigned int ipcmem_tx_write_one(struct ipclite_fifo *tx_fifo,
					    unsigned int head,
					    const void *data, size_t count)
{
	size_t len;

	if (WARN_ON_ONCE(head > tx_fifo->length))
		return head;

	len = min_t(size_t, count, tx_fifo->length - head);
	if (len)
		memcpy(tx_fifo->fifo + head, data, len);

	if (len != count)
		memcpy(tx_fifo->fifo, data + len, count - len);

	head += count;
	if (head >= tx_fifo->length)
		head -= tx_fifo->length;

	return head;
}

static void ipcmem_tx_write(struct ipclite_fifo *tx_fifo,
			const void *data, size_t dlen, uint32_t core_id, uint32_t signal_id)
{
	unsigned int head;

	head = le32_to_cpu(*tx_fifo->head);
	head = ipcmem_tx_write_one(tx_fifo, head, data, dlen);

	head = ALIGN(head, 8);
	if (head >= tx_fifo->length)
		head -= tx_fifo->length;

	/* Ensure ordering of fifo and head update */
	wmb();

	*tx_fifo->head = cpu_to_le32(head);

	IPCLITE_OS_LOG(IPCLITE_DBG, "head : %d core_id : %d signal_id : %d\n",
						*tx_fifo->head, core_id, signal_id);

	/* Storing the debug data in debug structures */
	if (ipclite_debug_control & IPCLITE_DBG_STRUCT) {
		ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_wr_index[1] =
				ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_wr_index[0];
		ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_wr_index[0] =
				ipclite_dbg_struct->dbg_info_host[core_id].tx_wr_index;
		ipclite_dbg_struct->dbg_info_host[core_id].tx_wr_index = *tx_fifo->head;

		ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_rd_index[1] =
				ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_rd_index[0];
		ipclite_dbg_struct->dbg_info_host[core_id].prev_tx_rd_index[0] =
				ipclite_dbg_struct->dbg_info_host[core_id].tx_rd_index;
		ipclite_dbg_struct->dbg_info_host[core_id].tx_rd_index = *tx_fifo->tail;

		ipclite_dbg_struct->dbg_info_overall.total_numsig_sent++;
		ipclite_dbg_struct->dbg_info_host[core_id].numsig_sent++;
		ipclite_dbg_struct->dbg_info_overall.last_sent_host_id = core_id;
		ipclite_dbg_struct->dbg_info_overall.last_sigid_sent = signal_id;
	}
}

static size_t ipclite_rx_avail(struct ipclite_channel *channel)
{
	return channel->rx_fifo->avail(channel->rx_fifo);
}

static void ipclite_rx_peak(struct ipclite_channel *channel,
			       void *data, size_t count)
{
	channel->rx_fifo->peak(channel->rx_fifo, data, count);
}

static void ipclite_rx_advance(struct ipclite_channel *channel,
					size_t count)
{
	channel->rx_fifo->advance(channel->rx_fifo, count, channel->remote_pid);
}

static size_t ipclite_tx_avail(struct ipclite_channel *channel)
{
	return channel->tx_fifo->avail(channel->tx_fifo);
}

static void ipclite_tx_write(struct ipclite_channel *channel,
				const void *data, size_t dlen)
{
	channel->tx_fifo->write(channel->tx_fifo, data, dlen, channel->remote_pid,
								channel->irq_info->signal_id);
}

static int ipclite_rx_data(struct ipclite_channel *channel, size_t avail)
{
	uint64_t data;
	int ret = 0;

	if (avail < sizeof(data)) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Not enough data in fifo, Core : %d Signal : %d\n",
						channel->remote_pid, channel->irq_info->signal_id);
		return -EAGAIN;
	}

	ipclite_rx_peak(channel, &data, sizeof(data));

	if (synx_client.reg_complete == 1) {
		if (synx_client.callback)
			synx_client.callback(channel->remote_pid, data,
								synx_client.priv_data);
	}
	ipclite_rx_advance(channel, ALIGN(sizeof(data), 8));
	return ret;
}

static int ipclite_rx_test_data(struct ipclite_channel *channel, size_t avail)
{
	uint64_t data;
	int ret = 0;

	if (avail < sizeof(data)) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Not enough data in fifo, Core : %d Signal : %d\n",
						channel->remote_pid, channel->irq_info->signal_id);
		return -EAGAIN;
	}

	ipclite_rx_peak(channel, &data, sizeof(data));

	if (test_client.reg_complete == 1) {
		if (test_client.callback)
			test_client.callback(channel->remote_pid, data,
								test_client.priv_data);
	}
	ipclite_rx_advance(channel, ALIGN(sizeof(data), 8));
	return ret;
}

static irqreturn_t ipclite_intr(int irq, void *data)
{
	struct ipclite_channel *channel;
	struct ipclite_irq_info *irq_info;
	unsigned int avail = 0;
	int ret = 0;
	uint64_t msg;

	irq_info = (struct ipclite_irq_info *)data;
	channel = container_of(irq_info, struct ipclite_channel, irq_info[irq_info->signal_id]);

	IPCLITE_OS_LOG(IPCLITE_DBG, "Interrupt received from Core : %d Signal : %d\n",
							channel->remote_pid, irq_info->signal_id);

	/* Storing the debug data in debug structures */
	if (ipclite_debug_control & IPCLITE_DBG_STRUCT) {
		ipclite_dbg_struct->dbg_info_host[channel->remote_pid].num_intr++;
		ipclite_dbg_struct->dbg_info_overall.last_recv_host_id = channel->remote_pid;
		ipclite_dbg_struct->dbg_info_overall.last_sigid_recv = irq_info->signal_id;
	}

	if (irq_info->signal_id == IPCLITE_MSG_SIGNAL) {
		for (;;) {
			avail = ipclite_rx_avail(channel);
			if (avail < sizeof(msg))
				break;

			ret = ipclite_rx_data(channel, avail);
		}
		IPCLITE_OS_LOG(IPCLITE_DBG, "checking messages in rx_fifo done\n");
	} else if (irq_info->signal_id == IPCLITE_VERSION_SIGNAL) {
		IPCLITE_OS_LOG(IPCLITE_DBG, "Versioning is currently not enabled\n");
	} else if (irq_info->signal_id == IPCLITE_TEST_SIGNAL) {
		for (;;) {
			avail = ipclite_rx_avail(channel);
			if (avail < sizeof(msg))
				break;

			ret = ipclite_rx_test_data(channel, avail);
		}
		IPCLITE_OS_LOG(IPCLITE_DBG, "checking messages in rx_fifo done\n");
	} else {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Wrong Interrupt Signal from core : %d signal : %d\n",
							channel->remote_pid, irq_info->signal_id);
	}

	return IRQ_HANDLED;
}

static int ipclite_tx(struct ipclite_channel *channel,
			uint64_t data, size_t dlen, uint32_t ipclite_signal)
{
	unsigned long flags;
	int ret = 0;

	if (channel->status != ACTIVE) {
		if (channel->status == IN_PROGRESS && *channel->gstatus_ptr == ACTIVE) {
			channel->status = ACTIVE;
		} else {
			IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot Send, Channel not active\n");
			return -EOPNOTSUPP;
		}
	}

	spin_lock_irqsave(&channel->tx_lock, flags);
	if (ipclite_tx_avail(channel) < dlen) {
		spin_unlock_irqrestore(&channel->tx_lock, flags);
		ret = -EAGAIN;
		return ret;
	}

	ipclite_tx_write(channel, &data, dlen);

	mbox_send_message(channel->irq_info[ipclite_signal].mbox_chan, NULL);
	mbox_client_txdone(channel->irq_info[ipclite_signal].mbox_chan, 0);

	spin_unlock_irqrestore(&channel->tx_lock, flags);

	return ret;
}

static int ipclite_send_debug_info(int32_t proc_id)
{
	int ret = 0;
	struct ipclite_channel *channel;

	if (proc_id < 0 || proc_id >= IPCMEM_NUM_HOSTS) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid proc_id : %d\n", proc_id);
		return -EINVAL;
	}
	channel = &ipclite->channel[proc_id];

	if (channel->status != ACTIVE) {
		if (channel->status == IN_PROGRESS && *channel->gstatus_ptr == ACTIVE) {
			channel->status = ACTIVE;
		} else {
			IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot Send, Core %d is Inactive\n", proc_id);
			return -EOPNOTSUPP;
		}
	}

	ret = mbox_send_message(channel->irq_info[IPCLITE_DEBUG_SIGNAL].mbox_chan, NULL);
	if (ret < 0) {
		IPCLITE_OS_LOG(IPCLITE_ERR,
				"Debug Signal sending failed to Core : %d Signal : %d ret : %d\n",
							proc_id, IPCLITE_DEBUG_SIGNAL, ret);
		return ret;
	}

	IPCLITE_OS_LOG(IPCLITE_DBG,
				"Debug Signal send completed to core : %d signal : %d ret : %d\n",
							proc_id, IPCLITE_DEBUG_SIGNAL, ret);
	return 0;
}

int ipclite_ssr_update(int32_t proc_id)
{
	int ret = 0;
	struct ipclite_channel *channel;

	if (proc_id < 0 || proc_id >= IPCMEM_NUM_HOSTS) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid proc_id : %d\n", proc_id);
		return -EINVAL;
	}
	channel = &ipclite->channel[proc_id];

	if (channel->status != ACTIVE) {
		if (channel->status == IN_PROGRESS && *channel->gstatus_ptr == ACTIVE) {
			channel->status = ACTIVE;
		} else {
			IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot Send, Core %d is Inactive\n", proc_id);
			return -EOPNOTSUPP;
		}
	}

	ret = mbox_send_message(channel->irq_info[IPCLITE_SSR_SIGNAL].mbox_chan, NULL);
	if (ret < 0) {
		IPCLITE_OS_LOG(IPCLITE_ERR,
				"SSR Signal sending failed to Core : %d Signal : %d ret : %d\n",
							proc_id, IPCLITE_SSR_SIGNAL, ret);
		return ret;
	}

	IPCLITE_OS_LOG(IPCLITE_DBG,
				"SSR Signal send completed to core : %d signal : %d ret : %d\n",
							proc_id, IPCLITE_SSR_SIGNAL, ret);
	return 0;
}

void ipclite_recover(enum ipcmem_host_type core_id)
{
	int ret, host, host0, host1;
	uint32_t p;

	IPCLITE_OS_LOG(IPCLITE_DBG, "IPCLite Recover - Crashed Core : %d\n", core_id);

	/* verify and reset the hw mutex lock */
	if (core_id == ipclite->ipcmem.toc_data.host_info->hwlock_owner) {
		ipclite->ipcmem.toc_data.host_info->hwlock_owner = IPCMEM_INVALID_HOST;
		hwspin_unlock_raw(ipclite->hwlock);
		IPCLITE_OS_LOG(IPCLITE_DBG, "HW Lock Reset\n");
	}

	mutex_lock(&ssr_mutex);
	/* Set the Global Channel Status to 0 to avoid Race condition */
	for (p = 0; p < partitions; p++) {
		host0 = ipclite->ipcmem.toc_data.partition_entry[p].host0;
		host1 = ipclite->ipcmem.toc_data.partition_entry[p].host1;
		if (host0 != core_id && host1 != core_id)
			continue;

		ipclite_global_atomic_store_i32((ipclite_atomic_int32_t *)
			(&(ipclite->ipcmem.partition[p]->hdr.status)), 0);

		IPCLITE_OS_LOG(IPCLITE_DBG, "Global Channel Status : [%d][%d] : %d\n",
					host0, host1, ipclite->ipcmem.partition[p]->hdr.status);
	}

	/* Resets the TX/RX queue */
	*(ipclite->channel[core_id].tx_fifo->head) = 0;
	*(ipclite->channel[core_id].rx_fifo->tail) = 0;

	IPCLITE_OS_LOG(IPCLITE_DBG, "TX Fifo Reset : %d\n",
						*(ipclite->channel[core_id].tx_fifo->head));
	IPCLITE_OS_LOG(IPCLITE_DBG, "RX Fifo Reset : %d\n",
						*(ipclite->channel[core_id].rx_fifo->tail));

	/* Increment the Global Channel Status for APPS and crashed core*/
	ipclite_global_atomic_inc((ipclite_atomic_int32_t *)
					ipclite->channel[core_id].gstatus_ptr);

	ipclite->channel[core_id].status = *ipclite->channel[core_id].gstatus_ptr;

	/* Update other cores about SSR */
	for (host = 1; host < IPCMEM_NUM_HOSTS; host++) {
		if (!is_host_enabled(host) || host == core_id)
			continue;
		ret = ipclite_ssr_update(host);
		if (ret < 0)
			IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to send SSR update to core %d\n", host);
		else
			IPCLITE_OS_LOG(IPCLITE_DBG, "SSR update sent to core %d\n", host);
	}
	mutex_unlock(&ssr_mutex);

	/* Dump the debug information */
	if (ipclite_debug_dump & IPCLITE_DUMP_SSR) {
		ipclite_dump_debug_struct();
		ipclite_dump_inmem_logs();
	}

	return;
}
EXPORT_SYMBOL(ipclite_recover);

int ipclite_msg_send(int32_t proc_id, uint64_t data)
{
	int ret = 0;

	if (proc_id < 0 || proc_id >= IPCMEM_NUM_HOSTS) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid proc_id : %d\n", proc_id);
		return -EINVAL;
	}

	ret = ipclite_tx(&ipclite->channel[proc_id], data, sizeof(data),
								IPCLITE_MSG_SIGNAL);

	IPCLITE_OS_LOG(IPCLITE_DBG, "Message send complete to core : %d signal : %d ret : %d\n",
								proc_id, IPCLITE_MSG_SIGNAL, ret);
	return ret;
}
EXPORT_SYMBOL(ipclite_msg_send);

int ipclite_register_client(IPCLite_Client cb_func_ptr, void *priv)
{
	if (!cb_func_ptr) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid callback pointer\n");
		return -EINVAL;
	}
	synx_client.callback = cb_func_ptr;
	synx_client.priv_data = priv;
	synx_client.reg_complete = 1;
	IPCLITE_OS_LOG(IPCLITE_DBG, "Client Registration completed\n");
	return 0;
}
EXPORT_SYMBOL(ipclite_register_client);

int ipclite_test_msg_send(int32_t proc_id, uint64_t data)
{
	int ret = 0;

	if (proc_id < 0 || proc_id >= IPCMEM_NUM_HOSTS) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid proc_id : %d\n", proc_id);
		return -EINVAL;
	}

	ret = ipclite_tx(&ipclite->channel[proc_id], data, sizeof(data),
									IPCLITE_TEST_SIGNAL);

	IPCLITE_OS_LOG(IPCLITE_DBG, "Test Msg send complete to core : %d signal : %d ret : %d\n",
								proc_id, IPCLITE_TEST_SIGNAL, ret);
	return ret;
}
EXPORT_SYMBOL(ipclite_test_msg_send);

int ipclite_register_test_client(IPCLite_Client cb_func_ptr, void *priv)
{
	if (!cb_func_ptr) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Invalid callback pointer\n");
		return -EINVAL;
	}
	test_client.callback = cb_func_ptr;
	test_client.priv_data = priv;
	test_client.reg_complete = 1;
	IPCLITE_OS_LOG(IPCLITE_DBG, "Test Client Registration Completed\n");
	return 0;
}
EXPORT_SYMBOL(ipclite_register_test_client);

static int map_ipcmem(struct ipclite_info *ipclite, const char *name)
{
	struct device *dev;
	struct device_node *np;
	struct resource r;
	int ret = 0;

	dev = ipclite->dev;

	np = of_parse_phandle(dev->of_node, name, 0);
	if (!np) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "No %s specified\n", name);
		return -EINVAL;
	}

	ret = of_address_to_resource(np, 0, &r);
	of_node_put(np);
	if (ret)
		return ret;

	ipclite->ipcmem.mem.aux_base = (u64)r.start;
	ipclite->ipcmem.mem.size = resource_size(&r);
	ipclite->ipcmem.mem.virt_base = devm_ioremap_wc(dev, r.start,
					resource_size(&r));
	if (!ipclite->ipcmem.mem.virt_base)
		return -ENOMEM;

	IPCLITE_OS_LOG(IPCLITE_DBG, "aux_base = %lx, size=%d,virt_base=%p\n",
			ipclite->ipcmem.mem.aux_base, ipclite->ipcmem.mem.size,
			ipclite->ipcmem.mem.virt_base);

	return ret;
}

/**
 * insert_magic_number() - Inserts the magic number in toc header
 *
 * Function computes a simple checksum of the contents in toc header
 * and stores the result in magic_number field in the toc header
 */
static void insert_magic_number(void)
{
	uint32_t *block = ipclite->ipcmem.mem.virt_base;
	size_t size = sizeof(struct ipcmem_toc_header) / sizeof(uint32_t);

	for (int i = 1; i < size; i++)
		block[0] ^= block[i];

	block[0] = ~block[0];
}

static int32_t setup_toc(struct ipclite_mem *ipcmem)
{
	size_t offset = 0;
	void *virt_base = ipcmem->mem.virt_base;
	struct ipcmem_offsets *offsets = &ipcmem->toc->offsets;
	struct ipcmem_toc_data *toc_data = &ipcmem->toc_data;

	/* Setup Offsets */
	offsets->host_info		= offset += IPCMEM_TOC_VAR_OFFSET;
	offsets->global_entry		= offset += sizeof(struct ipcmem_host_info);
	offsets->partition_info		= offset += sizeof(struct ipcmem_partition_entry);
	offsets->partition_entry	= offset += sizeof(struct ipcmem_partition_info);
	// offsets->debug		= virt_base + size - 64K;
	/* Offset to be used for any new structure added in toc (after partition_entry) */
	// offsets->new_struct	= offset += sizeof(struct ipcmem_partition_entry)*IPCMEM_NUM_HOSTS;

	IPCLITE_OS_LOG(IPCLITE_DBG, "toc_data offsets:");
	IPCLITE_OS_LOG(IPCLITE_DBG, "host_info = 0x%X", offsets->host_info);
	IPCLITE_OS_LOG(IPCLITE_DBG, "global_entry = 0x%X", offsets->global_entry);
	IPCLITE_OS_LOG(IPCLITE_DBG, "partition_info = 0x%X", offsets->partition_info);
	IPCLITE_OS_LOG(IPCLITE_DBG, "partition_entry = 0x%X", offsets->partition_entry);

	/* Point structures to the appropriate offset in TOC */
	toc_data->host_info		= ADD_OFFSET(virt_base, offsets->host_info);
	toc_data->global_entry		= ADD_OFFSET(virt_base, offsets->global_entry);
	toc_data->partition_info	= ADD_OFFSET(virt_base, offsets->partition_info);
	toc_data->partition_entry	= ADD_OFFSET(virt_base, offsets->partition_entry);

	return 0;
}

static void setup_global_partition(struct ipclite_mem *ipcmem, uint32_t base_offset)
{
	/*Fill in global partition details*/
	ipcmem->toc_data.global_entry->base_offset = base_offset;
	ipcmem->toc_data.global_entry->size = GLOBAL_PARTITION_SIZE;
	ipcmem->toc_data.global_entry->flags = GLOBAL_PARTITION_FLAGS;
	ipcmem->toc_data.global_entry->host0 = IPCMEM_GLOBAL_HOST;
	ipcmem->toc_data.global_entry->host1 = IPCMEM_GLOBAL_HOST;

	ipcmem->global_partition = ADD_OFFSET(ipcmem->mem.virt_base, base_offset);

	IPCLITE_OS_LOG(IPCLITE_DBG, "base_offset =%x,ipcmem->global_partition = %p\n",
				base_offset,
				ipcmem->global_partition);

	ipcmem->global_partition->hdr = global_partition_hdr;

	IPCLITE_OS_LOG(IPCLITE_DBG, "hdr.type = %x,hdr.offset = %x,hdr.size = %d\n",
				ipcmem->global_partition->hdr.partition_type,
				ipcmem->global_partition->hdr.region_offset,
				ipcmem->global_partition->hdr.region_size);
}

static void update_partition(struct ipclite_mem *ipcmem, uint32_t p)
{
	int host0 = ipcmem->toc_data.partition_entry[p].host0;
	int host1 = ipcmem->toc_data.partition_entry[p].host1;

	IPCLITE_OS_LOG(IPCLITE_DBG, "host0 = %d, host1=%d\n", host0, host1);

	ipcmem->partition[p] = ADD_OFFSET(ipcmem->mem.virt_base,
					ipcmem->toc_data.partition_entry[p].base_offset);

	IPCLITE_OS_LOG(IPCLITE_DBG, "partition[%d] = %p,partition_base_offset[%d]=%lx",
				p, ipcmem->partition[p],
				p, ipcmem->toc_data.partition_entry[p].base_offset);

	if (host0 == host1)
		ipcmem->partition[p]->hdr = loopback_partition_hdr;
	else
		ipcmem->partition[p]->hdr = default_partition_hdr;

	IPCLITE_OS_LOG(IPCLITE_DBG, "hdr.type = %x,hdr.offset = %x,hdr.size = %d",
				ipcmem->partition[p]->hdr.type,
				ipcmem->partition[p]->hdr.desc_offset,
				ipcmem->partition[p]->hdr.desc_size);
}

static int32_t setup_partitions(struct ipclite_mem *ipcmem, uint32_t base_offset)
{
	uint32_t p, host0, host1;
	uint32_t num_entry = 0;

	/*Fill in each valid ipcmem partition table entry*/
	for (host0 = 0; host0 < IPCMEM_NUM_HOSTS; host0++) {
		if (!is_host_enabled(host0))
			continue;
		for (host1 = host0; host1 < IPCMEM_NUM_HOSTS; host1++) {
			if (!is_host_enabled(host1) || is_loopback_except_apps(host0, host1))
				continue;
			ipcmem->toc_data.partition_entry[num_entry].base_offset = base_offset;
			ipcmem->toc_data.partition_entry[num_entry].size = DEFAULT_PARTITION_SIZE;
			ipcmem->toc_data.partition_entry[num_entry].flags = DEFAULT_PARTITION_FLAGS;
			ipcmem->toc_data.partition_entry[num_entry].host0 = host0;
			ipcmem->toc_data.partition_entry[num_entry].host1 = host1;

			base_offset += DEFAULT_PARTITION_SIZE;
			num_entry++;
		}
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "total partitions = %u", num_entry);

	ipcmem->partition = kcalloc(num_entry, sizeof(*ipcmem->partition), GFP_KERNEL);
	if (!ipcmem->partition) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Partition Allocation failed");
		return -ENOMEM;
	}

	/*Update appropriate partition based on partition entries*/
	for (p = 0; p < num_entry; p++)
		update_partition(ipcmem, p);

	/*Set up info to parse partition entries*/
	ipcmem->toc_data.partition_info->num_entries = partitions = num_entry;
	ipcmem->toc_data.partition_info->entry_size = sizeof(struct ipcmem_partition_entry);
	return 0;
}

static int32_t ipcmem_init(struct ipclite_mem *ipcmem, struct device_node *pn)
{
	int ret;
	uint32_t remote_pid;
	uint32_t host_count = 0;
	uint32_t gmem_offset = 0;
	struct device_node *cn;

	for_each_available_child_of_node(pn, cn) {
		of_property_read_u32(cn, "qcom,remote-pid", &remote_pid);
		if (remote_pid < IPCMEM_NUM_HOSTS) {
			enabled_hosts |= BIT_MASK(remote_pid);
			host_count++;
		}
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "enabled_hosts = 0x%X", enabled_hosts);
	IPCLITE_OS_LOG(IPCLITE_DBG, "host_count = %u", host_count);

	ipcmem->toc = ipcmem->mem.virt_base;
	IPCLITE_OS_LOG(IPCLITE_DBG, "toc_base = %p\n", ipcmem->toc);

	ret = setup_toc(ipcmem);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to set up toc");
		return ret;
	}

	/*Set up host related info*/
	ipcmem->toc_data.host_info->hwlock_owner = IPCMEM_INVALID_HOST;
	ipcmem->toc_data.host_info->configured_host = enabled_hosts;

	gmem_offset += IPCMEM_TOC_SIZE;
	setup_global_partition(ipcmem, gmem_offset);

	gmem_offset += GLOBAL_PARTITION_SIZE;
	ret = setup_partitions(ipcmem, gmem_offset);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to set up partitions");
		return ret;
	}

	/*Making sure all writes for ipcmem configurations are completed*/
	wmb();

	ipcmem->toc->hdr.init_done = IPCMEM_INIT_COMPLETED;
	IPCLITE_OS_LOG(IPCLITE_DBG, "Ipcmem init completed\n");
	return 0;
}

static int ipclite_channel_irq_init(struct device *parent, struct device_node *node,
								struct ipclite_channel *channel)
{
	int ret = 0;
	u32 index;
	struct ipclite_irq_info *irq_info;
	struct device *dev;
	char strs[MAX_CHANNEL_SIGNALS][IPCLITE_SIGNAL_LABEL_SIZE] = {
			"msg", "mem-init", "version", "test", "ssr", "debug"};

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->parent = parent;
	dev->of_node = node;
	dev_set_name(dev, "%s:%pOFn", dev_name(parent->parent), node);
	IPCLITE_OS_LOG(IPCLITE_DBG, "Registering %s device\n", dev_name(parent->parent));
	ret = device_register(dev);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "failed to register ipclite child node\n");
		put_device(dev);
		return ret;
	}

	ret = of_property_read_u32(dev->of_node, "index",
				   &index);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "failed to parse index\n");
		goto err_dev;
	}

	irq_info = &channel->irq_info[index];
	IPCLITE_OS_LOG(IPCLITE_DBG, "irq_info[%d]=%p\n", index, irq_info);

	irq_info->mbox_client.dev = dev;
	irq_info->mbox_client.knows_txdone = true;
	irq_info->mbox_chan = mbox_request_channel(&irq_info->mbox_client, 0);
	IPCLITE_OS_LOG(IPCLITE_DBG, "irq_info[%d].mbox_chan=%p\n", index, irq_info->mbox_chan);
	if (IS_ERR(irq_info->mbox_chan)) {
		if (PTR_ERR(irq_info->mbox_chan) != -EPROBE_DEFER)
			IPCLITE_OS_LOG(IPCLITE_ERR, "failed to acquire IPC channel\n");
		goto err_dev;
	}

	snprintf(irq_info->irqname, 32, "ipclite-signal-%s", strs[index]);
	irq_info->irq = of_irq_get(dev->of_node, 0);
	IPCLITE_OS_LOG(IPCLITE_DBG, "irq[%d] = %d\n", index, irq_info->irq);
	irq_info->signal_id = index;
	ret = devm_request_irq(dev, irq_info->irq,
			       ipclite_intr,
			       IRQF_NO_SUSPEND | IRQF_SHARED,
			       irq_info->irqname, irq_info);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "failed to request IRQ\n");
		goto err_dev;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "Interrupt init completed, ret = %d\n", ret);
	return 0;

err_dev:
	device_unregister(dev);
	kfree(dev);
	return ret;
}

int32_t get_global_partition_info(struct global_region_info *global_ipcmem)
{
	struct ipcmem_global_partition *global_partition;

	/* Check added to verify ipclite is initialized */
	if (!ipclite) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "IPCLite not initialized\n");
		return -ENOMEM;
	}

	if (!global_ipcmem)
		return -EINVAL;

	global_partition = ipclite->ipcmem.global_partition;
	global_ipcmem->virt_base = (void *)((char *)global_partition +
							global_partition->hdr.region_offset);
	global_ipcmem->size = (size_t)(global_partition->hdr.region_size);

	IPCLITE_OS_LOG(IPCLITE_DBG, "base = %p, size=%lx\n", global_ipcmem->virt_base,
									global_ipcmem->size);
	return 0;
}
EXPORT_SYMBOL(get_global_partition_info);

static struct ipcmem_partition_header *get_ipcmem_partition_hdr(struct ipclite_mem ipcmem, int local_pid,
								int remote_pid)
{
	uint32_t p;
	uint32_t found = -1;

	for (p = 0; p < partitions; p++) {
		if (ipcmem.toc_data.partition_entry[p].host0 == local_pid
			&& ipcmem.toc_data.partition_entry[p].host1 == remote_pid) {
			found = p;
			break;
		}
	}

	if (found < partitions)
		return (struct ipcmem_partition_header *)((char *)ipcmem.mem.virt_base +
					ipcmem.toc_data.partition_entry[found].base_offset);
	else
		return NULL;
}

static void ipclite_channel_release(struct device *dev)
{
	IPCLITE_OS_LOG(IPCLITE_INFO, "Releasing ipclite channel\n");
	kfree(dev);
}

/* Sets up following fields of IPCLite channel structure:
 *	remote_pid,tx_fifo, rx_fifo
 */
static int ipclite_channel_init(struct device *parent,
								struct device_node *node)
{
	struct ipclite_fifo *rx_fifo;
	struct ipclite_fifo *tx_fifo;

	struct device *dev;
	u32 local_pid, remote_pid, global_atomic;
	u32 *descs;
	int ret = 0;

	struct device_node *child;

	struct ipcmem_partition_header *partition_hdr;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->parent = parent;
	dev->of_node = node;
	dev->release = ipclite_channel_release;
	dev_set_name(dev, "%s:%pOFn", dev_name(parent->parent), node);
	IPCLITE_OS_LOG(IPCLITE_DBG, "Registering %s device\n", dev_name(parent->parent));
	ret = device_register(dev);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "failed to register ipclite device\n");
		put_device(dev);
		kfree(dev);
		return ret;
	}

	local_pid = LOCAL_HOST;

	ret = of_property_read_u32(dev->of_node, "qcom,remote-pid",
				   &remote_pid);
	if (ret) {
		dev_err(dev, "failed to parse qcom,remote-pid\n");
		goto err_put_dev;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "remote_pid = %d, local_pid=%d\n", remote_pid, local_pid);

	ipclite_hw_mutex = devm_kzalloc(dev, sizeof(*ipclite_hw_mutex), GFP_KERNEL);
	if (!ipclite_hw_mutex) {
		ret = -ENOMEM;
		goto err_put_dev;
	}

	ret = of_property_read_u32(dev->of_node, "global_atomic", &global_atomic);
	if (ret) {
		dev_err(dev, "failed to parse global_atomic\n");
		goto err_put_dev;
	}
	if (global_atomic == 0)
		global_atomic_support = GLOBAL_ATOMICS_DISABLED;

	rx_fifo = devm_kzalloc(dev, sizeof(*rx_fifo), GFP_KERNEL);
	tx_fifo = devm_kzalloc(dev, sizeof(*tx_fifo), GFP_KERNEL);
	if (!rx_fifo || !tx_fifo) {
		ret = -ENOMEM;
		goto err_put_dev;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "rx_fifo = %p, tx_fifo=%p\n", rx_fifo, tx_fifo);

	partition_hdr = get_ipcmem_partition_hdr(ipclite->ipcmem, local_pid, remote_pid);
	IPCLITE_OS_LOG(IPCLITE_DBG, "partition_hdr = %p\n", partition_hdr);
	if (!partition_hdr) {
		ret = -ENOMEM;
		goto err_put_dev;
	}

	descs = (u32 *)((char *)partition_hdr + partition_hdr->desc_offset);
	IPCLITE_OS_LOG(IPCLITE_DBG, "descs = %p\n", descs);

	if (local_pid < remote_pid) {
		tx_fifo->fifo = (char *)partition_hdr + partition_hdr->fifo0_offset;
		tx_fifo->length = partition_hdr->fifo0_size;
		rx_fifo->fifo = (char *)partition_hdr + partition_hdr->fifo1_offset;
		rx_fifo->length = partition_hdr->fifo1_size;

		tx_fifo->tail = &descs[0];
		tx_fifo->head = &descs[1];
		rx_fifo->tail = &descs[2];
		rx_fifo->head = &descs[3];

	} else {
		tx_fifo->fifo = (char *)partition_hdr + partition_hdr->fifo1_offset;
		tx_fifo->length = partition_hdr->fifo1_size;
		rx_fifo->fifo = (char *)partition_hdr + partition_hdr->fifo0_offset;
		rx_fifo->length = partition_hdr->fifo0_size;

		rx_fifo->tail = &descs[0];
		rx_fifo->head = &descs[1];
		tx_fifo->tail = &descs[2];
		tx_fifo->head = &descs[3];
	}

	if (partition_hdr->type == LOOPBACK_PARTITION_TYPE) {
		rx_fifo->tail = tx_fifo->tail;
		rx_fifo->head = tx_fifo->head;
	}

	/* rx_fifo->reset = ipcmem_rx_reset;*/
	rx_fifo->avail = ipcmem_rx_avail;
	rx_fifo->peak = ipcmem_rx_peak;
	rx_fifo->advance = ipcmem_rx_advance;

	/* tx_fifo->reset = ipcmem_tx_reset;*/
	tx_fifo->avail = ipcmem_tx_avail;
	tx_fifo->write = ipcmem_tx_write;

	*rx_fifo->tail = 0;
	*tx_fifo->head = 0;

	/*Store Channel Information*/
	ipclite->channel[remote_pid].remote_pid = remote_pid;
	ipclite->channel[remote_pid].tx_fifo = tx_fifo;
	ipclite->channel[remote_pid].rx_fifo = rx_fifo;
	ipclite->channel[remote_pid].gstatus_ptr = &partition_hdr->status;

	spin_lock_init(&ipclite->channel[remote_pid].tx_lock);

	for_each_available_child_of_node(dev->of_node, child) {
		ret = ipclite_channel_irq_init(dev, child,
				&ipclite->channel[remote_pid]);
		if (ret) {
			IPCLITE_OS_LOG(IPCLITE_ERR, "irq setup for ipclite channel failed\n");
			goto err_put_dev;
		}
	}

	/* Updating Local & Global Channel Status */
	if (remote_pid == IPCMEM_APPS) {
		*ipclite->channel[remote_pid].gstatus_ptr = ACTIVE;
		ipclite->channel[remote_pid].status = ACTIVE;
	} else {
		*ipclite->channel[remote_pid].gstatus_ptr = IN_PROGRESS;
		ipclite->channel[remote_pid].status = IN_PROGRESS;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "Channel init completed, ret = %d\n", ret);
	return ret;

err_put_dev:
	ipclite->channel[remote_pid].status = INACTIVE;
	device_unregister(dev);
	kfree(dev);
	return ret;
}

static void probe_subsystem(struct device *dev, struct device_node *np)
{
	int ret = 0;

	ret = ipclite_channel_init(dev, np);
	if (ret)
		IPCLITE_OS_LOG(IPCLITE_ERR, "IPCLite Channel init failed\n");
}

static ssize_t ipclite_dbg_lvl_write(struct kobject *kobj,
				struct kobj_attribute *attr, const char *buf, size_t count)
{
	int ret = 0, host = 0;

	/* Parse the string from Sysfs Interface */
	ret = kstrtoint(buf, 0, &ipclite_debug_level);
	if (ret < 0) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Error parsing the sysfs value");
		return ret;
	}

	/* Check if debug structure is initialized */
	if (!ipclite_dbg_info) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Debug structures not initialized\n");
		return -ENOMEM;
	}

	/* Update the Global Debug variable for FW cores */
	ipclite_dbg_info->debug_level = ipclite_debug_level;

	/* Memory Barrier to make sure all writes are completed */
	wmb();

	/* Signal other cores for updating the debug information */
	for (host = 1; host < IPCMEM_NUM_HOSTS; host++) {
		if (!is_host_enabled(host))
			continue;
		ret = ipclite_send_debug_info(host);
		if (ret < 0)
			IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to send the debug info %d\n", host);
		else
			IPCLITE_OS_LOG(IPCLITE_DBG, "Debug info sent to host %d\n", host);
	}

	return count;
}

static ssize_t ipclite_dbg_ctrl_write(struct kobject *kobj,
				struct kobj_attribute *attr, const char *buf, size_t count)
{
	int ret = 0, host = 0;

	/* Parse the string from Sysfs Interface */
	ret = kstrtoint(buf, 0, &ipclite_debug_control);
	if (ret < 0) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Error parsing the sysfs value");
		return ret;
	}

	/* Check if debug structures are initialized */
	if (!ipclite_dbg_info || !ipclite_dbg_struct || !ipclite_dbg_inmem) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Debug structures not initialized\n");
		return -ENOMEM;
	}

	/* Update the Global Debug variable for FW cores */
	ipclite_dbg_info->debug_control = ipclite_debug_control;

	/* Memory Barrier to make sure all writes are completed */
	wmb();

	/* Signal other cores for updating the debug information */
	for (host = 1; host < IPCMEM_NUM_HOSTS; host++) {
		if (!is_host_enabled(host))
			continue;
		ret = ipclite_send_debug_info(host);
		if (ret < 0)
			IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to send the debug info %d\n", host);
		else
			IPCLITE_OS_LOG(IPCLITE_DBG, "Debug info sent to host %d\n", host);
	}

	return count;
}

static ssize_t ipclite_dbg_dump_write(struct kobject *kobj,
				struct kobj_attribute *attr, const char *buf, size_t count)
{
	int ret = 0;

	/* Parse the string from Sysfs Interface */
	ret = kstrtoint(buf, 0, &ipclite_debug_dump);
	if (ret < 0) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Error parsing the sysfs value");
		return ret;
	}

	/* Check if debug structures are initialized */
	if (!ipclite_dbg_info || !ipclite_dbg_struct || !ipclite_dbg_inmem) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Debug structures not initialized\n");
		return -ENOMEM;
	}

	/* Dump the debug information */
	if (ipclite_debug_dump & IPCLITE_DUMP_DBG_STRUCT)
		ipclite_dump_debug_struct();

	if (ipclite_debug_dump & IPCLITE_DUMP_INMEM_LOG)
		ipclite_dump_inmem_logs();

	return count;
}

struct kobj_attribute sysfs_dbg_lvl = __ATTR(ipclite_debug_level, 0660,
					NULL, ipclite_dbg_lvl_write);
struct kobj_attribute sysfs_dbg_ctrl = __ATTR(ipclite_debug_control, 0660,
					NULL, ipclite_dbg_ctrl_write);
struct kobj_attribute sysfs_dbg_dump = __ATTR(ipclite_debug_dump, 0660,
					NULL, ipclite_dbg_dump_write);

static int ipclite_debug_sysfs_setup(void)
{
	int ret = 0;

	/* Creating a directory in /sys/kernel/ */
	sysfs_kobj = kobject_create_and_add("ipclite", kernel_kobj);
	if (!sysfs_kobj) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot create and add sysfs directory\n");
		return -ENOMEM;
	}

	/* Creating sysfs files/interfaces for debug */
	ret = sysfs_create_file(sysfs_kobj, &sysfs_dbg_lvl.attr);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot create sysfs debug level file\n");
		return ret;
	}

	ret = sysfs_create_file(sysfs_kobj, &sysfs_dbg_ctrl.attr);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot create sysfs debug control file\n");
		return ret;
	}

	ret = sysfs_create_file(sysfs_kobj, &sysfs_dbg_dump.attr);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Cannot create sysfs debug dump file\n");
		return ret;
	}

	return ret;
}

static int ipclite_debug_info_setup(void)
{
	/* Setting up the Debug Structures */
	ipclite_dbg_info = (struct ipclite_debug_info *)(((char *)ipclite->ipcmem.mem.virt_base +
						ipclite->ipcmem.mem.size) - DEBUG_PARTITION_SIZE);
	if (!ipclite_dbg_info)
		return -EADDRNOTAVAIL;

	ipclite_dbg_struct = (struct ipclite_debug_struct *)
					(((char *)ipclite_dbg_info + IPCLITE_DEBUG_INFO_SIZE) +
					(sizeof(*ipclite_dbg_struct) * IPCMEM_APPS));
	if (!ipclite_dbg_struct)
		return -EADDRNOTAVAIL;

	ipclite_dbg_inmem = (struct ipclite_debug_inmem_buf *)
					(((char *)ipclite_dbg_info + IPCLITE_DEBUG_INFO_SIZE) +
					(sizeof(*ipclite_dbg_struct) * IPCMEM_NUM_HOSTS));

	if (!ipclite_dbg_inmem)
		return -EADDRNOTAVAIL;

	IPCLITE_OS_LOG(IPCLITE_DBG, "virtual_base_ptr = %p total_size : %d debug_size : %d\n",
		ipclite->ipcmem.mem.virt_base, ipclite->ipcmem.mem.size, DEBUG_PARTITION_SIZE);
	IPCLITE_OS_LOG(IPCLITE_DBG, "dbg_info : %p dbg_struct : %p dbg_inmem : %p\n",
					ipclite_dbg_info, ipclite_dbg_struct, ipclite_dbg_inmem);

	return 0;
}

static int ipclite_probe(struct platform_device *pdev)
{
	int ret = 0;
	int hwlock_id;
	struct ipcmem_region *mem;
	struct device_node *cn;
	struct device_node *pn = pdev->dev.of_node;
	struct ipclite_channel broadcast;

	ipclite = kzalloc(sizeof(*ipclite), GFP_KERNEL);
	if (!ipclite) {
		ret = -ENOMEM;
		goto error;
	}

	ipclite->dev = &pdev->dev;

	hwlock_id = of_hwspin_lock_get_id(pn, 0);
	if (hwlock_id < 0) {
		if (hwlock_id != -EPROBE_DEFER)
			dev_err(&pdev->dev, "failed to retrieve hwlock\n");
		ret = hwlock_id;
		goto release;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "Hwlock id retrieved, hwlock_id=%d\n", hwlock_id);

	ipclite->hwlock = hwspin_lock_request_specific(hwlock_id);
	if (!ipclite->hwlock) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to assign hwlock_id\n");
		ret = -ENXIO;
		goto release;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "Hwlock id assigned successfully, hwlock=%p\n",
									ipclite->hwlock);

	/* Initializing Local Mutex Lock for SSR functionality */
	mutex_init(&ssr_mutex);

	ret = map_ipcmem(ipclite, "memory-region");
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "failed to map ipcmem\n");
		goto release;
	}
	mem = &(ipclite->ipcmem.mem);
	memset(mem->virt_base, 0, mem->size);

	ret = ipcmem_init(&ipclite->ipcmem, pn);
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to set up IPCMEM");
		goto release;
	}

	/* Set up sysfs for debug  */
	ret = ipclite_debug_sysfs_setup();
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to Set up IPCLite Debug Sysfs\n");
		goto release;
	}

	/* Mapping Debug Memory */
	ret = ipclite_debug_info_setup();
	if (ret) {
		IPCLITE_OS_LOG(IPCLITE_ERR, "Failed to Set up IPCLite Debug Structures\n");
		goto release;
	}

	/* Setup Channel for each Remote Subsystem */
	for_each_available_child_of_node(pn, cn)
		probe_subsystem(&pdev->dev, cn);
	/* Broadcast init_done signal to all subsystems once mbox channels
	 * are set up
	 */
	broadcast = ipclite->channel[IPCMEM_APPS];
	ret = mbox_send_message(broadcast.irq_info[IPCLITE_MEM_INIT_SIGNAL].mbox_chan,
								 NULL);
	if (ret < 0)
		goto mem_release;

	mbox_client_txdone(broadcast.irq_info[IPCLITE_MEM_INIT_SIGNAL].mbox_chan, 0);

	if (global_atomic_support) {
		ipclite->ipcmem.toc->hdr.feature_mask |= GLOBAL_ATOMIC_SUPPORT_BMSK;
	}
	IPCLITE_OS_LOG(IPCLITE_DBG, "global_atomic_support : %d\n", global_atomic_support);

	/* Should be called after all Global TOC related init is done */
	insert_magic_number();

	/* hw mutex callbacks */
	ipclite_hw_mutex->acquire = ipclite_hw_mutex_acquire;
	ipclite_hw_mutex->release = ipclite_hw_mutex_release;

	/* store to ipclite structure */
	ipclite->ipclite_hw_mutex = ipclite_hw_mutex;

	/* Update the Global Debug variable for FW cores */
	ipclite_dbg_info->debug_level = ipclite_debug_level;
	ipclite_dbg_info->debug_control = ipclite_debug_control;

	IPCLITE_OS_LOG(IPCLITE_INFO, "IPCLite probe completed successfully\n");
	return ret;

mem_release:
	/* If the remote subsystem has already completed the init and actively
	 * using IPCMEM, re-assigning IPCMEM memory back to HLOS can lead to crash
	 * Solution: Either we don't take back the memory or make sure APPS completes
	 * init before any other subsystem initializes IPCLite (we won't have to send
	 * braodcast)
	 */
release:
	kfree(ipclite);
	ipclite = NULL;
error:
	IPCLITE_OS_LOG(IPCLITE_ERR, "IPCLite probe failed\n");
	return ret;
}

static const struct of_device_id ipclite_of_match[] = {
	{ .compatible = "qcom,ipclite"},
	{}
};
MODULE_DEVICE_TABLE(of, ipclite_of_match);

static struct platform_driver ipclite_driver = {
	.probe = ipclite_probe,
	.driver = {
		.name = "ipclite",
		.of_match_table = ipclite_of_match,
	},
};

module_platform_driver(ipclite_driver);

MODULE_DESCRIPTION("IPCLite Driver");
MODULE_LICENSE("GPL v2");
MODULE_SOFTDEP("pre: qcom_hwspinlock");