samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add 'qcom/opensource/mmrm-driver/' from commit '35211a9255b69d52ddc2b82dc8b1dd2840b98868'

Browse Source 
git-subtree-dir: qcom/opensource/mmrm-driver
git-subtree-mainline: f9b254670f
git-subtree-split: 35211a9255
Change-Id:
repo: https://git.codelinaro.org/clo/la/platform/vendor/opensource/mmrm-driver
tag: VIDEO.LA.4.0.r2-06100-lanai.0
This commit is contained in:
David Wronek
2024-10-06 16:45:08 +02:00
parent f9b254670f 35211a9255
commit 99d06628db
45 changed files with 7155 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
qcom/opensource/mmrm-driver/vm/be/Kbuild Normal file
View File

@@ -0,0 +1,9 @@
ifeq ($(CONFIG_MSM_MMRM_VM),y)
LINUXINCLUDE += -I$(MMRM_ROOT)/vm/be/src -I$(MMRM_ROOT)/driver/src
obj-m += mmrm_vm_be.o
mmrm_vm_be-objs := src/mmrm_vm_be_main.o \
src/mmrm_vm_be_dispatch.o \
src/mmrm_vm_be_msgq.o \
../common/src/mmrm_vm_debug.o
endif

32
qcom/opensource/mmrm-driver/vm/be/src/mmrm_vm_be.h Normal file
View File

@@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef _MMRM_VM_BE_H_
#define _MMRM_VM_BE_H_
#include <linux/soc/qcom/msm_mmrm.h>
#include <mmrm_vm_interface.h>
/*
* mmrm_vm_be_recv -- BE message receiving thread call this function
* for transfer receiving packet to BE
* @mmrm_vm: device driver info
* @data: message pointer
* @size: message size
*/
int mmrm_vm_be_recv(struct mmrm_vm_driver_data *mmrm_vm, void *data, size_t size);
/*
* mmrm_vm_be_send_response -- BE message receiving thread call this function
* for sending back API calling result to FE
* @mmrm_vm: specific device driver info
* @size: message size
*/
int mmrm_vm_be_send_response(struct mmrm_vm_driver_data *mmrm_vm, void *msg);
#endif /* _MMRM_VM_BE_H_ */

9
qcom/opensource/mmrm-driver/vm/be/src/mmrm_vm_be.rc Normal file
View File

@@ -0,0 +1,9 @@
# SPDX-License-Identifier: GPL-2.0-only
#
# Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
#
on boot
insmod /vendor/lib/modules/mmrm_vm_be.ko

292
qcom/opensource/mmrm-driver/vm/be/src/mmrm_vm_be_dispatch.c Normal file
View File

@@ -0,0 +1,292 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include "mmrm_vm_debug.h"
#include "mmrm_vm_interface.h"
#include "mmrm_vm_msgq.h"
#include "mmrm_vm_be.h"
/**
* mmrm_vm_be_send_response - send response to FE
* mmrm_vm: driver private data
* msg: response message
*/
int mmrm_vm_be_send_response(struct mmrm_vm_driver_data *mmrm_vm, void *msg)
{
struct mmrm_vm_response_msg_pkt *ppkt = (struct mmrm_vm_response_msg_pkt *)msg;
struct mmrm_vm_msg_hdr *hdr = &ppkt->hdr;
size_t msg_size = sizeof(*hdr) + hdr->size;
int rc;
hdr->version = MMRM_VM_VER_1;
hdr->type = MMRM_VM_TYPE_DATA;
hdr->flags = 0;
rc = mmrm_vm_msgq_send(mmrm_vm, msg, msg_size);
d_mpr_l("%s: size:%d rc=%d\n", __func__, msg_size, rc);
return rc;
}
/**
* mmrm_vm_be_client_register - call mmrm API to register client
* mmrm_vm: driver private data
* req: request parameters
*/
static int mmrm_vm_be_client_register(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
struct mmrm_client *pClient;
int rc;
struct mmrm_vm_response_msg_pkt pkt;
struct mmrm_client_desc client_desc;
// unpacketizing the call from fe on SVM
client_desc.client_type = req->data.reg.client_type;
memcpy(&(client_desc.client_info.desc), &(req->data.reg.desc),
sizeof(client_desc.client_info.desc));
client_desc.priority = req->data.reg.priority;
d_mpr_l("%s: register type:%d priority:%d\n", __func__,
client_desc.client_type, client_desc.priority);
d_mpr_l("%s: domain:%d client ID:%d\n", __func__,
client_desc.client_info.desc.client_domain,
client_desc.client_info.desc.client_id);
d_mpr_l("%s: clk name:%s\n", __func__, client_desc.client_info.desc.name);
// call mmrm register function
pClient = mmrm_client_register(&client_desc);
if (pClient != NULL) {
mmrm_vm->clk_client_tbl[pClient->client_uid] = pClient;
pkt.msg.data.reg.client_id = pClient->client_uid;
} else {
pkt.msg.data.reg.client_id = U32_MAX;
d_mpr_e("%s: client:%p client id:%d\n", __func__, pClient, pkt.msg.data.reg.client_id);
}
// prepare response packet & send to fe on SVM
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_REGISTER;
pkt.msg.hd.seq_no = req->hd.seq_no;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.reg);
d_mpr_l("%s: cmd_id:%d data size:%d\n", __func__, pkt.msg.hd.cmd_id, pkt.hdr.size);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_client_setvalue - call mmrm API to set client values
* mmrm_vm: driver private data
* req: set client value request parameters
*/
static int mmrm_vm_be_client_setvalue(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
struct mmrm_vm_response_msg_pkt pkt_resp;
int rc;
struct mmrm_vm_setvalue_request *req_param = &req->data.setval;
// call mmrm client set value function, and fill response packet
rc = mmrm_client_set_value(mmrm_vm->clk_client_tbl[req_param->client_id],
&req_param->data, req_param->val);
if (rc != 0) {
d_mpr_e("%s: set value rc:%d client id:%d\n", __func__, rc, req_param->client_id);
}
// prepare response packet & send to fe on SVM
pkt_resp.msg.hd.cmd_id = MMRM_VM_RESPONSE_SETVALUE;
pkt_resp.msg.hd.seq_no = req->hd.seq_no;
pkt_resp.hdr.size = sizeof(pkt_resp.msg.hd) + sizeof(pkt_resp.msg.data.setval);
pkt_resp.msg.data.setval.val = rc;
d_mpr_l("%s: cmd_id:%d data size:%d\n", __func__,
pkt_resp.msg.hd.cmd_id, pkt_resp.hdr.size);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt_resp);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_client_setvalue_inrange - call mmrm API to set client range values
* mmrm_vm: driver private data
* req: set client value request parameters
*/
static int mmrm_vm_be_client_setvalue_inrange(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
struct mmrm_vm_response_msg_pkt pkt;
int rc;
struct mmrm_vm_setvalue_inrange_request *req_param = &req->data.setval_range;
rc = mmrm_client_set_value_in_range(mmrm_vm->clk_client_tbl[req_param->client_id],
&req_param->data, &req_param->val);
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_SETVALUE_INRANGE;
pkt.msg.hd.seq_no = req->hd.seq_no;
pkt.msg.data.setval_range.ret_code = rc;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.setval_range);
d_mpr_l("%s: cmd_id:%d data size:%d\n", __func__, pkt.msg.hd.cmd_id, pkt.hdr.size);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_client_getvalue - call mmrm API to get client values
* mmrm_vm: driver private data
* req: set client value request parameters
*/
static int mmrm_vm_be_client_getvalue(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
struct mmrm_vm_response_msg_pkt pkt;
int rc;
struct mmrm_vm_getvalue_request *req_param = &req->data.getval;
struct mmrm_client_res_value val;
struct mmrm_client_res_value *p_val = &pkt.msg.data.getval.val;
rc = mmrm_client_get_value(mmrm_vm->clk_client_tbl[req_param->client_id], &val);
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_GETVALUE;
pkt.msg.hd.seq_no = req->hd.seq_no;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.getval);
p_val->cur = val.cur;
p_val->max = val.max;
p_val->min = val.min;
// pr_err("%s: cmd_id:%d data size:%d\n", __func__, pkt.msg.hd.cmd_id, pkt.hdr.size);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_client_deregister - call mmrm API to deregister client
* mmrm_vm: driver private data
* req: set client value request parameters
*/
static int mmrm_vm_be_client_deregister(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
int rc;
struct mmrm_vm_response_msg_pkt pkt;
struct mmrm_vm_deregister_request *req_param = &req->data.dereg;
rc = mmrm_client_deregister(mmrm_vm->clk_client_tbl[req_param->client_id]);
// pr_err("%s: client:%d\n", __func__, req_param->client_id);
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_DEREGISTER;
pkt.msg.hd.seq_no = req->hd.seq_no;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.dereg);
pkt.msg.data.dereg.ret_code = rc;
// pr_err("%s: cmd_id:%d data size:%d ret:%d\n", __func__,
// pkt.msg.hd.cmd_id, pkt.hdr.size, pkt.msg.data.dereg.ret_code);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_client_noop - call none mmrm API to calculate msgq roundtrip time
* mmrm_vm: driver private data
* req: request parameters
*/
static int mmrm_vm_be_client_noop(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_api_request_msg *req)
{
int rc = 0;
struct mmrm_vm_response_msg_pkt pkt;
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_NOOP;
pkt.msg.hd.seq_no = req->hd.seq_no;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.lptest);
pkt.msg.data.dereg.ret_code = rc;
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}
/**
* mmrm_vm_be_recv - be dispatch mmrm request to mmrm API call
* mmrm_vm: driver private data
* data: request message buffer pointer
* size: request message size
*/
int mmrm_vm_be_recv(struct mmrm_vm_driver_data *mmrm_vm, void *data, size_t size)
{
struct mmrm_vm_api_request_msg *cmd = data;
int rc = -1;
switch (cmd->hd.cmd_id) {
case MMRM_VM_REQUEST_REGISTER:
rc = mmrm_vm_be_client_register(mmrm_vm, cmd);
break;
case MMRM_VM_REQUEST_SETVALUE:
rc = mmrm_vm_be_client_setvalue(mmrm_vm, cmd);
break;
case MMRM_VM_REQUEST_SETVALUE_INRANGE:
rc = mmrm_vm_be_client_setvalue_inrange(mmrm_vm, cmd);
break;
case MMRM_VM_REQUEST_GETVALUE:
rc = mmrm_vm_be_client_getvalue(mmrm_vm, cmd);
break;
case MMRM_VM_REQUEST_DEREGISTER:
rc = mmrm_vm_be_client_deregister(mmrm_vm, cmd);
break;
case MMRM_VM_REQUEST_NOOP:
rc = mmrm_vm_be_client_noop(mmrm_vm, cmd);
break;
default:
pr_err("%s: cmd_id:%d unknown!!!\n", __func__, cmd->hd.cmd_id);
break;
}
return rc;
}
/**
* mmrm_vm_be_wrong_request - deal with SVM wrong request
* mmrm_vm: driver private data
*/
int mmrm_vm_be_wrong_request(struct mmrm_vm_driver_data *mmrm_vm)
{
int rc = 0;
struct mmrm_vm_response_msg_pkt pkt;
pkt.msg.hd.cmd_id = MMRM_VM_RESPONSE_INVALID_PKT;
pkt.msg.hd.seq_no = 0;
pkt.hdr.size = sizeof(pkt.msg.hd) + sizeof(pkt.msg.data.dereg);
pkt.msg.data.dereg.ret_code = rc;
d_mpr_e("%s: wrong request\n", __func__);
rc = mmrm_vm_be_send_response(mmrm_vm, &pkt);
if (rc != 0)
d_mpr_e("%s: rc:%d\n", __func__, rc);
return rc;
}

112
qcom/opensource/mmrm-driver/vm/be/src/mmrm_vm_be_main.c Normal file
View File

@@ -0,0 +1,112 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/slab.h>
#include "mmrm_vm_be.h"
#include "mmrm_vm_msgq.h"
#include "mmrm_vm_interface.h"
#include "mmrm_debug.h"
#define MMRM_CLK_CLIENTS_NUM_MAX 35
struct mmrm_vm_driver_data *drv_vm_be = (void *) -EPROBE_DEFER;
int msm_mmrm_debug = MMRM_ERR | MMRM_WARN | MMRM_PRINTK;
int mmrm_client_get_clk_count(void);
static int mmrm_vm_be_driver_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
int sz, clk_count, rc;
drv_vm_be = devm_kzalloc(dev, sizeof(*drv_vm_be), GFP_KERNEL);
if (!drv_vm_be)
return -ENOMEM;
clk_count = mmrm_client_get_clk_count();
if (clk_count <= 0 || clk_count > MMRM_CLK_CLIENTS_NUM_MAX) {
d_mpr_e("%s: clk count is not correct\n", __func__);
goto clk_count_err;
}
sz = sizeof(struct mmrm_client *) * clk_count;
drv_vm_be->clk_client_tbl = devm_kzalloc(dev, sz, GFP_KERNEL);
if (!drv_vm_be->clk_client_tbl)
goto client_tbl_err;
drv_vm_be->debugfs_root = msm_mmrm_debugfs_init();
if (!drv_vm_be->debugfs_root)
d_mpr_e("%s: failed to create debugfs for mmrm\n", __func__);
dev_set_drvdata(&pdev->dev, drv_vm_be);
rc = mmrm_vm_msgq_init(drv_vm_be);
if (rc != 0) {
d_mpr_e("%s: failed to init msgq\n", __func__);
goto msgq_init_err;
}
drv_vm_be->dev = dev;
dev_err(dev, "msgq probe success");
return 0;
msgq_init_err:
dev_set_drvdata(&pdev->dev, NULL);
msm_mmrm_debugfs_deinit(drv_vm_be->debugfs_root);
return -EINVAL;
client_tbl_err:
dev_err(dev, "msgq register alloc memory failed");
return -ENOMEM;
clk_count_err:
return -EINVAL;
}
static int mmrm_vm_be_driver_remove(struct platform_device *pdev)
{
mmrm_vm_msgq_deinit(drv_vm_be);
msm_mmrm_debugfs_deinit(drv_vm_be->debugfs_root);
dev_set_drvdata(&pdev->dev, NULL);
drv_vm_be = (void *) -EPROBE_DEFER;
return 0;
}
static const struct of_device_id mmrm_vm_be_match[] = {
{ .compatible = "qcom,mmrm-vm-be" },
{},
};
MODULE_DEVICE_TABLE(of, mmrm_vm_be_match);
static struct platform_driver mmrm_vm_be_driver = {
.probe = mmrm_vm_be_driver_probe,
.driver = {
.name = "mmrm-vm-be",
.of_match_table = mmrm_vm_be_match,
},
.remove = mmrm_vm_be_driver_remove,
};
static int __init mmrm_vm_be_module_init(void)
{
pr_info("%s: init start\n", __func__);
return platform_driver_register(&mmrm_vm_be_driver);
}
subsys_initcall(mmrm_vm_be_module_init);
static void __exit mmrm_vm_be_module_exit(void)
{
platform_driver_unregister(&mmrm_vm_be_driver);
}
module_exit(mmrm_vm_be_module_exit);
MODULE_SOFTDEP("pre: gunyah_transport");
MODULE_SOFTDEP("pre: msm-mmrm");
MODULE_DESCRIPTION("Qualcomm Technologies, Inc. MMRM BE Driver");
MODULE_LICENSE("GPL v2");

317
qcom/opensource/mmrm-driver/vm/be/src/mmrm_vm_be_msgq.c Normal file
View File

@@ -0,0 +1,317 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/gunyah/gh_msgq.h>
#include <linux/kthread.h>
#include <linux/slab.h>
#include <linux/notifier.h>
#include <linux/gunyah/gh_rm_drv.h>
#include <linux/workqueue.h>
#include <linux/list.h>
#include "mmrm_vm_be.h"
#include "mmrm_vm_interface.h"
#include "mmrm_vm_debug.h"
#define MAX_ERR_COUNT 5
int mmrm_vm_be_wrong_request(struct mmrm_vm_driver_data *mmrm_vm);
static int is_valid_mmrm_message(struct mmrm_vm_request_msg_pkt *pkt)
{
int rc = -1;
struct mmrm_vm_msg_hdr *hdr = &pkt->hdr;
if (hdr->version == MMRM_VM_VER_1 &&
hdr->type == MMRM_VM_TYPE_DATA)
rc = 0;
return rc;
}
/**
* mmrm_vm_msgq_msg_handler - fe request handler
* work: work parameter that workqueue thread transfer
*/
static void mmrm_vm_msgq_msg_handler(struct work_struct *work)
{
struct mmrm_vm_thread_info *pthread_info =
container_of(work, struct mmrm_vm_thread_info, msgq_work.work);
struct mmrm_vm_driver_data *mmrm_vm =
container_of(pthread_info, struct mmrm_vm_driver_data, thread_info);
struct mmrm_vm_msg *msg;
struct mmrm_vm_msg *next_msg;
struct list_head head;
struct mmrm_vm_request_msg_pkt *pkt;
if (IS_ERR_OR_NULL(work))
return;
mutex_lock(&pthread_info->list_lock);
list_replace_init(&pthread_info->queued_msg, &head);
mutex_unlock(&pthread_info->list_lock);
list_for_each_entry_safe(msg, next_msg, &head, link) {
pkt = (struct mmrm_vm_request_msg_pkt *)msg->msg_buf;
if (is_valid_mmrm_message(pkt) == 0)
mmrm_vm_be_recv(mmrm_vm, &pkt->msg, pkt->hdr.size);
else {
mmrm_vm_be_wrong_request(mmrm_vm);
d_mpr_e("%s: wrong mmrm message\n", __func__);
}
list_del(&msg->link);
kfree(msg);
}
}
/**
* mmrm_vm_be_msgq_listener - gunyah's message receiving thread
* data: parameter that caller transfer
*/
static int mmrm_vm_be_msgq_listener(void *data)
{
struct mmrm_vm_driver_data *mmrm_vm;
struct mmrm_vm_gh_msgq_info *pmsg_info;
struct mmrm_vm_thread_info *thread_info;
struct mmrm_vm_msg *msg;
size_t size;
int ret = 0;
int err_count = 0;
if (IS_ERR_OR_NULL(data))
return -EINVAL;
mmrm_vm = (struct mmrm_vm_driver_data *)data;
pmsg_info = &mmrm_vm->msg_info;
thread_info = &mmrm_vm->thread_info;
while (true) {
msg = kzalloc(sizeof(struct mmrm_vm_msg), GFP_KERNEL);
if (!msg)
return -ENOMEM;
ret = gh_msgq_recv(pmsg_info->msgq_handle, msg->msg_buf,
GH_MSGQ_MAX_MSG_SIZE_BYTES, &size, 0);
if (ret < 0) {
kfree(msg);
d_mpr_e("gh_msgq_recv failed, rc=%d\n", ret);
err_count++;
if (err_count < MAX_ERR_COUNT)
continue;
return -EINVAL;
}
err_count = 0;
msg->msg_size = size;
mutex_lock(&thread_info->list_lock);
list_add_tail(&msg->link, &thread_info->queued_msg);
mutex_unlock(&thread_info->list_lock);
queue_delayed_work(thread_info->msg_workq,
&thread_info->msgq_work, msecs_to_jiffies(0));
}
return 0;
}
/**
* mmrm_vm_msgq_send - send response message by gunyah API
* mmrm_vm: driver data
* msg: message buffer pointer
* msg_size: message size
*/
int mmrm_vm_msgq_send(struct mmrm_vm_driver_data *mmrm_vm, void *msg, size_t msg_size)
{
if (!mmrm_vm->msg_info.msgq_handle) {
d_mpr_e("Failed to send msg, invalid msgq handle\n");
return -EINVAL;
}
if (msg_size > GH_MSGQ_MAX_MSG_SIZE_BYTES) {
d_mpr_e("msg size unsupported for msgq: %ld > %d\n", msg_size,
GH_MSGQ_MAX_MSG_SIZE_BYTES);
return -E2BIG;
}
return gh_msgq_send(mmrm_vm->msg_info.msgq_handle, msg, msg_size, GH_MSGQ_TX_PUSH);
}
/**
* mmrm_vm_be_gh_validate_register - check gunyah connection validation
* msg_info: gunyah meesage info
* vm_status_payload: gunyah notification message status info
*/
int mmrm_vm_be_gh_validate_register(struct mmrm_vm_gh_msgq_info *msg_info,
struct gh_rm_notif_vm_status_payload *vm_status_payload)
{
gh_vmid_t peer_vmid;
gh_vmid_t self_vmid;
int rc = -1;
if (vm_status_payload->vm_status != GH_RM_VM_STATUS_READY)
return rc;
if (gh_rm_get_vmid(msg_info->peer_id, &peer_vmid))
return rc;
if (gh_rm_get_vmid(GH_PRIMARY_VM, &self_vmid))
return rc;
if (peer_vmid != vm_status_payload->vmid)
return NOTIFY_DONE;
d_mpr_l("%s: vmid=%d peer_vmid=%d\n", __func__, vm_status_payload->vmid, peer_vmid);
if (msg_info->msgq_handle) {
return rc;
}
msg_info->msgq_handle = gh_msgq_register(msg_info->msgq_label);
rc = 0;
if (IS_ERR_OR_NULL(msg_info->msgq_handle)) {
rc = -1;
d_mpr_e("%s: gunyah message queue registration failed :%ld\n", __func__,
PTR_ERR(msg_info->msgq_handle));
}
return rc;
}
/**
* mmrm_vm_be_msgq_cb - check gunyah connection validation
* nb: gunyah notofier block info
* cmd: gunyah notification status category info
* data: user defined data pointer
*/
static int mmrm_vm_be_msgq_cb(struct notifier_block *nb, unsigned long cmd, void *data)
{
struct gh_rm_notif_vm_status_payload *vm_status_payload;
struct mmrm_vm_driver_data *mmrm_vm;
struct mmrm_vm_gh_msgq_info *msg_info;
struct mmrm_vm_thread_info *thread_info;
int rc;
if (IS_ERR_OR_NULL(nb))
return -EINVAL;
msg_info = container_of(nb, struct mmrm_vm_gh_msgq_info, pvt_nb);
mmrm_vm = container_of(msg_info, struct mmrm_vm_driver_data, msg_info);
thread_info = &mmrm_vm->thread_info;
if (cmd != GH_RM_NOTIF_VM_STATUS)
return NOTIFY_DONE;
/*
* check VM status, only GH_TRUSTED_VM notification activate
* GUNYAH message queue registering
*/
vm_status_payload = (struct gh_rm_notif_vm_status_payload *)data;
rc = mmrm_vm_be_gh_validate_register(msg_info, vm_status_payload);
if (rc != 0) {
return NOTIFY_DONE;
}
d_mpr_e("%s: msgq registration successful\n", __func__);
thread_info->msgq_listener_thread = kthread_run(mmrm_vm_be_msgq_listener,
(void *)mmrm_vm, "mmrm_msgq_listener");
if (IS_ERR_OR_NULL(thread_info->msgq_listener_thread)) {
return NOTIFY_DONE;
};
wake_up_process(thread_info->msgq_listener_thread);
return NOTIFY_DONE;
}
/**
* mmrm_vm_msgq_init - gunyah message queue initialization
* mmrm_vm: driver data
*/
int mmrm_vm_msgq_init(struct mmrm_vm_driver_data *mmrm_vm)
{
struct mmrm_vm_gh_msgq_info *msg_info;
struct mmrm_vm_thread_info *thread_info;
int rc = -1;
if (IS_ERR_OR_NULL(mmrm_vm)) {
rc = -EINVAL;
d_mpr_e("%s: driver init wrong\n", __func__);
goto err;
}
msg_info = &mmrm_vm->msg_info;
thread_info = &mmrm_vm->thread_info;
msg_info->msgq_label = GH_MSGQ_LABEL_MMRM;
d_mpr_l("%s: msgq-label=%d\n", __func__, msg_info->msgq_label);
msg_info->peer_id = GH_TRUSTED_VM;
msg_info->pvt_nb.notifier_call = mmrm_vm_be_msgq_cb;
rc = gh_rm_register_notifier(&msg_info->pvt_nb);
if (rc != 0) {
d_mpr_e("%s: gunyah register notifier failed\n", __func__);
goto err;
}
msg_info->status |= MMRM_VM_MSG_STATUS_NOTIFIER;
mutex_init(&thread_info->list_lock);
INIT_LIST_HEAD(&thread_info->queued_msg);
thread_info->msg_workq = create_singlethread_workqueue("vm_message_workq");
if (IS_ERR_OR_NULL(thread_info->msg_workq)) {
d_mpr_e("%s: create workqueue thread failed\n", __func__);
goto err_workqueue;
};
INIT_DELAYED_WORK(&thread_info->msgq_work, mmrm_vm_msgq_msg_handler);
return 0;
err_workqueue:
gh_rm_unregister_notifier(&msg_info->pvt_nb);
msg_info->status &= ~MMRM_VM_MSG_STATUS_NOTIFIER;
err:
return rc;
}
/**
* mmrm_vm_msgq_init - gunyah message queue de-initialization
* mmrm_vm: driver data
*/
int mmrm_vm_msgq_deinit(struct mmrm_vm_driver_data *mmrm_vm)
{
struct mmrm_vm_gh_msgq_info *msg_info;
struct mmrm_vm_thread_info *thread_info;
int rc = 0;
if (IS_ERR_OR_NULL(mmrm_vm))
return -EINVAL;
msg_info = &mmrm_vm->msg_info;
thread_info = &mmrm_vm->thread_info;
if (thread_info->msgq_listener_thread) {
kthread_stop(thread_info->msgq_listener_thread);
thread_info->msgq_listener_thread = NULL;
}
if (msg_info->status & MMRM_VM_MSG_STATUS_NOTIFIER)
gh_rm_unregister_notifier(&msg_info->pvt_nb);
if (msg_info->msgq_handle) {
rc = gh_msgq_unregister(msg_info->msgq_handle);
if (rc != 0)
d_mpr_e("%s: msgq gunyah unregistration failed: err:%d\n", __func__, rc);
msg_info->msgq_handle = NULL;
}
if (thread_info->msg_workq) {
destroy_workqueue(thread_info->msg_workq);
thread_info->msg_workq = NULL;
}
return rc;
}

63
qcom/opensource/mmrm-driver/vm/common/inc/mmrm_vm_debug.h Normal file
View File

@@ -0,0 +1,63 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef __MMRM_VM_DEBUG__
#define __MMRM_VM_DEBUG__
#include <linux/debugfs.h>
#include <linux/printk.h>
#ifndef MMRM_VM_DBG_LABEL
#define MMRM_VM_DBG_LABEL "mmrm_vm"
#endif
#define MMRM_VM_DBG_TAG MMRM_VM_DBG_LABEL ": %4s: "
/* To enable messages OR these values and
* echo the result to debugfs file.
*/
enum mmrm_msg_prio {
MMRM_VM_ERR = 0x000001,
MMRM_VM_HIGH = 0x000002,
MMRM_VM_LOW = 0x000004,
MMRM_VM_WARN = 0x000008,
MMRM_VM_PRINTK = 0x010000,
};
extern int mmrm_vm_debug;
#define dprintk(__level, __fmt, ...) \
do { \
if (mmrm_vm_debug & __level) { \
if (mmrm_vm_debug & MMRM_VM_PRINTK) { \
pr_info(MMRM_VM_DBG_TAG __fmt, \
get_debug_level_str(__level), \
##__VA_ARGS__); \
} \
} \
} while (0)
#define d_mpr_e(__fmt, ...) dprintk(MMRM_VM_ERR, __fmt, ##__VA_ARGS__)
#define d_mpr_h(__fmt, ...) dprintk(MMRM_VM_HIGH, __fmt, ##__VA_ARGS__)
#define d_mpr_l(__fmt, ...) dprintk(MMRM_VM_LOW, __fmt, ##__VA_ARGS__)
#define d_mpr_w(__fmt, ...) dprintk(MMRM_VM_WARN, __fmt, ##__VA_ARGS__)
static inline char *get_debug_level_str(int level)
{
switch (level) {
case MMRM_VM_ERR:
return "err ";
case MMRM_VM_HIGH:
return "high";
case MMRM_VM_LOW:
return "low ";
case MMRM_VM_WARN:
return "warn";
default:
return "????";
}
}
#endif /* __MMRM_VM_DEBUG__ */

246
qcom/opensource/mmrm-driver/vm/common/inc/mmrm_vm_interface.h Normal file
View File

@@ -0,0 +1,246 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef __MMRM_VM_INTERNAL_H__
#define __MMRM_VM_INTERNAL_H__
#include <linux/mutex.h>
#include <linux/soc/qcom/msm_mmrm.h>
#include <mmrm_vm_msgq.h>
/**
* mmrm_vm_thread_info - message listener & workqueue info
* @msgq_listener_thread: handle to msgq listener thread that is used
* to receive/send messages through gunyah interface
* @msg_workq: message workqueue pointer
* @msgq_work: message work, worker thread to process the messages
* @queued_msg: message queue head
*/
struct mmrm_vm_thread_info {
struct task_struct *msgq_listener_thread;
struct workqueue_struct *msg_workq;
struct delayed_work msgq_work;
struct mutex list_lock;
struct list_head queued_msg;
};
/**
* struct mmrm_vm_data_priv -- device driver private part
* @dev: device pointer
* @msg_info: gunyah message info
* @thread_info: message lister & workqueue info
* @clk_client_tbl: index and client handler LUT
* @debugfs_root: debug fs, /sys/kernel/debug
* @vm_pvt_data: pointer to fe/be specific data
*/
struct mmrm_vm_driver_data {
struct device *dev;
struct mmrm_vm_gh_msgq_info msg_info;
struct mmrm_vm_thread_info thread_info;
struct mmrm_client **clk_client_tbl;
/* debugfs */
struct dentry *debugfs_root;
void *vm_pvt_data;
};
/**
* enum mmrm_vm_api_msg_id -- request/response cmd ID
*/
enum mmrm_vm_api_msg_id {
MMRM_VM_REQUEST_REGISTER = 1,
MMRM_VM_REQUEST_SETVALUE,
MMRM_VM_REQUEST_SETVALUE_INRANGE,
MMRM_VM_REQUEST_GETVALUE,
MMRM_VM_REQUEST_DEREGISTER,
MMRM_VM_REQUEST_NOOP, // this is for debug purpose,calculating msgq roundtrip time
MMRM_VM_RESPONSE_REGISTER = MMRM_VM_REQUEST_REGISTER | 0x800,
MMRM_VM_RESPONSE_SETVALUE,
MMRM_VM_RESPONSE_SETVALUE_INRANGE,
MMRM_VM_RESPONSE_GETVALUE,
MMRM_VM_RESPONSE_DEREGISTER,
MMRM_VM_RESPONSE_NOOP, // this is for debug purpose,calculating msgq roundtrip time
MMRM_VM_RESPONSE_INVALID_PKT,
};
/**
* struct msg_head -- message head
* @cmd_id: mmrm API message cmd id
* @seq_no: message sequence id
*/
struct mmrm_vm_api_msg_head {
enum mmrm_vm_api_msg_id cmd_id;
int seq_no;
};
/**
* struct register_request -- mmrm register parameters
* @client_type: client type, definition see msm_mmrm.h
* @priority: client priority, definition see msm_mmrm.h
* @desc: client description, definition see msm_mmrm.h
*/
struct mmrm_vm_register_request {
enum mmrm_client_type client_type;
enum mmrm_client_priority priority;
struct mmrm_clk_client_desc desc;
};
/**
* struct deregister_request -- mmrm deregister parameters
* @client: client registered handle
*/
struct mmrm_vm_deregister_request {
u32 client_id;
};
/**
* struct mmrm_vm_noop_request -- noop request parameters
* @client: 32 bits value transfered
*/
struct mmrm_vm_noop_request {
u32 client_id;
};
/**
* struct setvalue_request -- mmrm setvalue parameters
* @client: client type, definition see msm_mmrm.h
* @data: client info, definition see msm_mmrm.h
* @val: new clock rate value
*/
struct mmrm_vm_setvalue_request {
u32 client_id;
struct mmrm_client_data data;
unsigned long val;
};
/**
* struct mmrm_vm_setvalue_inrange_request -- mmrm setvalue_inrange parameters
* @client: client type, definition see msm_mmrm.h
* @data: client info, definition see msm_mmrm.h
* @val: new clock rate value range, definition see msm_mmrm.h
*/
struct mmrm_vm_setvalue_inrange_request {
u32 client_id;
struct mmrm_client_data data;
struct mmrm_client_res_value val;
};
/**
* struct mmrm_vm_getvalue_request -- mmrm getvalue parameters
* @client: client type, definition see msm_mmrm.h
* @val: current clock rate value range, definition see msm_mmrm.h
*/
struct mmrm_vm_getvalue_request {
u32 client_id;
};
/**
* struct mmrm_vm_api_request_msg -- mmrm request API message unified data definition
* @hd: mmrm API request message head
* @data: parameters mmrm API needs per API message cmd id
*/
struct mmrm_vm_api_request_msg {
struct mmrm_vm_api_msg_head hd;
union {
struct mmrm_vm_register_request reg;
struct mmrm_vm_deregister_request dereg;
struct mmrm_vm_setvalue_request setval;
struct mmrm_vm_setvalue_inrange_request setval_range;
struct mmrm_vm_getvalue_request getval;
struct mmrm_vm_noop_request lptest;
} data;
};
/**
* struct mmrm_vm_register_response -- mmrm_client_register API response message
* @client: handle for registered client
*/
struct mmrm_vm_register_response {
u32 client_id;
};
/**
* struct mmrm_vm_deregister_response -- mmrm_client_deregister API response message
* @ret_code: indicates if the mmrm_client_deregister is successful
*/
struct mmrm_vm_deregister_response {
int ret_code;
};
/**
* struct mmrm_vm_noop_response -- noop request's response message
* @ret_code: return inetger
*/
struct mmrm_vm_noop_response {
int ret_code;
};
/**
* struct mmrm_vm_setvalue_response -- mmrm_client_set_value API response message
* @val: value that mmrm_client_set_value return
*/
struct mmrm_vm_setvalue_response {
unsigned long val;
};
/**
* struct mmrm_vm_setvalue_inrange_response -- mmrm_client_set_value_in_range API response message
* @ret_code: value that mmrm_client_set_value_in_range return
*/
struct mmrm_vm_setvalue_inrange_response {
int ret_code;
};
/**
* struct mmrm_vm_getvalue_response -- mmrm_client_get_value API response message
* @val: value that mmrm_client_get_value return
*/
struct mmrm_vm_getvalue_response {
struct mmrm_client_res_value val;
};
/**
* struct mmrm_vm_api_response_msg -- mmrm response message unified data
* @hd: mmrm API response message head
* @data: data that mmrm API return per API response message id
*/
struct mmrm_vm_api_response_msg {
struct mmrm_vm_api_msg_head hd;
union {
struct mmrm_vm_register_response reg;
struct mmrm_vm_deregister_response dereg;
struct mmrm_vm_setvalue_response setval;
struct mmrm_vm_setvalue_inrange_response setval_range;
struct mmrm_vm_getvalue_response getval;
struct mmrm_vm_noop_response lptest;
} data;
};
/**
* struct mmrm_vm_request_msg_pkt -- mmrm request packet that is sent through gunyah API
* @hdr: message head for checking message valid
* @msg: data that is needed by mmrm API
*/
struct mmrm_vm_request_msg_pkt {
struct mmrm_vm_msg_hdr hdr;
struct mmrm_vm_api_request_msg msg;
u64 start_time_ns;
};
/**
* struct mmrm_vm_response_msg_pkt -- mmrm response packet that is sent through gunyah API
* @hdr: message head for checking message valid
* @msg: data that is returned by mmrm API
*/
struct mmrm_vm_response_msg_pkt {
struct mmrm_vm_msg_hdr hdr;
struct mmrm_vm_api_response_msg msg;
};
#endif /* __MMRM_VM_INTERNAL_H__ */

104
qcom/opensource/mmrm-driver/vm/common/inc/mmrm_vm_msgq.h Normal file
View File

@@ -0,0 +1,104 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef __MMRM_VM_MSGQ_H__
#define __MMRM_VM_MSGQ_H__
#include <linux/gunyah/gh_msgq.h>
#define MMRM_VM_VER_1 1 // mmrm version, for message valid check
#define MMRM_VM_MAX_PKT_SZ 1024 // mmrm max gunyah packet size
#define MMRM_VM_MSG_STATUS_NOTIFIER 0x01
/**
* mmrm_vm_pkt_type: mmrm transfer type, for message valid check
* @MMRM_VM_TYPE_DATA: request/response data
*/
enum mmrm_vm_pkt_type {
MMRM_VM_TYPE_DATA = 1,
};
struct mmrm_vm_driver_data;
/**
* struct mmrm_vm_msg_hdr - mmrm vm packet header
* @version: protocol version
* @type: packet type; one of MMRM_VM_TYPE_* in mmrm_vm_pkt_type
* @flags: Reserved for future use
* @size: length of packet, excluding this header
*/
struct mmrm_vm_msg_hdr {
u8 version;
u8 type;
u8 flags;
u8 resv;
u32 size;
};
/**
* mmrm_vm_msg - message that be received.
* @link - list head
* @msg_size - message size
* @msg_buf - message buffer
*/
struct mmrm_vm_msg {
struct list_head link;
size_t msg_size;
u8 msg_buf[GH_MSGQ_MAX_MSG_SIZE_BYTES];
};
/**
* mmrm_vm_msgq_info - gunyah info.
* @peer_id: notification callback check if message is from SVM
* @msgq_handle - registered msg queue handle with gunyah api
* @msgq_label - message queue label
* @status: indicate init status
* @pvt_nb - notifier info
*/
struct mmrm_vm_gh_msgq_info {
int peer_id;
void *msgq_handle;
int msgq_label;
int status;
struct notifier_block pvt_nb;
};
/**
* struct mmrm_vm_msg_q -- svm mmrm API caller queue that wait for mmrm API return
* @link: list head
* @m_req: request message pointer
* @m_resp: response message buffer pointer
* @complete: sync mmrm API response and caller
*/
struct mmrm_vm_msg_q {
struct list_head link;
struct mmrm_vm_request_msg_pkt *m_req;
struct mmrm_vm_response_msg_pkt *m_resp;
struct completion complete;
};
/**
* mmrm_vm_msgq_init - initialize display message queue: both TX and RX
* @mmrm_vm - handle to mmrm_vm_data_priv
*/
int mmrm_vm_msgq_init(struct mmrm_vm_driver_data *mmrm_vm);
/**
* mmrm_vm_msgq_deinit - deinitialize display message queue: both TX and RX
* @mmrm_vm - handle to mmrm_vm_data_priv
*/
int mmrm_vm_msgq_deinit(struct mmrm_vm_driver_data *mmrm_vm);
/**
* mmrm_vm_msgq_send - send custom messages across VM's
* @mmrm_vm - handle to mmrm_vm_data_priv
* @msg - payload data
* @msg_size - size of the payload_data
*/
int mmrm_vm_msgq_send(struct mmrm_vm_driver_data *mmrm_vm, void *msg, size_t msg_size);
#endif // __MMRM_VM_MSGQ_H__

44
qcom/opensource/mmrm-driver/vm/common/src/mmrm_vm_debug.c Normal file
View File

@@ -0,0 +1,44 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/slab.h>
#include "mmrm_vm_debug.h"
int mmrm_vm_debug = MMRM_VM_ERR | MMRM_VM_WARN | MMRM_VM_PRINTK;
/**
* msm_mmrm_debugfs_init - init debug sys entry
*/
struct dentry *msm_mmrm_debugfs_init(void)
{
struct dentry *dir;
/* create a directory in debugfs root (/sys/kernel/debug) */
dir = debugfs_create_dir("mmrm_vm", NULL);
if (IS_ERR_OR_NULL(dir)) {
d_mpr_e("%s: Call to debugfs_create_dir(%s) failed!\n", __func__, "mmrm");
goto failed_create_dir;
}
/* add other params here */
debugfs_create_u32("debug_level", 0644, dir, &mmrm_vm_debug);
return dir;
failed_create_dir:
d_mpr_e("%s: error\n", __func__);
return NULL;
}
/**
* msm_mmrm_debugfs_deinit - de-init debug sys entry
* dir: directory in debugfs root
*/
void msm_mmrm_debugfs_deinit(struct dentry *dir)
{
debugfs_remove_recursive(dir);
}

15
qcom/opensource/mmrm-driver/vm/fe/Kbuild Normal file
View File

@@ -0,0 +1,15 @@
ifeq ($(CONFIG_MSM_MMRM_VM), y)
obj-m += mmrm_vm_fe.o
ifeq ($(CONFIG_ARCH_KALAMA), y)
ifeq ($(CONFIG_ARCH_QTI_VM), y)
mmrm_vm_fe-objs := \
src/mmrm_vm_fe_main.o \
src/mmrm_vm_fe_frontend.o \
src/mmrm_vm_fe_msgq.o \
src/mmrm_vm_fe_api.o \
../common/src/mmrm_vm_debug.o
endif
endif
endif

16
qcom/opensource/mmrm-driver/vm/fe/src/Makefile.am Normal file
View File

@@ -0,0 +1,16 @@
KBUILD_OPTIONS+= MMRM_ROOT=$(KERNEL_SRC)/$(M)
all: modules
modules:
$(MAKE) -C $(KERNEL_SRC) M=$(M) modules $(KBUILD_OPTIONS)
modules_install:
$(MAKE) INSTALL_MOD_STRIP=1 -C $(KERNEL_SRC) M=$(M) modules_install
%:
$(MAKE) -C $(KERNEL_SRC) M=$(M) $@ $(KBUILD_OPTIONS)
clean:
rm -f *.o *.ko *.mod.c *.mod.o *~ .*.cmd Module.symvers
rm -rf .tmp_versions

121
qcom/opensource/mmrm-driver/vm/fe/src/mmrm_vm_fe.h Normal file
View File

@@ -0,0 +1,121 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef __MMRM_VM_FE_H__
#define __MMRM_VM_FE_H__
#include <mmrm_vm_msgq.h>
#include <mmrm_vm_interface.h>
#define MMRM_SYSFS_ENTRY_MAX_LEN PAGE_SIZE
struct mmrm_vm_fe_clk_client_desc {
u32 client_domain;
u32 client_id;
u32 num_hw_blocks;
};
struct mmrm_vm_fe_clk_src_set {
struct mmrm_vm_fe_clk_client_desc *clk_src_tbl;
u32 count;
};
struct mmrm_vm_fe_msgq_rt_stats {
u64 register_total_us;
u64 looptest_total_us;
u32 count;
};
struct mmrm_vm_fe_priv {
struct device *dev;
struct mmrm_client *client_tbl;
struct list_head resp_works;
struct mutex resp_works_lock;
struct mmrm_vm_fe_clk_src_set clk_src_set;
struct mutex msg_send_lock;
int seq_no;
bool is_clk_scaling_supported;
struct mmrm_vm_fe_msgq_rt_stats msgq_rt_stats;
};
struct mmrm_vm_fe_pkt {
struct mmrm_vm_msg_q msgq;
struct mmrm_vm_request_msg_pkt req_pkt;
struct mmrm_vm_response_msg_pkt resp_pkt;
};
/*
* mmrm_vm_fe_recv_cb -- FE message receiving thread call this function
* for transfer receiving packet to FE
* @mmrm_vm: specific device driver info
* @data: message pointer
* @size: message size
*/
void mmrm_vm_fe_recv_cb(struct mmrm_vm_driver_data *mmrm_vm, void *data, size_t size);
/*
* mmrm_vm_fe_request_send -- FE send mmrm request message
* @mmrm_vm: device data, includes message handle
* @msg_pkt: request message pointer
* @msg_size: message size
*/
int mmrm_vm_fe_request_send(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_request_msg_pkt *msg_pkt, size_t msg_size);
/*
* get_client_id_2_handle -- get handle from client ID
* @client_id: client ID
*/
struct mmrm_client *mmrm_vm_fe_get_client(u32 client_id);
/*
* load_clk_resource_info -- get clk resource info from DT
* @drv_priv: device data
*/
int mmrm_vm_fe_load_clk_rsrc(struct mmrm_vm_driver_data *drv_priv);
/*
* mmrm_vm_fe_clk_src_check -- check if fe support the clk src
* @desc: clk src description
*/
struct mmrm_vm_fe_clk_client_desc *mmrm_vm_fe_clk_src_get(struct mmrm_client_desc *desc);
/*
* init_lookup_table -- init et clk lookup table
* @mmrm_vm: device data
*/
int mmrm_vm_fe_init_lookup_table(struct mmrm_vm_driver_data *mmrm_vm);
/*
* mmrm_vm_fe_clk_print_info -- output clk info through sys
* @clk_src_set: clk info
* @buf: received output buffer
* @max_len: buffer length
*/
int mmrm_vm_fe_clk_print_info(
struct mmrm_vm_fe_clk_src_set *clk_src_set,
char *buf, int max_len);
/*
* mmrm_vm_fe_recv -- process received response info
* @mmrm_vm: device data
* @data: received response info buffer
* @size: message size
*/
void mmrm_vm_fe_recv(struct mmrm_vm_driver_data *mmrm_vm, void *data, size_t size);
/*
* mmrm_vm_fe_count_clk_clients_frm_dt -- process received response info
* @pdev: platform device
*/
int mmrm_vm_fe_count_clk_clients_frm_dt(struct platform_device *pdev);
#endif /* __MMRM_VM_FE_H__ */

320
qcom/opensource/mmrm-driver/vm/fe/src/mmrm_vm_fe_api.c Normal file
View File

@@ -0,0 +1,320 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/gunyah/gh_msgq.h>
#include <linux/gunyah/gh_rm_drv.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/sysfs.h>
#include <linux/pm.h>
#include <linux/suspend.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/ktime.h>
#include "mmrm_vm_fe.h"
#include "mmrm_vm_interface.h"
#include "mmrm_vm_msgq.h"
#include "mmrm_vm_debug.h"
#define get_client_handle_2_id(client) (client->client_uid)
extern struct mmrm_vm_driver_data *drv_vm_fe;
#define MAX_TIMEOUT_MS 300
#define CHECK_SKIP_MMRM_CLK_RSRC(drv_data) \
{ \
if (!drv_data->is_clk_scaling_supported) { \
d_mpr_h("%s: mmrm clk rsrc not supported\n", __func__);\
goto skip_mmrm; \
} \
}
int mmrm_fe_append_work_list(struct mmrm_vm_msg_q *msg_q, int msg_sz)
{
struct mmrm_vm_request_msg_pkt *msg_pkt = msg_q->m_req;
struct mmrm_vm_fe_priv *fe_data = drv_vm_fe->vm_pvt_data;
unsigned long waited_time_ms;
init_completion(&msg_q->complete);
mutex_lock(&fe_data->resp_works_lock);
list_add_tail(&msg_q->link, &fe_data->resp_works);
mutex_unlock(&fe_data->resp_works_lock);
mutex_lock(&fe_data->msg_send_lock);
msg_pkt->msg.hd.seq_no = fe_data->seq_no++;
mutex_unlock(&fe_data->msg_send_lock);
d_mpr_w("%s: seq no:%d\n", __func__, msg_pkt->msg.hd.seq_no);
msg_pkt->start_time_ns = ktime_get_ns();
mmrm_vm_fe_request_send(drv_vm_fe, msg_pkt, msg_sz);
waited_time_ms = wait_for_completion_timeout(&msg_q->complete,
msecs_to_jiffies(MAX_TIMEOUT_MS));
if (waited_time_ms >= MAX_TIMEOUT_MS) {
d_mpr_e("%s: request send timeout\n", __func__);
return -1;
}
return 0;
}
struct mmrm_vm_msg_q *get_msg_work(void)
{
struct mmrm_vm_msg_q *msg_q;
struct mmrm_vm_fe_pkt *data;
data = kzalloc(sizeof(struct mmrm_vm_fe_pkt), GFP_KERNEL);
if (data == NULL)
goto err_mem_fail;
msg_q = &data->msgq;
msg_q->m_req = &data->req_pkt;
msg_q->m_resp = &data->resp_pkt;
return msg_q;
err_mem_fail:
d_mpr_e("%s: failed to alloc msg buffer\n", __func__);
return NULL;
}
void release_msg_work(struct mmrm_vm_msg_q *msg_q)
{
struct mmrm_vm_fe_pkt *data;
if (msg_q == NULL) {
d_mpr_e("%s: release null msg ptr\n", __func__);
return;
}
data = container_of(msg_q, struct mmrm_vm_fe_pkt, msgq);
kfree(data);
}
struct mmrm_client *mmrm_client_register(struct mmrm_client_desc *desc)
{
struct mmrm_vm_msg_q *msg_q;
struct mmrm_vm_api_request_msg *api_msg;
struct mmrm_vm_register_request *reg_data;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
int rc = 0;
struct mmrm_client *client = NULL;
if (mmrm_vm_fe_clk_src_get(desc) == NULL) {
d_mpr_e("%s: FE doesn't support clk domain=%d client id=%d\n", __func__,
desc->client_info.desc.client_domain, desc->client_info.desc.client_id);
goto err_clk_src;
}
msg_q = get_msg_work();
if (msg_q == NULL) {
d_mpr_e("%s: failed to alloc msg buf\n", __func__);
goto err_no_mem;
}
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.reg;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_REGISTER;
reg_data->client_type = desc->client_type;
reg_data->priority = desc->priority;
memcpy(&reg_data->desc, &desc->client_info.desc, sizeof(reg_data->desc));
rc = mmrm_fe_append_work_list(msg_q, msg_size);
if (rc == 0) {
client = mmrm_vm_fe_get_client(msg_q->m_resp->msg.data.reg.client_id);
};
release_msg_work(msg_q);
err_no_mem:
err_clk_src:
return client;
}
EXPORT_SYMBOL(mmrm_client_register);
int mmrm_client_deregister(struct mmrm_client *client)
{
int rc = -1;
struct mmrm_vm_api_request_msg *api_msg;
struct mmrm_vm_deregister_request *reg_data;
struct mmrm_vm_msg_q *msg_q;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
msg_q = get_msg_work();
if (msg_q == NULL) {
d_mpr_e("%s: failed to alloc msg buf\n", __func__);
goto err_no_mem;
}
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.dereg;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_DEREGISTER;
reg_data->client_id = get_client_handle_2_id(client);
rc = mmrm_fe_append_work_list(msg_q, msg_size);
if (rc == 0)
rc = msg_q->m_resp->msg.data.dereg.ret_code;
release_msg_work(msg_q);
err_no_mem:
return rc;
}
EXPORT_SYMBOL(mmrm_client_deregister);
int mmrm_client_set_value(struct mmrm_client *client,
struct mmrm_client_data *client_data, unsigned long val)
{
int rc = -1;
struct mmrm_vm_api_request_msg *api_msg;
struct mmrm_vm_setvalue_request *reg_data;
struct mmrm_vm_msg_q *msg_q;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
msg_q = get_msg_work();
if (msg_q == NULL) {
d_mpr_e("%s: failed to alloc msg buf\n", __func__);
goto err_no_mem;
}
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.setval;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_SETVALUE;
reg_data->client_id = get_client_handle_2_id(client);
reg_data->data.flags = client_data->flags;
reg_data->data.num_hw_blocks = client_data->num_hw_blocks;
reg_data->val = val;
rc = mmrm_fe_append_work_list(msg_q, msg_size);
if (rc != 0)
return rc;
rc = msg_q->m_resp->msg.data.setval.val;
d_mpr_h("%s: done rc=%d\n", __func__, rc);
err_no_mem:
return rc;
}
EXPORT_SYMBOL(mmrm_client_set_value);
int mmrm_client_set_value_in_range(struct mmrm_client *client,
struct mmrm_client_data *client_data,
struct mmrm_client_res_value *val)
{
int rc = -1;
struct mmrm_vm_api_request_msg *api_msg ;
struct mmrm_vm_setvalue_inrange_request *reg_data;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
struct mmrm_vm_msg_q *msg_q;
msg_q = get_msg_work();
if (msg_q == NULL) {
d_mpr_e("%s: failed to alloc msg buf\n", __func__);
goto err_no_mem;
}
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.setval_range;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_SETVALUE_INRANGE;
reg_data->client_id = get_client_handle_2_id(client);
reg_data->data.flags = client_data->flags;
reg_data->data.num_hw_blocks = client_data->num_hw_blocks;
reg_data->val.cur = val->cur;
reg_data->val.max = val->max;
reg_data->val.min = val->min;
rc = mmrm_fe_append_work_list(msg_q, msg_size);
err_no_mem:
return rc;
}
EXPORT_SYMBOL(mmrm_client_set_value_in_range);
int mmrm_client_get_value(struct mmrm_client *client,
struct mmrm_client_res_value *val)
{
int rc = -1;
struct mmrm_vm_api_request_msg *api_msg;
struct mmrm_vm_getvalue_request *reg_data;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
struct mmrm_vm_msg_q *msg_q;
msg_q = get_msg_work();
if (msg_q == NULL) {
d_mpr_e("%s: failed to alloc msg buf\n", __func__);
goto err_no_mem;
}
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.getval;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_GETVALUE;
reg_data->client_id = get_client_handle_2_id(client);
rc = mmrm_fe_append_work_list(msg_q, msg_size);
if (rc == 0) {
val->cur = msg_q->m_resp->msg.data.getval.val.cur;
val->max = msg_q->m_resp->msg.data.getval.val.max;
val->min = msg_q->m_resp->msg.data.getval.val.min;
}
err_no_mem:
return rc;
}
EXPORT_SYMBOL(mmrm_client_get_value);
bool mmrm_client_check_scaling_supported(enum mmrm_client_type client_type, u32 client_domain)
{
struct mmrm_vm_fe_priv *fe_data;
if (drv_vm_fe == (void *)-EPROBE_DEFER) {
d_mpr_e("%s: mmrm probe_init not done\n", __func__);
goto err_exit;
}
fe_data = drv_vm_fe->vm_pvt_data;
if (client_type == MMRM_CLIENT_CLOCK) {
CHECK_SKIP_MMRM_CLK_RSRC(fe_data);
}
return true;
err_exit:
d_mpr_e("%s: error exit\n", __func__);
skip_mmrm:
return false;
}
EXPORT_SYMBOL(mmrm_client_check_scaling_supported);
int mmrm_client_msgq_roundtrip_measure(u32 val)
{
int rc = 0;
struct mmrm_vm_api_request_msg *api_msg;
struct mmrm_vm_noop_request *reg_data;
struct mmrm_vm_msg_q *msg_q;
size_t msg_size = sizeof(api_msg->hd) + sizeof(*reg_data);
msg_q = get_msg_work();
api_msg = &msg_q->m_req->msg;
reg_data = &api_msg->data.lptest;
api_msg->hd.cmd_id = MMRM_VM_REQUEST_NOOP;
reg_data->client_id = val;
rc = mmrm_fe_append_work_list(msg_q, msg_size);
release_msg_work(msg_q);
return rc;
}

263
qcom/opensource/mmrm-driver/vm/fe/src/mmrm_vm_fe_frontend.c Normal file
View File

@@ -0,0 +1,263 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/of.h>
#include <linux/limits.h>
#include <linux/timekeeping.h>
#include "mmrm_vm_fe.h"
#include "mmrm_vm_interface.h"
#include "mmrm_vm_msgq.h"
#include "mmrm_vm_debug.h"
extern struct mmrm_vm_driver_data *drv_vm_fe;
void mmrm_vm_fe_recv(struct mmrm_vm_driver_data *mmrm_vm, void *data, size_t size)
{
struct mmrm_vm_api_response_msg *msg = data;
struct mmrm_vm_msg_q *node, *temp;
int rc = -1;
u64 kt2, interval;
struct mmrm_vm_fe_priv *fe_data = mmrm_vm->vm_pvt_data;
mutex_lock(&fe_data->resp_works_lock);
list_for_each_entry_safe(node, temp, &fe_data->resp_works, link) {
if (msg->hd.seq_no == node->m_req->msg.hd.seq_no) {
d_mpr_w("%s: seq no:%d\n", __func__, msg->hd.seq_no);
list_del(&node->link);
rc = 0;
break;
}
}
mutex_unlock(&fe_data->resp_works_lock);
if (rc != 0) {
d_mpr_e("%s: seq no:%d wrong\n", __func__, msg->hd.seq_no);
return;
}
d_mpr_w("%s: cmd:%d\n", __func__, msg->hd.cmd_id);
switch (msg->hd.cmd_id) {
case MMRM_VM_RESPONSE_REGISTER:
node->m_resp->msg.data.reg.client_id = msg->data.reg.client_id;
d_mpr_w("%s: client_id:%u\n", __func__, msg->data.reg.client_id);
break;
case MMRM_VM_RESPONSE_SETVALUE:
node->m_resp->msg.data.setval.val = msg->data.setval.val;
break;
case MMRM_VM_RESPONSE_SETVALUE_INRANGE:
node->m_resp->msg.data.setval_range.ret_code = msg->data.setval_range.ret_code;
break;
case MMRM_VM_RESPONSE_GETVALUE:
node->m_resp->msg.data.getval.val = msg->data.getval.val;
break;
case MMRM_VM_RESPONSE_DEREGISTER:
node->m_resp->msg.data.dereg.ret_code = msg->data.dereg.ret_code;
break;
case MMRM_VM_RESPONSE_NOOP:
kt2 = ktime_get_ns();
interval = kt2 - node->m_req->start_time_ns;
d_mpr_w("%s: looptest start:%lu end:%lu interval:%luns\n",
__func__,
node->m_req->start_time_ns, kt2,
interval);
fe_data->msgq_rt_stats.looptest_total_us += interval;
break;
case MMRM_VM_RESPONSE_INVALID_PKT:
d_mpr_e("%s: invalid request code\n");
break;
default:
d_mpr_e("wrong response\n");
break;
};
complete(&node->complete);
}
int mmrm_vm_fe_request_send(struct mmrm_vm_driver_data *mmrm_vm,
struct mmrm_vm_request_msg_pkt *msg_pkt, size_t msg_size)
{
int rc;
struct mmrm_vm_msg_hdr *hdr;
struct mmrm_vm_gh_msgq_info *pmsg_info = &mmrm_vm->msg_info;
hdr = (struct mmrm_vm_msg_hdr *)&msg_pkt->hdr;
hdr->version = MMRM_VM_VER_1;
hdr->type = MMRM_VM_TYPE_DATA;
hdr->flags = 0;
hdr->size = msg_size;
if (!pmsg_info->msgq_handle) {
d_mpr_e("Failed to send msg, invalid msgq handle\n");
return -EINVAL;
}
if (msg_size > GH_MSGQ_MAX_MSG_SIZE_BYTES) {
d_mpr_e("msg size unsupported for msgq: %ld > %d\n", msg_size,
GH_MSGQ_MAX_MSG_SIZE_BYTES);
return -E2BIG;
}
rc = gh_msgq_send(pmsg_info->msgq_handle, msg_pkt,
msg_size + sizeof(msg_pkt->hdr), GH_MSGQ_TX_PUSH);
return rc;
}
int mmrm_vm_fe_count_clk_clients_frm_dt(struct platform_device *pdev)
{
u32 size_clk_src = 0, num_clk_src = 0;
of_find_property(pdev->dev.of_node, "mmrm-client-info", &size_clk_src);
num_clk_src = size_clk_src / sizeof(struct mmrm_vm_fe_clk_client_desc);
d_mpr_h("%s: found %d clk_srcs size %d\n",
__func__, num_clk_src, size_clk_src);
return num_clk_src;
}
int mmrm_vm_fe_load_clk_rsrc(struct mmrm_vm_driver_data *mmrm_vm)
{
int rc = 0, num_clk_src = 0;
int c = 0, size_clk_src = 0, entry_offset = 3;
struct platform_device *pdev;
struct mmrm_vm_fe_clk_client_desc *pclk_src;
struct mmrm_vm_fe_priv *fe_data = mmrm_vm->vm_pvt_data;
pdev = container_of(fe_data->dev, struct platform_device, dev);
of_find_property(pdev->dev.of_node, "mmrm-client-info", &size_clk_src);
if ((size_clk_src < sizeof(*fe_data->clk_src_set.clk_src_tbl)) ||
(size_clk_src % sizeof(*fe_data->clk_src_set.clk_src_tbl))) {
d_mpr_e("%s: invalid size(%d) of clk src table\n",
__func__, size_clk_src);
fe_data->clk_src_set.count = 0;
goto err_load_clk_src_tbl;
}
fe_data->clk_src_set.clk_src_tbl = devm_kzalloc(&pdev->dev,
size_clk_src, GFP_KERNEL);
if (!fe_data->clk_src_set.clk_src_tbl) {
d_mpr_e("%s: failed to allocate memory for clk_src_tbl\n",
__func__);
rc = -ENOMEM;
goto err_load_clk_src_tbl;
}
num_clk_src = size_clk_src / sizeof(struct mmrm_vm_fe_clk_client_desc);
fe_data->clk_src_set.count = num_clk_src;
d_mpr_w("%s: found %d clk_srcs size %d\n",
__func__, num_clk_src, size_clk_src);
for (c = 0; c < num_clk_src; c++) {
pclk_src = &fe_data->clk_src_set.clk_src_tbl[c];
of_property_read_u32_index(pdev->dev.of_node,
"mmrm-client-info", (c*entry_offset),
&pclk_src->client_domain);
of_property_read_u32_index(pdev->dev.of_node,
"mmrm-client-info", (c*entry_offset+1),
&pclk_src->client_id);
of_property_read_u32_index(pdev->dev.of_node,
"mmrm-client-info", (c*entry_offset+2),
&pclk_src->num_hw_blocks);
}
return 0;
err_load_clk_src_tbl:
return rc;
}
struct mmrm_vm_fe_clk_client_desc *mmrm_vm_fe_clk_src_get(struct mmrm_client_desc *desc)
{
struct mmrm_vm_fe_priv *fe_data = drv_vm_fe->vm_pvt_data;
int num_clk_src = fe_data->clk_src_set.count;
struct mmrm_vm_fe_clk_client_desc *pclk_src;
int i;
d_mpr_l("%s: num clk src=%d domain:%d id:%d\n", __func__, num_clk_src,
desc->client_info.desc.client_domain, desc->client_info.desc.client_id);
pclk_src = fe_data->clk_src_set.clk_src_tbl;
for (i = 0; i < num_clk_src; i++, pclk_src++) {
if (pclk_src->client_domain == desc->client_info.desc.client_domain ||
pclk_src->client_id == desc->client_info.desc.client_id) {
return pclk_src;
}
}
return NULL;
}
int mmrm_vm_fe_init_lookup_table(struct mmrm_vm_driver_data *mmrm_vm)
{
int i, rc = -1;
struct platform_device *pdev;
struct mmrm_vm_fe_priv *fe_data = mmrm_vm->vm_pvt_data;
pdev = container_of(fe_data->dev, struct platform_device, dev);
fe_data->client_tbl = devm_kzalloc(&pdev->dev,
fe_data->clk_src_set.count * sizeof(struct mmrm_client), GFP_KERNEL);
if (!fe_data->client_tbl)
return rc;
for (i = 0; i < fe_data->clk_src_set.count; i++) {
fe_data->client_tbl[i].client_type = 0;
fe_data->client_tbl[i].client_uid = U32_MAX;
}
return 0;
}
int mmrm_vm_fe_clk_print_info(
struct mmrm_vm_fe_clk_src_set *clk_src_set,
char *buf, int max_len)
{
int left_spaces = max_len;
int len, c;
struct mmrm_vm_fe_clk_client_desc *pclk_src;
int num_clk_src = clk_src_set->count;
len = scnprintf(buf, left_spaces, "Domain ID Num\n");
left_spaces -= len;
buf += len;
pclk_src = clk_src_set->clk_src_tbl;
for (c = 0; c < num_clk_src; c++, pclk_src++) {
len = scnprintf(buf, left_spaces, "%d\t%d\t%d\n",
pclk_src->client_domain, pclk_src->client_id, pclk_src->num_hw_blocks);
left_spaces -= len;
buf += len;
}
return max_len - left_spaces;
}
struct mmrm_client *mmrm_vm_fe_get_client(u32 client_id)
{
int i;
struct mmrm_client *ptr;
struct mmrm_vm_fe_priv *fe_data = drv_vm_fe->vm_pvt_data;
if (client_id == U32_MAX)
return NULL;
for (i = 0, ptr = fe_data->client_tbl; i < fe_data->clk_src_set.count; i++, ptr++) {
if (ptr->client_uid == client_id)
return ptr;
}
for (i = 0, ptr = fe_data->client_tbl; i < fe_data->clk_src_set.count; i++, ptr++) {
if (ptr->client_uid == U32_MAX) {
ptr->client_uid = client_id;
return ptr;
}
}
return NULL;
}

224
qcom/opensource/mmrm-driver/vm/fe/src/mmrm_vm_fe_main.c Normal file
View File

@@ -0,0 +1,224 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/types.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/of.h>
#include "mmrm_vm_fe.h"
#include "mmrm_vm_msgq.h"
#include "mmrm_vm_interface.h"
#include "mmrm_vm_debug.h"
struct mmrm_vm_driver_data *drv_vm_fe = (void *) -EPROBE_DEFER;
static ssize_t dump_clk_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int rc;
struct mmrm_vm_fe_priv *fe_data = drv_vm_fe->vm_pvt_data;
rc = mmrm_vm_fe_clk_print_info(&fe_data->clk_src_set, buf, MMRM_SYSFS_ENTRY_MAX_LEN);
if (rc == 0)
d_mpr_e("%s: failed to dump clk info\n", __func__);
return rc;
}
ssize_t msgq_send_trigger_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct mmrm_vm_driver_data *priv = dev->driver_data;
char send_buf[64] = "test msg";
int ret;
bool flag;
ret = strtobool(buf, &flag);
if (ret) {
dev_err(dev, "invalid user input\n");
return -1;
}
if (flag) {
ret = mmrm_vm_msgq_send(priv, send_buf, sizeof(send_buf));
if (ret)
d_mpr_e("%s:send msgq failed\n", __func__);
else
d_mpr_e("%s:send msgq success\n", __func__);
}
return ret ? ret : count;
}
extern int mmrm_client_msgq_roundtrip_measure(u32 val);
ssize_t msgq_rt_test_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int ret;
long sz, n;
struct mmrm_vm_fe_priv *fe_data;
struct mmrm_vm_fe_msgq_rt_stats *trip_time;
if (IS_ERR_OR_NULL(drv_vm_fe)) {
return -1;
}
ret = kstrtol(buf, 10, &sz);
if (ret) {
dev_err(dev, "invalid user input\n");
return -1;
}
if (sz) {
d_mpr_w("%s: loop count:%d\n", __func__, sz);
fe_data = drv_vm_fe->vm_pvt_data;
trip_time = &fe_data->msgq_rt_stats;
trip_time->looptest_total_us = 0;
n = sz;
while (n-- > 0) {
ret = mmrm_client_msgq_roundtrip_measure(0);
if (ret) {
d_mpr_e("%s:send msgq failed\n", __func__);
break;
};
}
if (n <= 0)
d_mpr_w("%s: aver: %d\n", __func__, trip_time->looptest_total_us / sz);
}
return ret ? ret : count;
}
static DEVICE_ATTR_RO(dump_clk_info);
static DEVICE_ATTR_WO(msgq_send_trigger);
static DEVICE_ATTR_WO(msgq_rt_test);
static struct attribute *mmrm_vm_fe_fs_attrs[] = {
&dev_attr_dump_clk_info.attr,
&dev_attr_msgq_send_trigger.attr,
&dev_attr_msgq_rt_test.attr,
NULL,
};
static struct attribute_group mmrm_vm_fe_fs_attrs_group = {
.attrs = mmrm_vm_fe_fs_attrs,
};
static int mmrm_vm_fe_driver_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct mmrm_vm_fe_priv *fe_priv_data;
int rc = 0;
u32 clk_clients = 0;
drv_vm_fe = devm_kzalloc(dev, sizeof(*drv_vm_fe), GFP_KERNEL);
if (!drv_vm_fe)
return -ENOMEM;
fe_priv_data = devm_kzalloc(dev, sizeof(*fe_priv_data), GFP_KERNEL);
if (!fe_priv_data) {
rc = -ENOMEM;
goto err_priv_data;
}
drv_vm_fe->vm_pvt_data = fe_priv_data;
fe_priv_data->seq_no = 0;
fe_priv_data->dev = dev;
/* check for clk clients needing admission control */
clk_clients = mmrm_vm_fe_count_clk_clients_frm_dt(pdev);
if (clk_clients) {
d_mpr_h("%s: %d clk clients managed for admission control\n",
__func__, clk_clients);
fe_priv_data->is_clk_scaling_supported = true;
} else {
d_mpr_h("%s: no clk clients managed for admission control\n",
__func__);
fe_priv_data->is_clk_scaling_supported = false;
goto skip_mmrm;
}
mutex_init(&fe_priv_data->msg_send_lock);
dev_set_drvdata(&pdev->dev, drv_vm_fe);
INIT_LIST_HEAD(&fe_priv_data->resp_works);
mutex_init(&fe_priv_data->resp_works_lock);
mmrm_vm_fe_load_clk_rsrc(drv_vm_fe);
rc = mmrm_vm_msgq_init(drv_vm_fe);
if (rc != 0) {
d_mpr_e("%s: failed to msgq init\n",
__func__);
goto err_msgq_init;
}
rc = mmrm_vm_fe_init_lookup_table(drv_vm_fe);
if (rc == -1) {
d_mpr_e("%s: failed to lookup table init\n",
__func__);
goto err_lookup_table;
}
if (sysfs_create_group(&pdev->dev.kobj, &mmrm_vm_fe_fs_attrs_group)) {
d_mpr_e("%s: failed to create sysfs\n",
__func__);
}
d_mpr_w("msgq probe success");
return rc;
err_lookup_table:
mmrm_vm_msgq_deinit(drv_vm_fe);
err_msgq_init:
err_priv_data:
d_mpr_e("%s: failed to probe\n", __func__);
skip_mmrm:
return rc;
}
static int mmrm_vm_fe_driver_remove(struct platform_device *pdev)
{
struct mmrm_vm_driver_data *mmrm_vm = dev_get_drvdata(&pdev->dev);
mmrm_vm_msgq_deinit(mmrm_vm);
return 0;
}
static const struct of_device_id mmrm_vm_fe_match[] = {
{ .compatible = "qcom,mmrm-vm-fe" },
{},
};
MODULE_DEVICE_TABLE(of, mmrm_vm_fe_match);
static struct platform_driver mmrm_vm_fe_driver = {
.probe = mmrm_vm_fe_driver_probe,
.driver = {
.name = "mmrm-vm-fe",
.of_match_table = mmrm_vm_fe_match,
},
.remove = mmrm_vm_fe_driver_remove,
};
static int __init mmrm_vm_fe_module_init(void)
{
d_mpr_e("%s: init start\n", __func__);
return platform_driver_register(&mmrm_vm_fe_driver);
}
subsys_initcall(mmrm_vm_fe_module_init);
static void __exit mmrm_vm_fe_module_exit(void)
{
platform_driver_unregister(&mmrm_vm_fe_driver);
}
module_exit(mmrm_vm_fe_module_exit);
MODULE_SOFTDEP("pre: gunyah_transport");
MODULE_DESCRIPTION("Qualcomm Technologies, Inc. Test MSGQ Driver");
MODULE_LICENSE("GPL v2");

182
qcom/opensource/mmrm-driver/vm/fe/src/mmrm_vm_fe_msgq.c Normal file
View File

@@ -0,0 +1,182 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <linux/gunyah/gh_msgq.h>
#include <linux/kthread.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/of.h>
#include <mmrm_vm_interface.h>
#include "mmrm_vm_fe.h"
#include "mmrm_vm_debug.h"
void mmrm_vm_fe_msgq_msg_handler(struct work_struct *work)
{
struct mmrm_vm_thread_info *pthread_info =
container_of(work, struct mmrm_vm_thread_info, msgq_work.work);
struct mmrm_vm_driver_data *mmrm_vm =
container_of(pthread_info, struct mmrm_vm_driver_data, thread_info);
struct list_head head;
struct mmrm_vm_msg *dummy = NULL;
struct mmrm_vm_msg *msg;
struct mmrm_vm_request_msg_pkt *msg_pkt;
mutex_lock(&pthread_info->list_lock);
list_replace_init(&pthread_info->queued_msg, &head);
mutex_unlock(&pthread_info->list_lock);
list_for_each_entry_safe(msg, dummy, &head, link) {
msg_pkt = (struct mmrm_vm_request_msg_pkt *)msg->msg_buf;
mmrm_vm_fe_recv(mmrm_vm, &msg_pkt->msg, msg_pkt->hdr.size);
list_del(&msg->link);
kfree(msg);
}
}
int mmrm_vm_msgq_listener(void *data)
{
struct mmrm_vm_driver_data *mmrm_vm = (struct mmrm_vm_driver_data *)data;
struct mmrm_vm_gh_msgq_info *pmsg_info = &mmrm_vm->msg_info;
struct mmrm_vm_thread_info *pthread_info = &mmrm_vm->thread_info;
size_t size;
int ret = 0;
struct mmrm_vm_msg *msg;
while (true) {
msg = kzalloc(sizeof(*msg), GFP_KERNEL);
if (!msg)
return -ENOMEM;
ret = gh_msgq_recv(pmsg_info->msgq_handle, msg->msg_buf,
GH_MSGQ_MAX_MSG_SIZE_BYTES, &size, 0);
d_mpr_l("done ret=%d\n", ret);
if (ret < 0) {
kfree(msg);
d_mpr_e("gh_msgq_recv failed, rc=%d\n", ret);
return -EINVAL;
}
msg->msg_size = size;
mutex_lock(&pthread_info->list_lock);
list_add_tail(&msg->link, &pthread_info->queued_msg);
mutex_unlock(&pthread_info->list_lock);
queue_delayed_work(pthread_info->msg_workq,
&pthread_info->msgq_work, msecs_to_jiffies(0));
}
return 0;
}
int mmrm_vm_msgq_send(struct mmrm_vm_driver_data *mmrm_vm, void *msg, size_t msg_size)
{
int rc;
struct mmrm_vm_gh_msgq_info *pmsg_info;
if (IS_ERR_OR_NULL(mmrm_vm))
return -EINVAL;
pmsg_info = &mmrm_vm->msg_info;
if (!pmsg_info->msgq_handle) {
d_mpr_e("Failed to send msg, invalid msgq handle\n");
return -EINVAL;
}
if (msg_size > GH_MSGQ_MAX_MSG_SIZE_BYTES) {
d_mpr_e("msg size unsupported for msgq: %ld > %d\n", msg_size,
GH_MSGQ_MAX_MSG_SIZE_BYTES);
return -E2BIG;
}
rc = gh_msgq_send(pmsg_info->msgq_handle, msg, msg_size, 0);
d_mpr_h("%s: result:%d\n", __func__, rc);
return rc;
}
int mmrm_vm_msgq_init(struct mmrm_vm_driver_data *mmrm_vm)
{
int rc = 0;
struct mmrm_vm_gh_msgq_info *pmsg_info;
struct mmrm_vm_thread_info *pthread_info;
if (IS_ERR_OR_NULL(mmrm_vm)) {
rc = -EINVAL;
goto err;
}
pmsg_info = &mmrm_vm->msg_info;
pthread_info = &mmrm_vm->thread_info;
mutex_init(&pthread_info->list_lock);
INIT_LIST_HEAD(&pthread_info->queued_msg);
pthread_info->msg_workq = create_singlethread_workqueue("vm_fe_message_workq");
if (IS_ERR_OR_NULL(pthread_info->msg_workq)) {
rc = -1;
goto err;
}
INIT_DELAYED_WORK(&pthread_info->msgq_work, mmrm_vm_fe_msgq_msg_handler);
pmsg_info->msgq_label = GH_MSGQ_LABEL_MMRM;
pmsg_info->msgq_handle = gh_msgq_register(pmsg_info->msgq_label);
d_mpr_h("%s: label:%d handle:%p\n", __func__,
pmsg_info->msgq_label, pmsg_info->msgq_handle);
if (IS_ERR(pmsg_info->msgq_handle)) {
rc = PTR_ERR(pmsg_info->msgq_handle);
d_mpr_e("msgq register failed rc:%d\n", rc);
goto err_msgq_reg;
}
pthread_info->msgq_listener_thread =
kthread_create(mmrm_vm_msgq_listener, mmrm_vm, "mmrm_vm_fe");
if (IS_ERR_OR_NULL(pthread_info->msgq_listener_thread)) {
rc = PTR_ERR(pmsg_info->msgq_handle);
goto err_listener_thread;
}
wake_up_process(pthread_info->msgq_listener_thread);
d_mpr_w("%s: msgq init done\n", __func__);
return rc;
err_listener_thread:
gh_msgq_unregister(pmsg_info->msgq_handle);
pmsg_info->msgq_handle = NULL;
err_msgq_reg:
destroy_workqueue(pthread_info->msg_workq);
pthread_info->msg_workq = NULL;
err:
return rc;
}
int mmrm_vm_msgq_deinit(struct mmrm_vm_driver_data *mmrm_vm)
{
struct mmrm_vm_gh_msgq_info *pmsg_info;
struct mmrm_vm_thread_info *pthread_info;
if (IS_ERR_OR_NULL(mmrm_vm))
return -EINVAL;
pmsg_info = &mmrm_vm->msg_info;
pthread_info = &mmrm_vm->thread_info;
if (pthread_info->msgq_listener_thread)
kthread_stop(pthread_info->msgq_listener_thread);
if (pmsg_info->msgq_handle)
gh_msgq_unregister(pmsg_info->msgq_handle);
if (pthread_info->msg_workq)
destroy_workqueue(pthread_info->msg_workq);
return 0;
}

9
qcom/opensource/mmrm-driver/vm/fe/vm_test/Kbuild Normal file
View File

@@ -0,0 +1,9 @@
obj-m += mmrm_vm_fe_test.o
ifeq ($(CONFIG_ARCH_KALAMA), y)
ifeq ($(CONFIG_ARCH_QTI_VM), y)
mmrm_vm_fe_test-objs := mmrm_vm_fe_test_main.o \
mmrm_vm_fe_test_internal.o
endif
endif

892
qcom/opensource/mmrm-driver/vm/fe/vm_test/mmrm_vm_fe_test_internal.c Normal file
View File

@@ -0,0 +1,892 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#define pr_fmt(fmt) "mmrm_test: " fmt
#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/timekeeping.h>
#include "mmrm_vm_debug.h"
#include "mmrm_vm_fe_test_internal.h"
#define MMRM_TEST_MAX_CLK_CLIENTS 30
#define MMRM_TEST_NUM_CASES 3
enum mmrm_test_result {
TEST_MMRM_SUCCESS = 0,
TEST_MMRM_FAIL_REGISTER,
TEST_MMRM_FAIL_SETVALUE,
TEST_MMRM_FAIL_CLKGET,
};
struct mmrm_test_clk_client {
struct mmrm_clk_client_desc clk_client_desc;
unsigned long clk_rate[MMRM_TEST_VDD_LEVEL_MAX];
struct mmrm_client *client;
};
static int test_mmrm_client_callback(struct mmrm_client_notifier_data *notifier_data)
{
// TODO: Test callback here
return 0;
}
static struct mmrm_client *test_mmrm_vm_fe_client_register(struct mmrm_client_desc *desc)
{
struct mmrm_client *client;
u64 kt1, kt2;
if (!desc) {
d_mpr_e("%s: Invalid input\n", __func__);
return NULL;
}
d_mpr_h("%s: domain(%d) cid(%d) name(%s) type(%d) pri(%d)\n",
__func__,
desc->client_info.desc.client_domain,
desc->client_info.desc.client_id,
desc->client_info.desc.name,
desc->client_type,
desc->priority);
d_mpr_w("%s: Registering mmrm client %s\n", __func__, desc->client_info.desc.name);
kt1 = ktime_get_ns();
client = mmrm_client_register(desc);
kt2 = ktime_get_ns();
d_mpr_h("%s: time interval: %lu\n", __func__, kt2 - kt1);
if (client == NULL) {
d_mpr_e("%s: Failed to register mmrm client %s\n",
__func__,
desc->client_info.desc.name);
return NULL;
}
return client;
}
static int test_mmrm_vm_fe_client_deregister(struct mmrm_client *client)
{
int rc;
if (!client) {
d_mpr_e("%s: Invalid input\n", __func__);
return -EINVAL;
}
d_mpr_h("%s: cuid(%d) Deregistering mmrm client\n", __func__, client->client_uid);
rc = mmrm_client_deregister(client);
if (rc != 0) {
d_mpr_e("%s: cuid(%d) Failed to deregister mmrm client with %d\n",
__func__,
client->client_uid,
rc);
return rc;
}
return rc;
}
static int test_mmrm_vm_fe_client_set_value(
struct mmrm_client *client, struct mmrm_client_data *client_data, unsigned long val)
{
int rc;
u64 kt1, kt2;
if (!client || !client_data) {
d_mpr_e("%s: Invalid input\n", __func__);
return -EINVAL;
}
d_mpr_h("%s: Setting value(%d) for mmrm client\n",
__func__,
val);
kt1 = ktime_get_ns();
rc = mmrm_client_set_value(client, client_data, val);
kt2 = ktime_get_ns();
if (rc != 0) {
d_mpr_e("%s: Failed to set value(%d) for mmrm client with %d\n",
__func__,
val,
rc);
return rc;
}
return rc;
}
static int test_mmrm_vm_fe_client_get_value(struct mmrm_client *client, struct mmrm_client_res_value *val)
{
int rc;
if (!client || !val) {
d_mpr_e("%s: Invalid input\n", __func__);
return -EINVAL;
}
rc = mmrm_client_get_value(client, val);
if (rc != 0) {
d_mpr_e("%s: Failed to get value for mmrm client with %d\n",
__func__,
rc);
return rc;
}
d_mpr_h("%s: min(%d) cur(%d) max(%d)\n",
__func__,
val->min,
val->cur,
val->max);
return rc;
}
void mmrm_vm_fe_client_tests(struct platform_device *pdev)
{
struct mmrm_client *client; // mmrm client
struct mmrm_client_data client_data; // mmrm client data
int level;
unsigned long val;
struct clock_rate *p_clk_res;
struct mmrm_clk_client_desc *clk_desc;
struct mmrm_client_desc desc;
struct mmrm_client_res_value res_val;
int i, pass_count, count;
int rc = 0;
count = get_clock_count();
d_mpr_w("%s: Running individual client tests : %d\n", __func__, count);
// Run nominal test for each individual clock source
for (i = 0, pass_count = 0; i < count; i++) {
// Create callback used to pass resource data to client
struct mmrm_client_notifier_data notifier_data = {
MMRM_CLIENT_RESOURCE_VALUE_CHANGE, // cb_type
{{0, 0}}, // cb_data (old_val, new_val)
NULL}; // pvt_data
// Create client descriptor
p_clk_res = get_nth_clock(i);
desc.client_type = MMRM_CLIENT_CLOCK;
desc.priority = MMRM_CLIENT_PRIOR_HIGH;
desc.pvt_data = notifier_data.pvt_data;
desc.notifier_callback_fn = test_mmrm_client_callback;
clk_desc = &desc.client_info.desc;
clk_desc->client_domain = p_clk_res->domain;
clk_desc->client_id = p_clk_res->id;
strlcpy((char *)clk_desc->name, p_clk_res->name, sizeof(clk_desc->name));
// Register client
client = test_mmrm_vm_fe_client_register(&desc);
if (client == NULL) {
rc = -EINVAL;
d_mpr_e("%s: client register failed\n", __func__);
goto err_register;
}
// Set values (Use reserve only)
client_data = (struct mmrm_client_data){
1,
MMRM_CLIENT_DATA_FLAG_RESERVE_ONLY
};
for (level = 0; level < MMRM_TEST_VDD_LEVEL_MAX; level++) {
val = p_clk_res->clk_rates[level];
rc = test_mmrm_vm_fe_client_set_value(client, &client_data, val);
if (rc != 0) {
d_mpr_e("%s: client set value failed\n", __func__);
goto err_setval;
}
}
// Get value
rc = test_mmrm_vm_fe_client_get_value(client, &res_val);
if (rc != 0) {
d_mpr_e("%s: client get value failed\n", __func__);
goto err_getval;
}
d_mpr_h("%s: min:%d max:%d cur:%d\n", __func__, res_val.min, res_val.max, res_val.cur);
err_setval:
err_getval:
// Reset clk rate
test_mmrm_vm_fe_client_set_value(client, &client_data, 0);
err_register:
if (rc == 0)
pass_count++;
}
d_mpr_w("%s: Finish individual client tests (pass / total): (%d / %d)\n",
__func__, pass_count, count);
}
void mmrm_vm_fe_client_register_tests(struct platform_device *pdev)
{
struct mmrm_client *client; // mmrm client
struct clock_rate *p_clk_res;
struct mmrm_clk_client_desc *clk_desc;
struct mmrm_client_desc desc;
d_mpr_h("%s: client register test\n", __func__);
// Run nominal test for each individual clock source
{
// Create callback used to pass resource data to client
struct mmrm_client_notifier_data notifier_data = {
MMRM_CLIENT_RESOURCE_VALUE_CHANGE, // cb_type
{{0, 0}}, // cb_data (old_val, new_val)
NULL}; // pvt_data
// Create client descriptor
p_clk_res = get_nth_clock(0);
desc.client_type = MMRM_CLIENT_CLOCK;
desc.priority = MMRM_CLIENT_PRIOR_HIGH;
desc.pvt_data = notifier_data.pvt_data;
desc.notifier_callback_fn = test_mmrm_client_callback;
clk_desc = &desc.client_info.desc;
clk_desc->client_domain = p_clk_res->domain;
clk_desc->client_id = p_clk_res->id;
strlcpy((char *)clk_desc->name, p_clk_res->name, sizeof(clk_desc->name));
// Register client
client = test_mmrm_vm_fe_client_register(&desc);
if (client == NULL) {
d_mpr_e("%s: client register fails\n", __func__);
} else
d_mpr_w("%s: client register successful\n", __func__);
}
}
// for camera ife/ipe/bps at nom
// all camera +cvp at nom
// all camera +cvp + mdss_mdp at nom
// all camera + cvp +mdss_mdp +video at nom
// all camera at nom + mdp/cvp/video svsl1
// mdp at svsl1 + video at nom : voltage corner scaling
// mdp at svsl1 + video at svsl1 + cvp at svsl1 + camera at nom
// for camera ife/ipe/bps at nom
//
static test_case_info_t test_case_1[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera +cvp at nom
//
static test_case_info_t test_case_4[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera +cvp + mdss_mdp at nom
//
static test_case_info_t test_case_5[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera + cvp +mdss_mdp +video at nom
//
static test_case_info_t test_case_6[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera at nom
//
static test_case_info_t test_case_7[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (lowsvs) + ipe (svs) + bps (nom)
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
// ife0, ife1, ife2 (svs) + ipe (nom) + bps (nom) + sbi (svs)
// ife0, ife1 (svs) , ife2 (lowsvs) +
// sfe0 (svs) + sfe1(svs) + ipe (nom) + bps (nom) + sbi (svs)
// ife0, ife1 (svs) + ipe (nom) + bps (nom) + sbi (svs)
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
// ife0, ife1 (lowsvs) + ipe (svs) + bps (nom)
static test_case_info_t test_case_11[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
static test_case_info_t test_case_12[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
static test_case_info_t test_case_13[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
static test_case_info_t test_case_14[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1, ife2 (svs) + ipe (nom) + bps (nom) + sbi (svs)
static test_case_info_t test_case_15[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (svs) , ife2 (lowsvs) + sfe0 (svs) + sfe1(svs) + ipe (nom) +
// bps (nom) + sbi (svs)
static test_case_info_t test_case_16[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (svs) + ipe (nom) + bps (nom) + sbi (svs)
static test_case_info_t test_case_17[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// ife0, ife1 (lowsvs) + ipe (nom) + bps (nom) + sbi (lowsvs)
static test_case_info_t test_case_18[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// throttle video
// bps(nom) + ipe(nom) +sfe0(nom) + sfe1(nom) +camnoc(nom) + ife0(nom) + csid0(nom)+ ife1(nom) + csid1(nom) + ife2(svs)
//
//
static test_case_info_t test_case_20[] = {
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_SVS},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// throttle ipe
// bps(nom) + ipe(nom) +sfe0(nom) + sfe1(nom) +camnoc(nom) + ife0(nom) + csid0(nom)+ ife1(nom) + csid1(nom) + ife2(svs)
//
//
static test_case_info_t test_case_21[] = {
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_SVS_L1},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_SVS_L1},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// Reinstate throttled client. Moved below clients to LOW SVS to make sufficient available power
// for throttled client to reinstate
static test_case_info_t test_case_22[] = {
{"video_cc_mvs1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"disp_cc_mdss_mdp_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera +cam_cc_csid at nom
//
static test_case_info_t test_case_9[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 0, 3},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
// all camera at nom + cam_cc_csid
//
static test_case_info_t test_case_10[] = {
{"cam_cc_ife_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_2_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_sfe_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ife_lite_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_ipe_nps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_bps_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 0, 3},
{"cam_cc_jpeg_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_camnoc_axi_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_icp_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cphy_rx_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi0phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi1phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi2phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi3phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi4phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_csi5phytimer_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_0_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_cci_1_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_slow_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"cam_cc_fast_ahb_clk_src", MMRM_TEST_VDD_LEVEL_NOM},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
test_case_info_t *kalama_testcases[] = {
test_case_1,
test_case_4,
test_case_5,
test_case_6,
test_case_7,
test_case_9,
test_case_10,
test_case_11,
test_case_12,
test_case_13,
test_case_14,
test_case_15,
test_case_16,
test_case_17,
test_case_18,
test_case_20,
test_case_21,
test_case_22,
};
int kalama_testcases_count = sizeof(kalama_testcases)/sizeof(kalama_testcases[0]);
static test_case_info_t cornercases_1[] = {
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 3},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 2},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 1},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 2},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 3},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
static test_case_info_t cornercases_2[] = {
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS, 1, 3},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_LOW_SVS, 1, 2},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_SVS_L1, 1, 1},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 2},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_NOM, 1, 3},
{"cam_cc_csid_clk_src", MMRM_TEST_VDD_LEVEL_SVS_L1, 1, 1},
{"", MMRM_TEST_VDD_LEVEL_MAX}
};
test_case_info_t *kalama_cornercase_testcases[] = {
cornercases_1,
cornercases_2,
};
int kalama_cornercase_testcases_count = sizeof(kalama_cornercase_testcases)/sizeof(kalama_cornercase_testcases[0]);
int test_mmrm_testcase_client_register(struct platform_device *pdev,
test_case_info_t *pcase)
{
int rc = TEST_MMRM_SUCCESS;
// Create client descriptor
struct mmrm_client_desc desc = {
MMRM_CLIENT_CLOCK, // client type
{}, // clock client descriptor
MMRM_CLIENT_PRIOR_HIGH, // client priority
NULL, // pvt_data
test_mmrm_client_callback // callback fn
};
desc.client_info.desc.client_domain = pcase->client_domain;
desc.client_info.desc.client_id = pcase->client_id;
strlcpy((char *)(desc.client_info.desc.name), pcase->name,
MMRM_CLK_CLIENT_NAME_SIZE);
// Register client
pcase->client = test_mmrm_vm_fe_client_register(&desc);
return rc;
}
int test_mmrm_run_one_case(struct platform_device *pdev,
test_case_info_t *pcase)
{
struct mmrm_client_data client_data;
unsigned long val;
test_case_info_t *p = pcase;
int rc = TEST_MMRM_SUCCESS;
client_data = (struct mmrm_client_data){0, MMRM_CLIENT_DATA_FLAG_RESERVE_ONLY};
while (p->vdd_level != MMRM_TEST_VDD_LEVEL_MAX) {
val = p->clk_rate[p->vdd_level];
rc = test_mmrm_testcase_client_register(pdev, p);
if ((rc != TEST_MMRM_SUCCESS) || (IS_ERR_OR_NULL(p->client))) {
d_mpr_e("%s: client(%s) fail register\n", __func__,
p->name);
rc = -TEST_MMRM_FAIL_REGISTER;
break;
}
if (p->num_hw_blocks == 0) {
client_data.num_hw_blocks = 1;
} else {
client_data.num_hw_blocks = p->num_hw_blocks;
}
d_mpr_h("%s: domain:%d csid:%d num_hw_block:%d\n",
__func__,
p->client_domain,
p->client_id,
client_data.num_hw_blocks);
if (test_mmrm_vm_fe_client_set_value(p->client, &client_data, val) != 0) {
rc = -TEST_MMRM_FAIL_SETVALUE;
break;
}
p++;
}
p = pcase;
while (p->vdd_level != MMRM_TEST_VDD_LEVEL_MAX) {
if (!IS_ERR_OR_NULL(p->client)) {
test_mmrm_vm_fe_client_set_value(p->client, &client_data, 0);
test_mmrm_vm_fe_client_deregister(p->client);
}
p++;
}
return rc;
}
int test_mmrm_populate_testcase(struct platform_device *pdev,
test_case_info_t **pcase, int count)
{
int i;
test_case_info_t **p = pcase, *ptr;
struct clock_rate *p_clk_rate;
if (pcase[0]->client_id != 0)
return 0;
for (i = 0; i < count; i++, p++) {
ptr = *p;
while (ptr->vdd_level != MMRM_TEST_VDD_LEVEL_MAX) {
p_clk_rate = find_clk_by_name(ptr->name);
if (p_clk_rate != NULL) {
ptr->client_domain = p_clk_rate->domain;
ptr->client_id = p_clk_rate->id;
memcpy(ptr->clk_rate, p_clk_rate->clk_rates, sizeof(ptr->clk_rate));
if (ptr->num_hw_blocks == 0)
ptr->num_hw_blocks = 1;
}
ptr++;
}
}
return i;
}
void test_mmrm_concurrent_client_cases(struct platform_device *pdev,
test_case_info_t **testcases, int count)
{
test_case_info_t **p = testcases;
int i;
int size, rc, pass = 0;
int *result_ptr;
d_mpr_h("%s: Started\n", __func__);
size = sizeof(int) * count;
test_mmrm_populate_testcase(pdev, testcases, count);
result_ptr = kzalloc(size, GFP_KERNEL);
if (IS_ERR_OR_NULL(result_ptr)) {
d_mpr_e("%s: failed to allocate memory for concurrent client test\n",
__func__);
goto err_fail_alloc_result_ptr;
}
p = testcases;
for (i = 0; i < count; i++, p++) {
d_mpr_e("%s: testcase: %d -----\n", __func__, i);
rc = test_mmrm_run_one_case(pdev, *p);
result_ptr[i] = rc;
if (rc == TEST_MMRM_SUCCESS)
pass++;
}
d_mpr_w("%s: Finish concurrent client tests (pass / total): (%d / %d)\n",
__func__, pass, count);
for (i = 0; i < count; i++) {
if (result_ptr[i] != TEST_MMRM_SUCCESS)
d_mpr_w("%s: Failed client test# %d reason %d\n",
__func__, i, result_ptr[i]);
}
kfree(result_ptr);
err_fail_alloc_result_ptr:
;
}
void test_mmrm_switch_volt_corner_client_testcases(struct platform_device *pdev,
test_case_info_t **testcases, int count)
{
test_case_info_t **p = testcases;
int i;
int size, rc, pass = 0;
int *result_ptr;
d_mpr_h("%s: Started\n", __func__);
size = sizeof(int) * count;
test_mmrm_populate_testcase(pdev, testcases, count);
result_ptr = kzalloc(size, GFP_KERNEL);
if (IS_ERR_OR_NULL(result_ptr)) {
d_mpr_h("%s: failed to allocate memory for concurrent client test\n",
__func__);
goto err_fail_alloc_result_ptr;
}
p = testcases;
for (i = 0; i < count; i++, p++) {
d_mpr_h("%s: switch volt corner testcase: %d -----\n", __func__, i);
rc = test_mmrm_run_one_case(pdev, *p);
result_ptr[i] = rc;
if (rc == TEST_MMRM_SUCCESS)
pass++;
}
d_mpr_w("%s: Finish switch volt corner client tests (pass / total): (%d / %d)\n",
__func__, pass, count);
for (i = 0; i < count; i++) {
if (result_ptr[i] != TEST_MMRM_SUCCESS)
d_mpr_w("%s: Failed client test# %d reason %d\n",
__func__, i, result_ptr[i]);
}
kfree(result_ptr);
err_fail_alloc_result_ptr:
;
}

66
qcom/opensource/mmrm-driver/vm/fe/vm_test/mmrm_vm_fe_test_internal.h Normal file
View File

@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef TEST_MMRM_TEST_INTERNAL_H_
#define TEST_MMRM_TEST_INTERNAL_H_
#include <linux/platform_device.h>
#include <linux/soc/qcom/msm_mmrm.h>
#define MMRM_SYSFS_ENTRY_MAX_LEN PAGE_SIZE
struct mmrm_test_desc {
struct mmrm_test_clk_client *clk_client;
u32 clk_rate_id;
};
#define MMRM_SYSFS_ENTRY_MAX_LEN PAGE_SIZE
enum mmrm_vdd_level {
MMRM_TEST_VDD_LEVEL_LOW_SVS = 0,
MMRM_TEST_VDD_LEVEL_SVS,
MMRM_TEST_VDD_LEVEL_SVS_L1,
MMRM_TEST_VDD_LEVEL_NOM,
MMRM_TEST_VDD_LEVEL_TURBO,
MMRM_TEST_VDD_LEVEL_MAX
};
struct clock_rate {
const char *name;
u32 domain;
u32 id;
u32 clk_rates[MMRM_TEST_VDD_LEVEL_MAX];
};
typedef struct test_case_info_s {
const char name[MMRM_CLK_CLIENT_NAME_SIZE];
int vdd_level;
u32 flags;
u32 num_hw_blocks;
u32 client_domain;
u32 client_id;
u32 clk_rate[MMRM_TEST_VDD_LEVEL_MAX];
struct mmrm_client *client;
} test_case_info_t;
extern test_case_info_t *kalama_testcases[];
extern int kalama_testcases_count;
extern test_case_info_t *kalama_cornercase_testcases[];
extern int kalama_cornercase_testcases_count;
void mmrm_vm_fe_client_tests(struct platform_device *pdev);
void test_mmrm_single_client_cases(struct platform_device *pdev,
int index, int count);
void test_mmrm_concurrent_client_cases(struct platform_device *pdev,
test_case_info_t **testcases, int count);
struct clock_rate *find_clk_by_name(const char *name);
struct clock_rate *get_nth_clock(int nth);
void test_mmrm_switch_volt_corner_client_testcases(struct platform_device *pdev,
test_case_info_t **testcases, int count);
int get_clock_count(void);
void mmrm_vm_fe_client_register_tests(struct platform_device *pdev);
#endif // TEST_MMRM_TEST_INTERNAL_H_

397
qcom/opensource/mmrm-driver/vm/fe/vm_test/mmrm_vm_fe_test_main.c Normal file
View File

@@ -0,0 +1,397 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#define pr_fmt(fmt) "mmrm_test: " fmt
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/soc/qcom/msm_mmrm.h>
#include <soc/qcom/socinfo.h>
#include "mmrm_vm_fe_test_internal.h"
#include "mmrm_vm_debug.h"
#define MODULE_NAME "mmrm_vm_fe_test"
enum supported_soc_ids {
SOC_KALAMA_ID = 519 /* KAILUA */
};
struct mmrm_test_platform_resources {
struct platform_device *pdev;
struct clock_rate *clk_rate_tbl;
u32 count;
};
struct mmrm_test_driver_data {
struct mmrm_test_platform_resources clk_res;
};
static struct mmrm_test_driver_data *test_drv_data = (void *) -EPROBE_DEFER;
int mmrm_vm_debug = MMRM_VM_ERR | MMRM_VM_WARN | MMRM_VM_PRINTK;
int mmrm_vm_fe_load_mmrm_test_table(
struct mmrm_test_platform_resources *dt_res)
{
int rc = 0, num_clock_names = 0, c = 0;
struct platform_device *pdev = dt_res->pdev;
int entry_offset = 0;
struct clock_rate *clk_rate;
num_clock_names = of_property_count_strings(pdev->dev.of_node,
"clock-names");
if (num_clock_names <= 0) {
dt_res->count = 0;
goto err_load_corner_tbl;
}
d_mpr_h("%s: count =%d\n", __func__, num_clock_names);
dt_res->clk_rate_tbl = devm_kzalloc(&pdev->dev,
sizeof(*dt_res->clk_rate_tbl) * num_clock_names, GFP_KERNEL);
if (!dt_res->clk_rate_tbl) {
rc = -ENOMEM;
goto err_load_corner_tbl;
}
dt_res->count = num_clock_names;
clk_rate = dt_res->clk_rate_tbl;
for (c = 0; c < num_clock_names; c++, clk_rate++) {
of_property_read_string_index(pdev->dev.of_node,
"clock-names", c, &clk_rate->name);
}
clk_rate = dt_res->clk_rate_tbl;
for (c = 0; c < num_clock_names; c++, entry_offset += 7, clk_rate++) {
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset, &clk_rate->domain);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+1, &clk_rate->id);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+2, &clk_rate->clk_rates[0]);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+3, &clk_rate->clk_rates[1]);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+4, &clk_rate->clk_rates[2]);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+5, &clk_rate->clk_rates[3]);
of_property_read_u32_index(pdev->dev.of_node,
"clock_rates", entry_offset+6, &clk_rate->clk_rates[4]);
}
/* print clock rate tables */
clk_rate = dt_res->clk_rate_tbl;
for (c = 0; c < num_clock_names; c++, clk_rate++) {
d_mpr_h("clock name:%s, %d, %d, %d, %d, %d, %d, %d\n", clk_rate->name,
clk_rate->domain, clk_rate->id,
clk_rate->clk_rates[0], clk_rate->clk_rates[1],
clk_rate->clk_rates[2], clk_rate->clk_rates[3],
clk_rate->clk_rates[4]);
}
return 0;
err_load_corner_tbl:
return rc;
}
int mmrm_clk_print_info(
struct mmrm_test_platform_resources *dt_res,
char *buf, int max_len)
{
struct clock_rate *clk_rate;
int left_spaces = max_len;
int len, c;
u32 count;
count = dt_res->count;
/* print clock rate tables */
clk_rate = dt_res->clk_rate_tbl;
for (c = 0; c < count; c++, clk_rate++) {
len = scnprintf(buf, left_spaces, "clock name:%s, %d, %d, %d, %d, %d, %d, %d\n",
clk_rate->name, clk_rate->domain, clk_rate->id,
clk_rate->clk_rates[0], clk_rate->clk_rates[1],
clk_rate->clk_rates[2], clk_rate->clk_rates[3],
clk_rate->clk_rates[4]);
left_spaces -= len;
buf += len;
}
return max_len - left_spaces;
}
struct clock_rate *find_clk_by_name(const char *name)
{
int i;
struct mmrm_test_platform_resources *res = &test_drv_data->clk_res;
struct clock_rate *p = res->clk_rate_tbl;
for (i = 0; i < res->count; i++, p++) {
if (strcmp(name, p->name) == 0)
return p;
}
return NULL;
}
int get_clock_count(void)
{
return test_drv_data->clk_res.count;
}
struct clock_rate *get_nth_clock(int nth)
{
struct mmrm_test_platform_resources *res = &test_drv_data->clk_res;
return &(res->clk_rate_tbl[nth]);
}
int mmrm_vm_fe_test_read_platform_resources(struct platform_device *pdev)
{
int rc = 0;
d_mpr_h("%s: mmrm_test_read_platform_resources =%p test_drv_data:%p\n",
__func__, pdev, test_drv_data);
if (pdev == NULL || pdev->dev.of_node == NULL) {
rc = -EINVAL;
goto exit;
}
if (test_drv_data == (void *) -EPROBE_DEFER) {
d_mpr_e("%s: mmrm_test_read_platform_resources\n", __func__);
goto exit;
}
rc = mmrm_vm_fe_load_mmrm_test_table(&test_drv_data->clk_res);
if (rc) {
goto exit;
}
exit:
return rc;
}
static int mmrm_test(struct platform_device *pdev, int flags)
{
int soc_id;
// Get socid to get known mmrm configurations
soc_id = socinfo_get_id();
d_mpr_e("%s: soc id: %d flags=%x\n", __func__, soc_id, flags);
soc_id = SOC_KALAMA_ID;
d_mpr_e("%s: soc id: %d flags=%x\n", __func__, soc_id, flags);
switch (soc_id) {
case SOC_KALAMA_ID:
if (flags & 1)
mmrm_vm_fe_client_tests(pdev);
if (flags & 2)
test_mmrm_concurrent_client_cases(pdev, kalama_testcases, kalama_testcases_count);
if (flags & 4)
test_mmrm_switch_volt_corner_client_testcases(pdev, kalama_cornercase_testcases, kalama_cornercase_testcases_count);
break;
default:
d_mpr_e("%s: Not supported for soc_id %d\n", __func__, soc_id);
return -ENODEV;
}
return 0;
}
static ssize_t mmrm_vm_fe_sysfs_debug_get(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret;
ret = scnprintf(buf, MMRM_SYSFS_ENTRY_MAX_LEN, "0x%x\n", mmrm_vm_debug);
pr_info("%s: 0x%04X\n", __func__, mmrm_vm_debug);
return ret;
}
static ssize_t mmrm_vm_fe_sysfs_debug_set(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int ret;
unsigned long dbg_mask;
ret = kstrtoul(buf, 16, &dbg_mask);
if (ret == 0)
mmrm_vm_debug = dbg_mask;
return count;
}
static ssize_t dump_clk_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int rc;
rc = mmrm_clk_print_info(&test_drv_data->clk_res, buf, MMRM_SYSFS_ENTRY_MAX_LEN);
if (rc == 0)
d_mpr_e("%s: failed to dump clk info\n", __func__);
return rc;
}
ssize_t test_trigger_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = container_of(dev, struct platform_device, dev);
int ret;
unsigned long flags;
d_mpr_e("%s: start ...\n", __func__);
ret = kstrtoul(buf, 16, &flags);
if (ret) {
d_mpr_e("invalid user input\n");
return -1;
}
if (flags & 0x80)
mmrm_vm_fe_client_register_tests(pdev);
else
mmrm_test(pdev, flags);
return count;
}
static DEVICE_ATTR_RO(dump_clk_info);
static DEVICE_ATTR(debug, 0644,
mmrm_vm_fe_sysfs_debug_get,
mmrm_vm_fe_sysfs_debug_set);
static DEVICE_ATTR_WO(test_trigger);
static struct attribute *mmrm_vm_fe_test_fs_attrs[] = {
&dev_attr_debug.attr,
&dev_attr_dump_clk_info.attr,
&dev_attr_test_trigger.attr,
NULL,
};
static struct attribute_group mmrm_vm_fe_test_fs_attrs_group = {
.attrs = mmrm_vm_fe_test_fs_attrs,
};
static int mmrm_vm_fe_test_probe(struct platform_device *pdev)
{
bool is_mmrm_supported = false;
int rc;
// Check if of_node is found
if (!of_device_is_compatible(pdev->dev.of_node, "qcom,mmrm-vm-fe-test")) {
d_mpr_e("No compatible device node\n");
return 1;
}
is_mmrm_supported = mmrm_client_check_scaling_supported(MMRM_CLIENT_CLOCK, 0);
if (!is_mmrm_supported) {
d_mpr_e("%s: MMRM not supported on %s\n", __func__, socinfo_get_id_string());
return 0;
}
test_drv_data = kzalloc(sizeof(*test_drv_data), GFP_KERNEL);
if (!test_drv_data) {
rc = -ENOMEM;
goto err_no_mem;
}
test_drv_data->clk_res.pdev = pdev;
dev_set_drvdata(&pdev->dev, test_drv_data);
rc = mmrm_vm_fe_test_read_platform_resources(pdev);
if (rc) {
d_mpr_e("%s: unable to read platform resources for mmrm\n",
__func__);
goto err_read;
}
d_mpr_e("%s: Validating mmrm on target\n", __func__);
if (sysfs_create_group(&pdev->dev.kobj, &mmrm_vm_fe_test_fs_attrs_group)) {
d_mpr_e("%s: failed to create sysfs\n",
__func__);
}
err_no_mem:
err_read:
return 0;
}
int mmrm_vm_fe_test_remove(struct platform_device *pdev)
{
int rc = 0;
if (!pdev) {
rc = -EINVAL;
goto err_exit;
}
test_drv_data = dev_get_drvdata(&pdev->dev);
if (!test_drv_data) {
rc = -EINVAL;
goto err_exit;
}
if (test_drv_data->clk_res.clk_rate_tbl)
kfree(test_drv_data->clk_res.clk_rate_tbl);
dev_set_drvdata(&pdev->dev, NULL);
kfree(test_drv_data);
test_drv_data = (void *) -EPROBE_DEFER;
err_exit:
return rc;
}
static const struct of_device_id mmrm_vm_fe_test_dt_match[] = {
{.compatible = "qcom,mmrm-vm-fe-test"}, {} // empty
};
static struct platform_driver mmrm_vm_fe_test_driver = {
.probe = mmrm_vm_fe_test_probe,
.remove = mmrm_vm_fe_test_remove,
.driver = {
.name = MODULE_NAME,
.owner = THIS_MODULE,
.of_match_table = mmrm_vm_fe_test_dt_match,
},
};
static int __init mmrm_vm_fe_test_init(void)
{
int rc = 0;
rc = platform_driver_register(&mmrm_vm_fe_test_driver);
if (rc) {
pr_info("%s: failed to register platform driver\n", __func__);
}
return rc;
}
module_init(mmrm_vm_fe_test_init);
static void __exit mmrm_vm_fe_test_exit(void)
{
platform_driver_unregister(&mmrm_vm_fe_test_driver);
}
module_exit(mmrm_vm_fe_test_exit);
MODULE_DESCRIPTION("MMRM VM FE TEST");
MODULE_LICENSE("GPL v2");