int closeFile(struct file *fp) { filp_close(fp,NULL); return 0; }
int mini_isp_debug_load_reg(char *reg_file,u32 *reg_key,u32 reg_max,u32 *reg_cnt) { struct kstat stat; mm_segment_t fs; struct file *fp = NULL; int file_flag = O_RDONLY; ssize_t ret = 0; u32 addr = 0; char addr_array[8] = {0}; char temp; bool bRegStart = false; if (NULL == reg_file) { print_error("%s param error", __func__); return -EINVAL; } print_debug("enter %s", __func__); /* must have the following 2 statement */ fs = get_fs(); set_fs(KERNEL_DS); fp = filp_open(reg_file, file_flag, 0666); if (IS_ERR_OR_NULL(fp)) { print_debug("no debug configuration file(%s) - do nothing, just skip it!\n",reg_file); return -1; } if (0 != vfs_stat(reg_file, &stat)) { print_error("failed to get file state!"); goto ERROR; } *reg_cnt = 0; print_debug("file size : %d", (u32) stat.size); while (0 < vfs_read(fp, &temp, 1, &fp->f_pos)) { switch (temp) { case '{': bRegStart = true; if (0 == vfs_read(fp, addr_array, 7, &fp->f_pos)) goto ERROR; addr = mini_atoi16(addr_array); if (*reg_cnt < reg_max){ reg_key[*reg_cnt]=addr; *reg_cnt=*reg_cnt+1; } break; case '}': bRegStart = false; break; default: break; } } /* must have the following 1 statement */ set_fs(fs); ERROR: if (NULL != fp) filp_close(fp, 0); return ret; }
/*write pattern*/ int write_pat(void *arg, int mode){ int i; int rc = 0; struct strops_args *kptr = (struct strops_args *)arg; struct file *readFilePtr = NULL;/*for input file pointer.*/ size_t inputInodeSize = 0;/* for get size of input file*/ struct file *writeFilePtr = NULL;/*for output file pointer.*/ char *out_dir = "temp.txt"; mm_segment_t oldfs; char *bytes;/* bytes from input file*/ char *temp; if(mode == 0){ /* write to temp file*/ readFilePtr = filp_open(kptr->in_file, O_EXCL, 0); } else{ readFilePtr = filp_open(out_dir, O_EXCL, 0); } if(!readFilePtr || IS_ERR(readFilePtr)){ printk("Open input file error: %d\n", (int)PTR_ERR(readFilePtr)); rc = -ENOENT; readFilePtr = NULL; goto out; } rc = isInFileValid(readFilePtr); if(rc < 0) goto close_input_file; inputInodeSize = i_size_read(readFilePtr->f_path.dentry->d_inode); /*check whether can open:*/ if(mode == 0){ writeFilePtr = filp_open(out_dir, O_WRONLY|O_CREAT|O_TRUNC, 0644); }else{ writeFilePtr = filp_open(kptr->in_file, O_WRONLY|O_CREAT|O_TRUNC, 0644); } if(!writeFilePtr || IS_ERR(writeFilePtr)){ printk("Open output file error: %d\n", (int)PTR_ERR(writeFilePtr)); rc = -ENOENT; writeFilePtr = NULL; goto close_input_file; } rc = isOutFileValid(writeFilePtr); if(rc < 0) goto close_output_file; bytes = (char *)kmalloc(PAGE * sizeof(char) + 1, GFP_KERNEL); if(IS_ERR(bytes)){ rc = -ENOMEM; goto close_output_file; } temp = (char *)kmalloc(PAGE * sizeof(char) + 1, GFP_KERNEL); if(IS_ERR(temp)){ rc = -ENOMEM; goto free_bytes; } oldfs = get_fs(); set_fs(get_ds()); if(mode == 0){/*write new file to temp*/ if(kptr->flag == 1){/* delete pattern*/ char *index; int page_count = 1; int dist = 0; while((inputInodeSize - readFilePtr->f_pos) > 0){ if(inputInodeSize - readFilePtr->f_pos >= PAGE){ int pos = readFilePtr->f_pos; dist = 0; rc = readFilePtr->f_op->read(readFilePtr, bytes, PAGE, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[PAGE] = '\0'; index = bytes; for(i = 0; i < kptr->res_len; i++){ if(kptr->res[i] < pos) continue; if(kptr->res[i] > page_count * PAGE) continue; dist = kptr->res[i] % PAGE - (index - bytes); strncpy(temp, index, dist); temp[dist] = '\0'; index += dist + kptr->old_len; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } strncpy(temp, index, PAGE - (index - bytes)); temp[PAGE - (index - bytes)] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } page_count++; }else{ int rest = inputInodeSize - readFilePtr->f_pos; int pos = readFilePtr->f_pos; dist = 0; rc = readFilePtr->f_op->read(readFilePtr, bytes, rest, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[rest] = '\0'; index = bytes; for(i = 0; i < kptr->res_len; i++){ if(kptr->res[i] < pos) continue; dist = kptr->res[i] % PAGE - (index - bytes); strncpy(temp, index, dist); temp[dist] = '\0'; index += dist + kptr->old_len; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } strncpy(temp, index, rest - (index - bytes)); temp[rest - (index - bytes)] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } } } if(kptr->flag == 2){/* replace pattern */ char *index; int page_count = 1; int dist = 0; while((inputInodeSize - readFilePtr->f_pos) > 0){ if(inputInodeSize - readFilePtr->f_pos >= PAGE){ int pos = readFilePtr->f_pos; dist = 0; rc = readFilePtr->f_op->read(readFilePtr, bytes, PAGE, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[PAGE] = '\0'; index = bytes; for(i = 0; i < kptr->res_len; i++){ if(kptr->res[i] < pos) continue; if(kptr->res[i] > page_count * PAGE) continue; dist = kptr->res[i] % PAGE - (index - bytes); strncpy(temp, index, dist); temp[dist] = '\0'; index += dist + kptr->old_len; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } strncpy(temp, kptr->new_str, kptr->new_len); temp[kptr->new_len] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } strncpy(temp, index, PAGE - (index - bytes)); temp[PAGE - (index - bytes)] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } page_count++; }else{ int rest = inputInodeSize - readFilePtr->f_pos; int pos = readFilePtr->f_pos; dist = 0; rc = readFilePtr->f_op->read(readFilePtr, bytes, rest, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[rest] = '\0'; index = bytes; for(i = 0; i < kptr->res_len; i++){ if(kptr->res[i] < pos) continue; dist = kptr->res[i] % PAGE - (index - bytes); strncpy(temp, index, dist); temp[dist] = '\0'; index += dist + kptr->old_len; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } strncpy(temp, kptr->new_str, kptr->new_len); temp[kptr->new_len] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } strncpy(temp, index, rest - (index - bytes)); temp[rest - (index - bytes)] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, temp ,strlen(temp), &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } } } /*goto mode 1 to write back*/ rc = write_pat(kptr, 1); } if(mode == 1){/*write temp to new file*/ while((inputInodeSize - readFilePtr->f_pos) > 0){ if(inputInodeSize - readFilePtr->f_pos >= PAGE){ rc = readFilePtr->f_op->read(readFilePtr, bytes, PAGE, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[PAGE] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, bytes ,PAGE, &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } }else{ int rest = inputInodeSize - readFilePtr->f_pos; rc = readFilePtr->f_op->read(readFilePtr, bytes, rest, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[rest] = '\0'; rc = writeFilePtr->f_op->write(writeFilePtr, bytes ,rest, &writeFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Write the hash key to header of output file reading failed!\n"); goto set_oldfs; } } } if(kptr->flag == 1){printk("Deletion Succeed!\n"); kptr->flag = -1;} if(kptr->flag == 2){printk("Replacement Succeed!\n");kptr->flag = -2;} if ((rc = vfs_unlink(readFilePtr->f_path.dentry->d_parent->d_inode, readFilePtr->f_path.dentry, NULL)) < 0) printk("vfs_unlink failed\n"); } set_oldfs: set_fs(oldfs); kfree(temp); free_bytes: kfree(bytes); close_output_file: filp_close(writeFilePtr, NULL); close_input_file: filp_close(readFilePtr, NULL); out: return rc; }
static int accel_do_calibrate(struct ssp_data *data, int iEnable) { int iSum[3] = { 0, }; int iRet = 0, iCount; struct file *cal_filp = NULL; mm_segment_t old_fs; if (iEnable) { data->accelcal.x = 0; data->accelcal.y = 0; data->accelcal.z = 0; set_accel_cal(data); iRet = enable_accel_for_cal(data); msleep(300); for (iCount = 0; iCount < CALIBRATION_DATA_AMOUNT; iCount++) { iSum[0] += data->buf[ACCELEROMETER_SENSOR].x; iSum[1] += data->buf[ACCELEROMETER_SENSOR].y; iSum[2] += data->buf[ACCELEROMETER_SENSOR].z; mdelay(10); } disable_accel_for_cal(data, iRet); data->accelcal.x = (iSum[0] / CALIBRATION_DATA_AMOUNT); data->accelcal.y = (iSum[1] / CALIBRATION_DATA_AMOUNT); data->accelcal.z = (iSum[2] / CALIBRATION_DATA_AMOUNT); if (data->accelcal.z > 0) data->accelcal.z -= MAX_ACCEL_1G; else if (data->accelcal.z < 0) data->accelcal.z += MAX_ACCEL_1G; } else { data->accelcal.x = 0; data->accelcal.y = 0; data->accelcal.z = 0; } ssp_info("do accel calibrate %d, %d, %d", data->accelcal.x, data->accelcal.y, data->accelcal.z); old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(CALIBRATION_FILE_PATH, O_CREAT | O_TRUNC | O_WRONLY, 0666); if (IS_ERR(cal_filp)) { pr_err("[SSP]: %s - Can't open calibration file\n", __func__); set_fs(old_fs); iRet = PTR_ERR(cal_filp); return iRet; } iRet = cal_filp->f_op->write(cal_filp, (char *)&data->accelcal, 3 * sizeof(int), &cal_filp->f_pos); if (iRet != 3 * sizeof(int)) { pr_err("[SSP]: %s - Can't write the accelcal to file\n", __func__); iRet = -EIO; } filp_close(cal_filp, current->files); set_fs(old_fs); set_accel_cal(data); return iRet; }
void set_packet_filter(void) { struct file *tcpFs = NULL; struct file *tcpFs6 = NULL; char tcpState[5]; unsigned short tcpDestPort = 0; if(tcpFs==NULL) { tcpFs = filp_open("/proc/net/tcpFilter", O_RDONLY, 0); if(IS_ERR(tcpFs)) { tcpFs = NULL; printk(KERN_ERR "Tiger> can't open /proc/net/tcpFilter\n"); } else { tcpFs6 = filp_open("/proc/net/tcpFilter6", O_RDONLY, 0); if(IS_ERR(tcpFs6)) { filp_close(tcpFs, NULL); tcpFs = NULL; tcpFs6 = NULL; printk(KERN_ERR "Tiger> can't open /proc/net/tcpFilter6\n"); } else { unsigned char oem_cmd_buf[128]; unsigned short *oem_ptr = (unsigned short *)oem_cmd_buf; unsigned short *port_start = NULL; int portCount = 0, cmdSize = 0; *oem_ptr = 0; oem_ptr ++; cmdSize ++; *oem_ptr = CLEAR_TABLE; oem_ptr ++; cmdSize ++; /* IPv4 */ //tcpFs->f_op->llseek(tcpFs, 0, 0); while(tcpFs->f_op->read(tcpFs, (char *)&tcpState, 4, &tcpFs->f_pos) == 4) { tcpState[4] = 0; tcpDestPort = (tcpState[0]<='9') ? (tcpState[0]-'0')<<12 : (tcpState[0]-'A'+10)<<12; tcpDestPort += (tcpState[1]<='9') ? (tcpState[1]-'0')<<8 : (tcpState[1]-'A'+10)<<8; tcpDestPort += (tcpState[2]<='9') ? (tcpState[2]-'0')<<4 : (tcpState[2]-'A'+10)<<4; tcpDestPort += (tcpState[3]<='9') ? (tcpState[3]-'0') : (tcpState[3]-'A'+10); //printk(KERN_ERR "filter tcp destination port (%d)\n", tcpDestPort); //printk(KERN_ERR "filter tcp destination port (%s)\n", tcpState); if(port_start == NULL) { port_start = oem_ptr; *oem_ptr = ADD_DEST_PORT; oem_ptr += 2; cmdSize += 2; *oem_ptr = tcpDestPort; oem_ptr ++; cmdSize ++; portCount = 1; } else { int i; // search dummy port for(i=0; i<portCount; i++) { if(*(port_start+i+2) == tcpDestPort) { break; } } if(i == portCount) { *oem_ptr = tcpDestPort; oem_ptr ++; cmdSize ++; portCount ++; if(portCount == 59) { oem_ptr = (unsigned short *)oem_cmd_buf; *oem_ptr = cmdSize<<1; *(port_start+1) = portCount; msm_proc_comm_oem_tcp_filter(oem_ptr, cmdSize<<1); *oem_ptr = 0; oem_ptr ++; cmdSize = 1; port_start = NULL; portCount = 0; } } } } /* IPv6 */ //tcpFs6->f_op->llseek(tcpFs6, 0, 0); while(tcpFs6->f_op->read(tcpFs6, (char *)&tcpState, 4, &tcpFs6->f_pos) == 4) { tcpState[4] = 0; tcpDestPort = (tcpState[0]<='9') ? (tcpState[0]-'0')<<12 : (tcpState[0]-'A'+10)<<12; tcpDestPort += (tcpState[1]<='9') ? (tcpState[1]-'0')<<8 : (tcpState[1]-'A'+10)<<8; tcpDestPort += (tcpState[2]<='9') ? (tcpState[2]-'0')<<4 : (tcpState[2]-'A'+10)<<4; tcpDestPort += (tcpState[3]<='9') ? (tcpState[3]-'0') : (tcpState[3]-'A'+10); //printk(KERN_ERR "filter tcp destination port (%d)\n", tcpDestPort); //printk(KERN_ERR "filter tcp destination port (%s)\n", tcpState); if(port_start == NULL) { port_start = oem_ptr; *oem_ptr = ADD_DEST_PORT; oem_ptr += 2; cmdSize += 2; *oem_ptr = tcpDestPort; oem_ptr ++; cmdSize ++; portCount = 1; } else { int i; // search dummy port for(i=0; i<portCount; i++) { if(*(port_start+i+2) == tcpDestPort) { break; } } if(i == portCount) { *oem_ptr = tcpDestPort; oem_ptr ++; cmdSize ++; portCount ++; if(portCount == 59) { oem_ptr = (unsigned short *)oem_cmd_buf; *oem_ptr = cmdSize<<1; *(port_start+1) = portCount; msm_proc_comm_oem_tcp_filter(oem_ptr, cmdSize<<1); *oem_ptr = 0; oem_ptr ++; cmdSize = 1; port_start = NULL; portCount = 0; } } } } *oem_ptr = UPDATE_COMPLETE; cmdSize ++; oem_ptr = (unsigned short *)oem_cmd_buf; *oem_ptr = cmdSize<<1; if(port_start != NULL) { *(port_start+1) = portCount; } msm_proc_comm_oem_tcp_filter(oem_ptr, cmdSize<<1); filp_close(tcpFs, NULL); tcpFs = NULL; filp_close(tcpFs6, NULL); tcpFs6 = NULL; } } } }
void osl_os_close_image(void *image) { if (image) filp_close((struct file *)image, NULL); }
void open_grip_caldata(struct ssp_data *data) { struct file *cal_filp = NULL; mm_segment_t old_fs; int cap_main_len = sizeof(data->gripcal.cap_main); int ref_cap_main_len = sizeof(data->gripcal.ref_cap_main); int useful_len = sizeof(data->gripcal.useful); int offset_len = sizeof(data->gripcal.offset); int len = cap_main_len + ref_cap_main_len + useful_len + offset_len; int temp; int ret; old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(CALIBRATION_FILE_PATH, O_RDONLY, S_IRUGO | S_IWUSR | S_IWGRP); if (IS_ERR(cal_filp)) { ret = PTR_ERR(cal_filp); if (ret != -ENOENT) pr_err("[SSP]: %s - Can't open calibration file.\n", __func__); else { pr_info("[SSP]: %s - There is no calibration file\n", __func__); data->gripcal.cap_main = 0; data->gripcal.ref_cap_main = 0; data->gripcal.useful = 0, data->gripcal.offset = 0; } set_fs(old_fs); data->gripcal.threshold = data->gripcal.init_threshold; data->gripcal.mode_set = true; goto slope; } ret = cal_filp->f_op->read(cal_filp, (char *)&data->gripcal, len, &cal_filp->f_pos); if (ret != len) { pr_err("[SSP]: %s - Can't read the cal data from file\n", __func__); data->gripcal.threshold = data->gripcal.init_threshold; } else { data->gripcal.threshold = data->gripcal.cap_main + data->gripcal.diff_threshold; } filp_close(cal_filp, current->files); set_fs(old_fs); data->gripcal.mode_set = true; slope: /* slope */ old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(SLOPE_FILE_PATH, O_RDONLY, S_IRUGO | S_IWUSR | S_IWGRP); if (IS_ERR(cal_filp)) { ret = PTR_ERR(cal_filp); if (ret != -ENOENT) pr_err("[SSP]: %s - Can't open slope file.\n", __func__); else { pr_info("[SSP]: %s - There is no slope file\n", __func__); data->gripcal.slope = 0; } set_fs(old_fs); goto temp; } ret = cal_filp->f_op->read(cal_filp, (char *)&data->gripcal.slope, sizeof(data->gripcal.slope), &cal_filp->f_pos); if (ret != sizeof(data->gripcal.slope)) { pr_err("[SSP]: %s - Can't read the slope from file\n", __func__); } filp_close(cal_filp, current->files); set_fs(old_fs); temp: /* temp */ temp = get_temp(); if (temp != TEMP_ERROR) data->gripcal.temp = temp; /* temp_cal */ old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(TEMP_CAL_FILE_PATH, O_RDONLY, S_IRUGO | S_IWUSR | S_IWGRP); if (IS_ERR(cal_filp)) { ret = PTR_ERR(cal_filp); if (ret != -ENOENT) pr_err("[SSP]: %s - Can't open temp_cal file.\n", __func__); else { pr_info("[SSP]: %s - There is no temp_cal file\n", __func__); data->gripcal.temp_cal = 0; } goto exit; } ret = cal_filp->f_op->read(cal_filp, (char *)&data->gripcal.temp_cal, sizeof(data->gripcal.temp_cal), &cal_filp->f_pos); if (ret != sizeof(data->gripcal.temp_cal)) { pr_err("[SSP]: %s - Can't read the temp_cal from file\n", __func__); } filp_close(cal_filp, current->files); exit: set_fs(old_fs); pr_info("[SSP]: %s - cal = (%d,%d,%d,%d)\n", __func__, data->gripcal.cap_main, data->gripcal.ref_cap_main, data->gripcal.useful, data->gripcal.offset); pr_info("[SSP]: %s - slope = %d\n", __func__, data->gripcal.slope); pr_info("[SSP]: %s - temp = %d\n", __func__, data->gripcal.temp); pr_info("[SSP]: %s - temp_cal = %d\n", __func__, data->gripcal.temp_cal); }
int dhd_write_rdwr_macaddr(struct ether_addr *mac) { #ifdef ENABLE_INSMOD_NO_FW_LOAD char *filepath = "/efs/wifi/mac/.mac.info"; #else char *filepath = "/efs/wifi/.mac.info"; #endif char *filepath_data = "/data/.mac.info"; struct file *fp_mac = NULL; char buf[18] = {0}; mm_segment_t oldfs = {0}; int ret = -1; if ((g_imac_flag != MACADDR_COB) && (g_imac_flag != MACADDR_MOD)) return 0; sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X\n", mac->octet[0], mac->octet[1], mac->octet[2], mac->octet[3], mac->octet[4], mac->octet[5]); /* File is always created. */ fp_mac = filp_open(filepath, O_RDWR | O_CREAT, 0664); if (IS_ERR(fp_mac)) { DHD_ERROR(("[WIFI] %s: File open error: %ld\n", filepath, PTR_ERR(fp_mac))); return -1; } else { oldfs = get_fs(); set_fs(get_ds()); if (fp_mac->f_mode & FMODE_WRITE) { ret = fp_mac->f_op->write(fp_mac, (const char *)buf, sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed" " to write into File: %s\n", buf, filepath)); else DHD_INFO(("[WIFI] Mac address [%s] written" " into File: %s\n", buf, filepath)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* /efs/wifi/.mac.info will be created */ fp_mac = filp_open(filepath_data, O_RDWR | O_CREAT, 0664); if (IS_ERR(fp_mac)) { DHD_ERROR(("[WIFI] %s: File open error: %ld\n", filepath, PTR_ERR(fp_mac))); return -1; } else { oldfs = get_fs(); set_fs(get_ds()); if (fp_mac->f_mode & FMODE_WRITE) { ret = fp_mac->f_op->write(fp_mac, (const char *)buf, sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed" " to write into File: %s\n", buf, filepath)); else DHD_INFO(("[WIFI] Mac address [%s] written" " into File: %s\n", buf, filepath)); } set_fs(oldfs); filp_close(fp_mac, NULL); } return 0; }
int dhd_check_rdwr_macaddr(struct dhd_info *dhd, dhd_pub_t *dhdp, struct ether_addr *mac) { struct file *fp_mac = NULL; struct file *fp_nvm = NULL; char macbuffer[18] = {0}; char randommac[3] = {0}; char buf[18] = {0}; char buf_temp[18] = {0}; #ifdef ENABLE_INSMOD_NO_FW_LOAD char *filepath = "/efs/wifi/mac/.mac.info"; #else char *filepath = "/efs/wifi/.mac.info"; #endif #ifdef CONFIG_TARGET_LOCALE_NA char *nvfilepath = "/data/misc/wifi/.nvmac.info"; #else #ifdef CONFIG_MACH_SAMSUNG_P4LTE char *nvfilepath = "/data/.mac.info"; char *nvfilepath2 = "/efs/wifi/.mac.info"; #else char *nvfilepath = "/efs/wifi/.nvmac.info"; char *nvfilepath2 = "/efs/imei/.nvmac.info"; #endif #endif char cur_mac[128] = {0}; char dummy_mac[ETHER_ADDR_LEN] = {0x00, 0x90, 0x4C, 0xC5, 0x12, 0x38}; char cur_macbuffer[18] = {0}; int ret = -1; g_imac_flag = MACADDR_NONE; fp_nvm = filp_open(nvfilepath, O_RDONLY, 0); if (IS_ERR(fp_nvm)) { /* file does not exist */ DHD_ERROR(("[WIFI] Fail to open %s, " "MAC address is missing or Wi-Fi only model\n", nvfilepath)); fp_nvm = filp_open(nvfilepath2, O_RDONLY, 0); } if (IS_ERR(fp_nvm)) { /* file does not exist */ DHD_ERROR(("[WIFI] Fail to open %s\n", nvfilepath2)); /* read MAC Address */ strcpy(cur_mac, "cur_etheraddr"); ret = dhd_wl_ioctl_cmd(dhdp, WLC_GET_VAR, cur_mac, sizeof(cur_mac), 0, 0); if (ret < 0) { DHD_ERROR(("Current READ MAC error \r\n")); memset(cur_mac , 0 , ETHER_ADDR_LEN); return -1; } else { DHD_ERROR(("MAC (OTP) : " "[%02X.%02X.%02X] \r\n", cur_mac[0], cur_mac[4], cur_mac[5])); } sprintf(cur_macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n", cur_mac[0], cur_mac[1], cur_mac[2], cur_mac[3], cur_mac[4], cur_mac[5]); fp_mac = filp_open(filepath, O_RDONLY, 0); if (IS_ERR(fp_mac)) { /* file does not exist */ /* read mac is the dummy mac (00:90:4C:C5:12:38) */ if (memcmp(cur_mac, dummy_mac, ETHER_ADDR_LEN) == 0) g_imac_flag = MACADDR_MOD_RANDOM; else if (strncmp(buf, "00:00:00:00:00:00", 17) == 0) g_imac_flag = MACADDR_MOD_RANDOM; else g_imac_flag = MACADDR_MOD; } else { int is_zeromac; ret = kernel_read(fp_mac, 0, buf, 18); filp_close(fp_mac, NULL); buf[17] = '\0'; is_zeromac = strncmp(buf, "00:00:00:00:00:00", 17); /*DHD_ERROR(("MAC (FILE): [%s] [%d] \r\n", buf, is_zeromac));*/ if (is_zeromac == 0) { DHD_ERROR(("Zero MAC detected." " Trying Random MAC.\n")); g_imac_flag = MACADDR_MOD_RANDOM; } else { sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]), (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); DHD_ERROR(("MAC (FILE): [%02X.%02X.%02X] " "[%d] \r\n", mac->octet[0], mac->octet[4], mac->octet[5], is_zeromac)); /* current MAC address is same as previous one */ if (memcmp(cur_mac, mac->octet, ETHER_ADDR_LEN) == 0) { g_imac_flag = MACADDR_NONE; } else { /* change MAC address */ if (0 == _dhd_set_mac_address(dhd, 0, mac)) { DHD_INFO(("%s: MACID is" " overwritten\n", __func__)); g_imac_flag = MACADDR_MOD; } else { DHD_ERROR(("%s: " "_dhd_set_mac_address()" " failed\n", __func__)); g_imac_flag = MACADDR_NONE; } } } } } else { /* COB type. only COB. */ /* Reading the MAC Address from .nvmac.info file * (the existed file or just created file) */ ret = kernel_read(fp_nvm, 0, buf, 18); /* to prevent abnormal string display when mac address * is displayed on the screen. */ buf[17] = '\0'; /*DHD_ERROR(("Read MAC : [%s] [%d] \r\n", buf, strncmp(buf, "00:00:00:00:00:00", 17)));*/ if ((buf[0] == '\0') || (strncmp(buf, "00:00:00:00:00:00", 17) == 0)) { g_imac_flag = MACADDR_COB_RANDOM; } else { if (!strncmp(buf, "12:34:56", 8)) { strncpy(buf_temp, buf+9, 8); snprintf(buf, 18, "00:12:34:%s", buf_temp); DHD_ERROR(("Wrong prefix is detected, 12:34:56 is changed as 00:12:34 : %d\n", sizeof(buf))); } sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]), (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); /* Writing Newly generated MAC ID to the Dongle */ if (0 == _dhd_set_mac_address(dhd, 0, mac)) { DHD_INFO(("%s: MACID is overwritten\n", __func__)); g_imac_flag = MACADDR_COB; } else { DHD_ERROR(("%s: _dhd_set_mac_address()" " failed\n", __func__)); } } filp_close(fp_nvm, NULL); } if ((g_imac_flag == MACADDR_COB_RANDOM) || (g_imac_flag == MACADDR_MOD_RANDOM)) { get_random_bytes(randommac, 3); sprintf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n", 0x00, 0x12, 0x34, randommac[0], randommac[1], randommac[2]); sscanf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X", (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]), (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); DHD_ERROR(("[WIFI] The Random Generated MAC ID : " "%02X.%02X.%02X\n", mac->octet[0], mac->octet[4], mac->octet[5])); if (0 == _dhd_set_mac_address(dhd, 0, mac)) { DHD_INFO(("%s: MACID is overwritten\n", __func__)); g_imac_flag = MACADDR_COB; } else { DHD_ERROR(("%s: _dhd_set_mac_address() failed\n", __func__)); } } return 0; }
/* Reutrn 0 when fail, return address when succeed */ unsigned long mtfs_kallsyms_lookup_name(const char *name) { #if defined (__linux__) && defined(__KERNEL__) mm_segment_t old_fs; struct file *file = NULL; loff_t pos = 0; #else int fd = 0; #endif int readlen = 0; char *buff = NULL; int offset = 0; int i = 0; unsigned long address = 0; int ret = 0; char *line = NULL; int keepon = 1; int line_found = 0; char *tmp_name = NULL; char *module_name = NULL; char *symbol_name = NULL; char *colon = NULL; MTFS_STRDUP(tmp_name, name); if (tmp_name == NULL) { MERROR("not enough memory\n"); goto out; } MTFS_ALLOC(buff, MTFS_KALLSYMS_BUFF_SIZE); if (buff == NULL) { MERROR("not enough memory\n"); goto out_free_name; } #if defined (__linux__) && defined(__KERNEL__) file = filp_open(PROC_KALLSYMS_PTAH, O_RDONLY, 0); if (IS_ERR(file)) { MERROR("failed to open %s, ret = %d\n", PROC_KALLSYMS_PTAH, PTR_ERR(file)); goto out_free_buff; } MASSERT(file->f_op->read); old_fs = get_fs(); set_fs(get_ds()); #else fd = open(PROC_KALLSYMS_PTAH, O_RDONLY); if (fd < 0) { MERROR("failed to open %s\n", PROC_KALLSYMS_PTAH); goto out_free_buff; } #endif if ((colon = strchr(tmp_name, ':')) != NULL) { *colon = '\0'; module_name = tmp_name; symbol_name = colon + 1; } else { module_name = NULL; symbol_name = tmp_name; } while (keepon) { #if defined (__linux__) && defined(__KERNEL__) readlen = file->f_op->read(file, buff + offset, MTFS_KALLSYMS_BUFF_SIZE - 1 - offset, &pos); #else readlen = read(fd, buff + offset, MTFS_KALLSYMS_BUFF_SIZE - 1 - offset); #endif if (readlen < 0) { MERROR("failed to read %s, ret = %d\n", PROC_KALLSYMS_PTAH, readlen); break; } offset += readlen; if (offset == 0) { break; } if (offset >= MTFS_KALLSYMS_BUFF_SIZE) { MERROR("offset: %d, readlen: %d\n", offset, readlen); } MASSERT(offset < MTFS_KALLSYMS_BUFF_SIZE); buff[offset] = '\0'; line = buff; for(i = 0; i < offset; i++) { if (buff[i] == '\n') { line_found = 1; buff[i] = '\0'; ret = mtfs_parse_kallsyms(line, module_name, symbol_name, &address); if (ret == 1) { keepon = 0; break; } else if (ret < 0) { keepon = 0; break; } else { line = buff + i + 1; /* Point to next line */ } } } if (keepon) { if (line != buff + offset) { MASSERT(line < buff + offset); if (line_found) { /* Try read again to complete */ memmove(buff, line, buff + offset - line); line_found = 0; offset = buff + offset - line; } else { /* The last line */ MASSERT(readlen < MTFS_KALLSYMS_BUFF_SIZE - 1); mtfs_parse_kallsyms(line, module_name, symbol_name, &address); /* Read again to make sure this is the EOF */ #if defined (__linux__) && defined(__KERNEL__) readlen = file->f_op->read(file, buff, MTFS_KALLSYMS_BUFF_SIZE - 1, &pos); #else readlen = read(fd, buff + offset, MTFS_KALLSYMS_BUFF_SIZE - 1); #endif if (readlen < 0) { MERROR("failed to read %s, ret = %d\n", PROC_KALLSYMS_PTAH, readlen); } else if (readlen > 0) { MERROR("buffer size(%d) is not long engough\n", MTFS_KALLSYMS_BUFF_SIZE); } break; } } else { offset = 0; } } } #if defined (__linux__) && defined(__KERNEL__) set_fs(old_fs); filp_close(file, NULL); #else close(fd); #endif out_free_buff: MTFS_FREE(buff, MTFS_KALLSYMS_BUFF_SIZE); out_free_name: if (colon) { *colon = ':'; } MTFS_FREE_STR(tmp_name); out: return address; }
/*============================================================================== [Function] rlog_pmaps_to_user ==============================================================================*/ static void rlog_pmaps_to_user( pid_t tgid, long lr, long pc, unsigned long addr ) { struct file *filp; mm_segment_t fs; char *buff = NULL; char *line_buff = NULL; char path[24]; int i; int read_size = 0; int line_size = 0; int pre_size = 0; memset( path, 0x00, sizeof(path) ); snprintf( path, 23, "/proc/%d/maps", tgid ); filp = filp_open( path, O_RDONLY , 0 ); if( IS_ERR(filp) ){ printk( "[RLOG]can't open %s\n", path ); return; } fs = get_fs(); set_fs( get_ds() ); buff = kzalloc( PMAPS_KALLOC_SIZE, GFP_KERNEL ); if( !buff ){ printk( "[RLOG]kzalloc failure\n" ); return; } line_buff = kzalloc( 512, GFP_KERNEL ); if( !line_buff ){ printk( "[RLOG]kzalloc failure\n" ); kfree( buff ); return; } do{ memset( buff, 0x00, PMAPS_KALLOC_SIZE ); read_size = filp->f_op->read( filp, buff, PMAPS_KALLOC_SIZE, &filp->f_pos ); if( read_size <= 0 ){ break; } for( i = 0; i < read_size; i++ ){ if( buff[i] == '\n' ){ memcpy( &line_buff[pre_size], &buff[i-line_size], line_size - pre_size + 1 ); rlog_check_pc_lr( line_buff, lr, pc, addr ); line_size = 0; pre_size = 0; memset( line_buff, 0x00, 512 ); } else { if( line_size < 250 ){ line_size++; } } } if( read_size == PMAPS_KALLOC_SIZE && line_size != 0 ){ memcpy( line_buff, &buff[i-line_size], line_size ); pre_size = line_size; line_size = 0; } }while( read_size == PMAPS_KALLOC_SIZE ); set_fs( fs ); filp_close( filp, NULL ); kfree( line_buff ); kfree( buff ); }
int dhd_custom_get_mac_address(unsigned char *buf) { int ret = 0; int maclen; int i = 0; struct file *fp; char macaddr[16]; char c = '\0'; if (!buf) return -1; fp = filp_open("/data/misc/wifi/wifiNvMacaddress", O_RDONLY, 0); if(IS_ERR(fp) || (fp == NULL)) { printk("djt %s open file err, fp = %x\n", __FUNCTION__, fp); return -1; } maclen = kernel_read(fp, 0, macaddr, 12); filp_close(fp, NULL); macaddr[12] = 0x00; //printk("zhaoruiqing macaddr %s\n", macaddr); for(i = 0; i < 6; i++) { unsigned int sum = 0; if(macaddr[i * 2] <= 'F' && macaddr[i * 2] >= 'A') { c = macaddr[i * 2] - 'A' + 10; } else if(macaddr[i * 2] <= 'f' && macaddr[i * 2] >= 'a') { c = macaddr[i * 2] - 'a' + 10; } else { c = macaddr[i * 2] - '0'; } sum = c * 16; if(macaddr[i * 2 + 1] <= 'F' && macaddr[i * 2 + 1] >= 'A') { c = macaddr[i * 2 + 1] - 'A' + 10; } else if(macaddr[i * 2 + 1] <= 'f' && macaddr[i * 2 + 1] >= 'a') { c = macaddr[i * 2 + 1] - 'a' + 10; } else { c = macaddr[i * 2 + 1] - '0'; } sum += c; printk("zhaoruiqing sum = %02x \n ", sum); buf[i] = (unsigned char)sum; } //printk("zhaoruiqing buf: %x\n ", buf); return ret; }
int dhd_read_macaddr(dhd_info_t *dhd) { struct file *fp = NULL; struct file *fpnv = NULL; char macbuffer[18] = {0}; mm_segment_t oldfs = {0}; char randommac[3] = {0}; char buf[18] = {0}; char* filepath = "/data/.mac.info"; char* nvfilepath = "/data/.nvmac.info"; int ret; //MAC address copied from nv fpnv = filp_open(nvfilepath, O_RDONLY, 0); if (IS_ERR(fpnv)) { start_readmac: fpnv = NULL; fp = filp_open(filepath, O_RDONLY, 0); if (IS_ERR(fp)) { /* File Doesn't Exist. Create and write mac addr.*/ fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); if(IS_ERR(fp)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); return -1; } oldfs = get_fs(); set_fs(get_ds()); /* Generating the Random Bytes for 3 last octects of the MAC address */ get_random_bytes(randommac, 3); sprintf(macbuffer,"%02X:%02X:%02X:%02X:%02X:%02X\n", 0x60,0xd0,0xa9,randommac[0],randommac[1],randommac[2]); DHD_INFO(("[WIFI] The Random Generated MAC ID : %s\n", macbuffer)); printk("[WIFI] The Random Generated MAC ID : %s\n", macbuffer); if(fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, (const char *)macbuffer, sizeof(macbuffer), &fp->f_pos); if(ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to write into File: %s\n", macbuffer, filepath)); else DHD_INFO(("[WIFI] Mac address [%s] written into File: %s\n", macbuffer, filepath)); } set_fs(oldfs); } /* Reading the MAC Address from .mac.info file( the existed file or just created file)*/ //rtn_value=kernel_read(fp, fp->f_pos, buf, 18); ret = kernel_read(fp, 0, buf, 18); } else { /* Reading the MAC Address from .nvmac.info file( the existed file or just created file)*/ ret = kernel_read(fpnv, 0, buf, 18); buf[17] ='\0'; // to prevent abnormal string display when mac address is displayed on the screen. printk("Read MAC : [%s] [%d] \r\n" , buf, strncmp(buf , "00:00:00:00:00:00" , 17)); if(strncmp(buf , "00:00:00:00:00:00" , 17) == 0) { filp_close(fpnv, NULL); goto start_readmac; } fp = filp_open(filepath, O_RDONLY, 0); if (IS_ERR(fp)) // If you want to write MAC address to /data/.mac.info once, { fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); if(IS_ERR(fp)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); return -1; } oldfs = get_fs(); set_fs(get_ds()); if(fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, (const char *)buf, sizeof(buf), &fp->f_pos); if(ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to write into File: %s\n", buf, filepath)); else DHD_INFO(("[WIFI] Mac address [%s] written into File: %s\n", buf, filepath)); } set_fs(oldfs); } ret = kernel_read(fp, 0, buf, 18); } if(ret) sscanf(buf,"%02X:%02X:%02X:%02X:%02X:%02X", &dhd->pub.mac.octet[0], &dhd->pub.mac.octet[1], &dhd->pub.mac.octet[2], &dhd->pub.mac.octet[3], &dhd->pub.mac.octet[4], &dhd->pub.mac.octet[5]); else DHD_ERROR(("dhd_bus_start: Reading from the '%s' returns 0 bytes\n", filepath)); if (fp) filp_close(fp, NULL); if (fpnv) filp_close(fpnv, NULL); /* Writing Newly generated MAC ID to the Dongle */ if (0 == _dhd_set_mac_address(dhd, 0, &dhd->pub.mac)) DHD_INFO(("dhd_bus_start: MACID is overwritten\n")); else DHD_ERROR(("dhd_bus_start: _dhd_set_mac_address() failed\n")); return 0; }
int sec_dhd_config_pm(dhd_pub_t *dhd, uint power_mode) { struct file *fp = NULL; char* filepath = "/data/.psm.info"; char iovbuf[WL_EVENTING_MASK_LEN + 12]; int ret = 0; /* Set PowerSave mode */ fp = filp_open(filepath, O_RDONLY, 0); if(IS_ERR(fp))// the file is not exist { /* Set PowerSave mode */ ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode)); if (ret < 0) goto err_out; fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); if(IS_ERR(fp)||(fp==NULL)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); } else { char buffer[2] = {1}; if(fp->f_mode & FMODE_WRITE) { sprintf(buffer,"1\n"); fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos); } if(fp) filp_close(fp, NULL); } return; } else { char buffer[1] = {0}; kernel_read(fp, fp->f_pos, buffer, 1); if(strncmp(buffer, "1",1)==0) { /* Set PowerSave mode */ ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode)); if (ret < 0) goto err_out; } else { /*Disable Power save features for CERTIFICATION*/ power_mode = 0; /* Set PowerSave mode */ ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode)); if (ret < 0) goto err_out; /* Disable MPC */ bcm_mkiovar("mpc", (char *)&power_mode, 4, iovbuf, sizeof(iovbuf)); ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); if (ret < 0) goto err_out; fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); if(IS_ERR(fp)||(fp==NULL)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath)); } else { char buffer[2] = {1}; if(fp->f_mode & FMODE_WRITE) { sprintf(buffer,"1\n"); fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos); } if(fp) filp_close(fp, NULL); } return; } } err_out: if(fp) filp_close(fp, NULL); return ret; }
static inline void dpram_close(struct file *filp) { filp_close(filp, current->files); }
int dhd_read_macaddr(struct dhd_info *dhd, struct ether_addr *mac) { struct file *fp = NULL; char macbuffer[18] = {0}; mm_segment_t oldfs = {0}; char randommac[3] = {0}; char buf[18] = {0}; char *filepath_efs = MACINFO_EFS; char buf_temp[18] = {0}; #ifdef CONFIG_TARGET_LOCALE_VZW char *nvfilepath = "/data/misc/wifi/.nvmac.info"; #else char *nvfilepath = NVMACINFO; #endif int ret = 0; fp = filp_open(filepath_efs, O_RDONLY, 0); if (IS_ERR(fp)) { start_readmac: /* File Doesn't Exist. Create and write mac addr.*/ fp = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } oldfs = get_fs(); set_fs(get_ds()); /* Generating the Random Bytes for 3 last octects of the MAC address */ get_random_bytes(randommac, 3); sprintf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n", 0x00, 0x12, 0x34, randommac[0], randommac[1], randommac[2]); DHD_ERROR(("[WIFI]The Random Generated MAC ID: %s\n", macbuffer)); if (fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, (const char *)macbuffer, sizeof(macbuffer), &fp->f_pos); if (ret < 0) DHD_ERROR(("[WIFI]MAC address [%s] Failed to write into File: %s\n", macbuffer, filepath_efs)); else DHD_ERROR(("[WIFI]MAC address [%s] written into File: %s\n", macbuffer, filepath_efs)); } set_fs(oldfs); /* Reading the MAC Address from .mac.info file( the existed file or just created file)*/ ret = kernel_read(fp, 0, buf, 18); } else { /* Reading the MAC Address from .mac.info file( the existed file or just created file)*/ ret = kernel_read(fp, 0, buf, 18); /* to prevent abnormal string display when mac address is displayed on the screen. */ buf[17] = '\0'; /*DHD_ERROR(("Read MAC : [%s] [%d] \r\n" , buf, strncmp(buf , "00:00:00:00:00:00" , 17))); */ if (strncmp(buf , "00:00:00:00:00:00" , 17) < 1) { DHD_ERROR(("goto start_readmac \r\n")); filp_close(fp, NULL); goto start_readmac; } } if (ret) { if (!strncmp(buf, "12:34:56", 8)) { strncpy(buf_temp, buf+9, 8); snprintf(buf, 18, "00:12:34:%s", buf_temp); DHD_ERROR(("Wrong prefix is detected, 12:34:56 is" " changed as 00:12:34 : %d\n", sizeof(buf))); } sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]), (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); } else DHD_ERROR(("dhd_bus_start: Reading from the '%s' returns 0 bytes\n", filepath_efs)); if (fp) filp_close(fp, NULL); /* Writing Newly generated MAC ID to the Dongle */ if (0 == _dhd_set_mac_address(dhd, 0, mac)) DHD_INFO(("dhd_bus_start: MACID is overwritten\n")); else DHD_ERROR(("dhd_bus_start: _dhd_set_mac_address() failed\n")); return 0; }
static int fd_configure_device(struct se_device *dev) { struct fd_dev *fd_dev = FD_DEV(dev); struct fd_host *fd_host = dev->se_hba->hba_ptr; struct file *file; struct inode *inode = NULL; int flags, ret = -EINVAL; if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) { pr_err("Missing fd_dev_name=\n"); return -EINVAL; } /* * Use O_DSYNC by default instead of O_SYNC to forgo syncing * of pure timestamp updates. */ flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC; /* * Optionally allow fd_buffered_io=1 to be enabled for people * who want use the fs buffer cache as an WriteCache mechanism. * * This means that in event of a hard failure, there is a risk * of silent data-loss if the SCSI client has *not* performed a * forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE * to write-out the entire device cache. */ if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) { pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n"); flags &= ~O_DSYNC; } file = filp_open(fd_dev->fd_dev_name, flags, 0600); if (IS_ERR(file)) { pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name); ret = PTR_ERR(file); goto fail; } fd_dev->fd_file = file; /* * If using a block backend with this struct file, we extract * fd_dev->fd_[block,dev]_size from struct block_device. * * Otherwise, we use the passed fd_size= from configfs */ inode = file->f_mapping->host; if (S_ISBLK(inode->i_mode)) { struct request_queue *q = bdev_get_queue(inode->i_bdev); unsigned long long dev_size; fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev); /* * Determine the number of bytes from i_size_read() minus * one (1) logical sector from underlying struct block_device */ dev_size = (i_size_read(file->f_mapping->host) - fd_dev->fd_block_size); pr_debug("FILEIO: Using size: %llu bytes from struct" " block_device blocks: %llu logical_block_size: %d\n", dev_size, div_u64(dev_size, fd_dev->fd_block_size), fd_dev->fd_block_size); if (target_configure_unmap_from_queue(&dev->dev_attrib, q)) pr_debug("IFILE: BLOCK Discard support available," " disabled by default\n"); /* * Enable write same emulation for IBLOCK and use 0xFFFF as * the smaller WRITE_SAME(10) only has a two-byte block count. */ dev->dev_attrib.max_write_same_len = 0xFFFF; if (blk_queue_nonrot(q)) dev->dev_attrib.is_nonrot = 1; } else { if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) { pr_err("FILEIO: Missing fd_dev_size=" " parameter, and no backing struct" " block_device\n"); goto fail; } fd_dev->fd_block_size = FD_BLOCKSIZE; /* * Limit UNMAP emulation to 8k Number of LBAs (NoLB) */ dev->dev_attrib.max_unmap_lba_count = 0x2000; /* * Currently hardcoded to 1 in Linux/SCSI code.. */ dev->dev_attrib.max_unmap_block_desc_count = 1; dev->dev_attrib.unmap_granularity = 1; dev->dev_attrib.unmap_granularity_alignment = 0; /* * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB) * based upon struct iovec limit for vfs_writev() */ dev->dev_attrib.max_write_same_len = 0x1000; } dev->dev_attrib.hw_block_size = fd_dev->fd_block_size; dev->dev_attrib.max_bytes_per_io = FD_MAX_BYTES; dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size; dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH; if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) { pr_debug("FILEIO: Forcing setting of emulate_write_cache=1" " with FDBD_HAS_BUFFERED_IO_WCE\n"); dev->dev_attrib.emulate_write_cache = 1; } fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++; fd_dev->fd_queue_depth = dev->queue_depth; pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s," " %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id, fd_dev->fd_dev_name, fd_dev->fd_dev_size); return 0; fail: if (fd_dev->fd_file) { filp_close(fd_dev->fd_file, NULL); fd_dev->fd_file = NULL; } return ret; }
int dhd_write_rdwr_korics_macaddr(struct dhd_info *dhd, struct ether_addr *mac) { struct file *fp = NULL; char macbuffer[18] = {0}; mm_segment_t oldfs = {0}; char randommac[3] = {0}; char buf[18] = {0}; char *filepath_efs = MACINFO_EFS; int is_zeromac = 0; int ret = 0; /* MAC address copied from efs/wifi.mac.info */ fp = filp_open(filepath_efs, O_RDONLY, 0); if (IS_ERR(fp)) { /* File Doesn't Exist. Create and write mac addr.*/ fp = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } oldfs = get_fs(); set_fs(get_ds()); /* Generating the Random Bytes for * 3 last octects of the MAC address */ get_random_bytes(randommac, 3); sprintf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n", 0x60, 0xd0, 0xa9, randommac[0], randommac[1], randommac[2]); DHD_ERROR(("[WIFI] The Random Generated MAC ID : %s\n", macbuffer)); if (fp->f_mode & FMODE_WRITE) { ret = fp->f_op->write(fp, (const char *)macbuffer, sizeof(macbuffer), &fp->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s]" " Failed to write into File:" " %s\n", macbuffer, filepath_efs)); else DHD_ERROR(("[WIFI] Mac address [%s]" " written into File: %s\n", macbuffer, filepath_efs)); } set_fs(oldfs); } else { /* Reading the MAC Address from .mac.info file * (the existed file or just created file) */ ret = kernel_read(fp, 0, buf, 18); /* to prevent abnormal string display when mac address * is displayed on the screen. */ buf[17] = '\0'; /* Remove security log */ /*DHD_ERROR(("Read MAC : [%s] [%d] \r\n", buf, strncmp(buf, "00:00:00:00:00:00", 17)));*/ if ((buf[0] == '\0') || (strncmp(buf, "00:00:00:00:00:00", 17) == 0)) { is_zeromac = 1; } } if (ret) sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]), (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]), (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5])); else DHD_INFO(("dhd_bus_start: Reading from the" " '%s' returns 0 bytes\n", filepath_efs)); if (fp) filp_close(fp, NULL); if (!is_zeromac) { /* Writing Newly generated MAC ID to the Dongle */ if (0 == _dhd_set_mac_address(dhd, 0, mac)) DHD_INFO(("dhd_bus_start: MACID is overwritten\n")); else DHD_ERROR(("dhd_bus_start: _dhd_set_mac_address() " "failed\n")); } else { DHD_ERROR(("dhd_bus_start:Is ZeroMAC BypassWrite.mac.info!\n")); } return 0; }
int mcsdl_download_binary_data(bool touch_id) { int nRet = 0; int retry_cnt = 0; long fw1_size = 0; unsigned char *fw_data1; #ifdef FW_FROM_FILE struct file *filp; loff_t pos; int ret = 0; mm_segment_t oldfs; spinlock_t lock; oldfs = get_fs(); set_fs(get_ds()); filp = filp_open(MELFAS_FW1, O_RDONLY, 0); if (IS_ERR(filp)) { pr_err("file open error:%d\n", (s32)filp); return -1; } fw1_size = filp->f_path.dentry->d_inode->i_size; pr_info("Size of the file : %ld(bytes)\n", fw1_size); fw_data1 = kmalloc(fw1_size, GFP_KERNEL); memset(fw_data1, 0, fw1_size); pos = 0; memset(fw_data1, 0, fw1_size); ret = vfs_read(filp, (char __user *)fw_data1, fw1_size, &pos); if(ret != fw1_size) { pr_err("Failed to read file %s (ret = %d)\n", MELFAS_FW1, ret); kfree(fw_data1); filp_close(filp, current->files); return -1; } filp_close(filp, current->files); set_fs(oldfs); spin_lock_init(&lock); spin_lock(&lock); #endif #if 0 #if MELFAS_USE_PROTOCOL_COMMAND_FOR_DOWNLOAD melfas_send_download_enable_command(); mcsdl_delay(MCSDL_DELAY_100US); #endif MELFAS_DISABLE_BASEBAND_ISR(); // Disable Baseband touch interrupt ISR. MELFAS_DISABLE_WATCHDOG_TIMER_RESET(); // Disable Baseband watchdog timer #endif //------------------------ // Run Download //------------------------ #ifdef FW_FROM_FILE for (retry_cnt = 0; retry_cnt < 3; retry_cnt++) { pr_info("[TSP] ADB - MASTER CHIP Firmware update! try : %d",retry_cnt+1); nRet = mcsdl_download( (const UINT8*) fw_data1, (const UINT16)fw1_size, 0); if (nRet) continue; #if MELFAS_2CHIP_DOWNLOAD_ENABLE pr_info("[TSP] ADB - SLAVE CHIP Firmware update! try : %d",retry_cnt+1); nRet = mcsdl_download( (const UINT8*) fw_data1, (const UINT16)fw1_size, 1); if (nRet) continue; #endif break; } #else //FW_FROM_FILE for (retry_cnt = 0; retry_cnt < 5; retry_cnt++) { if (touch_id) nRet = mcsdl_download( (const UINT8*) MELFAS_binary_2, (const UINT16)MELFAS_binary_nLength_2, 0); else nRet = mcsdl_download( (const UINT8*) MELFAS_binary_1, (const UINT16)MELFAS_binary_nLength_1 , 0); if (nRet) continue; #if MELFAS_2CHIP_DOWNLOAD_ENABLE if (touch_id) nRet = mcsdl_download( (const UINT8*) MELFAS_binary_2, (const UINT16)MELFAS_binary_nLength_2, 1); // Slave Binary data download else nRet = mcsdl_download( (const UINT8*) MELFAS_binary_1, (const UINT16)MELFAS_binary_nLength_1, 1); // Slave Binary data download if (nRet) continue; #endif break; } #endif //FW_FROM_FILE MELFAS_ROLLBACK_BASEBAND_ISR(); // Roll-back Baseband touch interrupt ISR. MELFAS_ROLLBACK_WATCHDOG_TIMER_RESET(); // Roll-back Baseband watchdog timer fw_error: if (nRet) { mcsdl_erase_flash(0); mcsdl_erase_flash(1); } #ifdef FW_FROM_FILE kfree(fw_data1); spin_unlock(&lock); #endif return nRet; }
int dhd_write_macaddr(struct ether_addr *mac) { char *filepath_data = MACINFO; char *filepath_efs = MACINFO_EFS; struct file *fp_mac = NULL; char buf[18] = {0}; mm_segment_t oldfs = {0}; int ret = -1; int retry_count = 0; startwrite: sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X\n", mac->octet[0], mac->octet[1], mac->octet[2], mac->octet[3], mac->octet[4], mac->octet[5]); /* File will be created /data/.mac.info. */ fp_mac = filp_open(filepath_data, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath_data)); return -1; } else { oldfs = get_fs(); set_fs(get_ds()); if (fp_mac->f_mode & FMODE_WRITE) { ret = fp_mac->f_op->write(fp_mac, (const char *)buf, sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to" " write into File: %s\n", buf, filepath_data)); else DHD_INFO(("[WIFI] Mac address [%s] written" " into File: %s\n", buf, filepath_data)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* check .mac.info file is 0 byte */ fp_mac = filp_open(filepath_data, O_RDONLY, 0); ret = kernel_read(fp_mac, 0, buf, 18); if ((ret == 0) && (retry_count++ < 3)) { filp_close(fp_mac, NULL); goto startwrite; } filp_close(fp_mac, NULL); /* end of /data/.mac.info */ if (filepath_efs == NULL) { DHD_ERROR(("[WIFI]%s : no efs filepath", __func__)); return 0; } /* File will be created /efs/wifi/.mac.info. */ fp_mac = filp_open(filepath_efs, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp_mac)) { DHD_ERROR(("[WIFI] %s: File open error\n", filepath_efs)); return -1; } else { oldfs = get_fs(); set_fs(get_ds()); if (fp_mac->f_mode & FMODE_WRITE) { ret = fp_mac->f_op->write(fp_mac, (const char *)buf, sizeof(buf), &fp_mac->f_pos); if (ret < 0) DHD_ERROR(("[WIFI] Mac address [%s] Failed to" " write into File: %s\n", buf, filepath_efs)); else DHD_INFO(("[WIFI] Mac address [%s] written" " into File: %s\n", buf, filepath_efs)); } set_fs(oldfs); filp_close(fp_mac, NULL); } /* check .mac.info file is 0 byte */ fp_mac = filp_open(filepath_efs, O_RDONLY, 0); ret = kernel_read(fp_mac, 0, buf, 18); if ((ret == 0) && (retry_count++ < 3)) { filp_close(fp_mac, NULL); goto startwrite; } filp_close(fp_mac, NULL); return 0; }
static int get_grip_calibration(struct ssp_data *data) { struct file *cal_filp = NULL; mm_segment_t old_fs; bool set = 0; int cmd = MSG2SSP_AP_MCU_GRIP_GET_CAL_DATA; int set_len = sizeof(set); int cap_main_len = sizeof(data->gripcal.cap_main); int ref_cap_main_len = sizeof(data->gripcal.ref_cap_main); int useful_len = sizeof(data->gripcal.useful); int offset_len = sizeof(data->gripcal.offset); int len = set_len+cap_main_len+ref_cap_main_len+useful_len+offset_len; char cal_data[len]; int ret = 0; if (!(data->uSensorState & (1 << GRIP_SENSOR))) { pr_info("[SSP]: %s - Skip this function!!!\n" "[SSP]: grip sensor is not connected(0x%x)\n", __func__, data->uSensorState); return -EIO; } if (data->gripcal.temp < TEMP_LOW_BOUND || data->gripcal.temp > TEMP_HIGH_BOUND) { pr_info("[SSP]: %s - Skip calibration temp = %d\n", __func__, data->gripcal.temp); return -EINVAL; } ret = get_grip_factory_data(data, cmd, cal_data, sizeof(cal_data)); if (ret != SUCCESS) { pr_err("[SSP]: %s - get_grip_factory_data fail %d\n", __func__, ret); return -EIO; } for (ret = 0; ret < (int)sizeof(cal_data); ret++) { pr_info("[SSP]: %s cal_data[%d] = %d\n", __func__, ret, cal_data[ret]); } memcpy(&set, &cal_data[0], set_len); if (!set) { pr_err("[SSP]: %s - Grip sensor calibration fail %d\n", __func__, set); return -EIO; } memcpy(&data->gripcal.cap_main, &cal_data[set_len], cap_main_len); memcpy(&data->gripcal.ref_cap_main, &cal_data[set_len+cap_main_len], ref_cap_main_len); memcpy(&data->gripcal.useful, &cal_data[set_len+cap_main_len+ref_cap_main_len], useful_len); memcpy(&data->gripcal.offset, &cal_data[set_len+cap_main_len+ref_cap_main_len+useful_len], offset_len); old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(TEMP_CAL_FILE_PATH, O_CREAT | O_TRUNC | O_WRONLY | O_SYNC, S_IRUGO | S_IWUSR | S_IWGRP); if (IS_ERR(cal_filp)) { pr_err("[SSP]: %s - Can't open temp_cal file\n", __func__); goto exit; } ret = cal_filp->f_op->write(cal_filp, (char *)&data->gripcal.temp, sizeof(data->gripcal.temp), &cal_filp->f_pos); if (ret != sizeof(data->gripcal.temp)) { pr_err("[SSP]: %s - Can't write the temp_cal to file\n", __func__); } else { data->gripcal.temp_cal = data->gripcal.temp; } filp_close(cal_filp, current->files); exit: set_fs(old_fs); pr_info("[SSP]: Grip calibration - %d,%d,%d,%d temp_cal = %d\n", data->gripcal.cap_main, data->gripcal.ref_cap_main, data->gripcal.useful, data->gripcal.offset, data->gripcal.temp_cal); return SUCCESS; }
void sec_control_pm(dhd_pub_t *dhd, uint *power_mode) { struct file *fp = NULL; char *filepath = PSMINFO; mm_segment_t oldfs = {0}; char power_val = 0; char iovbuf[WL_EVENTING_MASK_LEN + 12]; g_pm_control = FALSE; fp = filp_open(filepath, O_RDONLY, 0); if (IS_ERR(fp)) { /* Enable PowerSave Mode */ dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0); fp = filp_open(filepath, O_RDWR | O_CREAT, 0666); if (IS_ERR(fp) || (fp == NULL)) { DHD_ERROR(("[%s, %d] /data/.psm.info open failed\n", __FUNCTION__, __LINE__)); return; } else { oldfs = get_fs(); set_fs(get_ds()); if (fp->f_mode & FMODE_WRITE) { power_val = '1'; fp->f_op->write(fp, (const char *)&power_val, sizeof(char), &fp->f_pos); } set_fs(oldfs); } } else { kernel_read(fp, fp->f_pos, &power_val, 1); DHD_ERROR(("POWER_VAL = %c \r\n" , power_val)); if (power_val == '0') { #ifdef ROAM_ENABLE uint roamvar = 1; #endif *power_mode = PM_OFF; /* Disable PowerSave Mode */ dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0); /* Turn off MPC in AP mode */ bcm_mkiovar("mpc", (char *)power_mode, 4, iovbuf, sizeof(iovbuf)); dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); g_pm_control = TRUE; #ifdef ROAM_ENABLE /* Roaming off of dongle */ bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf)); dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0); #endif } else { dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0); } } if (fp) filp_close(fp, NULL); }
void ssp_pcm_dump_task(struct work_struct *work) { struct ssp_big *big = container_of(work, struct ssp_big, work); struct ssp_sensorhub_data *hub_data = big->data->hub_data; struct ssp_msg *msg; int buf_len, residue = big->length, ret = 0, index = 0; mm_segment_t old_fs; struct file *voice_filp; char pcm_path[BIN_PATH_SIZE+1]; char *buff; old_fs = get_fs(); set_fs(KERNEL_DS); snprintf(pcm_path, BIN_PATH_SIZE, "/data/voice%d.pcm", hub_data->pcm_cnt); voice_filp = filp_open(pcm_path, O_RDWR | O_CREAT | O_APPEND, 0666); if (IS_ERR(voice_filp)) { sensorhub_err("open pcm dump file err"); goto exit; } buf_len = big->length > DATA_PACKET_SIZE ? DATA_PACKET_SIZE : big->length; buff = kzalloc(buf_len, GFP_KERNEL); while (residue > 0) { buf_len = residue > DATA_PACKET_SIZE ? DATA_PACKET_SIZE : residue; msg = kzalloc(sizeof(*msg), GFP_KERNEL); msg->cmd = MSG2SSP_AP_GET_BIG_DATA; msg->length = buf_len; msg->options = AP2HUB_READ | (index++ << SSP_INDEX); msg->data = big->addr; msg->buffer = buff; msg->free_buffer = 0; ret = ssp_spi_sync(big->data, msg, 1000); if (ret != SUCCESS) { sensorhub_err("receive pcm dump err(%d)", ret); break; } ret = voice_filp->f_op->write(voice_filp, (char __user *)buff, buf_len, &voice_filp->f_pos); if (ret < 0) { sensorhub_err("write pcm dump to file err(%d)", ret); break; } residue -= buf_len; sensorhub_info("write pcm dump..."); } filp_close(voice_filp, current->files); kfree(buff); exit: set_fs(old_fs); }
/* fd_create_virtdevice(): (Part of se_subsystem_api_t template) * * */ static struct se_device *fd_create_virtdevice( struct se_hba *hba, struct se_subsystem_dev *se_dev, void *p) { char *dev_p = NULL; struct se_device *dev; struct se_dev_limits dev_limits; struct queue_limits *limits; struct fd_dev *fd_dev = (struct fd_dev *) p; struct fd_host *fd_host = (struct fd_host *) hba->hba_ptr; mm_segment_t old_fs; struct file *file; struct inode *inode = NULL; int dev_flags = 0, flags, ret = -EINVAL; memset(&dev_limits, 0, sizeof(struct se_dev_limits)); old_fs = get_fs(); set_fs(get_ds()); dev_p = getname(fd_dev->fd_dev_name); set_fs(old_fs); if (IS_ERR(dev_p)) { pr_err("getname(%s) failed: %lu\n", fd_dev->fd_dev_name, IS_ERR(dev_p)); ret = PTR_ERR(dev_p); goto fail; } #if 0 if (di->no_create_file) flags = O_RDWR | O_LARGEFILE; else flags = O_RDWR | O_CREAT | O_LARGEFILE; #else flags = O_RDWR | O_CREAT | O_LARGEFILE; #endif /* flags |= O_DIRECT; */ /* * If fd_buffered_io=1 has not been set explicitly (the default), * use O_SYNC to force FILEIO writes to disk. */ if (!(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO)) flags |= O_SYNC; file = filp_open(dev_p, flags, 0600); if (IS_ERR(file)) { pr_err("filp_open(%s) failed\n", dev_p); ret = PTR_ERR(file); goto fail; } if (!file || !file->f_dentry) { pr_err("filp_open(%s) failed\n", dev_p); goto fail; } fd_dev->fd_file = file; /* * If using a block backend with this struct file, we extract * fd_dev->fd_[block,dev]_size from struct block_device. * * Otherwise, we use the passed fd_size= from configfs */ inode = file->f_mapping->host; if (S_ISBLK(inode->i_mode)) { struct request_queue *q; /* * Setup the local scope queue_limits from struct request_queue->limits * to pass into transport_add_device_to_core_hba() as struct se_dev_limits. */ q = bdev_get_queue(inode->i_bdev); limits = &dev_limits.limits; limits->logical_block_size = bdev_logical_block_size(inode->i_bdev); limits->max_hw_sectors = queue_max_hw_sectors(q); limits->max_sectors = queue_max_sectors(q); /* * Determine the number of bytes from i_size_read() minus * one (1) logical sector from underlying struct block_device */ fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev); fd_dev->fd_dev_size = (i_size_read(file->f_mapping->host) - fd_dev->fd_block_size); pr_debug("FILEIO: Using size: %llu bytes from struct" " block_device blocks: %llu logical_block_size: %d\n", fd_dev->fd_dev_size, div_u64(fd_dev->fd_dev_size, fd_dev->fd_block_size), fd_dev->fd_block_size); } else { if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) { pr_err("FILEIO: Missing fd_dev_size=" " parameter, and no backing struct" " block_device\n"); goto fail; } limits = &dev_limits.limits; limits->logical_block_size = FD_BLOCKSIZE; limits->max_hw_sectors = FD_MAX_SECTORS; limits->max_sectors = FD_MAX_SECTORS; fd_dev->fd_block_size = FD_BLOCKSIZE; } dev_limits.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH; dev_limits.queue_depth = FD_DEVICE_QUEUE_DEPTH; dev = transport_add_device_to_core_hba(hba, &fileio_template, se_dev, dev_flags, fd_dev, &dev_limits, "FILEIO", FD_VERSION); if (!dev) goto fail; fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++; fd_dev->fd_queue_depth = dev->queue_depth; pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s," " %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id, fd_dev->fd_dev_name, fd_dev->fd_dev_size); putname(dev_p); return dev; fail: if (fd_dev->fd_file) { filp_close(fd_dev->fd_file, NULL); fd_dev->fd_file = NULL; } putname(dev_p); return ERR_PTR(ret); }
int mini_isp_debug_load_cfg(char *cfg_file,char *key_name,u8 *key_var) { struct kstat stat; mm_segment_t fs; struct file *fp = NULL; int file_flag = O_RDONLY; ssize_t ret = 0; char temp_array[64] = {0}; char temp; int cnt=0; bool bRegStart = false; bool bKeyFound = false; bool bKeyCfg = false; print_debug("enter %s", __func__); if (NULL == cfg_file) { print_error("%s cfg_file null ptr.", __func__); return -EINVAL; } if (NULL == key_name) { print_error("%s key_name null ptr.", __func__); return -EINVAL; } if (NULL == key_var) { print_error("%s key_var null ptr.", __func__); return -EINVAL; } /* must have the following 2 statement */ fs = get_fs(); set_fs(KERNEL_DS); fp = filp_open(cfg_file, file_flag, 0666); if (IS_ERR_OR_NULL(fp)) { print_debug("no debug configuration file(%s) - do nothing, just skip it!\n",cfg_file); return -1; } if (0 != vfs_stat(cfg_file, &stat)) { print_error("failed to get file %s state!",cfg_file); goto ERROR; } print_debug("%s size : %d",cfg_file, (u32)stat.size); while (0 < vfs_read(fp, &temp, 1, &fp->f_pos)) { switch (temp) { case '{': bRegStart = true; cnt = 0; bKeyFound = false; memset(temp_array,sizeof(char),sizeof(temp_array)); break; case '}': bRegStart = false; if(bKeyFound) { *key_var = mini_atoi16(temp_array); bKeyCfg = true; print_debug("%s:0x%x",key_name,*key_var); } break; case '=': if (bRegStart) { bKeyFound = false; if (0 == strncmp(key_name,temp_array,strlen(key_name))) { bKeyFound = true; } cnt = 0; } break; default: if (bRegStart){ if (cnt >= 64) { bRegStart = false; } else { temp_array[cnt] = temp; cnt=cnt+1; } } break; } if (bKeyCfg) { break; } } /* must have the following 1 statement */ set_fs(fs); ERROR: if (NULL != fp) filp_close(fp, 0); return ret; }
void KRIL_InitCmdHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp) { KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd; ClientInfo_t clientInfo; CAPI2_MS_Element_t data; if (capi2_rsp != NULL) { KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result); if(capi2_rsp->result != RESULT_OK) { pdata->handler_state = BCM_ErrorCAPI2Cmd; } } switch(pdata->handler_state) { case BCM_SendCAPI2Cmd: { KrilInit_t *pInitData = (KrilInit_t *)(pdata->ril_cmd->data); // if there is a valid IMEI, make appropriate CAPI2 call to set // IMEI on CP, otherwise fall through to next init command if (pInitData->is_valid_imei) { KRIL_DEBUG(DBG_INFO, "OTP IMEI:%s\n", pInitData->imei); #ifdef CONFIG_BRCM_SIM_SECURE_ENABLE // Record IMEI1 infomation if (FALSE == ProcessImei((UInt8*)pInitData->imei, sImei_Info)) { KRIL_DEBUG(DBG_ERROR,"Process IMEI:%s Failed!!!", pInitData->imei); pdata->handler_state = BCM_ErrorCAPI2Cmd; kernel_power_off(); } #endif //CONFIG_BRCM_SIM_SECURE_ENABLE memset(&data, 0, sizeof(CAPI2_MS_Element_t)); memcpy(data.data_u.imeidata, pInitData->imei, IMEI_DIGITS); data.inElemType = MS_LOCAL_PHCTRL_ELEM_IMEI; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SET_HSDPA_PHY_CATEGORY; break; } #ifdef CONFIG_BRCM_SIM_SECURE_ENABLE else { // For secure boot, the IMEI is important inform for verifying SIM lock data. KRIL_DEBUG(DBG_ERROR, "IMEI is invalid. Error!!!\n"); kernel_power_off(); } #endif //CONFIG_BRCM_SIM_SECURE_ENABLE // if OTP IMEI passed from URIL is not valid, we skip the // CAPI2_MS_SetElement() call and fall through to execute the // next CAPI2 init call instead... } case BCM_SET_HSDPA_PHY_CATEGORY: { struct file *filp; mm_segment_t fs; int ret; int hsdpa_phy_cat = 8; filp = filp_open("/data/hsdpa.dat", O_RDWR|O_SYNC, 0); if (IS_ERR(filp)) { // Do not set hsdpa phy category value. just go next case. (Normal operaton) pdata->handler_state = BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS; } else { // hsdpa phy category is changed to do Vodafone test fs = get_fs(); set_fs(get_ds()); ret = filp->f_op->read(filp, (char __user *)&hsdpa_phy_cat, sizeof(hsdpa_phy_cat), &filp->f_pos); set_fs(fs); filp_close(filp, NULL); KRIL_DEBUG(DBG_ERROR,"BCM_SET_HSDPA_PHY_CATEGORY\n"); CAPI2_SYSPARM_SetHSDPAPHYCategory(GetNewTID(), GetClientID(), hsdpa_phy_cat ); pdata->handler_state = BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS; break; } } case BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS: { memset((UInt8*)&data, 0, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SMS_ELEM_CLIENT_HANDLE_MT_SMS; data.data_u.bData = TRUE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SMS_SetSmsReadStatusChangeMode; break; } case BCM_SMS_SetSmsReadStatusChangeMode: { CAPI2_SMS_SetSmsReadStatusChangeMode(GetNewTID(), GetClientID(), FALSE); pdata->handler_state = BCM_SYS_SetFilteredEventMask; break; } case BCM_SYS_SetFilteredEventMask: { UInt16 filterList[]={MSG_RSSI_IND, MSG_CELL_INFO_IND, MSG_LCS_RRC_UE_STATE_IND, MSG_DATE_TIMEZONE_IND, MSG_DATA_SUSPEND_IND, MSG_DATA_RESUME_IND, MSG_CAPI2_AT_RESPONSE_IND, MSG_UE_3G_STATUS_IND}; CAPI2_SYS_SetFilteredEventMask(GetNewTID(), GetClientID(), &filterList[0], sizeof(filterList)/sizeof(UInt16), SYS_AP_DEEP_SLEEP_MSG_FILTER); pdata->handler_state = BCM_SYS_SetRssiThreshold; break; } case BCM_SYS_SetRssiThreshold: { CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_PhoneCtrlApi_SetRssiThreshold(&clientInfo, g_RSSIThreshold, 20, g_RSSIThreshold, 20); pdata->handler_state = BCM_TIMEZONE_SetTZUpdateMode; break; } case BCM_TIMEZONE_SetTZUpdateMode: { CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_NetRegApi_SetTZUpdateMode(&clientInfo, TIMEZONE_UPDATEMODE_NO_TZ_UPDATE); pdata->handler_state = BCM_SATK_SetTermProfile; break; } case BCM_SATK_SetTermProfile: { CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_SatkApi_SetTermProfile(&clientInfo, terminal_profile_data, sizeof(terminal_profile_data)/sizeof(UInt8)); pdata->handler_state = BCM_SATK_SETUP_CALL_CTR; break; } case BCM_SATK_SETUP_CALL_CTR: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_SETUP_CALL_CTR; #ifdef OEM_RIL_ENABLE data.data_u.bData = FALSE; pdata->handler_state = BCM_SATK_SEND_SS_CTR; #else data.data_u.bData = TRUE; pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG; #endif CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SATK_ICON_DISP_SUPPORTED; break; } case BCM_SATK_ICON_DISP_SUPPORTED: { memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_ICON_DISP_SUPPORTED; data.data_u.bData = TRUE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); #ifdef OEM_RIL_ENABLE pdata->handler_state = BCM_SATK_SEND_SS_CTR; #else pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG; #endif break; } #ifdef OEM_RIL_ENABLE case BCM_SATK_SEND_SS_CTR: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_SEND_SS_CTR; data.data_u.bData = FALSE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SATK_SEND_USSD_CTR; break; } case BCM_SATK_SEND_USSD_CTR: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_SEND_USSD_CTR; data.data_u.bData = FALSE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SATK_SEND_SMS_CTR; break; } case BCM_SATK_SEND_SMS_CTR: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_SEND_SMS_CTR; data.data_u.bData = FALSE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SATK_SEND_ENABLE_7BIT_CONVERSIONS; break; } case BCM_SATK_SEND_ENABLE_7BIT_CONVERSIONS: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_ENABLE_7BIT_CONVERSIONS; data.data_u.bData = FALSE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SATK_SEND_SETUP_EVENT_LIST_CTR; break; } case BCM_SATK_SEND_SETUP_EVENT_LIST_CTR: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SATK_ELEM_SETUP_EVENT_LIST_CTR; data.data_u.bData = FALSE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_CFG_SIM_LOCK_SUPPORTED; break; } case BCM_CFG_SIM_LOCK_SUPPORTED: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_CFG_ELEM_SIM_LOCK_SUPPORTED ; data.data_u.bData = TRUE; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG; break; } #endif case BCM_SS_SET_ENABLE_OLD_SS_MSG: { // enabled sending of "old" supp svcs messages // NOTE: this should go away when we move to the new SS apis memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SS_ELEM_ENABLE_OLD_SS_MSG; data.data_u.u8Data = 1; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SS_SET_ELEM_FDN_CHECK; break; } case BCM_SS_SET_ELEM_FDN_CHECK: { // enable FDN check for SS dialing memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_SS_ELEM_FDN_CHECK; data.data_u.u8Data = 1; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement(&clientInfo, &data); pdata->handler_state = BCM_SET_SupportedRATandBand; break; } case BCM_SET_SupportedRATandBand: { KrilInit_t *pInitData = (KrilInit_t *)(pdata->ril_cmd->data); KRIL_SetPreferredNetworkType(pInitData->networktype); KRIL_SetBandMode(pInitData->band); CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); KRIL_DEBUG(DBG_INFO,"BCM_SET_SupportedRATandBand network type %d\n", pInitData->networktype); KRIL_DEBUG(DBG_INFO,"BCM_SET_SupportedRATandBand band %d conv band %d\n", pInitData->band, ConvertBandMode(pInitData->band)); //TODO jw check this new api last two extra parameter. CAPI2_NetRegApi_SetSupportedRATandBand(&clientInfo, ConvertNetworkType(pInitData->networktype), ConvertBandMode(pInitData->band), ConvertNetworkType(pInitData->networktype), ConvertBandMode(pInitData->band) ); //++ JSHAN Attach for next power on vGprsAttachMode = pInitData->gprs_attach_init; if (vGprsAttachMode == 1 || vGprsAttachMode == 2) pdata->handler_state = BCM_SET_AttachMode; else pdata->handler_state = BCM_SET_RADIO_OFF; //-- JSHAN Attach for next power on break; } //++ JSHAN Attach for next power on case BCM_SET_AttachMode: { CAPI2_MS_Element_t data; memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t)); data.inElemType = MS_LOCAL_PHCTRL_ELEM_ATTACH_MODE; data.data_u.u8Data = vGprsAttachMode; CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_MsDbApi_SetElement ( &clientInfo,&data); pdata->handler_state = BCM_SET_RADIO_OFF; break; } //-- JSHAN Attach for next power on case BCM_SET_RADIO_OFF: { // For flight mode power up battery ADC & deep sleep issue (MobC00131482), set the initial CP state to RADIO_OFF. // If MS is powered up in normal mode, Android framework will send BRCM_RIL_REQUEST_RADIO_POWER to RIL. CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID()); CAPI2_PhoneCtrlApi_ProcessNoRfReq(&clientInfo); pdata->handler_state = BCM_RESPCAPI2Cmd; break; } case BCM_RESPCAPI2Cmd: { pdata->handler_state = BCM_FinishCAPI2Cmd; break; } default: { KRIL_DEBUG(DBG_ERROR,"Error handler_state:0x%lX\n", pdata->handler_state); pdata->handler_state = BCM_ErrorCAPI2Cmd; break; } } }
static int proximity_store_cancelation(struct device *dev, bool do_calib) { struct cm36686_data *cm36686 = dev_get_drvdata(dev); struct file *cancel_filp = NULL; mm_segment_t old_fs; int err = 0; u16 ps_data = 0; if (do_calib) { mutex_lock(&cm36686->read_lock); cm36686_i2c_read_word(cm36686, REG_PS_DATA, &ps_data); ps_reg_init_setting[PS_CANCEL][CMD] = ps_data; mutex_unlock(&cm36686->read_lock); err = get_proximity_threshold(cm36686); if(err != ERROR) { if (cm36686->pdata->cancel_hi_thd) { ps_reg_init_setting[PS_THD_HIGH][CMD] = cm36686->pdata->cancel_hi_thd; } else ps_reg_init_setting[PS_THD_HIGH][CMD] = CANCEL_HI_THD; if (cm36686->pdata->cancel_low_thd) { ps_reg_init_setting[PS_THD_LOW][CMD] = cm36686->pdata->cancel_low_thd; } else ps_reg_init_setting[PS_THD_LOW][CMD] = DEFUALT_LOW_THD; } else { set_default_proximity_threshold(cm36686); } } else { /* reset */ ps_reg_init_setting[PS_CANCEL][CMD] = 0; set_default_proximity_threshold(cm36686); } err = cm36686_i2c_write_word(cm36686, REG_PS_CANC, ps_reg_init_setting[PS_CANCEL][CMD]); if (err < 0) pr_err("%s: cm36686_ps_canc_reg is failed. %d\n", __func__, err); err = cm36686_i2c_write_word(cm36686, REG_PS_THD_HIGH, ps_reg_init_setting[PS_THD_HIGH][CMD]); if (err < 0) pr_err("%s: cm36686_ps_high_reg is failed. %d\n", __func__, err); err = cm36686_i2c_write_word(cm36686, REG_PS_THD_LOW, ps_reg_init_setting[PS_THD_LOW][CMD]); if (err < 0) pr_err("%s: cm36686_ps_low_reg is failed. %d\n", __func__, err); pr_info("%s: prox_cal = 0x%x, ps_high_thresh = 0x%x, ps_low_thresh = 0x%x\n", __func__, ps_reg_init_setting[PS_CANCEL][CMD], ps_reg_init_setting[PS_THD_HIGH][CMD], ps_reg_init_setting[PS_THD_LOW][CMD]); old_fs = get_fs(); set_fs(KERNEL_DS); cancel_filp = filp_open(CANCELATION_FILE_PATH, O_CREAT | O_TRUNC | O_WRONLY | O_SYNC, 0666); if (IS_ERR(cancel_filp)) { pr_err("%s: Can't open cancelation file\n", __func__); set_fs(old_fs); err = PTR_ERR(cancel_filp); return err; } err = cancel_filp->f_op->write(cancel_filp, (char *)&ps_reg_init_setting[PS_CANCEL][CMD], sizeof(u16), &cancel_filp->f_pos); if (err != sizeof(u16)) { pr_err("%s: Can't write the cancel data to file\n", __func__); err = -EIO; } filp_close(cancel_filp, current->files); set_fs(old_fs); if (!do_calib) /* delay for clearing */ msleep(150); return err; }
static int proximity_do_calibrate(struct gp2a_data *data, bool do_calib, bool thresh_set) { struct file *cal_filp; int err; int xtalk_avg = 0; int offset_change = 0; uint16_t thrd = 0; u8 reg; mm_segment_t old_fs; if (do_calib) { if (thresh_set) { /* for proximity_thresh_store */ data->offset_value = data->threshold_high - (gp2a_reg[6][1] << 8 | gp2a_reg[5][1]); } else { /* tap offset button */ /* get offset value */ xtalk_avg = proximity_adc_read(data); offset_change = (gp2a_reg[6][1] << 8 | gp2a_reg[5][1]) - DEFAULT_HI_THR; if (xtalk_avg < offset_change) { /* do not need calibration */ data->cal_result = 0; err = 0; goto no_cal; } data->offset_value = xtalk_avg - offset_change; } /* update threshold */ thrd = (gp2a_reg[4][1] << 8 | gp2a_reg[3][1]) + (data->offset_value); THR_REG_LSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[3][0], ®); THR_REG_MSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[4][0], ®); thrd = (gp2a_reg[4][1] << 8 | gp2a_reg[5][1]) +(data->offset_value); THR_REG_LSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[5][0], ®); THR_REG_MSB(thrd, reg); gp2a_i2c_write(data, gp2a_reg[6][0], ®); /* calibration result */ if (!thresh_set) data->cal_result = 1; } else { /* tap reset button */ data->offset_value = 0; /* update threshold */ gp2a_i2c_write(data, gp2a_reg[3][0], &gp2a_reg[3][1]); gp2a_i2c_write(data, gp2a_reg[4][0], &gp2a_reg[4][1]); gp2a_i2c_write(data, gp2a_reg[5][0], &gp2a_reg[5][1]); gp2a_i2c_write(data, gp2a_reg[6][0], &gp2a_reg[6][1]); /* calibration result */ data->cal_result = 2; } old_fs = get_fs(); set_fs(KERNEL_DS); cal_filp = filp_open(data->pdata->prox_cal_path, O_CREAT | O_TRUNC | O_WRONLY, S_IRUGO | S_IWUSR | S_IWGRP); if (IS_ERR(cal_filp)) { pr_err("%s: Can't open calibration file\n", __func__); set_fs(old_fs); err = PTR_ERR(cal_filp); goto done; } err = cal_filp->f_op->write(cal_filp, (char *)&data->offset_value, sizeof(int), &cal_filp->f_pos); if (err != sizeof(int)) { pr_err("%s: Can't write the cal data to file\n", __func__); err = -EIO; } filp_close(cal_filp, current->files); done: set_fs(old_fs); no_cal: return err; }
/*search pattern*/ int search_pat(void *arg){ int rc = 0; struct strops_args *kptr = (struct strops_args *)arg; struct file *readFilePtr = NULL;/*for input file pointer.*/ size_t inputInodeSize = 0;/* for get size of input file*/ mm_segment_t oldfs; char *bytes;/* bytes from input file*/ char *temp; char *res; int page_count = 0; readFilePtr = filp_open(kptr->in_file, O_EXCL, 0); if(!readFilePtr || IS_ERR(readFilePtr)){ printk("Open input file error: %d\n", (int)PTR_ERR(readFilePtr)); rc = -ENOENT; readFilePtr = NULL; goto out; } rc = isInFileValid(readFilePtr); if(rc < 0) goto close_input_file; inputInodeSize = i_size_read(readFilePtr->f_path.dentry->d_inode); bytes = (char *)kmalloc(PAGE * sizeof(char) + 1, GFP_KERNEL); if(IS_ERR(bytes)){ rc = -ENOMEM; goto close_input_file; } oldfs = get_fs(); set_fs(get_ds()); while((inputInodeSize - readFilePtr->f_pos) > 0){ if(kptr->res_len == MAX_OCC){ printk("find more than maximum(100) number of results! Truncate.\n"); break; } if(inputInodeSize - readFilePtr->f_pos >= PAGE){ rc = readFilePtr->f_op->read(readFilePtr, bytes, PAGE, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[PAGE] = '\0'; temp = bytes; while((res = strstr(temp, kptr->old_str)) != NULL){ int dis = res - bytes; if(kptr->res_len == MAX_OCC){ printk("find more than maximum(100) number of results! Truncate.\n"); goto set_oldfs; } if(page_count == 0){ kptr->res[(kptr->res_len)++] = dis; } else{ kptr->res[(kptr->res_len)++] = dis - kptr->old_len * page_count + (PAGE) * page_count; } temp = kptr->old_len + res; } page_count++; readFilePtr->f_pos -= kptr->old_len; }else{ int rest = inputInodeSize - readFilePtr->f_pos; rc = readFilePtr->f_op->read(readFilePtr, bytes, rest, &readFilePtr->f_pos); if(rc < 0){ rc = -EPERM; printk("Read Blocks failed!\n"); goto set_oldfs; } bytes[rest] = '\0'; temp = bytes; while((res = strstr(temp, kptr->old_str)) != NULL){ int dis = res - bytes; if(kptr->res_len == MAX_OCC){ printk("find more than maximum(100) number of results! Truncate.\n"); goto set_oldfs; } if(page_count != 0) kptr->res[(kptr->res_len)++] = dis - kptr->old_len * page_count + (PAGE) * page_count; else kptr->res[(kptr->res_len)++] = dis; temp = kptr->old_len + res; } } } set_oldfs: set_fs(oldfs); kfree(bytes); close_input_file: filp_close(readFilePtr, NULL); out: return rc; }
int wacom_i2c_load_fw(struct i2c_client *client) { struct file *fp; mm_segment_t old_fs; long fsize, nread; int ret; struct wacom_i2c *wac_i2c = i2c_get_clientdata(client); unsigned char *Binary_UMS = NULL; #if defined(CONFIG_MACH_P4NOTE) Binary_UMS = kmalloc(MAX_ADDR_514 + 1, GFP_KERNEL); #else Binary_UMS = kmalloc(WACOM_FW_SIZE, GFP_KERNEL); #endif if (Binary_UMS == NULL) { printk(KERN_DEBUG "[E-PEN] %s, kmalloc failed\n", __func__); return -ENOENT; } wacom_i2c_set_firm_data(Binary_UMS); old_fs = get_fs(); set_fs(KERNEL_DS); fp = filp_open(WACOM_FW_PATH, O_RDONLY, S_IRUSR); if (IS_ERR(fp)) { printk(KERN_ERR "[E-PEN] failed to open %s.\n", WACOM_FW_PATH); goto open_err; } fsize = fp->f_path.dentry->d_inode->i_size; printk(KERN_NOTICE "[E-PEN] start, file path %s, size %ld Bytes\n", WACOM_FW_PATH, fsize); nread = vfs_read(fp, (char __user *)Binary, fsize, &fp->f_pos); printk(KERN_ERR "[E-PEN] nread %ld Bytes\n", nread); if (nread != fsize) { printk(KERN_ERR "[E-PEN] failed to read firmware file, nread %ld Bytes\n", nread); goto read_err; } ret = wacom_i2c_flash(wac_i2c); if (ret < 0) { printk(KERN_ERR "[E-PEN] failed to write firmware(%d)\n", ret); goto fw_write_err; } wacom_i2c_set_firm_data(NULL); kfree(Binary_UMS); filp_close(fp, current->files); set_fs(old_fs); return 0; open_err: kfree(Binary_UMS); set_fs(old_fs); return -ENOENT; read_err: kfree(Binary_UMS); filp_close(fp, current->files); set_fs(old_fs); return -EIO; fw_write_err: kfree(Binary_UMS); filp_close(fp, current->files); set_fs(old_fs); return -1; }