ssd2531 Capacitive Touch Panel driver

最新推荐文章于 2024-10-18 14:19:47 发布
最新推荐文章于 2024-10-18 14:19:47 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： linux 文章标签： report input struct timer android attributes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CAIYUNFREEDOM/article/details/6586448
版权

调试记录：

1.编译uImage进行调试，报告如下错误，reset host i2c,I2C不通。原因是，android是先加载uImage后再初始化I2C的，故出错，I2C不通。

2.原以为在硬件正确的情况下，触屏就会有中断。（ssd2531是低电平中断的）后来，了解后，才知，只有IC初始化正常后，中断才是可用的。

3.对linux的编译系统不了解，犯了好多错误。

编译命令笔记：

root@sunny-desktop:/home/4g/BSP/Kernel/linux-2.6.29-ssl# make ARCH=arm CROSS_COMPILE=arm-eabi- menuconfig


root@sunny-desktop:/home/4g/BSP/Kernel/linux-2.6.29-ssl# make ARCH=arm CROSS_COMPILE=arm-eabi- modules


/usr/system/setup.sh_bk


mount /usr -o remount,rw
rmmod mma7455l
echo 8 > /proc/sys/kernel/printk

insmod tp_dss2521.ko

驱动原代码如下：


//==================================================================//
// Project Name: Touch Panel (AUO TP2) for Linux System
// Engineer: David Dai
// Create Date: 2010/06/02
// Revision:
//			
//==================================================================//

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <asm/gpio.h>
#include <asm/irq.h>
#include <linux/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/hardware.h>
#include <linux/timer.h>

#define   debug_ssd2521 0
//#define SINGLE_TOUCH
#if 0         
#include <linux/init.h>
#include <linux/module.h>
#include <linux/workqueue.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <asm/system.h> /* cli(), *_flags */
#include <asm/uaccess.h> /* copy_from/to_user */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/mutex.h>
#include <asm/io.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/arch/irqs.h>
//#nclude <asm/gpio.h>include <asm/arch/regs-gpio.h>

#include <asm/gpio.h>
#include <asm/irq.h>
#include <linux/irq.h>
#include <asm/ioctl.h>

#endif
#define AUO_INT_LOW         1    
#define  Android_AUO_TSC_INT   GPIO_NUM(3, 17) //PD17
int tp_ssd2521_major = 60;
static long int time=0;
static struct i2c_client *save_client=NULL;
static struct work_struct works,works_timer;
struct gpio_reg{
    uint32_t ctl_reg;
    uint32_t func_reg;
    uint32_t mod_reg;
    uint32_t pull_en_reg;
    uint32_t direc_reg;
    uint32_t OSSR1_reg;
    uint32_t OSSR2_reg;
    uint32_t ISSA1_reg;
    uint32_t ISSA2_reg;
    uint32_t ISSB1_reg;
    uint32_t ISSB2_reg;
    uint32_t data_reg;
    uint32_t int_cfg1_reg;
    uint32_t int_cfg2_reg;
    uint32_t IER_reg;
    uint32_t ISR_reg;
    uint32_t pull_sel_reg;
};
struct MT_Info
{
	u8 press;
	int32_t x;
	int32_t y;	
} mt_buf[4]={{0,0,0},{0,0,0},{0,0,0},{0,0,0}},last_mt_buf[4];
typedef struct
{
	int32_t a;
	int32_t b;
	int32_t c;
	int32_t d;
	int32_t e;
	int32_t f;
	int32_t div;
} ssd2521_cal_t;
static ssd2521_cal_t calibrate ={1,0,0,0,1,0,1};
#define FINGER_ID ABS_CNT
#define FINGER_TYPE ABS_MT_TOOL_TYPE

struct gpio_reg g_irq_reg;
const char *auo_ts_name ="SSL TouchScreen";

static void tp_ssd2521_timer_handle(unsigned long data);
static void i2c_access_work(struct work_struct *work);
static int tp_ssd2521_attach_adapter(struct i2c_adapter *adapter);
static int tp_ssd2521_detach_client(struct i2c_client *client);
/* Structure for Input Type*/
struct auo_tp2_ts{
	struct input_dev * dev;
	long xp1;
	long yp1;
	char phys[32]; //for raw data or others  
};

static struct auo_tp2_ts *ts;
static int ssd2521_suspend(struct i2c_client *client, pm_message_t message);
static int ssd2521_resume(struct i2c_client *client);
static struct i2c_driver tp_driver={
	.driver ={
		.name = "tp_ssd2521",
	},
	.attach_adapter = tp_ssd2521_attach_adapter,
	.detach_client  = tp_ssd2521_detach_client,
#ifdef CONFIG_PM
	.suspend	= ssd2521_suspend,
	.resume		= ssd2521_resume,
#endif
};
void tp_ssd2521_exit(void); 
static unsigned short normal_i2c[] = { 0x5C, I2C_CLIENT_END }; //slave's 7 bit address is 0x5c or 0x48
I2C_CLIENT_INSMOD_1(tp_ssd2521);
struct timer_list *tp_ssd2521_timer;
static int tp_ssd2521_init(void)
{
	int result;		
	tp_ssd2521_timer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
	init_timer(tp_ssd2521_timer);
	#if debug_ssd2521
	printk( "start i2c_add_driver(&tp_driver);\n");
	#endif
	result=i2c_add_driver(&tp_driver);
	#if debug_ssd2521
	printk( "end i2c_add_driver(&tp_driver); \n");
	#endif
	if (result)
        goto fail;
	#if debug_ssd2521
	printk( KERN_ALERT "Inserting tp_ssd2521 module %d\n",result);
	#endif
	return 0;
	
fail: 
	tp_ssd2521_exit(); 
	return result;
}

static ssize_t ssd2521_calibrate_set (struct device *dev,
		struct device_attribute *attr, char *buf);
static DEVICE_ATTR (calibrate, 0666, NULL, ssd2521_calibrate_set);
static struct attribute *ssd2521_attributes[] = {
			&dev_attr_calibrate.attr,
				NULL,
};
static struct attribute_group ssd2521_attr_group = {
		.attrs = ssd2521_attributes,
};
static uint32_t irq;
#define SSD2521_CAL_RESET	"reset"
#define SSD2521_CAL_SHOW	"show"
void ssl_calibrate_for_Android(int32_t *x, int32_t *y);
static ssize_t ssd2521_calibrate_set (struct device *dev,
		struct device_attribute *attr, char *buf)
{
	int32_t a,b,c,d,e,f,div;
	uint32_t x,y;

	if (strncmp(buf,SSD2521_CAL_RESET,sizeof(SSD2521_CAL_RESET)-1)==0)
	{
		calibrate.a=1;
		calibrate.b=0;
		calibrate.c=0;
		calibrate.d=0;
		calibrate.e=1;
		calibrate.f=0;
		calibrate.div=1;
		goto _exit;
	}
	if (strncmp(buf,SSD2521_CAL_SHOW,sizeof(SSD2521_CAL_SHOW)-1)==0)
	{
		x=100;y=200;
		ssl_calibrate_for_Android(&x, &y);
		printk("(100,200) -> (%d, %d)\n", x,y);
		x=900;y=200;
		ssl_calibrate_for_Android(&x, &y);
		printk("(900,200) -> (%d, %d)\n", x,y);
		x=100;y=800;
		ssl_calibrate_for_Android(&x, &y);
		printk("(100,800) -> (%d, %d)\n", x,y);
		x=900;y=800;
		ssl_calibrate_for_Android(&x, &y);
		printk("(900,800) -> (%d, %d)\n", x,y);
		goto _exit;
	}

	sscanf(buf,"%d %d %d %d %d %d %d",&a,&b,&c,&d,&e,&f,&div);
	if (0==div) 
	{
		printk("ssd2531 canot set the div to 0!\n");
		goto _exit;
	}

	calibrate.a=a;
	calibrate.b=b;
	calibrate.c=c;
	calibrate.d=d;
	calibrate.e=e;
	calibrate.f=f;
	calibrate.div=div;	

_exit:	
	printk("ssd2531 calibration data:\n %d %d %d %d %d %d %d\n",calibrate.a, calibrate.b,\
			calibrate.c,calibrate.d, calibrate.e,calibrate.f,calibrate.div);
	return -1;
}

void tp_ssd2521_exit(void) 
{
	sysfs_remove_group(&save_client->dev.kobj, &ssd2521_attr_group);
	disable_irq (irq);
	free_irq(irq,ts->dev) ;
	cancel_work_sync (&works);
	del_timer(tp_ssd2521_timer);
	kfree(tp_ssd2521_timer);
	i2c_del_driver(&tp_driver);
	printk( KERN_ALERT "Removing tp_ssd2521 module\n");
}
void tp_ssd2521_read_reg(u8 addr,u8 len);
u8 tp_ssd2521_write_reg(struct i2c_client *client,const char *buf ,int count);
struct tp_ssd2521_data{
	struct i2c_client client;
};
static irqreturn_t stylus_action(int irqno, void *param)
{
	//time=jiffies_to_msecs(get_jiffies_64());
	//printk("---------------%li\n",time);
	#if debug_ssd2521
		printk("in stylus_action \n");
	#endif
	disable_irq(irq);
	schedule_work(&works);
	printk("in stylus_action \n");
	//enable_irq(irqno);
	return IRQ_HANDLED;
}
static void tp_ssd2521_timer_work(struct work_struct *work);

/* This function is called by i2c_probe */
static int tp_ssd2521_detect(struct i2c_adapter *adapter, int address, int kind)
{
	
	u8 tx_buff[4];
	u8 Panel_D=16;
	u8 Panel_S=10;
	u8 Skw_Rate=0;
	u8 tmp;
	struct input_dev *pInput_dev;

	//================================//
	//    Register as I2C Client      //
	//================================//
	
	struct i2c_client *new_client;
	struct tp_ssd2521_data *data;
	#if debug_ssd2521
	printk("in tp_ssd2521_detect \n");
	#endif
	int err = 0;
	
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA|I2C_FUNC_SMBUS_BYTE))
		goto exit;
	
	if (!(data = kzalloc(sizeof(struct tp_ssd2521_data), GFP_KERNEL))) {
		err = -ENOMEM;
		goto exit;
	}
	new_client = &data->client;
	save_client=new_client;
	//memset(data->data, 0xff, EEPROM_SIZE);
	printk("reach i2c_set_clientdata \n");
	i2c_set_clientdata(new_client, data);
	new_client->addr = address;
	new_client->adapter = adapter;
	new_client->driver = &tp_driver;
	new_client->flags = 0;
	#if debug_ssd2521
	if(new_client->adapter==NULL)
	printk("new_client->adapter==NULL \n");
	if(save_client->adapter==NULL)
	printk("save_client->adapter==NULL \n");
	#endif
	if (err = i2c_attach_client(new_client))
		goto exit_kfree;
	//=====================================//
	//    Touch Panel Setting & Calibrate  //
	//=====================================//	
	printk("reach Touch Panel Setting & Calibrate \n");
	tx_buff[0]=0x23; 
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//exit sleep mode
	msleep(10);
	tx_buff[0]=0x2B;
	tx_buff[1]=0x03;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//turn on clock
	tx_buff[0]=0xD4;
	tx_buff[1]=0x08;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//enable sense filter
	tx_buff[0]=0x65;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//median filter 0 to 2
	tx_buff[0]=0x06;
	tx_buff[1]=0x0e;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//filter type for delta data default=0:1-6-1
	tx_buff[0]=0x07;
	tx_buff[1]=0x06;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//sampling delay
	tx_buff[0]=0x08;
	tx_buff[1]=0x14; //0x07
	tp_ssd2521_write_reg(new_client,tx_buff,2);//POR=04
	tx_buff[0]=0x09;
	tx_buff[1]=0x13;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//Enable self-cap
	tx_buff[0]=0x0a;
	tx_buff[1]=0x12;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//Enable self-cap
	tx_buff[0]=0x0b;
	tx_buff[1]=0x11; //Clk select
	tp_ssd2521_write_reg(new_client,tx_buff,2);//F set osc frequency default =0,range 0 to F
	tx_buff[0]=0x0c;
	tx_buff[1]=0x10;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set drive line
	tx_buff[0]=0x0d;
	tx_buff[1]=0X0F;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set sense line
	tx_buff[0]=0x0E;
	tx_buff[1]=0x0E;//9 //0A
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x0F;
	tx_buff[1]=0x0D;//0B
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x10;
	tx_buff[1]=0x0C;//0C
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x11;
	tx_buff[1]=0x0B;//0D
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x12;
	tx_buff[1]=0x00;//0E
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x13;
	tx_buff[1]=0x01;//0F
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0X14;
	tx_buff[1]=0x02;//10;
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x15;
	tx_buff[1]=0x03;//05;
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x16;
	tx_buff[1]=0x04;
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x17;
	tx_buff[1]=0x05;//03;//10
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x18;
	tx_buff[1]=0x06;//02;//19
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x19;
	tx_buff[1]=0x07;//01;//20
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x1A;
	tx_buff[1]=0x08;//00;//0
    	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x1B;
	tx_buff[1]=0x09;//13;//1
	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0xD8;
	tx_buff[1]=0x03;//14;//2
	tp_ssd2521_write_reg(new_client,tx_buff,2);
	tx_buff[0]=0x2A;
	tx_buff[1]=0x03;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set sub-frame default =3 ,range 0 to F
	tx_buff[0]=0x8D;
	tx_buff[1]=0x01;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//enable manual RAM control mode 
	tx_buff[0]=0x8E;
	tx_buff[1]=0x02;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set RAM bank to scaling RAM
	tx_buff[0]=0x94;
	tx_buff[1]=0x00;
	tx_buff[2]=0x00;
	tp_ssd2521_write_reg(new_client,tx_buff,3);//init scaling RAM
	tx_buff[0]=0x8D;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//disable manual RAM control
	tx_buff[0]=0x25;
	tx_buff[1]=0x02; //0x04 06
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set scan mode
	msleep(100);
	tx_buff[0]=0xc1;
	tx_buff[1]=0x02;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set power down time
	tx_buff[0]=0xd5;
	tx_buff[1]=0x0F;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set No of frames escape without finger touch before enter powersave mode
	msleep(300);
	tx_buff[0]=0xd9;
	tx_buff[1]=0x01;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set charge bump * 6
	tx_buff[0]=0x59;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set driving voltage
	
	tx_buff[0]=0x5b;
	tx_buff[1]=0x02;
    	tp_ssd2521_write_reg(new_client,tx_buff,2);//delta data range original
	tx_buff[0]=0x5a;
	tx_buff[1]=0x00; //0x02
    	tp_ssd2521_write_reg(new_client,tx_buff,2);//set min ,finger area
	tx_buff[0]=0x2c;
	tx_buff[1]=0x02;//4f,3f,45.48 50 <=======
    	tp_ssd2521_write_reg(new_client,tx_buff,2);//set min finger level
	tx_buff[0]=0x3d;
	tx_buff[1]=0x01;
    	tp_ssd2521_write_reg(new_client,tx_buff,2);//finger weight threshold
	tx_buff[0]=0x38;
	tx_buff[1]=0x00;//1e,22
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set max finger area
	tx_buff[0]=0x33;
	tx_buff[1]=0x01;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//set segmentation depth
	tx_buff[0]=0x34;
	tx_buff[1]=0x60; //0x01
	tp_ssd2521_write_reg(new_client,tx_buff,2);// 1:enable curve fitting 0:disable curve fitting
	tx_buff[0]=0x35;
	tx_buff[1]=0x00;
	tx_buff[2]=0x02;
	tp_ssd2521_write_reg(new_client,tx_buff,3);// 1:enable finger 1&2 moving average 0:disable
	tx_buff[0]=0x36;
	tx_buff[1]=0x1e;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//single click timing
	tx_buff[0]=0x37;
	tx_buff[1]=0x03;

	tp_ssd2521_write_reg(new_client,tx_buff,2);//double click timing
	tx_buff[0]=0x39;
	tx_buff[1]=0x00; //0x04
	tp_ssd2521_write_reg(new_client,tx_buff,2);//CG tolerance
	tx_buff[0]=0x56;
	tx_buff[1]=0x01; //0x2F AF
	tp_ssd2521_write_reg(new_client,tx_buff,2);//X tracking
	tx_buff[0]=0x51;
	tx_buff[1]=0x00; //1F
	tx_buff[2]=0x0f;
	tp_ssd2521_write_reg(new_client,tx_buff,3);//Y tracking
	tx_buff[0]=0x52;
	tx_buff[1]=0x02;
	tx_buff[2]=0xff;
	tp_ssd2521_write_reg(new_client,tx_buff,3);//Moving average filter
	tx_buff[0]=0x53;
	tx_buff[1]=0x08;	//0x31;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//X scaling xx.xxxxxx x1
	tx_buff[0]=0x54;
	tx_buff[1]=0x14;	//0x3F;
	tp_ssd2521_write_reg(new_client,tx_buff,2);//Y scaling xx.xxxxxx x1
	tx_buff[0]=0x55;
	tx_buff[0]=0x14;
	tp_ssd2521_write_reg(new_client,tx_buff,2);	//Event Stack Clear
	tx_buff[0]=0x7A;
	tx_buff[1]=0x80; //0xEF
	tx_buff[2]=0x00; //0x1F
	tp_ssd2521_write_reg(new_client,tx_buff,3); //Event Mask
	tx_buff[0]=0x7B;
	tx_buff[1]=0xe0; //0xE0
	tp_ssd2521_write_reg(new_client,tx_buff,2);//IRQ Mask
	tx_buff[0]=0x67;
	tx_buff[1]=0x54;
	tp_ssd2521_write_reg(new_client,tx_buff,1);	//Event Stack Clear
	
	tx_buff[0]=0x66; //
	tx_buff[1]=0x57; //
	tp_ssd2521_write_reg(new_client,tx_buff,2);//Enable moving tolerance
	tx_buff[0]=0xa2; //
	tx_buff[1]=0x00; //
	tp_ssd2521_write_reg(new_client,tx_buff,2);
		
	msleep(600);
	printk("reach msleep(600); \n");
	tp_ssd2521_read_reg(0x02,2);
	tp_ssd2521_read_reg(0x26,1);
	tp_ssd2521_read_reg(0x79,1);
	for(tmp=0;tmp<8;tmp++)
	{
		tp_ssd2521_read_reg(0x79,1);
		tp_ssd2521_read_reg(0x80,4);
	}
	
	//tp_ssd2521_read_reg(0x7C,4);
	//tp_ssd2521_read_reg(0x7D,4);
	//tp_ssd2521_read_reg(0x7E,4);
	//tp_ssd2521_read_reg(0x7F,4);
	//tp_ssd2521_read_reg(0x23,1);
	//================================//
	//    Register as Input Device    //
	//================================//
	
	ts=kzalloc(sizeof(struct auo_tp2_ts), GFP_KERNEL);
	INIT_WORK(&works_timer, tp_ssd2521_timer_work);
	INIT_WORK(&works, i2c_access_work);
	pInput_dev = input_allocate_device();
	if(!ts || !pInput_dev)
	{
		input_free_device(pInput_dev);
		kfree(ts);
		printk("input_allocate_device error in tp_ssd2521_detect\n");
		return -ENOMEM;
	}
	
	ts->dev = pInput_dev;
       //ts->dev->keybit [BIT_WORD (BTN_TOUCH)] = BIT_MASK (BTN_TOUCH);//single touch
	ts->dev->evbit[0] = BIT_MASK (EV_SYN)|BIT_MASK (EV_ABS) ;//mult touch	
#ifdef SINGLE_TOUCH   //single touch
	ts->dev->evbit[0] = BIT_MASK (EV_SYN) | BIT_MASK (EV_KEY) | BIT_MASK (EV_ABS);//single touch
	ts->dev->keybit [BIT_WORD (BTN_TOUCH)] = BIT_MASK (BTN_TOUCH);
	input_set_abs_params(ts->dev, ABS_Y, 0, 480, 0, 0);
	input_set_abs_params(ts->dev, ABS_X, 0, 800, 0, 0);
	input_set_abs_params(ts->dev, ABS_PRESSURE, 0, 1, 0, 0);
#else
   	//multi touch
	input_set_abs_params(ts->dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
	input_set_abs_params(ts->dev, ABS_MT_TOUCH_MAJOR,0, 1, 0, 0);
	input_set_abs_params(ts->dev, ABS_MT_POSITION_Y, 0, 480, 0, 0);
	input_set_abs_params(ts->dev, ABS_MT_POSITION_X, 0, 800, 0, 0);
#endif
	sprintf(ts->phys, "ts0");
	#if debug_ssd2521
	printk("ts->dev->name = auo_ts_name; \n");
	#endif
	ts->dev->name = auo_ts_name;
	ts->dev->phys = ts->phys;
	ts->dev->id.bustype = BUS_I2C;
	ts->dev->id.vendor = 0xABCD;
	ts->dev->id.product = 0xBEEE;
	#define AUO_TS_VERSION	0x0001
	ts->dev->id.version = AUO_TS_VERSION;    
    	//register the GPIO inerrupt
    	gpio_direction_input(Android_AUO_TSC_INT);
    	irq = gpio_to_irq(Android_AUO_TSC_INT);
    	//if (AUO_INT_LOW){
        //	set_irq_type(irq, IRQ_TYPE_EDGE_FALLING);
    	//}
    	//else {
       //		set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
	//}
	set_irq_type(irq, IRQ_TYPE_LEVEL_LOW);
    	#if debug_ssd2521
	printk("start request_irq\n");
	#endif	
    	if (request_irq(irq, stylus_action, IRQF_SHARED, "andriod-ts-i2c", (void *) ts->dev)) {
		input_free_device(ts->dev);
		kfree(ts);
		return -EIO;
	}
	printk("end request_irq\n");
	input_register_device(ts->dev);
	#if debug_ssd2521
	printk("exit tp_ssd2521_detect \n");
	#endif	
	tp_ssd2521_timer->function = &tp_ssd2521_timer_handle;
	tp_ssd2521_timer->expires = jiffies + 100;
	tp_ssd2521_timer->data = 0;
	add_timer(tp_ssd2521_timer);

	err=sysfs_create_group (&save_client->dev.kobj, &ssd2521_attr_group);
	if (err)
	{
		printk("Can't create sysfs attributes!\n ");
		return err;
	}
	return 0;
	/*
	exit_detach:
	i2c_detach_client(new_client);
	*/
	exit_kfree:
		kfree(data);
	exit:
		return err;
	
}
u8   tp_ssd2521_read_single_byte(u8 addr);
void   in_sleep_ssd2521()
{
	u8 tx_buff[2];	
	printk("SSD2521 in sleep\n");
	tx_buff[0]=0x25;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(save_client,tx_buff,2);
	while(tp_ssd2521_read_single_byte(0x26)!=0);
	tx_buff[0]=0x24;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(save_client,tx_buff,2);
}
void   out_sleep_ssd2521()
{
	u8 tx_buff[2];
	tx_buff[0]=0x23;
	tx_buff[1]=0x00;
	tp_ssd2521_write_reg(save_client,tx_buff,2);
	tx_buff[0]=0x25;
	tx_buff[1]=0x06;
	tp_ssd2521_write_reg(save_client,tx_buff,2);
	printk("SSD2521 out sleep\n");
}
static int ssd2521_suspend(struct i2c_client *client, pm_message_t message)
{
	in_sleep_ssd2521();
	return 0;
}
static int ssd2521_resume(struct i2c_client *client)
{
	out_sleep_ssd2521();
	return 0;
}
static void *g_pGPIOReg_I2C_INT_V;
static int tp_ssd2521_attach_adapter(struct i2c_adapter *adapter)
{
	printk("in tp_ssd2521_attach_adapter \n");
	return i2c_probe(adapter, &addr_data, tp_ssd2521_detect);
}
static int tp_ssd2521_detach_client(struct i2c_client *client)
{
	int err;
	err = i2c_detach_client(client);
	if(err)
		return err;
	kfree(i2c_get_clientdata(client));
	disable_irq(&g_irq_reg.IER_reg);
	input_free_device(ts->dev);
	kfree(ts);
	iounmap(g_pGPIOReg_I2C_INT_V);
	printk("in tp_ssd2521_attach_adapter \n");
	return 0;
}
u8 tp_ssd2521_write_reg(struct i2c_client *client,const char *buf ,int count)
{
	int ret;
	struct i2c_adapter *adap=client->adapter;
	struct i2c_msg msg;

	msg.addr = save_client->addr;
	msg.flags = 0;
	msg.len = count;
	msg.buf = (char *)buf;

	ret = i2c_transfer(adap, &msg, 1);
	if (i2c_transfer(save_client->adapter, &msg, 1) < 0)
	{
		printk("write the address (0x%x) of the ssd2521 fail.",buf[0]);
		return false;
	}
}
u8 tp_ssd2521_read_event_state(u8 addr,u8* buf_to_i2c)
{
	u8 msgbuf[1] = { addr };// get Device ID
	struct i2c_msg msgs[] = {
		{
			.addr   = save_client->addr,
			.flags  = 0, //Write
			.len    = 1,
			.buf    = msgbuf,
		},
		{
			.addr   = save_client->addr,
			.flags  = I2C_M_RD,
			.len    = 1,
			.buf    = buf_to_i2c,
		},
	};
	i2c_transfer(save_client->adapter, msgs, 2);
}

u8 tp_ssd2521_read_event_stack(u8 addr,u8* buf_to_i2c)
{
	u8 msgbuf[1] = { addr };// get Device ID
	struct i2c_msg msgs[] = {
		{
			.addr	= save_client->addr,
			.flags	= 0, //Write
			.len	= 1,
			.buf	= msgbuf,
		},
		{
			.addr	= save_client->addr,
			.flags	= I2C_M_RD,
			.len	= 4,
			.buf	= buf_to_i2c,
		},
	};
	i2c_transfer(save_client->adapter, msgs, 2);		
}
u8   tp_ssd2521_read_single_byte(u8 addr)
{
	u8 msgbuf[1] = { addr };// get Device ID
	u8 ret=0;
	struct i2c_msg msgs[] = {
		{
			.addr   = save_client->addr,
			.flags  = 0, //Write
			.len    = 1,
			.buf    = msgbuf,
		},
		{
			.addr   = save_client->addr,
			.flags  = I2C_M_RD,
			.len    = 1,
			.buf    = &ret,
		},
	};
	i2c_transfer(save_client->adapter, msgs, 2);
	return ret;
}
void tp_ssd2521_read_reg(u8 addr,u8 len)
{
	u8 buf_to_i2c[4]={0,0,0,0},tmp;
	u8 msgbuf[1] = { addr };// get Device ID
	struct i2c_msg msgs[] = {
		{
			.addr	= save_client->addr,
			.flags	= 0, //Write
			.len	= 1,
			.buf	= msgbuf,
		},
		{
			.addr	= save_client->addr,
			.flags	= I2C_M_RD,
			.len	= len,
			.buf	= buf_to_i2c,
		},
	};
	if(len>4)
	{
		printk("Erro:the read length is %d ,greater than the maximum length 4\n",len);
		return;
	}
	//printk("in tp_ssd2521_read_reg \n");
	#if debug_ssd2521
	if(save_client==NULL)
	{
		printk("in tp_ssd2521_read_reg save_client=NULL \n");
		return ;
	}
	if(save_client->adapter==NULL)
	{
		printk("in tp_ssd2521_read_reg save_client->adapter=NULL \n");
		return ;
	}
	if(msgs==NULL)
	{
		printk("in tp_ssd2521_read_reg msgs=NULL \n");
		return ;
	}
	#endif
	if (i2c_transfer(save_client->adapter, msgs, 2) < 0)
	{
		printk("read the address (0x%x) of the ssd2521 fail.",addr);
		return;
	}
	else
	{
		;
		 //printk("len =%d \n",len);
		 //printk("read the address (0x%x) of the ssd2521 is 0x",addr);	
		 //for(tmp=0;tmp<len;tmp++)
		 //{
		 //	printk("%x:",buf_to_i2c[tmp]);	
		 //}
		 //printk("\n");
		 //printk("read the address (0x%x) of the ssd2521 is 0x%x%x\n",addr,buf_to_i2c[0],buf_to_i2c[1]);	
	}
	return;
	//printk("exit  tp_ssd2521_read_reg \n");
}
#define SRSC_EVENT 	1	//single finger single click event
#define SFDC_EVENT 	2 	//single finger double click event
#define TFSC_EVENT 	3	//two fingers singer click event
#define TFDC_EVENT 	4	//two fingers double click event
#define FE_EVENT     	5	//finger-enter event per finger base
#define FL_EVENT 	6	//finger-leave event per finger base
#define FM_EVENT 	7	//finger-move event per finger base

static void report_ssd2521_inf(u8 finger,u8 event_no,int32_t x,int32_t y)
{
	//add your code to report the number of finger

	
	switch(event_no)
	{
		case SFDC_EVENT://break;
		case SRSC_EVENT:
			input_report_abs(ts->dev, ABS_X, y);
			input_report_abs(ts->dev, ABS_Y, x);
			input_report_abs(ts->dev, ABS_PRESSURE, 1);
			input_sync(ts->dev);
			input_report_abs(ts->dev, ABS_X, y);
			input_report_abs(ts->dev, ABS_Y, x);
			input_report_abs(ts->dev, ABS_PRESSURE, 0);
			input_sync(ts->dev);
			break;		
		case TFSC_EVENT:break;
		case TFDC_EVENT:break;
		case FE_EVENT://input_report_key (ts->dev, BTN_TOUCH, 1);//break;
		case FM_EVENT:			
			input_report_abs(ts->dev, ABS_MT_POSITION_X, y);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, x);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, finger);
			//input_report_abs(ts->dev, ABS_PRESSURE, 1);
			input_mt_sync(ts->dev);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, y);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, x);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, finger);
			//input_report_abs(ts->dev, ABS_PRESSURE, 1);
			input_mt_sync(ts->dev);
			input_sync(ts->dev);
			break;
		case FL_EVENT:
			//input_report_abs(ts->dev, ABS_X, x);
			//input_report_abs(ts->dev, ABS_Y, y);
			//input_report_abs(ts->dev, ABS_PRESSURE, 0);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			//input_report_key (ts->dev, BTN_TOUCH, 0);
			input_mt_sync(ts->dev);
			input_sync(ts->dev);
			break;
		
	}
}
void ssl_calibrate_for_Android(int32_t *x, int32_t *y)
{
	int32_t tx,ty;
	tx=*x;
	ty=*y;
	*x=(calibrate.a*tx + calibrate.b *ty +calibrate.c) / calibrate.div;
	*y=(calibrate.d*tx + calibrate.e *ty +calibrate.f) / calibrate.div;
	//printk("(%d, %d) -> (%d, %d)\n", tx,ty,*x,*y);

}
u8 last_event_status=0;
static void tp_ssd2521_timer_handle(unsigned long data)
{
	schedule_work(&works_timer);
	//printk("key is pressed too long to run tp_ssd2521_timer_handle\n");
}
static void tp_ssd2521_timer_work(struct work_struct *work)
{
	u8 tx_buff[2]={0xA2,0x00};
	u8 event_status=0,i; 
	tp_ssd2521_read_event_state(0x79,&event_status);	
	//printk("******event_status=%d\n",event_status);
	if((event_status&0x0F)==0x00)
	{
		for(i=0;i<=3;i++)
		{
			input_report_abs(ts->dev, ABS_MT_POSITION_X, mt_buf[i].y);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, mt_buf[i].x);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			input_mt_sync(ts->dev);
		}
		input_sync(ts->dev);
		last_event_status=0;
    		tp_ssd2521_write_reg(save_client,tx_buff,2);//rest init reference procedure
	}
	else
	{
		//printk("-----\n");
		mod_timer(tp_ssd2521_timer,jiffies + 100 );
	}

} 
#define FIFO_NOT_EMPTY 0x10
static void i2c_access_work(struct work_struct *work)
{
	u8 buf[4]={0,0,0,0},i;
	u8 event_status=0;
	static long int time1=0;
	int32_t x=0, y=0;
	printk("+++++++++in  work  +++++++++\n");
	//time=jiffies_to_msecs(get_jiffies_64());
	//printk("++++++++++++++++++%li\n",time);
	//time1=jiffies_to_msecs(get_jiffies_64());
	//printk("*****************%li\n",time1-time);
	//time=time1;
	//printk("***********************in i2c_access_work****************************\n");
	while(1)
	{
		//time1=jiffies_to_msecs(get_jiffies_64());
		//printk("^^^^^^^^^^^^^^^^^^^^^^^%li\n",time1-time);
		//time=time1;
		if(gpio_get_value(Android_AUO_TSC_INT)!=0)
		{
			enable_irq(irq);
			mod_timer(tp_ssd2521_timer,jiffies + 100);
			break;
		}
		tp_ssd2521_read_event_state(0x79,&event_status);	
		//if(event_status!=last_event_status)
		//	printk("event_status = %x\n",event_status);
		
		if(event_status&0x10)
			tp_ssd2521_read_reg(0x80,4);
		if((event_status&0x0F)==0&&((last_event_status&0x0F)==0))
		{
			enable_irq(irq);
			mod_timer(tp_ssd2521_timer,jiffies + 100);
			break;
		}
#ifdef SINGLE_TOUCH
		if(event_status&0x01)
		{
			tp_ssd2521_read_event_stack(0x7C,buf);
			mt_buf[0].x=buf[0]|((buf[2]&0xF0)<<4);
			mt_buf[0].y=buf[1]|((buf[2]&0x0F)<<8);
			if(mt_buf[0].x==0xFFF)
			{
				enable_irq(irq);
				break;
			}
			x=mt_buf[0].y;
			y=mt_buf[0].x;
			input_report_abs(ts->dev, ABS_X, x);
			input_report_abs(ts->dev, ABS_Y, y);
			input_report_abs(ts->dev,ABS_PRESSURE, 1);
			input_report_key (ts->dev, BTN_TOUCH, 1);
		}
		else
		{
			x=mt_buf[0].y;
			y=mt_buf[0].x;
			input_report_abs(ts->dev, ABS_X, x);
			input_report_abs(ts->dev, ABS_Y, y);
			input_report_abs(ts->dev,ABS_PRESSURE, 0);
			input_report_key (ts->dev, BTN_TOUCH, 0);
		}
		input_sync(ts->dev);
		last_event_status=event_status;
		//msleep(10);
		continue;
#endif
		/*for( i=0;i<4;i++)
		{
			if((event_status>>i)&1)
			{
				tp_ssd2521_read_event_stack(0x7C+i,buf);
				mt_buf[0].x=buf[0]|((buf[2]&0xF0)<<4);
				mt_buf[0].y=buf[1]|((buf[2]&0x0F)<<8);
				x=mt_buf[0].y;
				y=mt_buf[0].x;
				input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
				input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
				input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 1);
				input_mt_sync(ts->dev);
			}
		}
		last_event_status=event_status;
		input_sync(ts->dev);
		continue;*********************************/
		if(event_status&0x01)
		{
			tp_ssd2521_read_event_stack(0x7C,buf);
			mt_buf[0].x=buf[0]|((buf[2]&0xF0)<<4);
			mt_buf[0].y=buf[1]|((buf[2]&0x0F)<<8);
			//printk("x=%d,y=%d\n",mt_buf[0].x,mt_buf[0].y);
			if(mt_buf[0].x==0xFFF)
			{
				enable_irq(irq);
				break;
			}
			x=mt_buf[0].y;
			y=mt_buf[0].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 1);
			input_report_abs(ts->dev,ABS_MT_WIDTH_MAJOR,(buf[3]&0xF0)>>4);
			input_mt_sync(ts->dev);
		}
		else
		{
			x=mt_buf[0].y;
			y=mt_buf[0].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);

			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			input_mt_sync(ts->dev);
		}
	//		last_event_status=event_status;
	//		input_sync(ts->dev);
	//	continue;
		if(((event_status&0x0E)==0)&&((last_event_status&0x0E)==0))
		{
			msleep(10);
			last_event_status=event_status;
			input_sync(ts->dev);
			continue;
		}
		if(event_status&0x02)
		{
			tp_ssd2521_read_event_stack(0x7D,buf);
			mt_buf[1].x=buf[0]|((buf[2]&0xF0)<<4);
			mt_buf[1].y=buf[1]|((buf[2]&0x0F)<<8);
			if(mt_buf[1].x==0xFFF)
			{
				input_sync(ts->dev);
				enable_irq(irq);
				break;
			}
			x=mt_buf[1].y;
			y=mt_buf[1].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 1);
			 input_report_abs(ts->dev,ABS_MT_WIDTH_MAJOR,(buf[3]&0xF0)>>4);
			input_mt_sync(ts->dev);
		}
		else
		{
			x=mt_buf[1].y;
			y=mt_buf[1].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			input_mt_sync(ts->dev);
		}
		//imsleep(10);
		if(((event_status&0x0C)==0)&&((last_event_status&0x0C)==0))
		{
			last_event_status=event_status;
			input_sync(ts->dev);
			//msleep(10);
			continue;
		}
		if(event_status&0x04)
		{
			tp_ssd2521_read_event_stack(0x7E,buf);
			mt_buf[2].x=buf[0]|((buf[2]&0xF0)<<4);
			mt_buf[2].y=buf[1]|((buf[2]&0x0F)<<8);
			if(mt_buf[2].x==0xFFF)
			{
				input_sync(ts->dev);
				enable_irq(irq);
				break;
			}
			x=mt_buf[2].y;
			y=mt_buf[2].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 1);
			input_report_abs(ts->dev,ABS_MT_WIDTH_MAJOR,(buf[3]&0xF0)>>4);
			input_mt_sync(ts->dev);
		}
		else
		{
			x=mt_buf[2].y;
			y=mt_buf[2].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			input_mt_sync(ts->dev);
		}
		//msleep(10);
		if(((event_status&0x08)==0)&&((last_event_status&0x08)==0))
		{
			last_event_status=event_status;
			input_sync(ts->dev);
			//msleep(10);
			continue;
		}
		if(event_status&0x08)
		{
			tp_ssd2521_read_event_stack(0x7F,buf);
			mt_buf[3].x=buf[0]|((buf[2]&0xF0)<<4);
			mt_buf[3].y=buf[1]|((buf[2]&0x0F)<<8);
			if(mt_buf[3].x==0xFFF)
			{
				input_sync(ts->dev);
				enable_irq(irq);
				break;
			}
			x=mt_buf[3].y;
			y=mt_buf[3].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 1);
			input_report_abs(ts->dev,ABS_MT_WIDTH_MAJOR,(buf[3]&0xF0)>>4);
			input_mt_sync(ts->dev);
		}
		else
		{
			x=mt_buf[3].y;
			y=mt_buf[3].x;
			ssl_calibrate_for_Android(&x,&y);
			input_report_abs(ts->dev, ABS_MT_POSITION_X, x);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, y);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, 0);
			input_mt_sync(ts->dev);
		}
		last_event_status=event_status;
		input_sync(ts->dev);
		//msleep(10);
		/*for(i=0;(i<4);i++)
		{
			tp_ssd2521_read_event_stack(0x7C+i,buf);
			x=buf[0]|((buf[2]&0xF0)<<4);
			y=buf[1]|((buf[2]&0x0F)<<8);
			if( ((y+x)>688)&&(event_status>>i&0x01))
			{
				;
			}
			else
			{

				if(event_status>>i&0x01)
				{
					mt_buf[i].y=buf[1]|((buf[2]&0x0F)<<8);
					mt_buf[i].x=buf[0]|((buf[2]&0xF0)<<4);
				}
			}
			input_report_abs(ts->dev, ABS_MT_POSITION_X, mt_buf[i].y);
			input_report_abs(ts->dev, ABS_MT_POSITION_Y, mt_buf[i].x);
			input_report_abs(ts->dev,ABS_MT_TOUCH_MAJOR, mt_buf[i].press=event_status>>i&0x01);
			//input_report_abs(ts->dev,ABS_MT_WIDTH_MAJOR,(buf[3]&0xF0)>>4);
			input_mt_sync(ts->dev);
			printk("finger=%d   pressed=%d  x=%d  y=%d\n",i, event_status>>i&0x01,mt_buf[i].x,mt_buf[i].y);
			if((event_status&0x0F)>>(i+1)==0&&mt_buf[i+1].press==0)break;
			msleep(10);
		}	*/		
		//if((event_status&FIFO_NOT_EMPTY)==0)
			//break;
	}
	/*if((event_no==FL_EVENT)&&(finger==0))
	{
		disable_irq (irq);
		msleep(60);		
		enable_irq(irq);
		tx_buff[0]=0x81;
		tp_ssd2521_write_reg(save_client,tx_buff,1);	//Event Stack Clear		
	}*********************************/	
}
/* Declaration of the init and exit functions */
module_init(tp_ssd2521_init);
module_exit(tp_ssd2521_exit);

MODULE_AUTHOR("TP ssd2521 Test");
MODULE_DESCRIPTION("TP ssd2521 Test");
MODULE_LICENSE("Dual BSD/GPL");



彩云的笔记
关注
专栏目录
【USB】全球USB厂家 USB ID大全。更新时间：2014.05.05
shen_wei的专栏
06-04 6万+
 # # List of USB ID's # # Maintained by Stephen J. Gowdy # If you have any new entries, please submit them via # http://www.linux-usb.org/usb-ids.html # or send entries as patches (diff -u old ne
capacitive touch
07-01
capacitive touch conector
ssd2531总结
power的专栏
07-12 1895
关于ssd2531，支持最多4点，电容触摸屏。问题：发现Y轴有一点问题，多点提交时，出现漂移现象。解决问题过程：ssd2531是solomen的IC，找solomen的工程师，驱动工程师，及现场应用工程师都说没问题。驱动工程师说是IC初始化的问题。现场应用工程师说，IC的初始化代
SSD202 Linux开发日志记录
开发学习过程中一点经验积累
05-25 7497
一些SSD202开发过程记录 不定期更新
TouchPanel在MSM7X27上的移植
Bloom and Grow
07-26 1975
p { margin-bottom: 0.21cm; }       调试TouchPanel也有一段时间了，今天总结一下，平台是MSM7x27，android2.2，TP主要就是I2C了，这里不介绍I2C,不清楚的自己search，主要介绍TP在这个平台上的移植内容。一.设备和
【USB】全球USB厂家 USB ID大全。更新时间：2017-07-29
热门推荐
shen_wei的专栏
08-15 8万+
# # List of USB ID's # # Maintained by Stephen J. Gowdy # If you have any new entries, please submit them via # http://www.linux-usb.org/usb-ids.html # or send entries as patches (diff -u old new) i
USB VID&PID 表
xqhrs232的专栏
03-12 5万+
原文地址::http://blog.csdn.net/bai_hei1025/article/details/23879165 相关文章 1、USB设备的VID与PID----http://blog.csdn.net/tankai19880619/article/details/8642066
Asus ZenBook NX500 review
laptopakku
01-26 1236
Feast your eyes on Asus' newest premium 15-inch notebook. The $2,699 Asus ZenBook NX500 will make your jaw drop with its gorgeous 4K, Ultra HD touch screen and sleek design. It's not all eye candy, ei
关于fex的说明
explore_world的博客
11-21 4860
Fex Guide Jump to: navigation, search Contents 1 FEX Description2 Port Definitions3 application 3.1 [product] 4 system configuration 4.1 [ta
USB设备生产厂家代码和设备代码查询
smstong的成长轨迹
04-21 7万+
http://www.linux-usb.org/usb.ids # # List of USB ID's # # Maintained by Stephen J. Gowdy # If you have any new entries, please submit them via # http://www.linux-usb.org/usb-ids.html # or send en
MSP430-Capacitive-Touch-BoosterPack.zip_Capacitive touch _MSP430
09-21
【标题】"MSP430-Capacitive-Touch-BoosterPack.zip" 是一个针对MSP430系列微控制器的扩展包，专注于电容式触摸功能的应用开发。这个压缩包为用户提供了深入理解如何使用MSP430进行电容式触摸感应设计的资源。 ...
touchpanel测试程序
05-02
这个程序通过直接操作帧缓冲区（Framebuffer，FB0）来实现对触控屏（CTP， Capacitive Touch Panel）的检测。 帧缓冲区是操作系统用于存储屏幕图像数据的内存区域，可以直接映射到显示设备上。在本测试程序中，FB0...
Capacitive-Touch-Sensor-Module
03-07
电容式触摸传感器模块 访问JLCPCB（ ） 该文章正在与JLCPCB合作发表。 它是最有经验的PCB制造商之一，在PCB原型和制造领域拥有十多年的经验，他们致力于满足我们来自不同行业的客户在质量，交付，成本效益和任何...
Android -- [SelfView] 炫酷文字圆盘时钟
最新发布
8023的博客
10-18 245
【代码】Android -- [SelfView] 炫酷文字圆盘时钟。
Android[BLE] BluetoothDeivce.connectGatt函数中的autoConnect可能出现的问题
weixin_38622593的博客
10-15 314
autoConnect可能出现的问题
Android：记录一个打包发布版的release包以后闪退的问题
Spy003的博客
10-13 522
个人感觉其实release闪退的问题挺难排查的，因为release包运行起来as捕获不到相应的应用程序进程，从而不易查看到日志，也是我玩得不溜，大家有不同的方法可以评论区探讨，我也定期回复一些评论一起讨论。
SQLite数据库在Android中的应用及操作方式
Good_tea_h的博客
10-14 765
SQLite数据库在Android中的应用非常广泛，它作为一个轻量级的关系型数据库，以其高效、可靠和易于使用的特点，成为了Android平台上存储和管理数据的首选方案。以下是对SQLite数据库在Android中的应用及操作方式的详细介绍。
android:launchMode=“singleInstancePerTask“
Steve_XiaoHai的博客
10-15 373
提供了一种灵活的机制，允许多个任务分别拥有一个独立的 Activity 实例。与相比，它允许在不同的任务中创建多个实例，而不是全系统只允许一个实例。
capacitive touch sense型号对比
01-04
capacitive touch sense型号对比可以从以下几个方面进行比较： 1. 技术特点：不同型号的capacitive touch sense可能采用不同的技术特点，如电容屏幕的灵敏度、响应速度、噪音抑制能力等方面可能有所不同。 2. 型号...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值