soc: qcom: Add snapshot of SMD driver

	  processors in the System on a Chip (SoC) which allows basic

	  inter-processor communication.

config MSM_SMD

	depends on MSM_SMEM

	bool "MSM Shared Memory Driver (SMD)"

	help

	  Support for the shared memory interprocessor communication protocol

	  which provides virual point to point serial channels between processes

	  on the apps processor and processes on other processors in the SoC.

	  Also includes support for the Shared Memory State Machine (SMSM)

	  protocol which provides a mechanism to publish single bit state

	  information to one or more processors in the SoC.

config MSM_SMD_DEBUG

	depends on MSM_SMD

	bool "MSM SMD debug support"

	help

	  Support for debugging SMD and SMSM communication between apps and

	  other processors in the SoC. Debug support primarily consists of

	  logs consisting of information such as what interrupts were processed,

	  what channels caused interrupt activity, and when internal state

	  change events occur.

config QCOM_GSBI

        tristate "QCOM General Serial Bus Interface"

        depends on ARCH_QCOM

obj-$(CONFIG_MSM_SMEM)	+=	msm_smem.o smem_debug.o

obj-$(CONFIG_MSM_SMD)	+= 	msm_smd.o smd_debug.o smd_private.o smd_init_dt.o smsm_debug.o

obj-$(CONFIG_QCOM_GSBI)	+=	qcom_gsbi.o

obj-$(CONFIG_QCOM_PM)	+=	spm.o

obj-$(CONFIG_QCOM_SMD) +=	smd.o

/* drivers/soc/qcom/smd_debug.c

 *

 * Copyright (C) 2007 Google, Inc.

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

 * Author: Brian Swetland <swetland@google.com>

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

#include <linux/debugfs.h>

#include <linux/list.h>

#include <linux/ctype.h>

#include <linux/jiffies.h>

#include <linux/err.h>

#include <soc/qcom/smem.h>

#include "smd_private.h"

#if defined(CONFIG_DEBUG_FS)

static char *chstate(unsigned n)

{

	switch (n) {

	case SMD_SS_CLOSED:

		return "CLOSED";

	case SMD_SS_OPENING:

		return "OPENING";

	case SMD_SS_OPENED:

		return "OPENED";

	case SMD_SS_FLUSHING:

		return "FLUSHING";

	case SMD_SS_CLOSING:

		return "CLOSING";

	case SMD_SS_RESET:

		return "RESET";

	case SMD_SS_RESET_OPENING:

		return "ROPENING";

	default:

		return "UNKNOWN";

	}

}

static void debug_int_stats(struct seq_file *s)

{

	int subsys;

	struct interrupt_stat *stats = interrupt_stats;

	const char *subsys_name;

	seq_puts(s,

		"   Subsystem    | Interrupt ID |    In     |    Out    |\n");

	for (subsys = 0; subsys < NUM_SMD_SUBSYSTEMS; ++subsys) {

		subsys_name = smd_pid_to_subsystem(subsys);

		if (!IS_ERR_OR_NULL(subsys_name)) {

			seq_printf(s, "%-10s %4s |    %9d | %9u | %9u |\n",

				smd_pid_to_subsystem(subsys), "smd",

				stats->smd_interrupt_id,

				stats->smd_in_count,

				stats->smd_out_count);

			seq_printf(s, "%-10s %4s |    %9d | %9u | %9u |\n",

				smd_pid_to_subsystem(subsys), "smsm",

				stats->smsm_interrupt_id,

				stats->smsm_in_count,

				stats->smsm_out_count);

		}

		++stats;

	}

}

static void debug_int_stats_reset(struct seq_file *s)

{

	int subsys;

	struct interrupt_stat *stats = interrupt_stats;

	seq_puts(s, "Resetting interrupt stats.\n");

	for (subsys = 0; subsys < NUM_SMD_SUBSYSTEMS; ++subsys) {

		stats->smd_in_count = 0;

		stats->smd_out_count = 0;

		stats->smsm_in_count = 0;

		stats->smsm_out_count = 0;

		++stats;

	}

}

/* NNV: revist, it may not be smd version */

static void debug_read_smd_version(struct seq_file *s)

{

	uint32_t *smd_ver;

	uint32_t n, version;

	smd_ver = smem_find(SMEM_VERSION_SMD, 32 * sizeof(uint32_t),

							0, SMEM_ANY_HOST_FLAG);

	if (smd_ver)

		for (n = 0; n < 32; n++) {

			version = smd_ver[n];

			seq_printf(s, "entry %d: %d.%d\n", n,

				       version >> 16,

				       version & 0xffff);

		}

}

/**

 * pid_to_str - Convert a numeric processor id value into a human readable

 *		string value.

 *

 * @pid: the processor id to convert

 * @returns: a string representation of @pid

 */

static char *pid_to_str(int pid)

{

	switch (pid) {

	case SMD_APPS:

		return "APPS";

	case SMD_MODEM:

		return "MDMSW";

	case SMD_Q6:

		return "ADSP";

	case SMD_TZ:

		return "TZ";

	case SMD_WCNSS:

		return "WCNSS";

	case SMD_MODEM_Q6_FW:

		return "MDMFW";

	case SMD_RPM:

		return "RPM";

	default:

		return "???";

	}

}

/**

 * print_half_ch_state - Print the state of half of a SMD channel in a human

 *			readable format.

 *

 * @s: the sequential file to print to

 * @half_ch: half of a SMD channel that should have its state printed

 * @half_ch_funcs: the relevant channel access functions for @half_ch

 * @size: size of the fifo in bytes associated with @half_ch

 * @proc: the processor id that owns the part of the SMD channel associated with

 *		@half_ch

 * @is_restricted: true if memory access is restricted

 */

static void print_half_ch_state(struct seq_file *s,

				void *half_ch,

				struct smd_half_channel_access *half_ch_funcs,

				unsigned size,

				int proc,

				bool is_restricted)

{

	seq_printf(s, "%-5s|", pid_to_str(proc));

	if (!is_restricted) {

		seq_printf(s, "%-7s|0x%05X|0x%05X|0x%05X",

			chstate(half_ch_funcs->get_state(half_ch)),

			size,

			half_ch_funcs->get_tail(half_ch),

			half_ch_funcs->get_head(half_ch));

		seq_printf(s, "|%c%c%c%c%c%c%c%c|0x%05X",

			half_ch_funcs->get_fDSR(half_ch) ? 'D' : 'd',

			half_ch_funcs->get_fCTS(half_ch) ? 'C' : 'c',

			half_ch_funcs->get_fCD(half_ch) ? 'C' : 'c',

			half_ch_funcs->get_fRI(half_ch) ? 'I' : 'i',

			half_ch_funcs->get_fHEAD(half_ch) ? 'W' : 'w',

			half_ch_funcs->get_fTAIL(half_ch) ? 'R' : 'r',

			half_ch_funcs->get_fSTATE(half_ch) ? 'S' : 's',

			half_ch_funcs->get_fBLOCKREADINTR(half_ch) ? 'B' : 'b',

			(half_ch_funcs->get_head(half_ch) -

				half_ch_funcs->get_tail(half_ch)) & (size - 1));

	} else {

		seq_puts(s, " Access Restricted");

	}

}

/**

 * smd_xfer_type_to_str - Convert a numeric transfer type value into a human

 *		readable string value.

 *

 * @xfer_type: the processor id to convert

 * @returns: a string representation of @xfer_type

 */

static char *smd_xfer_type_to_str(uint32_t xfer_type)

{

	if (xfer_type == 1)

		return "S"; /* streaming type */

	else if (xfer_type == 2)

		return "P"; /* packet type */

	else

		return "L"; /* legacy type */

}

/**

 * print_smd_ch_table - Print the current state of every valid SMD channel in a

 *			specific SMD channel allocation table to a human

 *			readable formatted output.

 *

 * @s: the sequential file to print to

 * @tbl: a valid pointer to the channel allocation table to print from

 * @num_tbl_entries: total number of entries in the table referenced by @tbl

 * @ch_base_id: the SMEM item id corresponding to the array of channel

 *		structures for the channels found in @tbl

 * @fifo_base_id: the SMEM item id corresponding to the array of channel fifos

 *		for the channels found in @tbl

 * @pid: processor id to use for any SMEM operations

 * @flags: flags to use for any SMEM operations

 */

static void print_smd_ch_table(struct seq_file *s,

				struct smd_alloc_elm *tbl,

				unsigned num_tbl_entries,

				unsigned ch_base_id,

				unsigned fifo_base_id,

				unsigned pid,

				unsigned flags)

{

	void *half_ch;

	unsigned half_ch_size;

	uint32_t ch_type;

	void *buffer;

	unsigned buffer_size;

	int n;

	bool is_restricted;

/*

 * formatted, human readable channel state output, ie:

ID|CHANNEL NAME       |T|PROC |STATE  |FIFO SZ|RDPTR  |WRPTR  |FLAGS   |DATAPEN

-------------------------------------------------------------------------------

00|DS                 |S|APPS |CLOSED |0x02000|0x00000|0x00000|dcCiwrsb|0x00000

  |                   | |MDMSW|OPENING|0x02000|0x00000|0x00000|dcCiwrsb|0x00000

-------------------------------------------------------------------------------

 */

	seq_printf(s, "%2s|%-19s|%1s|%-5s|%-7s|%-7s|%-7s|%-7s|%-8s|%-7s\n",

								"ID",

								"CHANNEL NAME",

								"T",

								"PROC",

								"STATE",

								"FIFO SZ",

								"RDPTR",

								"WRPTR",

								"FLAGS",

								"DATAPEN");

	seq_puts(s,

		"-------------------------------------------------------------------------------\n");

	for (n = 0; n < num_tbl_entries; ++n) {

		if (strlen(tbl[n].name) == 0)

			continue;

		seq_printf(s, "%2u|%-19s|%s|", tbl[n].cid, tbl[n].name,

			smd_xfer_type_to_str(SMD_XFER_TYPE(tbl[n].type)));

		ch_type = SMD_CHANNEL_TYPE(tbl[n].type);

		if (smd_edge_to_remote_pid(ch_type) == SMD_RPM &&

		   smd_edge_to_local_pid(ch_type) != SMD_APPS)

			is_restricted = true;

		else

			is_restricted = false;

		if (is_word_access_ch(ch_type))

			half_ch_size =

				sizeof(struct smd_half_channel_word_access);

		else

			half_ch_size = sizeof(struct smd_half_channel);

		half_ch = smem_find(ch_base_id + n, 2 * half_ch_size,

								pid, flags);

		buffer = smem_get_entry(fifo_base_id + n, &buffer_size,

								pid, flags);

		if (half_ch && buffer)

			print_half_ch_state(s,

					half_ch,

					get_half_ch_funcs(ch_type),

					buffer_size / 2,

					smd_edge_to_local_pid(ch_type),

					is_restricted);

		seq_puts(s, "\n");

		seq_printf(s, "%2s|%-19s|%1s|", "", "", "");

		if (half_ch && buffer)

			print_half_ch_state(s,

					half_ch + half_ch_size,

					get_half_ch_funcs(ch_type),

					buffer_size / 2,

					smd_edge_to_remote_pid(ch_type),

					is_restricted);

		seq_puts(s, "\n");

		seq_puts(s,

			"-------------------------------------------------------------------------------\n");

	}

}

/**

 * debug_ch - Print the current state of every valid SMD channel in a human

 *		readable formatted table.

 *

 * @s: the sequential file to print to

 */

static void debug_ch(struct seq_file *s)

{

	struct smd_alloc_elm *tbl;

	struct smd_alloc_elm *default_pri_tbl;

	struct smd_alloc_elm *default_sec_tbl;

	unsigned tbl_size;

	int i;

	tbl = smem_get_entry(ID_CH_ALLOC_TBL, &tbl_size, 0, SMEM_ANY_HOST_FLAG);

	default_pri_tbl = tbl;

	if (!tbl) {

		seq_puts(s, "Channel allocation table not found\n");

		return;

	}

	if (IS_ERR(tbl) && PTR_ERR(tbl) == -EPROBE_DEFER) {

		seq_puts(s, "SMEM is not initialized\n");

		return;

	}

	seq_puts(s, "Primary allocation table:\n");

	print_smd_ch_table(s, tbl, tbl_size / sizeof(*tbl), ID_SMD_CHANNELS,

							SMEM_SMD_FIFO_BASE_ID,

							0,

							SMEM_ANY_HOST_FLAG);

	tbl = smem_get_entry(SMEM_CHANNEL_ALLOC_TBL_2, &tbl_size, 0,

							SMEM_ANY_HOST_FLAG);

	default_sec_tbl = tbl;

	if (tbl) {

		seq_puts(s, "\n\nSecondary allocation table:\n");

		print_smd_ch_table(s, tbl, tbl_size / sizeof(*tbl),

						SMEM_SMD_BASE_ID_2,

						SMEM_SMD_FIFO_BASE_ID_2,

						0,

						SMEM_ANY_HOST_FLAG);

	}

	for (i = 1; i < NUM_SMD_SUBSYSTEMS; ++i) {

		tbl = smem_get_entry(ID_CH_ALLOC_TBL, &tbl_size, i, 0);

		if (tbl && tbl != default_pri_tbl) {

			seq_puts(s, "\n\n");

			seq_printf(s, "%s <-> %s Primary allocation table:\n",

							pid_to_str(SMD_APPS),

							pid_to_str(i));

			print_smd_ch_table(s, tbl, tbl_size / sizeof(*tbl),

							ID_SMD_CHANNELS,

							SMEM_SMD_FIFO_BASE_ID,

							i,

							0);

		}

		tbl = smem_get_entry(SMEM_CHANNEL_ALLOC_TBL_2, &tbl_size, i, 0);

		if (tbl && tbl != default_sec_tbl) {

			seq_puts(s, "\n\n");

			seq_printf(s, "%s <-> %s Secondary allocation table:\n",

							pid_to_str(SMD_APPS),

							pid_to_str(i));

			print_smd_ch_table(s, tbl, tbl_size / sizeof(*tbl),

						SMEM_SMD_BASE_ID_2,

						SMEM_SMD_FIFO_BASE_ID_2,

						i,

						0);

		}

	}

}

static int debugfs_show(struct seq_file *s, void *data)

{

	void (*show)(struct seq_file *) = s->private;

	show(s);

	return 0;

}

static int debug_open(struct inode *inode, struct file *file)

{

	return single_open(file, debugfs_show, inode->i_private);

}

static const struct file_operations debug_ops = {

	.open = debug_open,

	.release = single_release,

	.read = seq_read,

	.llseek = seq_lseek,

};

static void debug_create(const char *name, umode_t mode,

			 struct dentry *dent,

			 void (*show)(struct seq_file *))

{

	struct dentry *file;

	file = debugfs_create_file(name, mode, dent, show, &debug_ops);

	if (!file)

		pr_err("%s: unable to create file '%s'\n", __func__, name);

}

static int __init smd_debugfs_init(void)

{

	struct dentry *dent;

	dent = debugfs_create_dir("smd", 0);

	if (IS_ERR(dent))

		return PTR_ERR(dent);

	debug_create("ch", 0444, dent, debug_ch);

	debug_create("version", 0444, dent, debug_read_smd_version);

	debug_create("int_stats", 0444, dent, debug_int_stats);

	debug_create("int_stats_reset", 0444, dent, debug_int_stats_reset);

	return 0;

}

late_initcall(smd_debugfs_init);

#endif

/* drivers/soc/qcom/smd_init_dt.c

 *

 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */

#include <linux/platform_device.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_irq.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/ipc_logging.h>

#include "smd_private.h"

#define MODULE_NAME "msm_smd"

#define IPC_LOG(level, x...) do { \

	if (smd_log_ctx) \

		ipc_log_string(smd_log_ctx, x); \

	else \

		printk(level x); \

	} while (0)

#if defined(CONFIG_MSM_SMD_DEBUG)

#define SMD_DBG(x...) do {				\

		if (msm_smd_debug_mask & MSM_SMD_DEBUG) \

			IPC_LOG(KERN_DEBUG, x);		\

	} while (0)

#define SMSM_DBG(x...) do {					\

		if (msm_smd_debug_mask & MSM_SMSM_DEBUG)	\

			IPC_LOG(KERN_DEBUG, x);		\

	} while (0)

#else

#define SMD_DBG(x...) do { } while (0)

#define SMSM_DBG(x...) do { } while (0)

#endif

static DEFINE_MUTEX(smd_probe_lock);

static int first_probe_done;

static int msm_smsm_probe(struct platform_device *pdev)

{

	uint32_t edge;

	char *key;

	int ret;

	uint32_t irq_offset;

	uint32_t irq_bitmask;

	uint32_t irq_line;

	struct interrupt_config_item *private_irq;

	struct device_node *node;

	void *irq_out_base;

	resource_size_t irq_out_size;

	struct platform_device *parent_pdev;

	struct resource *r;

	struct interrupt_config *private_intr_config;

	uint32_t remote_pid;

	node = pdev->dev.of_node;

	if (!pdev->dev.parent) {

		pr_err("%s: missing link to parent device\n", __func__);

		return -ENODEV;

	}

	parent_pdev = to_platform_device(pdev->dev.parent);

	key = "irq-reg-base";

	r = platform_get_resource_byname(parent_pdev, IORESOURCE_MEM, key);

	if (!r)

		goto missing_key;

	irq_out_size = resource_size(r);

	irq_out_base = ioremap_nocache(r->start, irq_out_size);

	if (!irq_out_base) {

		pr_err("%s: ioremap_nocache() of irq_out_base addr:%pr size:%pr\n",

				__func__, &r->start, &irq_out_size);

		return -ENOMEM;

	}

	SMSM_DBG("%s: %s = %p", __func__, key, irq_out_base);

	key = "qcom,smsm-edge";

	ret = of_property_read_u32(node, key, &edge);

	if (ret)

		goto missing_key;

	SMSM_DBG("%s: %s = %d", __func__, key, edge);

	key = "qcom,smsm-irq-offset";

	ret = of_property_read_u32(node, key, &irq_offset);

	if (ret)

		goto missing_key;

	SMSM_DBG("%s: %s = %x", __func__, key, irq_offset);

	key = "qcom,smsm-irq-bitmask";

	ret = of_property_read_u32(node, key, &irq_bitmask);

	if (ret)

		goto missing_key;

	SMSM_DBG("%s: %s = %x", __func__, key, irq_bitmask);

	key = "interrupts";

	irq_line = irq_of_parse_and_map(node, 0);

	if (!irq_line)

		goto missing_key;

	SMSM_DBG("%s: %s = %d", __func__, key, irq_line);

	private_intr_config = smd_get_intr_config(edge);

	if (!private_intr_config) {

		pr_err("%s: invalid edge\n", __func__);

		return -ENODEV;

	}

	private_irq = &private_intr_config->smsm;

	private_irq->out_bit_pos = irq_bitmask;

	private_irq->out_offset = irq_offset;

	private_irq->out_base = irq_out_base;

	private_irq->irq_id = irq_line;

	remote_pid = smd_edge_to_remote_pid(edge);

	interrupt_stats[remote_pid].smsm_interrupt_id = irq_line;

	ret = request_irq(irq_line,

				private_irq->irq_handler,

				IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND,

				node->name,

				NULL);

	if (ret < 0) {

		pr_err("%s: request_irq() failed on %d\n", __func__, irq_line);

		return ret;

	} else {

		ret = enable_irq_wake(irq_line);

		if (ret < 0)

			pr_err("%s: enable_irq_wake() failed on %d\n", __func__,

					irq_line);

	}

	ret = smsm_post_init();

	if (ret) {

		pr_err("smd_post_init() failed ret=%d\n", ret);

		return ret;

	}

	return 0;

missing_key:

	pr_err("%s: missing key: %s", __func__, key);

	return -ENODEV;

}

static int msm_smd_probe(struct platform_device *pdev)

{

	uint32_t edge;

	char *key;

	int ret;

	uint32_t irq_offset;

	uint32_t irq_bitmask;

	uint32_t irq_line;

	const char *subsys_name;

	struct interrupt_config_item *private_irq;

	struct device_node *node;

	void *irq_out_base;

	resource_size_t irq_out_size;

	struct platform_device *parent_pdev;

	struct resource *r;

	struct interrupt_config *private_intr_config;

	uint32_t remote_pid;

	bool skip_pil;

	node = pdev->dev.of_node;

	if (!pdev->dev.parent) {

		pr_err("%s: missing link to parent device\n", __func__);

		return -ENODEV;

	}

	mutex_lock(&smd_probe_lock);

	if (!first_probe_done) {

		smd_reset_all_edge_subsys_name();

		first_probe_done = 1;

	}

	mutex_unlock(&smd_probe_lock);

	parent_pdev = to_platform_device(pdev->dev.parent);

	key = "irq-reg-base";

	r = platform_get_resource_byname(parent_pdev, IORESOURCE_MEM, key);

	if (!r)

		goto missing_key;

	irq_out_size = resource_size(r);

	irq_out_base = ioremap_nocache(r->start, irq_out_size);

	if (!irq_out_base) {

		pr_err("%s: ioremap_nocache() of irq_out_base addr:%pr size:%pr\n",

				__func__, &r->start, &irq_out_size);

		return -ENOMEM;

	}

	SMD_DBG("%s: %s = %p", __func__, key, irq_out_base);

	key = "qcom,smd-edge";

	ret = of_property_read_u32(node, key, &edge);

	if (ret)

		goto missing_key;

	SMD_DBG("%s: %s = %d", __func__, key, edge);

	key = "qcom,smd-irq-offset";

	ret = of_property_read_u32(node, key, &irq_offset);

	if (ret)

		goto missing_key;

	SMD_DBG("%s: %s = %x", __func__, key, irq_offset);

	key = "qcom,smd-irq-bitmask";

	ret = of_property_read_u32(node, key, &irq_bitmask);

	if (ret)

		goto missing_key;

	SMD_DBG("%s: %s = %x", __func__, key, irq_bitmask);

	key = "interrupts";

	irq_line = irq_of_parse_and_map(node, 0);

	if (!irq_line)

		goto missing_key;

	SMD_DBG("%s: %s = %d", __func__, key, irq_line);

	key = "label";

	subsys_name = of_get_property(node, key, NULL);

	SMD_DBG("%s: %s = %s", __func__, key, subsys_name);

	/*

	 * Backwards compatibility.  Although label is required, some DTs may

	 * still list the legacy pil-string.  Sanely handle pil-string.

	 */

	if (!subsys_name) {

		pr_warn("msm_smd: Missing required property - label. Using legacy parsing\n");

		key = "qcom,pil-string";

		subsys_name = of_get_property(node, key, NULL);

		SMD_DBG("%s: %s = %s", __func__, key, subsys_name);

		if (subsys_name)

			skip_pil = false;

		else

			skip_pil = true;

	} else {

		key = "qcom,not-loadable";

		skip_pil = of_property_read_bool(node, key);

		SMD_DBG("%s: %s = %d\n", __func__, key, skip_pil);

	}

	private_intr_config = smd_get_intr_config(edge);

	if (!private_intr_config) {

		pr_err("%s: invalid edge\n", __func__);

		return -ENODEV;

	}

	private_irq = &private_intr_config->smd;

	private_irq->out_bit_pos = irq_bitmask;

	private_irq->out_offset = irq_offset;

	private_irq->out_base = irq_out_base;