449 lines
12 KiB
C
449 lines
12 KiB
C
/* drivers/soc/qcom/smp2p_loopback.c
|
|
*
|
|
* Copyright (c) 2013-2014, 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/debugfs.h>
|
|
#include <linux/list.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/termios.h>
|
|
#include <linux/module.h>
|
|
#include <linux/remote_spinlock.h>
|
|
#include "smem_private.h"
|
|
#include "smp2p_private.h"
|
|
|
|
/**
|
|
* struct smp2p_loopback_ctx - Representation of remote loopback object.
|
|
*
|
|
* @proc_id: Processor id of the processor that sends the loopback commands.
|
|
* @out: Handle to the smem entry structure for providing the response.
|
|
* @out_nb: Notifies the opening of local entry.
|
|
* @out_is_active: Outbound entry events should be processed.
|
|
* @in_nb: Notifies changes in the remote entry.
|
|
* @in_is_active: Inbound entry events should be processed.
|
|
* @rmt_lpb_work: Work item that handles the incoming loopback commands.
|
|
* @rmt_cmd: Structure that holds the current and previous value of the entry.
|
|
*/
|
|
struct smp2p_loopback_ctx {
|
|
int proc_id;
|
|
struct msm_smp2p_out *out;
|
|
struct notifier_block out_nb;
|
|
bool out_is_active;
|
|
struct notifier_block in_nb;
|
|
bool in_is_active;
|
|
struct work_struct rmt_lpb_work;
|
|
struct msm_smp2p_update_notif rmt_cmd;
|
|
};
|
|
|
|
static struct smp2p_loopback_ctx remote_loopback[SMP2P_NUM_PROCS];
|
|
static struct msm_smp2p_remote_mock remote_mock;
|
|
|
|
/**
|
|
* remote_spinlock_test - Handles remote spinlock test.
|
|
*
|
|
* @ctx: Loopback context
|
|
*/
|
|
static void remote_spinlock_test(struct smp2p_loopback_ctx *ctx)
|
|
{
|
|
uint32_t test_request;
|
|
uint32_t test_response;
|
|
unsigned long flags;
|
|
int n;
|
|
unsigned lock_count = 0;
|
|
remote_spinlock_t *smem_spinlock;
|
|
|
|
test_request = 0x0;
|
|
SMP2P_SET_RMT_CMD_TYPE_REQ(test_request);
|
|
smem_spinlock = smem_get_remote_spinlock();
|
|
if (!smem_spinlock) {
|
|
pr_err("%s: unable to get remote spinlock\n", __func__);
|
|
return;
|
|
}
|
|
|
|
for (;;) {
|
|
remote_spin_lock_irqsave(smem_spinlock, flags);
|
|
++lock_count;
|
|
SMP2P_SET_RMT_CMD(test_request, SMP2P_LB_CMD_RSPIN_LOCKED);
|
|
(void)msm_smp2p_out_write(ctx->out, test_request);
|
|
|
|
for (n = 0; n < 10000; ++n) {
|
|
(void)msm_smp2p_in_read(ctx->proc_id,
|
|
"smp2p", &test_response);
|
|
test_response = SMP2P_GET_RMT_CMD(test_response);
|
|
|
|
if (test_response == SMP2P_LB_CMD_RSPIN_END)
|
|
break;
|
|
|
|
if (test_response != SMP2P_LB_CMD_RSPIN_UNLOCKED)
|
|
SMP2P_ERR("%s: invalid spinlock command %x\n",
|
|
__func__, test_response);
|
|
}
|
|
|
|
if (test_response == SMP2P_LB_CMD_RSPIN_END) {
|
|
SMP2P_SET_RMT_CMD_TYPE_RESP(test_request);
|
|
SMP2P_SET_RMT_CMD(test_request,
|
|
SMP2P_LB_CMD_RSPIN_END);
|
|
SMP2P_SET_RMT_DATA(test_request, lock_count);
|
|
(void)msm_smp2p_out_write(ctx->out, test_request);
|
|
break;
|
|
}
|
|
|
|
SMP2P_SET_RMT_CMD(test_request, SMP2P_LB_CMD_RSPIN_UNLOCKED);
|
|
(void)msm_smp2p_out_write(ctx->out, test_request);
|
|
remote_spin_unlock_irqrestore(smem_spinlock, flags);
|
|
}
|
|
remote_spin_unlock_irqrestore(smem_spinlock, flags);
|
|
}
|
|
|
|
/**
|
|
* smp2p_rmt_lpb_worker - Handles incoming remote loopback commands.
|
|
*
|
|
* @work: Work Item scheduled to handle the incoming commands.
|
|
*/
|
|
static void smp2p_rmt_lpb_worker(struct work_struct *work)
|
|
{
|
|
struct smp2p_loopback_ctx *ctx;
|
|
int lpb_cmd;
|
|
int lpb_cmd_type;
|
|
int lpb_data;
|
|
|
|
ctx = container_of(work, struct smp2p_loopback_ctx, rmt_lpb_work);
|
|
|
|
if (!ctx->in_is_active || !ctx->out_is_active)
|
|
return;
|
|
|
|
if (ctx->rmt_cmd.previous_value == ctx->rmt_cmd.current_value)
|
|
return;
|
|
|
|
lpb_cmd_type = SMP2P_GET_RMT_CMD_TYPE(ctx->rmt_cmd.current_value);
|
|
lpb_cmd = SMP2P_GET_RMT_CMD(ctx->rmt_cmd.current_value);
|
|
lpb_data = SMP2P_GET_RMT_DATA(ctx->rmt_cmd.current_value);
|
|
|
|
if (lpb_cmd & SMP2P_RLPB_IGNORE)
|
|
return;
|
|
|
|
switch (lpb_cmd) {
|
|
case SMP2P_LB_CMD_NOOP:
|
|
/* Do nothing */
|
|
break;
|
|
|
|
case SMP2P_LB_CMD_ECHO:
|
|
SMP2P_SET_RMT_CMD_TYPE(ctx->rmt_cmd.current_value, 0);
|
|
SMP2P_SET_RMT_DATA(ctx->rmt_cmd.current_value,
|
|
lpb_data);
|
|
(void)msm_smp2p_out_write(ctx->out,
|
|
ctx->rmt_cmd.current_value);
|
|
break;
|
|
|
|
case SMP2P_LB_CMD_CLEARALL:
|
|
ctx->rmt_cmd.current_value = 0;
|
|
(void)msm_smp2p_out_write(ctx->out,
|
|
ctx->rmt_cmd.current_value);
|
|
break;
|
|
|
|
case SMP2P_LB_CMD_PINGPONG:
|
|
SMP2P_SET_RMT_CMD_TYPE(ctx->rmt_cmd.current_value, 0);
|
|
if (lpb_data) {
|
|
lpb_data--;
|
|
SMP2P_SET_RMT_DATA(ctx->rmt_cmd.current_value,
|
|
lpb_data);
|
|
(void)msm_smp2p_out_write(ctx->out,
|
|
ctx->rmt_cmd.current_value);
|
|
}
|
|
break;
|
|
|
|
case SMP2P_LB_CMD_RSPIN_START:
|
|
remote_spinlock_test(ctx);
|
|
break;
|
|
|
|
case SMP2P_LB_CMD_RSPIN_LOCKED:
|
|
case SMP2P_LB_CMD_RSPIN_UNLOCKED:
|
|
case SMP2P_LB_CMD_RSPIN_END:
|
|
/* not used for remote spinlock test */
|
|
break;
|
|
|
|
default:
|
|
SMP2P_DBG("%s: Unknown loopback command %x\n",
|
|
__func__, lpb_cmd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* smp2p_rmt_in_edge_notify - Schedules a work item to handle the commands.
|
|
*
|
|
* @nb: Notifier block, this is called when the value in remote entry changes.
|
|
* @event: Takes value SMP2P_ENTRY_UPDATE or SMP2P_OPEN based on the event.
|
|
* @data: Consists of previous and current value in case of entry update.
|
|
* @returns: 0 for success (return value required for notifier chains).
|
|
*/
|
|
static int smp2p_rmt_in_edge_notify(struct notifier_block *nb,
|
|
unsigned long event, void *data)
|
|
{
|
|
struct smp2p_loopback_ctx *ctx;
|
|
|
|
if (!(event == SMP2P_ENTRY_UPDATE || event == SMP2P_OPEN))
|
|
return 0;
|
|
|
|
ctx = container_of(nb, struct smp2p_loopback_ctx, in_nb);
|
|
if (data && ctx->in_is_active) {
|
|
ctx->rmt_cmd =
|
|
*(struct msm_smp2p_update_notif *)data;
|
|
schedule_work(&ctx->rmt_lpb_work);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* smp2p_rmt_out_edge_notify - Notifies on the opening of the outbound entry.
|
|
*
|
|
* @nb: Notifier block, this is called when the local entry is open.
|
|
* @event: Takes on value SMP2P_OPEN when the local entry is open.
|
|
* @data: Consist of current value of the remote entry, if entry is open.
|
|
* @returns: 0 for success (return value required for notifier chains).
|
|
*/
|
|
static int smp2p_rmt_out_edge_notify(struct notifier_block *nb,
|
|
unsigned long event, void *data)
|
|
{
|
|
struct smp2p_loopback_ctx *ctx;
|
|
|
|
ctx = container_of(nb, struct smp2p_loopback_ctx, out_nb);
|
|
if (event == SMP2P_OPEN)
|
|
SMP2P_DBG("%s: 'smp2p':%d opened\n", __func__,
|
|
ctx->proc_id);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* msm_smp2p_init_rmt_lpb - Initializes the remote loopback object.
|
|
*
|
|
* @ctx: Pointer to remote loopback object that needs to be initialized.
|
|
* @pid: Processor id of the processor that is sending the commands.
|
|
* @entry: Name of the entry that needs to be opened locally.
|
|
* @returns: 0 on success, standard Linux error code otherwise.
|
|
*/
|
|
static int msm_smp2p_init_rmt_lpb(struct smp2p_loopback_ctx *ctx,
|
|
int pid, const char *entry)
|
|
{
|
|
int ret = 0;
|
|
int tmp;
|
|
|
|
if (!ctx || !entry || pid > SMP2P_NUM_PROCS)
|
|
return -EINVAL;
|
|
|
|
ctx->in_nb.notifier_call = smp2p_rmt_in_edge_notify;
|
|
ctx->out_nb.notifier_call = smp2p_rmt_out_edge_notify;
|
|
ctx->proc_id = pid;
|
|
ctx->in_is_active = true;
|
|
ctx->out_is_active = true;
|
|
tmp = msm_smp2p_out_open(pid, entry, &ctx->out_nb,
|
|
&ctx->out);
|
|
if (tmp) {
|
|
SMP2P_ERR("%s: open failed outbound entry '%s':%d - ret %d\n",
|
|
__func__, entry, pid, tmp);
|
|
ret = tmp;
|
|
}
|
|
|
|
tmp = msm_smp2p_in_register(ctx->proc_id,
|
|
SMP2P_RLPB_ENTRY_NAME,
|
|
&ctx->in_nb);
|
|
if (tmp) {
|
|
SMP2P_ERR("%s: unable to open inbound entry '%s':%d - ret %d\n",
|
|
__func__, entry, pid, tmp);
|
|
ret = tmp;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* msm_smp2p_init_rmt_lpb_proc - Wrapper over msm_smp2p_init_rmt_lpb
|
|
*
|
|
* @remote_pid: Processor ID of the processor that sends loopback command.
|
|
* @returns: Pointer to outbound entry handle.
|
|
*/
|
|
void *msm_smp2p_init_rmt_lpb_proc(int remote_pid)
|
|
{
|
|
int tmp;
|
|
void *ret = NULL;
|
|
|
|
tmp = msm_smp2p_init_rmt_lpb(&remote_loopback[remote_pid],
|
|
remote_pid, SMP2P_RLPB_ENTRY_NAME);
|
|
if (!tmp)
|
|
ret = remote_loopback[remote_pid].out;
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(msm_smp2p_init_rmt_lpb_proc);
|
|
|
|
/**
|
|
* msm_smp2p_deinit_rmt_lpb_proc - Unregister support for remote processor.
|
|
*
|
|
* @remote_pid: Processor ID of the remote system.
|
|
* @returns: 0 on success, standard Linux error code otherwise.
|
|
*
|
|
* Unregister loopback support for remote processor.
|
|
*/
|
|
int msm_smp2p_deinit_rmt_lpb_proc(int remote_pid)
|
|
{
|
|
int ret = 0;
|
|
int tmp;
|
|
struct smp2p_loopback_ctx *ctx;
|
|
|
|
if (remote_pid >= SMP2P_NUM_PROCS)
|
|
return -EINVAL;
|
|
|
|
ctx = &remote_loopback[remote_pid];
|
|
|
|
/* abort any pending notifications */
|
|
remote_loopback[remote_pid].out_is_active = false;
|
|
remote_loopback[remote_pid].in_is_active = false;
|
|
flush_work(&ctx->rmt_lpb_work);
|
|
|
|
/* unregister entries */
|
|
tmp = msm_smp2p_out_close(&remote_loopback[remote_pid].out);
|
|
remote_loopback[remote_pid].out = NULL;
|
|
if (tmp) {
|
|
SMP2P_ERR("%s: outbound 'smp2p':%d close failed %d\n",
|
|
__func__, remote_pid, tmp);
|
|
ret = tmp;
|
|
}
|
|
|
|
tmp = msm_smp2p_in_unregister(remote_pid,
|
|
SMP2P_RLPB_ENTRY_NAME, &remote_loopback[remote_pid].in_nb);
|
|
if (tmp) {
|
|
SMP2P_ERR("%s: inbound 'smp2p':%d close failed %d\n",
|
|
__func__, remote_pid, tmp);
|
|
ret = tmp;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(msm_smp2p_deinit_rmt_lpb_proc);
|
|
|
|
/**
|
|
* msm_smp2p_set_remote_mock_exists - Sets the remote mock configuration.
|
|
*
|
|
* @item_exists: true = Remote mock SMEM item exists
|
|
*
|
|
* This is used in the testing environment to simulate the existence of the
|
|
* remote smem item in order to test the negotiation algorithm.
|
|
*/
|
|
void msm_smp2p_set_remote_mock_exists(bool item_exists)
|
|
{
|
|
remote_mock.item_exists = item_exists;
|
|
}
|
|
EXPORT_SYMBOL(msm_smp2p_set_remote_mock_exists);
|
|
|
|
/**
|
|
* msm_smp2p_get_remote_mock - Get remote mock object.
|
|
*
|
|
* @returns: Point to the remote mock object.
|
|
*/
|
|
void *msm_smp2p_get_remote_mock(void)
|
|
{
|
|
return &remote_mock;
|
|
}
|
|
EXPORT_SYMBOL(msm_smp2p_get_remote_mock);
|
|
|
|
/**
|
|
* msm_smp2p_get_remote_mock_smem_item - Returns a pointer to remote item.
|
|
*
|
|
* @size: Size of item.
|
|
* @returns: Pointer to mock remote smem item.
|
|
*/
|
|
void *msm_smp2p_get_remote_mock_smem_item(uint32_t *size)
|
|
{
|
|
void *ptr = NULL;
|
|
if (remote_mock.item_exists) {
|
|
*size = sizeof(remote_mock.remote_item);
|
|
ptr = &(remote_mock.remote_item);
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
EXPORT_SYMBOL(msm_smp2p_get_remote_mock_smem_item);
|
|
|
|
/**
|
|
* smp2p_remote_mock_rx_interrupt - Triggers receive interrupt for mock proc.
|
|
*
|
|
* @returns: 0 for success
|
|
*
|
|
* This function simulates the receiving of interrupt by the mock remote
|
|
* processor in a testing environment.
|
|
*/
|
|
int smp2p_remote_mock_rx_interrupt(void)
|
|
{
|
|
remote_mock.rx_interrupt_count++;
|
|
if (remote_mock.initialized)
|
|
complete(&remote_mock.cb_completion);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(smp2p_remote_mock_rx_interrupt);
|
|
|
|
/**
|
|
* smp2p_remote_mock_tx_interrupt - Calls the SMP2P interrupt handler.
|
|
*
|
|
* This function calls the interrupt handler of the Apps processor to simulate
|
|
* receiving interrupts from a remote processor.
|
|
*/
|
|
static void smp2p_remote_mock_tx_interrupt(void)
|
|
{
|
|
msm_smp2p_interrupt_handler(SMP2P_REMOTE_MOCK_PROC);
|
|
}
|
|
|
|
/**
|
|
* smp2p_remote_mock_init - Initialize the remote mock and loopback objects.
|
|
*
|
|
* @returns: 0 for success
|
|
*/
|
|
static int __init smp2p_remote_mock_init(void)
|
|
{
|
|
int i;
|
|
struct smp2p_interrupt_config *int_cfg;
|
|
|
|
smp2p_init_header(&remote_mock.remote_item.header,
|
|
SMP2P_REMOTE_MOCK_PROC, SMP2P_APPS_PROC,
|
|
0, 0);
|
|
remote_mock.rx_interrupt_count = 0;
|
|
remote_mock.rx_interrupt = smp2p_remote_mock_rx_interrupt;
|
|
remote_mock.tx_interrupt = smp2p_remote_mock_tx_interrupt;
|
|
remote_mock.item_exists = false;
|
|
init_completion(&remote_mock.cb_completion);
|
|
remote_mock.initialized = true;
|
|
|
|
for (i = 0; i < SMP2P_NUM_PROCS; i++) {
|
|
INIT_WORK(&(remote_loopback[i].rmt_lpb_work),
|
|
smp2p_rmt_lpb_worker);
|
|
if (i == SMP2P_REMOTE_MOCK_PROC)
|
|
/* do not register loopback for remote mock proc */
|
|
continue;
|
|
|
|
int_cfg = smp2p_get_interrupt_config();
|
|
if (!int_cfg) {
|
|
SMP2P_ERR("Remote processor config unavailable\n");
|
|
return 0;
|
|
}
|
|
if (!int_cfg[i].is_configured)
|
|
continue;
|
|
|
|
msm_smp2p_init_rmt_lpb(&remote_loopback[i],
|
|
i, SMP2P_RLPB_ENTRY_NAME);
|
|
}
|
|
return 0;
|
|
}
|
|
module_init(smp2p_remote_mock_init);
|