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

+48
View File
@@ -0,0 +1,48 @@
menuconfig MTK_CCCI_DEVICES
bool "CCCI Devices"
default n
help
Say Y here to enable CCCI basic
support. If you say N,
all CCCI related code
(including dummy API) will be disable.
config MTK_MD1_SUPPORT
int "configure modem 1 boot up capability"
depends on MTK_CCCI_DRIVER || MTK_CCCI_EXT || MTK_ECCCI_DRIVER
default 0
help
modem 1 mode:
0=>invalid,
1=>2g,
2=>3g,
3=>wg,
4=>tg,
5=>lwg,
6=>ltg,
7=>sglte,
8=>ultg,
9=>ulwg,
10=>ulwtg,
11=>ulwcg,
12=>ulwctg,
13=>ulttg,
14=>ulfwg,
15=>ulfwcg,
16=>ulctg,
17=>ultctg,
18=>ultwg,
19=>ultwcg,
20=>ulftg,
21=>ulfctg
config MTK_MD3_SUPPORT
int "configure modem 3 boot up capability"
depends on MTK_CCCI_DRIVER || MTK_CCCI_EXT || MTK_ECCCI_DRIVER
default 0
help
modem 3 mode:
1=>2g,
2=>3g,
0=>invalid
+66
View File
@@ -0,0 +1,66 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#FPGA project no need build-in
ifndef CONFIG_MTK_FPGA
# ccci_util is build when ECCCI driver or CCCI driver enabled
ifeq ($(CONFIG_MTK_ECCCI_DRIVER), y)
CCCI_OBJ=y
else ifeq ($(CONFIG_MTK_ECCCI_DRIVER), m)
CCCI_OBJ=m
else
CCCI_OBJ=n
endif
ifneq ($(CONFIG_MTK_ENG_BUILD),y)
ifeq ($(CONFIG_EXTREME_LOW_RAM), y)
ccflags-y += -DCCCI_LOG_DISABLE
endif
endif
ifneq ($(CCCI_OBJ), n)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/ccci_util
ccflags-y += -I$(srctree)/drivers/misc/mediatek/memory-amms
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/
ifeq ($(CONFIG_MTK_SECURITY_SW_SUPPORT), y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/masp/asfv2/asf_export_inc
ccflags-y += -DENABLE_MD_IMG_SECURITY_FEATURE
endif
ifeq ($(CONFIG_MTK_SEC_MODEM_NVRAM_ANTI_CLONE), y)
ccflags-y += -DMTK_SEC_MODEM_NVRAM_ANTI_CLONE
endif
obj-$(CCCI_OBJ) += ccci_util_lib.o
ccci_util_lib-$(CCCI_OBJ) := ccci_util_lib_fo.o \
ccci_util_lib_load_img.o \
ccci_util_lib_sys.o \
ccci_private_log.o \
ccci_util_lib_time.o \
ccci_util_lib_main.o \
ccci_util_ld_md_errno.o \
ccci_util_broadcast.o \
ccci_util_pin_broadcast.o \
ccci_util_sib.o \
ccci_util_md_rat.o
endif
endif
obj-y += CCCI_UTIL_DUMMY.o # avoid build error
CCCI_UTIL_DUMMY-y := ccci_util_dummy.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,682 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2017 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <asm/ioctl.h>
#include <linux/compiler.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif
#include "ccci_util_log.h"
#include "ccci_util_lib_main.h"
/* Broadcast event defination */
struct md_status_event {
struct timeval time_stamp;
int md_id;
int event_type;
char reason[32];
};
#ifdef CONFIG_COMPAT
struct md_status_compat_event {
struct compat_timeval time_stamp;
int md_id;
int event_type;
char reason[32];
};
#endif
#define MD_BC_MAX_NUM (4)
#define MD1_BC_SUPPORT (1<<0)
#define MD3_BC_SUPPORT (1<<2)
#define EVENT_BUFF_SIZE (8)
static struct bc_ctl_block_t *s_bc_ctl_tbl[MD_BC_MAX_NUM];
static spinlock_t s_event_update_lock;
static int s_md1_user_request_lock_cnt;
static int s_md3_user_request_lock_cnt;
static spinlock_t s_md1_user_lock_cnt_lock;
static spinlock_t s_md3_user_lock_cnt_lock;
static struct class *s_ccci_bd_class;
static dev_t s_md_status_dev;
struct cdev s_bd_char_dev;
struct last_md_status_event {
int has_value;
int md_id;
struct timeval time_stamp;
int event_type;
char reason[32];
};
static struct last_md_status_event last_md_status[MAX_MD_NUM];
#define CCCI_UTIL_BC_MAGIC 'B' /*magic */
#define CCCI_IOC_HOLD_RST_LOCK _IO(CCCI_UTIL_BC_MAGIC, 0)
#define CCCI_IOC_FREE_RST_LOCK _IO(CCCI_UTIL_BC_MAGIC, 1)
#define CCCI_IOC_GET_HOLD_RST_CNT _IO(CCCI_UTIL_BC_MAGIC, 2)
#define CCCI_IOC_SHOW_LOCK_USER _IO(CCCI_UTIL_BC_MAGIC, 3)
/* Internal used */
struct bc_ctl_block_t {
struct list_head user_list;
unsigned int md_bit_mask;
wait_queue_head_t wait;
};
struct ccci_util_bc_user_ctlb {
struct bc_ctl_block_t *bc_dev_ptr;
int pending_event_cnt;
int has_request_rst_lock;
int curr_w;
int curr_r;
int buff_cnt;
struct md_status_event event_buf[EVENT_BUFF_SIZE];
int exit;
struct list_head node;
char user_name[32];
};
static void inject_event_helper(struct ccci_util_bc_user_ctlb *user_ctlb,
int md_id, const struct timeval *ev_rtime,
int event_type, char reason[])
{
int ret = 0;
if (user_ctlb->pending_event_cnt == user_ctlb->buff_cnt) {
/* Free one space */
user_ctlb->curr_r++;
user_ctlb->pending_event_cnt--;
if (user_ctlb->curr_r >= user_ctlb->buff_cnt)
user_ctlb->curr_r = 0;
}
if (user_ctlb->curr_w >= EVENT_BUFF_SIZE || user_ctlb->curr_w < 0) {
CCCI_UTIL_ERR_MSG(
"%s(user_ctlb->curr_w = %d)\n", __func__, user_ctlb->curr_w);
return;
}
user_ctlb->event_buf[user_ctlb->curr_w].time_stamp = *ev_rtime;
user_ctlb->event_buf[user_ctlb->curr_w].md_id = md_id;
user_ctlb->event_buf[user_ctlb->curr_w].event_type = event_type;
if (reason != NULL)
ret = snprintf(user_ctlb->event_buf[user_ctlb->curr_w].reason, 32,
"%s", reason);
else
ret = snprintf(user_ctlb->event_buf[user_ctlb->curr_w].reason, 32,
"%s", "----");
if (ret < 0 || ret >= 32) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,ret=%d\n", __func__, __LINE__, ret);
return;
}
user_ctlb->curr_w++;
if (user_ctlb->curr_w >= user_ctlb->buff_cnt)
user_ctlb->curr_w = 0;
user_ctlb->pending_event_cnt++;
}
static void save_last_md_status(int md_id,
const struct timeval *time_stamp, int event_type, char reason[])
{
/* MD_STA_EV_HS1 = 9
* ignore events before MD_STA_EV_HS1
*/
if (event_type < 9 || md_id < 0 || md_id >= MAX_MD_NUM)
return;
CCCI_UTIL_DBG_MSG("[%s] md_id = %d; event_type = %d\n",
__func__, md_id, event_type);
last_md_status[md_id].has_value = 1;
last_md_status[md_id].md_id = md_id;
last_md_status[md_id].time_stamp = *time_stamp;
last_md_status[md_id].event_type = event_type;
if (reason != NULL)
scnprintf(last_md_status[md_id].reason, 32, "%s", reason);
else
scnprintf(last_md_status[md_id].reason, 32, "%s", "----");
}
static void send_last_md_status_to_user(int md_id,
struct ccci_util_bc_user_ctlb *user_ctlb)
{
int i;
CCCI_UTIL_DBG_MSG("[%s] md_id = %d; user_name = %s\n",
__func__, md_id, user_ctlb->user_name);
/* md_id == -1, that means it's ccci_mdx_sta */
for (i = 0; i < MAX_MD_NUM; i++) {
if ((last_md_status[i].has_value == 1) &&
(md_id == -1 || md_id == last_md_status[i].md_id)) {
inject_event_helper(user_ctlb,
last_md_status[i].md_id,
&last_md_status[i].time_stamp,
last_md_status[i].event_type,
last_md_status[i].reason);
}
}
}
void inject_md_status_event(int md_id, int event_type, char reason[])
{
struct timeval time_stamp;
struct ccci_util_bc_user_ctlb *user_ctlb = NULL;
unsigned int md_mark;
int i;
unsigned long flag;
if (md_id == 0)
md_mark = MD1_BC_SUPPORT;
else if (md_id == 2)
md_mark = MD3_BC_SUPPORT;
else
md_mark = 0;
do_gettimeofday(&time_stamp);
spin_lock_irqsave(&s_event_update_lock, flag);
save_last_md_status(md_id, &time_stamp, event_type, reason);
for (i = 0; i < MD_BC_MAX_NUM; i++) {
if (s_bc_ctl_tbl[i]->md_bit_mask & md_mark) {
list_for_each_entry(user_ctlb,
&s_bc_ctl_tbl[i]->user_list, node)
inject_event_helper(user_ctlb, md_id,
&time_stamp, event_type, reason);
wake_up_interruptible(&s_bc_ctl_tbl[i]->wait);
}
}
spin_unlock_irqrestore(&s_event_update_lock, flag);
}
EXPORT_SYMBOL(inject_md_status_event);
int get_lock_rst_user_cnt(int md_id)
{
if (md_id == 0)
return s_md1_user_request_lock_cnt;
else if (md_id == 2)
return s_md3_user_request_lock_cnt;
return 0;
}
int get_lock_rst_user_list(int md_id, char list_buff[], int size)
{
int cpy_size;
int total_size = 0;
struct ccci_util_bc_user_ctlb *user_ctlb = NULL;
unsigned long flag;
if (list_buff == NULL) {
pr_info("ccci: NULL buffer for lock list\r\n");
return 0;
}
if (md_id == 0) {
spin_lock_irqsave(&s_event_update_lock, flag);
list_for_each_entry(user_ctlb,
&s_bc_ctl_tbl[0]->user_list, node) {
if (user_ctlb->has_request_rst_lock) {
cpy_size = scnprintf(&list_buff[total_size],
size - total_size,
"%s,", user_ctlb->user_name);
if (cpy_size > 0)
total_size += cpy_size;
}
}
spin_unlock_irqrestore(&s_event_update_lock, flag);
} else if (md_id == 2) {
spin_lock_irqsave(&s_event_update_lock, flag);
list_for_each_entry(user_ctlb,
&s_bc_ctl_tbl[3]->user_list, node) {
if (user_ctlb->has_request_rst_lock) {
cpy_size = scnprintf(&list_buff[total_size],
size - total_size,
"%s,", user_ctlb->user_name);
if (cpy_size > 0)
total_size += cpy_size;
}
}
spin_unlock_irqrestore(&s_event_update_lock, flag);
}
list_buff[total_size] = 0;
return total_size;
}
static int ccci_util_bc_open(struct inode *inode, struct file *filp)
{
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
int minor;
unsigned long flag;
minor = iminor(inode);
if (minor < 0 || minor >= MD_BC_MAX_NUM) {
CCCI_UTIL_ERR_MSG("invalid minor = %d\n", minor);
return -ENOMEM;
}
bc_dev = s_bc_ctl_tbl[minor];
user_ctlb = kzalloc(sizeof(struct ccci_util_bc_user_ctlb),
GFP_KERNEL);
if (user_ctlb == NULL)
return -ENOMEM;
user_ctlb->bc_dev_ptr = s_bc_ctl_tbl[minor];
user_ctlb->pending_event_cnt = 0;
user_ctlb->has_request_rst_lock = 0;
user_ctlb->curr_w = 0;
user_ctlb->curr_r = 0;
user_ctlb->buff_cnt = EVENT_BUFF_SIZE;
user_ctlb->exit = 0;
INIT_LIST_HEAD(&user_ctlb->node);
scnprintf(user_ctlb->user_name, 32, "%s", current->comm);
filp->private_data = user_ctlb;
nonseekable_open(inode, filp);
spin_lock_irqsave(&s_event_update_lock, flag);
list_add_tail(&user_ctlb->node, &bc_dev->user_list);
send_last_md_status_to_user(minor - 1, user_ctlb);
spin_unlock_irqrestore(&s_event_update_lock, flag);
return 0;
}
static int ccci_util_bc_release(struct inode *inode, struct file *filp)
{
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
unsigned long flag;
user_ctlb = filp->private_data;
bc_dev = user_ctlb->bc_dev_ptr;
user_ctlb->exit = 1;
wake_up_interruptible(&bc_dev->wait);
spin_lock_irqsave(&s_event_update_lock, flag);
user_ctlb->pending_event_cnt = 0;
spin_unlock_irqrestore(&s_event_update_lock, flag);
if (bc_dev->md_bit_mask & MD1_BC_SUPPORT) {
spin_lock(&s_md1_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 1) {
user_ctlb->has_request_rst_lock = 0;
s_md1_user_request_lock_cnt--;
}
spin_unlock(&s_md1_user_lock_cnt_lock);
} else if (bc_dev->md_bit_mask & MD3_BC_SUPPORT) {
spin_lock(&s_md3_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 1) {
user_ctlb->has_request_rst_lock = 0;
s_md3_user_request_lock_cnt--;
}
spin_unlock(&s_md3_user_lock_cnt_lock);
}
spin_lock_irqsave(&s_event_update_lock, flag);
list_del(&user_ctlb->node);
spin_unlock_irqrestore(&s_event_update_lock, flag);
kfree(user_ctlb);
return 0;
}
static ssize_t ccci_util_bc_write(struct file *filp, const char __user *buf,
size_t size, loff_t *ppos)
{
return 0;
}
static int read_out_event(struct ccci_util_bc_user_ctlb *user_ctlb,
struct md_status_event *event)
{
int ret;
struct md_status_event *src_event = NULL;
unsigned long flag;
spin_lock_irqsave(&s_event_update_lock, flag);
if (user_ctlb->pending_event_cnt) {
src_event = &user_ctlb->event_buf[user_ctlb->curr_r];
memcpy(event, src_event, sizeof(struct md_status_event));
user_ctlb->pending_event_cnt--;
ret = 1;
user_ctlb->curr_r++;
if (user_ctlb->curr_r >= user_ctlb->buff_cnt)
user_ctlb->curr_r = 0;
} else
ret = 0;
spin_unlock_irqrestore(&s_event_update_lock, flag);
return ret;
}
static int cpy_compat_event_to_user(char __user *buf, size_t size,
const struct md_status_event *event)
{
unsigned int event_size;
#ifdef CONFIG_COMPAT
struct md_status_compat_event compat_event;
#endif
/*check parameter from user is legal */
if (buf == NULL)
return -EFAULT;
#ifdef CONFIG_COMPAT
if (test_thread_flag(TIF_32BIT) && !COMPAT_USE_64BIT_TIME) {
event_size = sizeof(struct md_status_compat_event);
if (size < event_size)
return -EINVAL;
compat_event.time_stamp.tv_sec = event->time_stamp.tv_sec;
compat_event.time_stamp.tv_usec = event->time_stamp.tv_usec;
compat_event.md_id = event->md_id;
compat_event.event_type = event->event_type;
memcpy(compat_event.reason, event->reason, 32);
if (copy_to_user(buf, &compat_event, event_size))
return -EFAULT;
else
return (ssize_t)event_size;
} else {
#endif
event_size = sizeof(struct md_status_event);
if (copy_to_user(buf, event, event_size))
return -EFAULT;
else
return (ssize_t)event_size;
#ifdef CONFIG_COMPAT
}
#endif
}
static ssize_t ccci_util_bc_read(struct file *filp, char __user *buf,
size_t size, loff_t *ppos)
{
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
struct md_status_event event;
int ret;
int has_data;
user_ctlb = filp->private_data;
bc_dev = user_ctlb->bc_dev_ptr;
has_data = read_out_event(user_ctlb, &event);
/* For Non-block read */
if (filp->f_flags & O_NONBLOCK) {
if (has_data == 0)
return -EAGAIN;
else
return cpy_compat_event_to_user(buf, size, &event);
}
/* For block read */
while (1) {
if (has_data)
return cpy_compat_event_to_user(buf, size, &event);
ret = wait_event_interruptible(bc_dev->wait,
user_ctlb->pending_event_cnt ||
user_ctlb->exit);
if (ret)
return ret;
has_data = read_out_event(user_ctlb, &event);
}
return 0;
}
static long ccci_util_bc_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
int err = 0;
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
int lock_cnt, cpy_size;
char *buf = NULL;
int md_id;
user_ctlb = filp->private_data;
bc_dev = user_ctlb->bc_dev_ptr;
/* check device type and device number */
if (_IOC_TYPE(cmd) != CCCI_UTIL_BC_MAGIC)
return -EINVAL;
switch (cmd) {
case CCCI_IOC_HOLD_RST_LOCK:
if (bc_dev->md_bit_mask & MD1_BC_SUPPORT) {
spin_lock(&s_md1_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 0) {
user_ctlb->has_request_rst_lock = 1;
s_md1_user_request_lock_cnt++;
}
spin_unlock(&s_md1_user_lock_cnt_lock);
} else if (bc_dev->md_bit_mask & MD3_BC_SUPPORT) {
spin_lock(&s_md3_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 0) {
user_ctlb->has_request_rst_lock = 1;
s_md3_user_request_lock_cnt++;
}
spin_unlock(&s_md3_user_lock_cnt_lock);
} else
err = -1;
break;
case CCCI_IOC_FREE_RST_LOCK:
if (bc_dev->md_bit_mask & MD1_BC_SUPPORT) {
spin_lock(&s_md1_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 1) {
user_ctlb->has_request_rst_lock = 0;
s_md1_user_request_lock_cnt--;
}
spin_unlock(&s_md1_user_lock_cnt_lock);
} else if (bc_dev->md_bit_mask & MD3_BC_SUPPORT) {
spin_lock(&s_md3_user_lock_cnt_lock);
if (user_ctlb->has_request_rst_lock == 1) {
user_ctlb->has_request_rst_lock = 0;
s_md3_user_request_lock_cnt--;
}
spin_unlock(&s_md3_user_lock_cnt_lock);
} else
err = -1;
break;
case CCCI_IOC_GET_HOLD_RST_CNT:
if ((bc_dev->md_bit_mask & (MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== (MD1_BC_SUPPORT | MD3_BC_SUPPORT))
lock_cnt = get_lock_rst_user_cnt(MD_SYS1) +
get_lock_rst_user_cnt(MD_SYS3);
else if ((bc_dev->md_bit_mask &
(MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== MD1_BC_SUPPORT)
lock_cnt = get_lock_rst_user_cnt(MD_SYS1);
else if ((bc_dev->md_bit_mask &
(MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== MD3_BC_SUPPORT)
lock_cnt = get_lock_rst_user_cnt(MD_SYS3);
else
lock_cnt = 0;
err = put_user((unsigned int)lock_cnt,
(unsigned int __user *)arg);
break;
case CCCI_IOC_SHOW_LOCK_USER:
buf = kmalloc(1024, GFP_KERNEL);
if (buf == NULL) {
err = -1;
break;
}
if ((bc_dev->md_bit_mask & (MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== (MD1_BC_SUPPORT | MD3_BC_SUPPORT)) {
cpy_size = get_lock_rst_user_list(0, buf, 1024);
get_lock_rst_user_list(2, &buf[cpy_size],
1024 - cpy_size);
md_id = 0;
} else if ((bc_dev->md_bit_mask &
(MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== MD1_BC_SUPPORT) {
get_lock_rst_user_list(0, buf, 1024);
md_id = 1;
} else if ((bc_dev->md_bit_mask &
(MD1_BC_SUPPORT | MD3_BC_SUPPORT))
== MD3_BC_SUPPORT) {
get_lock_rst_user_list(2, buf, 1024);
md_id = 3;
} else {
md_id = 0;
buf[0] = 0;
}
pr_info("ccci: Lock reset user list: %s\r\n", buf);
kfree(buf);
break;
default:
err = -ENOIOCTLCMD;
break;
}
return err;
}
#ifdef CONFIG_COMPAT
long ccci_util_bc_compat_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
user_ctlb = filp->private_data;
bc_dev = user_ctlb->bc_dev_ptr;
if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
CCCI_UTIL_ERR_MSG(
"%s(!filp->f_op || !filp->f_op->unlocked_ioctl)\n", __func__);
return -ENOTTY;
}
return filp->f_op->unlocked_ioctl(filp, cmd,
(unsigned long)compat_ptr(arg));
}
#endif
static unsigned int ccci_util_bc_poll(struct file *filp,
struct poll_table_struct *wait)
{
unsigned int mask = 0;
struct ccci_util_bc_user_ctlb *user_ctlb;
struct bc_ctl_block_t *bc_dev;
unsigned long flag;
user_ctlb = (struct ccci_util_bc_user_ctlb *)filp->private_data;
bc_dev = user_ctlb->bc_dev_ptr;
poll_wait(filp, &bc_dev->wait, wait);
spin_lock_irqsave(&s_event_update_lock, flag);
if (user_ctlb->pending_event_cnt)
mask |= POLLIN|POLLRDNORM;
spin_unlock_irqrestore(&s_event_update_lock, flag);
return mask;
}
static const struct file_operations broad_cast_fops = {
.owner = THIS_MODULE,
.open = ccci_util_bc_open,
.read = ccci_util_bc_read,
.write = ccci_util_bc_write,
.unlocked_ioctl = ccci_util_bc_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = ccci_util_bc_compat_ioctl,
#endif
.poll = ccci_util_bc_poll,
.release = ccci_util_bc_release,
};
int ccci_util_broadcast_init(void)
{
int ret;
int i;
dev_t dev_n;
memset(last_md_status, 0, sizeof(last_md_status));
for (i = 0; i < MD_BC_MAX_NUM; i++) {
s_bc_ctl_tbl[i] = kmalloc(sizeof(struct bc_ctl_block_t),
GFP_KERNEL);
if (s_bc_ctl_tbl[i] == NULL)
goto _exit;
INIT_LIST_HEAD(&s_bc_ctl_tbl[i]->user_list);
init_waitqueue_head(&s_bc_ctl_tbl[i]->wait);
if (i == 0)
s_bc_ctl_tbl[i]->md_bit_mask = 0x7;
else
s_bc_ctl_tbl[i]->md_bit_mask = (1U << (i-1));
}
spin_lock_init(&s_event_update_lock);
spin_lock_init(&s_md1_user_lock_cnt_lock);
spin_lock_init(&s_md3_user_lock_cnt_lock);
s_ccci_bd_class = class_create(THIS_MODULE, "ccci_md_sta");
s_md1_user_request_lock_cnt = 0;
s_md3_user_request_lock_cnt = 0;
ret = alloc_chrdev_region(&s_md_status_dev, 0, 3, "ccci_md_sta");
if (ret != 0) {
CCCI_UTIL_ERR_MSG("alloc chrdev fail for ccci_md_sta(%d)\n",
ret);
goto _exit_1;
}
cdev_init(&s_bd_char_dev, &broad_cast_fops);
s_bd_char_dev.owner = THIS_MODULE;
ret = cdev_add(&s_bd_char_dev, s_md_status_dev, 3);
if (ret) {
CCCI_UTIL_ERR_MSG("cdev_add failed\n");
goto _exit_2;
}
/* create a device node in directory /dev/ */
for (i = 0; i < MD_BC_MAX_NUM; i++) {
dev_n = MKDEV(MAJOR(s_md_status_dev), i);
if (i == 0)
device_create(s_ccci_bd_class, NULL, dev_n,
NULL, "ccci_mdx_sta");
else
device_create(s_ccci_bd_class, NULL, dev_n,
NULL, "ccci_md%d_sta", i);
}
return 0;
_exit_2:
cdev_del(&s_bd_char_dev);
_exit_1:
unregister_chrdev_region(s_md_status_dev, 3);
_exit:
for (i = 0; i < MD_BC_MAX_NUM; i++)
kfree(s_bc_ctl_tbl[i]);
return -1;
}
@@ -0,0 +1,106 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/skbuff.h>
bool __weak spm_is_md1_sleep(void)
{
pr_notice("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
void __weak spm_ap_mdsrc_req(u8 lock)
{
pr_notice("[ccci/dummy] %s is not supported!\n", __func__);
}
int __weak exec_ccci_kern_func_by_md_id(int md_id, unsigned int id, char *buf,
unsigned int len)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
int __weak switch_sim_mode(int id, char *buf, unsigned int len)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
unsigned int __weak get_sim_switch_type(void)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
unsigned int __weak get_modem_is_enabled(int md_id)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
int __weak register_ccci_sys_call_back(int md_id, unsigned int id,
int (*func)(int, int))
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
unsigned int __weak mt_irq_get_pending(unsigned int irq)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
unsigned long __weak ccci_get_md_boot_count(int md_id)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
char * __weak ccci_get_ap_platform(void)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return "MTxxxxE1";
}
bool __weak is_clk_buf_from_pmic(void)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return false;
}
void __weak clk_buf_get_swctrl_status(void *swctrl_status)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
}
void __weak clk_buf_get_rf_drv_curr(void *rf_drv_curr)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
}
void __weak clk_buf_save_afc_val(unsigned int afcdac)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
}
int __weak rawbulk_push_upstream_buffer(int transfer_id, const void *buffer,
unsigned int length)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
int __weak mbim_start_xmit(struct sk_buff *skb, int ifid)
{
pr_debug("[ccci/dummy] %s is not supported!\n", __func__);
return 0;
}
@@ -0,0 +1,141 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2016 MediaTek Inc.
*/
enum {
Success = 0,
/* ----- Error id start here ----- */
LD_ERR_NULL_PTR = 1,
LD_ERR_GET_COM_CHK_HDR_FAIL,
LD_ERR_CHK_HDR_PATTERN,
LD_ERR_RESERVE_MEM_NOT_ENOUGH,
LD_ERR_ASS_FUNC_ALLOC_MEM_FAIL,
LD_ERR_ASS_FUNC_GET_CHK_HDR_FAIL,
LD_ERR_ASS_FIND_MAIN_INF_FAIL,
LD_ERR_ASS_FIND_DSP_INF_FAIL,
LD_ERR_ASS_FIND_ARMV7_INF_FAIL,
LD_ERR_ASS_FIND_RAMDISK_INF_FAIL,
LD_ERR_ASS_FIND_L1CORE_INF_FAIL,
LD_ERR_TAG_BUF_FULL,
LD_ERR_PAD_SIZE_LESS_THAN_64K,
LD_ERR_PAD_INVALID_INF,
LD_ERR_PAD_FREE_INF_ABNORMAL,
LD_ERR_PAD_OVER_TWO_REGION,
LD_ERR_PAD_MISC,
LD_ERR_PAD_REGION_NOT_ENOUGH,
LD_ERR_PAD_NO_REGION_RETRIEVE,
LD_ERR_OPT_SETTING_INVALID,
LD_ERR_OPT_NOT_FOUND,
LD_ERR_OPT_CMD_BUF_ALLOC_FAIL,
LD_ERR_PT_DEV_NULL,
LD_ERR_PT_NOT_FOUND,
LD_ERR_PT_READ_RAW_FAIL,
LD_ERR_PT_IMG_LIST_NULL,
LD_ERR_PT_ALLOC_HDR_MEM_FAIL,
LD_ERR_PT_READ_HDR_SIZE_ABNORMAL,
LD_ERR_PT_P_HDR_MAGIC_MIS_MATCH,
LD_ERR_PT_MAIN_IMG_SIZE_ABNORMAL,
LD_ERR_PT_CERT_CHAIN_FAIL,
LD_ERR_PT_IMG_TOO_LARGE,
LD_ERR_PT_IMG_SIZE_NOT_SYNC_CHK_HDR,
LD_ERR_PT_ALLOC_MD_MEM_FAIL,
LD_ERR_PT_LD_IMG_DATA_FAIL,
LD_ERR_PT_HASH_CHK_FAIL,
LD_ERR_PT_V2_PLAT_NOT_RDY,
LD_ERR_PT_SMEM_SIZE_ABNORMAL,
LD_ERR_PT_LIMIT_SETTING_ABNORMAL,
LD_ERR_PT_ALIGN_SETTING_ABNORMAL,
LD_ERR_PT_ALLOC_RORW_MEM_FAIL,
LD_ERR_PT_ALLOC_SMEM_FAIL,
LD_ERR_PT_ALLOC_CMD_BUF_FAIL,
LD_ERR_PT_MD1_LOAD_FAIL,
LD_ERR_PT_MD3_LOAD_FAIL,
LD_ERR_PT_APPLY_PLAT_SETTING_FAIL,
LD_ERR_PT_CHK_IMG_NAME_FAIL,
LD_ERR_PLAT_INVALID_MD_ID,
LD_ERR_PLAT_MPU_REGION_EMPTY,
LD_ERR_PLAT_MPU_REGION_TOO_MORE,
LD_ERR_PLAT_MPU_REGION_NUM_NOT_SYNC,
LD_ERR_PLAT_ABNORMAL_FREE_REGION,
LD_ERR_PLAT_ABNORMAL_PAD_ARRAY,
LD_ERR_PLAT_NO_MORE_FREE_REGION,
LD_ERR_PLAT_MD1_NOT_RDY,
};
static const char * const errno_str[] = {
"Success",
"LD_ERR_NULL_PTR",
"LD_ERR_GET_COM_CHK_HDR_FAIL",
"LD_ERR_CHK_HDR_PATTERN",
"LD_ERR_RESERVE_MEM_NOT_ENOUGH",
"LD_ERR_ASS_FUNC_ALLOC_MEM_FAIL",
"LD_ERR_ASS_FUNC_GET_CHK_HDR_FAIL",
"LD_ERR_ASS_FIND_MAIN_INF_FAIL",
"LD_ERR_ASS_FIND_DSP_INF_FAIL",
"LD_ERR_ASS_FIND_ARMV7_INF_FAIL",
"LD_ERR_ASS_FIND_RAMDISK_INF_FAIL",
"LD_ERR_ASS_FIND_L1CORE_INF_FAIL",
"LD_ERR_TAG_BUF_FULL",
"LD_ERR_PAD_SIZE_LESS_THAN_64K",
"LD_ERR_PAD_INVALID_INF",
"LD_ERR_PAD_FREE_INF_ABNORMAL",
"LD_ERR_PAD_OVER_TWO_REGION",
"LD_ERR_PAD_MISC",
"LD_ERR_PAD_REGION_NOT_ENOUGH",
"LD_ERR_PAD_NO_REGION_RETRIEVE",
"LD_ERR_OPT_SETTING_INVALID",
"LD_ERR_OPT_NOT_FOUND",
"LD_ERR_OPT_CMD_BUF_ALLOC_FAIL",
"LD_ERR_PT_DEV_NULL",
"LD_ERR_PT_NOT_FOUND",
"LD_ERR_PT_READ_RAW_FAIL",
"LD_ERR_PT_IMG_LIST_NULL",
"LD_ERR_PT_ALLOC_HDR_MEM_FAIL",
"LD_ERR_PT_READ_HDR_SIZE_ABNORMAL",
"LD_ERR_PT_P_HDR_MAGIC_MIS_MATCH",
"LD_ERR_PT_MAIN_IMG_SIZE_ABNORMAL",
"LD_ERR_PT_CERT_CHAIN_FAIL",
"LD_ERR_PT_IMG_TOO_LARGE",
"LD_ERR_PT_IMG_SIZE_NOT_SYNC_CHK_HDR",
"LD_ERR_PT_ALLOC_MD_MEM_FAIL",
"LD_ERR_PT_LD_IMG_DATA_FAIL",
"LD_ERR_PT_HASH_CHK_FAIL",
"LD_ERR_PT_V2_PLAT_NOT_RDY",
"LD_ERR_PT_SMEM_SIZE_ABNORMAL",
"LD_ERR_PT_LIMIT_SETTING_ABNORMAL",
"LD_ERR_PT_ALIGN_SETTING_ABNORMAL",
"LD_ERR_PT_ALLOC_RORW_MEM_FAIL",
"LD_ERR_PT_ALLOC_SMEM_FAIL",
"LD_ERR_PT_ALLOC_CMD_BUF_FAIL",
"LD_ERR_PT_MD1_LOAD_FAIL",
"LD_ERR_PT_MD3_LOAD_FAIL",
"LD_ERR_PT_APPLY_PLAT_SETTING_FAIL",
"LD_ERR_PT_CHK_IMG_NAME_FAIL",
"LD_ERR_PLAT_INVALID_MD_ID",
"LD_ERR_PLAT_MPU_REGION_EMPTY",
"LD_ERR_PLAT_MPU_REGION_TOO_MORE",
"LD_ERR_PLAT_MPU_REGION_NUM_NOT_SYNC",
"LD_ERR_PLAT_ABNORMAL_FREE_REGION",
"LD_ERR_PLAT_ABNORMAL_PAD_ARRAY",
"LD_ERR_PLAT_NO_MORE_FREE_REGION",
"LD_ERR_PLAT_MD1_NOT_RDY"
};
const char *ld_md_errno_to_str(int errno)
{
int tmp_idx;
if (errno == 0)
return "Success";
if (errno < 0)
tmp_idx = -errno;
else
tmp_idx = errno;
if (tmp_idx < (int)(sizeof(errno_str)/sizeof(char *)))
return errno_str[tmp_idx];
return "errno not found";
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,46 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/mm.h>
#include <linux/kfifo.h>
#include <linux/firmware.h>
#include <linux/syscalls.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/of.h>
#ifdef CONFIG_OF
#include <linux/of_fdt.h>
#endif
#include <asm/setup.h>
#include <linux/atomic.h>
#include "ccci_util_lib_main.h"
static int __init ccci_util_init(void)
{
ccci_log_init();
ccci_util_fo_init();
ccci_common_sysfs_init();
ccci_timer_for_md_init();
ccci_util_broadcast_init();
ccci_sib_init();
ccci_util_pin_broadcast_init();
return 0;
}
subsys_initcall(ccci_util_init);
MODULE_DESCRIPTION("MTK CCCI UTIL Driver");
MODULE_LICENSE("GPL");
@@ -0,0 +1,299 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#ifndef __CCCI_UTIL_LIB_MAIN_H__
#define __CCCI_UTIL_LIB_MAIN_H__
#include "mt-plat/mtk_ccci_common.h"
struct md_check_header_v3 {
/* magic number is "CHECK_HEADER"*/
unsigned char check_header[12];
/* header structure version number */
unsigned int header_verno;
/* 0x0:invalid;
* 0x1:debug version;
* 0x2:release version
*/
unsigned int product_ver;
/* 0x0:invalid;
* 0x1:2G modem;
* 0x2: 3G modem
*/
unsigned int image_type;
/* MT6573_S01 or MT6573_S02 */
unsigned char platform[16];
/* build time string */
unsigned char build_time[64];
/* project version, ex:11A_MD.W11.28 */
unsigned char build_ver[64];
/* bind to md sys id,
* MD SYS1: 1,
* MD SYS2: 2,
* MD SYS5: 5
*/
unsigned char bind_sys_id;
/* no shrink: 0, shrink: 1 */
unsigned char ext_attr;
/* for reserved */
unsigned char reserved[2];
/* md ROM/RAM image size requested by md */
unsigned int mem_size;
/* md image size, exclude head size */
unsigned int md_img_size;
/* RPC secure memory address */
unsigned int rpc_sec_mem_addr;
unsigned int dsp_img_offset;
unsigned int dsp_img_size;
unsigned char reserved2[88];
/* the size of this structure */
unsigned int size;
} __packed;
struct md_check_header_v4 {
/* magic number is "CHECK_HEADER"*/
unsigned char check_header[12];
/* header structure version number */
unsigned int header_verno;
/* 0x0:invalid;
* 0x1:debug version;
* 0x2:release version
*/
unsigned int product_ver;
/* 0x0:invalid;
* 0x1:2G modem;
* 0x2: 3G modem
*/
unsigned int image_type;
/* MT6573_S01 or MT6573_S02 */
unsigned char platform[16];
/* build time string */
unsigned char build_time[64];
/* project version, ex:11A_MD.W11.28 */
unsigned char build_ver[64];
/* bind to md sys id,
* MD SYS1: 1,
* MD SYS2: 2,
* MD SYS5: 5
*/
unsigned char bind_sys_id;
/* no shrink: 0, shrink: 1 */
unsigned char ext_attr;
/* for reserved */
unsigned char reserved[2];
/* md ROM/RAM image size requested by md */
unsigned int mem_size;
/* md image size, exclude head size */
unsigned int md_img_size;
/* RPC secure memory address */
unsigned int rpc_sec_mem_addr;
unsigned int dsp_img_offset;
unsigned int dsp_img_size;
/* total region number */
unsigned int region_num;
/* max support 8 regions */
struct _md_regin_info region_info[8];
/* max support 4 domain settings,
* each region has 4 control bits
*/
unsigned int domain_attr[4];
unsigned char reserved2[4];
/* the size of this structure */
unsigned int size;
} __packed;
struct md_check_header_v5 {
/* magic number is "CHECK_HEADER" */
unsigned char check_header[12];
/* header structure version number */
unsigned int header_verno;
/* 0x0:invalid;
* 0x1:debug version;
* 0x2:release version
*/
unsigned int product_ver;
/* 0x0:invalid;
* 0x1:2G modem;
* 0x2: 3G modem
*/
unsigned int image_type;
/* MT6573_S01 or MT6573_S02 */
unsigned char platform[16];
/* build time string */
unsigned char build_time[64];
/* project version, ex:11A_MD.W11.28 */
unsigned char build_ver[64];
/* bind to md sys id,
* MD SYS1: 1,
* MD SYS2: 2,
* MD SYS5: 5
*/
unsigned char bind_sys_id;
/* no shrink: 0, shrink: 1 */
unsigned char ext_attr;
/* for reserved */
unsigned char reserved[2];
/* md ROM/RAM image size requested by md */
unsigned int mem_size;
/* md image size, exclude head size */
unsigned int md_img_size;
/* RPC secure memory address */
unsigned int rpc_sec_mem_addr;
unsigned int dsp_img_offset;
unsigned int dsp_img_size;
/* total region number */
unsigned int region_num;
/* max support 8 regions */
struct _md_regin_info region_info[8];
/* max support 4 domain settings,
* each region has 4 control bits
*/
unsigned int domain_attr[4];
unsigned int arm7_img_offset;
unsigned int arm7_img_size;
unsigned char reserved_1[56];
/* the size of this structure */
unsigned int size;
} __packed;
struct md_check_header_struct {
/* magic number is "CHECK_HEADER"*/
unsigned char check_header[12];
/* header structure version number */
unsigned int header_verno;
/* 0x0:invalid;
* 0x1:debug version;
* 0x2:release version
*/
unsigned int product_ver;
/* 0x0:invalid;
* 0x1:2G modem;
* 0x2: 3G modem
*/
unsigned int image_type;
/* MT6573_S01 or MT6573_S02 */
unsigned char platform[16];
/* build time string */
unsigned char build_time[64];
/* project version, ex:11A_MD.W11.28 */
unsigned char build_ver[64];
/* bind to md sys id,
* MD SYS1: 1,
* MD SYS2: 2
*/
unsigned char bind_sys_id;
/* no shrink: 0, shrink: 1*/
unsigned char ext_attr;
/* for reserved */
unsigned char reserved[2];
/* md ROM/RAM image size requested by md */
unsigned int mem_size;
/* md image size, exclude head size*/
unsigned int md_img_size;
} __packed;
struct _free_padding_block {
unsigned int start_offset;
unsigned int length;
};
struct md_check_header_v6 {
/* magic number is "CHECK_HEADER"*/
unsigned char check_header[12];
/* header structure version number */
unsigned int header_verno;
/* 0x0:invalid;
* 0x1:debug version;
* 0x2:release version
*/
unsigned int product_ver;
/* 0x0:invalid;
* 0x1:2G modem;
* 0x2: 3G modem
*/
unsigned int image_type;
/* MT6573_S01 or MT6573_S02 */
unsigned char platform[16];
/* build time string */
unsigned char build_time[64];
/* project version, ex:11A_MD.W11.28 */
unsigned char build_ver[64];
/* bind to md sys id,
* MD SYS1: 1,
* MD SYS2: 2,
* MD SYS5: 5
*/
unsigned char bind_sys_id;
/* no shrink: 0, shrink: 1 */
unsigned char ext_attr;
/* for reserved */
unsigned char reserved[2];
/* md ROM/RAM image size requested by md */
unsigned int mem_size;
/* md image size, exclude head size */
unsigned int md_img_size;
/* RPC secure memory address */
unsigned int rpc_sec_mem_addr;
unsigned int dsp_img_offset;
unsigned int dsp_img_size;
/* total region number */
unsigned int region_num;
/* max support 8 regions */
struct _md_regin_info region_info[8];
/* max support 4 domain settings,
* each region has 4 control bits
*/
unsigned int domain_attr[4];
unsigned int arm7_img_offset;
unsigned int arm7_img_size;
struct _free_padding_block padding_blk[8];
unsigned int ap_md_smem_size;
unsigned int md_to_md_smem_size;
unsigned int ramdisk_offset;
unsigned int ramdisk_size;
unsigned char reserved_1[144];
/* the size of this structure */
unsigned int size;
};
extern char *ccci_get_ap_platform(void);
extern int ccci_common_sysfs_init(void);
extern void ccci_log_init(void);
extern int __init ccci_util_fo_init(void);
extern void ccci_timer_for_md_init(void);
extern const char *ld_md_errno_to_str(int errno);
extern int ccci_util_broadcast_init(void);
extern int ccci_sib_init(void);
extern int ccci_util_pin_broadcast_init(void);
#define MAX_MD_NUM_AT_LK (4)
#endif
@@ -0,0 +1,470 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
//#include <mt-plat/sync_write.h>
#include "mt-plat/mtk_ccci_common.h"
#include <linux/slab.h>
#include <linux/kobject.h>
#include "ccci_util_log.h"
#include "ccci_util_lib_sys.h"
#define CCCI_KOBJ_NAME "ccci"
struct ccci_info {
struct kobject kobj;
unsigned int ccci_attr_count;
};
struct ccci_attribute {
struct attribute attr;
ssize_t (*show)(char *buf);
ssize_t (*store)(const char *buf, size_t count);
};
#define CCCI_ATTR(_name, _mode, _show, _store) \
static struct ccci_attribute ccci_attr_##_name = { \
.attr = {.name = __stringify(_name), .mode = _mode }, \
.show = _show, \
.store = _store, \
}
static struct ccci_info *ccci_sys_info;
static void ccci_obj_release(struct kobject *kobj)
{
struct ccci_info *ccci_info_temp =
container_of(kobj, struct ccci_info, kobj);
kfree(ccci_info_temp);
/* as ccci_info_temp==ccci_sys_info */
ccci_sys_info = NULL;
}
static ssize_t ccci_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
{
ssize_t len = 0;
struct ccci_attribute *a =
container_of(attr, struct ccci_attribute, attr);
if (a->show)
len = a->show(buf);
return len;
}
static ssize_t ccci_attr_store(struct kobject *kobj,
struct attribute *attr, const char *buf, size_t count)
{
ssize_t len = 0;
struct ccci_attribute *a =
container_of(attr, struct ccci_attribute, attr);
if (a->store)
len = a->store(buf, count);
return len;
}
static const struct sysfs_ops ccci_sysfs_ops = {
.show = ccci_attr_show,
.store = ccci_attr_store
};
/*======================================= */
/* CCCI common sys attribute part */
/*======================================= */
/* Sys -- boot status */
static get_status_func_t get_status_func[MAX_MD_NUM];
static boot_md_func_t boot_md_func[MAX_MD_NUM];
static int get_md_status(int md_id, char val[], int size)
{
int ret = 0;
if (md_id < 0 || md_id >= MAX_MD_NUM) {
CCCI_UTIL_INF_MSG("invalid md_id = %d\n", md_id);
return -1;
}
if ((md_id < MAX_MD_NUM)
&& (get_status_func[md_id] != NULL))
(get_status_func[md_id]) (md_id, val, size);
else {
ret = snprintf(val, 32, "md%d:n/a", md_id + 1);
if (ret < 0 || ret >= 32) {
CCCI_UTIL_INF_MSG("%s-%d:snprintf fail,ret=%d\n",
__func__, __LINE__, ret);
return -1;
}
}
return 0;
}
static int trigger_md_boot(int md_id)
{
if (md_id < 0 || md_id >= MAX_MD_NUM) {
CCCI_UTIL_INF_MSG("invalid md_id = %d\n", md_id);
return -1;
}
if ((md_id < MAX_MD_NUM) && (boot_md_func[md_id] != NULL))
return (boot_md_func[md_id]) (md_id);
return -1;
}
static ssize_t boot_status_show(char *buf)
{
char md1_sta_str[32] = {0};
char md2_sta_str[32] = {0};
char md3_sta_str[32] = {0};
char md5_sta_str[32] = {0};
/* MD1 --- */
get_md_status(MD_SYS1, md1_sta_str, 32);
/* MD2 --- */
get_md_status(MD_SYS2, md2_sta_str, 32);
/* MD3 */
get_md_status(MD_SYS3, md3_sta_str, 32);
/* MD5 */
get_md_status(MD_SYS5, md5_sta_str, 32);
/* Final string */
return snprintf(buf, 32 * 4 + 3 * 4 + 1,
"%s | %s | %s | md4:n/a | %s\n",
md1_sta_str, md2_sta_str,
md3_sta_str, md5_sta_str);
}
static ssize_t boot_status_store(const char *buf, size_t count)
{
unsigned int md_id;
md_id = buf[0] - '0';
CCCI_UTIL_INF_MSG("md%d get boot store\n", md_id + 1);
if (md_id < MAX_MD_NUM) {
if (trigger_md_boot(md_id) != 0)
CCCI_UTIL_INF_MSG("md%d n/a\n", md_id + 1);
} else
CCCI_UTIL_INF_MSG("invalid id(%d)\n", md_id + 1);
return count;
}
CCCI_ATTR(boot, 0660, &boot_status_show, &boot_status_store);
/* Sys -- enable status */
static ssize_t ccci_md_enable_show(char *buf)
{
int i;
char md_en[MAX_MD_NUM];
for (i = 0; i < MAX_MD_NUM; i++) {
if (get_modem_is_enabled(MD_SYS1 + i))
md_en[i] = 'E';
else
md_en[i] = 'D';
}
/* Final string */
return snprintf(buf, 32,
"%c-%c-%c-%c-%c (1->5)\n",
md_en[0], md_en[1], md_en[2],
md_en[3], md_en[4]);
}
CCCI_ATTR(md_en, 0660, &ccci_md_enable_show, NULL);
/* Sys -- post fix */
static ssize_t ccci_md1_post_fix_show(char *buf)
{
get_md_postfix(MD_SYS1, NULL, buf, NULL);
return strlen(buf);
}
CCCI_ATTR(md1_postfix, 0444, &ccci_md1_post_fix_show, NULL);
/* Sys -- dump buff usage */
static ssize_t ccci_dump_buff_usage_show(char *buf)
{
return get_dump_buf_usage(buf, 4095);
}
CCCI_ATTR(dump_max, 0660, &ccci_dump_buff_usage_show, NULL);
/* Sys -- ccci stage change(chn) log */
static ssize_t ccci_dump_event_show(char *buf)
{
return (ssize_t)ccci_event_log_cpy(buf, 4095);
}
CCCI_ATTR(md_chn, 0444, &ccci_dump_event_show, NULL);
/* Sys -- Versin */
static unsigned int ccci_port_ver = 6; /* ECCCI_FSM */
static ssize_t ccci_version_show(char *buf)
{
return snprintf(buf, 16, "%d\n", ccci_port_ver);
}
void update_ccci_port_ver(unsigned int new_ver)
{
ccci_port_ver = new_ver;
}
CCCI_ATTR(version, 0644, &ccci_version_show, NULL);
static ssize_t debug_enable_show(char *buf)
{
int curr = 0;
curr = snprintf(buf, 16, "%d\n", 2);/* ccci_debug_enable); */
if (curr < 0 || curr >= 16) {
CCCI_UTIL_INF_MSG(
"%s-%d:snprintf fail,curr=%d\n", __func__, __LINE__, curr);
return -1;
}
return curr;
}
static ssize_t debug_enable_store(const char *buf, size_t count)
{
/* ccci_debug_enable = buf[0] - '0'; */
return count;
}
CCCI_ATTR(debug, 0660, &debug_enable_show, &debug_enable_store);
/* Sys -- dump lk load md info */
static ssize_t ccci_lk_load_md_show(char *buf)
{
return get_lk_load_md_info(buf, 4095);
}
CCCI_ATTR(lk_md, 0444, &ccci_lk_load_md_show, NULL);
/* Sys -- get ccci private feature info */
/* If platform has special feature setting,
* platform code will implemet this function
*/
int __attribute__((weak)) ccci_get_plat_ft_inf(char buf[], int size)
{
return (ssize_t)snprintf(buf, size, "ft_inf_ver:1");
}
static ssize_t ccci_ft_inf_show(char *buf)
{
if (ccci_get_plat_ft_inf) {
CCCI_UTIL_INF_MSG("using platform setting\n");
return (ssize_t)ccci_get_plat_ft_inf(buf, 4095);
}
/* Enter here means using default setting */
return (ssize_t)ccci_get_plat_ft_inf(buf, 4095);
}
CCCI_ATTR(ft_info, 0444, &ccci_ft_inf_show, NULL);
static ssize_t kcfg_setting_show(char *buf)
{
unsigned int curr = 0;
int actual_write = 0;
char md_en[MAX_MD_NUM] = {0};
unsigned int md_num = 0;
int i = 0;
char c_en = 0;
for (i = 0; i < MAX_MD_NUM; i++) {
if (get_modem_is_enabled(MD_SYS1 + i)) {
md_num++;
md_en[i] = '1';
} else
md_en[i] = '0';
}
/* MD enable setting part */
/* Reserve 16 byte to store size info */
actual_write = snprintf(&buf[curr],
4096 - 16 - curr,
"[modem num]:%d\n",
md_num);
if (actual_write < 0) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,actual_write=%d\n",
__func__, __LINE__, actual_write);
actual_write = 0;
} else if (actual_write >= 4096 - 16 - curr)
actual_write = 4096 - 16 - curr - 1;
curr += actual_write;
/* Reserve 16 byte to store size info */
actual_write = snprintf(&buf[curr], 4096 - 16 - curr,
"[modem en]:%c-%c-%c-%c-%c\n",
md_en[0], md_en[1], md_en[2],
md_en[3], md_en[4]);
if (actual_write < 0) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,actual_write=%d\n",
__func__, __LINE__, actual_write);
actual_write = 0;
} else if (actual_write >= 4096 - 16 - curr)
actual_write = 4096 - 16 - curr - 1;
curr += actual_write;
/* ECCCI_C2K */
if (check_rat_at_md_img(MD_SYS1, "C"))
c_en = '1';
else
c_en = '0';
actual_write = snprintf(&buf[curr],
4096 - curr, "[MTK_ECCCI_C2K]:%c\n", c_en);
if (actual_write < 0) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,actual_write=%d\n",
__func__, __LINE__, actual_write);
actual_write = 0;
} else if (actual_write >= 4096 - curr)
actual_write = 4096 - curr - 1;
curr += actual_write;
/* ECCCI_FSM */
if (ccci_port_ver == 6)
/* FSM using v2 */
actual_write = snprintf(&buf[curr], 4096 - curr,
"[ccci_drv_ver]:V2\n");
else
actual_write = snprintf(&buf[curr], 4096 - curr,
"[ccci_drv_ver]:V1\n");
if (actual_write < 0) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,actual_write=%d\n",
__func__, __LINE__, actual_write);
actual_write = 0;
} else if (actual_write >= 4096 - curr)
actual_write = 4096 - curr - 1;
curr += actual_write;
actual_write = snprintf(&buf[curr],
4096 - curr, "[MTK_MD_CAP]:%d\n", get_md_img_type(MD_SYS1));
if (actual_write > 0 && actual_write < (4096 - curr))
curr += actual_write;
/* Add total size to tail */
actual_write = snprintf(&buf[curr],
4096 - curr, "total:%d\n", curr);
if (actual_write < 0) {
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,actual_write=%d\n",
__func__, __LINE__, actual_write);
actual_write = 0;
} else if (actual_write >= 4096 - curr)
actual_write = 4096 - curr - 1;
curr += actual_write;
CCCI_UTIL_INF_MSG("cfg_info_buffer size:%d\n",
curr);
return (ssize_t) curr;
}
static ssize_t kcfg_setting_store(const char *buf, size_t count)
{
return count;
}
CCCI_ATTR(kcfg_setting, 0444, &kcfg_setting_show, &kcfg_setting_store);
static ssize_t ccci_pin_cfg_store(const char *buf, size_t count)
{
unsigned int pin_val;
pin_val = buf[0] - '0';
inject_pin_status_event(pin_val, "RF_cable");
return count;
}
CCCI_ATTR(pincfg, 0220, NULL, &ccci_pin_cfg_store);
/* Sys -- Add to group */
static struct attribute *ccci_default_attrs[] = {
&ccci_attr_boot.attr,
&ccci_attr_version.attr,
&ccci_attr_md_en.attr,
&ccci_attr_debug.attr,
&ccci_attr_kcfg_setting.attr,
&ccci_attr_dump_max.attr,
&ccci_attr_lk_md.attr,
&ccci_attr_md_chn.attr,
&ccci_attr_ft_info.attr,
&ccci_attr_md1_postfix.attr,
&ccci_attr_pincfg.attr,
NULL
};
static struct kobj_type ccci_ktype = {
.release = ccci_obj_release,
.sysfs_ops = &ccci_sysfs_ops,
.default_attrs = ccci_default_attrs
};
int ccci_sysfs_add_modem(int md_id, void *kobj, void *ktype,
get_status_func_t get_sta_func, boot_md_func_t boot_func)
{
int ret = 0;
static int md_add_flag;
if (md_id < 0 || md_id >= MAX_MD_NUM) {
CCCI_UTIL_ERR_MSG("invalid md_id = %d\n", md_id);
return -CCCI_ERR_SYSFS_NOT_READY;
}
md_add_flag = 0;
if (!ccci_sys_info) {
CCCI_UTIL_ERR_MSG("common sys not ready\n");
return -CCCI_ERR_SYSFS_NOT_READY;
}
if (md_add_flag & (1 << md_id)) {
CCCI_UTIL_ERR_MSG("md%d sys dup add\n", md_id + 1);
return -CCCI_ERR_SYSFS_NOT_READY;
}
ret =
kobject_init_and_add((struct kobject *)kobj,
(struct kobj_type *)ktype, &ccci_sys_info->kobj,
"mdsys%d", md_id + 1);
if (ret < 0) {
kobject_put(kobj);
CCCI_UTIL_ERR_MSG_WITH_ID(md_id, "fail to add md kobject\n");
} else {
md_add_flag |= (1 << md_id);
get_status_func[md_id] = get_sta_func;
boot_md_func[md_id] = boot_func;
}
return ret;
}
EXPORT_SYMBOL(ccci_sysfs_add_modem);
int ccci_common_sysfs_init(void)
{
int ret = 0;
int i;
ccci_sys_info = kmalloc(sizeof(struct ccci_info), GFP_KERNEL);
if (!ccci_sys_info)
return -ENOMEM;
memset(ccci_sys_info, 0, sizeof(struct ccci_info));
ret = kobject_init_and_add(&ccci_sys_info->kobj,
&ccci_ktype, kernel_kobj, CCCI_KOBJ_NAME);
if (ret < 0) {
kobject_put(&ccci_sys_info->kobj);
CCCI_UTIL_ERR_MSG("fail to add ccci kobject\n");
return ret;
}
for (i = 0; i < MAX_MD_NUM; i++) {
get_status_func[i] = NULL;
boot_md_func[i] = NULL;
}
ccci_sys_info->ccci_attr_count = ARRAY_SIZE(ccci_default_attrs) - 1;
CCCI_UTIL_DBG_MSG("ccci attr cnt %d\n", ccci_sys_info->ccci_attr_count);
return ret;
}
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 MediaTek Inc.
*/
extern unsigned int ccci_debug_enable;
extern int curr_ubin_id;
int get_dump_buf_usage(char buf[], int size);
extern void spm_ap_mdsrc_req(unsigned char set);
extern void inject_pin_status_event(int pin_value, char pin_name[]);
@@ -0,0 +1,66 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/device.h>
#include <linux/spinlock.h>
#include "mt-plat/mtk_ccci_common.h"
#include <linux/wait.h>
static wait_queue_head_t time_update_notify_queue_head;
static spinlock_t wait_count_lock;
static unsigned int wait_count;
static unsigned int get_update;
static unsigned int api_ready;
void ccci_timer_for_md_init(void)
{
init_waitqueue_head(&time_update_notify_queue_head);
spin_lock_init(&wait_count_lock);
wait_count = 0;
get_update = 0;
/* update in order */
mb();
api_ready = 1;
}
int wait_time_update_notify(void)
{ /* Only support one wait currently */
int ret = -1;
unsigned long flags;
if (api_ready) {
/* Update wait count ++ */
spin_lock_irqsave(&wait_count_lock, flags);
wait_count++;
spin_unlock_irqrestore(&wait_count_lock, flags);
ret = wait_event_interruptible(
time_update_notify_queue_head,
get_update);
if (ret != -ERESTARTSYS)
get_update = 0;
/* Update wait count -- */
spin_lock_irqsave(&wait_count_lock, flags);
wait_count--;
spin_unlock_irqrestore(&wait_count_lock, flags);
}
return ret;
}
EXPORT_SYMBOL(wait_time_update_notify);
void notify_time_update(void)
{
unsigned long flags;
if (!api_ready)
return; /* API not ready */
get_update = 1;
spin_lock_irqsave(&wait_count_lock, flags);
if (wait_count)
wake_up_all(&time_update_notify_queue_head);
spin_unlock_irqrestore(&wait_count_lock, flags);
}
@@ -0,0 +1,98 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#ifndef __CCCI_UTIL_LOG_H__
#define __CCCI_UTIL_LOG_H__
#if IS_ENABLED(CONFIG_MTK_AEE_IPANIC)
extern void mrdump_mini_add_misc(unsigned long addr, unsigned long size,
unsigned long start, char *name);
#endif
#define BRING_UP_LOG_MODE
/* #define BRING_UP_LOG_MODE */
#ifndef BRING_UP_LOG_MODE
/* ------------------------------------------------------------------------- */
/* For normal stage log */
/* ------------------------------------------------------------------------- */
/* No MD id message part */
#define CCCI_UTIL_DBG_MSG(fmt, args...) \
do {\
ccci_dump_write(0, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[0/util]" fmt, ##args);\
ccci_dump_write(0, CCCI_DUMP_NORMAL,\
CCCI_DUMP_TIME_FLAG, "[0/util]" fmt, ##args);\
} while (0)
#define CCCI_UTIL_INF_MSG(fmt, args...) \
do {\
ccci_dump_write(0, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[0/util]" fmt, ##args);\
ccci_dump_write(0, CCCI_DUMP_NORMAL,\
CCCI_DUMP_TIME_FLAG, "[0/util]" fmt, ##args);\
} while (0)
#define CCCI_UTIL_ERR_MSG(fmt, args...) \
do {\
ccci_dump_write(0, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[0/util]" fmt, ##args);\
pr_notice("[ccci0/util]" fmt, ##args);\
} while (0)
/* With MD id message part */
#define CCCI_UTIL_DBG_MSG_WITH_ID(id, fmt, args...) \
do {\
ccci_dump_write(id, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
ccci_dump_write(id, CCCI_DUMP_NORMAL,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
} while (0)
#define CCCI_UTIL_INF_MSG_WITH_ID(id, fmt, args...) \
do {\
ccci_dump_write(id, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
ccci_dump_write(id, CCCI_DUMP_NORMAL,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
} while (0)
#define CCCI_UTIL_NOTICE_MSG_WITH_ID(id, fmt, args...) \
do {\
ccci_dump_write(id, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
pr_notice("[ccci%d/util]" fmt, (id+1), ##args);\
} while (0)
#define CCCI_UTIL_ERR_MSG_WITH_ID(id, fmt, args...) \
do {\
ccci_dump_write(id, CCCI_DUMP_INIT,\
CCCI_DUMP_TIME_FLAG, "[%d/util]" fmt, (id+1), ##args);\
pr_notice("[ccci%d/util]" fmt, (id+1), ##args);\
} while (0)
#else
/* ------------------------------------------------------------------------- */
/* For bring up stage log */
/* ------------------------------------------------------------------------- */
/* No MD id message part */
#define CCCI_UTIL_DBG_MSG(fmt, args...) pr_notice("[ccci0/util]" fmt, ##args)
#define CCCI_UTIL_INF_MSG(fmt, args...) pr_notice("[ccci0/util]" fmt, ##args)
#define CCCI_UTIL_ERR_MSG(fmt, args...) pr_notice("[ccci0/util]" fmt, ##args)
/* With MD id message part */
#define CCCI_UTIL_DBG_MSG_WITH_ID(id, fmt, args...) \
pr_notice("[ccci%d/util]" fmt, (id+1), ##args)
#define CCCI_UTIL_INF_MSG_WITH_ID(id, fmt, args...) \
pr_notice("[ccci%d/util]" fmt, (id+1), ##args)
#define CCCI_UTIL_NOTICE_MSG_WITH_ID(id, fmt, args...) \
pr_notice("[ccci%d/util]" fmt, (id+1), ##args)
#define CCCI_UTIL_ERR_MSG_WITH_ID(id, fmt, args...) \
pr_notice("[ccci%d/util]" fmt, (id+1), ##args)
#endif /* end of #ifndef BRING_UP_LOG_MODE */
#endif /*__CCCI_UTIL_LOG_H__ */
@@ -0,0 +1,431 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#include "ccci_util_lib_main.h"
/*------------------------------------------*/
#define MD_CAP_BIT_NUM (7)
/*------------------------------------------*/
/* Bit map defination at MD side diff to AP */
/* 0 | 0 | Lf | Lt | W | C | T | G */
#define MD_CAP_GSM (1<<0)
#define MD_CAP_TDS_CDMA (1<<1)
#define MD_CAP_WCDMA (1<<3)
#define MD_CAP_TDD_LTE (1<<4)
#define MD_CAP_FDD_LTE (1<<5)
#define MD_CAP_CDMA2000 (1<<2)
#define MD_CAP_NR (1<<6)
#define MD_CAP_FULL_SET (MD_CAP_GSM|MD_CAP_TDS_CDMA| \
MD_CAP_WCDMA|MD_CAP_TDD_LTE| \
MD_CAP_FDD_LTE|MD_CAP_CDMA2000|MD_CAP_NR)
/* Note: this must keep sync with md_rat_map table.
* If MD_CAP_FULL_SET change or md_rat_map table change, this macro should change too.
*/
#define MD_CAP_FULL_SET_IDX (24)
static const unsigned int md_img_capability_map[] = { /* At check header */
/* 0 - None */
0,
/* 1 - G */
MD_CAP_GSM,
/* 2 - W */
MD_CAP_WCDMA,
/* 3 - WG = W + G */
(MD_CAP_WCDMA|MD_CAP_GSM),
/* 4 - TG = T + G */
(MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 5 - LWG = Lf + Lt + T + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM),
/* 6 - LTG = Lf + Lt + T + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 7 - SGLTE = Lf + Lt + T + G (Phase out)*/
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 8 - LTG = Lf + Lt + T + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 9 - LWG = Lf + Lt + W + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM),
/* 10 - LWTG = Lf + Lt + W + T + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 11 - LWCG = Lf + Lt + W + C + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000|MD_CAP_GSM),
/* 12 - LWCTG = N + Lf + Lt + W + C + T + G */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 13 - NLWTG = N + Lf + Lt + W + T + G */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* 14 - NLWCG = N + Lf + Lt + W + C + G */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA
|MD_CAP_CDMA2000|MD_CAP_GSM),
};
static const unsigned int md_rat_map[] = { /* Options supplied by MD */
/* 0 ~ 7 not userd */
0, 0, 0, 0, 0, 0, 0, 0,
/* ultg - 8 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* ulwg - 9 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM),
/* ulwtg - 10 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* ulwcg - 11 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000|MD_CAP_GSM),
/* ulwctg -12 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* ulttg - 13 */
(MD_CAP_TDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* ulfwg - 14 */
(MD_CAP_FDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM),
/* ulfwcg - 15 */
(MD_CAP_FDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000|MD_CAP_GSM),
/* ulctg - 16 */
(MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_CDMA2000|MD_CAP_TDS_CDMA
|MD_CAP_GSM),
/* ultctg - 17 */
(MD_CAP_TDD_LTE|MD_CAP_CDMA2000|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/*ultwg - 18 */
(MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM),
/* ultwcg -19 */
(MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000|MD_CAP_GSM),
/* ulftg - 20 */
(MD_CAP_FDD_LTE|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* ulfctg - 21 */
(MD_CAP_FDD_LTE|MD_CAP_CDMA2000|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* unlwg - 22 */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA
|MD_CAP_GSM),
/* unlwtg - 23 */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* unlwctg - 24 */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA|MD_CAP_CDMA2000
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
/* unlwcg - 25 */
(MD_CAP_NR|MD_CAP_FDD_LTE|MD_CAP_TDD_LTE|MD_CAP_WCDMA
|MD_CAP_CDMA2000|MD_CAP_GSM),
/* unltctg - 26 */
(MD_CAP_NR|MD_CAP_TDD_LTE|MD_CAP_CDMA2000
|MD_CAP_TDS_CDMA|MD_CAP_GSM),
};
static unsigned int get_bit_set_num(unsigned int bitmap)
{
unsigned int i;
unsigned int num = 0;
unsigned int curr_bit = 1;
for (i = 0; i < MD_CAP_BIT_NUM; i++) {
if (bitmap & curr_bit)
num++;
curr_bit = curr_bit << 1;
}
return num;
}
static unsigned int get_rat_id_by_bitmap(unsigned int rat_bit_map)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(md_rat_map); i++) {
if (rat_bit_map == md_rat_map[i])
return i;
}
return 0;
}
static unsigned int find_prefer_val(unsigned int ref_rat, unsigned int *idx)
{
unsigned int i;
unsigned int min_bitmap, min_bitmap_num, num;
unsigned int idx_at_support_list = MD_CAP_FULL_SET_IDX;
for (i = 0; i < ARRAY_SIZE(md_rat_map); i++) {
if (ref_rat == md_rat_map[i]) {
if (idx)
*idx = i;
return ref_rat;
}
}
/* Use the most similar settings */
min_bitmap = MD_CAP_FULL_SET;
min_bitmap_num = get_bit_set_num(min_bitmap);
for (i = 0; i < ARRAY_SIZE(md_rat_map); i++) {
if ((ref_rat & md_rat_map[i]) != ref_rat)
continue;
num = get_bit_set_num(md_rat_map[i]);
if (min_bitmap_num > num) {
min_bitmap = md_rat_map[i];
min_bitmap_num = num;
idx_at_support_list = i;
}
}
if (idx)
*idx = idx_at_support_list;
return min_bitmap;
}
static unsigned int get_capability_bit(char cap_str[])
{
if (cap_str == NULL)
return 0;
if ((strcmp(cap_str, "N") == 0) || (strcmp(cap_str, "n") == 0))
return MD_CAP_NR;
if ((strcmp(cap_str, "LF") == 0) || (strcmp(cap_str, "Lf") == 0)
|| (strcmp(cap_str, "lf") == 0))
return MD_CAP_FDD_LTE;
if ((strcmp(cap_str, "LT") == 0) || (strcmp(cap_str, "Lt") == 0)
|| (strcmp(cap_str, "lt") == 0))
return MD_CAP_TDD_LTE;
if ((strcmp(cap_str, "W") == 0) || (strcmp(cap_str, "w") == 0))
return MD_CAP_WCDMA;
if ((strcmp(cap_str, "C") == 0) || (strcmp(cap_str, "c") == 0))
return MD_CAP_CDMA2000;
if ((strcmp(cap_str, "T") == 0) || (strcmp(cap_str, "t") == 0))
return MD_CAP_TDS_CDMA;
if ((strcmp(cap_str, "G") == 0) || (strcmp(cap_str, "g") == 0))
return MD_CAP_GSM;
return 0;
}
#define MAX_CAP_STR_LENGTH 64
static unsigned int ccci_rat_str_to_bitmap(char str[])
{
char tmp_str[MAX_CAP_STR_LENGTH];
unsigned int tmp_str_curr_pos = 0;
unsigned int bitmap = 0;
int str_len;
int i;
if (str == NULL)
return 0;
str_len = strlen(str);
for (i = 0; i < str_len; i++) {
if (str[i] == ' ')
continue;
if (str[i] == '\t')
continue;
if ((str[i] == '/') || (str[i] == '\\') || (str[i] == '_')) {
if (tmp_str_curr_pos) {
tmp_str[tmp_str_curr_pos] = 0;
bitmap |= get_capability_bit(tmp_str);
}
tmp_str_curr_pos = 0;
continue;
}
if (tmp_str_curr_pos < (MAX_CAP_STR_LENGTH-1)) {
tmp_str[tmp_str_curr_pos] = str[i];
tmp_str_curr_pos++;
} else
break;
}
if (tmp_str_curr_pos) {
tmp_str[tmp_str_curr_pos] = 0;
bitmap |= get_capability_bit(tmp_str);
}
return bitmap;
}
unsigned int get_md_bin_capability(int md_id)
{
int img_type;
img_type = get_md_img_type(md_id);
if (img_type < 0)
return 0;
if (img_type < ARRAY_SIZE(md_img_capability_map))
return md_img_capability_map[img_type];
return 0;
}
EXPORT_SYMBOL(get_md_bin_capability);
int check_rat_at_md_img(int md_id, char str[])
{
unsigned int rat, cap;
rat = get_capability_bit(str);
cap = get_md_bin_capability(md_id);
if (rat & cap)
return 1;
return 0;
}
EXPORT_SYMBOL(check_rat_at_md_img);
static unsigned int s_md_rt_wm_id_bitmap[MAX_MD_NUM_AT_LK];
static unsigned int s_md_rt_wm_id[MAX_MD_NUM_AT_LK];
void set_soc_md_rt_rat(int md_id, unsigned int bitmap, unsigned int id)
{
if ((md_id < 0) || (md_id >= MAX_MD_NUM_AT_LK))
return;
s_md_rt_wm_id_bitmap[md_id] = bitmap;
s_md_rt_wm_id[md_id] = id;
}
EXPORT_SYMBOL(set_soc_md_rt_rat);
unsigned int get_soc_md_rt_rat(int md_id)
{
if ((md_id < 0) || (md_id >= MAX_MD_NUM_AT_LK))
return 0;
return s_md_rt_wm_id_bitmap[md_id];
}
EXPORT_SYMBOL(get_soc_md_rt_rat);
unsigned int get_soc_md_rt_rat_idx(int md_id)
{
if ((md_id < 0) || (md_id >= MAX_MD_NUM_AT_LK))
return 0;
return s_md_rt_wm_id[md_id];
}
EXPORT_SYMBOL(get_soc_md_rt_rat_idx);
int check_rat_at_rt_setting(int md_id, char str[])
{
unsigned int rat, cap;
rat = get_capability_bit(str);
cap = get_soc_md_rt_rat(md_id);
if (rat & cap)
return 1;
return 0;
}
EXPORT_SYMBOL(check_rat_at_rt_setting);
int set_soc_md_rt_rat_by_idx(int md_id, unsigned int wm_idx)
{
unsigned int rat_bitmap, cap;
cap = get_md_bin_capability(md_id);
if (!wm_idx)
return -1;
if (wm_idx >= ARRAY_SIZE(md_rat_map)) {
pr_info("CCCI: %s get not support wm_idx:%u\n", __func__, wm_idx);
return -1;
}
rat_bitmap = md_rat_map[wm_idx];
if (!rat_bitmap) {
pr_info("CCCI: %s get invalid wm_idx:%u\n", __func__, wm_idx);
return -1;
}
if ((rat_bitmap & cap) != rat_bitmap) {
pr_info("CCCI:%s: md img cap not support wm_idx: %u [c:0x%x|s:0x%x]\n",
__func__, wm_idx, cap, rat_bitmap);
return -1;
}
set_soc_md_rt_rat(md_id, rat_bitmap, wm_idx);
pr_info("CCCI:%s:wm_idx[%u][c:0x%x|s:0x%x]\n", __func__, wm_idx, cap, rat_bitmap);
return 0;
}
EXPORT_SYMBOL(set_soc_md_rt_rat_by_idx);
int set_soc_md_rt_rat_str(int md_id, char str[])
{
unsigned int rat_bitmap, prefer, cap, id;
cap = get_md_bin_capability(md_id);
id = get_rat_id_by_bitmap(cap);
if (id == 0) {
pr_info("CCCI: %s: should not run to here.MD cap not in support list!\n",
__func__);
return -1;
}
if (!str) {
pr_info("CCCI: %s get NULL ptr!\n", __func__);
set_soc_md_rt_rat(md_id, cap, id);
return 1;
}
if (strlen(str) == 0) {
pr_info("CCCI: %s str empty, set default value!\n", __func__);
set_soc_md_rt_rat(md_id, cap, id);
return 1;
}
rat_bitmap = ccci_rat_str_to_bitmap(str);
/* LTE only mode default use lwg mode */
if (rat_bitmap == (MD_CAP_TDD_LTE|MD_CAP_FDD_LTE)) {
set_soc_md_rt_rat(md_id,
(MD_CAP_TDD_LTE|MD_CAP_FDD_LTE|MD_CAP_WCDMA|MD_CAP_GSM), id);
pr_info("CCCI:%s:LTE only mode set lwg rat[%s](r:0x%x|c:0x%x)\n",
__func__, str, rat_bitmap, cap);
return 0;
}
prefer = find_prefer_val(rat_bitmap, &id);
if ((prefer == 0) || ((prefer & cap) != prefer)) {
pr_info("CCCI:%s:rat[%s](r:0x%x|p:0x%x|c:0x%x) not support!\n",
__func__, str, rat_bitmap, prefer, cap);
set_soc_md_rt_rat(md_id, cap, id);
return 1;
}
set_soc_md_rt_rat(md_id, prefer, id);
pr_info("CCCI:%s:rat[%s](r:0x%x|p:0x%x|c:0x%x)[%u]\n",
__func__, str, rat_bitmap, prefer, cap, id);
return 0;
}
EXPORT_SYMBOL(set_soc_md_rt_rat_str);
@@ -0,0 +1,195 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2017 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <asm/ioctl.h>
#include <linux/compiler.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif
#include "ccci_util_log.h"
#include "ccci_util_lib_main.h"
/* PIN broadcast event defination */
struct pin_status_event {
int pin_value;
char pin_name[32];
};
struct pin_event_user_ctrl {
struct pin_status_event pin_event;
int pin_update;
struct list_head entry;
};
static dev_t s_pin_status_dev;
static struct cdev s_pin_char_dev;
static struct class *s_ccci_pin_class;
static struct pin_status_event *pin_event;
static wait_queue_head_t pin_event_wait;
static spinlock_t pin_event_update_lock;
static struct list_head user_list;
void inject_pin_status_event(int pin_value, const char pin_name[])
{
struct pin_event_user_ctrl *user_ctrl = NULL;
int ret = 0;
spin_lock(&pin_event_update_lock);
if (pin_name != NULL)
ret = snprintf(pin_event->pin_name, 32, "%s", pin_name);
else
ret = snprintf(pin_event->pin_name, 32, "%s", "----");
if (ret < 0 || ret >= 32)
CCCI_UTIL_ERR_MSG(
"%s-%d:snprintf fail,ret=%d\n",
__func__, __LINE__, ret);
pin_event->pin_value = pin_value;
list_for_each_entry(user_ctrl, &user_list, entry)
user_ctrl->pin_update = 1;
wake_up_interruptible(&pin_event_wait);
spin_unlock(&pin_event_update_lock);
}
static int ccci_util_pin_bc_open(struct inode *inode, struct file *filp)
{
struct pin_event_user_ctrl *user_ctrl;
user_ctrl = kzalloc(sizeof(struct pin_event_user_ctrl), GFP_KERNEL);
if (user_ctrl == NULL)
return -ENOMEM;
INIT_LIST_HEAD(&user_ctrl->entry);
filp->private_data = user_ctrl;
spin_lock(&pin_event_update_lock);
list_add_tail(&user_ctrl->entry, &user_list);
spin_unlock(&pin_event_update_lock);
return 0;
}
static int ccci_util_pin_bc_release(struct inode *inode, struct file *filp)
{
struct pin_event_user_ctrl *user_ctrl;
spin_lock(&pin_event_update_lock);
user_ctrl = filp->private_data;
user_ctrl->pin_update = 0;
list_del(&user_ctrl->entry);
spin_unlock(&pin_event_update_lock);
kfree(user_ctrl);
return 0;
}
static ssize_t ccci_util_pin_bc_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
struct pin_event_user_ctrl *user_ctrl;
int ret;
user_ctrl = filp->private_data;
if (filp->f_flags & O_NONBLOCK) {
spin_lock(&pin_event_update_lock);
if (user_ctrl->pin_update == 0) {
spin_unlock(&pin_event_update_lock);
return 0;
}
memcpy(&user_ctrl->pin_event, pin_event, sizeof(struct pin_status_event));
spin_unlock(&pin_event_update_lock);
if (copy_to_user(buf, &user_ctrl->pin_event, sizeof(struct pin_status_event)))
return -EFAULT;
} else {
ret = wait_event_interruptible(pin_event_wait, user_ctrl->pin_update == 1);
if (ret < 0)
return -EINTR;
spin_lock(&pin_event_update_lock);
user_ctrl->pin_update = 0;
memcpy(&user_ctrl->pin_event, pin_event, sizeof(struct pin_status_event));
spin_unlock(&pin_event_update_lock);
if (copy_to_user(buf, &user_ctrl->pin_event, sizeof(struct pin_status_event)))
return -EFAULT;
}
return sizeof(struct pin_status_event);
}
static unsigned int ccci_util_pin_bc_poll(struct file *filp, struct poll_table_struct *wait)
{
struct pin_event_user_ctrl *user_ctrl;
unsigned int mask = 0;
user_ctrl = filp->private_data;
poll_wait(filp, &pin_event_wait, wait);
if (user_ctrl->pin_update == 1)
mask |= POLLIN|POLLRDNORM;
return mask;
}
static const struct file_operations pin_sta_bc_fops = {
.owner = THIS_MODULE,
.open = ccci_util_pin_bc_open,
.read = ccci_util_pin_bc_read,
.poll = ccci_util_pin_bc_poll,
.release = ccci_util_pin_bc_release,
};
int ccci_util_pin_broadcast_init(void)
{
int ret;
pin_event = kzalloc(sizeof(struct pin_status_event), GFP_KERNEL);
if (pin_event == NULL)
goto _exit;
spin_lock_init(&pin_event_update_lock);
init_waitqueue_head(&pin_event_wait);
INIT_LIST_HEAD(&user_list);
ret = alloc_chrdev_region(&s_pin_status_dev, 0, 1, "ccci_pin_sta");
if (ret != 0) {
CCCI_UTIL_ERR_MSG("alloc chrdev fail for ccci_pin_sta(%d)\n", ret);
goto _exit_1;
}
cdev_init(&s_pin_char_dev, &pin_sta_bc_fops);
s_pin_char_dev.owner = THIS_MODULE;
ret = cdev_add(&s_pin_char_dev, s_pin_status_dev, 1);
if (ret) {
CCCI_UTIL_ERR_MSG("cdev_add failed\n");
goto _exit_2;
}
s_ccci_pin_class = class_create(THIS_MODULE, "ccci_pin_sta");
device_create(s_ccci_pin_class, NULL, s_pin_status_dev, NULL, "ccci_pin_sta");
return 0;
_exit_2:
cdev_del(&s_pin_char_dev);
_exit_1:
unregister_chrdev_region(s_pin_status_dev, 1);
_exit:
kfree(pin_event);
return -1;
}
@@ -0,0 +1,115 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#include <linux/types.h>
#include <asm/cacheflush.h>
#include <mt-plat/mtk_ccci_common.h>
#include "ccci_util_sib.h"
#include "ccci_util_log.h"
static struct ccci_sib_region ccci_sib;
static ssize_t ccci_sib_read(struct file *file, char __user *buf,
size_t size, loff_t *ppos)
{
unsigned int *read_ptr;
unsigned int read_pos, read_len, available;
read_ptr = file->private_data;
read_pos = *read_ptr;
available = ccci_sib.size - read_pos;
read_len = size < available ? size : available;
if (read_len == 0)
return 0;
__inval_dcache_area(ccci_sib.base_ap_view_vir + read_pos, read_len);
if (copy_to_user(buf,
ccci_sib.base_ap_view_vir + read_pos,
read_len)) {
pr_notice("[ccci0/util]ccci_sib: copy_to_user fail\n");
return -EFAULT;
}
*read_ptr = read_pos + read_len;
return read_len;
}
unsigned int ccci_sib_poll(struct file *fp, struct poll_table_struct *poll)
{
unsigned int *read_ptr;
unsigned int read_pos;
read_ptr = fp->private_data;
read_pos = *read_ptr;
if (ccci_sib.size == read_pos)
return 0;
return POLLIN | POLLRDNORM;
}
static int ccci_sib_open(struct inode *inode, struct file *file)
{
unsigned int *read_ptr;
read_ptr = kzalloc(sizeof(unsigned int), GFP_KERNEL);
if (read_ptr == NULL)
return -1;
file->private_data = read_ptr;
return 0;
}
static int ccci_sib_close(struct inode *inode, struct file *file)
{
unsigned int *read_ptr;
read_ptr = file->private_data;
kfree(read_ptr);
return 0;
}
static const struct file_operations ccci_sib_fops = {
.read = ccci_sib_read,
.open = ccci_sib_open,
.release = ccci_sib_close,
.poll = ccci_sib_poll,
};
static void ccci_sib_smem_remap(void)
{
phys_addr_t md_sib_mem_addr;
unsigned int md_sib_mem_size;
get_md_sib_mem_info(&md_sib_mem_addr, &md_sib_mem_size);
ccci_sib.base_ap_view_phy = md_sib_mem_addr;
ccci_sib.size = md_sib_mem_size;
ccci_sib.base_ap_view_vir =
ccci_map_phy_addr(md_sib_mem_addr, md_sib_mem_size);
ccci_sib.base_md_view_phy = 0;
pr_notice(
"[ccci0/util]md sib mem info: (0x%llx 0x%llx %p %d)\n",
(unsigned long long)ccci_sib.base_ap_view_phy,
(unsigned long long)ccci_sib.base_md_view_phy,
ccci_sib.base_ap_view_vir,
ccci_sib.size);
}
void ccci_sib_init(void)
{
struct proc_dir_entry *ccci_sib_proc;
ccci_sib_proc = proc_create("ccci_sib", 0440, NULL, &ccci_sib_fops);
if (ccci_sib_proc == NULL) {
pr_notice("[ccci0/util]fail to create proc entry for sib dump\n");
return;
}
ccci_sib_smem_remap();
}
@@ -0,0 +1,17 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2015 MediaTek Inc.
*/
#ifndef __CCCI_UTIL_SIB_H__
#define __CCCI_UTIL_SIB_H__
struct ccci_sib_region {
phys_addr_t base_md_view_phy;
phys_addr_t base_ap_view_phy;
void __iomem *base_ap_view_vir;
unsigned int size;
};
#endif