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

+52
View File
@@ -0,0 +1,52 @@
config MEDIATEK_MC
bool "MediaTek Memory Controller support"
depends on MEMORY
select MEDIATEK_DRAMC
select MEDIATEK_EMI
help
This driver supports the Memory Controller (MC) hardware found on
MediaTek(R) SoCs. The config selects MEDIATEK_DRAMC and MEDIATEK_EMI
for the control of DRAMC and EMI drivers respectively. This config
will be enabled by default for MTK SoC.
config MEDIATEK_DRAMC
tristate "MediaTek DRAMC driver"
help
This selects the MediaTek(R) DRAMC driver.
Provide the API for DRAMC low power scenario, and the interface
for reporting DRAM information, e.g. DRAM mode register (MR) for
DRAM vendor ID, temperature, and density.
config HAVE_MTK_MC
bool "MediaTek Memory Controller support"
depends on ARCH_MEDIATEK
help
This driver supports the Memory Controller (MC) hardware found on
MediaTek(R) SoCs. The config enables MTK_DRAMC and MTK_EMI
for the control of DRAMC and EMI drivers respectively. This config
will be enabled by default for MTK SoC.
config MTK_DRAMC
tristate "MediaTek DRAMC driver"
depends on HAVE_MTK_MC
help
This selects the MediaTek(R) DRAMC driver.
Provide the API for DRAMC low power scenario, and the interface
for reporting DRAM information, e.g. DRAM mode register (MR) for
DRAM vendor ID, temperature, and density.
config MTK_EMI
tristate "MediaTek EMI driver"
depends on HAVE_MTK_MC
help
This selects the MediaTek(R) EMI driver.
Provide the API for MPU registration, EMI MPU violation handling,
the API for EMI information, the BWL golden setting,
and the sysfs for EMI ISU control.
config MEDIATEK_EMI
tristate "MediaTek EMI driver"
help
This selects the MediaTek(R) EMI driver.
Provide the API for MPU register and handle EMI MPU violation,
the API for EMI information, and the sysfs for EMI ISU control.
+19
View File
@@ -0,0 +1,19 @@
# SPDX-License-Identifier: GPL-2.0
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include
obj-$(CONFIG_MEDIATEK_DRAMC) += dramc_old.o
obj-$(CONFIG_MEDIATEK_DRAMC) += dramc_bin_old.o
ifeq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6768" "mt6739" "mt6785"))
obj-$(CONFIG_MTK_DRAMC) += dramc.o
obj-$(CONFIG_MTK_DRAMC) += dramc_bin.o
endif
obj-$(CONFIG_MEDIATEK_EMI) += emicen_old.o
obj-$(CONFIG_MEDIATEK_EMI) += emimpu_old.o
obj-$(CONFIG_MEDIATEK_EMI) += emiisu_old.o
ifeq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6768" "mt6785"))
obj-$(CONFIG_MTK_EMI) += emicen.o
obj-$(CONFIG_MTK_EMI) += emimpu.o
obj-$(CONFIG_MTK_EMI) += emiisu.o
endif
+776
View File
@@ -0,0 +1,776 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <memory/mediatek/dramc.h>
static struct platform_device *dramc_pdev;
static int mr4_v1_init(struct platform_device *pdev,
struct mr4_dev_t *mr4_dev_ptr)
{
struct device_node *dramc_node = pdev->dev.of_node;
int ret;
mr4_dev_ptr->version = 1;
ret = of_property_read_u32_array(dramc_node,
"mr4_rg", (unsigned int *)&(mr4_dev_ptr->mr4_rg), 3);
return ret;
}
static int fmeter_v0_init(struct platform_device *pdev,
struct fmeter_dev_t *fmeter_dev_ptr)
{
struct device_node *dramc_node = pdev->dev.of_node;
int ret;
fmeter_dev_ptr->version = 0;
ret = of_property_read_u32(dramc_node,
"crystal_freq", &(fmeter_dev_ptr->crystal_freq));
ret |= of_property_read_u32(dramc_node,
"shu_of", &(fmeter_dev_ptr->shu_of));
ret |= of_property_read_u32_array(dramc_node,
"shu_lv", (unsigned int *)&(fmeter_dev_ptr->shu_lv), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_id", (unsigned int *)&(fmeter_dev_ptr->pll_id), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_md", (unsigned int *)(fmeter_dev_ptr->pll_md), 6);
ret |= of_property_read_u32_array(dramc_node,
"sdmpcw", (unsigned int *)(fmeter_dev_ptr->sdmpcw), 6);
ret |= of_property_read_u32_array(dramc_node,
"prediv", (unsigned int *)(fmeter_dev_ptr->prediv), 6);
ret |= of_property_read_u32_array(dramc_node,
"posdiv", (unsigned int *)(fmeter_dev_ptr->posdiv), 6);
ret |= of_property_read_u32_array(dramc_node,
"ckdiv4", (unsigned int *)(fmeter_dev_ptr->ckdiv4), 6);
ret |= of_property_read_u32_array(dramc_node,
"cldiv2", (unsigned int *)(fmeter_dev_ptr->cldiv2), 6);
return ret;
}
static int fmeter_v1_init(struct platform_device *pdev,
struct fmeter_dev_t *fmeter_dev_ptr)
{
struct device_node *dramc_node = pdev->dev.of_node;
int ret;
fmeter_dev_ptr->version = 1;
ret = of_property_read_u32(dramc_node,
"crystal_freq", &(fmeter_dev_ptr->crystal_freq));
ret |= of_property_read_u32(dramc_node,
"shu_of", &(fmeter_dev_ptr->shu_of));
ret |= of_property_read_u32_array(dramc_node,
"shu_lv", (unsigned int *)&(fmeter_dev_ptr->shu_lv), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_id", (unsigned int *)&(fmeter_dev_ptr->pll_id), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_md", (unsigned int *)(fmeter_dev_ptr->pll_md), 6);
ret |= of_property_read_u32_array(dramc_node,
"sdmpcw", (unsigned int *)(fmeter_dev_ptr->sdmpcw), 6);
ret |= of_property_read_u32_array(dramc_node,
"prediv", (unsigned int *)(fmeter_dev_ptr->prediv), 6);
ret |= of_property_read_u32_array(dramc_node,
"posdiv", (unsigned int *)(fmeter_dev_ptr->posdiv), 6);
ret |= of_property_read_u32_array(dramc_node,
"ckdiv4", (unsigned int *)(fmeter_dev_ptr->ckdiv4), 6);
ret |= of_property_read_u32_array(dramc_node,
"cldiv2", (unsigned int *)(fmeter_dev_ptr->cldiv2), 6);
ret |= of_property_read_u32_array(dramc_node,
"fbksel", (unsigned int *)(fmeter_dev_ptr->fbksel), 6);
ret |= of_property_read_u32_array(dramc_node,
"dqopen", (unsigned int *)(fmeter_dev_ptr->dqopen), 6);
return ret;
}
static ssize_t mr_show(struct device_driver *driver, char *buf)
{
struct dramc_dev_t *dramc_dev_ptr;
struct mr_info_t *mr_info_ptr;
unsigned int i;
ssize_t ret;
if (!dramc_pdev)
return strlen(buf);
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
mr_info_ptr = dramc_dev_ptr->mr_info_ptr;
for (ret = 0, i = 0; i < dramc_dev_ptr->mr_cnt; i++) {
ret += snprintf(buf + ret, PAGE_SIZE - ret, "mr%d: 0x%x\n",
mr_info_ptr[i].mr_index, mr_info_ptr[i].mr_value);
if (ret >= PAGE_SIZE)
return strlen(buf);
}
return strlen(buf);
}
static ssize_t mr4_show(struct device_driver *driver, char *buf)
{
struct dramc_dev_t *dramc_dev_ptr;
unsigned int i;
ssize_t ret;
if (!dramc_pdev)
return strlen(buf);
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
for (ret = 0, i = 0; i < dramc_dev_ptr->ch_cnt; i++) {
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"mr4: ch%d 0x%x\n", i, mtk_dramc_get_mr4(i));
if (ret >= PAGE_SIZE)
return strlen(buf);
}
return strlen(buf);
}
static ssize_t dram_data_rate_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "DRAM data rate = %d\n",
mtk_dramc_get_data_rate());
}
__weak int mtk_dramc_binning_test(void)
{
return 0;
}
static ssize_t binning_test_show(struct device_driver *driver, char *buf)
{
int ret;
ret = mtk_dramc_binning_test();
if (!ret)
return snprintf(buf, PAGE_SIZE, "unsupport mem test\n");
else if (ret > 0)
return snprintf(buf, PAGE_SIZE, "mem test all pass\n");
else
return snprintf(buf, PAGE_SIZE, "mem test failed %d\n", ret);
}
static DRIVER_ATTR_RO(mr);
static DRIVER_ATTR_RO(mr4);
static DRIVER_ATTR_RO(dram_data_rate);
static DRIVER_ATTR_RO(binning_test);
static int dramc_probe(struct platform_device *pdev)
{
struct device_node *dramc_node = pdev->dev.of_node;
struct dramc_dev_t *dramc_dev_ptr;
unsigned int mr4_version;
unsigned int fmeter_version;
struct resource *res;
unsigned int i, size;
int ret;
pr_info("%s: module probe.\n", __func__);
dramc_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct dramc_dev_t), GFP_KERNEL);
if (!dramc_dev_ptr)
return -ENOMEM;
ret = of_property_read_u32(dramc_node,
"dram_type", &(dramc_dev_ptr->dram_type));
if (ret) {
pr_err("%s: get dram_type fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"support_ch_cnt", &(dramc_dev_ptr->support_ch_cnt));
if (ret) {
pr_err("%s: get support_ch_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"ch_cnt", &(dramc_dev_ptr->ch_cnt));
if (ret) {
pr_err("%s: get ch_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"rk_cnt", &(dramc_dev_ptr->rk_cnt));
if (ret) {
pr_err("%s: get rk_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"mr_cnt", &(dramc_dev_ptr->mr_cnt));
if (ret) {
pr_err("%s: get mr_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"freq_cnt", &(dramc_dev_ptr->freq_cnt));
if (ret) {
pr_err("%s: get freq_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node, "mr4_version", &mr4_version);
if (ret)
pr_info("%s: not support mr4\n", __func__);
else if (mr4_version == 1) {
dramc_dev_ptr->mr4_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct mr4_dev_t), GFP_KERNEL);
if (!(dramc_dev_ptr->mr4_dev_ptr))
return -ENOMEM;
ret = mr4_v1_init(pdev,
(struct mr4_dev_t *)(dramc_dev_ptr->mr4_dev_ptr));
if (ret) {
pr_err("%s: mr4_v1_init fail\n", __func__);
return -EINVAL;
}
} else
dramc_dev_ptr->mr4_dev_ptr = NULL;
pr_info("%s: %s(%d),%s(%d),%s(%d),%s(%d),%s(%d),%s(%d),%s(%s)\n",
__func__,
"dram_type", dramc_dev_ptr->dram_type,
"support_ch_cnt", dramc_dev_ptr->support_ch_cnt,
"ch_cnt", dramc_dev_ptr->ch_cnt,
"rk_cnt", dramc_dev_ptr->rk_cnt,
"mr_cnt", dramc_dev_ptr->mr_cnt,
"freq_cnt", dramc_dev_ptr->freq_cnt,
"mr4", (dramc_dev_ptr->mr4_dev_ptr) ? "true" : "false");
size = sizeof(unsigned int) * dramc_dev_ptr->rk_cnt;
dramc_dev_ptr->rk_size = devm_kmalloc(&pdev->dev, size, GFP_KERNEL);
if (!(dramc_dev_ptr->rk_size))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node,
"rk_size", dramc_dev_ptr->rk_size, dramc_dev_ptr->rk_cnt);
if (ret) {
pr_err("%s: get rk_size fail\n", __func__);
return -EINVAL;
}
size = sizeof(struct mr_info_t) * dramc_dev_ptr->mr_cnt;
dramc_dev_ptr->mr_info_ptr = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->mr_info_ptr))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node, "mr",
(unsigned int *)dramc_dev_ptr->mr_info_ptr, size >> 2);
if (ret) {
pr_err("%s: get mr_info fail\n", __func__);
return -EINVAL;
}
for (i = 0; i < dramc_dev_ptr->mr_cnt; i++)
pr_info("%s: mr%d(%x)\n", __func__,
dramc_dev_ptr->mr_info_ptr[i].mr_index,
dramc_dev_ptr->mr_info_ptr[i].mr_value);
size = sizeof(unsigned int) * dramc_dev_ptr->freq_cnt;
dramc_dev_ptr->freq_step = devm_kmalloc(&pdev->dev, size, GFP_KERNEL);
if (!(dramc_dev_ptr->freq_step))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node, "freq_step",
dramc_dev_ptr->freq_step, dramc_dev_ptr->freq_cnt);
if (ret) {
pr_err("%s: get freq_step fail\n", __func__);
return -EINVAL;
}
dramc_dev_ptr->sleep_base = of_iomap(dramc_node,
dramc_dev_ptr->support_ch_cnt * 4);
if (IS_ERR(dramc_dev_ptr->sleep_base)) {
pr_err("%s: unable to map sleep base\n", __func__);
return -EINVAL;
}
size = sizeof(phys_addr_t) * dramc_dev_ptr->support_ch_cnt;
dramc_dev_ptr->dramc_chn_base_ao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->dramc_chn_base_ao))
return -ENOMEM;
dramc_dev_ptr->dramc_chn_base_nao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->dramc_chn_base_nao))
return -ENOMEM;
dramc_dev_ptr->ddrphy_chn_base_ao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->ddrphy_chn_base_ao))
return -ENOMEM;
dramc_dev_ptr->ddrphy_chn_base_nao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->ddrphy_chn_base_nao))
return -ENOMEM;
for (i = 0; i < dramc_dev_ptr->support_ch_cnt; i++) {
res = platform_get_resource(pdev, IORESOURCE_MEM, i);
dramc_dev_ptr->dramc_chn_base_ao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->dramc_chn_base_ao[i])) {
pr_err("%s: unable to map ch%d DRAMC AO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt);
dramc_dev_ptr->dramc_chn_base_nao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->dramc_chn_base_nao[i])) {
pr_err("%s: unable to map ch%d DRAMC NAO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt * 2);
dramc_dev_ptr->ddrphy_chn_base_ao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->ddrphy_chn_base_ao[i])) {
pr_err("%s: unable to map ch%d DDRPHY AO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt * 3);
dramc_dev_ptr->ddrphy_chn_base_nao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->ddrphy_chn_base_nao[i])) {
pr_err("%s: unable to map ch%d DDRPHY NAO base\n",
__func__, i);
return -EINVAL;
}
}
ret = of_property_read_u32(
dramc_node, "fmeter_version", &fmeter_version);
if (ret) {
pr_err("%s: get fmeter_version fail\n", __func__);
return -EINVAL;
}
pr_info("%s: fmeter_version(%d)\n", __func__, fmeter_version);
dramc_dev_ptr->fmeter_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct fmeter_dev_t), GFP_KERNEL);
if (!(dramc_dev_ptr->fmeter_dev_ptr)) {
pr_info("%s: memory alloc fail\n", __func__);
return -ENOMEM;
}
switch (fmeter_version) {
case 0:
ret = fmeter_v0_init(pdev, dramc_dev_ptr->fmeter_dev_ptr);
if (ret) {
pr_err("%s: fmeter_v0_init fail\n", __func__);
return -EINVAL;
}
break;
case 1:
ret = fmeter_v1_init(pdev, dramc_dev_ptr->fmeter_dev_ptr);
if (ret) {
pr_err("%s: fmeter_v1_init fail\n", __func__);
return -EINVAL;
}
break;
default:
devm_kfree(&pdev->dev, dramc_dev_ptr->fmeter_dev_ptr);
dramc_dev_ptr->fmeter_dev_ptr = NULL;
}
ret = driver_create_file(
pdev->dev.driver, &driver_attr_binning_test);
if (ret) {
pr_info("%s: fail to create binning_test sysfs\n", __func__);
return ret;
}
ret = driver_create_file(
pdev->dev.driver, &driver_attr_dram_data_rate);
if (ret) {
pr_err("%s: fail to create dram_data_rate sysfs\n", __func__);
return ret;
}
ret = driver_create_file(
pdev->dev.driver, &driver_attr_mr);
if (ret) {
pr_err("%s: fail to create mr sysfs\n", __func__);
return ret;
}
if (dramc_dev_ptr->mr4_dev_ptr) {
ret = driver_create_file(
pdev->dev.driver, &driver_attr_mr4);
if (ret) {
pr_err("%s: fail to create mr4 sysfs\n", __func__);
return ret;
}
}
platform_set_drvdata(pdev, dramc_dev_ptr);
dramc_pdev = pdev;
pr_info("%s: DRAM data type = %d\n", __func__,
mtk_dramc_get_ddr_type());
pr_info("%s: DRAM data rate = %d\n", __func__,
mtk_dramc_get_data_rate());
return ret;
}
static int dramc_remove(struct platform_device *dev)
{
return 0;
}
static const struct of_device_id dramc_of_ids[] = {
{.compatible = "mediatek,common-dramc",},
{}
};
static struct platform_driver dramc_drv = {
.probe = dramc_probe,
.remove = dramc_remove,
.driver = {
.name = "dramc_drv",
.owner = THIS_MODULE,
.of_match_table = dramc_of_ids,
},
};
static int __init dramc_drv_init(void)
{
int ret;
ret = platform_driver_register(&dramc_drv);
if (ret) {
pr_err("%s: init fail, ret 0x%x\n", __func__, ret);
return ret;
}
return ret;
}
static void __exit dramc_drv_exit(void)
{
platform_driver_unregister(&dramc_drv);
}
module_init(dramc_drv_init);
module_exit(dramc_drv_exit);
/*
* mtk_dramc_get_steps_freq - get the freq of target DVFS step
* @step: the step index of DVFS
*
* Returns the DRAM freq
*/
int mtk_dramc_get_steps_freq(unsigned int step)
{
struct dramc_dev_t *dramc_dev_ptr;
if (!dramc_pdev)
return -1;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
if (step < dramc_dev_ptr->freq_cnt)
return dramc_dev_ptr->freq_step[step];
return -1;
}
EXPORT_SYMBOL(mtk_dramc_get_steps_freq);
static unsigned int decode_freq(unsigned int vco_freq)
{
switch (vco_freq) {
case 4264:
return 4266;
case 3718:
return 3733;
case 3094:
case 3068:
return 3200;
case 2392:
case 2366:
return 2400;
case 1859:
return 1866;
case 1534:
return 1600;
case 1196:
case 1144:
return 1200;
case 819:
case 754:
return 800;
}
return vco_freq;
}
static unsigned int fmeter_v0(struct dramc_dev_t *dramc_dev_ptr)
{
struct fmeter_dev_t *fmeter_dev_ptr =
(struct fmeter_dev_t *)dramc_dev_ptr->fmeter_dev_ptr;
unsigned int shu_lv_val;
unsigned int pll_id_val;
unsigned int pll_md_val;
unsigned int sdmpcw_val;
unsigned int prediv_val;
unsigned int posdiv_val;
unsigned int ckdiv4_val;
unsigned int cldiv2_val;
unsigned int offset;
unsigned int vco_freq;
shu_lv_val = (readl(dramc_dev_ptr->dramc_chn_base_ao[0] +
fmeter_dev_ptr->shu_lv.offset) &
fmeter_dev_ptr->shu_lv.mask) >>
fmeter_dev_ptr->shu_lv.shift;
pll_id_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] +
fmeter_dev_ptr->pll_id.offset) &
fmeter_dev_ptr->pll_id.mask) >>
fmeter_dev_ptr->pll_id.shift;
offset = fmeter_dev_ptr->pll_md[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
pll_md_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->pll_md[pll_id_val].mask) >>
fmeter_dev_ptr->pll_md[pll_id_val].shift;
offset = fmeter_dev_ptr->sdmpcw[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
sdmpcw_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->sdmpcw[pll_id_val].mask) >>
fmeter_dev_ptr->sdmpcw[pll_id_val].shift;
offset = fmeter_dev_ptr->prediv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
prediv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->prediv[pll_id_val].mask) >>
fmeter_dev_ptr->prediv[pll_id_val].shift;
offset = fmeter_dev_ptr->posdiv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
posdiv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->posdiv[pll_id_val].mask) >>
fmeter_dev_ptr->posdiv[pll_id_val].shift;
offset = fmeter_dev_ptr->ckdiv4[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
ckdiv4_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->ckdiv4[pll_id_val].mask) >>
fmeter_dev_ptr->ckdiv4[pll_id_val].shift;
offset = fmeter_dev_ptr->cldiv2[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
cldiv2_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->cldiv2[pll_id_val].mask) >>
fmeter_dev_ptr->cldiv2[pll_id_val].shift;
vco_freq = ((fmeter_dev_ptr->crystal_freq >> prediv_val) *
(sdmpcw_val >> 8)) >> posdiv_val >> ckdiv4_val >>
pll_md_val >> cldiv2_val;
return decode_freq(vco_freq);
}
static unsigned int fmeter_v1(struct dramc_dev_t *dramc_dev_ptr)
{
struct fmeter_dev_t *fmeter_dev_ptr =
(struct fmeter_dev_t *)dramc_dev_ptr->fmeter_dev_ptr;
unsigned int shu_lv_val;
unsigned int pll_id_val;
unsigned int pll_md_val;
unsigned int sdmpcw_val;
unsigned int prediv_val;
unsigned int posdiv_val;
unsigned int ckdiv4_val;
unsigned int cldiv2_val;
unsigned int offset;
unsigned int vco_freq;
unsigned int fbksel;
unsigned int dqopen;
shu_lv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_nao[0] +
fmeter_dev_ptr->shu_lv.offset) &
fmeter_dev_ptr->shu_lv.mask) >>
fmeter_dev_ptr->shu_lv.shift;
pll_id_val = (readl(dramc_dev_ptr->ddrphy_chn_base_nao[0] +
fmeter_dev_ptr->pll_id.offset) &
fmeter_dev_ptr->pll_id.mask) >>
fmeter_dev_ptr->pll_id.shift;
offset = fmeter_dev_ptr->pll_md[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
pll_md_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->pll_md[pll_id_val].mask) >>
fmeter_dev_ptr->pll_md[pll_id_val].shift;
offset = fmeter_dev_ptr->sdmpcw[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
sdmpcw_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->sdmpcw[pll_id_val].mask) >>
fmeter_dev_ptr->sdmpcw[pll_id_val].shift;
offset = fmeter_dev_ptr->prediv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
prediv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->prediv[pll_id_val].mask) >>
fmeter_dev_ptr->prediv[pll_id_val].shift;
offset = fmeter_dev_ptr->posdiv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
posdiv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->posdiv[pll_id_val].mask) >>
fmeter_dev_ptr->posdiv[pll_id_val].shift;
offset = fmeter_dev_ptr->ckdiv4[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
ckdiv4_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->ckdiv4[pll_id_val].mask) >>
fmeter_dev_ptr->ckdiv4[pll_id_val].shift;
offset = fmeter_dev_ptr->cldiv2[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
cldiv2_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->cldiv2[pll_id_val].mask) >>
fmeter_dev_ptr->cldiv2[pll_id_val].shift;
offset = fmeter_dev_ptr->fbksel[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
fbksel = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->fbksel[pll_id_val].mask) >>
fmeter_dev_ptr->fbksel[pll_id_val].shift;
offset = fmeter_dev_ptr->dqopen[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
dqopen = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->dqopen[pll_id_val].mask) >>
fmeter_dev_ptr->dqopen[pll_id_val].shift;
vco_freq = ((fmeter_dev_ptr->crystal_freq >> prediv_val) *
(sdmpcw_val >> 8)) >> posdiv_val >> ckdiv4_val >>
pll_md_val >> cldiv2_val << fbksel >> (dqopen << 1);
return decode_freq(vco_freq);
}
/*
* mtk_dramc_get_data_rate - calculate DRAM data rate
*
* Returns DRAM data rate (MB/s)
*/
unsigned int mtk_dramc_get_data_rate(void)
{
struct dramc_dev_t *dramc_dev_ptr;
struct fmeter_dev_t *fmeter_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
fmeter_dev_ptr = (struct fmeter_dev_t *)dramc_dev_ptr->fmeter_dev_ptr;
if (!fmeter_dev_ptr)
return 0;
switch (fmeter_dev_ptr->version) {
case 0:
return fmeter_v0(dramc_dev_ptr);
case 1:
return fmeter_v1(dramc_dev_ptr);
}
return 0;
}
EXPORT_SYMBOL(mtk_dramc_get_data_rate);
static unsigned int mr4_v1(struct dramc_dev_t *dramc_dev_ptr, unsigned int ch)
{
struct mr4_dev_t *mr4_dev_ptr =
(struct mr4_dev_t *)dramc_dev_ptr->mr4_dev_ptr;
return (readl(dramc_dev_ptr->dramc_chn_base_nao[ch] +
mr4_dev_ptr->mr4_rg.offset) & mr4_dev_ptr->mr4_rg.mask) >>
mr4_dev_ptr->mr4_rg.shift;
}
/*
* mtk_dramc_get_mr4 - get the DRAM MR4 value of specific DRAM channel
* @ch: the channel index
*
* Returns the MR4 value
*/
unsigned int mtk_dramc_get_mr4(unsigned int ch)
{
struct dramc_dev_t *dramc_dev_ptr;
struct mr4_dev_t *mr4_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
mr4_dev_ptr = (struct mr4_dev_t *)dramc_dev_ptr->mr4_dev_ptr;
if (!mr4_dev_ptr)
return 0;
if (ch >= dramc_dev_ptr->ch_cnt)
return 0;
if (mr4_dev_ptr->version == 1)
return mr4_v1(dramc_dev_ptr, ch);
return 0;
}
EXPORT_SYMBOL(mtk_dramc_get_mr4);
/*
* mtk_dramc_get_ddr_type - get DRAM type
*
* Returns the DRAM type
*/
unsigned int mtk_dramc_get_ddr_type(void)
{
struct dramc_dev_t *dramc_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
return dramc_dev_ptr->dram_type;
}
EXPORT_SYMBOL(mtk_dramc_get_ddr_type);
MODULE_DESCRIPTION("MediaTek DRAMC Driver v0.1");
+373
View File
@@ -0,0 +1,373 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/printk.h>
#include <linux/vmalloc.h>
#define MEM_TEST_SIZE 0x2000
#define PATTERN1 0x5A5A5A5A
#define PATTERN2 0xA5A5A5A5
int mtk_dramc_binning_test(void)
{
unsigned char *mem8_base;
unsigned short *mem16_base;
unsigned int *mem32_base;
unsigned int *mem_base;
unsigned long mem_ptr;
unsigned char pattern8;
unsigned short pattern16;
unsigned int i, j, size, pattern32;
unsigned int value;
unsigned int len = MEM_TEST_SIZE;
void *ptr;
int ret = 1;
ptr = vmalloc(len);
if (!ptr) {
ret = -24;
goto fail;
}
mem8_base = (unsigned char *)ptr;
mem16_base = (unsigned short *)ptr;
mem32_base = (unsigned int *)ptr;
mem_base = (unsigned int *)ptr;
/* pr_info("Test DRAM start address 0x%lx\n", (unsigned long)ptr); */
pr_info("Test DRAM start address %p\n", ptr);
pr_info("Test DRAM SIZE 0x%x\n", len);
size = len >> 2;
/* === test the tied bits (tied high) === */
for (i = 0; i < size; i++)
mem32_base[i] = 0;
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0) {
/* return -1; */
ret = -1;
goto fail;
} else
mem32_base[i] = 0xffffffff;
}
/* === test the tied bits (tied low) === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffffffff) {
/* return -2; */
ret = -2;
goto fail;
} else
mem32_base[i] = 0x00;
}
/* === test pattern 1 (0x00~0xff) === */
pattern8 = 0x00;
for (i = 0; i < len; i++)
mem8_base[i] = pattern8++;
pattern8 = 0x00;
for (i = 0; i < len; i++) {
if (mem8_base[i] != pattern8++) {
/* return -3; */
ret = -3;
goto fail;
}
}
/* === test pattern 2 (0x00~0xff) === */
pattern8 = 0x00;
for (i = j = 0; i < len; i += 2, j++) {
if (mem8_base[i] == pattern8)
mem16_base[j] = pattern8;
if (mem16_base[j] != pattern8) {
/* return -4; */
ret = -4;
goto fail;
}
pattern8 += 2;
}
/* === test pattern 3 (0x00~0xffff) === */
pattern16 = 0x00;
for (i = 0; i < (len >> 1); i++)
mem16_base[i] = pattern16++;
pattern16 = 0x00;
for (i = 0; i < (len >> 1); i++) {
if (mem16_base[i] != pattern16++) {
/* return -5; */
ret = -5;
goto fail;
}
}
/* === test pattern 4 (0x00~0xffffffff) === */
pattern32 = 0x00;
for (i = 0; i < (len >> 2); i++)
mem32_base[i] = pattern32++;
pattern32 = 0x00;
for (i = 0; i < (len >> 2); i++) {
if (mem32_base[i] != pattern32++) {
/* return -6; */
ret = -6;
goto fail;
}
}
/* === Pattern 5: Filling memory range with 0x44332211 === */
for (i = 0; i < size; i++)
mem32_base[i] = 0x44332211;
/* === Read Check then Fill Memory with a5a5a5a5 Pattern === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0x44332211) {
/* return -7; */
ret = -7;
goto fail;
} else {
mem32_base[i] = 0xa5a5a5a5;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 0h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5a5a5a5) {
/* return -8; */
ret = -8;
goto fail;
} else {
mem8_base[i * 4] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 2h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5a5a500) {
/* return -9; */
ret = -9;
goto fail;
} else {
mem8_base[i * 4 + 2] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 1h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa500a500) {
/* return -10; */
ret = -10;
goto fail;
} else {
mem8_base[i * 4 + 1] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 3h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5000000) {
/* return -11; */
ret = -11;
goto fail;
} else {
mem8_base[i * 4 + 3] = 0x00;
}
}
/* === Read Check then Fill Memory with ffff */
/* Word Pattern at offset 1h == */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0x00000000) {
/* return -12; */
ret = -12;
goto fail;
} else {
mem16_base[i * 2 + 1] = 0xffff;
}
}
/* === Read Check then Fill Memory with ffff */
/* Word Pattern at offset 0h == */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffff0000) {
/* return -13; */
ret = -13;
goto fail;
} else {
mem16_base[i * 2] = 0xffff;
}
}
/*=== Read Check === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffffffff) {
/* return -14; */
ret = -14;
goto fail;
}
}
/************************************************
* Additional verification
************************************************/
/* === stage 1 => write 0 === */
for (i = 0; i < size; i++)
mem_base[i] = PATTERN1;
/* === stage 2 => read 0, write 0xF === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -15; */
ret = -15;
goto fail;
}
mem_base[i] = PATTERN2;
}
/* === stage 3 => read 0xF, write 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN2) {
/* return -16; */
ret = -16;
goto fail;
}
mem_base[i] = PATTERN1;
}
/* === stage 4 => read 0, write 0xF === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -17; */
ret = -17;
goto fail;
}
mem_base[i] = PATTERN2;
}
/* === stage 5 => read 0xF, write 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN2) {
/* return -18; */
ret = -18;
goto fail;
}
mem_base[i] = PATTERN1;
}
/* === stage 6 => read 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -19; */
ret = -19;
goto fail;
}
}
/* === 1/2/4-byte combination test === */
mem_ptr = (unsigned long)mem_base;
while (mem_ptr < ((unsigned long)mem_base + (size << 2))) {
*((unsigned char *)mem_ptr) = 0x78;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x56;
mem_ptr += 1;
*((unsigned short *)mem_ptr) = 0x1234;
mem_ptr += 2;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned short *)mem_ptr) = 0x5678;
mem_ptr += 2;
*((unsigned char *)mem_ptr) = 0x34;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x12;
mem_ptr += 1;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned char *)mem_ptr) = 0x78;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x56;
mem_ptr += 1;
*((unsigned short *)mem_ptr) = 0x1234;
mem_ptr += 2;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned short *)mem_ptr) = 0x5678;
mem_ptr += 2;
*((unsigned char *)mem_ptr) = 0x34;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x12;
mem_ptr += 1;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
}
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != 0x12345678) {
/* return -20; */
ret = -20;
goto fail;
}
}
/* === Verify pattern 1 (0x00~0xff) === */
pattern8 = 0x00;
mem8_base[0] = pattern8;
for (i = 0; i < size * 4; i++) {
unsigned char waddr8, raddr8;
waddr8 = i + 1;
raddr8 = i;
if (i < size * 4 - 1)
mem8_base[waddr8] = pattern8 + 1;
if (mem8_base[raddr8] != pattern8) {
/* return -21; */
ret = -21;
goto fail;
}
pattern8++;
}
/* === Verify pattern 2 (0x00~0xffff) === */
pattern16 = 0x00;
mem16_base[0] = pattern16;
for (i = 0; i < size * 2; i++) {
if (i < size * 2 - 1)
mem16_base[i + 1] = pattern16 + 1;
if (mem16_base[i] != pattern16) {
/* return -22; */
ret = -22;
goto fail;
}
pattern16++;
}
/* === Verify pattern 3 (0x00~0xffffffff) === */
pattern32 = 0x00;
mem32_base[0] = pattern32;
for (i = 0; i < size; i++) {
if (i < size - 1)
mem32_base[i + 1] = pattern32 + 1;
if (mem32_base[i] != pattern32) {
/* return -23; */
ret = -23;
goto fail;
}
pattern32++;
}
pr_info("complex R/W mem test pass\n");
fail:
vfree(ptr);
return ret;
}
+373
View File
@@ -0,0 +1,373 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/printk.h>
#include <linux/vmalloc.h>
#define MEM_TEST_SIZE 0x2000
#define PATTERN1 0x5A5A5A5A
#define PATTERN2 0xA5A5A5A5
int mtk_dramc_binning_test(void)
{
unsigned char *mem8_base;
unsigned short *mem16_base;
unsigned int *mem32_base;
unsigned int *mem_base;
unsigned long mem_ptr;
unsigned char pattern8;
unsigned short pattern16;
unsigned int i, j, size, pattern32;
unsigned int value;
unsigned int len = MEM_TEST_SIZE;
void *ptr;
int ret = 1;
ptr = vmalloc(len);
if (!ptr) {
ret = -24;
goto fail;
}
mem8_base = (unsigned char *)ptr;
mem16_base = (unsigned short *)ptr;
mem32_base = (unsigned int *)ptr;
mem_base = (unsigned int *)ptr;
/* pr_info("Test DRAM start address 0x%lx\n", (unsigned long)ptr); */
pr_info("Test DRAM start address %p\n", ptr);
pr_info("Test DRAM SIZE 0x%x\n", len);
size = len >> 2;
/* === test the tied bits (tied high) === */
for (i = 0; i < size; i++)
mem32_base[i] = 0;
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0) {
/* return -1; */
ret = -1;
goto fail;
} else
mem32_base[i] = 0xffffffff;
}
/* === test the tied bits (tied low) === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffffffff) {
/* return -2; */
ret = -2;
goto fail;
} else
mem32_base[i] = 0x00;
}
/* === test pattern 1 (0x00~0xff) === */
pattern8 = 0x00;
for (i = 0; i < len; i++)
mem8_base[i] = pattern8++;
pattern8 = 0x00;
for (i = 0; i < len; i++) {
if (mem8_base[i] != pattern8++) {
/* return -3; */
ret = -3;
goto fail;
}
}
/* === test pattern 2 (0x00~0xff) === */
pattern8 = 0x00;
for (i = j = 0; i < len; i += 2, j++) {
if (mem8_base[i] == pattern8)
mem16_base[j] = pattern8;
if (mem16_base[j] != pattern8) {
/* return -4; */
ret = -4;
goto fail;
}
pattern8 += 2;
}
/* === test pattern 3 (0x00~0xffff) === */
pattern16 = 0x00;
for (i = 0; i < (len >> 1); i++)
mem16_base[i] = pattern16++;
pattern16 = 0x00;
for (i = 0; i < (len >> 1); i++) {
if (mem16_base[i] != pattern16++) {
/* return -5; */
ret = -5;
goto fail;
}
}
/* === test pattern 4 (0x00~0xffffffff) === */
pattern32 = 0x00;
for (i = 0; i < (len >> 2); i++)
mem32_base[i] = pattern32++;
pattern32 = 0x00;
for (i = 0; i < (len >> 2); i++) {
if (mem32_base[i] != pattern32++) {
/* return -6; */
ret = -6;
goto fail;
}
}
/* === Pattern 5: Filling memory range with 0x44332211 === */
for (i = 0; i < size; i++)
mem32_base[i] = 0x44332211;
/* === Read Check then Fill Memory with a5a5a5a5 Pattern === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0x44332211) {
/* return -7; */
ret = -7;
goto fail;
} else {
mem32_base[i] = 0xa5a5a5a5;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 0h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5a5a5a5) {
/* return -8; */
ret = -8;
goto fail;
} else {
mem8_base[i * 4] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 2h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5a5a500) {
/* return -9; */
ret = -9;
goto fail;
} else {
mem8_base[i * 4 + 2] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 1h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa500a500) {
/* return -10; */
ret = -10;
goto fail;
} else {
mem8_base[i * 4 + 1] = 0x00;
}
}
/* === Read Check then Fill Memory with */
/* 00 Byte Pattern at offset 3h === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xa5000000) {
/* return -11; */
ret = -11;
goto fail;
} else {
mem8_base[i * 4 + 3] = 0x00;
}
}
/* === Read Check then Fill Memory with ffff */
/* Word Pattern at offset 1h == */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0x00000000) {
/* return -12; */
ret = -12;
goto fail;
} else {
mem16_base[i * 2 + 1] = 0xffff;
}
}
/* === Read Check then Fill Memory with ffff */
/* Word Pattern at offset 0h == */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffff0000) {
/* return -13; */
ret = -13;
goto fail;
} else {
mem16_base[i * 2] = 0xffff;
}
}
/*=== Read Check === */
for (i = 0; i < size; i++) {
if (mem32_base[i] != 0xffffffff) {
/* return -14; */
ret = -14;
goto fail;
}
}
/************************************************
* Additional verification
************************************************/
/* === stage 1 => write 0 === */
for (i = 0; i < size; i++)
mem_base[i] = PATTERN1;
/* === stage 2 => read 0, write 0xF === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -15; */
ret = -15;
goto fail;
}
mem_base[i] = PATTERN2;
}
/* === stage 3 => read 0xF, write 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN2) {
/* return -16; */
ret = -16;
goto fail;
}
mem_base[i] = PATTERN1;
}
/* === stage 4 => read 0, write 0xF === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -17; */
ret = -17;
goto fail;
}
mem_base[i] = PATTERN2;
}
/* === stage 5 => read 0xF, write 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN2) {
/* return -18; */
ret = -18;
goto fail;
}
mem_base[i] = PATTERN1;
}
/* === stage 6 => read 0 === */
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != PATTERN1) {
/* return -19; */
ret = -19;
goto fail;
}
}
/* === 1/2/4-byte combination test === */
mem_ptr = (unsigned long)mem_base;
while (mem_ptr < ((unsigned long)mem_base + (size << 2))) {
*((unsigned char *)mem_ptr) = 0x78;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x56;
mem_ptr += 1;
*((unsigned short *)mem_ptr) = 0x1234;
mem_ptr += 2;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned short *)mem_ptr) = 0x5678;
mem_ptr += 2;
*((unsigned char *)mem_ptr) = 0x34;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x12;
mem_ptr += 1;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned char *)mem_ptr) = 0x78;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x56;
mem_ptr += 1;
*((unsigned short *)mem_ptr) = 0x1234;
mem_ptr += 2;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
*((unsigned short *)mem_ptr) = 0x5678;
mem_ptr += 2;
*((unsigned char *)mem_ptr) = 0x34;
mem_ptr += 1;
*((unsigned char *)mem_ptr) = 0x12;
mem_ptr += 1;
*((unsigned int *)mem_ptr) = 0x12345678;
mem_ptr += 4;
}
for (i = 0; i < size; i++) {
value = mem_base[i];
if (value != 0x12345678) {
/* return -20; */
ret = -20;
goto fail;
}
}
/* === Verify pattern 1 (0x00~0xff) === */
pattern8 = 0x00;
mem8_base[0] = pattern8;
for (i = 0; i < size * 4; i++) {
unsigned char waddr8, raddr8;
waddr8 = i + 1;
raddr8 = i;
if (i < size * 4 - 1)
mem8_base[waddr8] = pattern8 + 1;
if (mem8_base[raddr8] != pattern8) {
/* return -21; */
ret = -21;
goto fail;
}
pattern8++;
}
/* === Verify pattern 2 (0x00~0xffff) === */
pattern16 = 0x00;
mem16_base[0] = pattern16;
for (i = 0; i < size * 2; i++) {
if (i < size * 2 - 1)
mem16_base[i + 1] = pattern16 + 1;
if (mem16_base[i] != pattern16) {
/* return -22; */
ret = -22;
goto fail;
}
pattern16++;
}
/* === Verify pattern 3 (0x00~0xffffffff) === */
pattern32 = 0x00;
mem32_base[0] = pattern32;
for (i = 0; i < size; i++) {
if (i < size - 1)
mem32_base[i + 1] = pattern32 + 1;
if (mem32_base[i] != pattern32) {
/* return -23; */
ret = -23;
goto fail;
}
pattern32++;
}
pr_info("complex R/W mem test pass\n");
fail:
vfree(ptr);
return ret;
}
+681
View File
@@ -0,0 +1,681 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/interrupt.h>
#include <memory/mediatek/dramc.h>
#include <linux/bug.h>
static struct platform_device *dramc_pdev;
static struct platform_driver dramc_drv;
static int mr4_v1_init(struct platform_device *pdev,
struct mr4_dev_t *mr4_dev_ptr)
{
struct device_node *dramc_node = pdev->dev.of_node;
int ret;
mr4_dev_ptr->version = 1;
ret = of_property_read_u32_array(dramc_node,
"mr4_rg", (unsigned int *)&(mr4_dev_ptr->mr4_rg), 3);
return ret;
}
static int fmeter_v1_init(struct platform_device *pdev,
struct fmeter_dev_t *fmeter_dev_ptr)
{
struct device_node *dramc_node = pdev->dev.of_node;
int ret;
fmeter_dev_ptr->version = 1;
ret = of_property_read_u32(dramc_node,
"crystal_freq", &(fmeter_dev_ptr->crystal_freq));
ret |= of_property_read_u32(dramc_node,
"shu_of", &(fmeter_dev_ptr->shu_of));
ret |= of_property_read_u32_array(dramc_node,
"shu_lv", (unsigned int *)&(fmeter_dev_ptr->shu_lv), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_id", (unsigned int *)&(fmeter_dev_ptr->pll_id), 3);
ret |= of_property_read_u32_array(dramc_node,
"pll_md", (unsigned int *)(fmeter_dev_ptr->pll_md), 6);
ret |= of_property_read_u32_array(dramc_node,
"sdmpcw", (unsigned int *)(fmeter_dev_ptr->sdmpcw), 6);
ret |= of_property_read_u32_array(dramc_node,
"prediv", (unsigned int *)(fmeter_dev_ptr->prediv), 6);
ret |= of_property_read_u32_array(dramc_node,
"posdiv", (unsigned int *)(fmeter_dev_ptr->posdiv), 6);
ret |= of_property_read_u32_array(dramc_node,
"ckdiv4", (unsigned int *)(fmeter_dev_ptr->ckdiv4), 6);
ret |= of_property_read_u32_array(dramc_node,
"cldiv2", (unsigned int *)(fmeter_dev_ptr->cldiv2), 6);
ret |= of_property_read_u32_array(dramc_node,
"fbksel", (unsigned int *)(fmeter_dev_ptr->fbksel), 6);
ret |= of_property_read_u32_array(dramc_node,
"dqsopen", (unsigned int *)(fmeter_dev_ptr->dqsopen), 6);
ret |= of_property_read_u32_array(dramc_node,
"dqopen", (unsigned int *)(fmeter_dev_ptr->dqopen), 6);
ret |= of_property_read_u32_array(dramc_node,
"ckdiv4_ca", (unsigned int *)(fmeter_dev_ptr->ckdiv4_ca), 6);
return ret;
}
static ssize_t mr_show(struct device_driver *driver, char *buf)
{
struct dramc_dev_t *dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
struct mr_info_t *mr_info_ptr = dramc_dev_ptr->mr_info_ptr;
unsigned int i;
ssize_t ret;
for (ret = 0, i = 0; i < dramc_dev_ptr->mr_cnt; i++) {
ret += snprintf(buf + ret, PAGE_SIZE - ret, "mr%d: 0x%x\n",
mr_info_ptr[i].mr_index, mr_info_ptr[i].mr_value);
if (ret >= PAGE_SIZE)
return strlen(buf);
}
return strlen(buf);
}
static ssize_t mr4_show(struct device_driver *driver, char *buf)
{
struct dramc_dev_t *dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
unsigned int i;
ssize_t ret;
for (ret = 0, i = 0; i < dramc_dev_ptr->ch_cnt; i++) {
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"mr4: ch%d 0x%x\n", i, mtk_dramc_get_mr4(i));
if (ret >= PAGE_SIZE)
return strlen(buf);
}
return strlen(buf);
}
static ssize_t dram_data_rate_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "DRAM data rate = %d\n",
mtk_dramc_get_data_rate());
}
__weak int mtk_dramc_binning_test(void)
{
return 0;
}
static ssize_t binning_test_show(struct device_driver *driver, char *buf)
{
int ret;
ret = mtk_dramc_binning_test();
if (!ret)
return snprintf(buf, PAGE_SIZE, "unsupport mem test\n");
else if (ret > 0)
return snprintf(buf, PAGE_SIZE, "mem test all pass\n");
else
return snprintf(buf, PAGE_SIZE, "mem test failed %d\n", ret);
}
static DRIVER_ATTR_RO(mr);
static DRIVER_ATTR_RO(mr4);
static DRIVER_ATTR_RO(dram_data_rate);
static DRIVER_ATTR_RO(binning_test);
static int dramc_probe(struct platform_device *pdev)
{
struct device_node *dramc_node = pdev->dev.of_node;
struct dramc_dev_t *dramc_dev_ptr;
unsigned int mr4_version;
unsigned int fmeter_version;
struct resource *res;
unsigned int i, size;
int ret;
pr_info("%s: module probe.\n", __func__);
dramc_pdev = pdev;
dramc_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct dramc_dev_t), GFP_KERNEL);
if (!dramc_dev_ptr)
return -ENOMEM;
ret = of_property_read_u32(dramc_node,
"dram_type", &(dramc_dev_ptr->dram_type));
if (ret) {
pr_info("%s: get dram_type fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"support_ch_cnt", &(dramc_dev_ptr->support_ch_cnt));
if (ret) {
pr_info("%s: get support_ch_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"ch_cnt", &(dramc_dev_ptr->ch_cnt));
if (ret) {
pr_info("%s: get ch_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"rk_cnt", &(dramc_dev_ptr->rk_cnt));
if (ret) {
pr_info("%s: get rk_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"mr_cnt", &(dramc_dev_ptr->mr_cnt));
if (ret) {
pr_info("%s: get mr_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node,
"freq_cnt", &(dramc_dev_ptr->freq_cnt));
if (ret) {
pr_info("%s: get freq_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(dramc_node, "mr4_version", &mr4_version);
if (ret)
pr_info("%s: not support mr4\n", __func__);
else if (mr4_version == 1) {
dramc_dev_ptr->mr4_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct mr4_dev_t), GFP_KERNEL);
if (!(dramc_dev_ptr->mr4_dev_ptr))
return -ENOMEM;
ret = mr4_v1_init(pdev,
(struct mr4_dev_t *)(dramc_dev_ptr->mr4_dev_ptr));
if (ret) {
pr_info("%s: mr4_v1_init fail\n", __func__);
return -EINVAL;
}
} else
dramc_dev_ptr->mr4_dev_ptr = NULL;
pr_info("%s: %s(%d),%s(%d),%s(%d),%s(%d),%s(%d),%s(%d),%s(%s)\n",
__func__,
"dram_type", dramc_dev_ptr->dram_type,
"support_ch_cnt", dramc_dev_ptr->support_ch_cnt,
"ch_cnt", dramc_dev_ptr->ch_cnt,
"rk_cnt", dramc_dev_ptr->rk_cnt,
"mr_cnt", dramc_dev_ptr->mr_cnt,
"freq_cnt", dramc_dev_ptr->freq_cnt,
"mr4", (dramc_dev_ptr->mr4_dev_ptr) ? "true" : "false");
size = sizeof(unsigned int) * dramc_dev_ptr->rk_cnt;
dramc_dev_ptr->rk_size = devm_kmalloc(&pdev->dev, size, GFP_KERNEL);
if (!(dramc_dev_ptr->rk_size))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node,
"rk_size", dramc_dev_ptr->rk_size, dramc_dev_ptr->rk_cnt);
if (ret) {
pr_info("%s: get rk_size fail\n", __func__);
return -EINVAL;
}
size = sizeof(struct mr_info_t) * dramc_dev_ptr->mr_cnt;
dramc_dev_ptr->mr_info_ptr = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->mr_info_ptr))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node, "mr",
(unsigned int *)dramc_dev_ptr->mr_info_ptr, size >> 2);
if (ret) {
pr_info("%s: get mr_info fail\n", __func__);
return -EINVAL;
}
for (i = 0; i < dramc_dev_ptr->mr_cnt; i++)
pr_info("%s: mr%d(%x)\n", __func__,
dramc_dev_ptr->mr_info_ptr[i].mr_index,
dramc_dev_ptr->mr_info_ptr[i].mr_value);
size = sizeof(unsigned int) * dramc_dev_ptr->freq_cnt;
dramc_dev_ptr->freq_step = devm_kmalloc(&pdev->dev, size, GFP_KERNEL);
if (!(dramc_dev_ptr->freq_step))
return -ENOMEM;
ret = of_property_read_u32_array(dramc_node, "freq_step",
dramc_dev_ptr->freq_step, dramc_dev_ptr->freq_cnt);
if (ret) {
pr_info("%s: get freq_step fail\n", __func__);
return -EINVAL;
}
dramc_dev_ptr->sleep_base = of_iomap(dramc_node,
dramc_dev_ptr->support_ch_cnt * 4);
if (IS_ERR(dramc_dev_ptr->sleep_base)) {
pr_info("%s: unable to map sleep base\n", __func__);
return -EINVAL;
}
size = sizeof(phys_addr_t) * dramc_dev_ptr->support_ch_cnt;
dramc_dev_ptr->dramc_chn_base_ao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->dramc_chn_base_ao))
return -ENOMEM;
dramc_dev_ptr->dramc_chn_base_nao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->dramc_chn_base_nao))
return -ENOMEM;
dramc_dev_ptr->ddrphy_chn_base_ao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->ddrphy_chn_base_ao))
return -ENOMEM;
dramc_dev_ptr->ddrphy_chn_base_nao = devm_kmalloc(&pdev->dev,
size, GFP_KERNEL);
if (!(dramc_dev_ptr->ddrphy_chn_base_nao))
return -ENOMEM;
for (i = 0; i < dramc_dev_ptr->support_ch_cnt; i++) {
res = platform_get_resource(pdev, IORESOURCE_MEM, i);
dramc_dev_ptr->dramc_chn_base_ao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->dramc_chn_base_ao[i])) {
pr_info("%s: unable to map ch%d DRAMC AO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt);
dramc_dev_ptr->dramc_chn_base_nao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->dramc_chn_base_nao[i])) {
pr_info("%s: unable to map ch%d DRAMC NAO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt * 2);
dramc_dev_ptr->ddrphy_chn_base_ao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->ddrphy_chn_base_ao[i])) {
pr_info("%s: unable to map ch%d DDRPHY AO base\n",
__func__, i);
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM,
i + dramc_dev_ptr->support_ch_cnt * 3);
dramc_dev_ptr->ddrphy_chn_base_nao[i] =
devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(dramc_dev_ptr->ddrphy_chn_base_nao[i])) {
pr_info("%s: unable to map ch%d DDRPHY NAO base\n",
__func__, i);
return -EINVAL;
}
}
ret = of_property_read_u32(
dramc_node, "fmeter_version", &fmeter_version);
if (ret) {
pr_info("%s: get fmeter_version fail\n", __func__);
return -EINVAL;
}
pr_info("%s: fmeter_version(%d)\n", __func__, fmeter_version);
if (fmeter_version == 1) {
dramc_dev_ptr->fmeter_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct fmeter_dev_t), GFP_KERNEL);
if (!(dramc_dev_ptr->fmeter_dev_ptr)) {
pr_info("%s: memory alloc fail\n", __func__);
return -ENOMEM;
}
ret = fmeter_v1_init(pdev, dramc_dev_ptr->fmeter_dev_ptr);
if (ret) {
pr_info("%s: fmeter_init fail\n", __func__);
return -EINVAL;
}
} else
dramc_dev_ptr->fmeter_dev_ptr = NULL;
ret = driver_create_file(
pdev->dev.driver, &driver_attr_binning_test);
if (ret) {
pr_info("%s: fail to create binning_test sysfs\n", __func__);
return ret;
}
ret = driver_create_file(
pdev->dev.driver, &driver_attr_dram_data_rate);
if (ret) {
pr_info("%s: fail to create dram_data_rate sysfs\n", __func__);
return ret;
}
ret = driver_create_file(
pdev->dev.driver, &driver_attr_mr);
if (ret) {
pr_info("%s: fail to create mr sysfs\n", __func__);
return ret;
}
if (dramc_dev_ptr->mr4_dev_ptr) {
ret = driver_create_file(
pdev->dev.driver, &driver_attr_mr4);
if (ret) {
pr_info("%s: fail to create mr4 sysfs\n", __func__);
return ret;
}
}
platform_set_drvdata(pdev, dramc_dev_ptr);
pr_info("%s: DRAM data type = %d\n", __func__,
mtk_dramc_get_ddr_type());
pr_info("%s: DRAM data rate = %d\n", __func__,
mtk_dramc_get_data_rate());
return ret;
}
static int dramc_remove(struct platform_device *dev)
{
return 0;
}
static const struct of_device_id dramc_of_ids[] = {
{.compatible = "mediatek,common-dramc",},
{}
};
static struct platform_driver dramc_drv = {
.probe = dramc_probe,
.remove = dramc_remove,
.driver = {
.name = "dramc_drv",
.owner = THIS_MODULE,
.of_match_table = dramc_of_ids,
},
};
static int __init dramc_drv_init(void)
{
int ret;
ret = platform_driver_register(&dramc_drv);
if (ret) {
pr_info("%s: init fail, ret 0x%x\n", __func__, ret);
return ret;
}
return ret;
}
static void __exit dramc_drv_exit(void)
{
platform_driver_unregister(&dramc_drv);
}
module_init(dramc_drv_init);
module_exit(dramc_drv_exit);
/*
* mtk_dramc_get_steps_freq - get the freq of target DVFS step
* @step: the step index of DVFS
*
* Returns the DRAM freq
*/
int mtk_dramc_get_steps_freq(unsigned int step)
{
struct dramc_dev_t *dramc_dev_ptr;
if (!dramc_pdev)
return -1;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
if (step < dramc_dev_ptr->freq_cnt)
return dramc_dev_ptr->freq_step[step];
return -1;
}
EXPORT_SYMBOL(mtk_dramc_get_steps_freq);
static unsigned int decode_freq(unsigned int vco_freq)
{
switch (vco_freq) {
case 5460:
return 5500;
case 4264:
return 4266;
case 3718:
case 3588:
return 3733;
case 3068:
return 3200;
case 2652:
return 2667;
case 2366:
return 2400;
case 1859:
case 1794:
return 1866;
case 1534:
return 1600;
case 1144:
case 1196:
return 1200;
case 754:
case 799:
return 800;
case 396:
return 400;
}
return vco_freq;
}
static unsigned int fmeter_v1(struct dramc_dev_t *dramc_dev_ptr)
{
struct fmeter_dev_t *fmeter_dev_ptr =
(struct fmeter_dev_t *)dramc_dev_ptr->fmeter_dev_ptr;
unsigned int shu_lv_val;
unsigned int pll_id_val;
unsigned int pll_md_val;
unsigned int sdmpcw_val;
unsigned int prediv_val;
unsigned int posdiv_val;
unsigned int ckdiv4_val;
unsigned int cldiv2_val;
unsigned int offset;
unsigned int vco_freq;
unsigned int fbksel;
unsigned int dqsopen;
unsigned int dqopen;
unsigned int ckdiv4_ca_val;
shu_lv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_nao[0] +
fmeter_dev_ptr->shu_lv.offset) &
fmeter_dev_ptr->shu_lv.mask) >>
fmeter_dev_ptr->shu_lv.shift;
pll_id_val = (readl(dramc_dev_ptr->ddrphy_chn_base_nao[0] +
fmeter_dev_ptr->pll_id.offset) &
fmeter_dev_ptr->pll_id.mask) >>
fmeter_dev_ptr->pll_id.shift;
offset = fmeter_dev_ptr->pll_md[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
pll_md_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->pll_md[pll_id_val].mask) >>
fmeter_dev_ptr->pll_md[pll_id_val].shift;
offset = fmeter_dev_ptr->sdmpcw[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
sdmpcw_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->sdmpcw[pll_id_val].mask) >>
fmeter_dev_ptr->sdmpcw[pll_id_val].shift;
offset = fmeter_dev_ptr->prediv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
prediv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->prediv[pll_id_val].mask) >>
fmeter_dev_ptr->prediv[pll_id_val].shift;
offset = fmeter_dev_ptr->posdiv[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
posdiv_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->posdiv[pll_id_val].mask) >>
fmeter_dev_ptr->posdiv[pll_id_val].shift;
offset = fmeter_dev_ptr->ckdiv4[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
ckdiv4_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->ckdiv4[pll_id_val].mask) >>
fmeter_dev_ptr->ckdiv4[pll_id_val].shift;
offset = fmeter_dev_ptr->cldiv2[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
cldiv2_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->cldiv2[pll_id_val].mask) >>
fmeter_dev_ptr->cldiv2[pll_id_val].shift;
offset = fmeter_dev_ptr->fbksel[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
fbksel = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->fbksel[pll_id_val].mask) >>
fmeter_dev_ptr->fbksel[pll_id_val].shift;
offset = fmeter_dev_ptr->dqsopen[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
dqsopen = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->dqsopen[pll_id_val].mask) >>
fmeter_dev_ptr->dqsopen[pll_id_val].shift;
offset = fmeter_dev_ptr->dqopen[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
dqopen = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->dqopen[pll_id_val].mask) >>
fmeter_dev_ptr->dqopen[pll_id_val].shift;
offset = fmeter_dev_ptr->ckdiv4_ca[pll_id_val].offset +
fmeter_dev_ptr->shu_of * shu_lv_val;
ckdiv4_ca_val = (readl(dramc_dev_ptr->ddrphy_chn_base_ao[0] + offset) &
fmeter_dev_ptr->ckdiv4_ca[pll_id_val].mask) >>
fmeter_dev_ptr->ckdiv4_ca[pll_id_val].shift;
vco_freq = ((fmeter_dev_ptr->crystal_freq >> prediv_val) *
(sdmpcw_val >> 8)) >> posdiv_val >> ckdiv4_val >>
pll_md_val >> cldiv2_val << fbksel;
if ((dqsopen == 1 || dqopen == 1) && (ckdiv4_ca_val == 1))
vco_freq >>= 2;
else if ((dqsopen == 1 || dqopen == 1) && (ckdiv4_ca_val == 0))
vco_freq >>= 1;
return decode_freq(vco_freq);
}
/*
* mtk_dramc_get_data_rate - calculate DRAM data rate
*
* Returns DRAM data rate (MB/s)
*/
unsigned int mtk_dramc_get_data_rate(void)
{
struct dramc_dev_t *dramc_dev_ptr;
struct fmeter_dev_t *fmeter_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
fmeter_dev_ptr = (struct fmeter_dev_t *)dramc_dev_ptr->fmeter_dev_ptr;
if (!fmeter_dev_ptr)
return 0;
if (fmeter_dev_ptr->version == 1)
return fmeter_v1(dramc_dev_ptr);
return 0;
}
EXPORT_SYMBOL(mtk_dramc_get_data_rate);
static unsigned int mr4_v1(struct dramc_dev_t *dramc_dev_ptr, unsigned int ch)
{
struct mr4_dev_t *mr4_dev_ptr =
(struct mr4_dev_t *)dramc_dev_ptr->mr4_dev_ptr;
return (readl(dramc_dev_ptr->dramc_chn_base_nao[ch] +
mr4_dev_ptr->mr4_rg.offset) & mr4_dev_ptr->mr4_rg.mask) >>
mr4_dev_ptr->mr4_rg.shift;
}
/*
* mtk_dramc_get_mr4 - get the DRAM MR4 value of specific DRAM channel
* @ch: the channel index
*
* Returns the MR4 value
*/
unsigned int mtk_dramc_get_mr4(unsigned int ch)
{
struct dramc_dev_t *dramc_dev_ptr;
struct mr4_dev_t *mr4_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
mr4_dev_ptr = (struct mr4_dev_t *)dramc_dev_ptr->mr4_dev_ptr;
if (!mr4_dev_ptr)
return 0;
if (ch >= dramc_dev_ptr->ch_cnt)
return 0;
if (mr4_dev_ptr->version == 1)
return mr4_v1(dramc_dev_ptr, ch);
return 0;
}
EXPORT_SYMBOL(mtk_dramc_get_mr4);
/*
* mtk_dramc_get_ddr_type - get DRAM type
*
* Returns the DRAM type
*/
unsigned int mtk_dramc_get_ddr_type(void)
{
struct dramc_dev_t *dramc_dev_ptr;
if (!dramc_pdev)
return 0;
dramc_dev_ptr =
(struct dramc_dev_t *)platform_get_drvdata(dramc_pdev);
return dramc_dev_ptr->dram_type;
}
EXPORT_SYMBOL(mtk_dramc_get_ddr_type);
MODULE_DESCRIPTION("MediaTek DRAMC Driver v0.1");
+226
View File
@@ -0,0 +1,226 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk_sip_svc.h>
#include <memory/mediatek/emi.h>
DEFINE_SPINLOCK(emidbg_lock);
static struct platform_device *emicen_pdev;
static int emicen_probe(struct platform_device *pdev)
{
struct device_node *emicen_node = pdev->dev.of_node;
struct device_node *emichn_node =
of_parse_phandle(emicen_node, "mediatek,emi-reg", 0);
struct emicen_dev_t *emicen_dev_ptr;
unsigned int i;
int ret;
pr_info("%s: module probe.\n", __func__);
emicen_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct emicen_dev_t), GFP_KERNEL);
if (!emicen_dev_ptr)
return -ENOMEM;
ret = of_property_read_u32(emicen_node,
"ch_cnt", &(emicen_dev_ptr->ch_cnt));
if (ret) {
pr_info("%s: get ch_cnt fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u32(emicen_node,
"rk_cnt", &(emicen_dev_ptr->rk_cnt));
if (ret) {
pr_info("%s: get rk_cnt fail\n", __func__);
return -EINVAL;
}
pr_info("%s: %s(%d), %s(%d)\n", __func__,
"ch_cnt", emicen_dev_ptr->ch_cnt,
"rk_cnt", emicen_dev_ptr->rk_cnt);
emicen_dev_ptr->rk_size = devm_kmalloc_array(&pdev->dev,
emicen_dev_ptr->rk_cnt, sizeof(unsigned long long),
GFP_KERNEL);
if (!(emicen_dev_ptr->rk_size))
return -ENOMEM;
ret = of_property_read_u64_array(emicen_node,
"rk_size", emicen_dev_ptr->rk_size, emicen_dev_ptr->rk_cnt);
for (i = 0; i < emicen_dev_ptr->rk_cnt; i++)
pr_info("%s: rk_size%d(0x%llx)\n", __func__,
i, emicen_dev_ptr->rk_size[i]);
ret = of_property_count_elems_of_size(
emicen_node, "reg", sizeof(unsigned int) * 4);
if (ret <= 0) {
pr_info("%s: get emi_cen_cnt fail\n", __func__);
return -EINVAL;
}
emicen_dev_ptr->emi_cen_cnt = (unsigned int)ret;
emicen_dev_ptr->emi_cen_base = devm_kmalloc_array(&pdev->dev,
emicen_dev_ptr->emi_cen_cnt, sizeof(phys_addr_t), GFP_KERNEL);
if (!(emicen_dev_ptr->emi_cen_base))
return -ENOMEM;
for (i = 0; i < emicen_dev_ptr->emi_cen_cnt; i++)
emicen_dev_ptr->emi_cen_base[i] = of_iomap(emicen_node, i);
emicen_dev_ptr->emi_chn_base = devm_kmalloc_array(&pdev->dev,
emicen_dev_ptr->ch_cnt, sizeof(phys_addr_t), GFP_KERNEL);
if (!(emicen_dev_ptr->emi_chn_base))
return -ENOMEM;
for (i = 0; i < emicen_dev_ptr->ch_cnt; i++)
emicen_dev_ptr->emi_chn_base[i] = of_iomap(emichn_node, i);
platform_set_drvdata(pdev, emicen_dev_ptr);
emicen_pdev = pdev;
return 0;
}
static int emicen_remove(struct platform_device *dev)
{
return 0;
}
static const struct of_device_id emicen_of_ids[] = {
{.compatible = "mediatek,common-emicen",},
{}
};
static struct platform_driver emicen_drv = {
.probe = emicen_probe,
.remove = emicen_remove,
.driver = {
.name = "emicen_drv",
.owner = THIS_MODULE,
.of_match_table = emicen_of_ids,
},
};
static int __init emicen_drv_init(void)
{
int ret;
ret = platform_driver_register(&emicen_drv);
if (ret) {
pr_info("%s: init fail, ret 0x%x\n", __func__, ret);
return ret;
}
return ret;
}
static void __exit emicen_drv_exit(void)
{
platform_driver_unregister(&emicen_drv);
}
module_init(emicen_drv_init);
module_exit(emicen_drv_exit);
/*
* mtk_emicen_get_ch_cnt - get the channel count
*
* Returns the channel count
*/
unsigned int mtk_emicen_get_ch_cnt(void)
{
struct emicen_dev_t *emicen_dev_ptr;
if (!emicen_pdev)
return 0;
emicen_dev_ptr =
(struct emicen_dev_t *)platform_get_drvdata(emicen_pdev);
return emicen_dev_ptr->ch_cnt;
}
EXPORT_SYMBOL(mtk_emicen_get_ch_cnt);
/*
* mtk_emicen_get_rk_cnt - get the rank count
*
* Returns the rank count
*/
unsigned int mtk_emicen_get_rk_cnt(void)
{
struct emicen_dev_t *emicen_dev_ptr;
if (!emicen_pdev)
return 0;
emicen_dev_ptr =
(struct emicen_dev_t *)platform_get_drvdata(emicen_pdev);
return emicen_dev_ptr->rk_cnt;
}
EXPORT_SYMBOL(mtk_emicen_get_rk_cnt);
/*
* mtk_emicen_get_rk_size - get the rank size of target rank
* @rk_id: the id of target rank
*
* Returns the rank size of target rank
*/
unsigned int mtk_emicen_get_rk_size(unsigned int rk_id)
{
struct emicen_dev_t *emicen_dev_ptr;
if (!emicen_pdev)
return 0;
emicen_dev_ptr =
(struct emicen_dev_t *)platform_get_drvdata(emicen_pdev);
if (rk_id < emicen_dev_ptr->rk_cnt)
return emicen_dev_ptr->rk_size[rk_id];
return 0;
}
EXPORT_SYMBOL(mtk_emicen_get_rk_size);
/*
* mtk_emidbg_dump - dump emi full status to atf log
*
*/
void mtk_emidbg_dump(void)
{
unsigned long spinlock_save_flags;
struct arm_smccc_res smc_res;
spin_lock_irqsave(&emidbg_lock, spinlock_save_flags);
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIDBG_DUMP,
0, 0, 0, 0, 0, 0, &smc_res);
while (smc_res.a0 > 0) {
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIDBG_MSG,
0, 0, 0, 0, 0, 0, &smc_res);
pr_info("%s: %d, 0x%x, 0x%x, 0x%x\n", __func__,
(int)smc_res.a0,
(unsigned int)smc_res.a1,
(unsigned int)smc_res.a2,
(unsigned int)smc_res.a3);
}
spin_unlock_irqrestore(&emidbg_lock, spinlock_save_flags);
}
EXPORT_SYMBOL(mtk_emidbg_dump);
MODULE_DESCRIPTION("MediaTek EMICEN Driver v0.1");
File diff suppressed because it is too large. Load diff
+282
View File
@@ -0,0 +1,282 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <memory/mediatek/emi.h>
static struct platform_device *emiisu_pdev;
static int emiisu_probe(struct platform_device *pdev);
static ssize_t emiisu_ctrl_show(struct device_driver *driver, char *buf)
{
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned int state;
if (!emiisu_pdev)
return 0;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
if (!(emiisu_dev_ptr->con_addr))
return 0;
state = readl(emiisu_dev_ptr->con_addr);
return snprintf(buf, PAGE_SIZE, "isu_state: 0x%x\n", state);
}
static ssize_t emiisu_ctrl_store
(struct device_driver *driver, const char *buf, size_t count)
{
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned long state;
char *command;
char *backup_command;
char *ptr;
char *token[MTK_EMI_MAX_TOKEN];
int i;
if (!emiisu_pdev)
return count;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
if (!(emiisu_dev_ptr->ctrl_intf))
return count;
if (!(emiisu_dev_ptr->con_addr))
return count;
if ((strlen(buf) + 1) > MTK_EMI_MAX_CMD_LEN) {
pr_info("%s: store command overflow\n", __func__);
return count;
}
command = kmalloc((size_t)MTK_EMI_MAX_CMD_LEN, GFP_KERNEL);
if (!command)
return count;
backup_command = command;
strncpy(command, buf, (size_t)MTK_EMI_MAX_CMD_LEN);
for (i = 0; i < MTK_EMI_MAX_TOKEN; i++) {
ptr = strsep(&command, " ");
if (!ptr)
break;
token[i] = ptr;
}
if (i < 1)
goto emiisu_ctrl_store_end;
if (kstrtoul(token[0], 16, &state) == 0)
writel((unsigned int)state, emiisu_dev_ptr->con_addr);
emiisu_ctrl_store_end:
kfree(backup_command);
return count;
}
static DRIVER_ATTR_RW(emiisu_ctrl);
static ssize_t dump_buf_read
(struct file *file, char __user *data, size_t len, loff_t *ppos)
{
struct emiisu_dev_t *emiisu_dev_ptr;
ssize_t bytes;
ssize_t header_bytes = 0;
if (!emiisu_pdev)
return 0;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
bytes = len < (emiisu_dev_ptr->buf_size - *ppos) ?
len : (emiisu_dev_ptr->buf_size - *ppos);
if (!(emiisu_dev_ptr->buf_addr))
return 0;
if (!(emiisu_dev_ptr->ver_addr))
return 0;
if (*ppos == 0) {
if (copy_to_user(data, (char *)(emiisu_dev_ptr->ver_addr), 4)
|| (bytes < 4))
return -EFAULT;
data += 4;
header_bytes += 4;
bytes -= 4;
}
if (bytes) {
if (copy_to_user(data, (char *)(emiisu_dev_ptr->buf_addr) +
*ppos, bytes))
return -EFAULT;
}
*ppos += bytes;
return (bytes + header_bytes);
}
static int dump_buf_open(struct inode *inode, struct file *file)
{
return nonseekable_open(inode, file);
}
static const struct file_operations dump_buf_fops = {
.owner = THIS_MODULE,
.read = dump_buf_read,
.open = dump_buf_open
};
static int emiisu_remove(struct platform_device *dev)
{
return 0;
}
static const struct of_device_id emiisu_of_ids[] = {
{.compatible = "mediatek,common-emiisu",},
{}
};
static struct platform_driver emiisu_drv = {
.probe = emiisu_probe,
.remove = emiisu_remove,
.driver = {
.name = "emiisu_drv",
.owner = THIS_MODULE,
.of_match_table = emiisu_of_ids,
},
};
static int emiisu_probe(struct platform_device *pdev)
{
struct device_node *emiisu_node = pdev->dev.of_node;
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned long long addr_temp;
int ret;
pr_info("%s: module probe.\n", __func__);
emiisu_pdev = pdev;
emiisu_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct emiisu_dev_t), GFP_KERNEL);
if (!emiisu_dev_ptr)
return -ENOMEM;
ret = of_property_read_u32(emiisu_node,
"buf_size", &(emiisu_dev_ptr->buf_size));
if (ret) {
pr_info("%s: get buf_size fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u64(emiisu_node, "buf_addr", &addr_temp);
if (ret) {
pr_info("%s: get buf_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->buf_addr = ioremap_wc(
(phys_addr_t)addr_temp, emiisu_dev_ptr->buf_size);
else
emiisu_dev_ptr->buf_addr = NULL;
ret = of_property_read_u64(emiisu_node, "ver_addr", &addr_temp);
if (ret) {
pr_info("%s: get ver_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->ver_addr = ioremap((phys_addr_t)addr_temp, 4);
else
emiisu_dev_ptr->ver_addr = NULL;
ret = of_property_read_u64(emiisu_node, "con_addr", &addr_temp);
if (ret) {
pr_info("%s: get con_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->con_addr = ioremap((phys_addr_t)addr_temp, 4);
else
emiisu_dev_ptr->con_addr = NULL;
ret = of_property_read_u32(emiisu_node,
"ctrl_intf", &(emiisu_dev_ptr->ctrl_intf));
if (ret) {
pr_info("%s: get ctrl_intf fail\n", __func__);
return -EINVAL;
}
pr_info("%s: %s(%x),%s(%lx),%s(%lx),%s(%lx),%s(%d)\n", __func__,
"buf_size", emiisu_dev_ptr->buf_size,
"buf_addr", (unsigned long)(emiisu_dev_ptr->buf_addr),
"ver_addr", (unsigned long)(emiisu_dev_ptr->ver_addr),
"con_addr", (unsigned long)(emiisu_dev_ptr->con_addr),
"ctrl_intf", emiisu_dev_ptr->ctrl_intf);
emiisu_dev_ptr->dump_dir = debugfs_create_dir("emi_mbw", NULL);
if (!emiisu_dev_ptr->dump_dir) {
pr_info("%s: fail to create dump_dir\n", __func__);
return -EINVAL;
}
emiisu_dev_ptr->dump_buf = debugfs_create_file("dump_buf", 0444,
emiisu_dev_ptr->dump_dir, NULL, &dump_buf_fops);
if (!emiisu_dev_ptr->dump_buf) {
pr_info("%s: fail to create dump_buf\n", __func__);
return -EINVAL;
}
platform_set_drvdata(pdev, emiisu_dev_ptr);
ret = driver_create_file(&emiisu_drv.driver,
&driver_attr_emiisu_ctrl);
if (ret)
pr_info("%s: fail to create emiisu_ctrl\n", __func__);
return ret;
}
static int __init emiisu_drv_init(void)
{
int ret;
ret = platform_driver_register(&emiisu_drv);
if (ret) {
pr_info("%s: init fail, ret 0x%x\n", __func__, ret);
return ret;
}
return ret;
}
static void __exit emiisu_drv_exit(void)
{
platform_driver_unregister(&emiisu_drv);
}
module_init(emiisu_drv_init);
module_exit(emiisu_drv_exit);
MODULE_DESCRIPTION("MediaTek EMIISU Driver v0.1");
+283
View File
@@ -0,0 +1,283 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <memory/mediatek/emi.h>
static struct platform_device *emiisu_pdev;
static int emiisu_probe(struct platform_device *pdev);
static ssize_t emiisu_ctrl_show(struct device_driver *driver, char *buf)
{
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned int state;
if (!emiisu_pdev)
return 0;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
if (!(emiisu_dev_ptr->con_addr))
return 0;
state = readl(emiisu_dev_ptr->con_addr);
return snprintf(buf, PAGE_SIZE, "isu_state: 0x%x\n", state);
}
static ssize_t emiisu_ctrl_store
(struct device_driver *driver, const char *buf, size_t count)
{
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned long state;
char *command;
char *backup_command;
char *ptr;
char *token[MTK_EMI_MAX_TOKEN];
int i;
if (!emiisu_pdev)
return count;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
if (!(emiisu_dev_ptr->ctrl_intf))
return count;
if (!(emiisu_dev_ptr->con_addr))
return count;
if ((strlen(buf) + 1) > MTK_EMI_MAX_CMD_LEN) {
pr_info("%s: store command overflow\n", __func__);
return count;
}
command = kmalloc((size_t)MTK_EMI_MAX_CMD_LEN, GFP_KERNEL);
if (!command)
return count;
backup_command = command;
strncpy(command, buf, (size_t)MTK_EMI_MAX_CMD_LEN);
for (i = 0; i < MTK_EMI_MAX_TOKEN; i++) {
ptr = strsep(&command, " ");
if (!ptr)
break;
token[i] = ptr;
}
if (i < 1)
goto emiisu_ctrl_store_end;
if (kstrtoul(token[0], 16, &state) == 0)
writel((unsigned int)state, emiisu_dev_ptr->con_addr);
emiisu_ctrl_store_end:
kfree(backup_command);
return count;
}
static DRIVER_ATTR_RW(emiisu_ctrl);
static ssize_t dump_buf_read
(struct file *file, char __user *data, size_t len, loff_t *ppos)
{
struct emiisu_dev_t *emiisu_dev_ptr;
ssize_t bytes;
ssize_t header_bytes = 0;
if (!emiisu_pdev)
return 0;
emiisu_dev_ptr =
(struct emiisu_dev_t *)platform_get_drvdata(emiisu_pdev);
bytes = len < (emiisu_dev_ptr->buf_size - *ppos) ?
len : (emiisu_dev_ptr->buf_size - *ppos);
if (!(emiisu_dev_ptr->buf_addr))
return 0;
if (!(emiisu_dev_ptr->ver_addr))
return 0;
if (*ppos == 0) {
if (copy_to_user(data, (char *)(emiisu_dev_ptr->ver_addr), 4)
|| (bytes < 4))
return -EFAULT;
data += 4;
header_bytes += 4;
bytes -= 4;
}
if (bytes) {
if (copy_to_user(data, (char *)(emiisu_dev_ptr->buf_addr) +
*ppos, bytes))
return -EFAULT;
}
*ppos += bytes;
return (bytes + header_bytes);
}
static int dump_buf_open(struct inode *inode, struct file *file)
{
return nonseekable_open(inode, file);
}
static const struct file_operations dump_buf_fops = {
.owner = THIS_MODULE,
.read = dump_buf_read,
.open = dump_buf_open
};
static int emiisu_remove(struct platform_device *dev)
{
return 0;
}
static const struct of_device_id emiisu_of_ids[] = {
{.compatible = "mediatek,common-emiisu",},
{}
};
static struct platform_driver emiisu_drv = {
.probe = emiisu_probe,
.remove = emiisu_remove,
.driver = {
.name = "emiisu_drv",
.owner = THIS_MODULE,
.of_match_table = emiisu_of_ids,
},
};
static int emiisu_probe(struct platform_device *pdev)
{
struct device_node *emiisu_node = pdev->dev.of_node;
struct emiisu_dev_t *emiisu_dev_ptr;
unsigned long long addr_temp;
int ret;
pr_info("%s: module probe.\n", __func__);
emiisu_pdev = pdev;
emiisu_dev_ptr = devm_kmalloc(&pdev->dev,
sizeof(struct emiisu_dev_t), GFP_KERNEL);
if (!emiisu_dev_ptr)
return -ENOMEM;
ret = of_property_read_u32(emiisu_node,
"buf_size", &(emiisu_dev_ptr->buf_size));
if (ret) {
pr_info("%s: get buf_size fail\n", __func__);
return -EINVAL;
}
ret = of_property_read_u64(emiisu_node, "buf_addr", &addr_temp);
if (ret) {
pr_info("%s: get buf_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->buf_addr = ioremap_wc(
(phys_addr_t)addr_temp, emiisu_dev_ptr->buf_size);
else
emiisu_dev_ptr->buf_addr = NULL;
ret = of_property_read_u64(emiisu_node, "ver_addr", &addr_temp);
if (ret) {
pr_info("%s: get ver_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->ver_addr = ioremap((phys_addr_t)addr_temp, 4);
else
emiisu_dev_ptr->ver_addr = NULL;
ret = of_property_read_u64(emiisu_node, "con_addr", &addr_temp);
if (ret) {
pr_info("%s: get con_addr fail\n", __func__);
return -EINVAL;
}
if (addr_temp)
emiisu_dev_ptr->con_addr = ioremap((phys_addr_t)addr_temp, 4);
else
emiisu_dev_ptr->con_addr = NULL;
ret = of_property_read_u32(emiisu_node,
"ctrl_intf", &(emiisu_dev_ptr->ctrl_intf));
if (ret) {
pr_info("%s: get ctrl_intf fail\n", __func__);
return -EINVAL;
}
pr_info("%s: %s(%x),%s(%lx),%s(%lx),%s(%lx),%s(%d)\n", __func__,
"buf_size", emiisu_dev_ptr->buf_size,
"buf_addr", (unsigned long)(emiisu_dev_ptr->buf_addr),
"ver_addr", (unsigned long)(emiisu_dev_ptr->ver_addr),
"con_addr", (unsigned long)(emiisu_dev_ptr->con_addr),
"ctrl_intf", emiisu_dev_ptr->ctrl_intf);
emiisu_dev_ptr->dump_dir = debugfs_create_dir("emi_mbw", NULL);
if (!emiisu_dev_ptr->dump_dir) {
pr_info("%s: fail to create dump_dir\n", __func__);
return -EINVAL;
}
emiisu_dev_ptr->dump_buf = debugfs_create_file("dump_buf", 0444,
emiisu_dev_ptr->dump_dir, NULL, &dump_buf_fops);
if (!emiisu_dev_ptr->dump_buf) {
pr_info("%s: fail to create dump_buf\n", __func__);
return -EINVAL;
}
platform_set_drvdata(pdev, emiisu_dev_ptr);
ret = driver_create_file(&emiisu_drv.driver,
&driver_attr_emiisu_ctrl);
if (ret)
pr_info("%s: fail to create emiisu_ctrl\n", __func__);
return ret;
}
static int __init emiisu_drv_init(void)
{
int ret;
ret = platform_driver_register(&emiisu_drv);
if (ret) {
pr_info("%s: init fail, ret 0x%x\n", __func__, ret);
return ret;
}
return ret;
}
static void __exit emiisu_drv_exit(void)
{
platform_driver_unregister(&emiisu_drv);
}
module_init(emiisu_drv_init);
module_exit(emiisu_drv_exit);
MODULE_DESCRIPTION("MediaTek EMIISU Driver v0.1");
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff