static int set_hw_reason(int reason)
{
char filename[32] = "";
int hw_reason = reason;
struct file *filp = NULL;
ssize_t nread;
int pnum = get_partition_num_by_name("misc");
if (pnum < 0) {
pr_info("unknown partition number for misc partition\n");
return 0;
}
snprintf(filename, 32, "/dev/block/mmcblk0p%d", pnum);
filp = filp_open(filename, O_RDWR, 0);
if (IS_ERR(filp)) {
pr_info("unable to open file: %s\n", filename);
return PTR_ERR(filp);
}
filp->f_pos = 624;
nread = kernel_write(filp, (char *)&hw_reason, sizeof(int), filp->f_pos);
pr_info("wrire: %X (%d)\n", hw_reason, nread);
if (filp)
filp_close(filp, NULL);
return 1;
}
int32 write_conf_to_file(int8* name, int8 * pc_arr)
{
INI_FILE * fp;
int32 len;
#ifdef INI_KO_MODULE
fp = filp_open(NVRAM_CUST_FILE, O_CREAT|O_RDWR, 0664);
if (IS_ERR(fp))
{
INI_DEBUG("open %s failed", NVRAM_CUST_FILE);
return INI_FAILED;
}
#else
fp = fopen(NVRAM_CUST_FILE, "w+");
if (NULL == fp)
{
INI_DEBUG("open %s failed!:%s ", NVRAM_CUST_FILE, strerror(errno));
return INI_FAILED;
}
#endif
INI_DEBUG("open %s succ", NVRAM_CUST_FILE);
#ifdef INI_KO_MODULE
len = kernel_write(fp, pc_arr, HISI_CUST_NVRAM_LEN, 0);
#else
len = fwrite(pc_arr, 1, HISI_CUST_NVRAM_LEN, fp);
#endif
INI_DEBUG("write len:%d", len);
ini_file_close(fp);
return INI_SUCC;
}
/*
* Preparse a big key
*/
int big_key_preparse(struct key_preparsed_payload *prep)
{
struct path *path = (struct path *)&prep->payload.data[big_key_path];
struct file *file;
ssize_t written;
size_t datalen = prep->datalen;
int ret;
ret = -EINVAL;
if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
goto error;
/* Set an arbitrary quota */
prep->quotalen = 16;
prep->payload.data[big_key_len] = (void *)(unsigned long)datalen;
if (datalen > BIG_KEY_FILE_THRESHOLD) {
/* Create a shmem file to store the data in. This will permit the data
* to be swapped out if needed.
*
* TODO: Encrypt the stored data with a temporary key.
*/
file = shmem_kernel_file_setup("", datalen, 0);
if (IS_ERR(file)) {
ret = PTR_ERR(file);
goto error;
}
written = kernel_write(file, prep->data, prep->datalen, 0);
if (written != datalen) {
ret = written;
if (written >= 0)
ret = -ENOMEM;
goto err_fput;
}
/* Pin the mount and dentry to the key so that we can open it again
* later
*/
*path = file->f_path;
path_get(path);
fput(file);
} else {
/* Just store the data in a buffer */
void *data = kmalloc(datalen, GFP_KERNEL);
if (!data)
return -ENOMEM;
prep->payload.data[big_key_data] = data;
memcpy(data, prep->data, prep->datalen);
}
return 0;
err_fput:
fput(file);
error:
return ret;
}
static ssize_t htc_debug_write(struct file *file, const char __user *buffer,
size_t count, loff_t *ppos)
{
char buf[FLAG_LEN+3];
char filename[32] = "";
struct file *filp = NULL;
ssize_t nread;
int pnum;
SECMSG("%s called (count:%d)\n", __func__, (int)count);
if (count != sizeof(buf)){
printk(KERN_ERR"count != sizeof(buf)\n");
return -EFAULT;
}
if (copy_from_user(buf, buffer, count))
return -EFAULT;
memset(htc_debug_flag,0,FLAG_LEN+1);
memcpy(htc_debug_flag,buf+2,FLAG_LEN);
SECMSG("Receive :%s\n",buf);
SECMSG("Flag :%s\n",htc_debug_flag);
pnum = get_partition_num_by_name("misc");
if (pnum < 0) {
printk(KERN_ERR"unknown partition number for misc partition\n");
return 0;
}
snprintf(filename, 32, "/dev/block/mmcblk0p%d", pnum);
filp = filp_open(filename, O_RDWR, 0);
if (IS_ERR(filp)) {
printk(KERN_ERR"unable to open file: %s\n", filename);
return PTR_ERR(filp);
}
SECMSG("%s: offset :%d\n", __func__, offset);
filp->f_pos = offset;
nread = kernel_write(filp, buf, FLAG_LEN+2, filp->f_pos);
SECMSG("%s:wrire buf: %s (%zd)\n", __func__, buf, nread);
if (filp)
filp_close(filp, NULL);
return count;
}
// /data/aaa
int my_init(void) {
char *buff;
struct file *filp;
int ret;
filp = filp_open( "/data/bbb", O_WRONLY|O_TRUNC|O_CREAT, 0666 );
if( filp == 0 )
return 0;
buff = (char*)__get_free_pages( GFP_KERNEL, 0 );
strcpy(buff, "hello world");
ret = kernel_write( filp, buff, strlen(buff), 0 );
printk("ret=%d\n", ret );
free_pages( (unsigned long)buff, 0 );
filp_close( filp, 0 );
return 0;
}
static int write_env_area(char *env_buf)
{
int i,checksum = 0;
int result = 0;
int ret = 0;
loff_t pos = 0;
mm_segment_t old_fs;
struct file *write_fp;
memcpy(env_buf, ENV_SIG, sizeof(g_env.sig_head));
memcpy(env_buf + CFG_ENV_SIG_1_OFFSET, ENV_SIG, sizeof(g_env.sig_tail));
for (i = 0; i < (CFG_ENV_DATA_SIZE); i++) {
checksum += *(env_buf + CFG_ENV_DATA_OFFSET + i);
}
*((int *)env_buf + CFG_ENV_CHECKSUM_OFFSET / 4) = checksum;
write_fp = filp_open(MISC_PATH, O_RDWR, 0);
if (IS_ERR(write_fp)) {
result = PTR_ERR(write_fp);
pr_err("[%s]File open return fail,result=%d file=%p\n",
MODULE_NAME, result, write_fp);
goto filp_open_fail;
}
pos += CFG_ENV_OFFSET;
ret = kernel_write(write_fp, (u32*)env_buf, CFG_ENV_SIZE, pos);
if (ret < 0) {
pr_err("[%s]Kernel write env fail\n", MODULE_NAME);
result = -1;
}
old_fs = get_fs();
set_fs(get_ds());
ret = vfs_fsync(write_fp, 0);
if (ret < 0) {
pr_warn("[%s]Kernel write env sync fail\n", MODULE_NAME);
}
set_fs(old_fs);
filp_close(write_fp, 0);
filp_open_fail:
return (result);
}
/* Init task - the job of this task is to initialise all
* installed drivers, mount the root filesystem and
* bootstrap the system */
int init_task(void *priv)
{
uint32_t ret;
struct file *file;
char buf[20];
int rval;
/* Initialise kernel subsystems */
blk_init();
vfs_init();
pci_init();
do_initcalls();
/* Mount the root filesystem etc.. */
if ( vfs_mount_root("ext2", "floppy0") ) {
panic("Unable to mount root filesystem\n");
}
file = kernel_open("/test.txt", 0);
if ( NULL == file ) {
printk("init_task: open failed, returned %u\n", -1);
} else {
rval = kernel_read(file, buf, 16);
if ( rval < 0 )
printk("read error: %d\n", rval);
else if ( rval == 0 )
printk("read returned EOF\n");
else {
buf[rval] = '\0';
printk("read: %s.\n", buf);
}
rval = kernel_write(file, buf, 16);
kernel_close(file);
}
ret = _kernel_exec("/bin/bash");
ret = _kernel_exec("/sbin/init");
ret = _kernel_exec("/bin/cat");
printk("exec: /sbin/init: %i\n", (int)ret);
return ret;
}
int _sys_write(unsigned int handle, const char *buf, size_t count)
{
struct file *fd;
struct task *me;
char *kbuf;
if ( handle == 1 ) {
return _sys_write_stdout(handle, (void *)buf, count);
}
kbuf = strdup_from_user(buf, UACCESS_KERNEL_OK);
if ( NULL == kbuf )
return -1; /* EFAULT or ENOMEM */
me = __this_task;
fd = fdt_entry_retr(me->fd_table, handle);
if ( NULL == fd )
return -1; /* EMAXFILE */
return kernel_write(fd, kbuf, count);
}
static unsigned long get_spendcnt_from_datefile()
{
struct file* fp;
int buf_len;
char _tmp_buf[20];
char value[20];
char *p = value;
unsigned long spendcnt_poweroff = 0;
//buf_len = strlen(buf);
fp = filp_open(DATE_FILENAME,O_RDONLY,0);
if(IS_ERR(fp))
{
printk("bryan---->open file /data/time_record.dat failed\n");
return spendcnt_poweroff;
}
else
{
sprintf(_tmp_buf, "%lu", batteryspendcnt);
buf_len = strlen(_tmp_buf);
kernel_write(fp, _tmp_buf, buf_len, 0);
kernel_read(fp,0,value,10);
filp_close(fp,NULL);
value[20]=0;
while(*p)
{
if(*p==0x0d)
{
*p=0;
break;
}
p++;
}
sscanf(value,"%d",&spendcnt_poweroff);
printk("bryan---->last poweroff_spendcnt = %d\n",spendcnt_poweroff);
}
return spendcnt_poweroff;
}
static void save_spendcnt_to_datefile()
{
struct file* fp;
int buf_len;
char _tmp_buf[20];
char value[20];
char *p = value;
unsigned long spendcnt_poweroff = 0;
fp = filp_open(DATE_FILENAME,O_WRONLY | O_CREAT,0);
if(IS_ERR(fp))
{
printk("bryan---->open file /data/time_record.dat failed\n");
}
else
{
sprintf(_tmp_buf, "%lu", batteryspendcnt);
buf_len = strlen(_tmp_buf);
kernel_write(fp, _tmp_buf, buf_len, 0);
filp_close(fp,NULL);
}
}
/**
* Synchronize memory mapping with the file.
* Called from process context.
*/
static void
tempesta_unmap_file(struct file *file, unsigned long addr, unsigned long len,
int node)
{
mm_segment_t oldfs;
MArea *ma;
loff_t off = 0;
ssize_t r;
mutex_lock(&map_mtx);
ma = ma_lookup(addr, node);
if (!ma) {
TDB_WARN("Cannot sync memory area for %#lx address at node"
" %d\n", addr, node);
goto err;
}
oldfs = get_fs();
set_fs(get_ds());
r = kernel_write(file, (void *)ma->start, len, &off);
if (r != len) {
TDB_WARN("Cannot sync mapping %lx of size %lu pages\n",
ma->start, ma->pages);
goto err_fs;
}
err_fs:
set_fs(oldfs);
err:
fput(file);
ma_free(addr, node);
mutex_unlock(&map_mtx);
}
ssize_t expdb_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
return kernel_write(filp, buf, len, off);
}
static void rk2918_battery_timer_work(struct work_struct *work)
{
rk2918_get_bat_status(gBatteryData);
rk2918_get_bat_health(gBatteryData);
rk2918_get_bat_present(gBatteryData);
rk2918_get_bat_voltage(gBatteryData);
//to prevent gBatCapacity be changed sharply
if (gBatCapacity < 0)
{
gBatCapacity = 0;
}
else
{
if (gBatCapacity > 100)
{
gBatCapacity = 100;
}
}
rk2918_get_bat_capacity(gBatteryData);
if (rk29_battery_dbg_level)
{
if (++AdcTestCnt >= 20)
{
AdcTestCnt = 0;
printk("\nchg_ok_level =%d, chg_ok= %d, gBatStatus = %d, adc_val = %d, TrueBatVol = %d,gBatVol = %d, gBatCap = %d, captmp = %d, sec = %lu, time_chg_flag = %d, first_flag = %d\n",
gBatteryData->charge_ok_level, gpio_get_value(gBatteryData->charge_ok_pin), gBatStatus, AdcTestvalue, adc_to_voltage(AdcTestvalue),
gBatVoltage, gBatCapacity, capacitytmp, batteryspendcnt, time_chg_flag, first_flag);
}
}
/*update battery parameter after adc and capacity has been changed*/
if(((gBatStatus != gBatLastStatus) || (gBatPresent != gBatLastPresent) || (gBatCapacity != gBatLastCapacity))&&(suspend_flag==0))
{
//for debug
if (rk29_battery_dbg_level)
{
char _tmp_buf[250];
int buf_len = 0;
struct file* fp;
sprintf(_tmp_buf, "gBatStatus = %d, adc_val = %d, TrueBatVol = %d,gBatVol = %d, gBatCap = %d, captmp = %d, sec = %lu, inter_sec = %lu, time_chg_flag = %d, first_flag = %d\n",
gBatStatus, AdcTestvalue, ((AdcTestvalue * BAT_2V5_VALUE * (BAT_PULL_UP_R + BAT_PULL_DOWN_R)) / (1024 * BAT_PULL_DOWN_R)),
gBatVoltage, gBatCapacity, capacitytmp, batteryspendcnt, batteryspendcnt - last_batteryspendcnt, time_chg_flag, first_flag);
buf_len = strlen(_tmp_buf);
fp = filp_open(BATT_DBG_FILE,O_RDWR | O_APPEND | O_CREAT, 0);
if(IS_ERR(fp))
{
printk("bryan---->open file /data/bat_dbg_record.dat failed\n");
}
else
{
kernel_write(fp, _tmp_buf, buf_len ,buf_offset);
filp_close(fp,NULL);
buf_offset += buf_len;
}
last_batteryspendcnt = batteryspendcnt;
}
gBatLastStatus = gBatStatus;
gBatLastPresent = gBatPresent;
gBatLastCapacity = gBatCapacity;
power_supply_changed(&gBatteryData->battery);
}
}
/*
* Preparse a big key
*/
int big_key_preparse(struct key_preparsed_payload *prep)
{
struct path *path = (struct path *)&prep->payload.data[big_key_path];
struct file *file;
u8 *enckey;
u8 *data = NULL;
ssize_t written;
size_t datalen = prep->datalen;
int ret;
ret = -EINVAL;
if (datalen <= 0 || datalen > 1024 * 1024 || !prep->data)
goto error;
/* Set an arbitrary quota */
prep->quotalen = 16;
prep->payload.data[big_key_len] = (void *)(unsigned long)datalen;
if (datalen > BIG_KEY_FILE_THRESHOLD) {
/* Create a shmem file to store the data in. This will permit the data
* to be swapped out if needed.
*
* File content is stored encrypted with randomly generated key.
*/
size_t enclen = ALIGN(datalen, crypto_skcipher_blocksize(big_key_skcipher));
loff_t pos = 0;
/* prepare aligned data to encrypt */
data = kmalloc(enclen, GFP_KERNEL);
if (!data)
return -ENOMEM;
memcpy(data, prep->data, datalen);
memset(data + datalen, 0x00, enclen - datalen);
/* generate random key */
enckey = kmalloc(ENC_KEY_SIZE, GFP_KERNEL);
if (!enckey) {
ret = -ENOMEM;
goto error;
}
ret = big_key_gen_enckey(enckey);
if (ret)
goto err_enckey;
/* encrypt aligned data */
ret = big_key_crypt(BIG_KEY_ENC, data, enclen, enckey);
if (ret)
goto err_enckey;
/* save aligned data to file */
file = shmem_kernel_file_setup("", enclen, 0);
if (IS_ERR(file)) {
ret = PTR_ERR(file);
goto err_enckey;
}
written = kernel_write(file, data, enclen, &pos);
if (written != enclen) {
ret = written;
if (written >= 0)
ret = -ENOMEM;
goto err_fput;
}
/* Pin the mount and dentry to the key so that we can open it again
* later
*/
prep->payload.data[big_key_data] = enckey;
*path = file->f_path;
path_get(path);
fput(file);
kfree(data);
} else {
/* Just store the data in a buffer */
void *data = kmalloc(datalen, GFP_KERNEL);
if (!data)
return -ENOMEM;
prep->payload.data[big_key_data] = data;
memcpy(data, prep->data, prep->datalen);
}
return 0;
err_fput:
fput(file);
err_enckey:
kfree(enckey);
error:
kfree(data);
return ret;
}
