Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+45
View File
@@ -0,0 +1,45 @@
# SPDX-License-Identifier: GPL-2.0
config MTK_TINYSYS_SSPM_SUPPORT
tristate "Specify Interface Support SSPM"
default n
help
SSPM is a MediaTek in-house hardware for power management under
secure world.
Set Y to enable this feature.
If unsure, set N to stay with legancy feature.
config MTK_TINYSYS_SSPM_PLT_SUPPORT
bool "Specify Interface of SSPM on Platform"
default n
help
SSPM is a MediaTek in-house hardware for power management based
on platform.
Set Y to enable this feature for specific platform.
If unsure, set N to stay with legancy feature.
config MTK_TINYSYS_SSPM_V2
bool "Specify Interface SSPM Version2"
help
Set Interface SSPM Version as V2.
V2 is based on Tinysys IPI mechanism.
Set Y to enable this feature.
If unsure, set N to stay with original feature.
config MTK_TINYSYS_SSPM_V3
bool "Specify Interface SSPM Version3"
help
Set Interface SSPM Version as V3.
V3 is based on SCMI mechanism.
Set Y to enable this feature.
If unsure, set N to stay with original feature.
config MTK_MET_MEM_ALLOC
bool "Using dynamic allocate memory for MET"
config MTK_TINYSYS_SSPM_VERSION
string "Support MTK SSPM Driver Version"
depends on MTK_TINYSYS_SSPM_SUPPORT
default ""
help
MTK_TINYSYS_SSPM_VERSION define which sspm version will be used
+37
View File
@@ -0,0 +1,37 @@
# SPDX-License-Identifier: GPL-2.0
ifneq ($(strip $(CONFIG_MTK_TINYSYS_SSPM_SUPPORT)$(CONFIG_MTK_TINYSYS_SSPM_PLT_SUPPORT)),)
ifneq ($(strip $(CONFIG_MTK_TINYSYS_SSPM_V2)),)
obj-$(CONFIG_MTK_TINYSYS_SSPM_V2) += v2/
else ifneq ($(CONFIG_MTK_TINYSYS_SSPM_VERSION),"")
obj-y += $(subst ",,$(CONFIG_MTK_TINYSYS_SSPM_VERSION))/
else
# Common
obj-$(CONFIG_MTK_TINYSYS_SSPM_SUPPORT) += sspm.o
sspm-$(CONFIG_MTK_TINYSYS_SSPM_SUPPORT) += sspm_common.o sspm_mbox.o sspm_sysfs.o sspm_plt.o sspm_ipi_mbox.o sspm_reservedmem.o sspm_emi_mpu.o sspm_logger_impl.o sspm_timesync.o
# Platform Drivers
sspm-y += sspm_$(subst ",,$(CONFIG_MTK_PLATFORM)).o
ccflags-$(CONFIG_MTK_TINYSYS_SSPM_SUPPORT) += -I$(srctree)/drivers/misc/mediatek/sspm
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-$(CONFIG_MTK_EMI_LEGACY) += -I$(srctree)/drivers/misc/mediatek/emi/$(CONFIG_MTK_PLATFORM)
ccflags-$(CONFIG_MTK_ENG_BUILD) += -DDEBUG
endif
else
obj-y += dummy.o
endif
+13
View File
@@ -0,0 +1,13 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/*external sspm driver*/
/*
*
void sspm_dummy(void)
{
}
*/
+47
View File
@@ -0,0 +1,47 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/ioport.h>
#include <linux/io.h>
#include "sspm_common.h"
struct sspm_regs sspmreg;
struct platform_device *sspm_pdev;
unsigned int sspm_ready;
void memcpy_to_sspm(void __iomem *trg, const void *src, int size)
{
int i, len;
u32 __iomem *t = trg;
const u32 *s = src;
len = (size + 3) >> 2;
for (i = 0; i < len; i++)
*t++ = *s++;
}
void memcpy_from_sspm(void *trg, const void __iomem *src, int size)
{
int i, len;
u32 *t = trg;
const u32 __iomem *s = src;
len = (size + 3) >> 2;
for (i = 0; i < len; i++)
*t++ = *s++;
}
/*
* @return: 1 if sspm is ready for running tasks
*/
unsigned int is_sspm_ready(void)
{
return sspm_ready ? 1 : 0;
}
EXPORT_SYMBOL_GPL(is_sspm_ready);
+25
View File
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_COMMON_H__
#define __SSPM_COMMON_H__
#include <linux/types.h>
struct sspm_regs {
void __iomem *cfg;
unsigned int cfgregsize;
int irq;
};
extern struct sspm_regs sspmreg;
extern struct platform_device *sspm_pdev;
extern unsigned int sspm_ready;
extern int sspm_plt_init(void);
extern void memcpy_to_sspm(void __iomem *trg, const void *src, int size);
extern void memcpy_from_sspm(void *trg, const void __iomem *src, int size);
extern unsigned int is_sspm_ready(void);
#endif
+44
View File
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_DEFINE_H__
#define __SSPM_DEFINE_H__
#include <linux/param.h> /* for HZ */
#include <asm/arch_timer.h>
#define SSPM_MBOX_MAX 5
#define MBOX_IN_IRQ_OFS 0x0
#define MBOX_OUT_IRQ_OFS 0x4
#define MBOX_SLOT_SIZE 0x4
#define SSPM_CFG_OFS_SEMA 0x048
//#define SSPM_MPU_REGION_ID 4
#define SSPM_SHARE_BUFFER_SUPPORT
#define SSPM_PLT_SERV_SUPPORT (1)
#define SSPM_LOGGER_SUPPORT (1)
#define SSPM_TIMESYNC_SUPPORT (1)
#define PLT_INIT 0x504C5401
#define PLT_LOG_ENABLE 0x504C5402
#define SSPM_PLT_LOGGER_BUF_LEN 0x100000
struct plt_ipi_data_s {
unsigned int cmd;
union {
struct {
unsigned int phys;
unsigned int size;
} ctrl;
struct {
unsigned int enable;
} logger;
} u;
};
#endif
+69
View File
@@ -0,0 +1,69 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <mt-plat/sync_write.h>
#ifdef CONFIG_MTK_EMI_LEGACY
#include <mt_emi_api.h>
#elif CONFIG_MTK_EMI
#include <memory/mediatek/emi.h>
#endif
#ifdef CONFIG_MTK_EMI_LEGACY
void sspm_set_emi_mpu(unsigned int id, phys_addr_t base, phys_addr_t size)
{
struct emi_region_info_t region_info;
region_info.region = id;
region_info.start = base;
region_info.end = base + size - 1;
SET_ACCESS_PERMISSION(region_info.apc, UNLOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
pr_debug("[SSPM] MPU SSPM Share region<%d:%08llx:%08llx> %x, %x\n",
region_info.region, region_info.start, region_info.end,
region_info.apc[1], region_info.apc[0]);
emi_mpu_set_protection(&region_info);
}
#elif CONFIG_MTK_EMI
struct emimpu_region_t sspm_rg_info;
void sspm_set_emi_mpu(unsigned int id, phys_addr_t base, phys_addr_t size)
{
sspm_rg_info.rg_num = id;
sspm_rg_info.start = base;
sspm_rg_info.end = base + size - 1;
}
static int __init post_sspm_set_emi_mpu(void)
{
struct emimpu_region_t rg_info;
int ret;
mtk_emimpu_init_region(&rg_info, sspm_rg_info.rg_num);
mtk_emimpu_set_addr(&rg_info, sspm_rg_info.start, sspm_rg_info.end);
mtk_emimpu_set_apc(&rg_info, 0, MTK_EMIMPU_NO_PROTECTION);
mtk_emimpu_set_apc(&rg_info, 8, MTK_EMIMPU_NO_PROTECTION);
ret = mtk_emimpu_set_protection(&rg_info);
pr_debug("[SSPM] MPU SSPM Share region <%d:%08llx:%08llx> %s\n",
sspm_rg_info.rg_num, sspm_rg_info.start, sspm_rg_info.end,
ret ? "fail" : "success");
mtk_emimpu_free_region(&rg_info);
return 0;
}
late_initcall(post_sspm_set_emi_mpu);
#endif
+72
View File
@@ -0,0 +1,72 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_H__
#define __SSPM_IPI_H__
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/semaphore.h>
#include <linux/completion.h>
#include "sspm_ipi_pin.h"
struct ipi_action {
void *data;
unsigned int id;
spinlock_t *lock;
};
#define IPI_REG_OK 0
#define IPI_REG_ALREADY -1
#define IPI_REG_ACTION_ERROR -2
#define IPI_REG_SEMAPHORE_FAIL -3
#define IPI_SERVICE_NOT_AVAILABLE -100
#define IPI_SERVICE_NOT_INITED -101
/* ipi_send() return code */
#define IPI_DONE 0
#define IPI_RETURN 1
#define IPI_BUSY -1
#define IPI_TIMEOUT_AVL -2
#define IPI_TIMEOUT_ACK -3
#define IPI_MODULE_ID_ERROR -4
#define IPI_HW_ERROR -5
#define IPI_NO_MEMORY -6
#define IPI_USED_IN_WAIT -7
#define IPI_PIN_MISUES -8
extern int sspm_ipi_init(void);
/* definition for opts arguments (new) */
#define IPI_OPT_WAIT 0
#define IPI_OPT_POLLING 1
#define sspm_ipi_send_sync_new sspm_ipi_send_sync
extern int sspm_ipi_recv_registration(int mid, struct ipi_action *act);
extern int sspm_ipi_recv_registration_ex(int mid, spinlock_t *lock,
struct ipi_action *act);
extern int sspm_ipi_recv_unregistration(int mid);
extern int sspm_ipi_recv_wait(int mid);
extern void sspm_ipi_recv_complete(int mid);
extern int sspm_ipi_send_sync(int mid, int opts, void *buffer, int slot,
void *retbuf, int retslot);
extern int sspm_ipi_send_ack(int mid, unsigned int *data);
extern int sspm_ipi_send_ack_ex(int mid, void *data, int retslot);
/* old definition (obslete) */
#define IPI_OPT_DEFAUT 0
#define IPI_OPT_NOLOCK (IPI_OPT_REDEF_MASK)
#define IPI_OPT_LOCK_BUSY (IPI_OPT_REDEF_MASK|IPI_OPT_LOCK_MASK)
#define IPI_OPT_LOCK_POLLING (IPI_OPT_REDEF_MASK|IPI_OPT_LOCK_MASK| \
IPI_OPT_POLLING_MASK)
extern int sspm_ipi_is_inited(void);
extern int sspm_ipi_send_async(int mid, int opts, void *buffer, int slot);
extern int sspm_ipi_send_async_wait(int mid, int opts, void *retbuf);
extern int sspm_ipi_send_async_wait_ex(int mid, int opts, void *retbuf,
int retslot);
#endif /* __SSPM_IPI_H__ */
@@ -0,0 +1,133 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_DEFINE_H__
#define __SSPM_IPI_DEFINE_H__
/* definition of slot size for send PINs */
#define PINS_SIZE_PLATFORM 3 /* the following will use mbox 0 */
#define PINS_SIZE_CPU_DVFS 4
#define PINS_SIZE_QOS 4
#define PINS_SIZE_TST1 4
#define PINS_SIZE_FHCTL 9
/* ============================================================ */
#define PINS_SIZE_MCDI 2 /* the following will use mbox 1 */
#define PINS_SIZE_SPM_SUSPEND 8
#define PINS_SIZE_PMIC 5
#define PINS_SIZE_PPM 7
#define PINS_SIZE_THERMAL 4
#define PINS_SIZE_UPOWER 4
#define PINS_SIZE_CM 2
/* ============================================================ */
/* definition of slot offset for PINs */
#define PINS_OFFSET_PLATFORM 0 /* the following will use mbox 0 */
#define PINS_OFFSET_CPU_DVFS (PINS_OFFSET_PLATFORM + PINS_SIZE_PLATFORM)
#define PINS_OFFSET_QOS (PINS_OFFSET_CPU_DVFS + PINS_SIZE_CPU_DVFS)
#define PINS_OFFSET_TST1 (PINS_OFFSET_QOS + PINS_SIZE_QOS)
#define PINS_OFFSET_FHCTL (PINS_OFFSET_TST1 + PINS_SIZE_TST1)
#define PINS_MBOX0_USED (PINS_OFFSET_FHCTL + PINS_SIZE_FHCTL)
#if (PINS_MBOX0_USED > IPI_MBOX0_SLOTS)
#error "MBOX0 cannot hold all pin definitions"
#endif
/* ============================================================ */
#define PINS_OFFSET_MCDI 0 /* the following will use mbox 1 */
#define PINS_OFFSET_SPM_SUSPEND (PINS_OFFSET_MCDI + PINS_SIZE_MCDI)
#define PINS_OFFSET_PMIC (PINS_OFFSET_SPM_SUSPEND + \
PINS_SIZE_SPM_SUSPEND)
#define PINS_OFFSET_PPM (PINS_OFFSET_PMIC + PINS_SIZE_PMIC)
#define PINS_OFFSET_THERMAL (PINS_OFFSET_PPM + PINS_SIZE_PPM)
#define PINS_OFFSET_UPOWER (PINS_OFFSET_THERMAL + PINS_SIZE_THERMAL)
#define PINS_OFFSET_CM (PINS_OFFSET_UPOWER + PINS_SIZE_UPOWER)
#define PINS_MBOX1_USED (PINS_OFFSET_CM + PINS_SIZE_CM)
#if (PINS_MBOX1_USED > IPI_MBOX1_SLOTS)
#error "MBOX1 cannot hold all pin definitions"
#endif
/* ============================================================ */
/* definition of slot size for received PINs */
#define PINR_SIZE_PLATFORM 3 /* the following will use mbox 2 */
#define PINR_SIZE_CPU_DVFS 4
#define PINR_SIZE_QOS 4
#define PINR_SIZE_TST1 4
/* definition of slot offset for PINs */
#define PINR_OFFSET_PLATFORM 0 /* the following will use mbox 2 */
#define PINR_OFFSET_CPU_DVFS (PINR_OFFSET_PLATFORM + PINR_SIZE_PLATFORM)
#define PINR_OFFSET_QOS (PINR_OFFSET_CPU_DVFS + PINR_SIZE_CPU_DVFS)
#define PINR_OFFSET_TST1 (PINR_OFFSET_QOS + PINR_SIZE_QOS)
#define PINR_MBOX2_USED (PINR_OFFSET_TST1 + PINR_SIZE_TST1)
#if (PINR_MBOX2_USED > IPI_MBOX2_SLOTS)
#error "MBOX2 cannot hold all pin definitions"
#endif
/* mutex_send, sema_ack, mbox, slot, size,
* shared, retdata, lock, share_grp, polling, unused
*/
struct _pin_send mt6761_send_pintable[] = {
{{{0} }, {0}, 0, PINS_OFFSET_PLATFORM, PINS_SIZE_PLATFORM,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_CPU_DVFS, PINS_SIZE_CPU_DVFS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_QOS, PINS_SIZE_QOS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_TST1, PINS_SIZE_TST1,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_FHCTL, PINS_SIZE_FHCTL,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
{{{0} }, {0}, 1, PINS_OFFSET_MCDI, PINS_SIZE_MCDI,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_SPM_SUSPEND, PINS_SIZE_SPM_SUSPEND,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PMIC, PINS_SIZE_PMIC,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PPM, PINS_SIZE_PPM,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_THERMAL, PINS_SIZE_THERMAL,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_UPOWER, PINS_SIZE_UPOWER,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_CM, PINS_SIZE_CM,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
};
#define MT6761_TOTAL_SEND_PIN \
(sizeof(mt6761_send_pintable)/sizeof(struct _pin_send))
/* act, mbox, slot, size, shared, retdata, lock, share_grp, unused */
struct _pin_recv mt6761_recv_pintable[] = {
{NULL, 2, PINR_OFFSET_PLATFORM, PINR_SIZE_PLATFORM, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_CPU_DVFS, PINR_SIZE_CPU_DVFS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_QOS, PINR_SIZE_QOS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_TST1, PINR_SIZE_TST1, 0, 1, 0, 0, 0},
};
#define MT6761_TOTAL_RECV_PIN \
(sizeof(mt6761_recv_pintable)/sizeof(struct _pin_recv))
/* info for all mbox: start, end, used_slot, mode, unused */
struct _mbox_info mt6761_mbox_table[IPI_MBOX_TOTAL] = {
{0, 4, PINS_MBOX0_USED, 2, 0}, /* mbox 0 for send */
{5, 11, PINS_MBOX1_USED, 2, 0}, /* mbox 1 for send */
{0, 3, PINR_MBOX2_USED, 1, 0}, /* mbox 2 for recv */
{0, 0, 0, 0, 0}, /* mbox 3 */
};
char *mt6761_pin_name[IPI_ID_TOTAL] = {
"PLATFORM",
"CPU_DVFS",
"QOS",
"TST1",
"FHCTL",
"MCDI",
"SPM_SUSPEND",
"PMIC",
"PPM",
"Thermal",
"UPower",
"CM_MGR",
};
#endif /* __SSPM_IPI_DEFINE_H__ */
@@ -0,0 +1,133 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_DEFINE_H__
#define __SSPM_IPI_DEFINE_H__
/* definition of slot size for send PINs */
#define PINS_SIZE_PLATFORM 3 /* the following will use mbox 0 */
#define PINS_SIZE_CPU_DVFS 4
#define PINS_SIZE_QOS 4
#define PINS_SIZE_TST1 4
#define PINS_SIZE_FHCTL 9
/* ============================================================ */
#define PINS_SIZE_MCDI 2 /* the following will use mbox 1 */
#define PINS_SIZE_SPM_SUSPEND 8
#define PINS_SIZE_PMIC 5
#define PINS_SIZE_PPM 7
#define PINS_SIZE_THERMAL 4
#define PINS_SIZE_UPOWER 4
#define PINS_SIZE_UNUSED 0
/* ============================================================ */
/* definition of slot offset for PINs */
#define PINS_OFFSET_PLATFORM 0 /* the following will use mbox 0 */
#define PINS_OFFSET_CPU_DVFS (PINS_OFFSET_PLATFORM + PINS_SIZE_PLATFORM)
#define PINS_OFFSET_QOS (PINS_OFFSET_CPU_DVFS + PINS_SIZE_CPU_DVFS)
#define PINS_OFFSET_TST1 (PINS_OFFSET_QOS + PINS_SIZE_QOS)
#define PINS_OFFSET_FHCTL (PINS_OFFSET_TST1 + PINS_SIZE_TST1)
#define PINS_MBOX0_USED (PINS_OFFSET_FHCTL + PINS_SIZE_FHCTL)
#if (PINS_MBOX0_USED > IPI_MBOX0_SLOTS)
#error "MBOX0 cannot hold all pin definitions"
#endif
/* ============================================================ */
#define PINS_OFFSET_MCDI 0 /* the following will use mbox 1 */
#define PINS_OFFSET_SPM_SUSPEND (PINS_OFFSET_MCDI + PINS_SIZE_MCDI)
#define PINS_OFFSET_PMIC (PINS_OFFSET_SPM_SUSPEND + \
PINS_SIZE_SPM_SUSPEND)
#define PINS_OFFSET_PPM (PINS_OFFSET_PMIC + PINS_SIZE_PMIC)
#define PINS_OFFSET_THERMAL (PINS_OFFSET_PPM + PINS_SIZE_PPM)
#define PINS_OFFSET_UPOWER (PINS_OFFSET_THERMAL + PINS_SIZE_THERMAL)
#define PINS_OFFSET_UNUSED (PINS_OFFSET_UPOWER + PINS_SIZE_UPOWER)
#define PINS_MBOX1_USED (PINS_OFFSET_UNUSED + PINS_SIZE_UNUSED)
#if (PINS_MBOX1_USED > IPI_MBOX1_SLOTS)
#error "MBOX1 cannot hold all pin definitions"
#endif
/* ============================================================ */
/* definition of slot size for received PINs */
#define PINR_SIZE_PLATFORM 3 /* the following will use mbox 2 */
#define PINR_SIZE_CPU_DVFS 4
#define PINR_SIZE_QOS 4
#define PINR_SIZE_TST1 4
/* definition of slot offset for PINs */
#define PINR_OFFSET_PLATFORM 0 /* the following will use mbox 2 */
#define PINR_OFFSET_CPU_DVFS (PINR_OFFSET_PLATFORM + PINR_SIZE_PLATFORM)
#define PINR_OFFSET_QOS (PINR_OFFSET_CPU_DVFS + PINR_SIZE_CPU_DVFS)
#define PINR_OFFSET_TST1 (PINR_OFFSET_QOS + PINR_SIZE_QOS)
#define PINR_MBOX2_USED (PINR_OFFSET_TST1 + PINR_SIZE_TST1)
#if (PINR_MBOX2_USED > IPI_MBOX2_SLOTS)
#error "MBOX2 cannot hold all pin definitions"
#endif
/* mutex_send, sema_ack, mbox, slot, size,
* shared, retdata, lock, share_grp, polling, unused
*/
struct _pin_send mt6765_send_pintable[] = {
{{{0} }, {0}, 0, PINS_OFFSET_PLATFORM, PINS_SIZE_PLATFORM,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_CPU_DVFS, PINS_SIZE_CPU_DVFS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_QOS, PINS_SIZE_QOS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_TST1, PINS_SIZE_TST1,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_FHCTL, PINS_SIZE_FHCTL,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
{{{0} }, {0}, 1, PINS_OFFSET_MCDI, PINS_SIZE_MCDI,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_SPM_SUSPEND, PINS_SIZE_SPM_SUSPEND,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PMIC, PINS_SIZE_PMIC,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PPM, PINS_SIZE_PPM,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_THERMAL, PINS_SIZE_THERMAL,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_UPOWER, PINS_SIZE_UPOWER,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_UNUSED, PINS_SIZE_UNUSED,
0, 0, 0, 0, 0, 0},
/*====================================================================*/
};
#define MT6765_TOTAL_SEND_PIN \
(sizeof(mt6765_send_pintable)/sizeof(struct _pin_send))
/* act, mbox, slot, size, shared, retdata, lock, share_grp, unused */
struct _pin_recv mt6765_recv_pintable[] = {
{NULL, 2, PINR_OFFSET_PLATFORM, PINR_SIZE_PLATFORM, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_CPU_DVFS, PINR_SIZE_CPU_DVFS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_QOS, PINR_SIZE_QOS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_TST1, PINR_SIZE_TST1, 0, 1, 0, 0, 0},
};
#define MT6765_TOTAL_RECV_PIN \
(sizeof(mt6765_recv_pintable)/sizeof(struct _pin_recv))
/* info for all mbox: start, end, used_slot, mode, unused */
struct _mbox_info mt6765_mbox_table[IPI_MBOX_TOTAL] = {
{0, 4, PINS_MBOX0_USED, 2, 0}, /* mbox 0 for send */
{5, 10, PINS_MBOX1_USED, 2, 0}, /* mbox 1 for send */
{0, 3, PINR_MBOX2_USED, 1, 0}, /* mbox 2 for recv */
{0, 0, 0, 0, 0}, /* mbox 3 */
};
char *mt6765_pin_name[IPI_ID_TOTAL] = {
"PLATFORM",
"CPU_DVFS",
"QOS",
"TST1",
"FHCTL",
"MCDI",
"SPM_SUSPEND",
"PMIC",
"PPM",
"Thermal",
"UPower",
"UN_USED",
};
#endif /* __SSPM_IPI_DEFINE_H__ */
@@ -0,0 +1,133 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_DEFINE_H__
#define __SSPM_IPI_DEFINE_H__
/* definition of slot size for send PINs */
#define PINS_SIZE_PLATFORM 3 /* the following will use mbox 0 */
#define PINS_SIZE_CPU_DVFS 4
#define PINS_SIZE_QOS 6
#define PINS_SIZE_TST1 4
#define PINS_SIZE_FHCTL 9
/* ============================================================ */
#define PINS_SIZE_MCDI 2 /* the following will use mbox 1 */
#define PINS_SIZE_SPM_SUSPEND 8
#define PINS_SIZE_PMIC 5
#define PINS_SIZE_PPM 7
#define PINS_SIZE_THERMAL 4
#define PINS_SIZE_UPOWER 4
#define PINS_SIZE_CM 2
/* ============================================================ */
/* definition of slot offset for PINs */
#define PINS_OFFSET_PLATFORM 0 /* the following will use mbox 0 */
#define PINS_OFFSET_CPU_DVFS (PINS_OFFSET_PLATFORM + PINS_SIZE_PLATFORM)
#define PINS_OFFSET_QOS (PINS_OFFSET_CPU_DVFS + PINS_SIZE_CPU_DVFS)
#define PINS_OFFSET_TST1 (PINS_OFFSET_QOS + PINS_SIZE_QOS)
#define PINS_OFFSET_FHCTL (PINS_OFFSET_TST1 + PINS_SIZE_TST1)
#define PINS_MBOX0_USED (PINS_OFFSET_FHCTL + PINS_SIZE_FHCTL)
#if (PINS_MBOX0_USED > IPI_MBOX0_SLOTS)
#error "MBOX0 cannot hold all pin definitions"
#endif
/* ============================================================ */
#define PINS_OFFSET_MCDI 0 /* the following will use mbox 1 */
#define PINS_OFFSET_SPM_SUSPEND (PINS_OFFSET_MCDI + PINS_SIZE_MCDI)
#define PINS_OFFSET_PMIC (PINS_OFFSET_SPM_SUSPEND + \
PINS_SIZE_SPM_SUSPEND)
#define PINS_OFFSET_PPM (PINS_OFFSET_PMIC + PINS_SIZE_PMIC)
#define PINS_OFFSET_THERMAL (PINS_OFFSET_PPM + PINS_SIZE_PPM)
#define PINS_OFFSET_UPOWER (PINS_OFFSET_THERMAL + PINS_SIZE_THERMAL)
#define PINS_OFFSET_CM (PINS_OFFSET_UPOWER + PINS_SIZE_UPOWER)
#define PINS_MBOX1_USED (PINS_OFFSET_CM + PINS_SIZE_CM)
#if (PINS_MBOX1_USED > IPI_MBOX1_SLOTS)
#error "MBOX1 cannot hold all pin definitions"
#endif
/* ============================================================ */
/* definition of slot size for received PINs */
#define PINR_SIZE_PLATFORM 3 /* the following will use mbox 2 */
#define PINR_SIZE_CPU_DVFS 4
#define PINR_SIZE_QOS 6
#define PINR_SIZE_TST1 4
/* definition of slot offset for PINs */
#define PINR_OFFSET_PLATFORM 0 /* the following will use mbox 2 */
#define PINR_OFFSET_CPU_DVFS (PINR_OFFSET_PLATFORM + PINR_SIZE_PLATFORM)
#define PINR_OFFSET_QOS (PINR_OFFSET_CPU_DVFS + PINR_SIZE_CPU_DVFS)
#define PINR_OFFSET_TST1 (PINR_OFFSET_QOS + PINR_SIZE_QOS)
#define PINR_MBOX2_USED (PINR_OFFSET_TST1 + PINR_SIZE_TST1)
#if (PINR_MBOX2_USED > IPI_MBOX2_SLOTS)
#error "MBOX2 cannot hold all pin definitions"
#endif
/* mutex_send, sema_ack, mbox, slot, size,
* shared, retdata, lock, share_grp, polling, unused
*/
struct _pin_send mt6779_send_pintable[] = {
{{{0} }, {0}, 0, PINS_OFFSET_PLATFORM, PINS_SIZE_PLATFORM,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_CPU_DVFS, PINS_SIZE_CPU_DVFS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_QOS, PINS_SIZE_QOS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_TST1, PINS_SIZE_TST1,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_FHCTL, PINS_SIZE_FHCTL,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
{{{0} }, {0}, 1, PINS_OFFSET_MCDI, PINS_SIZE_MCDI,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_SPM_SUSPEND, PINS_SIZE_SPM_SUSPEND,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PMIC, PINS_SIZE_PMIC,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PPM, PINS_SIZE_PPM,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_THERMAL, PINS_SIZE_THERMAL,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_UPOWER, PINS_SIZE_UPOWER,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_CM, PINS_SIZE_CM,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
};
#define MT6779_TOTAL_SEND_PIN \
(sizeof(mt6779_send_pintable)/sizeof(struct _pin_send))
/* act, mbox, slot, size, shared, retdata, lock, share_grp, unused */
struct _pin_recv mt6779_recv_pintable[] = {
{NULL, 2, PINR_OFFSET_PLATFORM, PINR_SIZE_PLATFORM, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_CPU_DVFS, PINR_SIZE_CPU_DVFS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_QOS, PINR_SIZE_QOS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_TST1, PINR_SIZE_TST1, 0, 1, 0, 0, 0},
};
#define MT6779_TOTAL_RECV_PIN \
(sizeof(mt6779_recv_pintable)/sizeof(struct _pin_recv))
/* info for all mbox: start, end, used_slot, mode, unused */
struct _mbox_info mt6779_mbox_table[IPI_MBOX_TOTAL] = {
{0, 4, PINS_MBOX0_USED, 2, 0}, /* mbox 0 for send */
{5, 11, PINS_MBOX1_USED, 2, 0}, /* mbox 1 for send */
{0, 3, PINR_MBOX2_USED, 1, 0}, /* mbox 2 for recv */
{0, 0, 0, 0, 0}, /* mbox 3 */
};
char *mt6779_pin_name[IPI_ID_TOTAL] = {
"PLATFORM",
"CPU_DVFS",
"QOS",
"TST1",
"FHCTL",
"MCDI",
"SPM_SUSPEND",
"PMIC",
"PPM",
"Thermal",
"UPower",
"CM_MGR",
};
#endif /* __SSPM_IPI_DEFINE_H__ */
+847
View File
@@ -0,0 +1,847 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/atomic.h>
#include <linux/io.h>
#include <linux/sched/clock.h>
#include "sspm_define.h"
#include "sspm_common.h"
#include "sspm_mbox.h"
#include "sspm_ipi.h"
#include "sspm_ipi_mbox.h"
#ifdef SSPM_STF_ENABLED
#include <linux/cpu.h>
#include "sspm_stf.h"
#endif
#define IPI_MONITOR
#define TIMEOUT_COMPLETE msecs_to_jiffies(2000)
/* #define GET_IPI_TIMESTAMP */
#ifdef GET_IPI_TIMESTAMP
#include <linux/cpu.h>
#define IPI_TS_TEST_MAX 20
#define IPI_TS_TEST_PIN IPI_ID_PMIC_WRAP
u64 ipi_t0[IPI_TS_TEST_MAX];
u64 ipi_t4[IPI_TS_TEST_MAX];
u64 ipi_t5[IPI_TS_TEST_MAX];
static int test_cnt;
#endif
#ifdef IPI_MONITOR
#define IPI_MONITOR_TIMESTAMP
struct ipi_monitor {
/* 0: has no timestamp of t1/t2/t3 otherwise 1*/
unsigned int has_time: 1,
/* 0: no IPI, 1: t1 finished, 2: t2 finished, 3: t3 finished */
state : 2,
/* count of the IPI pin used */
seqno : 29;
#ifdef IPI_MONITOR_TIMESTAMP
unsigned long long t0;
unsigned long long t4;
unsigned long long t5;
#endif /* IPI_MONITOR_TIMESTAMP */
};
struct _mbox_info *mbox_table;
struct _pin_send *send_pintable;
struct _pin_recv *recv_pintable;
char *(*pin_name);
static struct ipi_monitor ipimon[IPI_ID_TOTAL];
static int ipi_last;
static spinlock_t lock_monitor;
#ifdef IPI_MONITOR_TIMESTAMP
static int err_pin;
static unsigned long long err_ts;
#endif /* IPI_MONITOR_TIMESTAMP */
static inline int check_table_tag(int mcnt)
{
int i, j = 0, k = 0, n = 0;
uint32_t data, check;
struct _pin_recv *rpin = NULL;
struct _pin_send *spin = NULL;
for (i = 0; i < mcnt; i++) {
if (mbox_table[i].mode == 0)
continue;
/* Write init data into mailbox */
j = mbox_table[i].start;
if (mbox_table[i].mode == 1) { /* for recev */
rpin = &(recv_pintable[j]);
data = 2;
} else if (mbox_table[i].mode == 2) { /* for send */
spin = &(send_pintable[j]);
data = 1;
} else {
pr_debug("Error: mbox %d has unsupported mode=%d\n",
i, mbox_table[i].mode);
return -2;
}
data = ((data<<16)|('M'<<24));
if (IPI_MBOX_MODE & (1 << i)) {
/* 64 slots in the mailbox */
data |= 0x00800000;
}
/* for each pin in the mbox */
for (; j <= mbox_table[i].end; j++) {
if (mbox_table[i].mode == 1) { /* for recev */
k = rpin->slot;
n = rpin->size;
rpin++;
} else if (mbox_table[i].mode == 2) { /* for send */
k = spin->slot;
n = spin->size;
spin++;
}
/* for each slot in the pin */
data &= ~0xFFFF;
data |= (j << 8)|((uint8_t)(n));
while (n) {
sspm_mbox_read(i, k, &check, 1);
if (check != data) {
pr_debug("Error: IPI Dismatch!! mbox:%d pin:%d slot=%d should be %08X but now %08X\n",
i, j, k, data, check);
return -3;
}
k++;
n--;
}
}
}
return 0;
}
static void ipi_monitor_dump_timeout(int mid, int opts)
{
int i;
unsigned long flags = 0;
spin_lock_irqsave(&lock_monitor, flags);
#ifdef IPI_MONITOR_TIMESTAMP
err_pin = -1;
err_ts = ULLONG_MAX;
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 1) || (ipimon[i].state == 2)) {
if (ipimon[i].t0 < err_ts) {
err_ts = ipimon[i].t0;
err_pin = i;
}
}
}
if (err_pin >= 0) {
pr_err("Error: possible error IPI %d pin=%s: t0=%llu\n",
err_pin, pin_name[err_pin], err_ts);
}
#endif /* IPI_MONITOR_TIMESTAMP */
pr_err("Error: IPI %d pin=%s mode=%d timeout at %lld (lastOK IPI=%d)\n",
mid, pin_name[mid], opts, cpu_clock(0), ipi_last);
#ifdef IPI_MONITOR_TIMESTAMP
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 0) || (ipimon[i].state == 3))
pr_err("IPI %d: seqno=%d, state=%d, t0=%lld, t4=%lld, t5=%lld\n",
i, ipimon[i].seqno, ipimon[i].state,
ipimon[i].t0, ipimon[i].t4, ipimon[i].t5);
else
pr_err("IPI %d: seqno=%d, state_err=%d, t0=%lld, t4=%lld, t5=%lld\n",
i, ipimon[i].seqno, ipimon[i].state,
ipimon[i].t0, ipimon[i].t4, ipimon[i].t5);
}
#else
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 0) || (ipimon[i].state == 3))
pr_err("IPI %d: seqno=%d, state=%d\n",
i, ipimon[i].seqno, ipimon[i].state);
else
pr_err("IPI %d: seqno=%d, state_err=%d\n",
i, ipimon[i].seqno, ipimon[i].state);
}
#endif /* IPI_MONITOR_TIMESTAMP */
spin_unlock_irqrestore(&lock_monitor, flags);
pr_err("Error: SSPM IPI=%d timeout\n", mid);
sspm_ipi_timeout_cb(mid);
BUG_ON(1);
}
#endif
static void ipi_check_send(int mid)
{
#ifdef SSPM_STF_ENABLED
if (test_table[mid].data)
test_table[mid].start_us = (unsigned int)(cpu_clock(0)/1000);
#endif /* SSPM_STF_ENABLED */
#ifdef GET_IPI_TIMESTAMP
if ((mid == IPI_TS_TEST_PIN) && (test_cnt < IPI_TS_TEST_MAX))
ipi_t0[test_cnt] = cpu_clock(0);
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
ipimon[mid].seqno++;
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[mid].t0 = cpu_clock(0);
ipimon[mid].t4 = 0;
ipimon[mid].t5 = 0;
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[mid].state = 1;
#endif /* IPI_MONITOR */
}
static void ipi_check_ack(int mid, int opts, int ret)
{
if (!ret) {
#ifdef SSPM_STF_ENABLED
if (test_table[mid].data) {
struct chk_data *pdata = test_table[mid].data;
int cnt = test_table[mid].test_cnt;
pdata[cnt].time_spent = ((unsigned int)
(cpu_clock(0)/1000) - test_table[mid].start_us);
if (retbuf)
pdata[cnt].ack_data_feedback =
*((unsigned int *)retbuf);
else
pdata[cnt].ack_data_feedback = 0;
test_table[mid].test_cnt++;
}
#endif /* SSPM_STF_ENABLED */
#ifdef GET_IPI_TIMESTAMP
if ((mid == IPI_TS_TEST_PIN) && (test_cnt < IPI_TS_TEST_MAX)) {
ipi_t5[test_cnt] = cpu_clock(0);
test_cnt++;
}
if (test_cnt >= IPI_TS_TEST_MAX) {
int i;
for (i = 0; i < IPI_TS_TEST_MAX; i++)
pr_err("IPI %d: t0=%llu, t4=%llu, t5=%llu\n",
i, ipi_t0[i], ipi_t4[i], ipi_t5[i]);
test_cnt = 0;
}
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[mid].t5 = cpu_clock(0);
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[mid].state = 3;
ipi_last = mid;
} else { /* timeout case */
ipi_monitor_dump_timeout(mid, opts);
}
#else
}
#endif /* IPI_MONITOR */
}
atomic_t lock_send[TOTAL_SEND_PIN];
atomic_t lock_ack[TOTAL_SEND_PIN];
spinlock_t lock_polling[TOTAL_SEND_PIN];
/* used for IPI module isr to sync with its task */
struct completion sema_ipi_task[TOTAL_RECV_PIN];
struct mutex mutex_ipi_reg;
static int sspm_ipi_inited;
static unsigned int ipi_isr_cb(unsigned int mbox, void __iomem *base,
unsigned int irq);
int sspm_ipi_init(void)
{
int i, ret;
struct _pin_send *pin;
#ifdef IPI_MONITOR
spin_lock_init(&lock_monitor);
#ifdef IPI_MONITOR_TIMESTAMP
for (i = 0; i < IPI_ID_TOTAL; i++)
ipimon[i].has_time = 1;
#endif /* IPI_MONITOR_TIMESTAMP */
#endif /* IPI_MONITOR */
mutex_init(&mutex_ipi_reg);
for (i = 0; i < TOTAL_SEND_PIN; i++) {
mutex_init(&send_pintable[i].mutex_send);
init_completion(&send_pintable[i].comp_ack);
atomic_set(&lock_send[i], 1);
atomic_set(&lock_ack[i], 0);
spin_lock_init(&lock_polling[i]);
}
/* IPI HW initialize and ISR registration */
if (sspm_mbox_init(IPI_MBOX_MODE, IPI_MBOX_TOTAL, ipi_isr_cb) != 0) {
pr_err("Error: sspm_mbox_init failed\n");
return -1;
}
for (i = 0; i < TOTAL_SEND_PIN; i++) {
pin = &(send_pintable[i]);
pin->prdata = sspm_mbox_addr(pin->mbox, pin->slot);
}
ret = check_table_tag(IPI_MBOX_TOTAL);
if (ret == 0)
sspm_ipi_inited = 1;
return ret;
}
extern int sspm_ipi_is_inited(void)
{
return sspm_ipi_inited;
}
int sspm_ipi_recv_registration(int mid, struct ipi_action *act)
{
struct _pin_recv *pin;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
if (act == NULL)
return IPI_REG_ACTION_ERROR;
pin = &(recv_pintable[mid]);
act->id = mid;
act->lock = NULL;
mutex_lock(&mutex_ipi_reg);
if (pin->act != NULL) {
mutex_unlock(&mutex_ipi_reg);
return IPI_REG_ALREADY;
}
mutex_unlock(&mutex_ipi_reg);
init_completion(&sema_ipi_task[mid]);
pin->act = act;
return IPI_REG_OK;
}
EXPORT_SYMBOL_GPL(sspm_ipi_recv_registration);
int sspm_ipi_recv_registration_ex(int mid, spinlock_t *lock,
struct ipi_action *act)
{
int ret = IPI_REG_OK;
ret = sspm_ipi_recv_registration(mid, act);
if (ret != IPI_REG_OK)
return ret;
act->lock = lock;
return IPI_REG_OK;
}
EXPORT_SYMBOL_GPL(sspm_ipi_recv_registration_ex);
int sspm_ipi_recv_wait(int mid)
{
struct _pin_recv *pin;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(recv_pintable[mid]);
wait_for_completion(&sema_ipi_task[mid]);
/* if the pin is waiting async data, eliminate multiple completions */
if (pin->act->lock)
while (try_wait_for_completion(&sema_ipi_task[mid]))
;
return 0;
}
EXPORT_SYMBOL_GPL(sspm_ipi_recv_wait);
void sspm_ipi_recv_complete(int mid)
{
complete(&sema_ipi_task[mid]);
}
EXPORT_SYMBOL_GPL(sspm_ipi_recv_complete);
int sspm_ipi_recv_unregistration(int mid)
{
struct _pin_recv *pin;
pin = &(recv_pintable[mid]);
pin->act = NULL;
return IPI_REG_OK;
}
EXPORT_SYMBOL_GPL(sspm_ipi_recv_unregistration);
static void ipi_do_ack(struct _mbox_info *mbox, unsigned int in_irq,
void __iomem *base)
{
/* executed from ISR */
int idx_end = mbox->end;
int idx_start = mbox->start;
int i;
struct _pin_send *pin = &(send_pintable[idx_start]);
for (i = idx_start; i <= idx_end; i++, pin++) {
if ((in_irq & 0x01) == 0x01) { /* irq bit enable */
atomic_inc(&lock_ack[i]);
/* check if pin user send in WAIT mode,
* wait lock & continue if not
*/
if (mutex_is_locked(&pin->mutex_send)) { /* WAIT mode */
#ifdef GET_IPI_TIMESTAMP
if ((i == IPI_TS_TEST_PIN) &&
(test_cnt < IPI_TS_TEST_MAX))
ipi_t4[test_cnt] = cpu_clock(0);
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[i].t4 = cpu_clock(0);
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[i].state = 2;
#endif /* IPI_MONITOR */
complete(&pin->comp_ack);
}
}
in_irq >>= 1;
}
}
static int handle_action(struct ipi_action *action, void *mbox_addr,
int bytelen)
{
/* if user has no data, just wakeup user without data */
if (action->data == NULL)
return 1;
/* if user async send without waiting ACK from SSPM */
/* use spin lock to mempcy without overwriting user data */
if (action->lock) {
if (spin_trylock(action->lock)) {
memcpy_from_sspm(action->data, mbox_addr, bytelen);
} else {
/* Users has lock. Just drop data */
return 0;
}
spin_unlock(action->lock);
} else {
memcpy_from_sspm(action->data, mbox_addr, bytelen);
}
return 1;
}
static void ipi_do_recv(struct _mbox_info *mbox, unsigned int in_irq,
void __iomem *base)
{
/* executed from ISR */
/* get the value from INT_IRQ_x (MD32 side) or OUT_IRQ_0 (Linux side) */
int idx_end = mbox->end;
int idx_start = mbox->start;
int i, ret;
struct _pin_recv *pin;
struct ipi_action *action;
if (in_irq == 0)
return;
/* check each bit for interrupt triggered */
/* the bit is used to determine the index of callback array */
pin = &(recv_pintable[idx_start]);
for (i = idx_start; i <= idx_end; i++, pin++) {
if ((in_irq & 0x01) == 0x01) { /* irq bit enable */
action = pin->act;
if (action != NULL) {
/* do the action */
ret = handle_action(action, (void *)
(base + (pin->slot * MBOX_SLOT_SIZE)),
pin->size * MBOX_SLOT_SIZE);
if (ret)
complete(&sema_ipi_task[i]);
}
} /* check bit is enabled */
in_irq >>= 1;
} /* check INT_IRQ bits */
}
int sspm_ipi_send_async(int mid, int opts, void *buffer, int slot)
{
int mbno, ret, lock = 0;
struct _pin_send *pin;
struct _mbox_info *mbox;
int timeout;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(send_pintable[mid]);
if (!pin->async)
return IPI_PIN_MISUES;
if (slot > pin->size)
return IPI_NO_MEMORY;
ipi_check_send(mid);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
if (!(opts & IPI_OPT_REDEF_MASK)) {
lock = pin->lock & IPI_LOCK_ORIGINAL;
} else {
if (opts & IPI_OPT_LOCK_MASK) {
lock = 1;
pin->lock |= 0x6;
} else {
pin->lock |= 0x4;
}
}
if (lock == 0) { /* use mutex */
mutex_lock(&pin->mutex_send);
} else { /* use spin method */
timeout = 0xffff;
while (atomic_read(&lock_send[mid]) == 0) {
timeout--;
udelay(10); /* fix me later, should we add this one? */
if (timeout == 0) {
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
return IPI_TIMEOUT_AVL;
}
}
atomic_dec(&lock_send[mid]);
}
atomic_set(&lock_ack[mid], 0);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
/* note: the bit of INT(OUT)_IRQ is depending on mid */
if (slot == 0)
slot = pin->size;
ret = sspm_mbox_send(mbno, pin->slot, mid - mbox->start, buffer, slot);
if (ret != 0) {
#ifdef IPI_MONITOR
ipimon[mid].seqno--;
#endif
/* release lock */
if (lock == 0) /* use mutex */
mutex_unlock(&pin->mutex_send);
else
atomic_inc(&lock_send[mid]);
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
return IPI_HW_ERROR;
}
return IPI_DONE;
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_async);
int sspm_ipi_send_async_wait(int mid, int opts, void *retbuf)
{
int slot = 1;
if (retbuf == NULL)
slot = 0;
return sspm_ipi_send_async_wait_ex(mid, opts, retbuf, slot);
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_async_wait);
int sspm_ipi_send_async_wait_ex(int mid, int opts, void *retbuf, int retslot)
{
int ret = 0, lock = 0, polling = 0;
struct _pin_send *pin;
unsigned long wait_comp;
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(send_pintable[mid]);
if (!pin->async)
return IPI_PIN_MISUES;
if (retslot > pin->size)
return IPI_NO_MEMORY;
if (!(opts & IPI_OPT_REDEF_MASK)) {
lock = pin->lock & IPI_LOCK_ORIGINAL;
polling = pin->polling;
} else {
if (opts & IPI_OPT_LOCK_MASK) {
lock = 1;
pin->lock |= 0x6;
if (opts & IPI_OPT_POLLING_MASK)
polling = 1;
} else {
pin->lock |= 0x4;
}
}
if (!lock) { /* use completion */
wait_comp = wait_for_completion_timeout(&pin->comp_ack,
TIMEOUT_COMPLETE);
if ((wait_comp == 0) && (atomic_read(&lock_ack[mid]) == 0)) {
/* wait mode timeout */
ret = IPI_TIMEOUT_ACK;
} else {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(MBOX_SLOT_SIZE * retslot));
}
atomic_set(&lock_ack[mid], 0);
} else { /* use spin method */
int retries = 2000000;
while (retries-- > 0) {
int mbno = pin->mbox;
struct _mbox_info *mbox = &(mbox_table[mbno]);
ret = sspm_mbox_polling(mbno, mid - mbox->start,
pin->slot, retbuf, retslot, 2000);
if (!ret)
break;
if (atomic_read(&lock_ack[mid])) {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(MBOX_SLOT_SIZE * retslot));
ret = 0;
break;
}
udelay(1);
}
atomic_set(&lock_ack[mid], 0);
if (retries == 0)
ret = IPI_TIMEOUT_ACK;
}
/* Release mutex */
if (!lock) /* use mutex */
mutex_unlock(&pin->mutex_send);
else
atomic_inc(&lock_send[mid]);
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
ipi_check_ack(mid, opts, ret);
return ret;
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_async_wait_ex);
int sspm_ipi_send_ack(int mid, unsigned int *data)
{
int len = 1;
if (!data)
len = 0;
return sspm_ipi_send_ack_ex(mid, data, len);
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_ack);
int sspm_ipi_send_ack_ex(int mid, void *data, int retslot)
{
struct _pin_recv *pin;
struct _mbox_info *mbox;
int len, mbno, irq, slot, ret;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(recv_pintable[mid]);
if (retslot > pin->size)
return IPI_NO_MEMORY;
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
irq = mid - (mbox->start);
/* return data length */
if (data && (pin->retdata))
len = retslot;
else
len = 0;
/* where to put the return data */
slot = pin->slot;
ret = sspm_mbox_send(mbno, slot, irq, (void *)data, len);
if (ret)
return -1;
return 0;
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_ack_ex);
int sspm_ipi_send_sync(int mid, int opts, void *buffer, int slot,
void *retbuf, int retslot)
{
unsigned long flags = 0;
unsigned long wait_comp;
int mbno, ret;
struct _pin_send *pin;
struct _mbox_info *mbox;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
/* check if mid is in the predefined range */
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
/* get the predefined pin info from mid */
pin = &(send_pintable[mid]);
if ((slot > pin->size) || (retslot > pin->size))
return IPI_NO_MEMORY;
/* check if IPI can be send in different mode */
if (opts&IPI_OPT_POLLING) { /* POLLING mode */
spin_lock_irqsave(&lock_polling[mid], flags);
if (mutex_is_locked(&pin->mutex_send)) {
spin_unlock_irqrestore(&lock_polling[mid], flags);
pr_err("Error: IPI pin=%d has been used in WAIT mode\n",
mid);
BUG_ON(1);
return IPI_USED_IN_WAIT;
}
} else { /* WAIT mode */
/* Check if users call in atomic/interrupt/IRQ disabled */
if (preempt_count() || in_interrupt() || irqs_disabled()) {
pr_err("IPI panic: pin id=%d, atomic=%d, interrupt=%ld, irq disabled=%d\n",
mid, preempt_count(), in_interrupt(),
irqs_disabled());
BUG_ON(1);
}
mutex_lock(&pin->mutex_send);
}
ipi_check_send(mid);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
/* note: the bit of INT(OUT)_IRQ is depending on mid */
if (slot == 0)
slot = pin->size;
atomic_set(&lock_ack[mid], 0);
/* send IPI data to SSPM */
ret = sspm_mbox_send(mbno, pin->slot, mid - mbox->start, buffer, slot);
if (ret != 0) {
#ifdef IPI_MONITOR
ipimon[mid].seqno--;
#endif
/* release lock */
if (opts&IPI_OPT_POLLING) /* POLLING mode */
spin_unlock_irqrestore(&lock_polling[mid], flags);
else
mutex_unlock(&pin->mutex_send);
return IPI_HW_ERROR;
}
/* if there is no retdata in predefined table */
if (!pin->retdata || !retslot)
retbuf = NULL;
/* wait ACK from SSPM */
if (opts&IPI_OPT_POLLING) { /* POLLING mode */
int retries = 2000000;
while (retries-- > 0) {
ret = sspm_mbox_polling(mbno, mid - mbox->start,
pin->slot, retbuf, retslot, 2000);
if (!ret)
break;
if (atomic_read(&lock_ack[mid])) {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(MBOX_SLOT_SIZE * retslot));
ret = 0;
break;
}
udelay(1);
}
atomic_set(&lock_ack[mid], 0);
if (retries == 0) /* polling mode timeout */
ret = IPI_TIMEOUT_ACK;
ipi_check_ack(mid, opts, ret);
spin_unlock_irqrestore(&lock_polling[mid], flags);
} else { /* WAIT mode */
wait_comp = wait_for_completion_timeout(&pin->comp_ack,
TIMEOUT_COMPLETE);
if ((wait_comp == 0) && (atomic_read(&lock_ack[mid]) == 0)) {
/* wait mode timeout */
ret = IPI_TIMEOUT_ACK;
} else {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(MBOX_SLOT_SIZE * retslot));
}
atomic_set(&lock_ack[mid], 0);
ipi_check_ack(mid, opts, ret);
mutex_unlock(&pin->mutex_send);
}
return ret;
}
EXPORT_SYMBOL_GPL(sspm_ipi_send_sync);
static unsigned int ipi_isr_cb(unsigned int mbno, void __iomem *base,
unsigned int irq)
{
struct _mbox_info *mbox;
if (mbno >= IPI_MBOX_TOTAL)
return irq;
mbox = &(mbox_table[mbno]);
if (mbox->mode == 2) /* ipi_do_ack */
ipi_do_ack(mbox, irq, base);
else if (mbox->mode == 1) /* ipi_do_recv */
ipi_do_recv(mbox, irq, base);
return irq;
}
@@ -0,0 +1,99 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_MBOX_H__
#define __SSPM_IPI_MBOX_H__
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/semaphore.h>
#include <linux/completion.h>
#include <linux/mutex.h>
#define IPI_MBOX_TOTAL 4
#define IPI_MBOX0_64D 0
#define IPI_MBOX1_64D 0
#define IPI_MBOX2_64D 0
#define IPI_MBOX3_64D 0
#define IPI_MBOX4_64D 0
#define IPI_MBOX_MODE ((IPI_MBOX4_64D<<4)|(IPI_MBOX3_64D<<3)| \
(IPI_MBOX2_64D<<2)|(IPI_MBOX1_64D<<1)| \
IPI_MBOX0_64D)
#define IPI_MBOX0_SLOTS ((IPI_MBOX0_64D+1)*32)
#define IPI_MBOX1_SLOTS ((IPI_MBOX1_64D+1)*32)
#define IPI_MBOX2_SLOTS ((IPI_MBOX2_64D+1)*32)
#define IPI_MBOX3_SLOTS ((IPI_MBOX3_64D+1)*32)
#define IPI_MBOX4_SLOTS ((IPI_MBOX4_64D+1)*32)
#define TOTAL_SEND_PIN 12
#define TOTAL_RECV_PIN 4
extern struct _mbox_info *mbox_table;
extern struct _pin_send *send_pintable;
extern struct _pin_recv *recv_pintable;
extern char *(*pin_name);
extern struct completion sema_ipi_task[];
/* pre-define slot and size here */
/* the array index is mapped to bit position of INT_IRQ or OUT_IRQ */
/* the slot is where the data begin */
/* the size is how many registers are needed */
struct _pin_send {
struct mutex mutex_send;
struct completion comp_ack;
unsigned int mbox:3, /* mailbox number used by the pin */
slot:6, /* bit position of INT_IRQ or OUT_IRQ */
size:6, /* register number used to pass argument */
async:1, /* pin can use async functions */
retdata:1, /* return data or not */
lock:3, /* Linux lock method: 0: mutex; 1: busy wait */
polling:1, /* Linux ack polling method */
unused:11;
uint32_t *prdata;
};
struct _pin_recv {
struct ipi_action *act;
unsigned int mbox:3, /* mailbox number used by the pin */
slot:6, /* slot offset of the pin */
size:6, /* register number used to pass argument */
shared:2, /* shared slot */
retdata:2, /* return data or not */
lock:2, /* Linux lock method: 0: mutex; 1: busy wait */
share_grp:5, /* shared group */
unused:6;
};
struct _mbox_info {
unsigned int start:8, /* start index of pin table */
end:8, /* end index of pin table */
used_slot:8, /* used slots in the mailbox */
mode:2, /* 0:disable, 1:for received, 2: for send */
unused:6;
};
#define IPI_SLOT_SHARED 1
#define IPI_SLOT_NONE 0
#define IPI_DATA_RETURN 1
#define IPI_DATA_NONE 0
#define IPI_LOCK_ORIGINAL 0x1
#define IPI_LOCK_NEW 0x2
#define IPI_LOCK_CHANGE 0x4
__weak void sspm_ipi_timeout_cb(int ipi_id) {}
extern struct _mbox_info *mbox_table;
extern struct _pin_send *send_pintable;
extern struct _pin_recv *recv_pintable;
extern char *(*pin_name);
#endif /* __SSPM_IPI_MBOX_H__ */
+30
View File
@@ -0,0 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_IPI_PIN_H__
#define __SSPM_IPI_PIN_H__
/* define module id here ... */
/* use bit 0 - 7 of IN_IRQ of mailbox 0 */
#define IPI_ID_PLATFORM 0 /* the following will use mbox 0 */
#define IPI_ID_CPU_DVFS 1
#define IPI_ID_QOS 2
#define IPI_ID_TST1 3
#define IPI_ID_FHCTL 4
/* use bit 8 - 15 of IN_IRQ of mailbox 1 */
#define IPI_ID_MCDI 5 /* the following will use mbox 1 */
#define IPI_ID_SPM_SUSPEND 6
#define IPI_ID_PMIC 7
#define IPI_ID_PPM 8
#define IPI_ID_THERMAL 9
#define IPI_ID_UPOWER 10
#define IPI_ID_CM 11
#define IPI_ID_TOTAL 12
#define IPI_OPT_REDEF_MASK 0x1
#define IPI_OPT_LOCK_MASK 0x2
#define IPI_OPT_POLLING_MASK 0x4
#endif /* __SSPM_IPI_PIN_H__ */
+14
View File
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_LOGGER_H__
#define __SSPM_LOGGER_H__
#include <linux/types.h>
extern unsigned int __init sspm_logger_init(phys_addr_t start,
phys_addr_t limit);
extern int __init sspm_logger_init_done(void);
#endif
@@ -0,0 +1,256 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/atomic.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
#ifdef SSPM_PLT_LOGGER_BUF_LEN
/* use platform-defined buffer length */
#define BUF_LEN SSPM_PLT_LOGGER_BUF_LEN
#else
/* otherwise use default buffer length */
#define BUF_LEN (1 * 1024 * 1024)
#endif
#define LBUF_LEN (4 * 1024)
#define SSPM_TIMER_TIMEOUT (1 * HZ) /* 1 seconds*/
struct log_ctrl_s {
unsigned int base;
unsigned int size;
unsigned int enable;
unsigned int info_ofs;
unsigned int buff_ofs;
unsigned int buff_size;
};
struct buffer_info_s {
unsigned int r_pos;
unsigned int w_pos;
};
static unsigned int sspm_logger_inited;
static struct log_ctrl_s *log_ctl;
static struct buffer_info_s *buf_info, *lbuf_info;
static struct timer_list sspm_log_timer;
static DEFINE_MUTEX(sspm_log_mutex);
static inline void sspm_log_timer_add(void)
{
if (sspm_log_timer.expires == 0) {
sspm_log_timer.expires = jiffies + SSPM_TIMER_TIMEOUT;
add_timer(&sspm_log_timer);
}
}
static void sspm_log_timeout(struct timer_list *unused)
{
if (buf_info->r_pos != buf_info->w_pos) {
sspm_log_if_wake();
sspm_log_timer.expires = 0;
} else {
sspm_log_timer_add();
}
}
ssize_t sspm_log_read(char __user *data, size_t len)
{
unsigned long w_pos, r_pos, datalen;
char *buf, *tmp_buf;
if (!sspm_logger_inited)
return 0;
datalen = 0;
mutex_lock(&sspm_log_mutex);
r_pos = buf_info->r_pos;
w_pos = buf_info->w_pos;
if (r_pos == w_pos)
goto error;
if (r_pos > w_pos)
datalen = BUF_LEN - r_pos; /* not wrap */
else
datalen = w_pos - r_pos;
if (datalen > len)
datalen = len;
buf = ((char *) log_ctl) + log_ctl->buff_ofs + r_pos;
tmp_buf = kmalloc((size_t)len, GFP_KERNEL);
len = datalen;
if (tmp_buf) {
memcpy_fromio(tmp_buf, buf, len);
if (copy_to_user(data, tmp_buf, len))
pr_debug("sspm logger: copy data failed !!!\n");
kfree(tmp_buf);
} else {
pr_debug("sspm logger: create log buffer failed !!!\n");
goto error;
}
r_pos += datalen;
if (r_pos >= BUF_LEN)
r_pos -= BUF_LEN;
buf_info->r_pos = r_pos;
error:
mutex_unlock(&sspm_log_mutex);
return datalen;
}
unsigned int sspm_log_poll(void)
{
if (!sspm_logger_inited)
return 0;
if (buf_info->r_pos != buf_info->w_pos)
return POLLIN | POLLRDNORM;
sspm_log_timer_add();
return 0;
}
static unsigned int sspm_log_enable_set(unsigned int enable)
{
struct plt_ipi_data_s ipi_data;
int ret, ackdata;
if (sspm_logger_inited) {
ipi_data.cmd = PLT_LOG_ENABLE;
ipi_data.u.logger.enable = enable;
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_WAIT,
&ipi_data, sizeof(ipi_data) / MBOX_SLOT_SIZE, &ackdata, 1);
if (ret != 0) {
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
goto error;
}
if (enable != ackdata) {
pr_err("SSPM: %s fail ret=%d\n", __func__, ackdata);
goto error;
}
log_ctl->enable = enable;
}
error:
return 0;
}
static ssize_t sspm_mobile_log_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
unsigned int stat;
stat = (sspm_logger_inited && log_ctl->enable) ? 1 : 0;
return snprintf(buf, PAGE_SIZE, "SSPM mobile log is %s\n",
(stat == 0x1) ? "enabled" : "disabled");
}
static ssize_t sspm_mobile_log_store(struct device *kobj,
struct device_attribute *attr, const char *buf, size_t n)
{
unsigned int enable;
if (kstrtouint(buf, 0, &enable) != 0)
return -EINVAL;
mutex_lock(&sspm_log_mutex);
sspm_log_enable_set(enable);
mutex_unlock(&sspm_log_mutex);
return n;
}
static DEVICE_ATTR_RW(sspm_mobile_log);
unsigned int __init sspm_logger_init(phys_addr_t start, phys_addr_t limit)
{
unsigned int last_ofs;
last_ofs = 0;
log_ctl = (struct log_ctrl_s *)(uintptr_t) start;
log_ctl->base = PLT_LOG_ENABLE; /* magic */
log_ctl->enable = 0;
log_ctl->size = sizeof(*log_ctl);
last_ofs += log_ctl->size;
log_ctl->info_ofs = last_ofs;
last_ofs += sizeof(*buf_info);
last_ofs = roundup(last_ofs, 4);
log_ctl->buff_ofs = last_ofs;
log_ctl->buff_size = BUF_LEN;
buf_info = (struct buffer_info_s *) (((unsigned char *) log_ctl) +
log_ctl->info_ofs);
buf_info->r_pos = 0;
buf_info->w_pos = 0;
last_ofs += log_ctl->buff_size;
if (last_ofs >= limit) {
pr_err("SSPM:%s() initial fail, last_ofs=%u, limit=%u\n",
__func__, last_ofs, (unsigned int) limit);
goto error;
}
return last_ofs;
error:
sspm_logger_inited = 0;
log_ctl = NULL;
buf_info = lbuf_info = NULL;
return 0;
}
int __init sspm_logger_init_done(void)
{
int ret;
if (log_ctl) {
ret = sspm_sysfs_create_file(&dev_attr_sspm_mobile_log);
if (ret)
return ret;
timer_setup(&sspm_log_timer, &sspm_log_timeout, 0);
sspm_log_timer.expires = 0;
sspm_logger_inited = 1;
}
return 0;
}
+290
View File
@@ -0,0 +1,290 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/delay.h>
#include "sspm_define.h"
#include "sspm_mbox.h"
#include "sspm_common.h"
struct sspm_mbox {
int id;
void __iomem *in_out;
void __iomem *base;
unsigned int size;
unsigned int enable;
sspm_ipi_isr isr;
int irq_num;
};
struct sspm_mbox sspmmbox[SSPM_MBOX_MAX];
static unsigned int sspm_mbox_cnt;
static spinlock_t lock_mbox[SSPM_MBOX_MAX];
unsigned int sspm_mbox_size(int mbox)
{
if (mbox >= sspm_mbox_cnt)
return 0;
return sspmmbox[mbox].size / MBOX_SLOT_SIZE;
}
uint32_t *sspm_mbox_addr(unsigned int mbox, unsigned int slot)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
return (uint32_t *)(desc->base + (MBOX_SLOT_SIZE * slot));
}
int sspm_mbox_read(unsigned int mbox, unsigned int slot, void *data,
unsigned int len)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
if (data)
memcpy_from_sspm(data, desc->base + (MBOX_SLOT_SIZE * slot),
MBOX_SLOT_SIZE*len);
return 0;
}
EXPORT_SYMBOL_GPL(sspm_mbox_read);
int sspm_mbox_write(unsigned int mbox, unsigned int slot, void *data,
unsigned int len)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
if (data)
memcpy_to_sspm(desc->base + (MBOX_SLOT_SIZE * slot), data,
len * MBOX_SLOT_SIZE);
return 0;
}
EXPORT_SYMBOL_GPL(sspm_mbox_write);
int sspm_mbox_polling(unsigned int mbox, unsigned int irq, unsigned int slot,
unsigned int *retdata, unsigned int retlen, unsigned int retries)
{
struct sspm_mbox *desc;
void __iomem *out_irq;
unsigned int irqs = 0;
unsigned long flags = 0;
desc = &sspmmbox[mbox];
irq = 0x1 << irq;
out_irq = desc->in_out + MBOX_OUT_IRQ_OFS;
spin_lock_irqsave(&lock_mbox[mbox], flags);
irqs = readl(out_irq);
if (irqs & irq) {
writel(irq, out_irq);
spin_unlock_irqrestore(&lock_mbox[mbox], flags);
if (retdata)
memcpy_from_sspm(retdata, desc->base +
(MBOX_SLOT_SIZE * slot), MBOX_SLOT_SIZE*retlen);
return 0;
}
spin_unlock_irqrestore(&lock_mbox[mbox], flags);
return -1;
}
int sspm_mbox_send(unsigned int mbox, unsigned int slot, unsigned int irq,
void *data, unsigned int len)
{
struct sspm_mbox *desc;
unsigned int size;
void __iomem *in_irq, *out_irq;
unsigned long flags = 0;
if (mbox >= sspm_mbox_cnt)
return -1;
size = sspm_mbox_size(mbox);
if (slot > size || (slot + len) > size)
return -1;
desc = &sspmmbox[mbox];
in_irq = desc->in_out + MBOX_IN_IRQ_OFS;
out_irq = desc->in_out + MBOX_OUT_IRQ_OFS;
spin_lock_irqsave(&lock_mbox[mbox], flags);
if (readl(out_irq) & (0x1 << irq)) {
pr_err("%s: MBOX%d[%d] out_irq is not clear!\n", __func__,
mbox, irq);
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
return -1;
}
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
if (!desc->enable)
return -1;
/* we only copy data to portion of mbox here .... */
/* len:0, mean send ack (OUT_IRQ) only no data transfer */
if (len > 0)
memcpy_to_sspm(desc->base + (MBOX_SLOT_SIZE * slot), data,
len * MBOX_SLOT_SIZE);
spin_lock_irqsave(&lock_mbox[mbox], flags);
writel(0x1 << irq, in_irq);
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
return 0;
}
/*
* dispatch sspm mbox irq and then reset mbox out irq
* @param irq: irq id
* @param dev_id: pointer point to sspmmbox
};
*/
static irqreturn_t sspm_mbox_irq_handler(int irq, void *dev_id)
{
struct sspm_mbox *desc = (struct sspm_mbox *) dev_id;
unsigned int irqs;
void __iomem *out_irq;
out_irq = desc->in_out + MBOX_OUT_IRQ_OFS;
spin_lock(&lock_mbox[desc->id]);
irqs = readl(out_irq);
writel(irqs, out_irq);
spin_unlock(&lock_mbox[desc->id]);
if (desc->isr)
desc->isr(desc->id, desc->base, irqs);
return IRQ_HANDLED;
}
static int sspm_mbox_group_activate(int mbox, unsigned int is64d,
sspm_ipi_isr isr)
{
struct sspm_mbox *desc;
char name[32];
int ret;
struct device *dev = &sspm_pdev->dev;
struct resource *res;
desc = &sspmmbox[mbox];
desc->size = (is64d) ? SSPM_MBOX_8BYTE : SSPM_MBOX_4BYTE;
desc->isr = isr;
if (sspm_pdev) {
snprintf(name, sizeof(name), "mbox%d_base", mbox);
res = platform_get_resource_byname(sspm_pdev,
IORESOURCE_MEM, name);
if (!res) {
pr_err("[SSPM] mbox%d_base IO resource not found\n",
mbox);
goto fail;
}
desc->base = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) desc->base)) {
pr_err("[SSPM] MBOX %d can't remap BASE\n", mbox);
goto fail;
}
snprintf(name, sizeof(name), "mbox%d_ctrl", mbox);
res = platform_get_resource_byname(sspm_pdev, IORESOURCE_MEM,
name);
if (!res) {
pr_err("[SSPM] mbox%d_ctrl IO resource not found\n",
mbox);
goto fail;
}
desc->in_out = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) desc->in_out)) {
pr_err("[SSPM] MBOX %d can't find IN_OUT_IRQ\n", mbox);
goto fail;
}
snprintf(name, sizeof(name), "mbox%d", mbox);
desc->irq_num = platform_get_irq_byname(sspm_pdev, name);
if (desc->irq_num < 0) {
pr_err("[SSPM] MBOX %d can't find IRQ\n", mbox);
goto fail;
}
ret = request_irq(desc->irq_num, sspm_mbox_irq_handler,
IRQF_TRIGGER_NONE, "SSPM_MBOX", (void *) desc);
if (ret) {
pr_err("[SSPM] MBOX %d request irq Failed\n", mbox);
goto fail;
}
desc->enable = 1;
desc->id = mbox;
}
return 0;
fail:
return -1;
}
/*
* parse device tree and mapping iomem
* @return: 0 if success
*/
unsigned int sspm_mbox_init(unsigned int mode, unsigned int count,
sspm_ipi_isr isr)
{
int mbox;
if (count > SSPM_MBOX_MAX) {
pr_debug("[SSPM] %s(): count (%u) too large, set to %u\n",
__func__, count, SSPM_MBOX_MAX);
count = SSPM_MBOX_MAX;
}
for (mbox = 0; mbox < count; mbox++) {
spin_lock_init(&lock_mbox[mbox]);
if (sspm_mbox_group_activate(mbox, mode & 0x1, isr))
goto fail;
mode >>= 1;
}
sspm_mbox_cnt = mbox;
pr_debug("[SSPM] Find %d MBOX\n", sspm_mbox_cnt);
return 0;
fail:
while (mbox >= 0) {
if (sspmmbox[mbox].irq_num > 0) {
free_irq(sspmmbox[mbox].irq_num, &sspmmbox[mbox]);
sspmmbox[mbox].irq_num = 0;
}
mbox--;
}
return -1;
}
+33
View File
@@ -0,0 +1,33 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_MBOX_H__
#define __SSPM_MBOX_H__
#include <linux/platform_device.h>
enum SSPM_MBOX_SIZE {
SSPM_MBOX_4BYTE = 0x80,
SSPM_MBOX_8BYTE = 0x100,
};
typedef unsigned int (*sspm_ipi_isr)(unsigned int mbox, void __iomem *base,
unsigned int irq);
unsigned int sspm_mbox_size(int mbox);
extern int sspm_mbox_send(unsigned int mbox, unsigned int slot,
unsigned int irq, void *data, unsigned int len);
extern uint32_t *sspm_mbox_addr(unsigned int mbox, unsigned int slot);
extern int sspm_mbox_read(unsigned int mbox, unsigned int slot, void *data,
unsigned int len);
extern int sspm_mbox_write(unsigned int mbox, unsigned int slot, void *data,
unsigned int len);
extern unsigned int sspm_mbox_init(unsigned int mode, unsigned int count,
sspm_ipi_isr ipi_isr_cb);
extern int sspm_mbox_polling(unsigned int mbox, unsigned int irq,
unsigned int slot, unsigned int *retdata, unsigned int retlen,
unsigned int retries);
#endif
+218
View File
@@ -0,0 +1,218 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/platform_device.h>
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/clk.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_sysfs.h"
#include "sspm_reservedmem.h"
#include "sspm_common.h"
#include "sspm_ipi_mbox.h"
#include "sspm_ipi_define_mt6761.h"
#include "sspm_reservedmem_define_mt6761.h"
#include "sspm_timesync.h"
static struct workqueue_struct *mt6761_sspm_workqueue;
static atomic_t sspm_inited = ATOMIC_INIT(0);
static int __init mt6761_sspm_module_init(void)
{
if (atomic_inc_return(&sspm_inited) != 1)
return 0;
pr_info("[SSPM] mt6761-sspm_module_init.\n");
/* static initialise */
sspm_ready = 0;
mt6761_sspm_workqueue = create_workqueue("mt6761-SSPM_WQ");
if (!mt6761_sspm_workqueue) {
pr_err("[SSPM] Workqueue Create Failed\n");
goto error;
}
#ifdef CONFIG_OF_RESERVED_MEM
if (sspm_reserve_memory_init()) {
pr_err("[SSPM] Reserved Memory Failed\n");
goto error;
}
#endif
sspm_ready = 1;
if (sspm_sysfs_init()) {
pr_err("[SSPM] Sysfs Init Failed\n");
return -1;
}
if (sspm_ipi_init()) {
pr_err("[SSPM] IPI Init Failed\n");
return -1;
}
pr_info("SSPM is ready to service IPI\n");
#if SSPM_PLT_SERV_SUPPORT
if (sspm_plt_init()) {
pr_err("[SSPM] Platform Init Failed\n");
return -1;
}
pr_info("SSPM platform service is ready\n");
#endif
#if SSPM_TIMESYNC_SUPPORT
if (sspm_timesync_init()) {
pr_err("SSPM timesync init fail\n");
return -1;
}
#endif
sspm_lock_emi_mpu(4);
return 0;
error:
atomic_set(&sspm_inited, 1);
return -1;
}
static int __init mt6761_sspm_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev = &pdev->dev;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfgreg");
if (!res) {
pr_err("[SSPM] cfgreg IO resource not found\n");
return -ENODEV;
}
sspmreg.cfg = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspmreg.cfg)) {
pr_err("[SSPM] Unable to ioremap registers\n");
return -1;
}
sspmreg.cfgregsize = (unsigned int) resource_size(res);
sspmreg.irq = platform_get_irq_byname(pdev, "ipc");
if (sspmreg.irq < 0) {
pr_err("[SSPM] Unable to get IRQ\n");
return -1;
}
pr_info("[SSPM] mt6761-sspm irq=%d, cfgreg=0x%p\n",
sspmreg.irq, sspmreg.cfg);
sspm_pdev = pdev;
mbox_table = mt6761_mbox_table;
send_pintable = mt6761_send_pintable;
recv_pintable = mt6761_recv_pintable;
pin_name = mt6761_pin_name;
sspm_reserve_mblock = mt6761_sspm_reserve_mblock;
pr_info("[SSPM] mt6761-sspm_probe Done.\n");
mt6761_sspm_module_init();
return 0;
}
#ifdef CONFIG_PM
static int mt6761_sspm_suspend(struct device *dev)
{
sspm_timesync_suspend();
return 0;
}
static int mt6761_sspm_resume(struct device *dev)
{
sspm_timesync_resume();
return 0;
}
static const struct dev_pm_ops mt6761_sspm_dev_pm_ops = {
.suspend = mt6761_sspm_suspend,
.resume = mt6761_sspm_resume,
};
#endif
static const struct of_device_id mt6761_sspm_of_match[] = {
{ .compatible = "mediatek,mt6761-sspm", },
{},
};
static const struct platform_device_id mt6761_sspm_id_table[] = {
{ "mt6761-sspm", 0},
{ },
};
static struct platform_driver mtk_mt6761_sspm_driver __refdata = {
.probe = mt6761_sspm_probe,
.remove = NULL,
.shutdown = NULL,
.suspend = NULL,
.resume = NULL,
.driver = {
.name = "mt6761-sspm",
.owner = THIS_MODULE,
.of_match_table = mt6761_sspm_of_match,
#ifdef CONFIG_PM
.pm = &mt6761_sspm_dev_pm_ops,
#endif
},
.id_table = mt6761_sspm_id_table,
};
/*
* driver initialization entry point
*/
static int __init mt6761_sspm_init(void)
{
return platform_driver_register(&mtk_mt6761_sspm_driver);
}
static void __exit mt6761_sspm_exit(void)
{
pr_info("[SSPM] mt6761-sspm Exit.\n");
}
MODULE_DESCRIPTION("MEDIATEK Module SSPM driver");
MODULE_LICENSE("GPL v2");
subsys_initcall(mt6761_sspm_init);
module_exit(mt6761_sspm_exit);
+218
View File
@@ -0,0 +1,218 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/platform_device.h>
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/clk.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_sysfs.h"
#include "sspm_reservedmem.h"
#include "sspm_common.h"
#include "sspm_ipi_mbox.h"
#include "sspm_ipi_define_mt6765.h"
#include "sspm_reservedmem_define_mt6765.h"
#include "sspm_timesync.h"
static struct workqueue_struct *mt6765_sspm_workqueue;
static atomic_t sspm_inited = ATOMIC_INIT(0);
static int __init mt6765_sspm_module_init(void)
{
if (atomic_inc_return(&sspm_inited) != 1)
return 0;
pr_info("[SSPM] mt6765-sspm_module_init.\n");
/* static initialise */
sspm_ready = 0;
mt6765_sspm_workqueue = create_workqueue("mt6765-SSPM_WQ");
if (!mt6765_sspm_workqueue) {
pr_err("[SSPM] Workqueue Create Failed\n");
goto error;
}
#ifdef CONFIG_OF_RESERVED_MEM
if (sspm_reserve_memory_init()) {
pr_err("[SSPM] Reserved Memory Failed\n");
goto error;
}
#endif
sspm_ready = 1;
if (sspm_sysfs_init()) {
pr_err("[SSPM] Sysfs Init Failed\n");
return -1;
}
if (sspm_ipi_init()) {
pr_err("[SSPM] IPI Init Failed\n");
return -1;
}
pr_info("SSPM is ready to service IPI\n");
#if SSPM_PLT_SERV_SUPPORT
if (sspm_plt_init()) {
pr_err("[SSPM] Platform Init Failed\n");
return -1;
}
pr_info("SSPM platform service is ready\n");
#endif
#if SSPM_TIMESYNC_SUPPORT
if (sspm_timesync_init()) {
pr_err("SSPM timesync init fail\n");
return -1;
}
#endif
sspm_lock_emi_mpu(4);
return 0;
error:
atomic_set(&sspm_inited, 1);
return -1;
}
static int __init mt6765_sspm_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev = &pdev->dev;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfgreg");
if (!res) {
pr_err("[SSPM] cfgreg IO resource not found\n");
return -ENODEV;
}
sspmreg.cfg = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspmreg.cfg)) {
pr_err("[SSPM] Unable to ioremap registers\n");
return -1;
}
sspmreg.cfgregsize = (unsigned int) resource_size(res);
sspmreg.irq = platform_get_irq_byname(pdev, "ipc");
if (sspmreg.irq < 0) {
pr_err("[SSPM] Unable to get IRQ\n");
return -1;
}
pr_info("[SSPM] mt6765-sspm irq=%d, cfgreg=0x%p\n",
sspmreg.irq, sspmreg.cfg);
sspm_pdev = pdev;
mbox_table = mt6765_mbox_table;
send_pintable = mt6765_send_pintable;
recv_pintable = mt6765_recv_pintable;
pin_name = mt6765_pin_name;
sspm_reserve_mblock = mt6765_sspm_reserve_mblock;
pr_info("[SSPM] mt6765-sspm_probe Done.\n");
mt6765_sspm_module_init();
return 0;
}
#ifdef CONFIG_PM
static int mt6765_sspm_suspend(struct device *dev)
{
sspm_timesync_suspend();
return 0;
}
static int mt6765_sspm_resume(struct device *dev)
{
sspm_timesync_resume();
return 0;
}
static const struct dev_pm_ops mt6765_sspm_dev_pm_ops = {
.suspend = mt6765_sspm_suspend,
.resume = mt6765_sspm_resume,
};
#endif
static const struct of_device_id mt6765_sspm_of_match[] = {
{ .compatible = "mediatek,mt6765-sspm", },
{},
};
static const struct platform_device_id mt6765_sspm_id_table[] = {
{ "mt6765-sspm", 0},
{ },
};
static struct platform_driver mtk_mt6765_sspm_driver __refdata = {
.probe = mt6765_sspm_probe,
.remove = NULL,
.shutdown = NULL,
.suspend = NULL,
.resume = NULL,
.driver = {
.name = "mt6765-sspm",
.owner = THIS_MODULE,
.of_match_table = mt6765_sspm_of_match,
#ifdef CONFIG_PM
.pm = &mt6765_sspm_dev_pm_ops,
#endif
},
.id_table = mt6765_sspm_id_table,
};
/*
* driver initialization entry point
*/
static int __init mt6765_sspm_init(void)
{
return platform_driver_register(&mtk_mt6765_sspm_driver);
}
static void __exit mt6765_sspm_exit(void)
{
pr_info("[SSPM] mt6765-sspm Exit.\n");
}
MODULE_DESCRIPTION("MEDIATEK Module SSPM driver");
MODULE_LICENSE("GPL v2");
subsys_initcall(mt6765_sspm_init);
module_exit(mt6765_sspm_exit);
+253
View File
@@ -0,0 +1,253 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/platform_device.h>
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/clk.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_sysfs.h"
#include "sspm_reservedmem.h"
#include "sspm_common.h"
#include "sspm_ipi_mbox.h"
#include "sspm_ipi_define_mt6779.h"
#include "sspm_reservedmem_define_mt6779.h"
#include "sspm_timesync.h"
static struct workqueue_struct *mt6779_sspm_workqueue;
static atomic_t sspm_inited = ATOMIC_INIT(0);
static int __init mt6779_sspm_module_init(void)
{
if (atomic_inc_return(&sspm_inited) != 1)
return 0;
pr_info("[SSPM] mt6779-sspm_module_init.\n");
/* static initialise */
sspm_ready = 0;
mt6779_sspm_workqueue = create_workqueue("mt6779-SSPM_WQ");
if (!mt6779_sspm_workqueue) {
pr_err("[SSPM] Workqueue Create Failed\n");
goto error;
}
#ifdef CONFIG_OF_RESERVED_MEM
if (sspm_reserve_memory_init()) {
pr_err("[SSPM] Reserved Memory Failed\n");
goto error;
}
#endif
sspm_ready = 1;
if (sspm_sysfs_init()) {
pr_err("[SSPM] Sysfs Init Failed\n");
return -1;
}
if (sspm_ipi_init()) {
pr_err("[SSPM] IPI Init Failed\n");
return -1;
}
pr_info("SSPM is ready to service IPI\n");
#if SSPM_PLT_SERV_SUPPORT
if (sspm_plt_init()) {
pr_err("[SSPM] Platform Init Failed\n");
return -1;
}
pr_info("SSPM platform service is ready\n");
#endif
#if SSPM_TIMESYNC_SUPPORT
if (sspm_timesync_init()) {
pr_err("SSPM timesync init fail\n");
return -1;
}
#endif
sspm_lock_emi_mpu(4);
return 0;
error:
atomic_set(&sspm_inited, 1);
return -1;
}
static int __init sspm_clk_en(struct device *dev, const char *id)
{
struct clk *sspm_clk;
sspm_clk = devm_clk_get(dev, id);
if (IS_ERR(sspm_clk))
goto error;
if (clk_prepare_enable(sspm_clk))
goto error;
return 0;
error:
pr_err("[SSPM] Enable sspm clock fail: %s.\n", id);
return -1;
}
static int __init mt6779_sspm_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev = &pdev->dev;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfgreg");
if (!res) {
pr_err("[SSPM] cfgreg IO resource not found\n");
return -ENODEV;
}
sspmreg.cfg = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspmreg.cfg)) {
pr_err("[SSPM] Unable to ioremap registers\n");
return -1;
}
sspmreg.cfgregsize = (unsigned int) resource_size(res);
sspmreg.irq = platform_get_irq_byname(pdev, "ipc");
if (sspmreg.irq < 0) {
pr_err("[SSPM] Unable to get IRQ\n");
return -1;
}
pr_info("[SSPM] mt6779-sspm irq=%d, cfgreg=0x%p\n",
sspmreg.irq, sspmreg.cfg);
if (sspm_clk_en(dev, "sspm_26m"))
return -1;
if (sspm_clk_en(dev, "sspm_32k"))
return -1;
if (sspm_clk_en(dev, "sspm_bus_hclk"))
return -1;
sspm_pdev = pdev;
#ifdef SSPM_SHARE_BUFFER_SUPPORT
if (sspm_sbuf_init()) {
pr_err("[SSPM] Shared Buffer Init Failed\n");
return -1;
}
#endif
mbox_table = mt6779_mbox_table;
send_pintable = mt6779_send_pintable;
recv_pintable = mt6779_recv_pintable;
pin_name = mt6779_pin_name;
sspm_reserve_mblock = mt6779_sspm_reserve_mblock;
pr_info("[SSPM] mt6779-sspm_probe Done.\n");
mt6779_sspm_module_init();
return 0;
}
#ifdef CONFIG_PM
static int mt6779_sspm_suspend(struct device *dev)
{
sspm_timesync_suspend();
return 0;
}
static int mt6779_sspm_resume(struct device *dev)
{
sspm_timesync_resume();
return 0;
}
static const struct dev_pm_ops mt6779_sspm_dev_pm_ops = {
.suspend = mt6779_sspm_suspend,
.resume = mt6779_sspm_resume,
};
#endif
static const struct of_device_id mt6779_sspm_of_match[] = {
{ .compatible = "mediatek,mt6779-sspm", },
{},
};
static const struct platform_device_id mt6779_sspm_id_table[] = {
{ "mt6779-sspm", 0},
{ },
};
static struct platform_driver mtk_mt6779_sspm_driver __refdata = {
.probe = mt6779_sspm_probe,
.remove = NULL,
.shutdown = NULL,
.suspend = NULL,
.resume = NULL,
.driver = {
.name = "mt6779-sspm",
.owner = THIS_MODULE,
.of_match_table = mt6779_sspm_of_match,
#ifdef CONFIG_PM
.pm = &mt6779_sspm_dev_pm_ops,
#endif
},
.id_table = mt6779_sspm_id_table,
};
/*
* driver initialization entry point
*/
static int __init mt6779_sspm_init(void)
{
return platform_driver_register(&mtk_mt6779_sspm_driver);
}
static void __exit mt6779_sspm_exit(void)
{
pr_info("[SSPM] mt6779-sspm Exit.\n");
}
MODULE_DESCRIPTION("MEDIATEK Module SSPM driver");
MODULE_LICENSE("GPL v2");
subsys_initcall(mt6779_sspm_init);
module_exit(mt6779_sspm_exit);
+168
View File
@@ -0,0 +1,168 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/types.h>
#include "sspm_define.h"
#include "sspm_sysfs.h"
#include "sspm_common.h"
#include "sspm_ipi.h"
#include "sspm_reservedmem.h"
#if SSPM_LOGGER_SUPPORT
#include "sspm_logger.h"
#endif
#if SSPM_PLT_SERV_SUPPORT
struct plt_ctrl_s {
unsigned int magic;
unsigned int size;
unsigned int mem_sz;
#if SSPM_LOGGER_SUPPORT
unsigned int logger_ofs;
#endif
};
static ssize_t sspm_alive_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
struct plt_ipi_data_s ipi_data;
int ret, ackdata = 0;
ipi_data.cmd = 0xDEAD;
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_WAIT,
&ipi_data, sizeof(ipi_data) / MBOX_SLOT_SIZE, &ackdata, 1);
if (ret == IPI_DONE)
return snprintf(buf, PAGE_SIZE, "%s\n",
ackdata ? "Alive" : "Dead");
else
return snprintf(buf, PAGE_SIZE, "Fail(%d)\n", ret);
}
static DEVICE_ATTR_RO(sspm_alive);
int __init sspm_plt_init(void)
{
phys_addr_t phys_addr, virt_addr, mem_sz;
struct plt_ipi_data_s ipi_data;
struct plt_ctrl_s *plt_ctl;
int ret, ackdata;
unsigned int last_ofs;
#if SSPM_LOGGER_SUPPORT
unsigned int last_sz;
#endif
unsigned int *mark;
unsigned char *b;
ret = sspm_sysfs_create_file(&dev_attr_sspm_alive);
if (ret)
goto error;
phys_addr = sspm_reserve_mem_get_phys(SSPM_MEM_ID);
if (phys_addr == 0) {
pr_err("SSPM: Can't get logger phys mem\n");
goto error;
}
virt_addr = sspm_reserve_mem_get_virt(SSPM_MEM_ID);
if (virt_addr == 0) {
pr_err("SSPM: Can't get logger virt mem\n");
goto error;
}
mem_sz = sspm_reserve_mem_get_size(SSPM_MEM_ID);
if (mem_sz == 0) {
pr_err("SSPM: Can't get logger mem size\n");
goto error;
}
b = (unsigned char *) (uintptr_t)virt_addr;
for (last_ofs = 0; last_ofs < sizeof(*plt_ctl); last_ofs++)
b[last_ofs] = 0x0;
mark = (unsigned int *) (uintptr_t)virt_addr;
*mark = PLT_INIT;
mark = (unsigned int *) ((unsigned char *) (uintptr_t)
virt_addr + mem_sz - 4);
*mark = PLT_INIT;
plt_ctl = (struct plt_ctrl_s *) (uintptr_t)virt_addr;
plt_ctl->magic = PLT_INIT;
plt_ctl->size = sizeof(*plt_ctl);
plt_ctl->mem_sz = mem_sz;
last_ofs = plt_ctl->size;
pr_debug("SSPM: %s(): after plt, ofs=%u\n", __func__, last_ofs);
#if SSPM_LOGGER_SUPPORT
plt_ctl->logger_ofs = last_ofs;
last_sz = sspm_logger_init(virt_addr + last_ofs, mem_sz - last_ofs);
if (last_sz == 0) {
pr_err("SSPM: sspm_logger_init return fail\n");
goto error;
}
last_ofs += last_sz;
pr_debug("SSPM: %s(): after logger, ofs=%u\n", __func__, last_ofs);
#endif
ipi_data.cmd = PLT_INIT;
ipi_data.u.ctrl.phys = phys_addr;
ipi_data.u.ctrl.size = mem_sz;
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_POLLING, &ipi_data,
sizeof(ipi_data) / MBOX_SLOT_SIZE, &ackdata, 1);
if (ret != 0) {
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
goto error;
}
if (!ackdata) {
pr_err("SSPM: logger IPI init fail, ret=%d\n", ackdata);
goto error;
}
#if SSPM_LOGGER_SUPPORT
sspm_logger_init_done();
#endif
return 0;
error:
return -1;
}
#endif
@@ -0,0 +1,223 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include "sspm_define.h"
#include "sspm_common.h"
#include "sspm_reservedmem.h"
#ifdef CONFIG_OF_RESERVED_MEM
#include <linux/of_reserved_mem.h>
#define SSPM_MEM_RESERVED_KEY "mediatek,reserve-memory-sspm_share"
#endif
static phys_addr_t sspm_mem_base_phys;
static phys_addr_t sspm_mem_base_virt;
static phys_addr_t sspm_mem_size;
struct sspm_reserve_mblock *sspm_reserve_mblock;
#if defined(MODULE)
static void sspm_reserve_memory_ioremap(struct platform_device *pdev)
{
struct device_node *rmem_node;
struct reserved_mem *rmem;
/* Get reserved memory */
rmem_node = of_find_compatible_node(NULL, NULL, SSPM_MEM_RESERVED_KEY);
if (!rmem_node) {
pr_err("[SSPM] no node for reserved memory\n");
return;
}
rmem = of_reserved_mem_lookup(rmem_node);
if (!rmem) {
pr_err("[SSPM] cannot lookup reserved memory\n");
return;
}
sspm_mem_base_phys = (phys_addr_t) rmem->base;
sspm_mem_size = (phys_addr_t) rmem->size;
}
#elif defined(CONFIG_OF_RESERVED_MEM)
static int __init sspm_reserve_mem_of_init(struct reserved_mem *rmem)
{
sspm_mem_base_phys = rmem->base;
sspm_mem_size = rmem->size;
#ifdef DEBUG
pr_debug("[SSPM] phys:0x%llx - 0x%llx (0x%llx)\n",
(unsigned long long)rmem->base,
(unsigned long long)(rmem->base + rmem->size),
(unsigned long long)rmem->size);
#endif
return 0;
}
RESERVEDMEM_OF_DECLARE(sspm_reservedmem, SSPM_MEM_RESERVED_KEY,
sspm_reserve_mem_of_init);
#endif
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_phys;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_phys);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_virt;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_virt);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].size;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_size);
int sspm_reserve_memory_init(void)
{
unsigned int id;
phys_addr_t accumlate_memory_size;
if (NUMS_MEM_ID == 0)
return 0;
#if defined(MODULE)
sspm_reserve_memory_ioremap(sspm_pdev);
#endif
if (!sspm_mem_base_phys)
return -1;
/* Phy memory */
accumlate_memory_size = 0;
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_phys = sspm_mem_base_phys +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
}
/* Virt memory */
accumlate_memory_size = 0;
sspm_mem_base_virt = (phys_addr_t)(uintptr_t)
ioremap_wc(sspm_mem_base_phys, sspm_mem_size);
#ifdef DEBUG
pr_info("[SSPM]reserve mem: virt:0x%llx - 0x%p (0x%llx)\n",
sspm_mem_base_virt,
sspm_mem_base_virt + sspm_mem_size,
sspm_mem_size);
#endif
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_virt = sspm_mem_base_virt +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
}
/* the reserved memory should be larger then expected memory
* or sspm_reserve_mblock does not match dts
*/
BUG_ON(accumlate_memory_size > sspm_mem_size);
#ifdef DEBUG
for (id = 0; id < NUMS_MEM_ID; id++) {
pr_info("[SSPM][mem_reserve-%d] ", id);
pr_info("phys:0x%llx, virt:0x%llx,size:0x%llx\n",
(unsigned long long)sspm_reserve_mem_get_phys(id),
(unsigned long long)sspm_reserve_mem_get_virt(id),
(unsigned long long)sspm_reserve_mem_get_size(id));
}
#endif
return 0;
}
void sspm_lock_emi_mpu(unsigned int region)
{
#ifdef CONFIG_MTK_EMI
if (sspm_mem_size > 0)
sspm_set_emi_mpu(region, sspm_mem_base_phys, sspm_mem_size);
#endif
}
#ifdef SSPM_SHARE_BUFFER_SUPPORT
void __iomem *sspm_base;
phys_addr_t sspm_sbuf_get(unsigned int offset)
{
if (!is_sspm_ready()) {
pr_notice("[SSPM] device resource is not ready\n");
return 0;
}
if (offset < SSPM_SHARE_REGION_BASE ||
offset > SSPM_SHARE_REGION_BASE + SSPM_SHARE_REGION_SIZE) {
pr_notice("[SSPM] illegal sbuf request: 0x%x\n", offset);
return 0;
} else {
return (phys_addr_t)(sspm_base + offset);
}
}
EXPORT_SYMBOL_GPL(sspm_sbuf_get);
int sspm_sbuf_init(void)
{
struct device *dev = &sspm_pdev->dev;
struct resource *res;
if (sspm_pdev) {
res = platform_get_resource_byname(sspm_pdev,
IORESOURCE_MEM, "sspm_base");
if (!res)
return -1;
sspm_base = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspm_base))
return -1;
}
return 0;
}
#endif
@@ -0,0 +1,56 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_RESERVED_H__
#define __SSPM_RESERVED_H__
#include <linux/types.h>
#include "sspm_define.h"
#ifndef _SSPM_MEM_ID_
#define _SSPM_MEM_ID_
enum {
SSPM_MEM_ID = 0,
PWRAP_MEM_ID,
PMIC_MEM_ID,
UPD_MEM_ID,
QOS_MEM_ID,
SWPM_MEM_ID,
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
MET_MEM_ID,
#endif
SMI_MEM_ID,
NUMS_MEM_ID,
};
#endif
struct sspm_reserve_mblock {
u32 num;
u64 start_phys;
u64 start_virt;
u64 size;
};
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id);
int sspm_reserve_memory_init(void);
void sspm_set_emi_mpu(unsigned int id, phys_addr_t base, phys_addr_t size);
void sspm_lock_emi_mpu(unsigned int region);
#ifdef SSPM_SHARE_BUFFER_SUPPORT
#define SSPM_SHARE_REGION_BASE 0x20000
#define SSPM_SHARE_REGION_SIZE 0x8000
#endif
#ifdef SSPM_SHARE_BUFFER_SUPPORT
extern struct platform_device *sspm_pdev;
phys_addr_t sspm_sbuf_get(unsigned int offset);
int sspm_sbuf_init(void);
#endif
extern struct sspm_reserve_mblock *sspm_reserve_mblock;
#endif
@@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _SSPM_RESERVEDMEM_DEFINE_H_
#define _SSPM_RESERVEDMEM_DEFINE_H_
#include <sspm_reservedmem.h>
#define _SSPM_INTERNAL_
#ifdef _SSPM_INTERNAL_
/* The total size of sspm_reserve_mblock should less equal than
* reserve-memory-sspm_share of device tree
*/
static struct sspm_reserve_mblock mt6761_sspm_reserve_mblock[NUMS_MEM_ID] = {
{
.num = SSPM_MEM_ID,
.size = 0x400 + SSPM_PLT_LOGGER_BUF_LEN,
/* logger header + 1M log buffer */
},
{
.num = PWRAP_MEM_ID,
.size = 0x300, /* 768 bytes */
},
{
.num = PMIC_MEM_ID,
.size = 0xC00, /* 3K */
},
{
.num = UPD_MEM_ID,
.size = 0x1800, /* 6K */
},
{
.num = QOS_MEM_ID,
.size = 0x1000, /* 4K */
},
{
.num = SWPM_MEM_ID,
.size = 0xC00, /* 6K */
},
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
{
.num = MET_MEM_ID,
.size = 0x400000, /* 4M */
},
#endif
{
.num = SMI_MEM_ID,
.size = 0x0,
},
/* TO align 64K, total is 1M(5M)+64K. The remaining size = 0xB900. */
};
#endif
#endif
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _SSPM_RESERVEDMEM_DEFINE_H_
#define _SSPM_RESERVEDMEM_DEFINE_H_
#include <sspm_reservedmem.h>
#define _SSPM_INTERNAL_
#ifdef _SSPM_INTERNAL_
/* The total size of sspm_reserve_mblock should less equal than
* reserve-memory-sspm_share of device tree
*/
static struct sspm_reserve_mblock mt6765_sspm_reserve_mblock[NUMS_MEM_ID] = {
{
.num = SSPM_MEM_ID,
.size = 0x400 + SSPM_PLT_LOGGER_BUF_LEN,
/* logger header + 1M log buffer */
},
{
.num = PWRAP_MEM_ID,
.size = 0x300, /* 768 bytes */
},
{
.num = PMIC_MEM_ID,
.size = 0xC00, /* 3K */
},
{
.num = UPD_MEM_ID,
.size = 0x1800, /* 6K */
},
{
.num = QOS_MEM_ID,
.size = 0x1000, /* 4K */
},
{
.num = SWPM_MEM_ID,
.size = 0xC00, /* 3K */
},
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
{
.num = MET_MEM_ID,
.size = 0x400000, /* 4M */
},
#endif
/* TO align 64K, total is 1M+64K. The remaining size = 0xB900. */
};
#endif
#endif
@@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _SSPM_RESERVEDMEM_DEFINE_H_
#define _SSPM_RESERVEDMEM_DEFINE_H_
#include <sspm_reservedmem.h>
#define _SSPM_INTERNAL_
#ifdef _SSPM_INTERNAL_
/* The total size of sspm_reserve_mblock should less equal than
* reserve-memory-sspm_share of device tree
*/
static struct sspm_reserve_mblock mt6779_sspm_reserve_mblock[NUMS_MEM_ID] = {
{
.num = SSPM_MEM_ID,
.size = 0x100 + SSPM_PLT_LOGGER_BUF_LEN,
/* logger header + 1M log buffer */
},
{
.num = PWRAP_MEM_ID,
.size = 0x300, /* 768 bytes */
},
{
.num = PMIC_MEM_ID,
.size = 0xC00, /* 3K */
},
{
.num = UPD_MEM_ID,
.size = 0x1800, /* 6K */
},
{
.num = QOS_MEM_ID,
.size = 0x1000, /* 4K */
},
{
.num = SWPM_MEM_ID,
.size = 0x1800, /* 6K */
},
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
{
.num = MET_MEM_ID,
.size = 0x400000, /* 4M */
},
#endif
{
.num = SMI_MEM_ID,
.size = 0x9000, /* 36K */
},
/* TO align 64K, total is 1M(5M)+64K. The remaining size = 0x2000. */
};
#endif
#endif
+99
View File
@@ -0,0 +1,99 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/atomic.h>
#include "sspm_define.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
static wait_queue_head_t logwait;
ssize_t __weak sspm_log_read(char __user *data, size_t len)
{
return 0;
}
unsigned int __weak sspm_log_poll(void)
{
return 0;
}
static ssize_t sspm_log_if_read(struct file *file, char __user *data,
size_t len, loff_t *ppos)
{
ssize_t ret;
ret = 0;
if (access_ok(VERIFY_WRITE, data, len))
ret = sspm_log_read(data, len);
return ret;
}
static int sspm_log_if_open(struct inode *inode, struct file *file)
{
return nonseekable_open(inode, file);
}
static unsigned int sspm_log_if_poll(struct file *file, poll_table *wait)
{
unsigned int ret = 0;
if (!(file->f_mode & FMODE_READ))
return ret;
poll_wait(file, &logwait, wait);
ret = sspm_log_poll();
return ret;
}
void sspm_log_if_wake(void)
{
wake_up(&logwait);
}
static const struct file_operations sspm_log_file_ops = {
.owner = THIS_MODULE,
.read = sspm_log_if_read,
.open = sspm_log_if_open,
.poll = sspm_log_if_poll,
};
static struct miscdevice sspm_log_device = {
.minor = MISC_DYNAMIC_MINOR,
.name = "sspm",
.fops = &sspm_log_file_ops
};
int __init sspm_sysfs_init(void)
{
int ret;
init_waitqueue_head(&logwait);
ret = misc_register(&sspm_log_device);
if (ret)
return ret;
return 0;
}
int sspm_sysfs_create_file(const struct device_attribute *attr)
{
return device_create_file(sspm_log_device.this_device, attr);
}
+16
View File
@@ -0,0 +1,16 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __SSPM_SYSFS_H__
#define __SSPM_SYSFS_H__
#include <linux/sysfs.h>
#include <linux/device.h>
void sspm_log_if_wake(void);
extern int __init sspm_sysfs_init(void);
extern int sspm_sysfs_create_file(const struct device_attribute *attr);
#endif
+229
View File
@@ -0,0 +1,229 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/clocksource.h>
#include <linux/sched/clock.h>
#include <linux/suspend.h>
#include <linux/timex.h>
#include <linux/types.h>
#include <asm/arch_timer.h>
#include <asm/timex.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_ipi_mbox.h"
#include "sspm_mbox.h"
#include "sspm_timesync.h"
#define sspm_ts_write(id, val) \
sspm_mbox_write(SSPM_TS_MBOX, id, (void *)&val, 1)
#define TIMESYNC_TAG "[SSPM_TS]"
#define TIMESYNC_MAX_VER (0x7)
#define TIMESYNC_HEADER_FREEZE_OFS (31)
#define TIMESYNC_HEADER_FREEZE (1 << TIMESYNC_HEADER_FREEZE_OFS)
#define TIMESYNC_HEADER_VER_OFS (28)
#define TIMESYNC_HEADER_VER_MASK (TIMESYNC_MAX_VER << TIMESYNC_HEADER_VER_OFS)
#define TIMESYNC_FLAG_SYNC (1 << 0)
#define TIMESYNC_FLAG_ASYNC (1 << 1)
#define TIMESYNC_FLAG_FREEZE (1 << 2)
#define TIMESYNC_FLAG_UNFREEZE (1 << 3)
/* sched_clock wrap time is 4398 seconds for arm arch timer
* applying a period less than it for tinysys timesync
*/
#define TIMESYNC_WRAP_TIME (4000ULL * NSEC_PER_SEC)
struct timesync_context_t {
spinlock_t lock;
struct work_struct work;
ktime_t wrap_kt;
u8 enabled;
u64 base_tick;
u64 base_ts;
};
static struct workqueue_struct *timesync_workqueue;
static struct timesync_context_t timesync_ctx;
static struct timecounter timesync_counter;
static struct hrtimer timesync_refresh_timer;
static u8 sspm_base_ver;
static void sspm_ts_update(int suspended, u64 tick, u64 ts)
{
u32 header, val;
sspm_base_ver = (sspm_base_ver + 1)%(TIMESYNC_MAX_VER+1);
/* make header: freeze and version */
header = suspended ? TIMESYNC_HEADER_FREEZE : 0;
header |= ((sspm_base_ver << TIMESYNC_HEADER_VER_OFS) &
TIMESYNC_HEADER_VER_MASK);
/* update tick, h -> l */
val = (tick >> 32) & 0xFFFFFFFF;
val |= header;
sspm_ts_write(SSPM_TS_MBOX_TICK_H, val);
/* fix update sequence to promise atomicity */
mb();
val = tick & 0xFFFFFFFF;
sspm_ts_write(SSPM_TS_MBOX_TICK_L, val);
/* fix update sequence to promise atomicity */
mb();
/* update ts, l -> h */
val = ts & 0xFFFFFFFF;
sspm_ts_write(SSPM_TS_MBOX_TS_L, val);
/* fix update sequence to promise atomicity */
mb();
val = (ts >> 32) & 0xFFFFFFFF;
val |= header;
sspm_ts_write(SSPM_TS_MBOX_TS_H, val);
/* fix update sequence to promise atomicity */
mb();
}
static u64 timesync_tick_read(const struct cyclecounter *cc)
{
return arch_timer_read_counter();
}
static struct cyclecounter timesync_cc __ro_after_init = {
.read = timesync_tick_read,
.mask = CLOCKSOURCE_MASK(56),
};
static void timesync_sync_base_internal(unsigned int flag)
{
u64 tick, ts;
unsigned long irq_flags = 0;
int freeze, unfreeze;
spin_lock_irqsave(&timesync_ctx.lock, irq_flags);
ts = timecounter_read(&timesync_counter);
tick = timesync_counter.cycle_last;
timesync_ctx.base_tick = tick;
timesync_ctx.base_ts = ts;
freeze = (flag & TIMESYNC_FLAG_FREEZE) ? 1 : 0;
unfreeze = (flag & TIMESYNC_FLAG_UNFREEZE) ? 1 : 0;
/* sync with sspm */
sspm_ts_update(freeze, tick, ts);
spin_unlock_irqrestore(&timesync_ctx.lock, irq_flags);
pr_info("%s update base: ts=%llu, tick=0x%llx, fz=%d, ver=%d\n",
TIMESYNC_TAG, ts, tick, freeze, sspm_base_ver);
}
static void timesync_sync_base(unsigned int flag)
{
if (!timesync_ctx.enabled)
return;
if (flag & TIMESYNC_FLAG_ASYNC)
queue_work(timesync_workqueue, &(timesync_ctx.work));
else
timesync_sync_base_internal(flag);
}
static enum hrtimer_restart timesync_refresh(struct hrtimer *hrt)
{
hrtimer_forward_now(hrt, timesync_ctx.wrap_kt);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_ASYNC);
return HRTIMER_RESTART;
}
static void timesync_ws(struct work_struct *ws)
{
timesync_sync_base(TIMESYNC_FLAG_SYNC);
}
unsigned int __init sspm_timesync_init(void)
{
timesync_workqueue = create_workqueue("sspm_ts_wq");
if (!timesync_workqueue) {
pr_info("%s workqueue create failed\n", __func__);
timesync_ctx.enabled = 0;
return -1;
}
INIT_WORK(&(timesync_ctx.work), timesync_ws);
spin_lock_init(&timesync_ctx.lock);
/* init cyclecounter mult and shift as sched_clock */
clocks_calc_mult_shift(&timesync_cc.mult, &timesync_cc.shift,
arch_timer_get_cntfrq(), NSEC_PER_SEC, 3600);
timesync_ctx.wrap_kt = ns_to_ktime(TIMESYNC_WRAP_TIME);
/* Init time counter:
* start_time: current sched_clock
* read: arch timer counter
*/
timecounter_init(&timesync_counter, &timesync_cc, sched_clock());
hrtimer_init(&timesync_refresh_timer,
CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timesync_refresh_timer.function = timesync_refresh;
hrtimer_start(&timesync_refresh_timer,
timesync_ctx.wrap_kt, HRTIMER_MODE_REL);
pr_info("%s ts: cycle_last %lld, time_base:%lld, wrap:%lld\n",
TIMESYNC_TAG, timesync_counter.cycle_last,
timesync_counter.nsec, timesync_ctx.wrap_kt);
timesync_ctx.enabled = 1;
timesync_sync_base(TIMESYNC_FLAG_SYNC);
return 0;
}
void sspm_timesync_suspend(void)
{
if (!timesync_ctx.enabled)
return;
hrtimer_cancel(&timesync_refresh_timer);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_SYNC |
TIMESYNC_FLAG_FREEZE);
}
void sspm_timesync_resume(void)
{
if (!timesync_ctx.enabled)
return;
/* re-init timecounter because sched_clock will be stopped during
* suspend but arch timer counter is not, so we need to update
* start time after resume
*/
timecounter_init(&timesync_counter, &timesync_cc, sched_clock());
hrtimer_start(&timesync_refresh_timer,
timesync_ctx.wrap_kt, HRTIMER_MODE_REL);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_SYNC |
TIMESYNC_FLAG_UNFREEZE);
}
@@ -0,0 +1,34 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _SSPM_TIMESYNC_H_
#define _SSPM_TIMESYNC_H_
#define SHAREMBOX_NO_MCDI 3
#define SHAREMBOX_OFFSET_MCDI 0
#define SHAREMBOX_SIZE_MCDI 20
#define SHAREMBOX_OFFSET_TIMESTAMP (SHAREMBOX_OFFSET_MCDI + \
SHAREMBOX_SIZE_MCDI)
#define SHAREMBOX_SIZE_TIMESTAMP 6
#define SSPM_TS_MBOX SHAREMBOX_NO_MCDI
#define SSPM_TS_MBOX_OFFSET_BASE SHAREMBOX_OFFSET_TIMESTAMP
/*
* Shared MBOX: AP write, SSPM read
* Unit for each offset: 4 bytes
*/
#define SSPM_TS_MBOX_TICK_H (SSPM_TS_MBOX_OFFSET_BASE + 0)
#define SSPM_TS_MBOX_TICK_L (SSPM_TS_MBOX_OFFSET_BASE + 1)
#define SSPM_TS_MBOX_TS_H (SSPM_TS_MBOX_OFFSET_BASE + 2)
#define SSPM_TS_MBOX_TS_L (SSPM_TS_MBOX_OFFSET_BASE + 3)
#define SSPM_TS_MBOX_DEBUG_TS_H (SSPM_TS_MBOX_OFFSET_BASE + 4)
#define SSPM_TS_MBOX_DEBUG_TS_L (SSPM_TS_MBOX_OFFSET_BASE + 5)
void sspm_timesync_suspend(void);
void sspm_timesync_resume(void);
unsigned int __init sspm_timesync_init(void);
#endif // _SSPM_TIMESYNC_H_
+13
View File
@@ -0,0 +1,13 @@
ifneq ($(strip $(CONFIG_MTK_TINYSYS_SSPM_SUPPORT)$(CONFIG_MTK_TINYSYS_SSPM_PLT_SUPPORT)),)
obj-y += sspm_emi_mpu.o
obj-y += sspm_ipi_timeout_cb.o
obj-y += sspm_helper.o sspm_irq.o sspm_sysfs.o sspm_reservedmem.o sspm_plt.o
obj-y += sspm_mbox.o sspm_ipi_mbox.o sspm_logger_impl.o sspm_timesync.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/$(CONFIG_MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/v1
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/$(CONFIG_MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/$(CONFIG_MTK_PLATFORM)
ccflags-$(CONFIG_MTK_ENG_BUILD) += -DDEBUG
endif
@@ -0,0 +1,56 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_DEFINE_H__
#define __SSPM_DEFINE_H__
#include <linux/param.h> /* for HZ */
#include <asm/arch_timer.h>
#define SSPM_MBOX_MAX 5
#define SSPM_MBOX_IN_IRQ_OFS 0x0
#define SSPM_MBOX_OUT_IRQ_OFS 0x4
#define SSPM_MBOX_SLOT_SIZE 0x4
#define SSPM_CFG_OFS_SEMA 0x048
#define SSPM_MPU_REGION_ID 9
#define SSPM_PLT_SERV_SUPPORT (1)
#define SSPM_LOGGER_SUPPORT (1)
#define SSPM_LASTK_SUPPORT (0)
#define SSPM_COREDUMP_SUPPORT (0)
#define SSPM_EMI_PROTECTION_SUPPORT (1)
#if defined(CONFIG_MACH_MT6768) || defined(CONFIG_MACH_MT6785)
#define SSPM_TIMESYNC_SUPPORT (0)
#else
#define SSPM_TIMESYNC_SUPPORT (1)
#endif
#define TIMESYNC_TIMEOUT (60 * 60 * HZ)
#define PLT_INIT 0x504C5401
#define PLT_LOG_ENABLE 0x504C5402
#define PLT_TIMESYNC_SYNC 0x504C5405
#define PLT_TIMESYNC_SRAM_TEST 0x504C5406
#define mtk_timer_src_count(...) arch_counter_get_cntvct(__VA_ARGS__)
struct plt_ipi_data_s {
unsigned int cmd;
union {
struct {
unsigned int phys;
unsigned int size;
} ctrl;
struct {
unsigned int enable;
} logger;
struct {
unsigned int mode;
} ts;
} u;
};
#endif
@@ -0,0 +1,32 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#if SSPM_EMI_PROTECTION_SUPPORT
#include <mt_emi_api.h>
void sspm_set_emi_mpu(phys_addr_t base, phys_addr_t size)
{
struct emi_region_info_t region_info;
region_info.region = SSPM_MPU_REGION_ID;
region_info.start = base;
region_info.end = base + size - 1;
SET_ACCESS_PERMISSION(region_info.apc, UNLOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
pr_debug("[SSPM] MPU SSPM Share region<%d:%08llx:%08llx> %x, %x\n",
region_info.region, region_info.start, region_info.end,
region_info.apc[1], region_info.apc[0]);
emi_mpu_set_protection(&region_info);
}
#endif
+135
View File
@@ -0,0 +1,135 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/io.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_excep.h"
#include "sspm_helper.h"
#include "sspm_sysfs.h"
#if SSPM_COREDUMP_SUPPORT
struct coredump_ctrl_s {
unsigned int base;
unsigned int size;
unsigned int db_ofs;
unsigned int db_size;
unsigned int buff_ofs;
unsigned int buff_size;
};
#endif
#if SSPM_COREDUMP_SUPPORT
struct coredump_ctrl_s *sspm_cd_ctl;
static unsigned int sspm_cd_exists;
#endif
#if SSPM_COREDUMP_SUPPORT
void sspm_log_coredump_recv(unsigned int exists)
{
sspm_cd_exists = exists;
}
static ssize_t sspm_aee_read(struct device *kobj, struct device_attribute *attr,
char *buf)
{
unsigned int ret;
if (!sspm_cd_exists)
return 0;
ret = sspm_cd_ctl->db_size;
memcpy_fromio(buf, ((unsigned char *) sspm_cd_ctl) +
sspm_cd_ctl->db_ofs, ret);
return ret;
}
DEVICE_ATTR(sspm_aee, 0444, sspm_aee_read, NULL);
static ssize_t sspm_coredump_read(struct file *filep, struct kobject *kobj,
struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
{
if (!sspm_cd_exists)
return 0;
if (offset >= SSPM_COREDUMP_SIZE)
return 0;
if ((offset + size) >= SSPM_COREDUMP_SIZE)
size = SSPM_COREDUMP_SIZE - offset;
memcpy_fromio(buf, ((unsigned char *) sspm_cd_ctl) +
sspm_cd_ctl->buff_ofs + offset, size);
return size;
}
BIN_ATTR_RO(sspm_coredump, 0);
#endif
/*
* generate an exception according to exception type
* @param type: exception type
*/
void sspm_aed(enum sspm_excep_id type)
{
}
unsigned int __init sspm_coredump_init(phys_addr_t start, phys_addr_t limit)
{
#if SSPM_COREDUMP_SUPPORT
unsigned int last_ofs;
sspm_cd_ctl = (struct coredump_ctrl_s *) start;
sspm_cd_ctl->base = PLT_COREDUMP_READY; /* magic */
last_ofs = sizeof(*sspm_cd_ctl);
sspm_cd_ctl->size = last_ofs;
sspm_cd_ctl->db_ofs = last_ofs;
sspm_cd_ctl->db_size = SSPM_DB_SIZE;
last_ofs += sspm_cd_ctl->db_size;
sspm_cd_ctl->buff_ofs = last_ofs;
sspm_cd_ctl->buff_size = SSPM_COREDUMP_SIZE;
last_ofs += sspm_cd_ctl->buff_size;
return last_ofs;
#else
return 0;
#endif
}
int __init sspm_coredump_init_done(void)
{
#if SSPM_COREDUMP_SUPPORT
int ret;
if (sspm_cd_ctl) {
ret = sspm_sysfs_create_file(&dev_attr_sspm_aee);
if (unlikely(ret != 0))
return ret;
ret = sspm_sysfs_create_bin_file(&bin_attr_sspm_coredump);
if (unlikely(ret != 0))
return ret;
}
#endif
return 0;
}
/*
* init excep for sspm
* @return: 0 if success
*/
int __init sspm_excep_init(void)
{
return 0;
}
@@ -0,0 +1,22 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_EXCEP_H__
#define __SSPM_EXCEP_H__
#include <linux/types.h>
enum sspm_excep_id {
SSPM_NR_EXCEP,
};
extern void sspm_log_coredump_recv(unsigned int exists);
extern void sspm_aed(enum sspm_excep_id type);
extern unsigned int __init sspm_coredump_init(phys_addr_t start,
phys_addr_t limit);
extern int __init sspm_coredump_init_done(void);
extern int sspm_excep_init(void);
#endif
+300
View File
@@ -0,0 +1,300 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/platform_device.h>
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_ipi.h"
#include "sspm_excep.h"
#include "sspm_sysfs.h"
#include "sspm_timesync.h"
#include "sspm_reservedmem.h"
#define SEM_TIMEOUT 5000
#define SSPM_INIT_FLAG 0x1
static int __init sspm_init(void);
struct sspm_regs sspmreg;
struct platform_device *sspm_pdev;
static struct workqueue_struct *sspm_workqueue;
static atomic_t sspm_inited = ATOMIC_INIT(0);
static atomic_t sspm_dev_inited = ATOMIC_INIT(0);
static unsigned int sspm_ready;
void memcpy_to_sspm(void __iomem *trg, const void *src, int size)
{
int i, len;
u32 __iomem *t = trg;
const u32 *s = src;
len = (size + 3) >> 2;
for (i = 0; i < len; i++)
*t++ = *s++;
}
EXPORT_SYMBOL_GPL(memcpy_to_sspm);
void memcpy_from_sspm(void *trg, const void __iomem *src, int size)
{
int i, len;
u32 *t = trg;
const u32 __iomem *s = src;
len = (size + 3) >> 2;
for (i = 0; i < len; i++)
*t++ = *s++;
}
EXPORT_SYMBOL_GPL(memcpy_from_sspm);
/*
* acquire a hardware semaphore
* @param flag: semaphore id
*/
int get_sspm_semaphore(int flag)
{
void __iomem *sema = sspmreg.cfg + SSPM_CFG_OFS_SEMA;
int read_back;
int count = 0;
int ret = -1;
flag = (flag * 2) + 1;
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 0) {
writel((1 << flag), sema);
while (count != SEM_TIMEOUT) {
/* repeat test if we get semaphore */
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 1) {
ret = 1;
break;
}
writel((1 << flag), sema);
count++;
}
if (ret < 0)
pr_debug("[SSPM] get semaphore %d TIMEOUT...!\n", flag);
} else {
pr_debug("[SSPM] already hold semaphore %d\n", flag);
}
return ret;
}
EXPORT_SYMBOL_GPL(get_sspm_semaphore);
/*
* release a hardware semaphore
* @param flag: semaphore id
*/
int release_sspm_semaphore(int flag)
{
void __iomem *sema = sspmreg.cfg + SSPM_CFG_OFS_SEMA;
int read_back;
int ret = -1;
flag = (flag * 2) + 1;
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 1) {
/* Write 1 clear */
writel((1 << flag), sema);
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 0)
ret = 1;
else
pr_debug("[SSPM] release semaphore %d failed!\n", flag);
} else {
pr_debug("[SSPM] try to release semaphore %d not own by me\n",
flag);
}
return ret;
}
EXPORT_SYMBOL_GPL(release_sspm_semaphore);
/*
* schedule a work on sspm's work queue
* @param sspm_ws: work_struct to schedule
*/
void sspm_schedule_work(struct sspm_work_struct *sspm_ws)
{
queue_work(sspm_workqueue, &sspm_ws->work);
}
EXPORT_SYMBOL_GPL(sspm_schedule_work);
/*
* @return: 1 if sspm is ready for running tasks
*/
unsigned int is_sspm_ready(void)
{
if (sspm_ready)
return 1;
else
return 0;
}
EXPORT_SYMBOL_GPL(is_sspm_ready);
static int sspm_device_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev = &pdev->dev;
if (atomic_inc_return(&sspm_dev_inited) != 1)
return -1;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfgreg");
sspmreg.cfg = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspmreg.cfg)) {
pr_err("[SSPM] Unable to ioremap registers\n");
return -1;
}
sspmreg.cfgregsize = (unsigned int) resource_size(res);
sspmreg.irq = platform_get_irq_byname(pdev, "ipc");
if (sspmreg.irq < 0) {
pr_err("[SSPM] Unable to get IRQ\n");
return -1;
}
pr_debug("[SSPM] sspm irq=%d, cfgreg=0x%p\n", sspmreg.irq, sspmreg.cfg);
sspm_pdev = pdev;
if (sspm_ipi_init()) {
pr_err("[SSPM] IPI Init Failed\n");
return -1;
}
pr_info("SSPM is ready to service IPI\n");
#ifdef CONFIG_OF_RESERVED_MEM
if (sspm_reserve_memory_init(sspm_pdev)) {
pr_err("[SSPM] Reserved Memory Failed\n");
atomic_set(&sspm_inited, 1);
return -1;
}
#endif
if (of_property_read_bool(pdev->dev.of_node, "sspm_share_buffer_supported")) {
if (sspm_sbuf_init()) {
pr_err("[SSPM] Shared Buffer Init Failed\n");
return -1;
}
}
return 0;
}
static const struct of_device_id sspm_of_match[] = {
{ .compatible = "mediatek,sspm", },
{},
};
static const struct platform_device_id sspm_id_table[] = {
{ "sspm", 0},
{ },
};
static struct platform_driver mtk_sspm_driver = {
.remove = NULL,
.shutdown = NULL,
.suspend = NULL,
.resume = NULL,
.probe = sspm_device_probe,
.driver = {
.name = "sspm",
.owner = THIS_MODULE,
.of_match_table = sspm_of_match,
},
.id_table = sspm_id_table,
};
/*
* driver initialization entry point
*/
static int __init sspm_init(void)
{
if (atomic_inc_return(&sspm_inited) != 1)
return 0;
/* static initialise */
sspm_ready = 0;
sspm_workqueue = create_workqueue("SSPM_WQ");
if (!sspm_workqueue) {
pr_err("[SSPM] Workqueue Create Failed\n");
goto error;
}
if (platform_driver_register(&mtk_sspm_driver)) {
pr_err("[SSPM] Device Init Failed\n");
goto error;
}
pr_debug("[SSPM] Helper Init\n");
sspm_ready = 1;
atomic_set(&sspm_inited, 1);
return 0;
error:
atomic_set(&sspm_inited, 1);
return -1;
}
static int __init sspm_module_init(void)
{
if (sspm_sysfs_init()) {
pr_err("[SSPM] Sysfs Init Failed\n");
return -1;
}
#if SSPM_PLT_SERV_SUPPORT
if (sspm_plt_init()) {
pr_err("[SSPM] Platform Init Failed\n");
return -1;
}
pr_info("SSPM platform service is ready\n");
#endif
sspm_lock_emi_mpu();
return 0;
}
arch_initcall(sspm_init);
module_init(sspm_module_init);
@@ -0,0 +1,37 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_HELPER_H__
#define __SSPM_HELPER_H__
#include <linux/types.h>
struct sspm_regs {
void __iomem *cfg;
unsigned int cfgregsize;
int irq;
};
struct sspm_work_struct {
struct work_struct work;
unsigned int flags;
};
enum SEMAPHORE_FLAG {
NR_FLAG = 0,
};
extern struct sspm_regs sspmreg;
extern int sspm_plt_init(void);
/* @group_id: the group want to swap in tcm and run. */
extern void memcpy_to_sspm(void __iomem *trg, const void *src, int size);
extern void memcpy_from_sspm(void *trg, const void __iomem *src, int size);
extern int get_sspm_semaphore(int flag);
extern int release_sspm_semaphore(int flag);
extern void sspm_schedule_work(struct sspm_work_struct *sspm_ws);
extern unsigned int is_sspm_ready(void);
#endif
+73
View File
@@ -0,0 +1,73 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_H__
#define __SSPM_IPI_H__
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/semaphore.h>
#include <linux/completion.h>
#include "sspm_ipi_pin.h"
struct ipi_action {
void *data;
unsigned int id;
spinlock_t *lock;
};
#define IPI_REG_OK 0
#define IPI_REG_ALREADY -1
#define IPI_REG_ACTION_ERROR -2
#define IPI_REG_SEMAPHORE_FAIL -3
#define IPI_SERVICE_NOT_AVAILABLE -100
#define IPI_SERVICE_NOT_INITED -101
/* ipi_send() return code */
#define IPI_DONE 0
#define IPI_RETURN 1
#define IPI_BUSY -1
#define IPI_TIMEOUT_AVL -2
#define IPI_TIMEOUT_ACK -3
#define IPI_MODULE_ID_ERROR -4
#define IPI_HW_ERROR -5
#define IPI_NO_MEMORY -6
#define IPI_USED_IN_WAIT -7
#define IPI_PIN_MISUES -8
extern int sspm_ipi_init(void);
/* definition for opts arguments (new) */
#define IPI_OPT_WAIT 0
#define IPI_OPT_POLLING 1
#define sspm_ipi_send_sync_new sspm_ipi_send_sync
extern int sspm_ipi_recv_registration(int mid, struct ipi_action *act);
extern int sspm_ipi_recv_registration_ex(int mid, spinlock_t *lock,
struct ipi_action *act);
extern int sspm_ipi_recv_unregistration(int mid);
extern int sspm_ipi_recv_wait(int mid);
extern void sspm_ipi_recv_complete(int mid);
extern int sspm_ipi_send_sync(int mid, int opts, void *buffer, int slot,
void *retbuf, int retslot);
extern int sspm_ipi_send_ack(int mid, unsigned int *data);
extern int sspm_ipi_send_ack_ex(int mid, void *data, int retslot);
/* old definition (obslete) */
#define IPI_OPT_DEFAUT 0
#define IPI_OPT_NOLOCK (IPI_OPT_REDEF_MASK)
#define IPI_OPT_LOCK_BUSY (IPI_OPT_REDEF_MASK|IPI_OPT_LOCK_MASK)
#define IPI_OPT_LOCK_POLLING (IPI_OPT_REDEF_MASK|IPI_OPT_LOCK_MASK| \
IPI_OPT_POLLING_MASK)
extern int sspm_ipi_is_inited(void);
extern int sspm_ipi_send_async(int mid, int opts, void *buffer, int slot);
extern int sspm_ipi_send_async_wait(int mid, int opts, void *retbuf);
extern int sspm_ipi_send_async_wait_ex(int mid, int opts, void *retbuf,
int retslot);
#endif /* __SSPM_IPI_H__ */
@@ -0,0 +1,144 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_DEFINE_H__
#define __SSPM_IPI_DEFINE_H__
#include "sspm_ipi_mbox_layout.h"
/* mutex_send, sema_ack, mbox, slot, size,
* async, retdata, lock, polling, unused, prdata
*/
struct _pin_send send_pintable[] = {
{{{0} }, {0}, 0, PINS_OFFSET_PLATFORM, PINS_SIZE_PLATFORM,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_CPU_DVFS, PINS_SIZE_CPU_DVFS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_QOS, PINS_SIZE_QOS,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_TST1, PINS_SIZE_TST1,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_FHCTL, PINS_SIZE_FHCTL,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 0, PINS_OFFSET_SMI, PINS_SIZE_SMI,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
{{{0} }, {0}, 1, PINS_OFFSET_MCDI, PINS_SIZE_MCDI,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_SPM_SUSPEND, PINS_SIZE_SPM_SUSPEND,
1, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PMIC, PINS_SIZE_PMIC,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_PPM, PINS_SIZE_PPM,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_THERMAL, PINS_SIZE_THERMAL,
0, 1, 0, 0, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_UPOWER, PINS_SIZE_UPOWER,
0, 1, 1, 1, 0, 0},
{{{0} }, {0}, 1, PINS_OFFSET_CM, PINS_SIZE_CM,
0, 1, 1, 1, 0, 0},
/*====================================================================*/
};
#define TOTAL_SEND_PIN (sizeof(send_pintable)/sizeof(struct _pin_send))
/* act, mbox, slot, size, shared, retdata, lock, share_grp, unused */
struct _pin_recv recv_pintable[] = {
{NULL, 2, PINR_OFFSET_PLATFORM, PINR_SIZE_PLATFORM, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_CPU_DVFS, PINR_SIZE_CPU_DVFS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_QOS, PINR_SIZE_QOS, 0, 1, 0, 0, 0},
{NULL, 2, PINR_OFFSET_TST1, PINR_SIZE_TST1, 0, 1, 0, 0, 0},
};
#define TOTAL_RECV_PIN (sizeof(recv_pintable)/sizeof(struct _pin_recv))
/* info for all mbox: start, end, used_slot, mode, unused */
struct _mbox_info mbox_table[IPI_MBOX_TOTAL] = {
{0, 5, PINS_MBOX0_USED, 2, 0}, /* mbox 0 for send */
{6, 12, PINS_MBOX1_USED, 2, 0}, /* mbox 1 for send */
{0, 3, PINR_MBOX2_USED, 1, 0}, /* mbox 2 for recv */
{0, 0, 0, 0, 0}, /* mbox 3 */
};
static char *pin_name[IPI_ID_TOTAL] = {
"PLATFORM",
"CPU_DVFS",
"QOS",
"TST1",
"FHCTL",
"SMI",
"MCDI",
"SPM_SUSPEND",
"PMIC",
"PPM",
"Thermal",
"UPower",
"CM_MGR",
};
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define sspm_ipi_lock_spm_scenario(start, id, opt, name)
#endif
static inline int check_table_tag(int mcnt)
{
int i, j = 0, k = 0, n = 0;
uint32_t data, check;
struct _pin_recv *rpin = NULL;
struct _pin_send *spin = NULL;
for (i = 0; i < mcnt; i++) {
if (mbox_table[i].mode == 0)
continue;
/* Write init data into mailbox */
j = mbox_table[i].start;
if (mbox_table[i].mode == 1) { /* for recev */
rpin = &(recv_pintable[j]);
data = 2;
} else if (mbox_table[i].mode == 2) { /* for send */
spin = &(send_pintable[j]);
data = 1;
} else {
pr_debug("Error: mbox %d has unsupported mode=%d\n",
i, mbox_table[i].mode);
return -2;
}
data = ((data<<16)|('M'<<24));
if (IPI_MBOX_MODE & (1 << i)) {
/* 64 slots in the mailbox */
data |= 0x00800000;
}
/* for each pin in the mbox */
for (; j <= mbox_table[i].end; j++) {
if (mbox_table[i].mode == 1) { /* for recev */
k = rpin->slot;
n = rpin->size;
rpin++;
} else if (mbox_table[i].mode == 2) { /* for send */
k = spin->slot;
n = spin->size;
spin++;
}
/* for each slot in the pin */
data &= ~0xFFFF;
data |= (j << 8)|((uint8_t)(n));
while (n) {
sspm_mbox_read(i, k, &check, 1);
if (check != data) {
pr_debug("Error: IPI Dismatch!! mbox:%d pin:%d slot=%d should be %08X but now %08X\n",
i, j, k, data, check);
return -3;
}
k++;
n--;
}
}
}
return 0;
}
#endif /* __SSPM_IPI_DEFINE_H__ */
@@ -0,0 +1,767 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/atomic.h>
#include <linux/io.h>
#include <linux/sched/clock.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_mbox.h"
#include "sspm_ipi.h"
#include "sspm_ipi_mbox.h"
#define IPI_MONITOR
#include "sspm_ipi_define.h"
#define TIMEOUT_COMPLETE msecs_to_jiffies(2000)
#ifdef SSPM_STF_ENABLED
#include <linux/cpu.h>
#include "sspm_stf.h"
#endif
/* #define GET_IPI_TIMESTAMP */
#ifdef GET_IPI_TIMESTAMP
#include <linux/cpu.h>
#define IPI_TS_TEST_MAX 20
#define IPI_TS_TEST_PIN IPI_ID_PMIC_WRAP
u64 ipi_t0[IPI_TS_TEST_MAX];
u64 ipi_t4[IPI_TS_TEST_MAX];
u64 ipi_t5[IPI_TS_TEST_MAX];
static int test_cnt;
#endif
#ifdef IPI_MONITOR
#define IPI_MONITOR_TIMESTAMP
struct ipi_monitor {
/* 0: has no timestamp of t1/t2/t3 otherwise 1*/
unsigned int has_time: 1,
/* 0: no IPI, 1: t1 finished, 2: t2 finished, 3: t3 finished */
state : 2,
/* count of the IPI pin used */
seqno : 29;
#ifdef IPI_MONITOR_TIMESTAMP
unsigned long long t0;
unsigned long long t4;
unsigned long long t5;
#endif /* IPI_MONITOR_TIMESTAMP */
};
static struct ipi_monitor ipimon[IPI_ID_TOTAL];
static int ipi_last;
static spinlock_t lock_monitor;
#ifdef IPI_MONITOR_TIMESTAMP
static int err_pin;
static unsigned long long err_ts;
#endif /* IPI_MONITOR_TIMESTAMP */
static void ipi_monitor_dump_timeout(int mid, int opts)
{
int i;
unsigned long flags = 0;
spin_lock_irqsave(&lock_monitor, flags);
#ifdef IPI_MONITOR_TIMESTAMP
err_pin = -1;
err_ts = 0xffffffffffffffffLL;
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 1) || (ipimon[i].state == 2)) {
if (ipimon[i].t0 < err_ts) {
err_ts = ipimon[i].t0;
err_pin = i;
}
}
}
if (err_pin >= 0) {
pr_err("Error: possible error IPI %d pin=%s: t0=%lld\n",
err_pin, pin_name[err_pin], err_ts);
}
#endif /* IPI_MONITOR_TIMESTAMP */
pr_err("Error: IPI %d pin=%s mode=%d timeout at %lld (lastOK IPI=%d)\n",
mid, pin_name[mid], opts, cpu_clock(0), ipi_last);
#ifdef IPI_MONITOR_TIMESTAMP
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 0) || (ipimon[i].state == 3))
pr_err("IPI %d: seqno=%d, state=%d, t0=%lld, t4=%lld, t5=%lld\n",
i, ipimon[i].seqno, ipimon[i].state,
ipimon[i].t0, ipimon[i].t4, ipimon[i].t5);
else
pr_err("IPI %d: seqno=%d, state_err=%d, t0=%lld, t4=%lld, t5=%lld\n",
i, ipimon[i].seqno, ipimon[i].state,
ipimon[i].t0, ipimon[i].t4, ipimon[i].t5);
}
#else
for (i = 0; i < IPI_ID_TOTAL; i++) {
if ((ipimon[i].state == 0) || (ipimon[i].state == 3))
pr_err("IPI %d: seqno=%d, state=%d\n",
i, ipimon[i].seqno, ipimon[i].state);
else
pr_err("IPI %d: seqno=%d, state_err=%d\n",
i, ipimon[i].seqno, ipimon[i].state);
}
#endif /* IPI_MONITOR_TIMESTAMP */
spin_unlock_irqrestore(&lock_monitor, flags);
pr_err("Error: SSPM IPI=%d timeout\n", mid);
sspm_ipi_timeout_cb(mid);
BUG_ON(1);
}
#endif
static void ipi_check_send(int mid)
{
#ifdef SSPM_STF_ENABLED
if (test_table[mid].data)
test_table[mid].start_us = (unsigned int)(cpu_clock(0)/1000);
#endif /* SSPM_STF_ENABLED */
#ifdef GET_IPI_TIMESTAMP
if ((mid == IPI_TS_TEST_PIN) && (test_cnt < IPI_TS_TEST_MAX))
ipi_t0[test_cnt] = cpu_clock(0);
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
ipimon[mid].seqno++;
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[mid].t0 = cpu_clock(0);
ipimon[mid].t4 = 0;
ipimon[mid].t5 = 0;
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[mid].state = 1;
#endif /* IPI_MONITOR */
}
static void ipi_check_ack(int mid, int opts, int ret)
{
if (ret == 0) {
#ifdef SSPM_STF_ENABLED
if (test_table[mid].data) {
struct chk_data *pdata = test_table[mid].data;
int cnt = test_table[mid].test_cnt;
pdata[cnt].time_spent = ((unsigned int)
(cpu_clock(0)/1000) - test_table[mid].start_us);
if (retbuf)
pdata[cnt].ack_data_feedback =
*((unsigned int *)retbuf);
else
pdata[cnt].ack_data_feedback = 0;
test_table[mid].test_cnt++;
}
#endif /* SSPM_STF_ENABLED */
#ifdef GET_IPI_TIMESTAMP
if ((mid == IPI_TS_TEST_PIN) && (test_cnt < IPI_TS_TEST_MAX)) {
ipi_t5[test_cnt] = cpu_clock(0);
test_cnt++;
}
if (test_cnt >= IPI_TS_TEST_MAX) {
int i;
for (i = 0; i < IPI_TS_TEST_MAX; i++)
pr_err("IPI %d: t0=%llu, t4=%llu, t5=%llu\n",
i, ipi_t0[i], ipi_t4[i], ipi_t5[i]);
test_cnt = 0;
}
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[mid].t5 = cpu_clock(0);
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[mid].state = 3;
ipi_last = mid;
} else { /* timeout case */
ipi_monitor_dump_timeout(mid, opts);
}
#else
}
#endif /* IPI_MONITOR */
}
atomic_t lock_send[TOTAL_SEND_PIN];
atomic_t lock_ack[TOTAL_SEND_PIN];
spinlock_t lock_polling[TOTAL_SEND_PIN];
/* used for IPI module isr to sync with its task */
struct completion sema_ipi_task[TOTAL_RECV_PIN];
struct mutex mutex_ipi_reg;
static int sspm_ipi_inited;
static unsigned int ipi_isr_cb(unsigned int mbox, void __iomem *base,
unsigned int irq);
int sspm_ipi_init(void)
{
int i, ret;
struct _pin_send *pin;
#ifdef IPI_MONITOR
spin_lock_init(&lock_monitor);
#ifdef IPI_MONITOR_TIMESTAMP
for (i = 0; i < IPI_ID_TOTAL; i++)
ipimon[i].has_time = 1;
#endif /* IPI_MONITOR_TIMESTAMP */
#endif /* IPI_MONITOR */
mutex_init(&mutex_ipi_reg);
for (i = 0; i < TOTAL_SEND_PIN; i++) {
mutex_init(&send_pintable[i].mutex_send);
init_completion(&send_pintable[i].comp_ack);
atomic_set(&lock_send[i], 1);
atomic_set(&lock_ack[i], 0);
spin_lock_init(&lock_polling[i]);
}
/* IPI HW initialize and ISR registration */
if (sspm_mbox_init(IPI_MBOX_MODE, IPI_MBOX_TOTAL, ipi_isr_cb) != 0) {
pr_err("Error: sspm_mbox_init failed\n");
return -1;
}
for (i = 0; i < TOTAL_SEND_PIN; i++) {
pin = &(send_pintable[i]);
pin->prdata = sspm_mbox_addr(pin->mbox, pin->slot);
}
ret = check_table_tag(IPI_MBOX_TOTAL);
if (ret == 0)
sspm_ipi_inited = 1;
return ret;
}
extern int sspm_ipi_is_inited(void)
{
return sspm_ipi_inited;
}
int sspm_ipi_recv_registration(int mid, struct ipi_action *act)
{
struct _pin_recv *pin;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
if (act == NULL)
return IPI_REG_ACTION_ERROR;
pin = &(recv_pintable[mid]);
act->id = mid;
act->lock = NULL;
mutex_lock(&mutex_ipi_reg);
if (pin->act != NULL) {
mutex_unlock(&mutex_ipi_reg);
return IPI_REG_ALREADY;
}
mutex_unlock(&mutex_ipi_reg);
init_completion(&sema_ipi_task[mid]);
pin->act = act;
return IPI_REG_OK;
}
EXPORT_SYMBOL(sspm_ipi_recv_registration);
int sspm_ipi_recv_registration_ex(int mid, spinlock_t *lock,
struct ipi_action *act)
{
int ret = IPI_REG_OK;
ret = sspm_ipi_recv_registration(mid, act);
if (ret != IPI_REG_OK)
return ret;
act->lock = lock;
return IPI_REG_OK;
}
int sspm_ipi_recv_wait(int mid)
{
struct _pin_recv *pin;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(recv_pintable[mid]);
wait_for_completion(&sema_ipi_task[mid]);
/* if the pin is waiting async data, eliminate multiple completions */
if (pin->act->lock)
while (try_wait_for_completion(&sema_ipi_task[mid]))
;
return 0;
}
EXPORT_SYMBOL(sspm_ipi_recv_wait);
void sspm_ipi_recv_complete(int mid)
{
complete(&sema_ipi_task[mid]);
}
EXPORT_SYMBOL(sspm_ipi_recv_complete);
int sspm_ipi_recv_unregistration(int mid)
{
struct _pin_recv *pin;
pin = &(recv_pintable[mid]);
pin->act = NULL;
return IPI_REG_OK;
}
EXPORT_SYMBOL(sspm_ipi_recv_unregistration);
static void ipi_do_ack(struct _mbox_info *mbox, unsigned int in_irq,
void __iomem *base)
{
/* executed from ISR */
int idx_end = mbox->end;
int idx_start = mbox->start;
int i;
struct _pin_send *pin = &(send_pintable[idx_start]);
for (i = idx_start; i <= idx_end; i++, pin++) {
if ((in_irq & 0x01) == 0x01) { /* irq bit enable */
atomic_inc(&lock_ack[i]);
/* check if pin user send in WAIT mode,
* wait lock & continue if not
*/
if (mutex_is_locked(&pin->mutex_send)) { /* WAIT mode */
#ifdef GET_IPI_TIMESTAMP
if ((i == IPI_TS_TEST_PIN) &&
(test_cnt < IPI_TS_TEST_MAX))
ipi_t4[test_cnt] = cpu_clock(0);
#endif /* GET_IPI_TIMESTAMP */
#ifdef IPI_MONITOR
#ifdef IPI_MONITOR_TIMESTAMP
ipimon[i].t4 = cpu_clock(0);
#endif /* IPI_MONITOR_TIMESTAMP */
ipimon[i].state = 2;
#endif /* IPI_MONITOR */
complete(&pin->comp_ack);
}
}
in_irq >>= 1;
}
}
static int handle_action(struct ipi_action *action, void *mbox_addr,
int bytelen)
{
/* if user has no data, just wakeup user without data */
if (action->data == NULL)
return 1;
/* if user async send without waiting ACK from SSPM */
/* use spin lock to mempcy without overwriting user data */
if (action->lock) {
if (spin_trylock(action->lock)) {
memcpy_from_sspm(action->data, mbox_addr, bytelen);
} else {
/* Users has lock. Just drop data */
return 0;
}
spin_unlock(action->lock);
} else {
memcpy_from_sspm(action->data, mbox_addr, bytelen);
}
return 1;
}
static void ipi_do_recv(struct _mbox_info *mbox, unsigned int in_irq,
void __iomem *base)
{
/* executed from ISR */
/* get the value from INT_IRQ_x (MD32 side) or OUT_IRQ_0 (Linux side) */
int idx_end = mbox->end;
int idx_start = mbox->start;
int i, ret;
struct _pin_recv *pin;
struct ipi_action *action;
if (in_irq == 0)
return;
/* check each bit for interrupt triggered */
/* the bit is used to determine the index of callback array */
pin = &(recv_pintable[idx_start]);
for (i = idx_start; i <= idx_end; i++, pin++) {
if ((in_irq & 0x01) == 0x01) { /* irq bit enable */
action = pin->act;
if (action != NULL) {
/* do the action */
ret = handle_action(action, (void *)
(base + (pin->slot * SSPM_MBOX_SLOT_SIZE)),
pin->size * SSPM_MBOX_SLOT_SIZE);
if (ret)
complete(&sema_ipi_task[i]);
}
} /* check bit is enabled */
in_irq >>= 1;
} /* check INT_IRQ bits */
}
int sspm_ipi_send_async(int mid, int opts, void *buffer, int slot)
{
int mbno, ret, lock = 0;
struct _pin_send *pin;
struct _mbox_info *mbox;
static int timeout;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(send_pintable[mid]);
if (!pin->async)
return IPI_PIN_MISUES;
if (slot > pin->size)
return IPI_NO_MEMORY;
ipi_check_send(mid);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
if (!(opts & IPI_OPT_REDEF_MASK)) {
lock = pin->lock & IPI_LOCK_ORIGINAL;
} else {
if (opts & IPI_OPT_LOCK_MASK) {
lock = 1;
pin->lock |= 0x6;
} else {
pin->lock |= 0x4;
}
}
if (lock == 0) { /* use mutex */
mutex_lock(&pin->mutex_send);
} else { /* use spin method */
timeout = 0xffff;
while (atomic_read(&lock_send[mid]) == 0) {
timeout--;
udelay(10); /* fix me later, should we add this one? */
if (timeout == 0) {
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
return IPI_TIMEOUT_AVL;
}
}
atomic_dec(&lock_send[mid]);
}
atomic_set(&lock_ack[mid], 0);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
/* note: the bit of INT(OUT)_IRQ is depending on mid */
if (slot == 0)
slot = pin->size;
ret = sspm_mbox_send(mbno, pin->slot, mid - mbox->start, buffer, slot);
if (ret != 0) {
#ifdef IPI_MONITOR
ipimon[mid].seqno--;
#endif
/* release lock */
if (lock == 0) /* use mutex */
mutex_unlock(&pin->mutex_send);
else
atomic_inc(&lock_send[mid]);
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
return IPI_HW_ERROR;
}
return IPI_DONE;
}
int sspm_ipi_send_async_wait(int mid, int opts, void *retbuf)
{
int slot = 1;
if (retbuf == NULL)
slot = 0;
return sspm_ipi_send_async_wait_ex(mid, opts, retbuf, slot);
}
int sspm_ipi_send_async_wait_ex(int mid, int opts, void *retbuf, int retslot)
{
int ret = 0, lock = 0, polling = 0;
struct _pin_send *pin;
unsigned long wait_comp;
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(send_pintable[mid]);
if (!pin->async)
return IPI_PIN_MISUES;
if (retslot > pin->size)
return IPI_NO_MEMORY;
if (!(opts & IPI_OPT_REDEF_MASK)) {
lock = pin->lock & IPI_LOCK_ORIGINAL;
polling = pin->polling;
} else {
if (opts & IPI_OPT_LOCK_MASK) {
lock = 1;
pin->lock |= 0x6;
if (opts & IPI_OPT_POLLING_MASK)
polling = 1;
} else {
pin->lock |= 0x4;
}
}
if (lock == 0) { /* use completion */
wait_comp = wait_for_completion_timeout(&pin->comp_ack,
TIMEOUT_COMPLETE);
if ((wait_comp == 0) && (atomic_read(&lock_ack[mid]) == 0)) {
/* wait mode timeout */
ret = IPI_TIMEOUT_ACK;
} else {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(SSPM_MBOX_SLOT_SIZE * retslot));
}
atomic_set(&lock_ack[mid], 0);
} else { /* use spin method */
int retries = 2000000;
while (retries-- > 0) {
int mbno = pin->mbox;
struct _mbox_info *mbox = &(mbox_table[mbno]);
ret = sspm_mbox_polling(mbno, mid - mbox->start,
pin->slot, retbuf, retslot, 2000);
if (ret == 0)
break;
if (atomic_read(&lock_ack[mid])) {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(SSPM_MBOX_SLOT_SIZE * retslot));
ret = 0;
break;
}
udelay(1);
}
atomic_set(&lock_ack[mid], 0);
if (retries == 0)
ret = IPI_TIMEOUT_ACK;
}
/* Release mutex */
if (lock == 0) /* use mutex */
mutex_unlock(&pin->mutex_send);
else
atomic_inc(&lock_send[mid]);
if (pin->lock & IPI_LOCK_CHANGE)
pin->lock &= IPI_LOCK_ORIGINAL;
ipi_check_ack(mid, opts, ret);
return ret;
}
int sspm_ipi_send_ack(int mid, unsigned int *data)
{
int len = 1;
if (data == NULL)
len = 0;
return sspm_ipi_send_ack_ex(mid, data, len);
}
EXPORT_SYMBOL(sspm_ipi_send_ack);
int sspm_ipi_send_ack_ex(int mid, void *data, int retslot)
{
struct _pin_recv *pin;
struct _mbox_info *mbox;
int len, mbno, irq, slot, ret;
if ((mid < 0) || (mid >= TOTAL_RECV_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
pin = &(recv_pintable[mid]);
if (retslot > pin->size)
return IPI_NO_MEMORY;
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
irq = mid - (mbox->start);
/* return data length */
if ((pin->retdata) && (data != NULL))
len = retslot;
else
len = 0;
/* where to put the return data */
slot = pin->slot;
ret = sspm_mbox_send(mbno, slot, irq, (void *)data, len);
if (ret)
return -1;
return 0;
}
int sspm_ipi_send_sync(int mid, int opts, void *buffer, int slot,
void *retbuf, int retslot)
{
unsigned long flags = 0;
unsigned long wait_comp;
int mbno, ret;
struct _pin_send *pin;
struct _mbox_info *mbox;
if (sspm_ipi_inited == 0)
return IPI_SERVICE_NOT_INITED;
/* check if mid is in the predefined range */
if ((mid < 0) || (mid >= TOTAL_SEND_PIN))
return IPI_SERVICE_NOT_AVAILABLE;
/* get the predefined pin info from mid */
pin = &(send_pintable[mid]);
if ((slot > pin->size) || (retslot > pin->size))
return IPI_NO_MEMORY;
/* check if IPI can be send in different mode */
if (opts&IPI_OPT_POLLING) { /* POLLING mode */
spin_lock_irqsave(&lock_polling[mid], flags);
if (mutex_is_locked(&pin->mutex_send)) {
spin_unlock_irqrestore(&lock_polling[mid], flags);
pr_err("Error: IPI pin=%d has been used in WAIT mode\n",
mid);
BUG_ON(1);
return IPI_USED_IN_WAIT;
}
} else { /* WAIT mode */
/* Check if users call in atomic/interrupt/IRQ disabled */
if (preempt_count() || in_interrupt() || irqs_disabled()) {
pr_err("IPI panic: pin id=%d, atomic=%d, interrupt=%ld, irq disabled=%d\n",
mid, preempt_count(), in_interrupt(),
irqs_disabled());
BUG_ON(1);
}
mutex_lock(&pin->mutex_send);
}
ipi_check_send(mid);
mbno = pin->mbox;
mbox = &(mbox_table[mbno]);
/* note: the bit of INT(OUT)_IRQ is depending on mid */
if (slot == 0)
slot = pin->size;
atomic_set(&lock_ack[mid], 0);
/* send IPI data to SSPM */
ret = sspm_mbox_send(mbno, pin->slot, mid - mbox->start, buffer, slot);
if (ret != 0) {
#ifdef IPI_MONITOR
ipimon[mid].seqno--;
#endif
/* release lock */
if (opts&IPI_OPT_POLLING) /* POLLING mode */
spin_unlock_irqrestore(&lock_polling[mid], flags);
else
mutex_unlock(&pin->mutex_send);
return IPI_HW_ERROR;
}
/* if there is no retdata in predefined table */
if ((pin->retdata == 0) || (retslot == 0))
retbuf = NULL;
/* wait ACK from SSPM */
if (opts&IPI_OPT_POLLING) { /* POLLING mode */
int retries = 2000000;
while (retries-- > 0) {
ret = sspm_mbox_polling(mbno, mid - mbox->start,
pin->slot, retbuf, retslot, 2000);
if (ret == 0)
break;
if (atomic_read(&lock_ack[mid])) {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(SSPM_MBOX_SLOT_SIZE * retslot));
ret = 0;
break;
}
udelay(1);
}
atomic_set(&lock_ack[mid], 0);
if (retries == 0) /* polling mode timeout */
ret = IPI_TIMEOUT_ACK;
ipi_check_ack(mid, opts, ret);
spin_unlock_irqrestore(&lock_polling[mid], flags);
} else { /* WAIT mode */
wait_comp = wait_for_completion_timeout(&pin->comp_ack,
TIMEOUT_COMPLETE);
if ((wait_comp == 0) && (atomic_read(&lock_ack[mid]) == 0)) {
/* wait mode timeout */
ret = IPI_TIMEOUT_ACK;
} else {
if (retbuf)
memcpy_from_sspm(retbuf, pin->prdata,
(SSPM_MBOX_SLOT_SIZE * retslot));
}
atomic_set(&lock_ack[mid], 0);
ipi_check_ack(mid, opts, ret);
mutex_unlock(&pin->mutex_send);
}
return ret;
}
EXPORT_SYMBOL(sspm_ipi_send_sync);
static unsigned int ipi_isr_cb(unsigned int mbno, void __iomem *base,
unsigned int irq)
{
struct _mbox_info *mbox;
if (mbno >= IPI_MBOX_TOTAL)
return irq;
mbox = &(mbox_table[mbno]);
if (mbox->mode == 2) /* ipi_do_ack */
ipi_do_ack(mbox, irq, base);
else if (mbox->mode == 1) /* ipi_do_recv */
ipi_do_recv(mbox, irq, base);
return irq;
}
@@ -0,0 +1,69 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_MBOX_H__
#define __SSPM_IPI_MBOX_H__
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/semaphore.h>
#include <linux/completion.h>
#include <linux/mutex.h>
extern struct completion sema_ipi_task[];
/* pre-define slot and size here */
/* the array index is mapped to bit position of INT_IRQ or OUT_IRQ */
/* the slot is where the data begin */
/* the size is how many registers are needed */
struct _pin_send {
struct mutex mutex_send;
struct completion comp_ack;
unsigned int mbox:3, /* mailbox number used by the pin */
slot:6, /* bit position of INT_IRQ or OUT_IRQ */
size:6, /* register number used to pass argument */
async:1, /* pin can use async functions */
retdata:1, /* return data or not */
lock:3, /* Linux lock method: 0: mutex; 1: busy wait */
polling:1, /* Linux ack polling method */
unused:11;
uint32_t *prdata;
};
struct _pin_recv {
struct ipi_action *act;
unsigned int mbox:3, /* mailbox number used by the pin */
slot:6, /* slot offset of the pin */
size:6, /* register number used to pass argument */
shared:2, /* shared slot */
retdata:2, /* return data or not */
lock:2, /* Linux lock method: 0: mutex; 1: busy wait */
share_grp:5, /* shared group */
unused:6;
};
struct _mbox_info {
unsigned int start:8, /* start index of pin table */
end:8, /* end index of pin table */
used_slot:8, /* used slots in the mailbox */
mode:2, /* 0:disable, 1:for received, 2: for send */
unused:6;
};
#define IPI_SLOT_SHARED 1
#define IPI_SLOT_NONE 0
#define IPI_DATA_RETURN 1
#define IPI_DATA_NONE 0
#define IPI_LOCK_ORIGINAL 0x1
#define IPI_LOCK_NEW 0x2
#define IPI_LOCK_CHANGE 0x4
__weak void sspm_ipi_timeout_cb(int ipi_id) {}
#endif /* __SSPM_IPI_MBOX_H__ */
@@ -0,0 +1,99 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_MBOX_LAYOUT_H__
#define __SSPM_IPI_MBOX_LAYOUT_H__
#define IPI_MBOX_TOTAL 4
#define IPI_MBOX0_64D 0
#define IPI_MBOX1_64D 0
#define IPI_MBOX2_64D 0
#define IPI_MBOX3_64D 0
#define IPI_MBOX4_64D 0
#define IPI_MBOX_MODE ((IPI_MBOX4_64D<<4)|(IPI_MBOX3_64D<<3)| \
(IPI_MBOX2_64D<<2)|(IPI_MBOX1_64D<<1)| \
IPI_MBOX0_64D)
#define IPI_MBOX0_SLOTS ((IPI_MBOX0_64D+1)*32)
#define IPI_MBOX1_SLOTS ((IPI_MBOX1_64D+1)*32)
#define IPI_MBOX2_SLOTS ((IPI_MBOX2_64D+1)*32)
#define IPI_MBOX3_SLOTS ((IPI_MBOX3_64D+1)*32)
#define IPI_MBOX4_SLOTS ((IPI_MBOX4_64D+1)*32)
/* definition of slot size for send PINs */
#define PINS_SIZE_PLATFORM 3 /* the following will use mbox 0 */
#define PINS_SIZE_CPU_DVFS 4
#if defined(CONFIG_MACH_MT6768) || defined(CONFIG_MACH_MT6771)
#define PINS_SIZE_QOS 4
#else
#define PINS_SIZE_QOS 6
#endif
#define PINS_SIZE_TST1 4
#define PINS_SIZE_FHCTL 9
#define PINS_SIZE_SMI 3
/* ============================================================ */
#define PINS_SIZE_MCDI 2 /* the following will use mbox 1 */
#define PINS_SIZE_SPM_SUSPEND 8
#define PINS_SIZE_PMIC 5
#define PINS_SIZE_PPM 7
#define PINS_SIZE_THERMAL 4
#define PINS_SIZE_UPOWER 4
#define PINS_SIZE_CM 2
/* ============================================================ */
/* definition of slot offset for PINs */
#define PINS_OFFSET_PLATFORM 0 /* the following will use mbox 0 */
#define PINS_OFFSET_CPU_DVFS (PINS_OFFSET_PLATFORM + PINS_SIZE_PLATFORM)
#define PINS_OFFSET_QOS (PINS_OFFSET_CPU_DVFS + PINS_SIZE_CPU_DVFS)
#define PINS_OFFSET_TST1 (PINS_OFFSET_QOS + PINS_SIZE_QOS)
#define PINS_OFFSET_FHCTL (PINS_OFFSET_TST1 + PINS_SIZE_TST1)
#define PINS_OFFSET_SMI (PINS_OFFSET_FHCTL + PINS_SIZE_FHCTL)
#define PINS_MBOX0_USED (PINS_OFFSET_SMI + PINS_SIZE_SMI)
#if (PINS_MBOX0_USED > IPI_MBOX0_SLOTS)
#error "MBOX0 cannot hold all pin definitions"
#endif
/* ============================================================ */
#define PINS_OFFSET_MCDI 0 /* the following will use mbox 1 */
#define PINS_OFFSET_SPM_SUSPEND (PINS_OFFSET_MCDI + PINS_SIZE_MCDI)
#define PINS_OFFSET_PMIC (PINS_OFFSET_SPM_SUSPEND + \
PINS_SIZE_SPM_SUSPEND)
#define PINS_OFFSET_PPM (PINS_OFFSET_PMIC + PINS_SIZE_PMIC)
#define PINS_OFFSET_THERMAL (PINS_OFFSET_PPM + PINS_SIZE_PPM)
#define PINS_OFFSET_UPOWER (PINS_OFFSET_THERMAL + PINS_SIZE_THERMAL)
#define PINS_OFFSET_CM (PINS_OFFSET_UPOWER + PINS_SIZE_UPOWER)
#define PINS_MBOX1_USED (PINS_OFFSET_CM + PINS_SIZE_CM)
#if (PINS_MBOX1_USED > IPI_MBOX1_SLOTS)
#error "MBOX1 cannot hold all pin definitions"
#endif
/* ============================================================ */
/* definition of slot size for received PINs */
#define PINR_SIZE_PLATFORM 3 /* the following will use mbox 2 */
#define PINR_SIZE_CPU_DVFS 4
#if defined(CONFIG_MACH_MT6768) || defined(CONFIG_MACH_MT6771)
#define PINR_SIZE_QOS 4
#else
#define PINR_SIZE_QOS 6
#endif
#define PINR_SIZE_TST1 4
/* definition of slot offset for PINs */
#define PINR_OFFSET_PLATFORM 0 /* the following will use mbox 2 */
#define PINR_OFFSET_CPU_DVFS (PINR_OFFSET_PLATFORM + PINR_SIZE_PLATFORM)
#define PINR_OFFSET_QOS (PINR_OFFSET_CPU_DVFS + PINR_SIZE_CPU_DVFS)
#define PINR_OFFSET_TST1 (PINR_OFFSET_QOS + PINR_SIZE_QOS)
#define PINR_MBOX2_USED (PINR_OFFSET_TST1 + PINR_SIZE_TST1)
#if (PINR_MBOX2_USED > IPI_MBOX2_SLOTS)
#error "MBOX2 cannot hold all pin definitions"
#endif
#define SHAREMBOX_NO_MCDI 3
#define SHAREMBOX_OFFSET_MCDI 0
#define SHAREMBOX_SIZE_MCDI 20
#define SHAREMBOX_OFFSET_TIMESTAMP (SHAREMBOX_OFFSET_MCDI + \
SHAREMBOX_SIZE_MCDI)
#define SHAREMBOX_SIZE_TIMESTAMP 6
#endif /* __SSPM_IPI_MBOX_LAYOUT_H__ */
@@ -0,0 +1,30 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_PIN_H__
#define __SSPM_IPI_PIN_H__
/* define module id here ... */
/* use bit 0 - 7 of IN_IRQ of mailbox 0 */
#define IPI_ID_PLATFORM 0 /* the following will use mbox 0 */
#define IPI_ID_CPU_DVFS 1
#define IPI_ID_QOS 2
#define IPI_ID_TST1 3
#define IPI_ID_FHCTL 4
#define IPI_ID_SMI 5
/* use bit 8 - 15 of IN_IRQ of mailbox 1 */
#define IPI_ID_MCDI 6 /* the following will use mbox 1 */
#define IPI_ID_SPM_SUSPEND 7
#define IPI_ID_PMIC 8
#define IPI_ID_PPM 9
#define IPI_ID_THERMAL 10
#define IPI_ID_UPOWER 11
#define IPI_ID_CM 12
#define IPI_ID_TOTAL 13
#define IPI_OPT_REDEF_MASK 0x1
#define IPI_OPT_LOCK_MASK 0x2
#define IPI_OPT_POLLING_MASK 0x4
#endif /* __SSPM_IPI_PIN_H__ */
@@ -0,0 +1,21 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
/* debug API */
__weak void dump_emi_outstanding(void) {}
__weak void mtk_spm_dump_debug_info(void) {}
__weak void usb_dump_debug_register(void) {}
__weak void dpmaif_dump_reg(void) {}
/* platform callback when ipi timeout */
void sspm_ipi_timeout_cb(int ipi_id)
{
}
+19
View File
@@ -0,0 +1,19 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <mt-plat/sync_write.h>
#include "sspm_helper.h"
#include "sspm_excep.h"
/*
* scp irq initialize
*/
void scp_irq_init(unsigned int irq)
{
}
@@ -0,0 +1,15 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_LOGGER_H__
#define __SSPM_LOGGER_H__
#include <linux/types.h>
extern void sspm_log_lastk_recv(unsigned int exists);
extern unsigned int __init sspm_logger_init(phys_addr_t start,
phys_addr_t limit);
extern int __init sspm_logger_init_done(void);
#endif
@@ -0,0 +1,338 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_ipi.h"
#include "sspm_reservedmem.h"
#include "sspm_reservedmem_define.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
#ifdef SSPM_PLT_LOGGER_BUF_LEN
/* use platform-defined buffer length */
#define BUF_LEN SSPM_PLT_LOGGER_BUF_LEN
#else
/* otherwise use default buffer length */
#define BUF_LEN (1 * 1024 * 1024)
#endif
#define LBUF_LEN (4 * 1024)
#define SSPM_TIMER_TIMEOUT (1 * HZ) /* 1 seconds*/
#define ROUNDUP(a, b) (((a) + ((b)-1)) & ~((b)-1))
struct log_ctrl_s {
unsigned int base;
unsigned int size;
unsigned int enable;
unsigned int info_ofs;
unsigned int buff_ofs;
unsigned int buff_size;
#if SSPM_LASTK_SUPPORT
unsigned int linfo_ofs;
unsigned int lbuff_ofs;
unsigned int lbuff_size;
#endif
};
struct buffer_info_s {
unsigned int r_pos;
unsigned int w_pos;
};
static unsigned int sspm_logger_inited;
static struct log_ctrl_s *log_ctl;
static struct buffer_info_s *buf_info, *lbuf_info;
static struct timer_list sspm_log_timer;
#if SSPM_LASTK_SUPPORT
static unsigned int sspm_logger_lastk_exists;
#endif
static DEFINE_MUTEX(sspm_log_mutex);
static inline void sspm_log_timer_add(void)
{
if (sspm_log_timer.expires == 0) {
sspm_log_timer.expires = jiffies + SSPM_TIMER_TIMEOUT;
add_timer(&sspm_log_timer);
}
}
static void sspm_log_timeout(struct timer_list *unused)
{
if (buf_info->r_pos != buf_info->w_pos) {
sspm_log_if_wake();
sspm_log_timer.expires = 0;
} else {
sspm_log_timer_add();
}
}
ssize_t sspm_log_read(char __user *data, size_t len)
{
unsigned long w_pos, r_pos, datalen;
char *buf, *tmp_buf;
if (!sspm_logger_inited)
return 0;
datalen = 0;
mutex_lock(&sspm_log_mutex);
r_pos = buf_info->r_pos;
w_pos = buf_info->w_pos;
if (r_pos == w_pos)
goto error;
if (r_pos > w_pos)
datalen = BUF_LEN - r_pos; /* not wrap */
else
datalen = w_pos - r_pos;
if (datalen > len)
datalen = len;
buf = ((char *) log_ctl) + log_ctl->buff_ofs + r_pos;
tmp_buf = kmalloc((size_t)len, GFP_KERNEL);
len = datalen;
if (tmp_buf) {
memcpy_fromio(tmp_buf, buf, len);
if (copy_to_user(data, tmp_buf, len))
pr_debug("sspm logger: copy data failed !!!\n");
kfree(tmp_buf);
} else {
pr_debug("sspm logger: create log buffer failed !!!\n");
goto error;
}
r_pos += datalen;
if (r_pos >= BUF_LEN)
r_pos -= BUF_LEN;
buf_info->r_pos = r_pos;
error:
mutex_unlock(&sspm_log_mutex);
return datalen;
}
unsigned int sspm_log_poll(void)
{
if (!sspm_logger_inited)
return 0;
if (buf_info->r_pos != buf_info->w_pos)
return POLLIN | POLLRDNORM;
sspm_log_timer_add();
return 0;
}
static unsigned int sspm_log_enable_set(unsigned int enable)
{
struct plt_ipi_data_s ipi_data;
int ret, ackdata;
if (sspm_logger_inited) {
ipi_data.cmd = PLT_LOG_ENABLE;
ipi_data.u.logger.enable = enable;
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_WAIT,
&ipi_data, sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE,
&ackdata, 1);
if (ret != 0) {
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
goto error;
}
if (enable != ackdata) {
pr_err("SSPM: %s fail ret=%d\n", __func__, ackdata);
goto error;
}
log_ctl->enable = enable;
}
error:
return 0;
}
#if SSPM_LASTK_SUPPORT
static unsigned int sspm_log_lastk_get(char *buf)
{
unsigned int ret, w_pos;
char *lbuf;
ret = 0;
if (sspm_logger_inited && sspm_logger_lastk_exists) {
w_pos = lbuf_info->w_pos;
lbuf = ((char *) log_ctl) + log_ctl->lbuff_ofs;
ret = w_pos;
#if 0 /* TODO: memcpy ? */
while (w_pos-- > 0)
*(buf++) = *(lbuf++);
#endif
memcpy_fromio(buf, lbuf, w_pos);
}
return ret;
}
void sspm_log_lastk_recv(unsigned int exists)
{
sspm_logger_lastk_exists = exists;
}
#endif
static ssize_t sspm_mobile_log_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
unsigned int stat;
stat = (sspm_logger_inited && log_ctl->enable) ? 1 : 0;
return snprintf(buf, PAGE_SIZE, "SSPM mobile log is %s\n",
(stat == 0x1) ? "enabled" : "disabled");
}
static ssize_t sspm_mobile_log_store(struct device *kobj,
struct device_attribute *attr, const char *buf, size_t n)
{
unsigned int enable;
if (kstrtouint(buf, 0, &enable) != 0)
return -EINVAL;
mutex_lock(&sspm_log_mutex);
sspm_log_enable_set(enable);
mutex_unlock(&sspm_log_mutex);
return n;
}
DEVICE_ATTR(sspm_mobile_log, 0644, sspm_mobile_log_show, sspm_mobile_log_store);
#if SSPM_LASTK_SUPPORT
static ssize_t sspm_log_lastk_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
unsigned int ret;
ret = sspm_log_lastk_get(buf);
return ret;
}
DEVICE_ATTR(sspm_log_lastk, 0444, sspm_log_lastk_show, NULL);
#endif
unsigned int __init sspm_logger_init(phys_addr_t start, phys_addr_t limit)
{
unsigned int last_ofs;
last_ofs = 0;
log_ctl = (struct log_ctrl_s *)(uintptr_t) start;
log_ctl->base = PLT_LOG_ENABLE; /* magic */
log_ctl->enable = 0;
log_ctl->size = sizeof(*log_ctl);
last_ofs += log_ctl->size;
log_ctl->info_ofs = last_ofs;
last_ofs += sizeof(*buf_info);
last_ofs = ROUNDUP(last_ofs, 4);
log_ctl->buff_ofs = last_ofs;
log_ctl->buff_size = BUF_LEN;
buf_info = (struct buffer_info_s *) (((unsigned char *) log_ctl) +
log_ctl->info_ofs);
buf_info->r_pos = 0;
buf_info->w_pos = 0;
last_ofs += log_ctl->buff_size;
#if SSPM_LASTK_SUPPORT
log_ctl->linfo_ofs = last_ofs;
last_ofs += sizeof(*lbuf_info);
last_ofs = ROUNDUP(last_ofs, 4);
log_ctl->lbuff_ofs = last_ofs;
log_ctl->lbuff_size = LBUF_LEN;
lbuf_info = (struct buffer_info_s *) (((unsigned char *) log_ctl) +
log_ctl->linfo_ofs);
lbuf_info->r_pos = 0;
lbuf_info->w_pos = 0;
last_ofs += log_ctl->lbuff_size;
#endif
if (last_ofs >= limit) {
pr_err("SSPM:%s() initial fail, last_ofs=%u, limit=%u\n",
__func__, last_ofs, (unsigned int) limit);
goto error;
}
return last_ofs;
error:
sspm_logger_inited = 0;
log_ctl = NULL;
buf_info = lbuf_info = NULL;
return 0;
}
int __init sspm_logger_init_done(void)
{
int ret;
if (log_ctl) {
ret = sspm_sysfs_create_file(&dev_attr_sspm_mobile_log);
if (unlikely(ret != 0))
return ret;
#if SSPM_LASTK_SUPPORT
ret = sspm_sysfs_create_file(&dev_attr_sspm_log_lastk);
if (unlikely(ret != 0))
return ret;
#endif
timer_setup(&sspm_log_timer, &sspm_log_timeout, 0);
sspm_log_timer.expires = 0;
sspm_logger_inited = 1;
}
return 0;
}
+289
View File
@@ -0,0 +1,289 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <mt-plat/sync_write.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/delay.h>
#include "sspm_define.h"
#include "sspm_mbox.h"
#include "sspm_helper.h"
struct sspm_mbox {
int id;
void __iomem *in_out;
void __iomem *base;
unsigned int size;
unsigned int enable;
sspm_ipi_isr isr;
int irq_num;
};
struct sspm_mbox sspmmbox[SSPM_MBOX_MAX];
static unsigned int sspm_mbox_cnt;
static spinlock_t lock_mbox[SSPM_MBOX_MAX];
unsigned int sspm_mbox_size(int mbox)
{
if (mbox >= sspm_mbox_cnt)
return 0;
return sspmmbox[mbox].size / SSPM_MBOX_SLOT_SIZE;
}
uint32_t *sspm_mbox_addr(unsigned int mbox, unsigned int slot)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
return (uint32_t *)(desc->base + (SSPM_MBOX_SLOT_SIZE * slot));
}
int sspm_mbox_read(unsigned int mbox, unsigned int slot, void *data,
unsigned int len)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
if (data)
memcpy_from_sspm(data, desc->base + (SSPM_MBOX_SLOT_SIZE * slot)
, SSPM_MBOX_SLOT_SIZE*len);
return 0;
}
int sspm_mbox_write(unsigned int mbox, unsigned int slot, void *data,
unsigned int len)
{
struct sspm_mbox *desc = &sspmmbox[mbox];
if (data)
memcpy_to_sspm(desc->base + (SSPM_MBOX_SLOT_SIZE * slot), data,
len * SSPM_MBOX_SLOT_SIZE);
return 0;
}
int sspm_mbox_polling(unsigned int mbox, unsigned int irq, unsigned int slot,
unsigned int *retdata, unsigned int retlen, unsigned int retries)
{
struct sspm_mbox *desc;
void __iomem *out_irq;
unsigned int irqs = 0;
unsigned long flags = 0;
desc = &sspmmbox[mbox];
irq = 0x1 << irq;
out_irq = desc->in_out + SSPM_MBOX_OUT_IRQ_OFS;
spin_lock_irqsave(&lock_mbox[mbox], flags);
#if 0
while (retries-- > 0) {
irqs = readl(out_irq);
if (irqs & irq)
break;
udelay(1);
}
#else
irqs = readl(out_irq);
#endif
if (irqs & irq) {
writel(irq, out_irq);
spin_unlock_irqrestore(&lock_mbox[mbox], flags);
if (retdata)
memcpy_from_sspm(retdata, desc->base +
(SSPM_MBOX_SLOT_SIZE * slot),
SSPM_MBOX_SLOT_SIZE*retlen);
return 0;
}
spin_unlock_irqrestore(&lock_mbox[mbox], flags);
return -1;
}
int sspm_mbox_send(unsigned int mbox, unsigned int slot, unsigned int irq,
void *data, unsigned int len)
{
struct sspm_mbox *desc;
unsigned int size;
void __iomem *in_irq, *out_irq;
unsigned long flags = 0;
if (mbox >= sspm_mbox_cnt)
return -1;
size = sspm_mbox_size(mbox);
if (slot > size || (slot + len) > size)
return -1;
desc = &sspmmbox[mbox];
in_irq = desc->in_out + SSPM_MBOX_IN_IRQ_OFS;
out_irq = desc->in_out + SSPM_MBOX_OUT_IRQ_OFS;
spin_lock_irqsave(&lock_mbox[mbox], flags);
if (readl(out_irq) & (0x1 << irq)) {
pr_err("%s: MBOX%d[%d] out_irq is not clear!\n", __func__,
mbox, irq);
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
return -1;
}
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
if (!desc->enable)
return -1;
/* we only copy data to portion of mbox here .... */
/* len:0, mean send ack (OUT_IRQ) only no data transfer */
if (len > 0)
memcpy_to_sspm(desc->base + (SSPM_MBOX_SLOT_SIZE * slot), data,
len * SSPM_MBOX_SLOT_SIZE);
spin_lock_irqsave(&lock_mbox[mbox], flags);
writel(0x1 << irq, in_irq);
spin_unlock_irqrestore(&lock_mbox[desc->id], flags);
return 0;
}
/*
* dispatch sspm mbox irq and then reset mbox out irq
* @param irq: irq id
* @param dev_id: pointer point to sspmmbox
};
*/
static irqreturn_t sspm_mbox_irq_handler(int irq, void *dev_id)
{
struct sspm_mbox *desc = (struct sspm_mbox *) dev_id;
unsigned int irqs;
void __iomem *out_irq;
out_irq = desc->in_out + SSPM_MBOX_OUT_IRQ_OFS;
spin_lock(&lock_mbox[desc->id]);
irqs = readl(out_irq);
writel(irqs, out_irq);
spin_unlock(&lock_mbox[desc->id]);
if (desc->isr)
desc->isr(desc->id, desc->base, irqs);
return IRQ_HANDLED;
}
static int sspm_mbox_group_activate(int mbox, unsigned int is64d,
sspm_ipi_isr isr)
{
struct sspm_mbox *desc;
char name[32];
int ret;
struct device *dev = &sspm_pdev->dev;
struct resource *res;
desc = &sspmmbox[mbox];
desc->size = (is64d) ? SSPM_MBOX_8BYTE : SSPM_MBOX_4BYTE;
desc->isr = isr;
if (sspm_pdev) {
snprintf(name, sizeof(name), "mbox%d_base", mbox);
res = platform_get_resource_byname(sspm_pdev,
IORESOURCE_MEM, name);
desc->base = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) desc->base)) {
pr_err("[SSPM] MBOX %d can't remap BASE\n", mbox);
goto fail;
}
snprintf(name, sizeof(name), "mbox%d_ctrl", mbox);
res = platform_get_resource_byname(sspm_pdev, IORESOURCE_MEM,
name);
desc->in_out = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) desc->in_out)) {
pr_err("[SSPM] MBOX %d can't find IN_OUT_IRQ\n", mbox);
goto fail;
}
snprintf(name, sizeof(name), "mbox%d", mbox);
desc->irq_num = platform_get_irq_byname(sspm_pdev, name);
if (desc->irq_num < 0) {
pr_err("[SSPM] MBOX %d can't find IRQ\n", mbox);
goto fail;
}
ret = request_irq(desc->irq_num, sspm_mbox_irq_handler,
IRQF_TRIGGER_NONE, "SSPM_MBOX", (void *) desc);
if (ret) {
pr_err("[SSPM] MBOX %d request irq Failed\n", mbox);
goto fail;
}
desc->enable = 1;
desc->id = mbox;
}
return 0;
fail:
return -1;
}
/*
* parse device tree and mapping iomem
* @return: 0 if success
*/
unsigned int sspm_mbox_init(unsigned int mode, unsigned int count,
sspm_ipi_isr isr)
{
int mbox;
if (count > SSPM_MBOX_MAX) {
pr_debug("[SSPM] %s(): count (%u) too large, set to %u\n",
__func__, count, SSPM_MBOX_MAX);
count = SSPM_MBOX_MAX;
}
for (mbox = 0; mbox < count; mbox++) {
spin_lock_init(&lock_mbox[mbox]);
if (sspm_mbox_group_activate(mbox, mode & 0x1, isr))
goto fail;
mode >>= 1;
}
sspm_mbox_cnt = mbox;
pr_debug("[SSPM] Find %d MBOX\n", sspm_mbox_cnt);
return 0;
fail:
while (mbox >= 0) {
if (sspmmbox[mbox].irq_num > 0) {
free_irq(sspmmbox[mbox].irq_num, &sspmmbox[mbox]);
sspmmbox[mbox].irq_num = 0;
}
mbox--;
}
return -1;
}
+35
View File
@@ -0,0 +1,35 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_MBOX_H__
#define __SSPM_MBOX_H__
#include <linux/platform_device.h>
enum SSPM_MBOX_SIZE {
SSPM_MBOX_4BYTE = 0x80,
SSPM_MBOX_8BYTE = 0x100,
};
extern struct platform_device *sspm_pdev;
typedef unsigned int (*sspm_ipi_isr)(unsigned int mbox, void __iomem *base,
unsigned int irq);
unsigned int sspm_mbox_size(int mbox);
extern int sspm_mbox_send(unsigned int mbox, unsigned int slot,
unsigned int irq, void *data, unsigned int len);
extern uint32_t *sspm_mbox_addr(unsigned int mbox, unsigned int slot);
extern int sspm_mbox_read(unsigned int mbox, unsigned int slot, void *data,
unsigned int len);
extern int sspm_mbox_write(unsigned int mbox, unsigned int slot, void *data,
unsigned int len);
extern unsigned int sspm_mbox_init(unsigned int mode, unsigned int count,
sspm_ipi_isr ipi_isr_cb);
extern int sspm_mbox_polling(unsigned int mbox, unsigned int irq,
unsigned int slot, unsigned int *retdata, unsigned int retlen,
unsigned int retries);
#endif
+250
View File
@@ -0,0 +1,250 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/types.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_ipi.h"
#include "sspm_excep.h"
#include "sspm_reservedmem.h"
#include "sspm_reservedmem_define.h"
#if SSPM_LOGGER_SUPPORT
#include "sspm_logger.h"
#endif
#if SSPM_TIMESYNC_SUPPORT
#include "sspm_timesync.h"
#endif
#include "sspm_sysfs.h"
#if SSPM_PLT_SERV_SUPPORT
struct plt_ctrl_s {
unsigned int magic;
unsigned int size;
unsigned int mem_sz;
#if SSPM_LOGGER_SUPPORT
unsigned int logger_ofs;
#endif
#if SSPM_COREDUMP_SUPPORT
unsigned int coredump_ofs;
#endif
#if SSPM_TIMESYNC_SUPPORT
unsigned int ts_ofs;
#endif
};
#if (SSPM_COREDUMP_SUPPORT || SSPM_LASTK_SUPPORT)
/* dont send any IPI from this thread, use workqueue instead */
static int sspm_recv_thread(void *userdata)
{
struct plt_ipi_data_s data;
struct ipi_action dev;
unsigned int rdata, ret;
dev.data = &data;
ret = sspm_ipi_recv_registration(IPI_ID_PLATFORM, &dev);
do {
rdata = 0;
sspm_ipi_recv_wait(IPI_ID_PLATFORM);
switch (data.cmd) {
#if SSPM_LASTK_SUPPORT
case PLT_LASTK_READY:
sspm_log_lastk_recv(data.u.logger.enable);
break;
#endif
#if SSPM_COREDUMP_SUPPORT
case PLT_COREDUMP_READY:
sspm_log_coredump_recv(data.u.coredump.exists);
break;
#endif
}
sspm_ipi_send_ack(IPI_ID_PLATFORM, &rdata);
} while (!kthread_should_stop());
return 0;
}
#endif
static ssize_t sspm_alive_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
struct plt_ipi_data_s ipi_data;
int ackdata = 0;
ipi_data.cmd = 0xDEAD;
sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_WAIT,
&ipi_data, sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE, &ackdata, 1);
return snprintf(buf, PAGE_SIZE, "%s\n", ackdata ? "Alive" : "Dead");
}
DEVICE_ATTR(sspm_alive, 0444, sspm_alive_show, NULL);
int __init sspm_plt_init(void)
{
phys_addr_t phys_addr, virt_addr, mem_sz;
struct plt_ipi_data_s ipi_data;
struct plt_ctrl_s *plt_ctl;
#if (SSPM_COREDUMP_SUPPORT || SSPM_LASTK_SUPPORT)
struct task_struct *sspm_task;
#endif
int ret, ackdata;
unsigned int last_ofs;
#if (SSPM_COREDUMP_SUPPORT || SSPM_LOGGER_SUPPORT || SSPM_TIMESYNC_SUPPORT)
unsigned int last_sz;
#endif
unsigned int *mark;
unsigned char *b;
ret = sspm_sysfs_create_file(&dev_attr_sspm_alive);
if (unlikely(ret != 0))
goto error;
phys_addr = sspm_reserve_mem_get_phys(SSPM_MEM_ID);
if (phys_addr == 0) {
pr_err("SSPM: Can't get logger phys mem\n");
goto error;
}
virt_addr = sspm_reserve_mem_get_virt(SSPM_MEM_ID);
if (virt_addr == 0) {
pr_err("SSPM: Can't get logger virt mem\n");
goto error;
}
mem_sz = sspm_reserve_mem_get_size(SSPM_MEM_ID);
if (mem_sz == 0) {
pr_err("SSPM: Can't get logger mem size\n");
goto error;
}
#if (SSPM_COREDUMP_SUPPORT || SSPM_LASTK_SUPPORT)
sspm_task = kthread_run(sspm_recv_thread, NULL, "sspm_recv");
#endif
b = (unsigned char *) (uintptr_t)virt_addr;
for (last_ofs = 0; last_ofs < sizeof(*plt_ctl); last_ofs++)
b[last_ofs] = 0x0;
mark = (unsigned int *) (uintptr_t)virt_addr;
*mark = PLT_INIT;
mark = (unsigned int *) ((unsigned char *) (uintptr_t)
virt_addr + mem_sz - 4);
*mark = PLT_INIT;
plt_ctl = (struct plt_ctrl_s *) (uintptr_t)virt_addr;
plt_ctl->magic = PLT_INIT;
plt_ctl->size = sizeof(*plt_ctl);
plt_ctl->mem_sz = mem_sz;
last_ofs = plt_ctl->size;
pr_debug("SSPM: %s(): after plt, ofs=%u\n", __func__, last_ofs);
#if SSPM_LOGGER_SUPPORT
plt_ctl->logger_ofs = last_ofs;
last_sz = sspm_logger_init(virt_addr + last_ofs, mem_sz - last_ofs);
if (last_sz == 0) {
pr_err("SSPM: sspm_logger_init return fail\n");
goto error;
}
last_ofs += last_sz;
pr_debug("SSPM: %s(): after logger, ofs=%u\n", __func__, last_ofs);
#endif
#if SSPM_COREDUMP_SUPPORT
plt_ctl->coredump_ofs = last_ofs;
last_sz = sspm_coredump_init(virt_addr + last_ofs, mem_sz - last_ofs);
if (last_sz == 0) {
pr_err("SSPM: sspm_coredump_init return fail\n");
goto error;
}
last_ofs += last_sz;
pr_debug("SSPM: %s(): after coredump, ofs=%u\n", __func__, last_ofs);
#endif
#if SSPM_TIMESYNC_SUPPORT
plt_ctl->ts_ofs = last_ofs;
last_sz = sspm_timesync_init(virt_addr + last_ofs, mem_sz - last_ofs);
if (last_sz == 0) {
pr_err("SSPM: sspm_timesync_init return fail\n");
goto error;
}
last_ofs += last_sz;
pr_debug("SSPM: %s(): after timesync, ofs=%u\n", __func__, last_ofs);
#endif
ipi_data.cmd = PLT_INIT;
ipi_data.u.ctrl.phys = phys_addr;
ipi_data.u.ctrl.size = mem_sz;
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_POLLING, &ipi_data,
sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE, &ackdata, 1);
if (ret != 0) {
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
goto error;
}
if (!ackdata) {
pr_err("SSPM: logger IPI init fail, ret=%d\n", ackdata);
goto error;
}
#if SSPM_TIMESYNC_SUPPORT
sspm_timesync_init_done();
#endif
#if SSPM_COREDUMP_SUPPORT
sspm_coredump_init_done();
#endif
#if SSPM_LOGGER_SUPPORT
sspm_logger_init_done();
#endif
return 0;
error:
return -1;
}
#endif
@@ -0,0 +1,239 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_excep.h"
#include "sspm_reservedmem.h"
#define _SSPM_INTERNAL_
#include "sspm_reservedmem_define.h"
#define MEMORY_TBL_ELEM_NUM (2)
#ifdef CONFIG_OF_RESERVED_MEM
#include <linux/of_reserved_mem.h>
#define SSPM_MEM_RESERVED_KEY "mediatek,reserve-memory-sspm_share"
#endif
static phys_addr_t sspm_mem_base_phys;
static phys_addr_t sspm_mem_base_virt;
static phys_addr_t sspm_mem_size;
#ifdef CONFIG_OF_RESERVED_MEM
static int __init sspm_reserve_mem_of_init(struct reserved_mem *rmem)
{
unsigned int id;
phys_addr_t accumlate_memory_size = 0;
sspm_mem_base_phys = (phys_addr_t) rmem->base;
sspm_mem_size = (phys_addr_t) rmem->size;
pr_debug("[SSPM] phys:0x%llx - 0x%llx (0x%llx)\n",
(unsigned long long)rmem->base,
(unsigned long long)rmem->base + (unsigned long long)rmem->size,
(unsigned long long)rmem->size);
accumlate_memory_size = 0;
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_phys = sspm_mem_base_phys +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
pr_debug("[SSPM][reserve_mem:%d]: ", id);
pr_debug("phys:0x%llx - 0x%llx (0x%llx)\n",
sspm_reserve_mblock[id].start_phys,
sspm_reserve_mblock[id].start_phys +
sspm_reserve_mblock[id].size,
sspm_reserve_mblock[id].size);
}
return 0;
}
RESERVEDMEM_OF_DECLARE(sspm_reservedmem, SSPM_MEM_RESERVED_KEY,
sspm_reserve_mem_of_init);
#endif
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_phys;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_phys);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_virt;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_virt);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].size;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_size);
void __iomem *sspm_base;
phys_addr_t sspm_sbuf_get(unsigned int offset)
{
if (!is_sspm_ready()) {
pr_notice("[SSPM] device resource is not ready\n");
return 0;
}
if (offset < SSPM_SHARE_REGION_BASE ||
offset > SSPM_SHARE_REGION_BASE + SSPM_SHARE_REGION_SIZE) {
pr_notice("[SSPM] illegal sbuf request: 0x%x\n", offset);
return 0;
} else {
return (phys_addr_t)(sspm_base + offset);
}
}
EXPORT_SYMBOL_GPL(sspm_sbuf_get);
int sspm_reserve_memory_init(struct platform_device *pdev)
{
unsigned int id;
unsigned int sspm_mem_num = 0;
unsigned int i, m_idx, m_size;
int ret;
const char *mem_key;
phys_addr_t accumlate_memory_size;
if (NUMS_MEM_ID == 0)
return 0;
if (sspm_mem_base_phys == 0)
return -1;
/* Get reserved memory */
ret = of_property_read_string(pdev->dev.of_node, "sspm_mem_key",
&mem_key);
if (ret) {
pr_info("[SSPM] cannot find property\n");
return -EINVAL;
}
/* Set reserved memory table */
sspm_mem_num = of_property_count_u32_elems(
pdev->dev.of_node,
"sspm_mem_tbl")
/ MEMORY_TBL_ELEM_NUM;
if (sspm_mem_num <= 0) {
pr_info("[SSPM] SSPM_mem_tbl not found\n");
sspm_mem_num = 0;
}
for (i = 0; i < sspm_mem_num; i++) {
ret = of_property_read_u32_index(pdev->dev.of_node,
"sspm_mem_tbl",
i * MEMORY_TBL_ELEM_NUM,
&m_idx);
if (ret) {
pr_info("Cannot get memory index(%d)\n", i);
return -1;
}
ret = of_property_read_u32_index(pdev->dev.of_node,
"sspm_mem_tbl",
(i * MEMORY_TBL_ELEM_NUM) + 1,
&m_size);
if (ret) {
pr_info("Cannot get memory size(%d)\n", i);
return -1;
}
if (m_idx >= NUMS_MEM_ID) {
pr_notice("[SSPM] skip unexpected index, %d\n", m_idx);
continue;
}
}
accumlate_memory_size = 0;
sspm_mem_base_virt = (phys_addr_t)(uintptr_t)
ioremap_wc(sspm_mem_base_phys, sspm_mem_size);
pr_debug("[SSPM]reserve mem: virt:0x%llx - 0x%llx (0x%llx)\n",
(unsigned long long)sspm_mem_base_virt,
(unsigned long long)sspm_mem_base_virt +
(unsigned long long)sspm_mem_size,
(unsigned long long)sspm_mem_size);
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_virt = sspm_mem_base_virt +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
}
/* the reserved memory should be larger then expected memory
* or sspm_reserve_mblock does not match dts
*/
BUG_ON(accumlate_memory_size > sspm_mem_size);
#ifdef DEBUG
for (id = 0; id < NUMS_MEM_ID; id++) {
pr_debug("[SSPM][mem_reserve-%d] ", id);
pr_debug("phys:0x%llx,virt:0x%llx,size:0x%llx\n",
(unsigned long long)sspm_reserve_mem_get_phys(id),
(unsigned long long)sspm_reserve_mem_get_virt(id),
(unsigned long long)sspm_reserve_mem_get_size(id));
}
#endif
return 0;
}
void sspm_lock_emi_mpu(void)
{
#if SSPM_EMI_PROTECTION_SUPPORT
if (sspm_mem_size > 0)
sspm_set_emi_mpu(sspm_mem_base_phys, sspm_mem_size);
#endif
}
int sspm_sbuf_init(void)
{
struct device *dev = &sspm_pdev->dev;
struct resource *res;
if (sspm_pdev) {
res = platform_get_resource_byname(sspm_pdev,
IORESOURCE_MEM, "sspm_base");
sspm_base = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspm_base))
return -1;
}
return 0;
}
@@ -0,0 +1,32 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_RESERVED_H__
#define __SSPM_RESERVED_H__
#include <linux/types.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include "sspm_define.h"
struct sspm_reserve_mblock {
u32 num;
u64 start_phys;
u64 start_virt;
u64 size;
};
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id);
int sspm_reserve_memory_init(struct platform_device *pdev);
void sspm_set_emi_mpu(phys_addr_t base, phys_addr_t size);
void sspm_lock_emi_mpu(void);
extern struct platform_device *sspm_pdev;
phys_addr_t sspm_sbuf_get(unsigned int offset);
int sspm_sbuf_init(void);
#endif
@@ -0,0 +1,78 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef _SSPM_RESERVEDMEM_DEFINE_H_
#define _SSPM_RESERVEDMEM_DEFINE_H_
#include <sspm_reservedmem.h>
enum {
SSPM_MEM_ID = 0,
PWRAP_MEM_ID,
PMIC_MEM_ID,
UPD_MEM_ID,
QOS_MEM_ID,
SWPM_MEM_ID,
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
MET_MEM_ID,
#endif
SMI_MEM_ID,
GPU_MEM_ID,
NUMS_MEM_ID,
};
#define SSPM_PLT_LOGGER_BUF_LEN 0x100000
#ifdef _SSPM_INTERNAL_
/* The total size of sspm_reserve_mblock should less equal than
* reserve-memory-sspm_share of device tree
*/
static struct sspm_reserve_mblock sspm_reserve_mblock[NUMS_MEM_ID] = {
{
.num = SSPM_MEM_ID,
.size = 0x400 + SSPM_PLT_LOGGER_BUF_LEN,
/* logger header + timesync header + 1M log buffer */
},
{
.num = PWRAP_MEM_ID,
.size = 0x300, /* 768 bytes */
},
{
.num = PMIC_MEM_ID,
.size = 0xC00, /* 3K */
},
{
.num = UPD_MEM_ID,
.size = 0x1800, /* 6K */
},
{
.num = QOS_MEM_ID,
.size = 0x1000, /* 4K */
},
{
.num = SWPM_MEM_ID,
.size = 0xC00, /* 3K */
},
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
{
.num = MET_MEM_ID,
.size = 0x400000, /* 4M */
},
#endif
{
.num = SMI_MEM_ID,
.size = 0x9000, /* 36K */
},
{
.num = GPU_MEM_ID,
.size = 0x1000, /* 4K */
},
/* TO align 64K, total is 1M+64K. The remaining size = 0x2800 */
};
#endif
#endif
#define SSPM_SHARE_REGION_BASE 0x20000
#define SSPM_SHARE_REGION_SIZE 0x8000
+110
View File
@@ -0,0 +1,110 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
static wait_queue_head_t logwait;
ssize_t __weak sspm_log_read(char __user *data, size_t len)
{
return 0;
}
unsigned int __weak sspm_log_poll(void)
{
return 0;
}
static ssize_t sspm_log_if_read(struct file *file, char __user *data,
size_t len, loff_t *ppos)
{
ssize_t ret;
/* pr_debug("[SSPM] sspm_log_if_read\n"); */
ret = 0;
if (access_ok(VERIFY_WRITE, data, len))
ret = sspm_log_read(data, len);
return ret;
}
static int sspm_log_if_open(struct inode *inode, struct file *file)
{
/* pr_debug("[SSPM] sspm_log_if_open\n"); */
return nonseekable_open(inode, file);
}
static unsigned int sspm_log_if_poll(struct file *file, poll_table *wait)
{
unsigned int ret = 0;
/* pr_debug("[SSPM] sspm_log_if_poll\n"); */
if (!(file->f_mode & FMODE_READ))
return ret;
poll_wait(file, &logwait, wait);
ret = sspm_log_poll();
return ret;
}
void sspm_log_if_wake(void)
{
wake_up(&logwait);
}
static const struct file_operations sspm_log_file_ops = {
.owner = THIS_MODULE,
.read = sspm_log_if_read,
.open = sspm_log_if_open,
.poll = sspm_log_if_poll,
};
static struct miscdevice sspm_log_device = {
.minor = MISC_DYNAMIC_MINOR,
.name = "sspm",
.fops = &sspm_log_file_ops
};
int __init sspm_sysfs_init(void)
{
int ret;
init_waitqueue_head(&logwait);
ret = misc_register(&sspm_log_device);
if (unlikely(ret != 0))
return ret;
return 0;
}
int sspm_sysfs_create_file(const struct device_attribute *attr)
{
return device_create_file(sspm_log_device.this_device, attr);
}
int sspm_sysfs_create_bin_file(const struct bin_attribute *attr)
{
return device_create_bin_file(sspm_log_device.this_device, attr);
}
@@ -0,0 +1,16 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_SYSFS_H__
#define __SSPM_SYSFS_H__
#include <linux/sysfs.h>
#include <linux/device.h>
extern void sspm_log_if_wake(void);
extern int __init sspm_sysfs_init(void);
extern int sspm_sysfs_create_file(const struct device_attribute *attr);
extern int sspm_sysfs_create_bin_file(const struct bin_attribute *attr);
#endif
@@ -0,0 +1,212 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/sched/clock.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/types.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_ipi.h"
#include "sspm_reservedmem.h"
#include "sspm_reservedmem_define.h"
#include "sspm_sysfs.h"
#include "sspm_timesync.h"
/* #define TINYSYS_TIME_TESTING */
struct timesync_ctrl_s {
unsigned int base;
unsigned int size;
unsigned int ts_h;
unsigned int ts_l;
unsigned int clk_h;
unsigned int clk_l;
};
static struct timesync_ctrl_s *ts_ctl;
static unsigned int sspm_ts_inited;
static struct sspm_work_struct sspm_timesync_work;
static struct timer_list sspm_timesync_timer;
static DEFINE_MUTEX(sspm_timesync_mutex);
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
static unsigned int sspm_sync_cnt;
#endif
static void sspm_timesync_timestamp(unsigned long long src, unsigned int *ts_h,
unsigned int *ts_l)
{
*ts_l = (unsigned int)(src & 0x00000000FFFFFFFF);
*ts_h = (unsigned int)((src & 0xFFFFFFFF00000000) >> 32);
}
void sspm_timesync_ts_get(unsigned int *ts_h, unsigned int *ts_l)
{
unsigned long long ap_ts;
ap_ts = sched_clock();
sspm_timesync_timestamp(ap_ts, ts_h, ts_l);
}
void sspm_timesync_clk_get(unsigned int *clk_h, unsigned int *clk_l)
{
unsigned long long ap_clk;
ap_clk = mtk_timer_src_count();
sspm_timesync_timestamp(ap_clk, clk_h, clk_l);
}
static void __tinysys_time_sync(int mode)
{
struct plt_ipi_data_s ipi_data;
int ret, ackdata;
if (sspm_ts_inited) {
memset((void *)&ipi_data, 0, sizeof(ipi_data));
mutex_lock(&sspm_timesync_mutex);
ipi_data.cmd = PLT_TIMESYNC_SYNC;
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
if (mode == 1)
ipi_data.u.ts.mode = mode;
#endif
/* inject timestamp and clk */
sspm_timesync_ts_get(&ts_ctl->ts_h, &ts_ctl->ts_l);
sspm_timesync_clk_get(&ts_ctl->clk_h, &ts_ctl->clk_l);
ret = sspm_ipi_send_sync(IPI_ID_PLATFORM, IPI_OPT_POLLING,
&ipi_data, sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE,
&ackdata, 1);
if (ret != 0)
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
mutex_unlock(&sspm_timesync_mutex);
}
}
static void tinysys_time_sync(void)
{
__tinysys_time_sync(0);
}
static void timesync_ws(struct work_struct *ws)
{
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
pr_debug("resync time about %d sec (%d)\n", TIMESYNC_TIMEOUT,
sspm_sync_cnt++);
#endif
tinysys_time_sync();
}
static void sspm_ts_timeout(struct timer_list *unused)
{
sspm_schedule_work(&sspm_timesync_work);
sspm_timesync_timer.expires = jiffies + TIMESYNC_TIMEOUT;
add_timer(&sspm_timesync_timer);
}
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
static void tinysys_time_verify(void)
{
__tinysys_time_sync(1);
}
static ssize_t sspm_time_sync_store(struct device *kobj,
struct device_attribute *attr, const char *buf, size_t n)
{
unsigned int sync;
if (n) {
if (kstrtouint(buf, 0, &sync) != 0)
return -EINVAL;
if (sync) {
/* tiny-system time sync verify*/
tinysys_time_verify();
pr_debug("%s Time-sync verify!!\n", __func__);
} else {
/* tiny-system time sync operation*/
tinysys_time_sync();
pr_debug("%s Time-sync operation!!\n", __func__);
}
}
return n;
}
DEVICE_ATTR(sspm_time_sync, 0220, NULL, sspm_time_sync_store);
#endif
unsigned int __init sspm_timesync_init(phys_addr_t start, phys_addr_t limit)
{
unsigned int last_ofs;
last_ofs = 0;
ts_ctl = (struct timesync_ctrl_s *) (uintptr_t)start;
ts_ctl->base = PLT_TIMESYNC_SYNC; /* magic */
ts_ctl->size = sizeof(*ts_ctl);
sspm_timesync_ts_get(&ts_ctl->ts_h, &ts_ctl->ts_l);
sspm_timesync_clk_get(&ts_ctl->clk_h, &ts_ctl->clk_l);
last_ofs += ts_ctl->size;
if (last_ofs >= limit) {
pr_err("SSPM:%s() initial fail, last_ofs=%u, limit=%u\n",
__func__, last_ofs, (unsigned int) limit);
goto error;
}
sspm_ts_inited = 1;
return last_ofs;
error:
sspm_ts_inited = 0;
ts_ctl = NULL;
return 0;
}
int __init sspm_timesync_init_done(void)
{
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
int ret;
#endif
tinysys_time_sync();
INIT_WORK(&sspm_timesync_work.work, timesync_ws);
timer_setup(&sspm_timesync_timer, &sspm_ts_timeout, 0);
sspm_timesync_timer.expires = jiffies + TIMESYNC_TIMEOUT;
add_timer(&sspm_timesync_timer);
#if defined(TINYSYS_TIME_TESTING) && defined(DEBUG)
ret = sspm_sysfs_create_file(&dev_attr_sspm_time_sync);
if (unlikely(ret != 0))
pr_err("[SSPM]: %s create file fail\n", __func__);
#endif
return 0;
}
@@ -0,0 +1,14 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef _SSPM_TIMESYNC_H_
#define _SSPM_TIMESYNC_H_
extern unsigned int sspm_timesync_init(phys_addr_t start, phys_addr_t limit);
extern int sspm_timesync_init_done(void);
extern void sspm_timesync_ts_get(unsigned int *ts_h, unsigned int *ts_l);
extern void sspm_timesync_clk_get(unsigned int *clk_h, unsigned int *clk_l);
extern u64 mtk_timer_get_cnt(u8 timer);
#endif
+21
View File
@@ -0,0 +1,21 @@
obj-$(CONFIG_MTK_TINYSYS_SSPM_SUPPORT) += sspm.o
sspm-objs += sspm_emi_mpu.o
sspm-objs += sspm_helper.o
sspm-objs += sspm_ipi_table.o
sspm-objs += sspm_ipi_timeout_cb.o
sspm-objs += sspm_logger_impl.o
sspm-objs += sspm_plt.o
sspm-objs += sspm_reservedmem.o
sspm-objs += sspm_sysfs.o
sspm-objs += sspm_timesync.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/$(CONFIG_MTK_PLATFORM)
ccflags-$(CONFIG_MTK_ENG_BUILD) += -DDEBUG
#ccflags-y += -DDEBUG
#SSPM_IPI_TEST=y
# obj-$(SSPM_IPI_TEST) += sspm_ipi_test.o
@@ -0,0 +1,58 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_DEFINE_H__
#define __SSPM_DEFINE_H__
#include <linux/param.h> /* for HZ */
#include <asm/arch_timer.h>
#define SSPM_MBOX_MAX 5
#define SSPM_MBOX_IN_IRQ_OFS 0x0
#define SSPM_MBOX_OUT_IRQ_OFS 0x4
#define SSPM_MBOX_SLOT_SIZE 0x4
#define SSPM_CFG_OFS_SEMA 0x048
#define SSPM_MPU_REGION_ID 5
#define SSPM_SHARE_BUFFER_SUPPORT
#define SSPM_PLT_SERV_SUPPORT (1)
#define SSPM_LOGGER_SUPPORT (1)
#define SSPM_TIMESYNC_SUPPORT (1)
#if defined(CONFIG_MEDIATEK_EMI) || defined(CONFIG_MTK_EMI)
#define SSPM_EMI_PROTECTION_SUPPORT (1)
#else
#define SSPM_EMI_PROTECTION_SUPPORT (0)
#endif
#define PLT_INIT 0x504C5401
#define PLT_LOG_ENABLE 0x504C5402
/* Legacy magic code define
* Should avoid to use duplicate definitions
#define PLT_LASTK_READY 0x504C5403
#define PLT_COREDUMP_READY 0x504C5404
#define PLT_TIMESYNC_SYNC 0x504C5405
*/
#define PLT_TIMESYNC_SRAM_TEST 0x504C5406
struct plt_ipi_data_s {
unsigned int cmd;
union {
struct {
unsigned int phys;
unsigned int size;
} ctrl;
struct {
unsigned int enable;
} logger;
struct {
unsigned int mode;
} ts;
} u;
};
#endif
@@ -0,0 +1,42 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include "sspm_define.h"
#if SSPM_EMI_PROTECTION_SUPPORT
#include <memory/mediatek/emi.h>
static unsigned long long sspm_start;
static unsigned long long sspm_end;
void __init sspm_set_emi_mpu(phys_addr_t base, phys_addr_t size)
{
sspm_start = base;
sspm_end = base + size - 1;
}
static int __init post_sspm_set_emi_mpu(void)
{
struct emimpu_region_t rg_info;
mtk_emimpu_init_region(&rg_info, SSPM_MPU_REGION_ID);
mtk_emimpu_set_addr(&rg_info, sspm_start, sspm_end);
mtk_emimpu_set_apc(&rg_info, 0, MTK_EMIMPU_NO_PROTECTION);
mtk_emimpu_set_apc(&rg_info, 8, MTK_EMIMPU_NO_PROTECTION);
mtk_emimpu_set_protection(&rg_info);
mtk_emimpu_free_region(&rg_info);
return 0;
}
late_initcall(post_sspm_set_emi_mpu);
#endif
+332
View File
@@ -0,0 +1,332 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/platform_device.h>
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_ipi_table.h"
#include "sspm_sysfs.h"
#include "sspm_reservedmem.h"
#include "sspm_timesync.h"
#define SEM_TIMEOUT 5000
#define SSPM_INIT_FLAG 0x1
static int __init sspm_init(void);
struct sspm_regs sspmreg;
struct platform_device *sspm_pdev;
#if SSPM_PLT_SERV_SUPPORT
int sspm_plt_ackdata;
#endif
static struct workqueue_struct *sspm_workqueue;
static atomic_t sspm_inited = ATOMIC_INIT(0);
static atomic_t sspm_dev_inited = ATOMIC_INIT(0);
static unsigned int sspm_ready;
/*
* acquire a hardware semaphore
* @param flag: semaphore id
*/
int get_sspm_semaphore(int flag)
{
void __iomem *sema = sspmreg.cfg + SSPM_CFG_OFS_SEMA;
int read_back;
int count = 0;
int ret = -1;
flag = (flag * 2) + 1;
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 0) {
writel((1 << flag), sema);
while (count != SEM_TIMEOUT) {
/* repeat test if we get semaphore */
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 1) {
ret = 1;
break;
}
writel((1 << flag), sema);
count++;
}
if (ret < 0)
pr_debug("[SSPM] get semaphore %d TIMEOUT...!\n", flag);
} else {
pr_debug("[SSPM] already hold semaphore %d\n", flag);
}
return ret;
}
EXPORT_SYMBOL_GPL(get_sspm_semaphore);
/*
* release a hardware semaphore
* @param flag: semaphore id
*/
int release_sspm_semaphore(int flag)
{
void __iomem *sema = sspmreg.cfg + SSPM_CFG_OFS_SEMA;
int read_back;
int ret = -1;
flag = (flag * 2) + 1;
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 1) {
/* Write 1 clear */
writel((1 << flag), sema);
read_back = (readl(sema) >> flag) & 0x1;
if (read_back == 0)
ret = 1;
else
pr_debug("[SSPM] release semaphore %d failed!\n", flag);
} else {
pr_debug("[SSPM] try to release semaphore %d not own by me\n",
flag);
}
return ret;
}
EXPORT_SYMBOL_GPL(release_sspm_semaphore);
/*
* schedule a work on sspm's work queue
* @param sspm_ws: work_struct to schedule
*/
void sspm_schedule_work(struct sspm_work_struct *sspm_ws)
{
queue_work(sspm_workqueue, &sspm_ws->work);
}
EXPORT_SYMBOL_GPL(sspm_schedule_work);
/*
* @return: 1 if sspm is ready for running tasks
*/
unsigned int is_sspm_ready(void)
{
if (sspm_ready)
return 1;
else
return 0;
}
EXPORT_SYMBOL_GPL(is_sspm_ready);
static int sspm_device_probe(struct platform_device *pdev)
{
struct resource *res;
struct device *dev = &pdev->dev;
int i, ret;
if (atomic_inc_return(&sspm_dev_inited) != 1)
return -1;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfgreg");
sspmreg.cfg = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspmreg.cfg)) {
pr_err("[SSPM] Unable to ioremap registers\n");
return -1;
}
sspmreg.cfgregsize = (unsigned int) resource_size(res);
sspmreg.irq = platform_get_irq_byname(pdev, "ipc");
if (sspmreg.irq < 0) {
pr_err("[SSPM] Unable to get IRQ\n");
return -1;
}
pr_debug("[SSPM] sspm irq=%d, cfgreg=0x%p\n", sspmreg.irq, sspmreg.cfg);
sspm_pdev = pdev;
pr_debug("[SSPM] mbox probe\n");
for (i = 0; i < SSPM_MBOX_TOTAL; i++) {
sspm_mbox_table[i].mbdev = &sspm_mboxdev;
ret = mtk_mbox_probe(pdev, sspm_mbox_table[i].mbdev, i);
if (ret) {
pr_err("[SSPM] mbox probe fail on mbox-%d, ret %d\n",
i, ret);
return -1;
}
}
pr_debug("[SSPM] ipi register\n");
ret = mtk_ipi_device_register(&sspm_ipidev, pdev, &sspm_mboxdev,
SSPM_IPI_COUNT);
if (ret) {
pr_err("[SSPM] ipi_dev_register fail, ret %d\n", ret);
return -1;
}
#if SSPM_PLT_SERV_SUPPORT
ret = mtk_ipi_register(&sspm_ipidev, IPIS_C_PLATFORM, NULL, NULL,
(void *) &sspm_plt_ackdata);
if (ret) {
pr_err("[SSPM] ipi_register fail, ret %d\n", ret);
return -1;
}
#endif
pr_info("SSPM is ready to service IPI\n");
#ifdef SSPM_SHARE_BUFFER_SUPPORT
if (sspm_sbuf_init()) {
pr_err("[SSPM] Shared Buffer Init Failed\n");
return -1;
}
#endif
return 0;
}
EXPORT_SYMBOL_GPL(sspm_ipidev);
#ifdef CONFIG_PM
static int sspm_suspend(struct device *dev)
{
sspm_timesync_suspend();
return 0;
}
static int sspm_resume(struct device *dev)
{
sspm_timesync_resume();
return 0;
}
static const struct dev_pm_ops sspm_dev_pm_ops = {
.suspend = sspm_suspend,
.resume = sspm_resume,
};
#endif
static const struct of_device_id sspm_of_match[] = {
{ .compatible = "mediatek,sspm", },
{},
};
static const struct platform_device_id sspm_id_table[] = {
{ "sspm", 0},
{ },
};
static struct platform_driver mtk_sspm_driver = {
.remove = NULL,
.shutdown = NULL,
.suspend = NULL,
.resume = NULL,
.probe = sspm_device_probe,
.driver = {
.name = "sspm",
.owner = THIS_MODULE,
.of_match_table = sspm_of_match,
#ifdef CONFIG_PM
.pm = &sspm_dev_pm_ops,
#endif
},
.id_table = sspm_id_table,
};
/*
* driver initialization entry point
*/
static int __init sspm_init(void)
{
if (atomic_inc_return(&sspm_inited) != 1)
return 0;
/* static initialise */
sspm_ready = 0;
sspm_workqueue = create_workqueue("SSPM_WQ");
if (!sspm_workqueue) {
pr_err("[SSPM] Workqueue Create Failed\n");
goto error;
}
if (platform_driver_register(&mtk_sspm_driver)) {
pr_err("[SSPM] Device Init Failed\n");
goto error;
}
#ifdef CONFIG_OF_RESERVED_MEM
if (sspm_reserve_memory_init()) {
pr_err("[SSPM] Reserved Memory Failed\n");
goto error;
}
#endif
pr_debug("[SSPM] Helper Init\n");
sspm_ready = 1;
atomic_set(&sspm_inited, 1);
return 0;
error:
atomic_set(&sspm_inited, 1);
return -1;
}
static int __init sspm_module_init(void)
{
if (sspm_sysfs_init()) {
pr_err("[SSPM] Sysfs Init Failed\n");
return -1;
}
#if SSPM_PLT_SERV_SUPPORT
if (sspm_plt_init()) {
pr_err("[SSPM] Platform Init Failed\n");
return -1;
}
pr_info("SSPM platform service is ready\n");
#endif
#if SSPM_TIMESYNC_SUPPORT
if (sspm_timesync_init()) {
pr_err("[SSPM] Timesync Init Failed\n");
return -1;
}
#endif
sspm_lock_emi_mpu();
return 0;
}
arch_initcall(sspm_init);
module_init(sspm_module_init);
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_HELPER_H__
#define __SSPM_HELPER_H__
#include <linux/types.h>
struct sspm_regs {
void __iomem *cfg;
unsigned int cfgregsize;
int irq;
};
struct sspm_work_struct {
struct work_struct work;
unsigned int flags;
};
enum SEMAPHORE_FLAG {
NR_FLAG = 0,
};
extern struct sspm_regs sspmreg;
extern int sspm_plt_ackdata;
extern int sspm_plt_init(void);
/* @group_id: the group want to swap in tcm and run. */
extern void memcpy_to_sspm(void __iomem *trg, const void *src, int size);
extern void memcpy_from_sspm(void *trg, const void __iomem *src, int size);
extern int get_sspm_semaphore(int flag);
extern int release_sspm_semaphore(int flag);
extern void sspm_schedule_work(struct sspm_work_struct *sspm_ws);
extern unsigned int is_sspm_ready(void);
#endif
@@ -0,0 +1,34 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_IPI_ID_H__
#define __SSPM_IPI_ID_H__
#include <linux/soc/mediatek/mtk_tinysys_ipi.h>
/* define module id here ... */
#define IPIS_C_PPM 0
#define IPIS_C_QOS 1
#define IPIS_C_PMIC 2
#define IPIS_C_MET 3
#define IPIS_C_THERMAL 4
#define IPIS_C_GPU_DVFS 5
#define IPIS_C_GPU_PM 6
#define IPIS_C_PLATFORM 7
#define IPIS_C_SMI 8
#define IPIS_C_CM 9
#define IPIS_C_SLBC 10
#define IPIS_C_SPM_SUSPEND 11
#define IPIR_I_QOS 12
#define IPIR_C_MET 13
#define IPIR_C_GPU_DVFS 14
#define IPIR_C_PLATFORM 15
#define IPIR_C_SLBC 16
#define IPIS_C_FHCTL 17
#define SSPM_IPI_COUNT 18
extern struct mtk_mbox_device sspm_mboxdev;
extern struct mtk_ipi_device sspm_ipidev;
#endif /* __SSPM_IPI_ID_H__ */
@@ -0,0 +1,220 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include "sspm_ipi_table.h"
/*
* mbox information
*
* mbdev :mbox device
* irq_num:identity of mbox irq
* id :mbox id
* slot :how many slots that mbox used, up to 1GB
* opt :option for mbox or share memory, 0:mbox, 1:share memory
* enable :mbox status, 0:disable, 1: enable
* is64d :mbox is64d status, 0:32d, 1: 64d
* base :mbox base address
* set_irq_reg : mbox set irq register
* clr_irq_reg : mbox clear irq register
* init_base_reg: mbox initialize register
* send_status_reg: mbox send status register
* recv_status_reg: mbox recv status register
* mbox lock : lock of mbox
*/
struct mtk_mbox_info sspm_mbox_table[SSPM_MBOX_TOTAL] = {
{0, 0, 0, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, { { { { 0 } } } } },
{0, 0, 1, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, { { { { 0 } } } } },
{0, 0, 2, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, { { { { 0 } } } } },
{0, 0, 3, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, { { { { 0 } } } } },
{0, 0, 4, 32, 0, 1, 0, 0, 0, 0, 0, 0, 0, { { { { 0 } } } } },
};
/*
* mbox pin structure, this is for send defination,
* ipi=endpoint=pin
* mbox : (mbox number)mbox number of the pin, up to 16(plt)
* offset : (slot)msg offset in share memory, up to 1024*4 KB(plt)
* send_opt : (opt)send opt, 0:send ,1: send for response(plt)
* lock : (lock)polling lock 0:unuse,1:used
* msg_size : (slot)message size in words, 4 bytes alignment(plt)
* pin_index : (bit offset)pin index in the mbox(plt)
* chan_id : (u32) ipc channel id(plt)
* mutex : (mutex)mutex for remote response
* completion : (completion)completion for remote response
* pin_lock : (spinlock_t)lock of the pin
*/
struct mtk_mbox_pin_send sspm_mbox_pin_send[] = {
/* the following will use mbox 0 */
{0, IPIS_C_PPM_OUT_OFFSET, 1, 0, IPIS_C_PPM_OUT_SIZE,
IPIS_C_PPM_OUT_OFFSET, IPIS_C_PPM,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_QOS_OUT_OFFSET, 1, 0, IPIS_C_QOS_OUT_SIZE,
IPIS_C_QOS_OUT_OFFSET, IPIS_C_QOS,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_PMIC_OUT_OFFSET, 1, 0, IPIS_C_PMIC_OUT_SIZE,
IPIS_C_PMIC_OUT_OFFSET, IPIS_C_PMIC,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_MET_OUT_OFFSET, 1, 0, IPIS_C_MET_OUT_SIZE,
IPIS_C_MET_OUT_OFFSET, IPIS_C_MET,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_THERMAL_OUT_OFFSET, 1, 0, IPIS_C_THERMAL_OUT_SIZE,
IPIS_C_THERMAL_OUT_OFFSET, IPIS_C_THERMAL,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_GPU_DVFS_OUT_OFFSET, 1, 0, IPIS_C_GPU_DVFS_OUT_SIZE,
IPIS_C_GPU_DVFS_OUT_OFFSET, IPIS_C_GPU_DVFS,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{0, IPIS_C_GPU_PM_OUT_OFFSET, 1, 0, IPIS_C_GPU_PM_OUT_SIZE,
IPIS_C_GPU_PM_OUT_OFFSET, IPIS_C_GPU_PM,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
/* the following will use mbox 1 */
{1, IPIS_C_PLATFORM_OUT_OFFSET, 1, 0, IPIS_C_PLATFORM_OUT_SIZE,
IPIS_C_PLATFORM_OUT_OFFSET, IPIS_C_PLATFORM,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIS_C_SMI_OUT_OFFSET, 1, 0, IPIS_C_SMI_OUT_SIZE,
IPIS_C_SMI_OUT_OFFSET, IPIS_C_SMI,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIS_C_CM_OUT_OFFSET, 1, 0, IPIS_C_CM_OUT_SIZE,
IPIS_C_CM_OUT_OFFSET, IPIS_C_CM,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIS_C_SLBC_OUT_OFFSET, 1, 0, IPIS_C_SLBC_OUT_SIZE,
IPIS_C_SLBC_OUT_OFFSET, IPIS_C_SLBC,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIS_C_SPM_SUSPEND_OUT_OFFSET, 1, 0, IPIS_C_SPM_SUSPEND_OUT_SIZE,
IPIS_C_SPM_SUSPEND_OUT_OFFSET, IPIS_C_SPM_SUSPEND,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIR_C_MET_OUT_OFFSET, 1, 0, IPIR_C_MET_OUT_SIZE,
IPIR_C_MET_OUT_OFFSET, IPIR_C_MET,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIR_C_GPU_DVFS_OUT_OFFSET, 1, 0, IPIR_C_GPU_DVFS_OUT_SIZE,
IPIR_C_GPU_DVFS_OUT_OFFSET, IPIR_C_GPU_DVFS,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIR_C_PLATFORM_OUT_OFFSET, 1, 0, IPIR_C_PLATFORM_OUT_SIZE,
IPIR_C_PLATFORM_OUT_OFFSET, IPIR_C_PLATFORM,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
{1, IPIR_C_SLBC_OUT_OFFSET, 1, 0, IPIR_C_SLBC_OUT_SIZE,
IPIR_C_SLBC_OUT_OFFSET, IPIR_C_SLBC,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
/* the following will use mbox 4 */
{4, IPIS_C_FHCTL_OUT_OFFSET, 1, 0, IPIS_C_FHCTL_OUT_SIZE,
IPIS_C_FHCTL_OUT_OFFSET, IPIS_C_FHCTL,
{ { 0 } }, { 0 }, { { { { 0 } } } } },
};
/*
* mbox pin structure, this is for receive defination,
* ipi=endpoint=pin
* mbox : (mbox number)mbox number of the pin, up to 16(plt)
* offset : (slot)msg offset in share memory, up to 1024*4 KB(plt)
* recv_opt : (opt)recv option, 0:receive ,1: response(plt)
* lock : (lock)polling lock 0:unuse,1:used
* buf_full_opt : (opt)buffer option 0:drop, 1:assert, 2:overwrite(plt)
* cb_ctx_opt : (opt)callback option 0:isr context, 1:process context(plt)
* msg_size : (slot)msg used slots in the mbox, 4 bytes alignment(plt)
* pin_index : (bit offset)pin index in the mbox(plt)
* chan_id : (u32) ipc channel id(plt)
* notify : (completion)notify process
* mbox_pin_cb: (cb)cb function
* pin_buf : (void*)buffer point
* prdata : (void*)private data
* pin_lock: (spinlock_t)lock of the pin
*/
struct mtk_mbox_pin_recv sspm_mbox_pin_recv[] = {
/* the following will use mbox 2 */
{2, IPIR_I_QOS_IN_OFFSET, 0, 0, 1, 1,
IPIR_I_QOS_IN_SIZE, IPIR_I_QOS_IN_OFFSET,
IPIR_I_QOS, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIR_C_MET_IN_OFFSET, 0, 0, 1, 1,
IPIR_C_MET_IN_SIZE, IPIR_C_MET_IN_OFFSET,
IPIR_C_MET, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIR_C_GPU_DVFS_IN_OFFSET, 0, 0, 1, 1,
IPIR_C_GPU_DVFS_IN_SIZE, IPIR_C_GPU_DVFS_IN_OFFSET,
IPIR_C_GPU_DVFS, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIR_C_PLATFORM_IN_OFFSET, 0, 0, 1, 1,
IPIR_C_PLATFORM_IN_SIZE, IPIR_C_PLATFORM_IN_OFFSET,
IPIR_C_PLATFORM, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIR_C_SLBC_IN_OFFSET, 0, 0, 1, 1,
IPIR_C_SLBC_IN_SIZE, IPIR_C_SLBC_IN_OFFSET,
IPIR_C_SLBC, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_PPM_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_PPM_IN_SIZE, IPIS_C_PPM_IN_OFFSET,
IPIS_C_PPM, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_QOS_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_QOS_IN_SIZE, IPIS_C_QOS_IN_OFFSET,
IPIS_C_QOS, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_PMIC_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_PMIC_IN_SIZE, IPIS_C_PMIC_IN_OFFSET,
IPIS_C_PMIC, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_MET_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_MET_IN_SIZE, IPIS_C_MET_IN_OFFSET,
IPIS_C_MET, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_THERMAL_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_THERMAL_IN_SIZE, IPIS_C_THERMAL_IN_OFFSET,
IPIS_C_THERMAL, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_GPU_DVFS_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_GPU_DVFS_IN_SIZE, IPIS_C_GPU_DVFS_IN_OFFSET,
IPIS_C_GPU_DVFS, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_GPU_PM_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_GPU_PM_IN_SIZE, IPIS_C_GPU_PM_IN_OFFSET,
IPIS_C_GPU_PM, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_PLATFORM_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_PLATFORM_IN_SIZE, IPIS_C_PLATFORM_IN_OFFSET,
IPIS_C_PLATFORM, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_SMI_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_SMI_IN_SIZE, IPIS_C_SMI_IN_OFFSET,
IPIS_C_SMI, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_CM_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_CM_IN_SIZE, IPIS_C_CM_IN_OFFSET,
IPIS_C_CM, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_SLBC_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_SLBC_IN_SIZE, IPIS_C_SLBC_IN_OFFSET,
IPIS_C_SLBC, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
{2, IPIS_C_SPM_SUSPEND_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_SPM_SUSPEND_IN_SIZE, IPIS_C_SPM_SUSPEND_IN_OFFSET,
IPIS_C_SPM_SUSPEND, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
/* the following will use mbox 4 */
{4, IPIS_C_FHCTL_IN_OFFSET, 1, 0, 1, 0,
IPIS_C_FHCTL_IN_SIZE, IPIS_C_FHCTL_IN_OFFSET,
IPIS_C_FHCTL, { 0 }, 0, 0, 0, { { { { 0 } } } },
{ 0, 0, 0, 0, 0, 0 } },
};
#define SSPM_TOTAL_SEND_PIN (sizeof(sspm_mbox_pin_send) \
/ sizeof(struct mtk_mbox_pin_send))
#define SSPM_TOTAL_RECV_PIN (sizeof(sspm_mbox_pin_recv) \
/ sizeof(struct mtk_mbox_pin_recv))
struct mtk_mbox_device sspm_mboxdev = {
.name = "sspm_mboxdev",
.pin_recv_table = &sspm_mbox_pin_recv[0],
.pin_send_table = &sspm_mbox_pin_send[0],
.info_table = &sspm_mbox_table[0],
.count = SSPM_MBOX_TOTAL,
.recv_count = SSPM_TOTAL_RECV_PIN,
.send_count = SSPM_TOTAL_SEND_PIN,
};
struct mtk_ipi_device sspm_ipidev = {
.name = "sspm_ipidev",
.id = IPI_DEV_SSPM,
.mbdev = &sspm_mboxdev,
.timeout_handler = sspm_ipi_timeout_cb,
};
@@ -0,0 +1,15 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include "sspm_ipi_id.h"
#include "sspm_mbox_pin.h"
extern void sspm_ipi_timeout_cb(int ipi_id);
extern struct mtk_mbox_info sspm_mbox_table[];
extern struct mtk_mbox_pin_send sspm_mbox_pin_send[];
extern struct mtk_mbox_pin_recv sspm_mbox_pin_recv[];
extern struct mtk_mbox_device sspm_mboxdev;
extern struct mtk_ipi_device sspm_ipidev;
@@ -0,0 +1,48 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include "sspm_define.h"
#include "sspm_ipi_id.h"
/* debug API */
__weak void dump_emi_outstanding(void) {}
__weak void mtk_spm_dump_debug_info(void) {}
__weak void usb_dump_debug_register(void) {}
__weak void dpmaif_dump_reg(void) {}
__weak void ccci_md_debug_dump(char *user_info) {}
static char *pin_name[SSPM_IPI_COUNT] = {
"PPM",
"QOS",
"PMIC",
"MET",
"THERMAL",
"GPU_DVFS",
"GPU_PM",
"PLATFORM",
"SMI",
"CM",
"SLBC",
"SPM_SUSPEND",
"QOS",
"MET",
"GPU_DVFS",
"PLATFORM",
"SLBC",
"FHCTL",
};
/* platform callback when ipi timeout */
void sspm_ipi_timeout_cb(int ipi_id)
{
pr_info("Error: possible error IPI %d pin=%s\n",
ipi_id, pin_name[ipi_id]);
ipi_monitor_dump(&sspm_ipidev);
BUG_ON(1);
}
@@ -0,0 +1,15 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_LOGGER_H__
#define __SSPM_LOGGER_H__
#include <linux/types.h>
extern void sspm_log_lastk_recv(unsigned int exists);
extern unsigned int __init sspm_logger_init(phys_addr_t start,
phys_addr_t limit);
extern int __init sspm_logger_init_done(void);
#endif
@@ -0,0 +1,271 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_ipi_id.h"
#include "sspm_helper.h"
#include "sspm_reservedmem.h"
#include "sspm_reservedmem_define.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
#if SSPM_PLT_SERV_SUPPORT
#ifdef SSPM_PLT_LOGGER_BUF_LEN
/* use platform-defined buffer length */
#define BUF_LEN SSPM_PLT_LOGGER_BUF_LEN
#else
/* otherwise use default buffer length */
#define BUF_LEN (1 * 1024 * 1024)
#endif
#define LBUF_LEN (4 * 1024)
#define SSPM_TIMER_TIMEOUT (1 * HZ) /* 1 seconds*/
#define ROUNDUP(a, b) (((a) + ((b)-1)) & ~((b)-1))
struct log_ctrl_s {
unsigned int base;
unsigned int size;
unsigned int enable;
unsigned int info_ofs;
unsigned int buff_ofs;
unsigned int buff_size;
};
struct buffer_info_s {
unsigned int r_pos;
unsigned int w_pos;
};
static unsigned int sspm_logger_inited;
static struct log_ctrl_s *log_ctl;
static struct buffer_info_s *buf_info, *lbuf_info;
static struct timer_list sspm_log_timer;
static DEFINE_MUTEX(sspm_log_mutex);
static inline void sspm_log_timer_add(void)
{
if (sspm_log_timer.expires == 0) {
sspm_log_timer.expires = jiffies + SSPM_TIMER_TIMEOUT;
add_timer(&sspm_log_timer);
}
}
static void sspm_log_timeout(struct timer_list *unused)
{
if (buf_info->r_pos != buf_info->w_pos) {
sspm_log_if_wake();
sspm_log_timer.expires = 0;
} else {
sspm_log_timer_add();
}
}
ssize_t sspm_log_read(char __user *data, size_t len)
{
unsigned long w_pos, r_pos, datalen;
char *buf, *tmp_buf;
if (!sspm_logger_inited)
return 0;
datalen = 0;
mutex_lock(&sspm_log_mutex);
r_pos = buf_info->r_pos;
w_pos = buf_info->w_pos;
if (r_pos == w_pos)
goto error;
if (r_pos > w_pos)
datalen = BUF_LEN - r_pos; /* not wrap */
else
datalen = w_pos - r_pos;
if (datalen > len)
datalen = len;
buf = ((char *) log_ctl) + log_ctl->buff_ofs + r_pos;
tmp_buf = kmalloc((size_t)len, GFP_KERNEL);
len = datalen;
if (tmp_buf) {
memcpy_fromio(tmp_buf, buf, len);
if (copy_to_user(data, tmp_buf, len))
pr_debug("sspm logger: copy data failed !!!\n");
kfree(tmp_buf);
} else {
pr_debug("sspm logger: create log buffer failed !!!\n");
goto error;
}
r_pos += datalen;
if (r_pos >= BUF_LEN)
r_pos -= BUF_LEN;
buf_info->r_pos = r_pos;
error:
mutex_unlock(&sspm_log_mutex);
return datalen;
}
unsigned int sspm_log_poll(void)
{
if (!sspm_logger_inited)
return 0;
if (buf_info->r_pos != buf_info->w_pos)
return POLLIN | POLLRDNORM;
sspm_log_timer_add();
return 0;
}
static unsigned int sspm_log_enable_set(unsigned int enable)
{
struct plt_ipi_data_s ipi_data;
int onoff, ret;
onoff = enable ? 257 : 1;
if (sspm_logger_inited) {
ipi_data.cmd = PLT_LOG_ENABLE;
ipi_data.u.logger.enable = onoff;
sspm_plt_ackdata = -1;
ret = mtk_ipi_send_compl(&sspm_ipidev, IPIS_C_PLATFORM,
IPI_SEND_WAIT, &ipi_data,
sizeof(ipi_data) / MBOX_SLOT_SIZE, 2000);
if (ret) {
pr_err("SSPM: logger IPI fail ret=%d\n", ret);
goto error;
}
if (enable != sspm_plt_ackdata) {
pr_err("SSPM: %s fail enable=%u ret=%d\n", __func__,
enable, sspm_plt_ackdata);
goto error;
}
log_ctl->enable = enable;
}
error:
return 0;
}
static ssize_t sspm_mobile_log_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
unsigned int stat;
stat = (sspm_logger_inited && log_ctl->enable) ? 1 : 0;
return snprintf(buf, PAGE_SIZE, "SSPM mobile log is %s\n",
(stat == 0x1) ? "enabled" : "disabled");
}
static ssize_t sspm_mobile_log_store(struct device *kobj,
struct device_attribute *attr, const char *buf, size_t n)
{
unsigned int enable;
if (kstrtouint(buf, 0, &enable) != 0)
return -EINVAL;
mutex_lock(&sspm_log_mutex);
sspm_log_enable_set(enable);
mutex_unlock(&sspm_log_mutex);
return n;
}
DEVICE_ATTR(sspm_mobile_log, 0644, sspm_mobile_log_show, sspm_mobile_log_store);
unsigned int __init sspm_logger_init(phys_addr_t start, phys_addr_t limit)
{
unsigned int last_ofs;
last_ofs = 0;
log_ctl = (struct log_ctrl_s *)(uintptr_t) start;
log_ctl->base = PLT_LOG_ENABLE; /* magic */
log_ctl->enable = 0;
log_ctl->size = sizeof(*log_ctl);
last_ofs += log_ctl->size;
log_ctl->info_ofs = last_ofs;
last_ofs += sizeof(*buf_info);
last_ofs = ROUNDUP(last_ofs, 4);
log_ctl->buff_ofs = last_ofs;
log_ctl->buff_size = BUF_LEN;
buf_info = (struct buffer_info_s *) (((unsigned char *) log_ctl) +
log_ctl->info_ofs);
buf_info->r_pos = 0;
buf_info->w_pos = 0;
last_ofs += log_ctl->buff_size;
if (last_ofs >= limit) {
pr_err("SSPM:%s() initial fail, last_ofs=%u, limit=%u\n",
__func__, last_ofs, (unsigned int) limit);
goto error;
}
return last_ofs;
error:
sspm_logger_inited = 0;
log_ctl = NULL;
buf_info = lbuf_info = NULL;
return 0;
}
int __init sspm_logger_init_done(void)
{
int ret;
if (log_ctl) {
ret = sspm_sysfs_create_file(&dev_attr_sspm_mobile_log);
if (unlikely(ret != 0))
return ret;
timer_setup(&sspm_log_timer, &sspm_log_timeout, 0);
sspm_log_timer.expires = 0;
sspm_logger_inited = 1;
}
return 0;
}
#endif
@@ -0,0 +1,135 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_MBOX_PIN_H__
#define __SSPM_MBOX_PIN_H__
#define SSPM_MBOX_TOTAL 5
/* definition of slot size for OUT PINs */
/* the following will use mbox 0 */
#define IPIS_C_PPM_OUT_SIZE 7
#define IPIS_C_QOS_OUT_SIZE 6
#define IPIS_C_PMIC_OUT_SIZE 5
#define IPIS_C_MET_OUT_SIZE 4
#define IPIS_C_THERMAL_OUT_SIZE 4
#define IPIS_C_GPU_DVFS_OUT_SIZE 4
#define IPIS_C_GPU_PM_OUT_SIZE 2
/* the following will use mbox 1 */
#define IPIS_C_PLATFORM_OUT_SIZE 3
#define IPIS_C_SMI_OUT_SIZE 3
#define IPIS_C_CM_OUT_SIZE 2
#define IPIS_C_SLBC_OUT_SIZE 2
#define IPIS_C_SPM_SUSPEND_OUT_SIZE 8
#define IPIR_C_MET_OUT_SIZE 1
#define IPIR_C_GPU_DVFS_OUT_SIZE 1
#define IPIR_C_PLATFORM_OUT_SIZE 1
#define IPIR_C_SLBC_OUT_SIZE 1
#define IPIS_C_FHCTL_OUT_SIZE 9
/* definition of slot offset for OUT PINs */
/* the following will use mbox 0 */
#define IPIS_C_PPM_OUT_OFFSET 0
#define IPIS_C_QOS_OUT_OFFSET (IPIS_C_PPM_OUT_OFFSET \
+ IPIS_C_PPM_OUT_SIZE)
#define IPIS_C_PMIC_OUT_OFFSET (IPIS_C_QOS_OUT_OFFSET \
+ IPIS_C_QOS_OUT_SIZE)
#define IPIS_C_MET_OUT_OFFSET (IPIS_C_PMIC_OUT_OFFSET \
+ IPIS_C_PMIC_OUT_SIZE)
#define IPIS_C_THERMAL_OUT_OFFSET (IPIS_C_MET_OUT_OFFSET \
+ IPIS_C_MET_OUT_SIZE)
#define IPIS_C_GPU_DVFS_OUT_OFFSET (IPIS_C_THERMAL_OUT_OFFSET \
+ IPIS_C_THERMAL_OUT_SIZE)
#define IPIS_C_GPU_PM_OUT_OFFSET (IPIS_C_GPU_DVFS_OUT_OFFSET \
+ IPIS_C_GPU_DVFS_OUT_SIZE)
/* the following will use mbox 1 */
#define IPIS_C_PLATFORM_OUT_OFFSET 0
#define IPIS_C_SMI_OUT_OFFSET (IPIS_C_PLATFORM_OUT_OFFSET \
+ IPIS_C_PLATFORM_OUT_SIZE)
#define IPIS_C_CM_OUT_OFFSET (IPIS_C_SMI_OUT_OFFSET \
+ IPIS_C_SMI_OUT_SIZE)
#define IPIS_C_SLBC_OUT_OFFSET (IPIS_C_CM_OUT_OFFSET \
+ IPIS_C_CM_OUT_SIZE)
#define IPIS_C_SPM_SUSPEND_OUT_OFFSET (IPIS_C_SLBC_OUT_OFFSET \
+ IPIS_C_SLBC_OUT_SIZE)
#define IPIR_C_MET_OUT_OFFSET (IPIS_C_SPM_SUSPEND_OUT_OFFSET \
+ IPIS_C_SPM_SUSPEND_OUT_SIZE)
#define IPIR_C_GPU_DVFS_OUT_OFFSET (IPIR_C_MET_OUT_OFFSET \
+ IPIR_C_MET_OUT_SIZE)
#define IPIR_C_PLATFORM_OUT_OFFSET (IPIR_C_GPU_DVFS_OUT_OFFSET \
+ IPIR_C_GPU_DVFS_OUT_SIZE)
#define IPIR_C_SLBC_OUT_OFFSET (IPIR_C_PLATFORM_OUT_OFFSET \
+ IPIR_C_PLATFORM_OUT_SIZE)
/* the following will use mbox 4 */
#define IPIS_C_FHCTL_OUT_OFFSET 0
/* definition of slot size for IN PINs */
/* the following will use mbox 2 */
#define IPIR_I_QOS_IN_SIZE 6
#define IPIR_C_MET_IN_SIZE 4
#define IPIR_C_GPU_DVFS_IN_SIZE 4
#define IPIR_C_PLATFORM_IN_SIZE 3
#define IPIR_C_SLBC_IN_SIZE 2
#define IPIS_C_PPM_IN_SIZE 1
#define IPIS_C_QOS_IN_SIZE 1
#define IPIS_C_PMIC_IN_SIZE 1
#define IPIS_C_MET_IN_SIZE 1
#define IPIS_C_THERMAL_IN_SIZE 1
#define IPIS_C_GPU_DVFS_IN_SIZE 1
#define IPIS_C_GPU_PM_IN_SIZE 1
#define IPIS_C_PLATFORM_IN_SIZE 1
#define IPIS_C_SMI_IN_SIZE 1
#define IPIS_C_CM_IN_SIZE 1
#define IPIS_C_SLBC_IN_SIZE 1
#define IPIS_C_SPM_SUSPEND_IN_SIZE 1
#define IPIS_C_FHCTL_IN_SIZE 1
/* definition of slot offset for IN PINs */
/* the following will use mbox 2 */
#define IPIR_I_QOS_IN_OFFSET 0
#define IPIR_C_MET_IN_OFFSET (IPIR_I_QOS_IN_OFFSET \
+ IPIR_I_QOS_IN_SIZE)
#define IPIR_C_GPU_DVFS_IN_OFFSET (IPIR_C_MET_IN_OFFSET \
+ IPIR_C_MET_IN_SIZE)
#define IPIR_C_PLATFORM_IN_OFFSET (IPIR_C_GPU_DVFS_IN_OFFSET \
+ IPIR_C_GPU_DVFS_IN_SIZE)
#define IPIR_C_SLBC_IN_OFFSET (IPIR_C_PLATFORM_IN_OFFSET \
+ IPIR_C_PLATFORM_IN_SIZE)
#define IPIS_C_PPM_IN_OFFSET (IPIR_C_SLBC_IN_OFFSET \
+ IPIR_C_SLBC_IN_SIZE)
#define IPIS_C_QOS_IN_OFFSET (IPIS_C_PPM_IN_OFFSET \
+ IPIS_C_PPM_IN_SIZE)
#define IPIS_C_PMIC_IN_OFFSET (IPIS_C_QOS_IN_OFFSET \
+ IPIS_C_QOS_IN_SIZE)
#define IPIS_C_MET_IN_OFFSET (IPIS_C_PMIC_IN_OFFSET \
+ IPIS_C_PMIC_IN_SIZE)
#define IPIS_C_THERMAL_IN_OFFSET (IPIS_C_MET_IN_OFFSET \
+ IPIS_C_MET_IN_SIZE)
#define IPIS_C_GPU_DVFS_IN_OFFSET (IPIS_C_THERMAL_IN_OFFSET \
+ IPIS_C_THERMAL_IN_SIZE)
#define IPIS_C_GPU_PM_IN_OFFSET (IPIS_C_GPU_DVFS_IN_OFFSET \
+ IPIS_C_GPU_DVFS_IN_SIZE)
#define IPIS_C_PLATFORM_IN_OFFSET (IPIS_C_GPU_PM_IN_OFFSET \
+ IPIS_C_GPU_PM_IN_SIZE)
#define IPIS_C_SMI_IN_OFFSET (IPIS_C_PLATFORM_IN_OFFSET \
+ IPIS_C_PLATFORM_IN_SIZE)
#define IPIS_C_CM_IN_OFFSET (IPIS_C_SMI_IN_OFFSET \
+ IPIS_C_SMI_IN_SIZE)
#define IPIS_C_SLBC_IN_OFFSET (IPIS_C_CM_IN_OFFSET \
+ IPIS_C_CM_IN_SIZE)
#define IPIS_C_SPM_SUSPEND_IN_OFFSET (IPIS_C_SLBC_IN_OFFSET \
+ IPIS_C_SLBC_IN_SIZE)
/* the following will use mbox 4 */
#define IPIS_C_FHCTL_IN_OFFSET (IPIS_C_FHCTL_OUT_OFFSET \
+ IPIS_C_FHCTL_OUT_SIZE)
#define SHAREMBOX_NO_MCDI 3
#define SHAREMBOX_OFFSET_MCDI 0
#define SHAREMBOX_SIZE_MCDI 20
#define SHAREMBOX_OFFSET_TIMESTAMP (SHAREMBOX_OFFSET_MCDI \
+ SHAREMBOX_SIZE_MCDI)
#define SHAREMBOX_SIZE_TIMESTAMP 6
#endif /* __SSPM_MBOX_PIN_H__ */
+212
View File
@@ -0,0 +1,212 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/atomic.h>
#include <linux/types.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_ipi_id.h"
#include "sspm_reservedmem.h"
#include "sspm_reservedmem_define.h"
#if SSPM_LOGGER_SUPPORT
#include "sspm_logger.h"
#endif
#include "sspm_sysfs.h"
#if SSPM_PLT_SERV_SUPPORT
struct plt_ctrl_s {
unsigned int magic;
unsigned int size;
unsigned int mem_sz;
#if SSPM_LOGGER_SUPPORT
unsigned int logger_ofs;
#endif
};
enum ipi_debug_opt {
IPI_TRACKING_OFF,
IPI_TRACKING_ON,
IPIMON_SHOW,
};
static ssize_t sspm_ipi_debug_help(struct device *kobj,
struct device_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "SSPM ipi debug command:\n"
"0: Turn off the ipi tracking\n"
"1: Turn on the ipi tracking\n"
"2: Dump the ipimon\n");
}
static ssize_t sspm_ipi_debug_set(struct device *kobj,
struct device_attribute *attr, const char *buf, size_t n)
{
unsigned int opt = 0xFFFF;
if (kstrtouint(buf, 10, &opt) != 0)
return -EINVAL;
switch (opt) {
case IPI_TRACKING_ON:
case IPI_TRACKING_OFF:
mtk_ipi_tracking(&sspm_ipidev, opt);
break;
case IPIMON_SHOW:
ipi_monitor_dump(&sspm_ipidev);
break;
default:
pr_info("cmd '%d' is not supported.\n", opt);
break;
}
return n;
}
DEVICE_ATTR(sspm_ipi_debug, 0644, sspm_ipi_debug_help, sspm_ipi_debug_set);
static ssize_t sspm_alive_show(struct device *kobj,
struct device_attribute *attr, char *buf)
{
struct plt_ipi_data_s ipi_data;
int ret;
ipi_data.cmd = 0xDEAD;
sspm_plt_ackdata = 0;
ret = mtk_ipi_send_compl(&sspm_ipidev, IPIS_C_PLATFORM, IPI_SEND_WAIT,
&ipi_data, sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE, 2000);
return snprintf(buf, PAGE_SIZE, "%s\n",
sspm_plt_ackdata ? "Alive" : "Dead");
}
DEVICE_ATTR(sspm_alive, 0444, sspm_alive_show, NULL);
int __init sspm_plt_init(void)
{
phys_addr_t phys_addr, virt_addr, mem_sz;
struct plt_ipi_data_s ipi_data;
struct plt_ctrl_s *plt_ctl;
int ret;
unsigned int last_ofs;
#if SSPM_LOGGER_SUPPORT
unsigned int last_sz;
#endif
unsigned int *mark;
unsigned char *b;
ret = sspm_sysfs_create_file(&dev_attr_sspm_alive);
if (unlikely(ret != 0))
goto error;
ret = sspm_sysfs_create_file(&dev_attr_sspm_ipi_debug);
if (unlikely(ret != 0))
pr_info("SSPM: Can't create file node for ipi debug !\n");
phys_addr = sspm_reserve_mem_get_phys(SSPM_MEM_ID);
if (phys_addr == 0) {
pr_err("SSPM: Can't get logger phys mem\n");
goto error;
}
virt_addr = sspm_reserve_mem_get_virt(SSPM_MEM_ID);
if (virt_addr == 0) {
pr_err("SSPM: Can't get logger virt mem\n");
goto error;
}
mem_sz = sspm_reserve_mem_get_size(SSPM_MEM_ID);
if (mem_sz == 0) {
pr_err("SSPM: Can't get logger mem size\n");
goto error;
}
b = (unsigned char *) (uintptr_t)virt_addr;
for (last_ofs = 0; last_ofs < sizeof(*plt_ctl); last_ofs++)
b[last_ofs] = 0x0;
mark = (unsigned int *) (uintptr_t)virt_addr;
*mark = PLT_INIT;
mark = (unsigned int *) ((unsigned char *) (uintptr_t)
virt_addr + mem_sz - 4);
*mark = PLT_INIT;
plt_ctl = (struct plt_ctrl_s *) (uintptr_t)virt_addr;
plt_ctl->magic = PLT_INIT;
plt_ctl->size = sizeof(*plt_ctl);
plt_ctl->mem_sz = mem_sz;
last_ofs = plt_ctl->size;
pr_debug("SSPM: %s(): after plt, ofs=%u\n", __func__, last_ofs);
#if SSPM_LOGGER_SUPPORT
plt_ctl->logger_ofs = last_ofs;
last_sz = sspm_logger_init(virt_addr + last_ofs, mem_sz - last_ofs);
if (last_sz == 0) {
pr_err("SSPM: sspm_logger_init return fail\n");
goto error;
}
last_ofs += last_sz;
pr_debug("SSPM: %s(): after logger, ofs=%u\n", __func__, last_ofs);
#endif
ipi_data.cmd = PLT_INIT;
ipi_data.u.ctrl.phys = phys_addr;
ipi_data.u.ctrl.size = mem_sz;
sspm_plt_ackdata = 0;
ret = mtk_ipi_send_compl(&sspm_ipidev, IPIS_C_PLATFORM,
IPI_SEND_POLLING, &ipi_data,
sizeof(ipi_data) / SSPM_MBOX_SLOT_SIZE, 2000);
if (ret) {
pr_err("SSPM: plt IPI fail ret=%d\n", ret);
goto error;
}
if (!sspm_plt_ackdata) {
pr_err("SSPM: plt IPI init fail, ackdata=%d\n",
sspm_plt_ackdata);
goto error;
}
#if SSPM_LOGGER_SUPPORT
sspm_logger_init_done();
#endif
return 0;
error:
return -1;
}
#endif
@@ -0,0 +1,199 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/vmalloc.h> /* needed by kmalloc */
#include <linux/uaccess.h> /* needed by copy_to_user */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/slab.h> /* needed by kmalloc */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/suspend.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_fdt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_helper.h"
#include "sspm_reservedmem.h"
#define _SSPM_INTERNAL_
#include "sspm_reservedmem_define.h"
#ifdef CONFIG_OF_RESERVED_MEM
#include <linux/of_reserved_mem.h>
#define SSPM_MEM_RESERVED_KEY "mediatek,reserve-memory-sspm_share"
#endif
static phys_addr_t sspm_mem_base_phys;
static phys_addr_t sspm_mem_base_virt;
static phys_addr_t sspm_mem_size;
#ifdef CONFIG_OF_RESERVED_MEM
static int __init sspm_reserve_mem_of_init(struct reserved_mem *rmem)
{
unsigned int id;
phys_addr_t accumlate_memory_size = 0;
sspm_mem_base_phys = (phys_addr_t) rmem->base;
sspm_mem_size = (phys_addr_t) rmem->size;
pr_debug("[SSPM] phys:0x%llx - 0x%llx (0x%llx)\n",
(unsigned long long)rmem->base,
(unsigned long long)rmem->base + (unsigned long long)rmem->size,
(unsigned long long)rmem->size);
accumlate_memory_size = 0;
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_phys = sspm_mem_base_phys +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
pr_debug("[SSPM][reserve_mem:%d]: ", id);
pr_debug("phys:0x%llx - 0x%llx (0x%llx)\n",
sspm_reserve_mblock[id].start_phys,
sspm_reserve_mblock[id].start_phys +
sspm_reserve_mblock[id].size,
sspm_reserve_mblock[id].size);
}
return 0;
}
RESERVEDMEM_OF_DECLARE(sspm_reservedmem, SSPM_MEM_RESERVED_KEY,
sspm_reserve_mem_of_init);
#endif
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_phys;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_phys);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].start_virt;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_virt);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id)
{
if (id >= NUMS_MEM_ID) {
pr_err("[SSPM] no reserve memory for 0x%x", id);
return 0;
} else
return sspm_reserve_mblock[id].size;
}
EXPORT_SYMBOL_GPL(sspm_reserve_mem_get_size);
#ifdef SSPM_SHARE_BUFFER_SUPPORT
void __iomem *sspm_base;
phys_addr_t sspm_sbuf_get(unsigned int offset)
{
if (!is_sspm_ready()) {
pr_notice("[SSPM] device resource is not ready\n");
return 0;
}
if (offset < SSPM_SHARE_REGION_BASE ||
offset > SSPM_SHARE_REGION_BASE + SSPM_SHARE_REGION_SIZE) {
pr_notice("[SSPM] illegal sbuf request: 0x%x\n", offset);
return 0;
} else {
return (phys_addr_t)(sspm_base + offset);
}
}
EXPORT_SYMBOL_GPL(sspm_sbuf_get);
#endif
int sspm_reserve_memory_init(void)
{
unsigned int id;
phys_addr_t accumlate_memory_size;
if (NUMS_MEM_ID == 0)
return 0;
if (sspm_mem_base_phys == 0)
return -1;
accumlate_memory_size = 0;
sspm_mem_base_virt = (phys_addr_t)(uintptr_t)
ioremap_wc(sspm_mem_base_phys, sspm_mem_size);
pr_debug("[SSPM]reserve mem: virt:0x%llx - 0x%llx (0x%llx)\n",
(unsigned long long)sspm_mem_base_virt,
(unsigned long long)sspm_mem_base_virt +
(unsigned long long)sspm_mem_size,
(unsigned long long)sspm_mem_size);
for (id = 0; id < NUMS_MEM_ID; id++) {
sspm_reserve_mblock[id].start_virt = sspm_mem_base_virt +
accumlate_memory_size;
accumlate_memory_size += sspm_reserve_mblock[id].size;
}
/* the reserved memory should be larger then expected memory
* or sspm_reserve_mblock does not match dts
*/
BUG_ON(accumlate_memory_size > sspm_mem_size);
#ifdef DEBUG
for (id = 0; id < NUMS_MEM_ID; id++) {
pr_debug("[SSPM][mem_reserve-%d] ", id);
pr_debug("phys:0x%llx,virt:0x%llx,size:0x%llx\n",
(unsigned long long)sspm_reserve_mem_get_phys(id),
(unsigned long long)sspm_reserve_mem_get_virt(id),
(unsigned long long)sspm_reserve_mem_get_size(id));
}
#endif
return 0;
}
void sspm_lock_emi_mpu(void)
{
#if SSPM_EMI_PROTECTION_SUPPORT
if (sspm_mem_size > 0)
sspm_set_emi_mpu(sspm_mem_base_phys, sspm_mem_size);
#endif
}
#ifdef SSPM_SHARE_BUFFER_SUPPORT
int sspm_sbuf_init(void)
{
struct device *dev = &sspm_pdev->dev;
struct resource *res;
if (sspm_pdev) {
res = platform_get_resource_byname(sspm_pdev,
IORESOURCE_MEM, "sspm_base");
sspm_base = devm_ioremap_resource(dev, res);
if (IS_ERR((void const *) sspm_base))
return -1;
}
return 0;
}
#endif
@@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_RESERVED_H__
#define __SSPM_RESERVED_H__
#include <linux/types.h>
#include "sspm_define.h"
struct sspm_reserve_mblock {
u32 num;
u64 start_phys;
u64 start_virt;
u64 size;
};
phys_addr_t sspm_reserve_mem_get_phys(unsigned int id);
phys_addr_t sspm_reserve_mem_get_virt(unsigned int id);
phys_addr_t sspm_reserve_mem_get_size(unsigned int id);
int sspm_reserve_memory_init(void);
void sspm_set_emi_mpu(phys_addr_t base, phys_addr_t size);
void sspm_lock_emi_mpu(void);
#ifdef SSPM_SHARE_BUFFER_SUPPORT
extern struct platform_device *sspm_pdev;
phys_addr_t sspm_sbuf_get(unsigned int offset);
int sspm_sbuf_init(void);
#endif /* SSPM_SHARE_BUFFER_SUPPORT */
#endif
@@ -0,0 +1,82 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef _SSPM_RESERVEDMEM_DEFINE_H_
#define _SSPM_RESERVEDMEM_DEFINE_H_
#include <sspm_reservedmem.h>
#ifndef _SSPM_MEM_ID_
#define _SSPM_MEM_ID_
enum {
SSPM_MEM_ID = 0,
PWRAP_MEM_ID,
PMIC_MEM_ID,
UPD_MEM_ID,
QOS_MEM_ID,
SWPM_MEM_ID,
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
MET_MEM_ID,
#endif
SMI_MEM_ID,
GPU_MEM_ID,
NUMS_MEM_ID,
};
#endif
#define SSPM_PLT_LOGGER_BUF_LEN 0x100000
#ifdef _SSPM_INTERNAL_
/* The total size of sspm_reserve_mblock should less equal than
* reserve-memory-sspm_share of device tree
*/
static struct sspm_reserve_mblock sspm_reserve_mblock[NUMS_MEM_ID] = {
{
.num = SSPM_MEM_ID,
.size = 0x100 + SSPM_PLT_LOGGER_BUF_LEN,
/* logger header + 1M log buffer */
},
{
.num = PWRAP_MEM_ID,
.size = 0x300, /* 768 bytes */
},
{
.num = PMIC_MEM_ID,
.size = 0xC00, /* 3K */
},
{
.num = UPD_MEM_ID,
.size = 0x1800, /* 6K */
},
{
.num = QOS_MEM_ID,
.size = 0x1000, /* 4K */
},
{
.num = SWPM_MEM_ID,
.size = 0x1800, /* 6K */
},
#if defined(CONFIG_MTK_GMO_RAM_OPTIMIZE) || defined(CONFIG_MTK_MET_MEM_ALLOC)
#else
{
.num = MET_MEM_ID,
.size = 0x400000, /* 4M */
},
#endif
{
.num = SMI_MEM_ID,
.size = 0x9000, /* 36K */
},
{
.num = GPU_MEM_ID,
.size = 0x1000, /* 4K */
},
/* TO align 64K, total is 1M(5M)+64K. The remaining size = 0x2000. */
};
#endif
#endif
#ifdef SSPM_SHARE_BUFFER_SUPPORT
#define SSPM_SHARE_REGION_BASE 0x20000
#define SSPM_SHARE_REGION_SIZE 0x8000
#endif
+110
View File
@@ -0,0 +1,110 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2011-2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/module.h> /* needed by all modules */
#include <linux/init.h> /* needed by module macros */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/miscdevice.h> /* needed by miscdevice* */
#include <linux/device.h> /* needed by device_* */
#include <linux/fs.h> /* needed by file_operations* */
#include <linux/poll.h> /* needed by poll */
#include <linux/mutex.h>
#include <linux/atomic.h>
#include <mt-plat/sync_write.h>
#include "sspm_define.h"
#include "sspm_sysfs.h"
#include "sspm_logger.h"
static wait_queue_head_t logwait;
ssize_t __weak sspm_log_read(char __user *data, size_t len)
{
return 0;
}
unsigned int __weak sspm_log_poll(void)
{
return 0;
}
static ssize_t sspm_log_if_read(struct file *file, char __user *data,
size_t len, loff_t *ppos)
{
ssize_t ret;
/* pr_debug("[SSPM] sspm_log_if_read\n"); */
ret = 0;
if (access_ok(VERIFY_WRITE, data, len))
ret = sspm_log_read(data, len);
return ret;
}
static int sspm_log_if_open(struct inode *inode, struct file *file)
{
/* pr_debug("[SSPM] sspm_log_if_open\n"); */
return nonseekable_open(inode, file);
}
static unsigned int sspm_log_if_poll(struct file *file, poll_table *wait)
{
unsigned int ret = 0;
/* pr_debug("[SSPM] sspm_log_if_poll\n"); */
if (!(file->f_mode & FMODE_READ))
return ret;
poll_wait(file, &logwait, wait);
ret = sspm_log_poll();
return ret;
}
void sspm_log_if_wake(void)
{
wake_up(&logwait);
}
static const struct file_operations sspm_log_file_ops = {
.owner = THIS_MODULE,
.read = sspm_log_if_read,
.open = sspm_log_if_open,
.poll = sspm_log_if_poll,
};
static struct miscdevice sspm_log_device = {
.minor = MISC_DYNAMIC_MINOR,
.name = "sspm",
.fops = &sspm_log_file_ops
};
int __init sspm_sysfs_init(void)
{
int ret;
init_waitqueue_head(&logwait);
ret = misc_register(&sspm_log_device);
if (unlikely(ret != 0))
return ret;
return 0;
}
int sspm_sysfs_create_file(const struct device_attribute *attr)
{
return device_create_file(sspm_log_device.this_device, attr);
}
int sspm_sysfs_create_bin_file(const struct bin_attribute *attr)
{
return device_create_bin_file(sspm_log_device.this_device, attr);
}
@@ -0,0 +1,16 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __SSPM_SYSFS_H__
#define __SSPM_SYSFS_H__
#include <linux/sysfs.h>
#include <linux/device.h>
extern void sspm_log_if_wake(void);
extern int __init sspm_sysfs_init(void);
extern int sspm_sysfs_create_file(const struct device_attribute *attr);
extern int sspm_sysfs_create_bin_file(const struct bin_attribute *attr);
#endif
@@ -0,0 +1,226 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/clocksource.h>
#include <linux/sched/clock.h>
#include <linux/suspend.h>
#include <linux/timex.h>
#include <linux/types.h>
#include <asm/arch_timer.h>
#include <asm/timex.h>
#include "sspm_define.h"
#include "sspm_timesync.h"
#define sspm_ts_write(id, val) \
mtk_mbox_write(&sspm_mboxdev, SSPM_TS_MBOX, id, (void *)&val, 1)
#define TIMESYNC_TAG "[SSPM_TS]"
#define TIMESYNC_MAX_VER (0x7)
#define TIMESYNC_HEADER_FREEZE_OFS (31)
#define TIMESYNC_HEADER_FREEZE (1 << TIMESYNC_HEADER_FREEZE_OFS)
#define TIMESYNC_HEADER_VER_OFS (28)
#define TIMESYNC_HEADER_VER_MASK (TIMESYNC_MAX_VER << TIMESYNC_HEADER_VER_OFS)
#define TIMESYNC_FLAG_SYNC (1 << 0)
#define TIMESYNC_FLAG_ASYNC (1 << 1)
#define TIMESYNC_FLAG_FREEZE (1 << 2)
#define TIMESYNC_FLAG_UNFREEZE (1 << 3)
/* sched_clock wrap time is 4398 seconds for arm arch timer
* applying a period less than it for tinysys timesync
*/
#define TIMESYNC_WRAP_TIME (4000*NSEC_PER_SEC)
struct timesync_context_t {
spinlock_t lock;
struct work_struct work;
ktime_t wrap_kt;
u8 enabled;
u64 base_tick;
u64 base_ts;
};
static struct workqueue_struct *timesync_workqueue;
static struct timesync_context_t timesync_ctx;
static struct timecounter timesync_counter;
static struct hrtimer timesync_refresh_timer;
static u8 sspm_base_ver;
static void sspm_ts_update(int suspended, u64 tick, u64 ts)
{
u32 header, val;
sspm_base_ver = (sspm_base_ver + 1)%(TIMESYNC_MAX_VER+1);
/* make header: freeze and version */
header = suspended ? TIMESYNC_HEADER_FREEZE : 0;
header |= ((sspm_base_ver << TIMESYNC_HEADER_VER_OFS) &
TIMESYNC_HEADER_VER_MASK);
/* update tick, h -> l */
val = (tick >> 32) & 0xFFFFFFFF;
val |= header;
sspm_ts_write(SSPM_TS_MBOX_TICK_H, val);
/* fix update sequence to promise atomicity */
mb();
val = tick & 0xFFFFFFFF;
sspm_ts_write(SSPM_TS_MBOX_TICK_L, val);
/* fix update sequence to promise atomicity */
mb();
/* update ts, l -> h */
val = ts & 0xFFFFFFFF;
sspm_ts_write(SSPM_TS_MBOX_TS_L, val);
/* fix update sequence to promise atomicity */
mb();
val = (ts >> 32) & 0xFFFFFFFF;
val |= header;
sspm_ts_write(SSPM_TS_MBOX_TS_H, val);
/* fix update sequence to promise atomicity */
mb();
}
static u64 timesync_tick_read(const struct cyclecounter *cc)
{
return arch_timer_read_counter();
}
static struct cyclecounter timesync_cc __ro_after_init = {
.read = timesync_tick_read,
.mask = CLOCKSOURCE_MASK(56),
};
static void timesync_sync_base_internal(unsigned int flag)
{
u64 tick, ts;
unsigned long irq_flags = 0;
int freeze, unfreeze;
spin_lock_irqsave(&timesync_ctx.lock, irq_flags);
ts = timecounter_read(&timesync_counter);
tick = timesync_counter.cycle_last;
timesync_ctx.base_tick = tick;
timesync_ctx.base_ts = ts;
freeze = (flag & TIMESYNC_FLAG_FREEZE) ? 1 : 0;
unfreeze = (flag & TIMESYNC_FLAG_UNFREEZE) ? 1 : 0;
/* sync with sspm */
sspm_ts_update(freeze, tick, ts);
spin_unlock_irqrestore(&timesync_ctx.lock, irq_flags);
pr_info("%s update base: ts=%llu, tick=0x%llx, fz=%d, ver=%d\n",
TIMESYNC_TAG, ts, tick, freeze, sspm_base_ver);
}
static void timesync_sync_base(unsigned int flag)
{
if (!timesync_ctx.enabled)
return;
if (flag & TIMESYNC_FLAG_ASYNC)
queue_work(timesync_workqueue, &(timesync_ctx.work));
else
timesync_sync_base_internal(flag);
}
static enum hrtimer_restart timesync_refresh(struct hrtimer *hrt)
{
hrtimer_forward_now(hrt, timesync_ctx.wrap_kt);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_ASYNC);
return HRTIMER_RESTART;
}
static void timesync_ws(struct work_struct *ws)
{
timesync_sync_base(TIMESYNC_FLAG_SYNC);
}
unsigned int __init sspm_timesync_init(void)
{
timesync_workqueue = create_workqueue("sspm_ts_wq");
if (!timesync_workqueue) {
pr_info("%s workqueue create failed\n", __func__);
timesync_ctx.enabled = 0;
return -1;
}
INIT_WORK(&(timesync_ctx.work), timesync_ws);
spin_lock_init(&timesync_ctx.lock);
/* init cyclecounter mult and shift as sched_clock */
clocks_calc_mult_shift(&timesync_cc.mult, &timesync_cc.shift,
arch_timer_get_cntfrq(), NSEC_PER_SEC, 3600);
timesync_ctx.wrap_kt = ns_to_ktime(TIMESYNC_WRAP_TIME);
/* Init time counter:
* start_time: current sched_clock
* read: arch timer counter
*/
timecounter_init(&timesync_counter, &timesync_cc, sched_clock());
hrtimer_init(&timesync_refresh_timer,
CLOCK_MONOTONIC, HRTIMER_MODE_REL);
timesync_refresh_timer.function = timesync_refresh;
hrtimer_start(&timesync_refresh_timer,
timesync_ctx.wrap_kt, HRTIMER_MODE_REL);
pr_info("%s ts: cycle_last %lld, time_base:%lld, wrap:%lld\n",
TIMESYNC_TAG, timesync_counter.cycle_last,
timesync_counter.nsec, timesync_ctx.wrap_kt);
timesync_ctx.enabled = 1;
timesync_sync_base(TIMESYNC_FLAG_SYNC);
return 0;
}
void sspm_timesync_suspend(void)
{
if (!timesync_ctx.enabled)
return;
hrtimer_cancel(&timesync_refresh_timer);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_SYNC |
TIMESYNC_FLAG_FREEZE);
}
void sspm_timesync_resume(void)
{
if (!timesync_ctx.enabled)
return;
/* re-init timecounter because sched_clock will be stopped during
* suspend but arch timer counter is not, so we need to update
* start time after resume
*/
timecounter_init(&timesync_counter, &timesync_cc, sched_clock());
hrtimer_start(&timesync_refresh_timer,
timesync_ctx.wrap_kt, HRTIMER_MODE_REL);
/* snchronize new sched_clock base to co-processors */
timesync_sync_base(TIMESYNC_FLAG_SYNC |
TIMESYNC_FLAG_UNFREEZE);
}
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _SSPM_TIMESYNC_H_
#define _SSPM_TIMESYNC_H_
#include "sspm_ipi_table.h"
#define SSPM_TS_MBOX SHAREMBOX_NO_MCDI
#define SSPM_TS_MBOX_OFFSET_BASE SHAREMBOX_OFFSET_TIMESTAMP
/*
* Shared MBOX: AP write, SSPM read
* Unit for each offset: 4 bytes
*/
#define SSPM_TS_MBOX_TICK_H (SSPM_TS_MBOX_OFFSET_BASE + 0)
#define SSPM_TS_MBOX_TICK_L (SSPM_TS_MBOX_OFFSET_BASE + 1)
#define SSPM_TS_MBOX_TS_H (SSPM_TS_MBOX_OFFSET_BASE + 2)
#define SSPM_TS_MBOX_TS_L (SSPM_TS_MBOX_OFFSET_BASE + 3)
#define SSPM_TS_MBOX_DEBUG_TS_H (SSPM_TS_MBOX_OFFSET_BASE + 4)
#define SSPM_TS_MBOX_DEBUG_TS_L (SSPM_TS_MBOX_OFFSET_BASE + 5)
void sspm_timesync_suspend(void);
void sspm_timesync_resume(void);
unsigned int __init sspm_timesync_init(void);
#endif // _SSPM_TIMESYNC_H_