1987 lines
56 KiB
C
Executable File
1987 lines
56 KiB
C
Executable File
|
|
|
|
#include <linux/interrupt.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <asm/uaccess.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/input.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/kobject.h>
|
|
#include <linux/platform_device.h>
|
|
#include <asm/atomic.h>
|
|
|
|
#include "up_devices.h"
|
|
#include "Cust_Memory_type.h"
|
|
|
|
#include <linux/cust_include/cust_project_all_config.h>
|
|
#ifdef __CUST_URXDO_GPIO_SELECT__
|
|
#if __CUST_URXDO_GPIO_SELECT__
|
|
#include <linux/of_gpio.h>
|
|
|
|
#define URXDO_SELECT_GPIO_NAME "urxdo_gpio_select"
|
|
|
|
static int up_urxdo_select_gpio_num;
|
|
int up_urxdo_flag = 0;
|
|
int get_urxdo_select_gpio(void);
|
|
static int up_parse_urxdo_dts(struct device_node *node, const char *gpio_name);
|
|
#endif
|
|
#endif
|
|
|
|
#define UP_DEVICE "up_device"
|
|
#define UP_VERSION "ALPS_S0MP1.RC"
|
|
|
|
|
|
typedef int (*up_dev_print)(struct seq_file *se_f);
|
|
|
|
typedef int (*up_dev_set_used)(char * module_name, int pdata);
|
|
|
|
struct up_lcm_device_info
|
|
{
|
|
struct list_head up_list; // list in up_devices_info
|
|
char lcm_module_descrip[50];
|
|
struct list_head lcm_list; // list in up_lcm_info
|
|
LCM_DRIVER* pdata;
|
|
compatible_type type;
|
|
};
|
|
|
|
struct up_camera_device_dinfo
|
|
{
|
|
struct list_head up_list;
|
|
char camera_module_descrip[48];
|
|
struct list_head camera_list;
|
|
int camera_id;
|
|
struct ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT* pdata;
|
|
compatible_type type;
|
|
enum CAMERA_DUAL_CAMERA_SENSOR_ENUM cam_type;
|
|
};
|
|
|
|
struct up_accsensor_device_dinfo
|
|
{
|
|
struct list_head up_list;
|
|
char sensor_descrip[20];
|
|
struct list_head sensor_list;
|
|
int dev_addr;
|
|
int ps_direction; // ps is throthold, als/msensor is diriction
|
|
compatible_type type;
|
|
struct acc_init_info * pdata;
|
|
};
|
|
|
|
//MSENSOR
|
|
struct up_msensor_device_dinfo
|
|
{
|
|
struct list_head up_list;
|
|
char sensor_descrip[20];
|
|
struct list_head sensor_list;
|
|
int dev_addr;
|
|
int ps_direction; // ps is throthold, als/msensor is diriction
|
|
compatible_type type;
|
|
struct mag_init_info * pdata;
|
|
};
|
|
|
|
//ALSPSSENSOR
|
|
struct up_alspssensor_device_dinfo
|
|
{
|
|
struct list_head up_list;
|
|
char sensor_descrip[20];
|
|
struct list_head sensor_list;
|
|
int dev_addr;
|
|
int ps_direction; // ps is throthold, als/alspssensor is diriction
|
|
compatible_type type;
|
|
struct alsps_init_info * pdata;
|
|
};
|
|
|
|
struct up_touchpanel_device_dinfo
|
|
{
|
|
struct list_head up_list; // list in up_devices_info
|
|
char touch_descrip[20];
|
|
struct list_head touch_list;
|
|
int dev_addr;
|
|
struct i2c_driver * pdata;
|
|
// int ps_direction; // ps is throthold, als/msensor is diriction
|
|
compatible_type type;
|
|
};
|
|
|
|
struct up_type_info
|
|
{
|
|
struct list_head up_device; // list in up_devices_info
|
|
struct list_head up_dinfo; // list in up_touch_device_dinfo
|
|
up_dev_print type_print;
|
|
up_dev_set_used set_used;
|
|
int dev_type;
|
|
void * current_used_dinfo;
|
|
struct mutex info_mutex;
|
|
};
|
|
|
|
struct list_head updisp_info_list;
|
|
|
|
struct up_mis_disp_info
|
|
{
|
|
struct list_head mis_info_list; // list in up_devices_info
|
|
void * current_used_dinfo;
|
|
};
|
|
|
|
struct up_devices_info
|
|
{
|
|
struct list_head type_list; // up_type_info list
|
|
struct list_head dev_list; // all_list
|
|
|
|
struct mutex de_mutex;
|
|
};
|
|
|
|
#ifdef __CUST_URXDO_GPIO_SELECT__
|
|
#if __CUST_URXDO_GPIO_SELECT__
|
|
static int up_parse_urxdo_dts(struct device_node *node, const char *gpio_name)
|
|
{
|
|
int gpio_num = 0;
|
|
struct gpio_desc *desc;
|
|
int ret = 0;
|
|
|
|
if (node)
|
|
{
|
|
gpio_num = of_get_named_gpio(node, gpio_name, 0);
|
|
if (gpio_num < 0)
|
|
{
|
|
printk("%s: of_get_named_gpio fail. \n", __func__);
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
printk("%s: of_get_named_gpio GPIO is %d.\n", __func__, gpio_num);
|
|
desc = gpio_to_desc(gpio_num);
|
|
if (!desc)
|
|
{
|
|
printk("%s: gpio_desc is null.\n", __func__);
|
|
return -1;
|
|
}
|
|
else
|
|
printk("%s: gpio_desc is not null.\n", __func__);
|
|
|
|
if (gpio_is_valid(gpio_num))
|
|
printk("%s: gpio number %d is valid. \n", __func__ ,gpio_num);
|
|
|
|
ret = gpio_request(gpio_num, gpio_name);
|
|
if (ret)
|
|
{
|
|
printk("%s: gpio_request fail. \n", __func__);
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
ret = gpio_direction_input(gpio_num);
|
|
if (ret)
|
|
{
|
|
printk("%s: gpio_direction_output failed. \n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
if(gpio_get_value(gpio_num))
|
|
{
|
|
up_urxdo_flag = 0;
|
|
printk("urxdo_1 %s: urxdo_gpio is <%d> status is <%d> flag = %d!\n", __func__,gpio_num,gpio_get_value(gpio_num),up_urxdo_flag);
|
|
}
|
|
else
|
|
{
|
|
up_urxdo_flag = 1;
|
|
printk("urxdo_2 %s: urxdo_gpio is <%d> status is <%d> flag = %d!\n", __func__,gpio_num,gpio_get_value(gpio_num),up_urxdo_flag);
|
|
}
|
|
return gpio_num;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printk("%s: get gpio num fail. \n", __func__);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int get_urxdo_select_gpio(void)
|
|
{
|
|
struct device_node *node;
|
|
printk("%s: enter. \n", __func__);
|
|
|
|
node = of_find_compatible_node(NULL, NULL, "mediatek,up_devices");
|
|
if (node)
|
|
{
|
|
up_urxdo_select_gpio_num = up_parse_urxdo_dts(node, URXDO_SELECT_GPIO_NAME);
|
|
|
|
if (0 > up_urxdo_select_gpio_num)
|
|
{
|
|
printk("%s: up_parse_dts fail. \n", __func__);
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printk("%s: cannot get the node: 'mediatek,up_devices'.\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
printk("%s: end. \n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
#endif//URXDO
|
|
|
|
|
|
struct up_devices_info * up_devices;
|
|
static int up_camera_info_print(struct seq_file *se_f);
|
|
static int up_touchpanel_info_print(struct seq_file *se_f);
|
|
static int up_accsensor_info_print(struct seq_file *se_f);
|
|
static int up_msensor_info_print(struct seq_file *se_f);
|
|
static int up_alspssensor_info_print(struct seq_file *se_f);
|
|
|
|
static int up_lcm_set_used(char * module_name,int pdata);
|
|
static int up_camera_set_used(char * module_name, int pdata);
|
|
static int up_touchpanel_set_used(char * module_name, int pdata);
|
|
static int up_accsensor_set_used(char * module_name, int pdata);
|
|
static int up_msensor_set_used(char * module_name, int pdata);
|
|
static int up_alspssensor_set_used(char * module_name, int pdata);
|
|
|
|
static int up_lcm_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * lcm_type_info;
|
|
struct up_lcm_device_info * plcm_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "---------UP LCM USAGE--------\t \n");
|
|
|
|
list_for_each_entry(lcm_type_info,&up_devices->type_list,up_device){
|
|
if(lcm_type_info->dev_type == ID_LCM_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(plcm_device,&lcm_type_info->up_dinfo,lcm_list){
|
|
seq_printf(se_f, " %s\t: ",plcm_device->lcm_module_descrip);
|
|
if(plcm_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
seq_printf(se_f, " used \n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void init_device_type_info(struct up_type_info * pdevice, void *used_info, int type)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_type_info));
|
|
INIT_LIST_HEAD(&pdevice->up_device);
|
|
INIT_LIST_HEAD(&pdevice->up_dinfo);
|
|
pdevice ->dev_type = type;
|
|
if(used_info)
|
|
pdevice->current_used_dinfo=used_info;
|
|
|
|
if(type == ID_LCM_TYPE)
|
|
{
|
|
pdevice->type_print = up_lcm_info_print;
|
|
pdevice->set_used= up_lcm_set_used;
|
|
}
|
|
else if(type == ID_CAMERA_TYPE)
|
|
{
|
|
pdevice->type_print = up_camera_info_print;
|
|
pdevice->set_used = up_camera_set_used;
|
|
}
|
|
else if(type == ID_TOUCH_TYPE)
|
|
{
|
|
pdevice->type_print = up_touchpanel_info_print;
|
|
pdevice->set_used = up_touchpanel_set_used;
|
|
}
|
|
else if(type == ID_ACCSENSOR_TYPE)
|
|
{
|
|
pdevice->type_print = up_accsensor_info_print;
|
|
pdevice->set_used = up_accsensor_set_used;
|
|
}
|
|
else if(type == ID_MSENSOR_TYPE)
|
|
{
|
|
pdevice->type_print = up_msensor_info_print;
|
|
pdevice->set_used = up_msensor_set_used;
|
|
}
|
|
else if(type == ID_ALSPSSENSOR_TYPE)
|
|
{
|
|
pdevice->type_print = up_alspssensor_info_print;
|
|
pdevice->set_used = up_alspssensor_set_used;
|
|
}
|
|
|
|
mutex_init(&pdevice->info_mutex);
|
|
list_add(&pdevice->up_device,&up_devices->type_list);
|
|
}
|
|
|
|
static void init_lcm_device(struct up_lcm_device_info *pdevice, LCM_DRIVER* nLcm)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_lcm_device_info));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->lcm_list);
|
|
strcpy(pdevice->lcm_module_descrip,nLcm->name);
|
|
pdevice->pdata=nLcm;
|
|
|
|
}
|
|
|
|
int up_lcm_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * lcm_type_info;
|
|
struct up_lcm_device_info * plcm_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(lcm_type_info,&up_devices->type_list,up_device){
|
|
if(lcm_type_info->dev_type == ID_LCM_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(plcm_device,&lcm_type_info->up_dinfo,lcm_list){
|
|
if(!strcmp(module_name,plcm_device->lcm_module_descrip))
|
|
{
|
|
plcm_device->type = DEVICE_USED;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
int up_lcm_device_add(LCM_DRIVER* nLcm, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * lcm_type_info;
|
|
struct up_lcm_device_info * plcm_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(lcm_type_info,&up_devices->type_list,up_device){
|
|
if(lcm_type_info->dev_type == ID_LCM_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
lcm_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(lcm_type_info == NULL)
|
|
{
|
|
printk("lcm_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(lcm_type_info, nLcm, ID_LCM_TYPE);
|
|
else
|
|
init_device_type_info(lcm_type_info, NULL, ID_LCM_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(lcm_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add lcm error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(plcm_device,&lcm_type_info->up_dinfo,lcm_list){
|
|
if(!strcmp(nLcm->name,plcm_device->lcm_module_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
printk("error ___ lcm type is duplicated \n");
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
plcm_device = kmalloc(sizeof(struct up_lcm_device_info), GFP_KERNEL);
|
|
if(plcm_device == NULL)
|
|
{
|
|
printk("lcm_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto devicemalloc_faid;
|
|
}
|
|
|
|
init_lcm_device(plcm_device,nLcm);
|
|
plcm_device->type=isUsed;
|
|
|
|
|
|
list_add(&plcm_device->up_list, &up_devices->dev_list);
|
|
list_add(&plcm_device->lcm_list,&lcm_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
duplicated_faild:
|
|
devicemalloc_faid:
|
|
kfree(plcm_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
|
|
|
|
static int up_camera_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * camera_type_info;
|
|
struct up_camera_device_dinfo * pcamera_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(camera_type_info,&up_devices->type_list,up_device){
|
|
if(camera_type_info->dev_type == ID_CAMERA_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(pcamera_device,&camera_type_info->up_dinfo,camera_list){
|
|
if(!strcmp(module_name,pcamera_device->camera_module_descrip))
|
|
{
|
|
pcamera_device->type = DEVICE_USED;
|
|
pcamera_device->cam_type = pdata;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
#if __CUST_MCAM_OTP_PDAF_STATUS__
|
|
extern char up_mcam_otp_status;
|
|
extern char up_mcam_pdaf_status;
|
|
#endif
|
|
#if __CUST_SCAM_OTP_PDAF_STATUS__
|
|
extern char up_scam_otp_status;
|
|
#endif
|
|
static int up_camera_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * camera_type_info;
|
|
struct up_camera_device_dinfo * pcamera_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "---------UP CAMERA USAGE-------- \n");
|
|
|
|
list_for_each_entry(camera_type_info,&up_devices->type_list,up_device){
|
|
if(camera_type_info->dev_type == ID_CAMERA_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(pcamera_device,&camera_type_info->up_dinfo,camera_list){
|
|
seq_printf(se_f, " %20s\t\t: ",pcamera_device->camera_module_descrip);
|
|
if(pcamera_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
{
|
|
seq_printf(se_f, " used \t");
|
|
if(pcamera_device->cam_type ==DUAL_CAMERA_MAIN_SENSOR)
|
|
{
|
|
seq_printf(se_f, " main camera ");
|
|
#if __CUST_MCAM_OTP_PDAF_STATUS__
|
|
if(up_mcam_otp_status)
|
|
seq_printf(se_f, "\n\t\t\t\t\t\t\t\tMCAM OTP CHECK Success");
|
|
if(up_mcam_pdaf_status)
|
|
seq_printf(se_f, "\n\t\t\t\t\t\t\t\tMCAM PDAF CHECK Success");
|
|
#endif
|
|
seq_printf(se_f, "\n");
|
|
}
|
|
else if(pcamera_device->cam_type ==DUAL_CAMERA_SUB_SENSOR)
|
|
{
|
|
seq_printf(se_f, " sub camera ");
|
|
#if __CUST_SCAM_OTP_PDAF_STATUS__
|
|
if(up_scam_otp_status)
|
|
seq_printf(se_f, "\n\t\t\t\t\t\t\t\tSCAM OTP CHECK Success");
|
|
#endif
|
|
seq_printf(se_f, "\n");
|
|
}
|
|
else if(pcamera_device->cam_type == 3)
|
|
{
|
|
seq_printf(se_f, " main2 camera \n");
|
|
}
|
|
else if(pcamera_device->cam_type == 4)
|
|
{
|
|
seq_printf(se_f, " sub2 camera \n");
|
|
}
|
|
else if(pcamera_device->cam_type == 5)
|
|
{
|
|
seq_printf(se_f, " main3 camera \n");
|
|
}
|
|
else
|
|
seq_printf(se_f, " camera unsupportd type %d\n", pcamera_device->cam_type);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void init_camera_device(struct up_camera_device_dinfo *pdevice, struct ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT* mCamera)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_camera_device_dinfo));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->camera_list);
|
|
strcpy(pdevice->camera_module_descrip,mCamera->drvname);
|
|
pdevice->pdata=mCamera;
|
|
|
|
}
|
|
|
|
|
|
int up_camera_device_add(struct ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT* mCamera, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * camera_type_info;
|
|
struct up_camera_device_dinfo * pcamera_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
list_for_each_entry(camera_type_info,&up_devices->type_list,up_device){
|
|
if(camera_type_info->dev_type == ID_CAMERA_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
camera_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(camera_type_info == NULL)
|
|
{
|
|
printk("cam_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(camera_type_info, mCamera, ID_CAMERA_TYPE);
|
|
else
|
|
init_device_type_info(camera_type_info, NULL, ID_CAMERA_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(camera_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add camera error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(pcamera_device,&camera_type_info->up_dinfo,camera_list){
|
|
if(!strcmp(mCamera->drvname,pcamera_device->camera_module_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
pcamera_device = kmalloc(sizeof(struct up_camera_device_dinfo), GFP_KERNEL);
|
|
if(camera_type_info == NULL)
|
|
{
|
|
printk("cam_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto malloc_faid;
|
|
}
|
|
init_camera_device(pcamera_device,mCamera);
|
|
pcamera_device->type=isUsed;
|
|
|
|
list_add(&pcamera_device->up_list, &up_devices->dev_list);
|
|
list_add(&pcamera_device->camera_list,&camera_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
duplicated_faild:
|
|
kfree(pcamera_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
|
|
|
|
static int up_touchpanel_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * touchpanel_type_info;
|
|
struct up_touchpanel_device_dinfo * ptouchpanel_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(touchpanel_type_info,&up_devices->type_list,up_device){
|
|
if(touchpanel_type_info->dev_type == ID_TOUCH_TYPE)
|
|
{
|
|
printk("touch type has find break !!\n");
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(ptouchpanel_device,&touchpanel_type_info->up_dinfo,touch_list){
|
|
if(!strcmp(module_name,ptouchpanel_device->touch_descrip))
|
|
{
|
|
ptouchpanel_device->type = DEVICE_USED;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
static int up_touchpanel_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * touchpanel_type_info;
|
|
struct up_touchpanel_device_dinfo * ptouchpanel_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "--------UP TOUCHPANEL USAGE-------\t \n");
|
|
|
|
list_for_each_entry(touchpanel_type_info,&up_devices->type_list,up_device){
|
|
if(touchpanel_type_info->dev_type == ID_TOUCH_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(ptouchpanel_device,&touchpanel_type_info->up_dinfo,touch_list){
|
|
seq_printf(se_f, " %20s\t: ",ptouchpanel_device->touch_descrip);
|
|
if(ptouchpanel_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
{
|
|
seq_printf(se_f, " used \t \n");
|
|
seq_printf(se_f, " %20s\t \n", touch_fw_version);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
static void init_touchpanel_device(struct up_touchpanel_device_dinfo *pdevice, struct i2c_driver * mTouch)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_touchpanel_device_dinfo));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->touch_list);
|
|
strcpy(pdevice->touch_descrip,mTouch->driver.name);
|
|
pdevice->pdata=mTouch;
|
|
|
|
}
|
|
|
|
|
|
int up_touchpanel_device_add(struct i2c_driver* mTouch, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * touchpanel_type_info;
|
|
struct up_touchpanel_device_dinfo * ptouchpanel_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
list_for_each_entry(touchpanel_type_info,&up_devices->type_list,up_device){
|
|
if(touchpanel_type_info->dev_type == ID_TOUCH_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
touchpanel_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(touchpanel_type_info == NULL)
|
|
{
|
|
printk("tp_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(touchpanel_type_info, mTouch, ID_TOUCH_TYPE);
|
|
else
|
|
init_device_type_info(touchpanel_type_info, NULL, ID_TOUCH_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(touchpanel_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add tp error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(ptouchpanel_device,&touchpanel_type_info->up_dinfo,touch_list){
|
|
if(!strcmp(mTouch->driver.name,ptouchpanel_device->touch_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
ptouchpanel_device = kmalloc(sizeof(struct up_touchpanel_device_dinfo), GFP_KERNEL);
|
|
if(ptouchpanel_device == NULL)
|
|
{
|
|
printk("tp_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto malloc_faid;
|
|
}
|
|
init_touchpanel_device(ptouchpanel_device,mTouch);
|
|
ptouchpanel_device->type=isUsed;
|
|
|
|
list_add(&ptouchpanel_device->up_list, &up_devices->dev_list);
|
|
list_add(&ptouchpanel_device->touch_list,&touchpanel_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
duplicated_faild:
|
|
kfree(ptouchpanel_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
|
|
|
|
static int up_accsensor_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * accsensor_type_info;
|
|
struct up_accsensor_device_dinfo * paccsensor_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(accsensor_type_info,&up_devices->type_list,up_device){
|
|
if(accsensor_type_info->dev_type == ID_ACCSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(paccsensor_device,&accsensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(module_name,paccsensor_device->sensor_descrip))
|
|
{
|
|
paccsensor_device->type = DEVICE_USED;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
static int up_accsensor_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * accsensor_type_info;
|
|
struct up_accsensor_device_dinfo * paccsensor_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "--------UP accsensor USAGE-------\t \n");
|
|
|
|
list_for_each_entry(accsensor_type_info,&up_devices->type_list,up_device){
|
|
if(accsensor_type_info->dev_type == ID_ACCSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(paccsensor_device,&accsensor_type_info->up_dinfo,sensor_list){
|
|
seq_printf(se_f, " %20s\t\t: ",paccsensor_device->sensor_descrip);
|
|
if(paccsensor_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
{
|
|
seq_printf(se_f, " used \t\n");
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
static void init_accsensor_device(struct up_accsensor_device_dinfo *pdevice, struct acc_init_info * maccsensor)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_accsensor_device_dinfo));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->sensor_list);
|
|
strcpy(pdevice->sensor_descrip,maccsensor->name);
|
|
pdevice->pdata=maccsensor;
|
|
|
|
}
|
|
|
|
int up_accsensor_device_add(struct acc_init_info* maccsensor, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * accsensor_type_info;
|
|
struct up_accsensor_device_dinfo * paccsensor_device;
|
|
struct acc_init_info * pacc_sensor;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
pacc_sensor = maccsensor;
|
|
|
|
list_for_each_entry(accsensor_type_info,&up_devices->type_list,up_device){
|
|
if(accsensor_type_info->dev_type == ID_ACCSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
accsensor_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(accsensor_type_info == NULL)
|
|
{
|
|
printk("acc_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(accsensor_type_info, maccsensor, ID_ACCSENSOR_TYPE);
|
|
else
|
|
init_device_type_info(accsensor_type_info, NULL, ID_ACCSENSOR_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(accsensor_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add accsensor error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(paccsensor_device,&accsensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(maccsensor->name,paccsensor_device->sensor_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
paccsensor_device = (struct up_accsensor_device_dinfo *)kmalloc(sizeof(struct up_accsensor_device_dinfo), GFP_KERNEL);
|
|
if(paccsensor_device == NULL)
|
|
{
|
|
printk("acc_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto malloc_faid;
|
|
}
|
|
init_accsensor_device(paccsensor_device , pacc_sensor);
|
|
|
|
paccsensor_device->type=isUsed;
|
|
|
|
list_add(&paccsensor_device->up_list, &up_devices->dev_list);
|
|
list_add(&paccsensor_device->sensor_list,&accsensor_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
duplicated_faild:
|
|
kfree(paccsensor_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
|
|
//MSENSOR START
|
|
static int up_msensor_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * msensor_type_info;
|
|
struct up_msensor_device_dinfo * pmsensor_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(msensor_type_info,&up_devices->type_list,up_device){
|
|
if(msensor_type_info->dev_type == ID_MSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(pmsensor_device,&msensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(module_name,pmsensor_device->sensor_descrip))
|
|
{
|
|
pmsensor_device->type = DEVICE_USED;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
static int up_msensor_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * msensor_type_info;
|
|
struct up_msensor_device_dinfo * pmsensor_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "--------UP msensor USAGE-------\t \n");
|
|
|
|
list_for_each_entry(msensor_type_info,&up_devices->type_list,up_device){
|
|
if(msensor_type_info->dev_type == ID_MSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(pmsensor_device,&msensor_type_info->up_dinfo,sensor_list){
|
|
seq_printf(se_f, " %20s\t\t: ",pmsensor_device->sensor_descrip);
|
|
if(pmsensor_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
{
|
|
seq_printf(se_f, " used \t\n");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void init_msensor_device(struct up_msensor_device_dinfo *pdevice, struct mag_init_info * mmsensor)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_msensor_device_dinfo));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->sensor_list);
|
|
strcpy(pdevice->sensor_descrip,mmsensor->name);
|
|
pdevice->pdata=mmsensor;
|
|
|
|
}
|
|
|
|
int up_msensor_device_add(struct mag_init_info* mmsensor, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * msensor_type_info;
|
|
struct up_msensor_device_dinfo * pmsensor_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
list_for_each_entry(msensor_type_info,&up_devices->type_list,up_device){
|
|
if(msensor_type_info->dev_type == ID_MSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
msensor_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(msensor_type_info == NULL)
|
|
{
|
|
printk("msensor_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(msensor_type_info, mmsensor, ID_MSENSOR_TYPE);
|
|
else
|
|
init_device_type_info(msensor_type_info, NULL, ID_MSENSOR_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(msensor_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add msensor error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(pmsensor_device,&msensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(mmsensor->name,pmsensor_device->sensor_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
pmsensor_device = kmalloc(sizeof(struct up_msensor_device_dinfo), GFP_KERNEL);
|
|
if(pmsensor_device == NULL)
|
|
{
|
|
printk("msensor_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto malloc_faid;
|
|
}
|
|
init_msensor_device(pmsensor_device,mmsensor);
|
|
pmsensor_device->type=isUsed;
|
|
|
|
list_add(&pmsensor_device->up_list, &up_devices->dev_list);
|
|
list_add(&pmsensor_device->sensor_list,&msensor_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
duplicated_faild:
|
|
kfree(pmsensor_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
//MSENSOR END
|
|
|
|
//ALSPSSENSOR START
|
|
static int up_alspssensor_set_used(char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * alspssensor_type_info;
|
|
struct up_alspssensor_device_dinfo * palspssensor_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
|
|
list_for_each_entry(alspssensor_type_info,&up_devices->type_list,up_device){
|
|
if(alspssensor_type_info->dev_type == ID_ALSPSSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
reterror = -1;
|
|
goto error_notype;
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(palspssensor_device,&alspssensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(module_name,palspssensor_device->sensor_descrip))
|
|
{
|
|
palspssensor_device->type = DEVICE_USED;
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == 1)
|
|
return 0;
|
|
|
|
error_notype:
|
|
return reterror;
|
|
|
|
}
|
|
|
|
static int up_alspssensor_info_print(struct seq_file *se_f)
|
|
{
|
|
|
|
struct up_type_info * alspssensor_type_info;
|
|
struct up_alspssensor_device_dinfo * palspssensor_device;
|
|
int flag = -1;
|
|
|
|
seq_printf(se_f, "--------UP alspssensor USAGE-------\t \n");
|
|
|
|
list_for_each_entry(alspssensor_type_info,&up_devices->type_list,up_device){
|
|
if(alspssensor_type_info->dev_type == ID_ALSPSSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag == 1)
|
|
{
|
|
list_for_each_entry(palspssensor_device,&alspssensor_type_info->up_dinfo,sensor_list){
|
|
seq_printf(se_f, " %20s\t\t: ",palspssensor_device->sensor_descrip);
|
|
if(palspssensor_device->type == DEVICE_SUPPORTED)
|
|
seq_printf(se_f, " supported \n");
|
|
else
|
|
{
|
|
seq_printf(se_f, " used \t\n");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seq_printf(se_f, " \t: NONE \n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void init_alspssensor_device(struct up_alspssensor_device_dinfo *pdevice, struct alsps_init_info * malspssensor)
|
|
{
|
|
memset(pdevice,0, sizeof(struct up_alspssensor_device_dinfo));
|
|
INIT_LIST_HEAD(&pdevice->up_list);
|
|
INIT_LIST_HEAD(&pdevice->sensor_list);
|
|
strcpy(pdevice->sensor_descrip,malspssensor->name);
|
|
pdevice->pdata=malspssensor;
|
|
|
|
}
|
|
|
|
|
|
int up_alspssensor_device_add(struct alsps_init_info* malspssensor, compatible_type isUsed)
|
|
{
|
|
struct up_type_info * alspssensor_type_info;
|
|
struct up_alspssensor_device_dinfo * palspssensor_device;
|
|
int flag = -1;
|
|
int reterror=0;
|
|
|
|
list_for_each_entry(alspssensor_type_info,&up_devices->type_list,up_device){
|
|
if(alspssensor_type_info->dev_type == ID_ALSPSSENSOR_TYPE)
|
|
{
|
|
flag =1; // this mean type is ok
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(flag == -1) // this mean type is new
|
|
{
|
|
alspssensor_type_info = kmalloc(sizeof(struct up_type_info), GFP_KERNEL);
|
|
|
|
if(alspssensor_type_info == NULL)
|
|
{
|
|
printk("alsps_alloc type info failed ~~~~ \n");
|
|
reterror = -1;
|
|
goto malloc_faid;
|
|
}
|
|
|
|
if(isUsed)
|
|
init_device_type_info(alspssensor_type_info, malspssensor, ID_ALSPSSENSOR_TYPE);
|
|
else
|
|
init_device_type_info(alspssensor_type_info, NULL, ID_ALSPSSENSOR_TYPE);
|
|
}
|
|
else
|
|
{
|
|
if(isUsed &&(alspssensor_type_info->current_used_dinfo!=NULL))
|
|
printk("~~~~add alsps error , duplicated current used lcm \n");
|
|
}
|
|
|
|
flag =-1;
|
|
|
|
list_for_each_entry(palspssensor_device,&alspssensor_type_info->up_dinfo,sensor_list){
|
|
if(!strcmp(malspssensor->name,palspssensor_device->sensor_descrip))
|
|
{
|
|
flag =1; // this mean device is ok
|
|
break;
|
|
}
|
|
}
|
|
if(flag ==1)
|
|
{
|
|
goto duplicated_faild;
|
|
}
|
|
else
|
|
{
|
|
palspssensor_device = kmalloc(sizeof(struct up_alspssensor_device_dinfo), GFP_KERNEL);
|
|
if(palspssensor_device == NULL)
|
|
{
|
|
printk("alsps_alloc type info failed ~~~~ \n");
|
|
reterror = -2;
|
|
goto malloc_faid;
|
|
}
|
|
init_alspssensor_device(palspssensor_device,malspssensor);
|
|
palspssensor_device->type=isUsed;
|
|
|
|
list_add(&palspssensor_device->up_list, &up_devices->dev_list);
|
|
list_add(&palspssensor_device->sensor_list,&alspssensor_type_info->up_dinfo);
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
duplicated_faild:
|
|
kfree(palspssensor_device);
|
|
malloc_faid:
|
|
|
|
printk("%s: error return: %x: ---\n",__func__,reterror);
|
|
return reterror;
|
|
|
|
}
|
|
//ALSPSSENSOR END
|
|
|
|
static int up_set_device_used(int dev_type, char * module_name, int pdata)
|
|
{
|
|
struct up_type_info * type_info;
|
|
int ret_val = 0;
|
|
|
|
list_for_each_entry(type_info,&up_devices->type_list,up_device){
|
|
if(type_info->dev_type == dev_type)
|
|
{
|
|
if(type_info->set_used!=NULL)
|
|
type_info->set_used(module_name,pdata);
|
|
}
|
|
}
|
|
|
|
return ret_val;
|
|
}
|
|
|
|
int up_set_touch_device_used(char * module_name, int pdata)
|
|
{
|
|
int ret_val = 0;
|
|
ret_val = up_set_device_used(ID_TOUCH_TYPE,module_name,pdata);
|
|
return ret_val;
|
|
}
|
|
|
|
|
|
int up_set_camera_device_used(char * module_name, int pdata)
|
|
{
|
|
int ret_val = 0;
|
|
ret_val = up_set_device_used(ID_CAMERA_TYPE,module_name,pdata);
|
|
return ret_val;
|
|
}
|
|
|
|
int up_set_accsensor_device_used(char * module_name, int pdata)
|
|
{
|
|
int ret_val = 0;
|
|
ret_val = up_set_device_used(ID_ACCSENSOR_TYPE,module_name,pdata);
|
|
return ret_val;
|
|
}
|
|
|
|
//MSENSOR
|
|
int up_set_msensor_device_used(char * module_name, int pdata)
|
|
{
|
|
int ret_val = 0;
|
|
ret_val = up_set_device_used(ID_MSENSOR_TYPE,module_name,pdata);
|
|
return ret_val;
|
|
}
|
|
|
|
//ALSPSSENSOR
|
|
int up_set_alspssensor_device_used(char * module_name, int pdata)
|
|
{
|
|
int ret_val = 0;
|
|
ret_val = up_set_device_used(ID_ALSPSSENSOR_TYPE,module_name,pdata);
|
|
return ret_val;
|
|
}
|
|
|
|
extern LCM_DRIVER *lcm_driver_list[];
|
|
extern unsigned int lcm_count;
|
|
extern int proc_upinfo_init(void);
|
|
#ifdef CONFIG_MACH_MT6779
|
|
extern struct ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT gimgsensor_sensor_list[];
|
|
#else
|
|
extern struct ACDK_KD_SENSOR_INIT_FUNCTION_STRUCT kdSensorList[];
|
|
#endif
|
|
extern LCM_DRIVER * DISP_GetLcmDrv(void);
|
|
static LCM_DRIVER *lcm_drv = NULL;
|
|
|
|
static void init_lcm(void)
|
|
{
|
|
int temp;
|
|
lcm_drv = DISP_GetLcmDrv();
|
|
|
|
if(lcm_count ==1)
|
|
{
|
|
up_lcm_device_add(lcm_driver_list[0], DEVICE_USED);
|
|
}
|
|
else
|
|
{
|
|
for(temp= 0;temp< lcm_count;temp++)
|
|
{
|
|
if(lcm_drv == lcm_driver_list[temp])
|
|
up_lcm_device_add(lcm_driver_list[temp], DEVICE_USED);
|
|
else
|
|
up_lcm_device_add(lcm_driver_list[temp], DEVICE_SUPPORTED);
|
|
}
|
|
}
|
|
}
|
|
|
|
void up_add_display_info(char * buffer, int lenth)
|
|
{
|
|
struct up_mis_disp_info * new_display_info;
|
|
char * buffer_info=NULL;
|
|
|
|
#if 0
|
|
if(*(buffer+lenth)!="\0")
|
|
{
|
|
printk("display info error\n");
|
|
return;
|
|
}
|
|
#endif
|
|
new_display_info = kmalloc(sizeof(struct up_mis_disp_info), GFP_KERNEL );
|
|
list_add(&new_display_info->mis_info_list , &updisp_info_list);
|
|
buffer_info = kmalloc(lenth , GFP_KERNEL );
|
|
new_display_info->current_used_dinfo = buffer_info;
|
|
memcpy(buffer_info, buffer,lenth );
|
|
|
|
}
|
|
|
|
void up_display_info_dump(struct seq_file *m)
|
|
{
|
|
struct up_mis_disp_info * pdisp_info=NULL;
|
|
|
|
seq_printf(m, "----UP INFO DUMP---\t \n");
|
|
|
|
list_for_each_entry(pdisp_info,&updisp_info_list ,mis_info_list){
|
|
seq_printf(m, "Info:%s\n",(char *)pdisp_info->current_used_dinfo);
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef EMMC_COMPATIBLE_NUM
|
|
|
|
extern char *saved_command_line;
|
|
|
|
|
|
int get_lpddr_emmc_used_index(void)
|
|
{
|
|
char *ptr;
|
|
int lpddr_index=0;
|
|
ptr=strstr(saved_command_line,"lpddr_used_index=");
|
|
if(ptr==NULL)
|
|
return -1;
|
|
ptr+=strlen("lpddr_used_index=");
|
|
lpddr_index=simple_strtol(ptr,NULL,10);
|
|
return lpddr_index;
|
|
}
|
|
|
|
int get_lpddr_emmc_flash_type(void)
|
|
{
|
|
char *ptr;
|
|
int flash_type=0;
|
|
ptr=strstr(saved_command_line,"flash_type=");
|
|
if(ptr==NULL)
|
|
return 0xFF;
|
|
ptr+=strlen("flash_type=");
|
|
flash_type=simple_strtol(ptr,NULL,10);
|
|
return flash_type;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_MACH_MT6757)
|
|
#include "../accdet/mt6355/accdet.h"
|
|
#else
|
|
//#include <mt6357-accdet.h>
|
|
#endif
|
|
//extern struct head_dts_data accdet_dts;
|
|
#if !defined(CONFIG_SND_SOC_AW87XXX)
|
|
#ifndef CONFIG_MTK_SPEAKER
|
|
#ifdef CONFIG_MACH_MT6779
|
|
#else
|
|
extern int extamp_sound_mode;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
extern char dump_stack_arch_desc_str[128];
|
|
char bbchip_name[128];
|
|
|
|
#if defined(CONFIG_SND_SOC_AW87XXX)
|
|
enum up_pa_aw87xxx_chipid {
|
|
UP_PA_AW87XXX_CHIPID_39 = 0x39,
|
|
UP_PA_AW87XXX_CHIPID_59 = 0x59,
|
|
UP_PA_AW87XXX_CHIPID_69 = 0x69,
|
|
UP_PA_AW87XXX_CHIPID_5A = 0x5A,
|
|
};
|
|
enum up_userd_aw_dev_chipid {
|
|
UP_USERD_AW_DEV_CHIPID_18 = 0x18,
|
|
UP_USERD_AW_DEV_CHIPID_39 = 0x39,
|
|
UP_USERD_AW_DEV_CHIPID_59 = 0x59,
|
|
UP_USERD_AW_DEV_CHIPID_69 = 0x69,
|
|
UP_USERD_AW_DEV_CHIPID_5A = 0x5A,
|
|
UP_USERD_AW_DEV_CHIPID_9A = 0x9A,
|
|
UP_USERD_AW_DEV_CHIPID_9B = 0x9B,
|
|
YUP_USERD_AW_DEV_CHIPID_76 = 0x76,
|
|
};
|
|
extern int pa_model;
|
|
#endif
|
|
|
|
int up_device_dump(struct seq_file *m)
|
|
{
|
|
static int ilcm_init = 0;
|
|
struct up_type_info * type_info;
|
|
int i = 0;
|
|
if(0 == ilcm_init)
|
|
{
|
|
init_lcm();
|
|
ilcm_init = 1;
|
|
}
|
|
|
|
|
|
for(i=0;i<strlen(dump_stack_arch_desc_str);i++)
|
|
{
|
|
if(dump_stack_arch_desc_str[i] ==' ')
|
|
{
|
|
bbchip_name[i] = '\0';
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
bbchip_name[i]=dump_stack_arch_desc_str[i];
|
|
}
|
|
}
|
|
|
|
seq_printf(m,"base:%s \tBBChip:%s\n",UP_VERSION,bbchip_name);
|
|
seq_printf(m," \t\t UP DEVICE DUMP--begin\n");
|
|
list_for_each_entry(type_info,&up_devices->type_list,up_device)
|
|
{
|
|
if(type_info->type_print == NULL)
|
|
{
|
|
printk(" error !!! this type [%d] has no dump fun \n",type_info->dev_type);
|
|
}
|
|
else
|
|
type_info->type_print(m);
|
|
}
|
|
|
|
seq_printf(m,"---------CUST MIC MODE-------- \n");
|
|
//seq_printf(m," accdet mic mode : %d\n",accdet_dts.mic_mode);
|
|
#if defined(CONFIG_SND_SOC_AW87XXX)
|
|
switch (pa_model) {
|
|
case UP_USERD_AW_DEV_CHIPID_18:
|
|
seq_printf(m," audio PA : AW87539\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_39:
|
|
seq_printf(m," audio PA : AW87339\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_59:
|
|
seq_printf(m," audio PA : AW87519\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_69:
|
|
seq_printf(m," audio PA : AW87369\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_5A:
|
|
seq_printf(m," audio PA : AW87559\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_9A:
|
|
seq_printf(m," audio PA : AW87309\n");
|
|
goto device_show;
|
|
case UP_USERD_AW_DEV_CHIPID_9B:
|
|
seq_printf(m," audio PA : AW87319\n");
|
|
goto device_show;
|
|
case YUP_USERD_AW_DEV_CHIPID_76:
|
|
seq_printf(m," audio PA : AW87390\n");
|
|
goto device_show;
|
|
default:
|
|
seq_printf(m," audio PA : No supported pa\n");
|
|
break;
|
|
}
|
|
|
|
#else
|
|
#ifndef CONFIG_MTK_SPEAKER
|
|
#ifndef __CUST_EXTAMP_MODE__
|
|
#else
|
|
seq_printf(m," UP_EXTAMP_HP_MODE : %d\n",extamp_sound_mode);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#if defined(CONFIG_SND_SOC_AW87XXX)
|
|
device_show:
|
|
#endif
|
|
seq_printf(m, "modem: %s\n", CUSTOM_MODEM);
|
|
up_display_info_dump(m);
|
|
return 0;
|
|
}
|
|
|
|
int up_memory_dump(struct seq_file *m)
|
|
{
|
|
#ifdef EMMC_COMPATIBLE_NUM
|
|
{
|
|
int tem = 0;
|
|
int flash_idex=0;
|
|
flash_idex = get_lpddr_emmc_used_index();
|
|
seq_printf(m, "----UP Memory USAGE---\t \n");
|
|
seq_printf(m," EMMC compatible num =%d,type=%x \n", EMMC_COMPATIBLE_NUM,get_lpddr_emmc_flash_type());
|
|
for(;tem<EMMC_COMPATIBLE_NUM;tem++)
|
|
{
|
|
if(flash_idex==tem)
|
|
seq_printf(m," EMMC COMP[%d] =%s\t --used\n", tem, Cust_emmc_support[tem]);
|
|
else
|
|
seq_printf(m," EMMC COMP[%d] =%s\t--support\n", tem, Cust_emmc_support[tem]);
|
|
}
|
|
|
|
seq_printf(m," \t\t UP Memory DUMP--end\n\n");
|
|
|
|
}
|
|
#endif
|
|
up_display_info_dump(m);
|
|
|
|
return 0;
|
|
|
|
}
|
|
#ifdef __CUST_M169_ONLY_SHOW_USED_MEMORY_ON_8618__
|
|
int up_onlyshowusedmem_dump(struct seq_file *m)
|
|
{
|
|
#ifdef EMMC_COMPATIBLE_NUM
|
|
{
|
|
int tem = 0;
|
|
int flash_idex=0;
|
|
flash_idex = get_lpddr_emmc_used_index();
|
|
seq_printf(m, "----UP Memory USAGE---\t \n");
|
|
seq_printf(m," EMMC compatible num =%d,type=%x \n", EMMC_COMPATIBLE_NUM,get_lpddr_emmc_flash_type());
|
|
for(;tem<EMMC_COMPATIBLE_NUM;tem++)
|
|
{
|
|
if(flash_idex==tem)
|
|
seq_printf(m," EMMC COMP[%d] =%s\t --used\n", tem, Cust_emmc_support[tem]);
|
|
}
|
|
seq_printf(m," \t\t UP Memory DUMP--end\n\n");
|
|
|
|
}
|
|
#endif
|
|
up_display_info_dump(m);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
//#define UP_DEVICES_IOCTL_SUPPORT
|
|
#ifdef UP_DEVICES_IOCTL_SUPPORT
|
|
#include "up_devices_ioctl.h"
|
|
|
|
static int open_flag=1;
|
|
static spinlock_t lock;
|
|
|
|
static int up_devices_open (struct inode *ind,struct file * fl){
|
|
spin_lock(&lock);
|
|
if(1 != open_flag){
|
|
spin_unlock(&lock);
|
|
printk("up_devices_open already open\n");
|
|
return -EBUSY;
|
|
}
|
|
|
|
open_flag --;
|
|
spin_unlock(&lock);
|
|
return 0;
|
|
}
|
|
|
|
static int up_devices_release (struct inode *inode, struct file *file){
|
|
printk("up_devices_release close\n");
|
|
open_flag ++;
|
|
return 0;
|
|
}
|
|
extern int IMM_GetOneChannelValue(int dwChannel, int data[4], int* rawdata);
|
|
|
|
|
|
static long up_devices_ioctl (struct file *file, unsigned int cmd, unsigned long arg){
|
|
int ret = -1;
|
|
int data = -1;
|
|
int adcdata[4] = {0};
|
|
int rawdata = 0;
|
|
switch (cmd) {
|
|
case UPIOC_GET_EXTAMP_SOUND_MODE :
|
|
ret = copy_to_user((int *)arg, &extamp_sound_mode ,sizeof(int));
|
|
printk("UPIOC_GET_EXTAMP_SOUND_MODE ret:%d,extamp_sound_mode:%d\n",ret,extamp_sound_mode);
|
|
break;
|
|
case UPIOC_SET_EXTAMP_SOUND_MODE :
|
|
ret = copy_from_user(&data ,(int *)arg,sizeof(int));
|
|
if (data < 1 || data > 5){
|
|
printk("UPIOC_SET_EXTAMP_SOUND_MODE err,mode:%d \n",data);
|
|
break;
|
|
}else
|
|
extamp_sound_mode = data;
|
|
ret = copy_to_user((int *)arg, &extamp_sound_mode ,sizeof(int));
|
|
break;
|
|
case UPIOC_GET_ACCDET_MIC_MODE :
|
|
|
|
//ret = copy_to_user((unsigned int *)arg, & accdet_dts_data.accdet_mic_mode ,sizeof(int));
|
|
break;
|
|
case UPIOC_SET_ACCDET_MIC_MODE :
|
|
|
|
break;
|
|
case UPIOC_GET_ADC_VALUE:
|
|
ret = copy_from_user(&data ,(int *)arg,sizeof(int));
|
|
if (ret != 0) break;
|
|
if( data < 0 || data > 14 ){
|
|
printk("UPIOC_GET_ADC_VALUE data err,data:%d \n",data);
|
|
}
|
|
ret = IMM_GetOneChannelValue(data, adcdata, &rawdata);
|
|
printk("up_adc_read Channel:%d rawdata= %x adcdata= %x %x, ret=%d \n",data,rawdata, adcdata[0], adcdata[1],ret);
|
|
if (ret != 0) break;
|
|
ret = copy_to_user((int *)arg, &rawdata ,sizeof(int));
|
|
break;
|
|
default:
|
|
printk("up_devices ioctl is not exits\n");
|
|
break;
|
|
}
|
|
if (ret < 0){
|
|
printk("up_devices ioctl failed\n");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static const struct file_operations up_devices_fops = {
|
|
.owner = THIS_MODULE,
|
|
// .write = up_devices_write,
|
|
// .read = up_devices_read,
|
|
.unlocked_ioctl = up_devices_ioctl,
|
|
// .compat_ioctl = up_devices_compat_ioctl,
|
|
.open = up_devices_open,
|
|
.release = up_devices_release,
|
|
.llseek = no_llseek,
|
|
};
|
|
|
|
|
|
static struct miscdevice up_devices_misc = {
|
|
.minor = MISC_DYNAMIC_MINOR,
|
|
.name = "up_devices",
|
|
.fops = &up_devices_fops,
|
|
};
|
|
|
|
#endif
|
|
|
|
int get_cts_flag_from_cmdline(void)
|
|
{
|
|
char *ptr;
|
|
int ret=0;
|
|
ptr=strstr(saved_command_line,"up_cts_flag=");
|
|
if(ptr==NULL)
|
|
return -1;
|
|
ptr+=strlen("up_cts_flag=");
|
|
ret=simple_strtol(ptr,NULL,10);
|
|
printk("get_cts_flag_from_cmdline. ret = %d. \n", ret);
|
|
return ret ? 1 : 0;
|
|
}
|
|
|
|
int is_up_cts_board(void)
|
|
{
|
|
#ifdef __CUST_URXDO_GPIO_SELECT__
|
|
return up_urxdo_flag;
|
|
#endif
|
|
#ifdef __CUST_S900_CAMERA_CTS_COMPATIBLE__
|
|
int id_volt = 0;
|
|
int ret;
|
|
|
|
ret = IMM_GetOneChannelValue_Cali(3, &id_volt);
|
|
if (ret != 0)
|
|
printk("id_volt read fail\n");
|
|
else
|
|
printk("id_volt = %d\n", id_volt);
|
|
if(id_volt/1000 > 1100) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
#endif
|
|
{
|
|
int value = get_cts_flag_from_cmdline();
|
|
return (1 == value) ? 1: 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int up_cts_dump(struct seq_file *m)
|
|
{
|
|
seq_printf(m, is_up_cts_board() ? "1" : "0");
|
|
return 0;
|
|
}
|
|
|
|
|
|
static ssize_t mt_cts_flag_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
int value;
|
|
if (!dev) {
|
|
printk("mt_cts_flag_show. dev is null!!\n");
|
|
return 0;
|
|
}
|
|
value = is_up_cts_board() ? 1 : 0;
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", value);
|
|
}
|
|
DEVICE_ATTR(up_cts_flag, 0664, mt_cts_flag_show, NULL);
|
|
static struct device_attribute *mt_sysfs_attributes[] = {
|
|
&dev_attr_up_cts_flag,
|
|
NULL
|
|
};
|
|
|
|
static int init_up_sysfs(struct device *dev)
|
|
{
|
|
struct device_attribute **attr;
|
|
int rc;
|
|
printk("init_up_sysfs. begin. \n");
|
|
|
|
for (attr = mt_sysfs_attributes; *attr; attr++) {
|
|
rc = device_create_file(dev, *attr);
|
|
if (rc)
|
|
goto out_unreg;
|
|
}
|
|
return 0;
|
|
|
|
out_unreg:
|
|
for (; attr >= mt_sysfs_attributes; attr--)
|
|
device_remove_file(dev, *attr);
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
static int up_devices_probe(struct platform_device *pdev)
|
|
{
|
|
int temp;
|
|
int err =0;
|
|
struct device *dev = &pdev->dev;
|
|
|
|
err = proc_upinfo_init();
|
|
if(err<0)
|
|
goto proc_error;
|
|
|
|
up_devices = kmalloc(sizeof(struct up_devices_info), GFP_KERNEL);
|
|
|
|
if(up_devices == NULL)
|
|
{
|
|
printk("%s: error probe becase of mem\n",__func__);
|
|
return -1;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&up_devices->type_list);
|
|
INIT_LIST_HEAD(&up_devices->dev_list);
|
|
mutex_init(&up_devices->de_mutex);
|
|
|
|
INIT_LIST_HEAD(&updisp_info_list);
|
|
|
|
|
|
for(temp=0;;temp++)
|
|
{
|
|
#ifdef CONFIG_MACH_MT6779
|
|
if(gimgsensor_sensor_list[temp].SensorInit!=NULL)
|
|
{
|
|
up_camera_device_add(&gimgsensor_sensor_list[temp], DEVICE_SUPPORTED);
|
|
}
|
|
#else
|
|
if(kdSensorList[temp].SensorInit!=NULL)
|
|
{
|
|
up_camera_device_add(&kdSensorList[temp], DEVICE_SUPPORTED);
|
|
}
|
|
#endif
|
|
else
|
|
break;
|
|
}
|
|
#ifdef UP_DEVICES_IOCTL_SUPPORT
|
|
err = misc_register(&up_devices_misc);
|
|
if (err < 0) {
|
|
printk("%s: misc_register error!\n",__func__);
|
|
goto proc_error;
|
|
}
|
|
|
|
|
|
spin_lock_init(&lock);
|
|
|
|
#endif
|
|
|
|
|
|
if (init_up_sysfs(dev)) {
|
|
printk("failed to init_sysfs. \n");
|
|
}
|
|
|
|
|
|
return 0;
|
|
proc_error:
|
|
return err;
|
|
}
|
|
/*----------------------------------------------------------------------------*/
|
|
static int up_devices_remove(struct platform_device *pdev)
|
|
{
|
|
#ifdef UP_DEVICES_IOCTL_SUPPORT
|
|
misc_deregister(&up_devices_misc);
|
|
#endif
|
|
return 0;
|
|
}
|
|
#ifdef CONFIG_OF
|
|
struct of_device_id up_device_of_match[] = {
|
|
{ .compatible = "mediatek,up_devices", },
|
|
{},
|
|
};
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
static struct platform_driver up_devices_driver = {
|
|
.probe = up_devices_probe,
|
|
.remove = up_devices_remove,
|
|
.driver = {
|
|
.name = UP_DEVICE,
|
|
.owner = THIS_MODULE,
|
|
#ifdef CONFIG_OF
|
|
.of_match_table = up_device_of_match,
|
|
#endif
|
|
},
|
|
|
|
};
|
|
|
|
#ifndef CONFIG_OF
|
|
static struct platform_device up_dev = {
|
|
.name = "up_devices",
|
|
.id = -1,
|
|
};
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
int up_debug = 0;
|
|
static int __init up_devices_init(void)
|
|
{
|
|
|
|
#ifndef CONFIG_OF
|
|
retval = platform_device_register(&up_dev);
|
|
if (retval != 0){
|
|
return retval;
|
|
}
|
|
#endif
|
|
|
|
up_debug = 1;
|
|
if(platform_driver_register(&up_devices_driver))
|
|
{
|
|
up_debug = 0;
|
|
printk("failed to register driver");
|
|
return -ENODEV;
|
|
}
|
|
up_debug = 0;
|
|
|
|
#ifdef __CUST_URXDO_GPIO_SELECT__
|
|
#if __CUST_URXDO_GPIO_SELECT__
|
|
if(0 > get_urxdo_select_gpio()) {
|
|
printk("get_urxdo_select_gpio failed.\n");
|
|
}
|
|
#endif
|
|
#endif
|
|
return 0;
|
|
}
|
|
/*----------------------------------------------------------------------------*/
|
|
static void __exit up_devices_exit(void)
|
|
{
|
|
platform_driver_unregister(&up_devices_driver);
|
|
}
|
|
/*----------------------------------------------------------------------------*/
|
|
rootfs_initcall(up_devices_init);
|
|
module_exit(up_devices_exit);
|
|
/*----------------------------------------------------------------------------*/
|
|
MODULE_DESCRIPTION("UP DEVICE INFO");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
|