diff options
Diffstat (limited to 'drivers/soc/qcom/smp2p.c')
| -rw-r--r-- | drivers/soc/qcom/smp2p.c | 1955 |
1 files changed, 1955 insertions, 0 deletions
diff --git a/drivers/soc/qcom/smp2p.c b/drivers/soc/qcom/smp2p.c new file mode 100644 index 000000000000..1de38bfd0adf --- /dev/null +++ b/drivers/soc/qcom/smp2p.c @@ -0,0 +1,1955 @@ +/* drivers/soc/qcom/smp2p.c + * + * Copyright (c) 2013-2016, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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/list.h> +#include <linux/ctype.h> +#include <linux/slab.h> +#include <linux/module.h> +#include <linux/io.h> +#include <linux/of.h> +#include <linux/platform_device.h> +#include <linux/interrupt.h> +#include <linux/ipc_logging.h> +#include <linux/err.h> +#include <soc/qcom/smem.h> +#include "smp2p_private_api.h" +#include "smp2p_private.h" + +#define NUM_LOG_PAGES 3 + +/** + * struct msm_smp2p_out - This structure represents the outbound SMP2P entry. + * + * @remote_pid: Outbound processor ID. + * @name: Entry name. + * @out_edge_list: Adds this structure into smp2p_out_list_item::list. + * @msm_smp2p_notifier_list: Notifier block head used to notify for open event. + * @open_nb: Notifier block used to notify for open event. + * @l_smp2p_entry: Pointer to the actual entry in the SMEM item. + */ +struct msm_smp2p_out { + int remote_pid; + char name[SMP2P_MAX_ENTRY_NAME]; + struct list_head out_edge_list; + struct raw_notifier_head msm_smp2p_notifier_list; + struct notifier_block *open_nb; + uint32_t __iomem *l_smp2p_entry; +}; + +/** + * struct smp2p_out_list_item - Maintains the state of outbound edge. + * + * @out_item_lock_lha1: Lock protecting all elements of the structure. + * @list: list of outbound entries (struct msm_smp2p_out). + * @smem_edge_out: Pointer to outbound smem item. + * @smem_edge_state: State of the outbound edge. + * @ops_ptr: Pointer to internal version-specific SMEM item access functions. + * + * @feature_ssr_ack_enabled: SSR ACK Support Enabled + * @restart_ack: Current cached state of the local ack bit + */ +struct smp2p_out_list_item { + spinlock_t out_item_lock_lha1; + + struct list_head list; + struct smp2p_smem __iomem *smem_edge_out; + enum msm_smp2p_edge_state smem_edge_state; + struct smp2p_version_if *ops_ptr; + + bool feature_ssr_ack_enabled; + bool restart_ack; +}; +static struct smp2p_out_list_item out_list[SMP2P_NUM_PROCS]; + +static void *log_ctx; +static int smp2p_debug_mask = MSM_SMP2P_INFO | MSM_SMP2P_DEBUG; +module_param_named(debug_mask, smp2p_debug_mask, + int, S_IRUGO | S_IWUSR | S_IWGRP); + +/** + * struct smp2p_in - Represents the entry on remote processor. + * + * @name: Name of the entry. + * @remote_pid: Outbound processor ID. + * @in_edge_list: Adds this structure into smp2p_in_list_item::list. + * @in_notifier_list: List for notifier block for entry opening/updates. + * @prev_entry_val: Previous value of the entry. + * @entry_ptr: Points to the current value in smem item. + * @notifier_count: Counts the number of notifier registered per pid,entry. + */ +struct smp2p_in { + int remote_pid; + char name[SMP2P_MAX_ENTRY_NAME]; + struct list_head in_edge_list; + struct raw_notifier_head in_notifier_list; + uint32_t prev_entry_val; + uint32_t __iomem *entry_ptr; + uint32_t notifier_count; +}; + +/** + * struct smp2p_in_list_item - Maintains the inbound edge state. + * + * @in_item_lock_lhb1: Lock protecting all elements of the structure. + * @list: List head for the entries on remote processor. + * @smem_edge_in: Pointer to the remote smem item. + */ +struct smp2p_in_list_item { + spinlock_t in_item_lock_lhb1; + struct list_head list; + struct smp2p_smem __iomem *smem_edge_in; + uint32_t item_size; + uint32_t safe_total_entries; +}; +static struct smp2p_in_list_item in_list[SMP2P_NUM_PROCS]; + +/** + * SMEM Item access function interface. + * + * This interface is used to help isolate the implementation of + * the functionality from any changes in the shared data structures + * that may happen as versions are changed. + * + * @is_supported: True if this version is supported by SMP2P + * @negotiate_features: Returns (sub)set of supported features + * @negotiation_complete: Called when negotiation has been completed + * @find_entry: Finds existing / next empty entry + * @create_entry: Creates a new entry + * @read_entry: Reads the value of an entry + * @write_entry: Writes a new value to an entry + * @modify_entry: Does a read/modify/write of an entry + * validate_size: Verifies the size of the remote SMEM item to ensure that + * an invalid item size doesn't result in an out-of-bounds + * memory access. + */ +struct smp2p_version_if { + /* common functions */ + bool is_supported; + uint32_t (*negotiate_features)(uint32_t features); + void (*negotiation_complete)(struct smp2p_out_list_item *); + void (*find_entry)(struct smp2p_smem __iomem *item, + uint32_t entries_total, char *name, + uint32_t **entry_ptr, int *empty_spot); + + /* outbound entry functions */ + int (*create_entry)(struct msm_smp2p_out *); + int (*read_entry)(struct msm_smp2p_out *, uint32_t *); + int (*write_entry)(struct msm_smp2p_out *, uint32_t); + int (*modify_entry)(struct msm_smp2p_out *, uint32_t, uint32_t, bool); + + /* inbound entry functions */ + struct smp2p_smem __iomem *(*validate_size)(int remote_pid, + struct smp2p_smem __iomem *, uint32_t); +}; + +static int smp2p_do_negotiation(int remote_pid, struct smp2p_out_list_item *p); +static void smp2p_send_interrupt(int remote_pid); + +/* v0 (uninitialized SMEM item) interface functions */ +static uint32_t smp2p_negotiate_features_v0(uint32_t features); +static void smp2p_negotiation_complete_v0(struct smp2p_out_list_item *out_item); +static void smp2p_find_entry_v0(struct smp2p_smem __iomem *item, + uint32_t entries_total, char *name, uint32_t **entry_ptr, + int *empty_spot); +static int smp2p_out_create_v0(struct msm_smp2p_out *); +static int smp2p_out_read_v0(struct msm_smp2p_out *, uint32_t *); +static int smp2p_out_write_v0(struct msm_smp2p_out *, uint32_t); +static int smp2p_out_modify_v0(struct msm_smp2p_out *, + uint32_t, uint32_t, bool); +static struct smp2p_smem __iomem *smp2p_in_validate_size_v0(int remote_pid, + struct smp2p_smem __iomem *smem_item, uint32_t size); + +/* v1 interface functions */ +static uint32_t smp2p_negotiate_features_v1(uint32_t features); +static void smp2p_negotiation_complete_v1(struct smp2p_out_list_item *out_item); +static void smp2p_find_entry_v1(struct smp2p_smem __iomem *item, + uint32_t entries_total, char *name, uint32_t **entry_ptr, + int *empty_spot); +static int smp2p_out_create_v1(struct msm_smp2p_out *); +static int smp2p_out_read_v1(struct msm_smp2p_out *, uint32_t *); +static int smp2p_out_write_v1(struct msm_smp2p_out *, uint32_t); +static int smp2p_out_modify_v1(struct msm_smp2p_out *, + uint32_t, uint32_t, bool); +static struct smp2p_smem __iomem *smp2p_in_validate_size_v1(int remote_pid, + struct smp2p_smem __iomem *smem_item, uint32_t size); + +/* Version interface functions */ +static struct smp2p_version_if version_if[] = { + [0] = { + .negotiate_features = smp2p_negotiate_features_v0, + .negotiation_complete = smp2p_negotiation_complete_v0, + .find_entry = smp2p_find_entry_v0, + .create_entry = smp2p_out_create_v0, + .read_entry = smp2p_out_read_v0, + .write_entry = smp2p_out_write_v0, + .modify_entry = smp2p_out_modify_v0, + .validate_size = smp2p_in_validate_size_v0, + }, + [1] = { + .is_supported = true, + .negotiate_features = smp2p_negotiate_features_v1, + .negotiation_complete = smp2p_negotiation_complete_v1, + .find_entry = smp2p_find_entry_v1, + .create_entry = smp2p_out_create_v1, + .read_entry = smp2p_out_read_v1, + .write_entry = smp2p_out_write_v1, + .modify_entry = smp2p_out_modify_v1, + .validate_size = smp2p_in_validate_size_v1, + }, +}; + +/* interrupt configuration (filled by device tree) */ +static struct smp2p_interrupt_config smp2p_int_cfgs[SMP2P_NUM_PROCS] = { + [SMP2P_MODEM_PROC].name = "modem", + [SMP2P_AUDIO_PROC].name = "lpass", + [SMP2P_SENSOR_PROC].name = "dsps", + [SMP2P_WIRELESS_PROC].name = "wcnss", + [SMP2P_CDSP_PROC].name = "cdsp", + [SMP2P_TZ_PROC].name = "tz", + [SMP2P_REMOTE_MOCK_PROC].name = "mock", +}; + +/** + * smp2p_get_log_ctx - Return log context for other SMP2P modules. + * + * @returns: Log context or NULL if none. + */ +void *smp2p_get_log_ctx(void) +{ + return log_ctx; +} + +/** + * smp2p_get_debug_mask - Return debug mask. + * + * @returns: Current debug mask. + */ +int smp2p_get_debug_mask(void) +{ + return smp2p_debug_mask; +} + +/** + * smp2p_interrupt_config - Return interrupt configuration. + * + * @returns interrupt configuration array for usage by debugfs. + */ +struct smp2p_interrupt_config *smp2p_get_interrupt_config(void) +{ + return smp2p_int_cfgs; +} + +/** + * smp2p_pid_to_name - Lookup name for remote pid. + * + * @returns: name (may be NULL). + */ +const char *smp2p_pid_to_name(int remote_pid) +{ + if (remote_pid >= SMP2P_NUM_PROCS) + return NULL; + + return smp2p_int_cfgs[remote_pid].name; +} + +/** + * smp2p_get_in_item - Return pointer to remote smem item. + * + * @remote_pid: Processor ID of the remote system. + * @returns: Pointer to inbound SMEM item + * + * This is used by debugfs to print the smem items. + */ +struct smp2p_smem __iomem *smp2p_get_in_item(int remote_pid) +{ + void *ret = NULL; + unsigned long flags; + + spin_lock_irqsave(&in_list[remote_pid].in_item_lock_lhb1, flags); + if (remote_pid < SMP2P_NUM_PROCS) + ret = in_list[remote_pid].smem_edge_in; + spin_unlock_irqrestore(&in_list[remote_pid].in_item_lock_lhb1, + flags); + + return ret; +} + +/** + * smp2p_get_out_item - Return pointer to outbound SMEM item. + * + * @remote_pid: Processor ID of remote system. + * @state: Edge state of the outbound SMEM item. + * @returns: Pointer to outbound (remote) SMEM item. + */ +struct smp2p_smem __iomem *smp2p_get_out_item(int remote_pid, int *state) +{ + void *ret = NULL; + unsigned long flags; + + spin_lock_irqsave(&out_list[remote_pid].out_item_lock_lha1, flags); + if (remote_pid < SMP2P_NUM_PROCS) { + ret = out_list[remote_pid].smem_edge_out; + if (state) + *state = out_list[remote_pid].smem_edge_state; + } + spin_unlock_irqrestore(&out_list[remote_pid].out_item_lock_lha1, flags); + + return ret; +} + +/** + * smp2p_get_smem_item_id - Return the proper SMEM item ID. + * + * @write_id: Processor that will write to the item. + * @read_id: Processor that will read from the item. + * @returns: SMEM ID + */ +static int smp2p_get_smem_item_id(int write_pid, int read_pid) +{ + int ret = -EINVAL; + + switch (write_pid) { + case SMP2P_APPS_PROC: + ret = SMEM_SMP2P_APPS_BASE + read_pid; + break; + case SMP2P_MODEM_PROC: + ret = SMEM_SMP2P_MODEM_BASE + read_pid; + break; + case SMP2P_AUDIO_PROC: + ret = SMEM_SMP2P_AUDIO_BASE + read_pid; + break; + case SMP2P_SENSOR_PROC: + ret = SMEM_SMP2P_SENSOR_BASE + read_pid; + break; + case SMP2P_WIRELESS_PROC: + ret = SMEM_SMP2P_WIRLESS_BASE + read_pid; + break; + case SMP2P_CDSP_PROC: + ret = SMEM_SMP2P_CDSP_BASE + read_pid; + break; + case SMP2P_POWER_PROC: + ret = SMEM_SMP2P_POWER_BASE + read_pid; + break; + case SMP2P_TZ_PROC: + ret = SMEM_SMP2P_TZ_BASE + read_pid; + break; + } + + return ret; +} + +/** + * Return pointer to SMEM item owned by the local processor. + * + * @remote_pid: Remote processor ID + * @returns: NULL for failure; otherwise pointer to SMEM item + * + * Must be called with out_item_lock_lha1 locked for mock proc. + */ +static void *smp2p_get_local_smem_item(int remote_pid) +{ + struct smp2p_smem __iomem *item_ptr = NULL; + + if (remote_pid < SMP2P_REMOTE_MOCK_PROC) { + unsigned size; + int smem_id; + + /* lookup or allocate SMEM item */ + smem_id = smp2p_get_smem_item_id(SMP2P_APPS_PROC, remote_pid); + if (smem_id >= 0) { + item_ptr = smem_get_entry(smem_id, &size, + remote_pid, 0); + + if (!item_ptr) { + size = sizeof(struct smp2p_smem_item); + item_ptr = smem_alloc(smem_id, size, + remote_pid, 0); + } + } + } else if (remote_pid == SMP2P_REMOTE_MOCK_PROC) { + /* + * This path is only used during unit testing so + * the GFP_ATOMIC allocation should not be a + * concern. + */ + if (!out_list[SMP2P_REMOTE_MOCK_PROC].smem_edge_out) + item_ptr = kzalloc( + sizeof(struct smp2p_smem_item), + GFP_ATOMIC); + } + return item_ptr; +} + +/** + * smp2p_get_remote_smem_item - Return remote SMEM item. + * + * @remote_pid: Remote processor ID + * @out_item: Pointer to the output item structure + * @returns: NULL for failure; otherwise pointer to SMEM item + * + * Return pointer to SMEM item owned by the remote processor. + * + * Note that this function does an SMEM lookup which uses a remote spinlock, + * so this function should not be called more than necessary. + * + * Must be called with out_item_lock_lha1 and in_item_lock_lhb1 locked. + */ +static void *smp2p_get_remote_smem_item(int remote_pid, + struct smp2p_out_list_item *out_item) +{ + void *item_ptr = NULL; + unsigned size = 0; + + if (!out_item) + return item_ptr; + + if (remote_pid < SMP2P_REMOTE_MOCK_PROC) { + int smem_id; + + smem_id = smp2p_get_smem_item_id(remote_pid, SMP2P_APPS_PROC); + if (smem_id >= 0) + item_ptr = smem_get_entry(smem_id, &size, + remote_pid, 0); + } else if (remote_pid == SMP2P_REMOTE_MOCK_PROC) { + item_ptr = msm_smp2p_get_remote_mock_smem_item(&size); + } + item_ptr = out_item->ops_ptr->validate_size(remote_pid, item_ptr, size); + + return item_ptr; +} + +/** + * smp2p_ssr_ack_needed - Returns true if SSR ACK required + * + * @rpid: Remote processor ID + * + * Must be called with out_item_lock_lha1 and in_item_lock_lhb1 locked. + */ +static bool smp2p_ssr_ack_needed(uint32_t rpid) +{ + bool ssr_done; + + if (!out_list[rpid].feature_ssr_ack_enabled) + return false; + + ssr_done = SMP2P_GET_RESTART_DONE(in_list[rpid].smem_edge_in->flags); + if (ssr_done != out_list[rpid].restart_ack) + return true; + + return false; +} + +/** + * smp2p_do_ssr_ack - Handles SSR ACK + * + * @rpid: Remote processor ID + * + * Must be called with out_item_lock_lha1 and in_item_lock_lhb1 locked. + */ +static void smp2p_do_ssr_ack(uint32_t rpid) +{ + bool ack; + + if (!smp2p_ssr_ack_needed(rpid)) + return; + + ack = !out_list[rpid].restart_ack; + SMP2P_INFO("%s: ssr ack pid %d: %d -> %d\n", __func__, rpid, + out_list[rpid].restart_ack, ack); + out_list[rpid].restart_ack = ack; + SMP2P_SET_RESTART_ACK(out_list[rpid].smem_edge_out->flags, ack); + smp2p_send_interrupt(rpid); +} + +/** + * smp2p_negotiate_features_v1 - Initial feature negotiation. + * + * @features: Inbound feature set. + * @returns: Supported features (will be a same/subset of @features). + */ +static uint32_t smp2p_negotiate_features_v1(uint32_t features) +{ + return SMP2P_FEATURE_SSR_ACK; +} + +/** + * smp2p_negotiation_complete_v1 - Negotiation completed + * + * @out_item: Pointer to the output item structure + * + * Can be used to do final configuration based upon the negotiated feature set. + * + * Must be called with out_item_lock_lha1 locked. + */ +static void smp2p_negotiation_complete_v1(struct smp2p_out_list_item *out_item) +{ + uint32_t features; + + features = SMP2P_GET_FEATURES(out_item->smem_edge_out->feature_version); + + if (features & SMP2P_FEATURE_SSR_ACK) + out_item->feature_ssr_ack_enabled = true; +} + +/** + * smp2p_find_entry_v1 - Search for an entry in SMEM item. + * + * @item: Pointer to the smem item. + * @entries_total: Total number of entries in @item. + * @name: Name of the entry. + * @entry_ptr: Set to pointer of entry if found, NULL otherwise. + * @empty_spot: If non-null, set to the value of the next empty entry. + * + * Searches for entry @name in the SMEM item. If found, a pointer + * to the item is returned. If it isn't found, the first empty + * index is returned in @empty_spot. + */ +static void smp2p_find_entry_v1(struct smp2p_smem __iomem *item, + uint32_t entries_total, char *name, uint32_t **entry_ptr, + int *empty_spot) +{ + int i; + struct smp2p_entry_v1 *pos; + char entry_name[SMP2P_MAX_ENTRY_NAME]; + + if (!item || !name || !entry_ptr) { + SMP2P_ERR("%s: invalid arguments %d %d %d\n", + __func__, !item, !name, !entry_ptr); + return; + } + + *entry_ptr = NULL; + if (empty_spot) + *empty_spot = -1; + + pos = (struct smp2p_entry_v1 *)(char *)(item + 1); + for (i = 0; i < entries_total; i++, ++pos) { + memcpy_fromio(entry_name, pos->name, SMP2P_MAX_ENTRY_NAME); + if (entry_name[0]) { + if (!strcmp(entry_name, name)) { + *entry_ptr = &pos->entry; + break; + } + } else if (empty_spot && *empty_spot < 0) { + *empty_spot = i; + } + } +} + +/** + * smp2p_out_create_v1 - Creates a outbound SMP2P entry. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Must be called with out_item_lock_lha1 locked. + */ +static int smp2p_out_create_v1(struct msm_smp2p_out *out_entry) +{ + struct smp2p_smem __iomem *smp2p_h_ptr; + struct smp2p_out_list_item *p_list; + uint32_t *state_entry_ptr; + uint32_t empty_spot; + uint32_t entries_total; + uint32_t entries_valid; + + if (!out_entry) + return -EINVAL; + + p_list = &out_list[out_entry->remote_pid]; + if (p_list->smem_edge_state != SMP2P_EDGE_STATE_OPENED) { + SMP2P_ERR("%s: item '%s':%d opened - wrong create called\n", + __func__, out_entry->name, out_entry->remote_pid); + return -ENODEV; + } + + smp2p_h_ptr = p_list->smem_edge_out; + entries_total = SMP2P_GET_ENT_TOTAL(smp2p_h_ptr->valid_total_ent); + entries_valid = SMP2P_GET_ENT_VALID(smp2p_h_ptr->valid_total_ent); + + p_list->ops_ptr->find_entry(smp2p_h_ptr, entries_total, + out_entry->name, &state_entry_ptr, &empty_spot); + if (state_entry_ptr) { + /* re-use existing entry */ + out_entry->l_smp2p_entry = state_entry_ptr; + + SMP2P_DBG("%s: item '%s':%d reused\n", __func__, + out_entry->name, out_entry->remote_pid); + } else if (entries_valid >= entries_total) { + /* need to allocate entry, but not more space */ + SMP2P_ERR("%s: no space for item '%s':%d\n", + __func__, out_entry->name, out_entry->remote_pid); + return -ENOMEM; + } else { + /* allocate a new entry */ + struct smp2p_entry_v1 *entry_ptr; + + entry_ptr = (struct smp2p_entry_v1 *)((char *)(smp2p_h_ptr + 1) + + empty_spot * sizeof(struct smp2p_entry_v1)); + memcpy_toio(entry_ptr->name, out_entry->name, + sizeof(entry_ptr->name)); + out_entry->l_smp2p_entry = &entry_ptr->entry; + ++entries_valid; + SMP2P_DBG("%s: item '%s':%d fully created as entry %d of %d\n", + __func__, out_entry->name, + out_entry->remote_pid, + entries_valid, entries_total); + SMP2P_SET_ENT_VALID(smp2p_h_ptr->valid_total_ent, + entries_valid); + smp2p_send_interrupt(out_entry->remote_pid); + } + raw_notifier_call_chain(&out_entry->msm_smp2p_notifier_list, + SMP2P_OPEN, 0); + + return 0; +} + +/** + * smp2p_out_read_v1 - Read the data from an outbound entry. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @data: Out pointer, the data is available in this argument on success. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Must be called with out_item_lock_lha1 locked. + */ +static int smp2p_out_read_v1(struct msm_smp2p_out *out_entry, uint32_t *data) +{ + struct smp2p_smem __iomem *smp2p_h_ptr; + uint32_t remote_pid; + + if (!out_entry) + return -EINVAL; + + smp2p_h_ptr = out_list[out_entry->remote_pid].smem_edge_out; + remote_pid = SMP2P_GET_REMOTE_PID(smp2p_h_ptr->rem_loc_proc_id); + + if (remote_pid != out_entry->remote_pid) + return -EINVAL; + + if (out_entry->l_smp2p_entry) { + *data = readl_relaxed(out_entry->l_smp2p_entry); + } else { + SMP2P_ERR("%s: '%s':%d not yet OPEN\n", __func__, + out_entry->name, remote_pid); + return -ENODEV; + } + + return 0; +} + +/** + * smp2p_out_write_v1 - Writes an outbound entry value. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @data: The data to be written. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Must be called with out_item_lock_lha1 locked. + */ +static int smp2p_out_write_v1(struct msm_smp2p_out *out_entry, uint32_t data) +{ + struct smp2p_smem __iomem *smp2p_h_ptr; + uint32_t remote_pid; + + if (!out_entry) + return -EINVAL; + + smp2p_h_ptr = out_list[out_entry->remote_pid].smem_edge_out; + remote_pid = SMP2P_GET_REMOTE_PID(smp2p_h_ptr->rem_loc_proc_id); + + if (remote_pid != out_entry->remote_pid) + return -EINVAL; + + if (out_entry->l_smp2p_entry) { + writel_relaxed(data, out_entry->l_smp2p_entry); + smp2p_send_interrupt(remote_pid); + } else { + SMP2P_ERR("%s: '%s':%d not yet OPEN\n", __func__, + out_entry->name, remote_pid); + return -ENODEV; + } + return 0; +} + +/** + * smp2p_out_modify_v1 - Modifies and outbound value. + * + * @set_mask: Mask containing the bits that needs to be set. + * @clear_mask: Mask containing the bits that needs to be cleared. + * @send_irq: Flag to send interrupt to remote processor. + * @returns: 0 on success, standard Linux error code otherwise. + * + * The clear mask is applied first, so if a bit is set in both clear and + * set mask, the result will be that the bit is set. + * + * Must be called with out_item_lock_lha1 locked. + */ +static int smp2p_out_modify_v1(struct msm_smp2p_out *out_entry, + uint32_t set_mask, uint32_t clear_mask, bool send_irq) +{ + struct smp2p_smem __iomem *smp2p_h_ptr; + uint32_t remote_pid; + + if (!out_entry) + return -EINVAL; + + smp2p_h_ptr = out_list[out_entry->remote_pid].smem_edge_out; + remote_pid = SMP2P_GET_REMOTE_PID(smp2p_h_ptr->rem_loc_proc_id); + + if (remote_pid != out_entry->remote_pid) + return -EINVAL; + + if (out_entry->l_smp2p_entry) { + uint32_t curr_value; + + curr_value = readl_relaxed(out_entry->l_smp2p_entry); + writel_relaxed((curr_value & ~clear_mask) | set_mask, + out_entry->l_smp2p_entry); + } else { + SMP2P_ERR("%s: '%s':%d not yet OPEN\n", __func__, + out_entry->name, remote_pid); + return -ENODEV; + } + + if (send_irq) + smp2p_send_interrupt(remote_pid); + return 0; +} + +/** + * smp2p_in_validate_size_v1 - Size validation for version 1. + * + * @remote_pid: Remote processor ID. + * @smem_item: Pointer to the inbound SMEM item. + * @size: Size of the SMEM item. + * @returns: Validated smem_item pointer (or NULL if size is too small). + * + * Validates we don't end up with out-of-bounds array access due to invalid + * smem item size. If out-of-bound array access can't be avoided, then an + * error message is printed and NULL is returned to prevent usage of the + * item. + * + * Must be called with in_item_lock_lhb1 locked. + */ +static struct smp2p_smem __iomem *smp2p_in_validate_size_v1(int remote_pid, + struct smp2p_smem __iomem *smem_item, uint32_t size) +{ + uint32_t total_entries; + unsigned expected_size; + struct smp2p_smem __iomem *item_ptr; + struct smp2p_in_list_item *in_item; + + if (remote_pid >= SMP2P_NUM_PROCS || !smem_item) + return NULL; + + in_item = &in_list[remote_pid]; + item_ptr = (struct smp2p_smem __iomem *)smem_item; + + total_entries = SMP2P_GET_ENT_TOTAL(item_ptr->valid_total_ent); + if (total_entries > 0) { + in_item->safe_total_entries = total_entries; + in_item->item_size = size; + + expected_size = sizeof(struct smp2p_smem) + + (total_entries * sizeof(struct smp2p_entry_v1)); + + if (size < expected_size) { + unsigned new_size; + + new_size = size; + new_size -= sizeof(struct smp2p_smem); + new_size /= sizeof(struct smp2p_entry_v1); + in_item->safe_total_entries = new_size; + + SMP2P_ERR( + "%s pid %d item too small for %d entries; expected: %d actual: %d; reduced to %d entries\n", + __func__, remote_pid, total_entries, + expected_size, size, new_size); + } + } else { + /* + * Total entries is 0, so the entry is still being initialized + * or is invalid. Either way, treat it as if the item does + * not exist yet. + */ + in_item->safe_total_entries = 0; + in_item->item_size = 0; + } + return item_ptr; +} + +/** + * smp2p_negotiate_features_v0 - Initial feature negotiation. + * + * @features: Inbound feature set. + * @returns: 0 (no features supported for v0). + */ +static uint32_t smp2p_negotiate_features_v0(uint32_t features) +{ + /* no supported features */ + return 0; +} + +/** + * smp2p_negotiation_complete_v0 - Negotiation completed + * + * @out_item: Pointer to the output item structure + * + * Can be used to do final configuration based upon the negotiated feature set. + */ +static void smp2p_negotiation_complete_v0(struct smp2p_out_list_item *out_item) +{ + SMP2P_ERR("%s: invalid negotiation complete for v0 pid %d\n", + __func__, + SMP2P_GET_REMOTE_PID(out_item->smem_edge_out->rem_loc_proc_id)); +} + +/** + * smp2p_find_entry_v0 - Stub function. + * + * @item: Pointer to the smem item. + * @entries_total: Total number of entries in @item. + * @name: Name of the entry. + * @entry_ptr: Set to pointer of entry if found, NULL otherwise. + * @empty_spot: If non-null, set to the value of the next empty entry. + * + * Entries cannot be searched for until item negotiation has been completed. + */ +static void smp2p_find_entry_v0(struct smp2p_smem __iomem *item, + uint32_t entries_total, char *name, uint32_t **entry_ptr, + int *empty_spot) +{ + if (entry_ptr) + *entry_ptr = NULL; + + if (empty_spot) + *empty_spot = -1; + + SMP2P_ERR("%s: invalid - item negotiation incomplete\n", __func__); +} + +/** + * smp2p_out_create_v0 - Initial creation function. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @returns: 0 on success, standard Linux error code otherwise. + * + * If the outbound SMEM item negotiation is not complete, then + * this function is called to start the negotiation process. + * Eventually when the negotiation process is complete, this + * function pointer is switched with the appropriate function + * for the version of SMP2P being created. + * + * Must be called with out_item_lock_lha1 locked. + */ +static int smp2p_out_create_v0(struct msm_smp2p_out *out_entry) +{ + int edge_state; + struct smp2p_out_list_item *item_ptr; + + if (!out_entry) + return -EINVAL; + + edge_state = out_list[out_entry->remote_pid].smem_edge_state; + + switch (edge_state) { + case SMP2P_EDGE_STATE_CLOSED: + /* start negotiation */ + item_ptr = &out_list[out_entry->remote_pid]; + edge_state = smp2p_do_negotiation(out_entry->remote_pid, + item_ptr); + break; + + case SMP2P_EDGE_STATE_OPENING: + /* still negotiating */ + break; + + case SMP2P_EDGE_STATE_OPENED: + SMP2P_ERR("%s: item '%s':%d opened - wrong create called\n", + __func__, out_entry->name, out_entry->remote_pid); + break; + + default: + SMP2P_ERR("%s: item '%s':%d invalid SMEM item state %d\n", + __func__, out_entry->name, out_entry->remote_pid, + edge_state); + break; + } + return 0; +} + +/** + * smp2p_out_read_v0 - Stub function. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @data: Out pointer, the data is available in this argument on success. + * @returns: -ENODEV + */ +static int smp2p_out_read_v0(struct msm_smp2p_out *out_entry, uint32_t *data) +{ + SMP2P_ERR("%s: item '%s':%d not OPEN\n", + __func__, out_entry->name, out_entry->remote_pid); + + return -ENODEV; +} + +/** + * smp2p_out_write_v0 - Stub function. + * + * @out_entry: Pointer to the SMP2P entry structure. + * @data: The data to be written. + * @returns: -ENODEV + */ +static int smp2p_out_write_v0(struct msm_smp2p_out *out_entry, uint32_t data) +{ + SMP2P_ERR("%s: item '%s':%d not yet OPEN\n", + __func__, out_entry->name, out_entry->remote_pid); + + return -ENODEV; +} + +/** + * smp2p_out_modify_v0 - Stub function. + * + * @set_mask: Mask containing the bits that needs to be set. + * @clear_mask: Mask containing the bits that needs to be cleared. + * @send_irq: Flag to send interrupt to remote processor. + * @returns: -ENODEV + */ +static int smp2p_out_modify_v0(struct msm_smp2p_out *out_entry, + uint32_t set_mask, uint32_t clear_mask, bool send_irq) +{ + SMP2P_ERR("%s: item '%s':%d not yet OPEN\n", + __func__, out_entry->name, out_entry->remote_pid); + + return -ENODEV; +} + +/** + * smp2p_in_validate_size_v0 - Stub function. + * + * @remote_pid: Remote processor ID. + * @smem_item: Pointer to the inbound SMEM item. + * @size: Size of the SMEM item. + * @returns: Validated smem_item pointer (or NULL if size is too small). + * + * Validates we don't end up with out-of-bounds array access due to invalid + * smem item size. If out-of-bound array access can't be avoided, then an + * error message is printed and NULL is returned to prevent usage of the + * item. + * + * Must be called with in_item_lock_lhb1 locked. + */ +static struct smp2p_smem __iomem *smp2p_in_validate_size_v0(int remote_pid, + struct smp2p_smem __iomem *smem_item, uint32_t size) +{ + struct smp2p_in_list_item *in_item; + + if (remote_pid >= SMP2P_NUM_PROCS || !smem_item) + return NULL; + + in_item = &in_list[remote_pid]; + + if (size < sizeof(struct smp2p_smem)) { + SMP2P_ERR( + "%s pid %d item size too small; expected: %zu actual: %d\n", + __func__, remote_pid, + sizeof(struct smp2p_smem), size); + smem_item = NULL; + in_item->item_size = 0; + } else { + in_item->item_size = size; + } + return smem_item; +} + +/** + * smp2p_init_header - Initializes the header of the smem item. + * + * @header_ptr: Pointer to the smp2p header. + * @local_pid: Local processor ID. + * @remote_pid: Remote processor ID. + * @feature: Features of smp2p implementation. + * @version: Version of smp2p implementation. + * + * Initializes the header as defined in the protocol specification. + */ +void smp2p_init_header(struct smp2p_smem __iomem *header_ptr, + int local_pid, int remote_pid, + uint32_t features, uint32_t version) +{ + header_ptr->magic = SMP2P_MAGIC; + SMP2P_SET_LOCAL_PID(header_ptr->rem_loc_proc_id, local_pid); + SMP2P_SET_REMOTE_PID(header_ptr->rem_loc_proc_id, remote_pid); + SMP2P_SET_FEATURES(header_ptr->feature_version, features); + SMP2P_SET_ENT_TOTAL(header_ptr->valid_total_ent, SMP2P_MAX_ENTRY); + SMP2P_SET_ENT_VALID(header_ptr->valid_total_ent, 0); + header_ptr->flags = 0; + + /* ensure that all fields are valid before version is written */ + wmb(); + SMP2P_SET_VERSION(header_ptr->feature_version, version); +} + +/** + * smp2p_do_negotiation - Implements negotiation algorithm. + * + * @remote_pid: Remote processor ID. + * @out_item: Pointer to the outbound list item. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Must be called with out_item_lock_lha1 locked. Will internally lock + * in_item_lock_lhb1. + */ +static int smp2p_do_negotiation(int remote_pid, + struct smp2p_out_list_item *out_item) +{ + struct smp2p_smem __iomem *r_smem_ptr; + struct smp2p_smem __iomem *l_smem_ptr; + uint32_t r_version; + uint32_t r_feature; + uint32_t l_version, l_feature; + int prev_state; + + if (remote_pid >= SMP2P_NUM_PROCS || !out_item) + return -EINVAL; + if (out_item->smem_edge_state == SMP2P_EDGE_STATE_FAILED) + return -EPERM; + + prev_state = out_item->smem_edge_state; + + /* create local item */ + if (!out_item->smem_edge_out) { + out_item->smem_edge_out = smp2p_get_local_smem_item(remote_pid); + if (!out_item->smem_edge_out) { + SMP2P_ERR( + "%s unable to allocate SMEM item for pid %d\n", + __func__, remote_pid); + return -ENODEV; + } + out_item->smem_edge_state = SMP2P_EDGE_STATE_OPENING; + } + l_smem_ptr = out_item->smem_edge_out; + + /* retrieve remote side and version */ + spin_lock(&in_list[remote_pid].in_item_lock_lhb1); + r_smem_ptr = smp2p_get_remote_smem_item(remote_pid, out_item); + spin_unlock(&in_list[remote_pid].in_item_lock_lhb1); + + r_version = 0; + if (r_smem_ptr) { + r_version = SMP2P_GET_VERSION(r_smem_ptr->feature_version); + r_feature = SMP2P_GET_FEATURES(r_smem_ptr->feature_version); + } + + if (r_version == 0) { + /* + * Either remote side doesn't exist, or is in the + * process of being initialized (the version is set last). + * + * In either case, treat as if the other side doesn't exist + * and write out our maximum supported version. + */ + r_smem_ptr = NULL; + r_version = ARRAY_SIZE(version_if) - 1; + r_feature = ~0U; + } + + /* find maximum supported version and feature set */ + l_version = min(r_version, (uint32_t)ARRAY_SIZE(version_if) - 1); + for (; l_version > 0; --l_version) { + if (!version_if[l_version].is_supported) + continue; + + /* found valid version */ + l_feature = version_if[l_version].negotiate_features(~0U); + if (l_version == r_version) + l_feature &= r_feature; + break; + } + + if (l_version == 0) { + SMP2P_ERR( + "%s: negotiation failure pid %d: RV %d RF %x\n", + __func__, remote_pid, r_version, r_feature + ); + SMP2P_SET_VERSION(l_smem_ptr->feature_version, + SMP2P_EDGE_STATE_FAILED); + smp2p_send_interrupt(remote_pid); + out_item->smem_edge_state = SMP2P_EDGE_STATE_FAILED; + return -EPERM; + } + + /* update header and notify remote side */ + smp2p_init_header(l_smem_ptr, SMP2P_APPS_PROC, remote_pid, + l_feature, l_version); + smp2p_send_interrupt(remote_pid); + + /* handle internal state changes */ + if (r_smem_ptr && l_version == r_version && + l_feature == r_feature) { + struct msm_smp2p_out *pos; + + /* negotiation complete */ + out_item->ops_ptr = &version_if[l_version]; + out_item->ops_ptr->negotiation_complete(out_item); + out_item->smem_edge_state = SMP2P_EDGE_STATE_OPENED; + SMP2P_INFO( + "%s: negotiation complete pid %d: State %d->%d F0x%08x\n", + __func__, remote_pid, prev_state, + out_item->smem_edge_state, l_feature); + + /* create any pending outbound entries */ + list_for_each_entry(pos, &out_item->list, out_edge_list) { + out_item->ops_ptr->create_entry(pos); + } + + /* update inbound edge */ + spin_lock(&in_list[remote_pid].in_item_lock_lhb1); + (void)out_item->ops_ptr->validate_size(remote_pid, r_smem_ptr, + in_list[remote_pid].item_size); + in_list[remote_pid].smem_edge_in = r_smem_ptr; + spin_unlock(&in_list[remote_pid].in_item_lock_lhb1); + } else { + SMP2P_INFO("%s: negotiation pid %d: State %d->%d F0x%08x\n", + __func__, remote_pid, prev_state, + out_item->smem_edge_state, l_feature); + } + return 0; +} + +/** + * msm_smp2p_out_open - Opens an outbound entry. + * + * @remote_pid: Outbound processor ID. + * @name: Name of the entry. + * @open_notifier: Notifier block for the open notification. + * @handle: Handle to the smem entry structure. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Opens an outbound entry with the name specified by entry, from the + * local processor to the remote processor(remote_pid). If the entry, remote_pid + * and open_notifier are valid, then handle will be set and zero will be + * returned. The smem item that holds this entry will be created if it has + * not been created according to the version negotiation algorithm. + * The open_notifier will be used to notify the clients about the + * availability of the entry. + */ +int msm_smp2p_out_open(int remote_pid, const char *name, + struct notifier_block *open_notifier, + struct msm_smp2p_out **handle) +{ + struct msm_smp2p_out *out_entry; + struct msm_smp2p_out *pos; + int ret = 0; + unsigned long flags; + + if (handle) + *handle = NULL; + + if (remote_pid >= SMP2P_NUM_PROCS || !name || !open_notifier || !handle) + return -EINVAL; + + if ((remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, remote_pid, name); + return -EPROBE_DEFER; + } + + /* Allocate the smp2p object and node */ + out_entry = kzalloc(sizeof(*out_entry), GFP_KERNEL); + if (!out_entry) + return -ENOMEM; + + /* Handle duplicate registration */ + spin_lock_irqsave(&out_list[remote_pid].out_item_lock_lha1, flags); + list_for_each_entry(pos, &out_list[remote_pid].list, + out_edge_list) { + if (!strcmp(pos->name, name)) { + spin_unlock_irqrestore( + &out_list[remote_pid].out_item_lock_lha1, + flags); + kfree(out_entry); + SMP2P_ERR("%s: duplicate registration '%s':%d\n", + __func__, name, remote_pid); + return -EBUSY; + } + } + + out_entry->remote_pid = remote_pid; + RAW_INIT_NOTIFIER_HEAD(&out_entry->msm_smp2p_notifier_list); + strlcpy(out_entry->name, name, SMP2P_MAX_ENTRY_NAME); + out_entry->open_nb = open_notifier; + raw_notifier_chain_register(&out_entry->msm_smp2p_notifier_list, + out_entry->open_nb); + list_add(&out_entry->out_edge_list, &out_list[remote_pid].list); + + ret = out_list[remote_pid].ops_ptr->create_entry(out_entry); + if (ret) { + list_del(&out_entry->out_edge_list); + raw_notifier_chain_unregister( + &out_entry->msm_smp2p_notifier_list, + out_entry->open_nb); + spin_unlock_irqrestore( + &out_list[remote_pid].out_item_lock_lha1, flags); + kfree(out_entry); + SMP2P_ERR("%s: unable to open '%s':%d error %d\n", + __func__, name, remote_pid, ret); + return ret; + } + spin_unlock_irqrestore(&out_list[remote_pid].out_item_lock_lha1, + flags); + *handle = out_entry; + + return 0; +} +EXPORT_SYMBOL(msm_smp2p_out_open); + +/** + * msm_smp2p_out_close - Closes the handle to an outbound entry. + * + * @handle: Pointer to smp2p out entry handle. + * @returns: 0 on success, standard Linux error code otherwise. + * + * The actual entry will not be deleted and can be re-opened at a later + * time. The handle will be set to NULL. + */ +int msm_smp2p_out_close(struct msm_smp2p_out **handle) +{ + unsigned long flags; + struct msm_smp2p_out *out_entry; + struct smp2p_out_list_item *out_item; + + if (!handle || !*handle) + return -EINVAL; + + out_entry = *handle; + *handle = NULL; + + if ((out_entry->remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[out_entry->remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, out_entry->remote_pid, out_entry->name); + return -EPROBE_DEFER; + } + + out_item = &out_list[out_entry->remote_pid]; + spin_lock_irqsave(&out_item->out_item_lock_lha1, flags); + list_del(&out_entry->out_edge_list); + raw_notifier_chain_unregister(&out_entry->msm_smp2p_notifier_list, + out_entry->open_nb); + spin_unlock_irqrestore(&out_item->out_item_lock_lha1, flags); + + kfree(out_entry); + + return 0; +} +EXPORT_SYMBOL(msm_smp2p_out_close); + +/** + * msm_smp2p_out_read - Allows reading the entry. + * + * @handle: Handle to the smem entry structure. + * @data: Out pointer that holds the read data. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Allows reading of the outbound entry for read-modify-write + * operation. + */ +int msm_smp2p_out_read(struct msm_smp2p_out *handle, uint32_t *data) +{ + int ret = -EINVAL; + unsigned long flags; + struct smp2p_out_list_item *out_item; + + if (!handle || !data) + return ret; + + if ((handle->remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[handle->remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, handle->remote_pid, handle->name); + return -EPROBE_DEFER; + } + + out_item = &out_list[handle->remote_pid]; + spin_lock_irqsave(&out_item->out_item_lock_lha1, flags); + ret = out_item->ops_ptr->read_entry(handle, data); + spin_unlock_irqrestore(&out_item->out_item_lock_lha1, flags); + + return ret; +} +EXPORT_SYMBOL(msm_smp2p_out_read); + +/** + * msm_smp2p_out_write - Allows writing to the entry. + * + * @handle: Handle to smem entry structure. + * @data: Data that has to be written. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Writes a new value to the output entry. Multiple back-to-back writes + * may overwrite previous writes before the remote processor get a chance + * to see them leading to ABA race condition. The client must implement + * their own synchronization mechanism (such as echo mechanism) if this is + * not acceptable. + */ +int msm_smp2p_out_write(struct msm_smp2p_out *handle, uint32_t data) +{ + int ret = -EINVAL; + unsigned long flags; + struct smp2p_out_list_item *out_item; + + if (!handle) + return ret; + + if ((handle->remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[handle->remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, handle->remote_pid, handle->name); + return -EPROBE_DEFER; + } + + out_item = &out_list[handle->remote_pid]; + spin_lock_irqsave(&out_item->out_item_lock_lha1, flags); + ret = out_item->ops_ptr->write_entry(handle, data); + spin_unlock_irqrestore(&out_item->out_item_lock_lha1, flags); + + return ret; + +} +EXPORT_SYMBOL(msm_smp2p_out_write); + +/** + * msm_smp2p_out_modify - Modifies the entry. + * + * @handle: Handle to the smem entry structure. + * @set_mask: Specifies the bits that needs to be set. + * @clear_mask: Specifies the bits that needs to be cleared. + * @send_irq: Flag to send interrupt to remote processor. + * @returns: 0 on success, standard Linux error code otherwise. + * + * The modification is done by doing a bitwise AND of clear mask followed by + * the bit wise OR of set mask. The clear bit mask is applied first to the + * data, so if a bit is set in both the clear mask and the set mask, then in + * the result is a set bit. Multiple back-to-back modifications may overwrite + * previous values before the remote processor gets a chance to see them + * leading to ABA race condition. The client must implement their own + * synchronization mechanism (such as echo mechanism) if this is not + * acceptable. + */ +int msm_smp2p_out_modify(struct msm_smp2p_out *handle, uint32_t set_mask, + uint32_t clear_mask, bool send_irq) +{ + int ret = -EINVAL; + unsigned long flags; + struct smp2p_out_list_item *out_item; + + if (!handle) + return ret; + + if ((handle->remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[handle->remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, handle->remote_pid, handle->name); + return -EPROBE_DEFER; + } + + out_item = &out_list[handle->remote_pid]; + spin_lock_irqsave(&out_item->out_item_lock_lha1, flags); + ret = out_item->ops_ptr->modify_entry(handle, set_mask, + clear_mask, send_irq); + spin_unlock_irqrestore(&out_item->out_item_lock_lha1, flags); + + return ret; +} +EXPORT_SYMBOL(msm_smp2p_out_modify); + +/** + * msm_smp2p_in_read - Read an entry on a remote processor. + * + * @remote_pid: Processor ID of the remote processor. + * @name: Name of the entry that is to be read. + * @data: Output pointer, the value will be placed here if successful. + * @returns: 0 on success, standard Linux error code otherwise. + */ +int msm_smp2p_in_read(int remote_pid, const char *name, uint32_t *data) +{ + unsigned long flags; + struct smp2p_out_list_item *out_item; + uint32_t *entry_ptr = NULL; + + if (remote_pid >= SMP2P_NUM_PROCS) + return -EINVAL; + + if ((remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, remote_pid, name); + return -EPROBE_DEFER; + } + + out_item = &out_list[remote_pid]; + spin_lock_irqsave(&out_item->out_item_lock_lha1, flags); + spin_lock(&in_list[remote_pid].in_item_lock_lhb1); + + if (in_list[remote_pid].smem_edge_in) + out_item->ops_ptr->find_entry( + in_list[remote_pid].smem_edge_in, + in_list[remote_pid].safe_total_entries, + (char *)name, &entry_ptr, NULL); + + spin_unlock(&in_list[remote_pid].in_item_lock_lhb1); + spin_unlock_irqrestore(&out_item->out_item_lock_lha1, flags); + + if (!entry_ptr) + return -ENODEV; + + *data = readl_relaxed(entry_ptr); + return 0; +} +EXPORT_SYMBOL(msm_smp2p_in_read); + +/** + * msm_smp2p_in_register - Notifies the change in value of the entry. + * + * @pid: Remote processor ID. + * @name: Name of the entry. + * @in_notifier: Notifier block used to notify about the event. + * @returns: 0 on success, standard Linux error code otherwise. + * + * Register for change notifications for a remote entry. If the remote entry + * does not exist yet, then the registration request will be held until the + * remote side opens. Once the entry is open, then the SMP2P_OPEN notification + * will be sent. Any changes to the entry will trigger a call to the notifier + * block with an SMP2P_ENTRY_UPDATE event and the data field will point to an + * msm_smp2p_update_notif structure containing the current and previous value. + */ +int msm_smp2p_in_register(int pid, const char *name, + struct notifier_block *in_notifier) +{ + struct smp2p_in *pos; + struct smp2p_in *in = NULL; + int ret; + unsigned long flags; + struct msm_smp2p_update_notif data; + uint32_t *entry_ptr; + + if (pid >= SMP2P_NUM_PROCS || !name || !in_notifier) + return -EINVAL; + + if ((pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, pid, name); + return -EPROBE_DEFER; + } + + /* Pre-allocate before spinlock since we will likely needed it */ + in = kzalloc(sizeof(*in), GFP_KERNEL); + if (!in) + return -ENOMEM; + + /* Search for existing entry */ + spin_lock_irqsave(&out_list[pid].out_item_lock_lha1, flags); + spin_lock(&in_list[pid].in_item_lock_lhb1); + + list_for_each_entry(pos, &in_list[pid].list, in_edge_list) { + if (!strncmp(pos->name, name, + SMP2P_MAX_ENTRY_NAME)) { + kfree(in); + in = pos; + break; + } + } + + /* Create and add it to the list */ + if (!in->notifier_count) { + in->remote_pid = pid; + strlcpy(in->name, name, SMP2P_MAX_ENTRY_NAME); + RAW_INIT_NOTIFIER_HEAD(&in->in_notifier_list); + list_add(&in->in_edge_list, &in_list[pid].list); + } + + ret = raw_notifier_chain_register(&in->in_notifier_list, + in_notifier); + if (ret) { + if (!in->notifier_count) { + list_del(&in->in_edge_list); + kfree(in); + } + SMP2P_DBG("%s: '%s':%d failed %d\n", __func__, name, pid, ret); + goto bail; + } + in->notifier_count++; + + if (out_list[pid].smem_edge_state == SMP2P_EDGE_STATE_OPENED) { + out_list[pid].ops_ptr->find_entry( + in_list[pid].smem_edge_in, + in_list[pid].safe_total_entries, (char *)name, + &entry_ptr, NULL); + if (entry_ptr) { + in->entry_ptr = entry_ptr; + in->prev_entry_val = readl_relaxed(entry_ptr); + + data.previous_value = in->prev_entry_val; + data.current_value = in->prev_entry_val; + in_notifier->notifier_call(in_notifier, SMP2P_OPEN, + (void *)&data); + } + } + SMP2P_DBG("%s: '%s':%d registered\n", __func__, name, pid); + +bail: + spin_unlock(&in_list[pid].in_item_lock_lhb1); + spin_unlock_irqrestore(&out_list[pid].out_item_lock_lha1, flags); + return ret; + +} +EXPORT_SYMBOL(msm_smp2p_in_register); + +/** + * msm_smp2p_in_unregister - Unregister the notifier for remote entry. + * + * @remote_pid: Processor Id of the remote processor. + * @name: The name of the entry. + * @in_notifier: Notifier block passed during registration. + * @returns: 0 on success, standard Linux error code otherwise. + */ +int msm_smp2p_in_unregister(int remote_pid, const char *name, + struct notifier_block *in_notifier) +{ + struct smp2p_in *pos; + struct smp2p_in *in = NULL; + int ret = -ENODEV; + unsigned long flags; + + if (remote_pid >= SMP2P_NUM_PROCS || !name || !in_notifier) + return -EINVAL; + + if ((remote_pid != SMP2P_REMOTE_MOCK_PROC) && + !smp2p_int_cfgs[remote_pid].is_configured) { + SMP2P_INFO("%s before msm_smp2p_init(): pid[%d] name[%s]\n", + __func__, remote_pid, name); + return -EPROBE_DEFER; + } + + spin_lock_irqsave(&in_list[remote_pid].in_item_lock_lhb1, flags); + list_for_each_entry(pos, &in_list[remote_pid].list, + in_edge_list) { + if (!strncmp(pos->name, name, SMP2P_MAX_ENTRY_NAME)) { + in = pos; + break; + } + } + if (!in) + goto fail; + + ret = raw_notifier_chain_unregister(&pos->in_notifier_list, + in_notifier); + if (ret == 0) { + pos->notifier_count--; + if (!pos->notifier_count) { + list_del(&pos->in_edge_list); + kfree(pos); + ret = 0; + } + } else { + SMP2P_ERR("%s: unregister failure '%s':%d\n", __func__, + name, remote_pid); + ret = -ENODEV; + } + +fail: + spin_unlock_irqrestore(&in_list[remote_pid].in_item_lock_lhb1, flags); + + return ret; +} +EXPORT_SYMBOL(msm_smp2p_in_unregister); + +/** + * smp2p_send_interrupt - Send interrupt to remote system. + * + * @remote_pid: Processor ID of the remote system + * + * Must be called with out_item_lock_lha1 locked. + */ +static void smp2p_send_interrupt(int remote_pid) +{ + if (smp2p_int_cfgs[remote_pid].name) + SMP2P_DBG("SMP2P Int Apps->%s(%d)\n", + smp2p_int_cfgs[remote_pid].name, remote_pid); + + ++smp2p_int_cfgs[remote_pid].out_interrupt_count; + if (remote_pid != SMP2P_REMOTE_MOCK_PROC && + smp2p_int_cfgs[remote_pid].out_int_mask) { + /* flush any pending writes before triggering interrupt */ + wmb(); + writel_relaxed(smp2p_int_cfgs[remote_pid].out_int_mask, + smp2p_int_cfgs[remote_pid].out_int_ptr); + } else { + smp2p_remote_mock_rx_interrupt(); + } +} + +/** + * smp2p_in_edge_notify - Notifies the entry changed on remote processor. + * + * @pid: Processor ID of the remote processor. + * + * This function is invoked on an incoming interrupt, it scans + * the list of the clients registered for the entries on the remote + * processor and notifies them if the data changes. + * + * Note: Edge state must be OPENED to avoid a race condition with + * out_list[pid].ops_ptr->find_entry. + */ +static void smp2p_in_edge_notify(int pid) +{ + struct smp2p_in *pos; + uint32_t *entry_ptr; + unsigned long flags; + struct smp2p_smem __iomem *smem_h_ptr; + uint32_t curr_data; + struct msm_smp2p_update_notif data; + + spin_lock_irqsave(&in_list[pid].in_item_lock_lhb1, flags); + smem_h_ptr = in_list[pid].smem_edge_in; + if (!smem_h_ptr) { + SMP2P_DBG("%s: No remote SMEM item for pid %d\n", + __func__, pid); + spin_unlock_irqrestore(&in_list[pid].in_item_lock_lhb1, flags); + return; + } + + list_for_each_entry(pos, &in_list[pid].list, in_edge_list) { + if (pos->entry_ptr == NULL) { + /* entry not open - try to open it */ + out_list[pid].ops_ptr->find_entry(smem_h_ptr, + in_list[pid].safe_total_entries, pos->name, + &entry_ptr, NULL); + + if (entry_ptr) { + pos->entry_ptr = entry_ptr; + pos->prev_entry_val = 0; + data.previous_value = 0; + data.current_value = readl_relaxed(entry_ptr); + raw_notifier_call_chain( + &pos->in_notifier_list, + SMP2P_OPEN, (void *)&data); + } + } + + if (pos->entry_ptr != NULL) { + /* send update notification */ + curr_data = readl_relaxed(pos->entry_ptr); + if (curr_data != pos->prev_entry_val) { + data.previous_value = pos->prev_entry_val; + data.current_value = curr_data; + pos->prev_entry_val = curr_data; + raw_notifier_call_chain( + &pos->in_notifier_list, + SMP2P_ENTRY_UPDATE, (void *)&data); + } + } + } + spin_unlock_irqrestore(&in_list[pid].in_item_lock_lhb1, flags); +} + +/** + * smp2p_interrupt_handler - Incoming interrupt handler. + * + * @irq: Interrupt ID + * @data: Edge + * @returns: IRQ_HANDLED or IRQ_NONE for invalid interrupt + */ +static irqreturn_t smp2p_interrupt_handler(int irq, void *data) +{ + unsigned long flags; + uint32_t remote_pid = (uint32_t)(uintptr_t)data; + + if (remote_pid >= SMP2P_NUM_PROCS) { + SMP2P_ERR("%s: invalid interrupt pid %d\n", + __func__, remote_pid); + return IRQ_NONE; + } + + if (smp2p_int_cfgs[remote_pid].name) + SMP2P_DBG("SMP2P Int %s(%d)->Apps\n", + smp2p_int_cfgs[remote_pid].name, remote_pid); + + spin_lock_irqsave(&out_list[remote_pid].out_item_lock_lha1, flags); + ++smp2p_int_cfgs[remote_pid].in_interrupt_count; + + if (out_list[remote_pid].smem_edge_state != SMP2P_EDGE_STATE_OPENED) + smp2p_do_negotiation(remote_pid, &out_list[remote_pid]); + + if (out_list[remote_pid].smem_edge_state == SMP2P_EDGE_STATE_OPENED) { + bool do_restart_ack; + + /* + * Follow double-check pattern for restart ack since: + * 1) we must notify clients of the X->0 transition + * that is part of the restart + * 2) lock cannot be held during the + * smp2p_in_edge_notify() call because clients may do + * re-entrant calls into our APIs. + * + * smp2p_do_ssr_ack() will only do the ack if it is + * necessary to handle the race condition exposed by + * unlocking the spinlocks. + */ + spin_lock(&in_list[remote_pid].in_item_lock_lhb1); + do_restart_ack = smp2p_ssr_ack_needed(remote_pid); + spin_unlock(&in_list[remote_pid].in_item_lock_lhb1); + spin_unlock_irqrestore(&out_list[remote_pid].out_item_lock_lha1, + flags); + + smp2p_in_edge_notify(remote_pid); + + if (do_restart_ack) { + spin_lock_irqsave( + &out_list[remote_pid].out_item_lock_lha1, + flags); + spin_lock(&in_list[remote_pid].in_item_lock_lhb1); + + smp2p_do_ssr_ack(remote_pid); + + spin_unlock(&in_list[remote_pid].in_item_lock_lhb1); + spin_unlock_irqrestore( + &out_list[remote_pid].out_item_lock_lha1, + flags); + } + } else { + spin_unlock_irqrestore(&out_list[remote_pid].out_item_lock_lha1, + flags); + } + + return IRQ_HANDLED; +} + +/** + * smp2p_reset_mock_edge - Reinitializes the mock edge. + * + * @returns: 0 on success, -EAGAIN to retry later. + * + * Reinitializes the mock edge to initial power-up state values. + */ +int smp2p_reset_mock_edge(void) +{ + const int rpid = SMP2P_REMOTE_MOCK_PROC; + unsigned long flags; + int ret = 0; + + spin_lock_irqsave(&out_list[rpid].out_item_lock_lha1, flags); + spin_lock(&in_list[rpid].in_item_lock_lhb1); + + if (!list_empty(&out_list[rpid].list) || + !list_empty(&in_list[rpid].list)) { + ret = -EAGAIN; + goto fail; + } + + kfree(out_list[rpid].smem_edge_out); + out_list[rpid].smem_edge_out = NULL; + out_list[rpid].ops_ptr = &version_if[0]; + out_list[rpid].smem_edge_state = SMP2P_EDGE_STATE_CLOSED; + out_list[rpid].feature_ssr_ack_enabled = false; + out_list[rpid].restart_ack = false; + + in_list[rpid].smem_edge_in = NULL; + in_list[rpid].item_size = 0; + in_list[rpid].safe_total_entries = 0; + +fail: + spin_unlock(&in_list[rpid].in_item_lock_lhb1); + spin_unlock_irqrestore(&out_list[rpid].out_item_lock_lha1, flags); + + return ret; +} + +/** + * msm_smp2p_interrupt_handler - Triggers incoming interrupt. + * + * @remote_pid: Remote processor ID + * + * This function is used with the remote mock infrastructure + * used for testing. It simulates triggering of interrupt in + * a testing environment. + */ +void msm_smp2p_interrupt_handler(int remote_pid) +{ + smp2p_interrupt_handler(0, (void *)(uintptr_t)remote_pid); +} + +/** + * msm_smp2p_probe - Device tree probe function. + * + * @pdev: Pointer to device tree data. + * @returns: 0 on success; -ENODEV otherwise + */ +static int msm_smp2p_probe(struct platform_device *pdev) +{ + struct resource *r; + void *irq_out_ptr = NULL; + char *key; + uint32_t edge; + int ret; + struct device_node *node; + uint32_t irq_bitmask; + uint32_t irq_line; + void *temp_p; + unsigned temp_sz; + + node = pdev->dev.of_node; + + key = "qcom,remote-pid"; + ret = of_property_read_u32(node, key, &edge); + if (ret) { + SMP2P_ERR("%s: missing edge '%s'\n", __func__, key); + ret = -ENODEV; + goto fail; + } + + r = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!r) { + SMP2P_ERR("%s: failed gathering irq-reg resource for edge %d\n" + , __func__, edge); + ret = -ENODEV; + goto fail; + } + irq_out_ptr = ioremap_nocache(r->start, resource_size(r)); + if (!irq_out_ptr) { + SMP2P_ERR("%s: failed remap from phys to virt for edge %d\n", + __func__, edge); + ret = -ENOMEM; + goto fail; + } + + key = "qcom,irq-bitmask"; + ret = of_property_read_u32(node, key, &irq_bitmask); + if (ret) + goto missing_key; + + key = "interrupts"; + irq_line = platform_get_irq(pdev, 0); + if (irq_line == -ENXIO) + goto missing_key; + + /* + * We depend on the SMEM driver, so do a test access to see if SMEM is + * ready. We don't want any side effects at this time (so no alloc) + * and the return doesn't matter, so long as it is not -EPROBE_DEFER. + */ + temp_p = smem_get_entry( + smp2p_get_smem_item_id(SMP2P_APPS_PROC, SMP2P_MODEM_PROC), + &temp_sz, + 0, + SMEM_ANY_HOST_FLAG); + if (PTR_ERR(temp_p) == -EPROBE_DEFER) { + SMP2P_INFO("%s: edge:%d probe before smem ready\n", __func__, + edge); + ret = -EPROBE_DEFER; + goto fail; + } + + ret = request_irq(irq_line, smp2p_interrupt_handler, + IRQF_TRIGGER_RISING, "smp2p", (void *)(uintptr_t)edge); + if (ret < 0) { + SMP2P_ERR("%s: request_irq() failed on %d (edge %d)\n", + __func__, irq_line, edge); + ret = -ENODEV; + goto fail; + } + + ret = enable_irq_wake(irq_line); + if (ret < 0) + SMP2P_ERR("%s: enable_irq_wake() failed on %d (edge %d)\n", + __func__, irq_line, edge); + + /* + * Set entry (keep is_configured last to prevent usage before + * initialization). + */ + smp2p_int_cfgs[edge].in_int_id = irq_line; + smp2p_int_cfgs[edge].out_int_mask = irq_bitmask; + smp2p_int_cfgs[edge].out_int_ptr = irq_out_ptr; + smp2p_int_cfgs[edge].is_configured = true; + return 0; + +missing_key: + SMP2P_ERR("%s: missing '%s' for edge %d\n", __func__, key, edge); + ret = -ENODEV; +fail: + if (irq_out_ptr) + iounmap(irq_out_ptr); + return ret; +} + +static struct of_device_id msm_smp2p_match_table[] = { + { .compatible = "qcom,smp2p" }, + {}, +}; + +static struct platform_driver msm_smp2p_driver = { + .probe = msm_smp2p_probe, + .driver = { + .name = "msm_smp2p", + .owner = THIS_MODULE, + .of_match_table = msm_smp2p_match_table, + }, +}; + +/** + * msm_smp2p_init - Initialization function for the module. + * + * @returns: 0 on success, standard Linux error code otherwise. + */ +static int __init msm_smp2p_init(void) +{ + int i; + int rc; + + for (i = 0; i < SMP2P_NUM_PROCS; i++) { + spin_lock_init(&out_list[i].out_item_lock_lha1); + INIT_LIST_HEAD(&out_list[i].list); + out_list[i].smem_edge_out = NULL; + out_list[i].smem_edge_state = SMP2P_EDGE_STATE_CLOSED; + out_list[i].ops_ptr = &version_if[0]; + out_list[i].feature_ssr_ack_enabled = false; + out_list[i].restart_ack = false; + + spin_lock_init(&in_list[i].in_item_lock_lhb1); + INIT_LIST_HEAD(&in_list[i].list); + in_list[i].smem_edge_in = NULL; + } + + log_ctx = ipc_log_context_create(NUM_LOG_PAGES, "smp2p", 0); + if (!log_ctx) + SMP2P_ERR("%s: unable to create log context\n", __func__); + + rc = platform_driver_register(&msm_smp2p_driver); + if (rc) { + SMP2P_ERR("%s: msm_smp2p_driver register failed %d\n", + __func__, rc); + return rc; + } + + return 0; +} +module_init(msm_smp2p_init); + +MODULE_DESCRIPTION("MSM Shared Memory Point to Point"); +MODULE_LICENSE("GPL v2"); |