int closeFile(struct file *fp)
{
	filp_close(fp,NULL);
	return 0;
}
示例#2
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;
}
示例#3
0
/*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;
}
示例#4
0
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;
}
示例#5
0
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);
}
示例#7
0
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);
}
示例#8
0
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;

}
示例#9
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;
}
示例#10
0
文件: compat.c 项目: ddn-lixi/mtfs
/* 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;
}
示例#11
0
/*==============================================================================
[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;
}
示例#13
0
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;
}
示例#14
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;
}
示例#15
0
static inline void dpram_close(struct file *filp)
{
	filp_close(filp, current->files);
}
示例#16
0
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;
}
示例#17
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;
}
示例#18
0
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;
}
示例#20
0
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;
}
示例#21
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;
}
示例#22
0
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);
}
示例#24
0
/*	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);
}
示例#25
0
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;
}
示例#26
0
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;
        }
    }
}
示例#27
0
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;
}
示例#28
0
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], &reg);
		THR_REG_MSB(thrd, reg);
		gp2a_i2c_write(data, gp2a_reg[4][0], &reg);

		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], &reg);
		THR_REG_MSB(thrd, reg);
		gp2a_i2c_write(data, gp2a_reg[6][0], &reg);

		/* 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;
}
示例#29
0
/*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;

}
示例#30
0
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;
}