/* 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 #include #include #include #include #include #include #include #include #include #include #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");