Piteball
/
android_kernel_samsung_msm8976
mirror of https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
1
1
Fork 0
Code Issues Projects Releases Wiki Activity
android_kernel_samsung_msm8976/drivers/soc/qcom/smp2p.c

1952 lines
56 KiB
C
Raw Permalink Blame History

/* 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_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_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");
Reference in New Issue View Git Blame Copy Permalink