static int yas_device_read(int32_t type, uint8_t addr, uint8_t *buf, int len)
{

	struct mt_i2c_msg msg[2];
	int err = 0;
	struct yas_state *st= i2c_get_clientdata(this_client);

	//memset(msg, 0, sizeof(msg));
	msg[0].addr = this_client->addr;
	msg[0].flags = 0;
	msg[0].len = 1;
	msg[0].buf = &addr;
	msg[0].timing = this_client->timing;	//add for mtk i2c
	msg[0].ext_flag = this_client->ext_flag & I2C_MASK_FLAG;//add for mtk i2c
	msg[1].addr = this_client->addr;
	msg[1].flags = I2C_M_RD;
	msg[1].len = len;
	msg[1].buf = buf;
	msg[1].timing = this_client->timing;	//add for mtk i2c
	msg[1].ext_flag = this_client->ext_flag & I2C_MASK_FLAG;//add for mtk i2c

	if((len > 8 ) && (st->dma_va != NULL))
	{
		msg[1].ext_flag = this_client->ext_flag | I2C_DMA_FLAG;//add for mtk i2c
	}
	mutex_lock(&yas537_i2c_mutex);
//#if 0
	if(len <= 8)
	{
		err = i2c_transfer(this_client->adapter, (struct i2c_msg *)msg, 2);
		if (err != 2) {
			dev_err(&this_client->dev,
					"i2c_transfer() read error: "
					"adapter num = %d,slave_addr=%02x, reg_addr=%02x, err=%d\n",
					this_client->adapter->nr, this_client->addr, addr, err);
			mutex_unlock(&yas537_i2c_mutex);
			return err;
		}
	}

//#else
	else
	{
	#if 0
		if(unlikely(NULL == st->dma_va))
		{
			this_client->ext_flag &= I2C_MASK_FLAG; //CLEAR DMA FLAG	
			memset(buf, 0,len);
			buf = &addr;
			err = i2c_master_send(this_client, buf,1);
			if(err < 0)
			{
				MSE_ERR("%s  i2c_master_send failed err = %d\n", __FUNCTION__, err);
				mutex_unlock(&yas537_i2c_mutex);
				return err;
			}
			
			for(i=0; i<=len; i=i+8)
			{
				trans_len = ((i+8)<=len) ? 8 : (len-i);
				MSE_LOG("%s   trans_len = %d\n", __FUNCTION__,trans_len);

				err = i2c_master_recv(this_client, &buf[i], trans_len);

				if(err < 0)
				{
					MSE_ERR("%s  i2c_master_recv failed err = %d\n", __FUNCTION__, err);
					mutex_unlock(&yas537_i2c_mutex);
					return err;
				}
			}
		}
		else
	#endif
		{
			memset(st->dma_va, 0, 1024);
			msg[1].buf = (char *)(st->dma_pa);
			err = i2c_transfer(this_client->adapter, (struct i2c_msg *)msg, 2);
			if (err != 2) {
				dev_err(&this_client->dev,
						"i2c_transfer() read error: "
						"adapter num = %d,slave_addr=%02x, reg_addr=%02x, err=%d\n",
						this_client->adapter->nr, this_client->addr, addr, err);

				mutex_unlock(&yas537_i2c_mutex);
				return err;
			}
			memcpy(buf, st->dma_va, len);
		}
	}
//#endif
//	MSE_LOG("%s   successful\n", __FUNCTION__);

	mutex_unlock(&yas537_i2c_mutex);
	return 0;
}
Exemplo n.º 2
0
static int max517_resume(struct device *dev)
{
	u8 outbuf = 0;

	return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
}
Exemplo n.º 3
0
static void s5c73m3_fill_mbus_fmt(struct v4l2_mbus_framefmt *mf,
				  const struct s5c73m3_frame_size *fs,
				  u32 code)
{
	mf->width = fs->width;
	mf->height = fs->height;
	mf->code = code;
	mf->colorspace = V4L2_COLORSPACE_JPEG;
	mf->field = V4L2_FIELD_NONE;
}

static int s5c73m3_i2c_write(struct i2c_client *client, u16 addr, u16 data)
{
	u8 buf[4] = { addr >> 8, addr & 0xff, data >> 8, data & 0xff };

	int ret = i2c_master_send(client, buf, sizeof(buf));

	v4l_dbg(4, s5c73m3_dbg, client, "%s: addr 0x%04x, data 0x%04x\n",
		 __func__, addr, data);

	if (ret == 4)
		return 0;

	return ret < 0 ? ret : -EREMOTEIO;
}

static int s5c73m3_i2c_read(struct i2c_client *client, u16 addr, u16 *data)
{
	int ret;
	u8 rbuf[2], wbuf[2] = { addr >> 8, addr & 0xff };
	struct i2c_msg msg[2] = {
Exemplo n.º 4
0
static int touch_event_handler(void *unused) {
    struct sched_param param = { .sched_priority = RTPM_PRIO_TPD }; 
    int i = 0,x1=0, y1=0, finger_num = 0;
    char buffer[32];//[16];
	u32 temp;
    
    sched_setscheduler(current, SCHED_RR, &param); 
    g_temptimerdiff=get_jiffies_64();//jiffies;
    do {
		if(tpd_debuglog==1) {
			TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__); 
		}	    	
        set_current_state(TASK_INTERRUPTIBLE);
	if(tpd_debuglog==1)
		TPD_DMESG("[mtk-tpd], %s, tpd_halt=%d\n", __FUNCTION__, tpd_halt);
        while (tpd_halt) {tpd_flag = 0; msleep(20);}
        wait_event_interruptible(waiter, tpd_flag != 0);
        //tpd_flag = 0;
        TPD_DEBUG_SET_TIME;
        set_current_state(TASK_RUNNING); 
        i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 8, &(buffer[0]));
        i2c_smbus_read_i2c_block_data(i2c_client, 0x08, 8, &(buffer[8]));
        i2c_smbus_read_i2c_block_data(i2c_client, 0x10, 8, &(buffer[16]));
        i2c_smbus_read_i2c_block_data(i2c_client, 0x18, 8, &(buffer[24]));		
        if((buffer[1]&0x01) != (buffer[30]&0x01))
        {        
            i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 8, &(buffer[0]));
            i2c_smbus_read_i2c_block_data(i2c_client, 0x08, 8, &(buffer[8]));
            i2c_smbus_read_i2c_block_data(i2c_client, 0x10, 8, &(buffer[16]));
            i2c_smbus_read_i2c_block_data(i2c_client, 0x18, 8, &(buffer[24]));		
        }
        if((buffer[1]&0xf0) != 0x10)
        {
            buffer[0] =  0x00;
            buffer[1] =  0x03;
            i2c_master_send(i2c_client,buffer,2);
            msleep(50);
            buffer[0] =  0x00;
            buffer[1] =  0x05;
            i2c_master_send(i2c_client,buffer,2);
            //status = i2c_master_recv(i2c_client, buffer, 3);
            msleep(50);
            buffer[0] =  0x00;
            buffer[1] =  0x21;
            buffer[2] =  0x07;
            buffer[3] =  0x01;
            buffer[4] =  0x00;
            i2c_master_send(i2c_client,buffer,5);
            msleep(50);
            continue; 
        }
	if(tpd_debuglog==1)
	{
        TPD_DMESG("[mtk-tpd]HST_MODE  : %x\n", buffer[0]); 
        TPD_DMESG("[mtk-tpd]TT_MODE   : %x\n", buffer[1]); 
        TPD_DMESG("[mtk-tpd]TT_STAT   : %x\n", buffer[2]);
       // TPD_DEBUG("[mtk-tpd]TOUCH_ID  : %x\n", buffer[8]);
		TPD_DMESG("[mtk-tpd]TOUCH_12ID  : %x\n", buffer[8]);
		TPD_DMESG("[mtk-tpd]TOUCH_34ID  : %x\n", buffer[21]);
	}	
                finger_num = 0;
        for(i = 0; i < 7;i++)
        { 
            x1 = buffer[4*i + 2] | ((buffer[4*i+4]&0x0f) << 8) ;
            y1 = buffer[4*i + 3] | ((buffer[4*i+4]&0xf0) << 4) ;
            if(x1 != 0xfff){
                tpd_down(x1, y1, x1, y1, 100);
                finger_num++;
                //printk("-----x:%d,y:%d-------down\n",x1,y1);            
            }
        }
           //printk("-----finger_num = %d-------\n",finger_num);            
        if(finger_num > 0)
            input_sync(tpd->dev);
        else
        {
           //printk("-----x:%d,y:%d-------up\n",x1,y1);            
            tpd_up(x1, y1, x1, y1, 0);
            //input_mt_sync(tpd->dev);
            input_sync(tpd->dev);
        }
       tpd_flag = 0;
   
    } while (!kthread_should_stop()); 
    return 0;
}
Exemplo n.º 5
0
/*
 * Probes Micron sensors with 8 bit address and 16 bit register width
 */
static int em28xx_probe_sensor_micron(struct em28xx *dev)
{
	int ret, i;
	char *name;
	u8 reg;
	__be16 id_be;
	u16 id;

	struct i2c_client client = dev->i2c_client[dev->def_i2c_bus];

	dev->em28xx_sensor = EM28XX_NOSENSOR;
	for (i = 0; micron_sensor_addrs[i] != I2C_CLIENT_END; i++) {
		client.addr = micron_sensor_addrs[i];
		/* NOTE: i2c_smbus_read_word_data() doesn't work with BE data */
		/* Read chip ID from register 0x00 */
		reg = 0x00;
		ret = i2c_master_send(&client, &reg, 1);
		if (ret < 0) {
			if (ret != -ENXIO)
				em28xx_errdev("couldn't read from i2c device 0x%02x: error %i\n",
					      client.addr << 1, ret);
			continue;
		}
		ret = i2c_master_recv(&client, (u8 *)&id_be, 2);
		if (ret < 0) {
			em28xx_errdev("couldn't read from i2c device 0x%02x: error %i\n",
				      client.addr << 1, ret);
			continue;
		}
		id = be16_to_cpu(id_be);
		/* Read chip ID from register 0xff */
		reg = 0xff;
		ret = i2c_master_send(&client, &reg, 1);
		if (ret < 0) {
			em28xx_errdev("couldn't read from i2c device 0x%02x: error %i\n",
				      client.addr << 1, ret);
			continue;
		}
		ret = i2c_master_recv(&client, (u8 *)&id_be, 2);
		if (ret < 0) {
			em28xx_errdev("couldn't read from i2c device 0x%02x: error %i\n",
				      client.addr << 1, ret);
			continue;
		}
		/* Validate chip ID to be sure we have a Micron device */
		if (id != be16_to_cpu(id_be))
			continue;
		/* Check chip ID */
		id = be16_to_cpu(id_be);
		switch (id) {
		case 0x1222:
			name = "MT9V012"; /* MI370 */ /* 640x480 */
			break;
		case 0x1229:
			name = "MT9V112"; /* 640x480 */
			break;
		case 0x1433:
			name = "MT9M011"; /* 1280x1024 */
			break;
		case 0x143a:    /* found in the ECS G200 */
			name = "MT9M111"; /* MI1310 */ /* 1280x1024 */
			dev->em28xx_sensor = EM28XX_MT9M111;
			break;
		case 0x148c:
			name = "MT9M112"; /* MI1320 */ /* 1280x1024 */
			break;
		case 0x1511:
			name = "MT9D011"; /* MI2010 */ /* 1600x1200 */
			break;
		case 0x8232:
		case 0x8243:	/* rev B */
			name = "MT9V011"; /* MI360 */ /* 640x480 */
			dev->em28xx_sensor = EM28XX_MT9V011;
			break;
		case 0x8431:
			name = "MT9M001"; /* 1280x1024 */
			dev->em28xx_sensor = EM28XX_MT9M001;
			break;
		default:
			em28xx_info("unknown Micron sensor detected: 0x%04x\n",
				    id);
			return 0;
		}

		if (dev->em28xx_sensor == EM28XX_NOSENSOR)
			em28xx_info("unsupported sensor detected: %s\n", name);
		else
			em28xx_info("sensor %s detected\n", name);

		dev->i2c_client[dev->def_i2c_bus].addr = client.addr;
		return 0;
	}

	return -ENODEV;
}
Exemplo n.º 6
0
/*
 *--------------------------------------------------------------------------
 * Function : config_multibyte_for_mode
 * Purpose :  Function which is invoked when user changes the configuration
 *            at run-time. Internally configures/switches both
 *            miniDSP_D and miniDSP_A Coefficient arrays.
 *---------------------------------------------------------------------------
 */
static int multibyte_coeff_change(struct snd_soc_codec *codec, int bk)
{

	u8 value, swap_reg_pre, swap_reg_post;
	struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);

	DBG(KERN_INFO "%s : entered\n",__func__);
	#if 0
	mutex_lock(&codec_io_mutex);
	aic3262_change_book(codec, bk);
	aic3262_change_page(codec, 0);
	mutex_unlock(&codec_io_mutex);
	if(aic3262->bus_type == SND_SOC_SPI) {
		/* Read the Value of the Book bk Page 0 Register 1 which controls the
		   Adaptive Switching Mode */
		mutex_lock(&codec_io_mutex);
		value[0] = codec->hw_read(codec,1);
		mutex_unlock(&codec_io_mutex);
		if( value[0] < 0) {
			printk(KERN_ERR "Cannot read the codec register\n");
			goto err;
		} else {
			swap_reg_pre = value[0];

			/* Write the Register bit updates */
			value[1] = value[0] | 1;
			value[0] = 1;
			mutex_lock(&codec_io_mutex);
			codec->hw_write(codec->control_data,value,2);
			mutex_unlock(&codec_io_mutex);
			/*before verifying for buffer_swap, make sure we give one 
				frame delay, because the buffer swap happens at the end of the frame */
			mdelay(5);
			/* verify buffer swap */
			mutex_lock(&codec_io_mutex);
			swap_reg_post = codec->hw_read(codec,1);
			mutex_unlock(&codec_io_mutex);

			if(swap_reg_post < 0) {
				printk(KERN_ERR "cannot read the codec register\n");
				goto err;
			}
			if ((swap_reg_pre == 4 && swap_reg_post == 6)
				|| (swap_reg_pre == 6 && swap_reg_post == 4))
				printk(KERN_INFO "Buffer swap success\n");
			else
				printk(KERN_ERR
				"Buffer swap...FAILED\nswap_reg_pre=%x, swap_reg_post=%x\n",
				swap_reg_pre, swap_reg_post);
			mutex_lock(&codec_io_mutex);
			aic3262_change_book(codec, 0x00);
			mutex_unlock(&codec_io_mutex);
		}
	} else {
		value[0] = 1;
		mutex_lock(&codec_io_mutex);
		if (i2c_master_send(codec->control_data, value, 1) != 1) {
			mutex_unlock(&codec_io_mutex);
			printk(KERN_ERR "Can not write register address\n");
		} else {
			/* Read the Value of the Page 8 Register 1 which controls the
			   Adaptive Switching Mode */
			if (i2c_master_recv(codec->control_data, value, 1) != 1) {
				printk(KERN_ERR "Can not read codec registers\n");
				mutex_unlock(&codec_io_mutex);
				goto err;
			}
			mutex_unlock(&codec_io_mutex);
			swap_reg_pre = value[0];

			/* Write the Register bit updates */
			value[1] = value[0] | 1;
			value[0] = 1;
			mutex_lock(&codec_io_mutex);
			if (i2c_master_send(codec->control_data, value, 2) != 2) {
				printk(KERN_ERR "Can not write register address\n");
				mutex_unlock(&codec_io_mutex);
				goto err;
			}
			mutex_unlock(&codec_io_mutex);
			/*before verifying for buffer_swap, make sure we give one
			frame delay, because the buffer swap happens at the end of the frame */
			mdelay(5);
			value[0] = 1;
			/* verify buffer swap */
			mutex_lock(&codec_io_mutex);
			if (i2c_master_send(codec->control_data, value, 1) != 1) {
				printk(KERN_ERR "Can not write register address\n");
			}
			mutex_unlock(&codec_io_mutex);
			/* Read the Value of the Page 8 Register 1 which controls the
			   Adaptive Switching Mode */
			mutex_lock(&codec_io_mutex);
			if (i2c_master_recv(codec->control_data, &swap_reg_post, 1) != 1) {
				printk(KERN_ERR "Can not read codec registers\n");
			}
			mutex_unlock(&codec_io_mutex);
			if ((swap_reg_pre == 4 && swap_reg_post == 6)
				|| (swap_reg_pre == 6 && swap_reg_post == 4))
				printk(KERN_INFO "Buffer swap success\n");
			else
				printk(KERN_ERR
				"Buffer swap...FAILED\nswap_reg_pre=%x, swap_reg_post=%x\n",
				swap_reg_pre, swap_reg_post);
			mutex_lock(&codec_io_mutex);
			aic3262_change_book(codec, 0x00);
			mutex_unlock(&codec_io_mutex);
			
		}
	}
#endif
	u8 reg =0x01;

	value=dsp_reg_read(codec,bk,reg);
	swap_reg_pre =value;

	value= value |1;
	dsp_reg_write(codec,bk,reg,value);
	mdelay(50);
	
	swap_reg_post=dsp_reg_read(codec,bk,reg);
	
	if((swap_reg_pre == 4 && swap_reg_post == 6)
		||(swap_reg_pre == 6 && swap_reg_post == 4)) {
		printk( "Buffer swap success\n");
	}
	else{
		printk(KERN_ERR
				"Buffer swap...FAILED\nswap_reg_pre=%x, swap_reg_post=%x\n",
				swap_reg_pre, swap_reg_post);
		}
err:
	return 0;
}
Exemplo n.º 7
0
//static DEFINE_MUTEX(fan5405_i2c_access_mutex_0);
ssize_t fan5405_read_byte(u8 reg, u8 *returnData)	/*read reg data and save to returndata*/
{
    char     cmd_buf[2]={0x00, 0x00};
    char     readData = 0;
    int     ret=0;
    
    struct i2c_msg	fan_msg[2];

    struct i2c_client *client	= new_client;
    struct i2c_adapter	*adap	= client->adapter;
	

//printk(KERN_INFO "jrd %s: client->addr:0x%x! flags:%d,reg:%d!\n",__func__, new_client->addr, client->flags, reg);
//	mutex_lock(&fan5405_i2c_access_mutex_0);
	
	client->addr = ((client->addr) & I2C_MASK_FLAG) | I2C_WR_FLAG;	
	client->flags = 0x00;

	cmd_buf[0] = reg;	/*reg num*/
	
	fan_msg[0].addr = client->addr;
	fan_msg[0].flags = client->flags & I2C_M_TEN;	/*flag for 10-bit address or 7-bit address*/
	fan_msg[0].len = 1;
	fan_msg[0].buf = &cmd_buf[0];
	fan_msg[0].timing = client->timing;
	fan_msg[0].ext_flag = client->ext_flag;

        fan_msg[1].addr = client->addr;
        fan_msg[1].flags = client->flags | I2C_M_RD;
        fan_msg[1].len = 1;
        fan_msg[1].buf = &cmd_buf[1];
	fan_msg[1].timing = client->timing;
	fan_msg[1].ext_flag = client->ext_flag;
	
	if(Enable_BATDRV_LOG >= 1)
	{
	printk(KERN_INFO "jrd %s: fan_msg0.addr:0x%x, flags:0x%x,len:0x%x, buf:0x%x, timing:0x%x, ext_flag:0x%x!\n\r",
				__func__, fan_msg[0].addr, fan_msg[0].flags, fan_msg[0].len, cmd_buf[0], fan_msg[0].timing, fan_msg[0].ext_flag);
	printk(KERN_INFO "jrd %s: fan_msg1.addr:0x%x, flags:0x%x,len:0x%x, buf:0x%x, timing:0x%x, ext_flag:0x%x!\n\r",
                                __func__, fan_msg[1].addr, fan_msg[1].flags, fan_msg[1].len, cmd_buf[1], fan_msg[1].timing, fan_msg[1].ext_flag);
	}	
//	i2c_transfer(adap, fan_msg, FAN5405_READ_TRANS);	/*i2c-gpio*/	
	ret = i2c_master_send(client, cmd_buf, (1 << 8 | 1));
	if(ret < 0)
		{
		printk(KERN_INFO "%s: send cmd fail!\n\r",__func__);
		}
//	ret = i2c_master_recv(client, &cmd_buf[1], 1);

    if (ret < 0) 
	{
        printk(KERN_INFO "Power/fan5405[mt6329_read_byte:write&read] fan5405 sends command error!! \n");
		new_client->addr = new_client->addr & I2C_MASK_FLAG;
//		mutex_unlock(&fan5405_i2c_access_mutex_0);
        return 0;
    }
	readData = cmd_buf[0];
    *returnData = readData;
//	printk(KERN_INFO "jrd %s: readData:0x%x",__func__, readData);

	new_client->addr = new_client->addr & I2C_MASK_FLAG;
    
//	mutex_unlock(&fan5405_i2c_access_mutex_0);
    return 1;

}
Exemplo n.º 8
0
static int wm2000_power_up(struct i2c_client *i2c, int analogue)
{
	struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
	int ret, timeout;

	BUG_ON(wm2000->anc_mode != ANC_OFF);

	dev_dbg(&i2c->dev, "Beginning power up\n");

	if (!wm2000->mclk_div) {
		dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
		wm2000_write(i2c, WM2000_REG_SYS_CTL2,
			     WM2000_MCLK_DIV2_ENA_CLR);
	} else {
		dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
		wm2000_write(i2c, WM2000_REG_SYS_CTL2,
			     WM2000_MCLK_DIV2_ENA_SET);
	}

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);

	/*                                     */
	if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
			     WM2000_ANC_ENG_IDLE, 1)) {
		dev_err(&i2c->dev, "ANC engine failed to reset\n");
		return -ETIMEDOUT;
	}

	if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
			     WM2000_STATUS_BOOT_COMPLETE, 1)) {
		dev_err(&i2c->dev, "ANC engine failed to initialise\n");
		return -ETIMEDOUT;
	}

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);

	/*                                                         
                 */
	dev_dbg(&i2c->dev, "Downloading %d bytes\n",
		wm2000->anc_download_size - 2);

	ret = i2c_master_send(i2c, wm2000->anc_download,
			      wm2000->anc_download_size);
	if (ret < 0) {
		dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
		return ret;
	}
	if (ret != wm2000->anc_download_size) {
		dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
			ret, wm2000->anc_download_size);
		return -EIO;
	}

	dev_dbg(&i2c->dev, "Download complete\n");

	if (analogue) {
		timeout = 248;
		wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, timeout / 4);

		wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
			     WM2000_MODE_ANA_SEQ_INCLUDE |
			     WM2000_MODE_MOUSE_ENABLE |
			     WM2000_MODE_THERMAL_ENABLE);
	} else {
		timeout = 10;

		wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
			     WM2000_MODE_MOUSE_ENABLE |
			     WM2000_MODE_THERMAL_ENABLE);
	}

	ret = wm2000_read(i2c, WM2000_REG_SPEECH_CLARITY);
	if (wm2000->speech_clarity)
		ret &= ~WM2000_SPEECH_CLARITY;
	else
		ret |= WM2000_SPEECH_CLARITY;
	wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, ret);

	wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
	wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);

	if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
			     WM2000_STATUS_MOUSE_ACTIVE, timeout)) {
		dev_err(&i2c->dev, "Timed out waiting for device after %dms\n",
			timeout * 10);
		return -ETIMEDOUT;
	}

	dev_dbg(&i2c->dev, "ANC active\n");
	if (analogue)
		dev_dbg(&i2c->dev, "Analogue active\n");
	wm2000->anc_mode = ANC_ACTIVE;

	return 0;
}
Exemplo n.º 9
0
/*
[function]: 
    write data to ctpm , the destination address is 0.
[parameters]:
    pbt_buf[in]    :point to data buffer;
    bt_len[in]        :the data numbers;    
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
FTS_BOOL byte_write(struct i2c_client *client,FTS_BYTE* pbt_buf, FTS_DWRD dw_len)
{
    
    return i2c_master_send(client, pbt_buf, dw_len);
}
Exemplo n.º 10
0
int loadBitFile(struct i2c_client * io_cli, const unsigned char * bitBuffer_user, const unsigned int length){
	unsigned char cfg = 1 ;	
	unsigned long int i ;
	unsigned long int timer = 0;
	unsigned char * bitBuffer ;	
	unsigned char i2c_buffer [4] ;
	//request_mem_region(GPIO3_BASE + 0x190, 8, gDrvrName);
	gpio_regs = ioremap_nocache(GPIO3_BASE + 0x190, 2*sizeof(int));

	bitBuffer = kmalloc(length, GFP_KERNEL);
	if(bitBuffer == NULL || copy_from_user(bitBuffer, bitBuffer_user, length)){
		printk("Failed allocate buffer for configuration file \n");
		return -ENOTTY;	
	}

	cfg = gpio_request(SSI_CLK, "ssi_clk");
	if(cfg < 0){
		printk("Failed to take control over ssi_clk pin \n");
		return -ENOTTY;
	}
	cfg = gpio_request(SSI_DATA, "ssi_data");
	if(cfg < 0){
		printk("Failed to take control over ssi_data pin \n");
		return -ENOTTY;
	}
	i2c_buffer[0] = I2C_IO_EXP_CONFIG_REG;
	i2c_buffer[1] = 0xFF;
	i2c_buffer[1] &= ~ ((1 << SSI_PROG) | (1 << MODE1) | (1 << MODE0));
	i2c_master_send(io_cli, i2c_buffer, 2); // set SSI_PROG, MODE0, MODE1 as output others as inputs
	i2c_set_pin(io_cli, MODE0, 1);
	i2c_set_pin(io_cli, MODE1, 1);
	i2c_set_pin(io_cli, SSI_PROG, 0);

	gpio_direction_output(SSI_CLK, 0);
	gpio_direction_output(SSI_DATA, 0);

	
	gpio_set_value(SSI_CLK, 0);
	i2c_set_pin(io_cli, SSI_PROG, 1);
	__delay_cycles(10*SSI_DELAY);	
	i2c_set_pin(io_cli, SSI_PROG, 0);
	__delay_cycles(5*SSI_DELAY);		
	while(i2c_get_pin(io_cli, SSI_INIT) > 0 && timer < 200) timer ++; // waiting for init pin to go down
	if(timer >= 200){
		printk("FPGA did not answer to prog request, init pin not going low \n");
		i2c_set_pin(io_cli, SSI_PROG, 1);
		gpio_free(SSI_CLK);
		gpio_free(SSI_DATA);
		return -ENOTTY;	
	}
	timer = 0;
	__delay_cycles(5*SSI_DELAY);
	i2c_set_pin(io_cli, SSI_PROG, 1);
	while(i2c_get_pin(io_cli, SSI_INIT) == 0 && timer < 256){ // need to find a better way ...
		 timer ++; // waiting for init pin to go up
	}
	if(timer >= 256){
		printk("FPGA did not answer to prog request, init pin not going high \n");
		gpio_free(SSI_CLK);
		gpio_free(SSI_DATA);
		return -ENOTTY;	
	}
	timer = 0;
	printk("Starting configuration of %d bits \n", length*8);
	for(i = 0 ; i < length ; i ++){
		serialConfigWriteByte(bitBuffer[i]);	
		schedule();
	}
	printk("Waiting for done pin to go high \n");
	while(timer < 50){
		ssiClearClk();
		__delay_cycles(SSI_DELAY);	
		ssiSetClk();
		__delay_cycles(SSI_DELAY);	
		timer ++ ;
	}
	gpio_set_value(SSI_CLK, 0);
	gpio_set_value(SSI_DATA, 1);	
	if(i2c_get_pin(io_cli, SSI_DONE) == 0){
		printk("FPGA prog failed, done pin not going high \n");
		gpio_free(SSI_CLK);
		gpio_free(SSI_DATA);
		return -ENOTTY;		
	}

	i2c_buffer[0] = I2C_IO_EXP_CONFIG_REG;
	i2c_buffer[1] = 0xDC;
	i2c_master_send(io_cli, i2c_buffer, 2); // set all unused config pins as input (keeping mode pins and PROG as output)
	gpio_direction_input(SSI_CLK);
	gpio_direction_input(SSI_DATA);
	gpio_free(SSI_CLK);
	gpio_free(SSI_DATA);
	iounmap(gpio_regs);
	//release_mem_region(GPIO3_BASE + 0x190, 8);
	kfree(bitBuffer) ;
	return length ;
}
Exemplo n.º 11
0
static int wm2000_power_up(struct i2c_client *i2c, int analogue)
{
	struct wm2000_priv *wm2000 = dev_get_drvdata(&i2c->dev);
	unsigned long rate;
	int ret;

	if (WARN_ON(wm2000->anc_mode != ANC_OFF))
		return -EINVAL;

	dev_dbg(&i2c->dev, "Beginning power up\n");

	ret = regulator_bulk_enable(WM2000_NUM_SUPPLIES, wm2000->supplies);
	if (ret != 0) {
		dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret);
		return ret;
	}

	rate = clk_get_rate(wm2000->mclk);
	if (rate <= 13500000) {
		dev_dbg(&i2c->dev, "Disabling MCLK divider\n");
		wm2000_write(i2c, WM2000_REG_SYS_CTL2,
			     WM2000_MCLK_DIV2_ENA_CLR);
	} else {
		dev_dbg(&i2c->dev, "Enabling MCLK divider\n");
		wm2000_write(i2c, WM2000_REG_SYS_CTL2,
			     WM2000_MCLK_DIV2_ENA_SET);
	}

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_CLR);
	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_ENG_SET);

	/* Wait for ANC engine to become ready */
	if (!wm2000_poll_bit(i2c, WM2000_REG_ANC_STAT,
			     WM2000_ANC_ENG_IDLE)) {
		dev_err(&i2c->dev, "ANC engine failed to reset\n");
		regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
		return -ETIMEDOUT;
	}

	if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
			     WM2000_STATUS_BOOT_COMPLETE)) {
		dev_err(&i2c->dev, "ANC engine failed to initialise\n");
		regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
		return -ETIMEDOUT;
	}

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_RAM_SET);

	/* Open code download of the data since it is the only bulk
	 * write we do. */
	dev_dbg(&i2c->dev, "Downloading %d bytes\n",
		wm2000->anc_download_size - 2);

	ret = i2c_master_send(i2c, wm2000->anc_download,
			      wm2000->anc_download_size);
	if (ret < 0) {
		dev_err(&i2c->dev, "i2c_transfer() failed: %d\n", ret);
		regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
		return ret;
	}
	if (ret != wm2000->anc_download_size) {
		dev_err(&i2c->dev, "i2c_transfer() failed, %d != %d\n",
			ret, wm2000->anc_download_size);
		regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
		return -EIO;
	}

	dev_dbg(&i2c->dev, "Download complete\n");

	if (analogue) {
		wm2000_write(i2c, WM2000_REG_ANA_VMID_PU_TIME, 248 / 4);

		wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
			     WM2000_MODE_ANA_SEQ_INCLUDE |
			     WM2000_MODE_MOUSE_ENABLE |
			     WM2000_MODE_THERMAL_ENABLE);
	} else {
		wm2000_write(i2c, WM2000_REG_SYS_MODE_CNTRL,
			     WM2000_MODE_MOUSE_ENABLE |
			     WM2000_MODE_THERMAL_ENABLE);
	}

	ret = wm2000_read(i2c, WM2000_REG_SPEECH_CLARITY);
	if (wm2000->speech_clarity)
		ret |= WM2000_SPEECH_CLARITY;
	else
		ret &= ~WM2000_SPEECH_CLARITY;
	wm2000_write(i2c, WM2000_REG_SPEECH_CLARITY, ret);

	wm2000_write(i2c, WM2000_REG_SYS_START0, 0x33);
	wm2000_write(i2c, WM2000_REG_SYS_START1, 0x02);

	wm2000_write(i2c, WM2000_REG_SYS_CTL2, WM2000_ANC_INT_N_CLR);

	if (!wm2000_poll_bit(i2c, WM2000_REG_SYS_STATUS,
			     WM2000_STATUS_MOUSE_ACTIVE)) {
		dev_err(&i2c->dev, "Timed out waiting for device\n");
		regulator_bulk_disable(WM2000_NUM_SUPPLIES, wm2000->supplies);
		return -ETIMEDOUT;
	}

	dev_dbg(&i2c->dev, "ANC active\n");
	if (analogue)
		dev_dbg(&i2c->dev, "Analogue active\n");
	wm2000->anc_mode = ANC_ACTIVE;

	return 0;
}
static void irda_remocon_work(struct ir_remocon_data *ir_data, int count)
{

	struct ir_remocon_data *data = ir_data;
	struct i2c_client *client = data->client;

	int buf_size = count+2;
	int ret;
	int sleep_timing;
	int end_data;
	int emission_time;
	int ack_pin_onoff;

	if (count_number >= 100)
		count_number = 0;

	count_number++;

	gpio_tlmm_config(GPIO_CFG(ir_data->pdata->irda_irq_gpio,  0, GPIO_CFG_INPUT,
		GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);

	printk(KERN_INFO "%s: total buf_size: %d\n", __func__, buf_size);

	irda_add_checksum_length(data, count);

	mutex_lock(&data->mutex);

	ret = i2c_master_send(client, data->signal, buf_size);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, data->signal, buf_size);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}

	mdelay(10);

	ack_pin_onoff = 0;
	if (gpio_get_value(data->pdata->irda_irq_gpio)) {
		printk(KERN_INFO "%s : %d Checksum NG!\n",
			__func__, count_number);
		ack_pin_onoff = 1;
	} else {
		printk(KERN_INFO "%s : %d Checksum OK!\n",
			__func__, count_number);
		ack_pin_onoff = 2;
	}
	ack_number = ack_pin_onoff;

	mutex_unlock(&data->mutex);

#if 0
	for (i = 0; i < buf_size; i++) {
		printk(KERN_INFO "%s: data[%d] : 0x%02x\n", __func__, i,
					data->signal[i]);

	}
#endif
	data->count = 2;

	end_data = data->signal[count-2] << 8 | data->signal[count-1];
	emission_time = \
		(1000 * (data->ir_sum - end_data) / (data->ir_freq)) + 10;
	sleep_timing = emission_time - 130;
	if (sleep_timing > 0)
		msleep(sleep_timing);
/*
	printk(KERN_INFO "%s: sleep_timing = %d\n", __func__, sleep_timing);
*/
	emission_time = \
		(1000 * (data->ir_sum) / (data->ir_freq)) + 50;
	if (emission_time > 0)
		msleep(emission_time);
		printk(KERN_INFO "%s: emission_time = %d\n",
					__func__, emission_time);

	if (gpio_get_value(data->pdata->irda_irq_gpio)) {
		printk(KERN_INFO "%s : %d Sending IR OK!\n",
				__func__, count_number);
		ack_pin_onoff = 4;
	} else {
		printk(KERN_INFO "%s : %d Sending IR NG!\n",
				__func__, count_number);
		ack_pin_onoff = 2;
	}

	ack_number += ack_pin_onoff;
#ifndef USE_STOP_MODE
	data->on_off = 0;
	data->pdata->ir_wake_en(data->pdata,0);
	irda_vdd_onoff(0);
	gpio_set_value(data->pdata->irda_led_en, 0);
#endif
	data->ir_freq = 0;
	data->ir_sum = 0;
	gpio_tlmm_config(GPIO_CFG(ir_data->pdata->irda_irq_gpio,  0, GPIO_CFG_INPUT,
		GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
static int irda_fw_update(struct ir_remocon_data *ir_data)
{
	struct ir_remocon_data *data = ir_data;
	struct i2c_client *client = data->client;
	int i, k, ret, ret2, checksum, checksum2, frame_count;
	u8 buf_ir_test[8];
	const u8 *IRDA_fw;
	ret = 0;

	ret = irda_vdd_onoff(0);
	if (ret) {
		pr_err("%s Regulator setting failed\n", __func__);
		goto err_regulator;
	}
	data->pdata->ir_wake_en(data->pdata, 0);
	msleep(100);
	ret = irda_vdd_onoff(1);
	if (ret) {
		pr_err("%s Regulator setting failed\n", __func__);
		goto err_regulator;
	}

	data->pdata->ir_wake_en(data->pdata,1);
	gpio_tlmm_config(GPIO_CFG(data->pdata->irda_irq_gpio,  0, GPIO_CFG_INPUT,
			GPIO_CFG_PULL_UP, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	msleep(70);

	ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
	if (ret < 0) {
		printk(KERN_ERR "%s: err %d\n", __func__, ret);
		ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
		if (ret < 0) {
			printk(KERN_INFO "%s: broken FW!\n", __func__);
			goto err_bootmode;
		}
	}

#ifdef DEBUG
	print_hex_dump(KERN_CRIT, "IRDA Master Rx: ", 16, 1,
				DUMP_PREFIX_ADDRESS, buf_ir_test, 8, 1);
#endif
	ret = buf_ir_test[2] << 8 | buf_ir_test[3];

	if ((ret == MC96FR116C_0x103) || (ret == MC96FR332A_0x202)) {
		data->pdata->ir_wake_en(data->pdata,0);
		ret = irda_vdd_onoff(0);
		if (ret) {
			pr_err("%s Regulator setting failed\n", __func__);
			goto err_regulator;
		}

		data->on_off = 0;
		msleep(100);
		download_pass = 1;
		return 0;
	}

	if (ret == MC96FR116C_0x101) {
		IRDA_fw     = IRDA_binary_103;
		frame_count = FRAME_COUNT_103;
		printk(KERN_ERR "%s: chip : %04x, bin : %04x, need update!\n",
					__func__, ret, MC96FR116C_0x103);
	}
	else if (ret == MC96FR332A_0x201) {
		IRDA_fw     = IRDA_binary_202;
		frame_count = FRAME_COUNT_202;
		printk(KERN_ERR "%s: chip : %04x, bin : %04x, need update!\n",
					__func__, ret, MC96FR332A_0x202);
	}
	else
		goto err_bootmode;

	printk(KERN_ERR "irda frame count = %d\n", frame_count);

	ret = irda_vdd_onoff(0);
	if (ret) {
		pr_err("%s Regulator setting failed\n", __func__);
		goto err_regulator;
	}

	data->pdata->ir_wake_en(data->pdata, 0);
	msleep(100);
	ret = irda_vdd_onoff(1);
	if (ret) {
		pr_err("%s Regulator setting failed\n", __func__);
		goto err_regulator;
	}

	msleep(70);

	ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
	if (ret < 0)
		printk(KERN_ERR " %s: err %d\n", __func__, ret);

#ifdef DEBUG
	print_hex_dump(KERN_CRIT, "IRDA Master Rx: ", 16, 1,
			DUMP_PREFIX_ADDRESS, buf_ir_test, 8, 1);
#endif

	ret = buf_ir_test[6] << 8 | buf_ir_test[7];

	checksum = 0;

	for (k = 0; k < 6; k++)
		checksum += buf_ir_test[k];

	if (ret == checksum)
		printk(KERN_INFO "%s: boot mode, FW download start! ret=%04x\n",
							__func__, ret);
	else {
		printk(KERN_ERR "ABOV IC bootcode broken\n");
		goto err_bootmode;
	}

	msleep(30);

	for (i = 0; i < frame_count; i++) {
		if (i == frame_count-1) {
			ret = i2c_master_send(client,
					&IRDA_fw[i * 70], 6);
			if (ret < 0)
				goto err_update;
		} else {
			ret = i2c_master_send(client,
					&IRDA_fw[i * 70], 70);
			if (ret < 0)
				goto err_update;
		}
		msleep(30);
	}

	ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
	if (ret < 0)
		printk(KERN_ERR "5. %s: err %d\n", __func__, ret);

#ifdef DEBUG
	print_hex_dump(KERN_CRIT, "IRDA Master Rx: ", 16, 1,
			DUMP_PREFIX_ADDRESS, buf_ir_test, 8, 1);
#endif

	ret = buf_ir_test[6] << 8 | buf_ir_test[7];
	checksum = 0;
	for (k = 0; k < 6; k++)
			checksum += buf_ir_test[k];

		msleep(20);

		ret2 = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);

		if (ret2 < 0)
			printk(KERN_ERR "6. %s: err %d\n", __func__, ret2);

		ret2 = buf_ir_test[6] << 8 | buf_ir_test[7];
		for (k = 0; k < 6; k++)
			checksum2 += buf_ir_test[k];

		if (ret == checksum) {
			printk(KERN_INFO "1. %s: boot down complete\n",
				__func__);
			download_pass = 1;
		} else if (ret2 == checksum2) {
			printk(KERN_INFO "2. %s: boot down complete\n",
				__func__);
			download_pass = 1;
		} else {
			printk(KERN_ERR "FW Checksum fail\n");
			goto err_bootmode;
		}

		ret = irda_vdd_onoff(0);
		if (ret) {
			pr_err("%s Regulator setting failed\n", __func__);
			goto err_regulator;
		}

		msleep(100);
		ret = irda_vdd_onoff(1);
		if (ret) {
			pr_err("%s Regulator setting failed\n", __func__);
			goto err_regulator;
		}

		data->pdata->ir_wake_en(data->pdata, 1);
		msleep(70);

		ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
		ret = buf_ir_test[2] << 8 | buf_ir_test[3];
		printk(KERN_INFO "7. %s: user mode : Upgrade FW_version : %04x\n",
						__func__, ret);

#ifdef DEBUG
	print_hex_dump(KERN_CRIT, "IRDA Master Rx: ", 16, 1,
				DUMP_PREFIX_ADDRESS, buf_ir_test, 8, 1);
#endif

		data->pdata->ir_wake_en(data->pdata,0);
		ret = irda_vdd_onoff(0);
		if (ret) {
			pr_err("%s Regulator setting failed\n", __func__);
			goto err_regulator;
		}

		data->on_off = 0;

	if ((ret == MC96FR116C_0x103) || (ret == MC96FR332A_0x202))
		download_pass = 1;

	return 0;
err_update:
	printk(KERN_ERR "%s: update fail! count : %x, ret = %x\n",
							__func__, i, ret);
	return ret;
err_bootmode:
	printk(KERN_ERR "%s: update fail, checksum = %x ret = %x\n",
					__func__, checksum, ret);
	data->pdata->ir_wake_en(data->pdata,0);
	ret = irda_vdd_onoff(0);
	if (ret) {
		pr_err("%s Regulator setting failed\n", __func__);
		goto err_regulator;
	}

	data->on_off = 0;
err_regulator:
	return ret;
}
Exemplo n.º 14
0
static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
			u8 reg_base, unsigned char alm_enable)
{
	int i, xfer;
	unsigned char rdata[10] = { 0, reg_base };
	unsigned char *buf = rdata + 2;

	static const unsigned char wel[3] = { 0, X1205_REG_SR,
						X1205_SR_WEL };

	static const unsigned char rwel[3] = { 0, X1205_REG_SR,
						X1205_SR_WEL | X1205_SR_RWEL };

	static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };

	dev_dbg(&client->dev,
		"%s: sec=%d min=%d hour=%d mday=%d mon=%d year=%d wday=%d\n",
		__func__, tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday,
		tm->tm_mon, tm->tm_year, tm->tm_wday);

	buf[CCR_SEC] = bin2bcd(tm->tm_sec);
	buf[CCR_MIN] = bin2bcd(tm->tm_min);

	/* set hour and 24hr bit */
	buf[CCR_HOUR] = bin2bcd(tm->tm_hour) | X1205_HR_MIL;

	buf[CCR_MDAY] = bin2bcd(tm->tm_mday);

	/* month, 1 - 12 */
	buf[CCR_MONTH] = bin2bcd(tm->tm_mon + 1);

	/* year, since the rtc epoch*/
	buf[CCR_YEAR] = bin2bcd(tm->tm_year % 100);
	buf[CCR_WDAY] = tm->tm_wday & 0x07;
	buf[CCR_Y2K] = bin2bcd((tm->tm_year + 1900) / 100);

	/* If writing alarm registers, set compare bits on registers 0-4 */
	if (reg_base < X1205_CCR_BASE)
		for (i = 0; i <= 4; i++)
			buf[i] |= 0x80;

	/* this sequence is required to unlock the chip */
	if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
		dev_err(&client->dev, "%s: wel - %d\n", __func__, xfer);
		return -EIO;
	}

	if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
		dev_err(&client->dev, "%s: rwel - %d\n", __func__, xfer);
		return -EIO;
	}

	xfer = i2c_master_send(client, rdata, sizeof(rdata));
	if (xfer != sizeof(rdata)) {
		dev_err(&client->dev,
			"%s: result=%d addr=%02x, data=%02x\n",
			__func__,
			 xfer, rdata[1], rdata[2]);
		return -EIO;
	}

	/* If we wrote to the nonvolatile region, wait 10msec for write cycle*/
	if (reg_base < X1205_CCR_BASE) {
		unsigned char al0e[3] = { 0, X1205_REG_INT, 0 };

		msleep(10);

		/* ...and set or clear the AL0E bit in the INT register */

		/* Need to set RWEL again as the write has cleared it */
		xfer = i2c_master_send(client, rwel, 3);
		if (xfer != 3) {
			dev_err(&client->dev,
				"%s: aloe rwel - %d\n",
				__func__,
				xfer);
			return -EIO;
		}

		if (alm_enable)
			al0e[2] = X1205_INT_AL0E;

		xfer = i2c_master_send(client, al0e, 3);
		if (xfer != 3) {
			dev_err(&client->dev,
				"%s: al0e - %d\n",
				__func__,
				xfer);
			return -EIO;
		}

		/* and wait 10msec again for this write to complete */
		msleep(10);
	}

	/* disable further writes */
	if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
		dev_err(&client->dev, "%s: diswe - %d\n", __func__, xfer);
		return -EIO;
	}

	return 0;
}
Exemplo n.º 15
0
static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
				   int bytes, const void *src)
{
	struct i2c_client *i2c = wm8994->control_data;
	int ret;

	unsigned char msg[2 + 2];
	void *buf;

	/* If we're doing a single register write we can probably just
	 * send the work_buf directly, otherwise try to do a gather
	 * write.
	 */
	if (bytes == 2) {
		dev_vdbg(wm8994->dev,
			 "%s: Single register write - Reg = 0x%04x, bytes = 0x%x\n",
			 __func__, reg, bytes);

		reg = cpu_to_be16(reg);
		memcpy(&msg[0], &reg, 2);
		memcpy(&msg[2], src, bytes);

		ret = i2c_master_send(i2c, msg, bytes + 2);
		if (ret < 0) {
			printk(KERN_DEBUG"[%s] write fail reg[%x], ret[%d]\n",
					__func__, reg, ret);
			return ret;
			}
		if (ret < bytes + 2) {
			printk(KERN_DEBUG"[%s] write fail reg[%x], ret EIO\n",
					__func__, reg);
			return -EIO;
			}
		return 0;
	} else {
		ret = wm8994_i2c_gather_write_device(wm8994, reg, bytes, src);
	}

	if (ret == -ENOTSUPP) {
		dev_vdbg(wm8994->dev,
			 "%s: Manual group write - Reg = 0x%04x, bytes = 0x%x\n",
			 __func__, reg, bytes);

		buf = kmalloc(2 + bytes, GFP_KERNEL);
		if (!buf)
			return -ENOMEM;

		reg = cpu_to_be16(reg);
		memcpy(buf, &reg, 2);
		memcpy(buf + 2, src, bytes);

		ret = i2c_master_send(i2c, buf, bytes + 2);

		kfree(buf);

		if (ret < 0)
			return ret;
		if (ret < bytes + 2)
			return -EIO;

		return 0;
	}
	return ret;
}
Exemplo n.º 16
0
E_UPGRADE_ERR_TYPE  fts_ctpm_fw_upgrade(struct i2c_client *client,FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
{
//    FTS_BYTE cmd_len     = 0;
    FTS_BYTE reg_val[2] = {0};
    FTS_DWRD i = 0;
//    FTS_BYTE ecc = 0;

    FTS_DWRD  packet_number;
    FTS_DWRD  j;
    FTS_DWRD  temp;
    FTS_DWRD  lenght;
    FTS_BYTE  packet_buf[FTS_PACKET_LENGTH + 6];
    FTS_BYTE  auc_i2c_write_buf[10];
    FTS_BYTE bt_ecc;

    /*********Step 1:Reset  CTPM *****/
    /*write 0xaa to register 0xfc*/
    Fts_i2c_write(client,0xfc,0xaa);
    delay_ms(50);
     /*write 0x55 to register 0xfc*/
    Fts_i2c_write(client,0xfc,0x55);
    pr_info("Step 1: Reset CTPM test\n");

    delay_ms(40);

    /*********Step 2:Enter upgrade mode *****/
     auc_i2c_write_buf[0] = 0x55;
     auc_i2c_write_buf[1] = 0xaa;
     i2c_master_send(client, auc_i2c_write_buf, 2);
     pr_info("Step 2: Enter update mode. \n");

    /*********Step 3:check READ-ID***********************/
    /*send the opration head*/
    do{
        if(i > 3)
        {
            return ERR_READID; 
        }
        /*read out the CTPM ID*/
        
        cmd_write(client,0x90,0x00,0x00,0x00,4);
        byte_read(client,reg_val,2);
        i++;
        pr_info("Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
    }while(reg_val[0] != 0x79 || reg_val[1] != 0x03);

     /*********Step 4:erase app*******************************/
    cmd_write(client,0x61,0x00,0x00,0x00,1);
    delay_ms(1500);
    pr_info("Step 4: erase. \n");

    /*********Step 5:write firmware(FW) to ctpm flash*********/
    bt_ecc = 0;
    pr_info("Step 5: start upgrade. \n");
    dw_lenth = dw_lenth - 8;
    packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
    packet_buf[0] = 0xbf;
    packet_buf[1] = 0x00;
    for (j=0;j<packet_number;j++)
    {
        temp = j * FTS_PACKET_LENGTH;
        packet_buf[2] = (FTS_BYTE)(temp>>8);
        packet_buf[3] = (FTS_BYTE)temp;
        lenght = FTS_PACKET_LENGTH;
        packet_buf[4] = (FTS_BYTE)(lenght>>8);
        packet_buf[5] = (FTS_BYTE)lenght;

        for (i=0;i<FTS_PACKET_LENGTH;i++)
        {
            packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i]; 
            bt_ecc ^= packet_buf[6+i];
        }
        
        byte_write(client,&packet_buf[0],FTS_PACKET_LENGTH + 6);
        delay_ms(FTS_PACKET_LENGTH/6 + 1);
        if ((j * FTS_PACKET_LENGTH % 1024) == 0)
        {
              pr_info("upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
        }
    }

    if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
    {
        temp = packet_number * FTS_PACKET_LENGTH;
        packet_buf[2] = (FTS_BYTE)(temp>>8);
        packet_buf[3] = (FTS_BYTE)temp;

        temp = (dw_lenth) % FTS_PACKET_LENGTH;
        packet_buf[4] = (FTS_BYTE)(temp>>8);
        packet_buf[5] = (FTS_BYTE)temp;

        for (i=0;i<temp;i++)
        {
            packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i]; 
            bt_ecc ^= packet_buf[6+i];
        }

        byte_write(client,&packet_buf[0],temp+6);    
        delay_ms(20);
    }
Exemplo n.º 17
0
int AT83C26_SendCmd(int Cmd, unsigned char *data, int size)
{
    char dataBuf[5];
    int ret;
    
    PrtMsg("%s with Cmd = %d\n", __FUNCTION__, Cmd);
    switch (Cmd)
    {
        case 3: 
            memcpy(dataBuf, (char*)data, size);
            dataBuf[0] |= 0x80; 
            size -=1;
            break;
        case 4:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xFC;
            break;
        case 5: 
            dataBuf[0] = (char)*data;
            CLEAR_BIT(dataBuf[0], 7);
            size = 0;
            break;
        case 6:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xF8;            
            break;
        case 7:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xF9;
            break;
        case 8:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xFA;
            break;
        case 9:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xFB;
            break;
        case 10:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xFD;
            break;
        case 11:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xFE;
            break;
        case 12:
            memcpy(dataBuf+1, (char*)data, size);
            dataBuf[0] = 0xF7;
            break;

        default: return(-1);
    }
    
    ret = i2c_master_send(AT83C26.client, dataBuf, size+1);
    if(ret < 0)
    {
        PrtMsg("%s: Fail to send i2c CMD: %d, error code = %d\n", __FUNCTION__, Cmd, ret);   
        return(-1);
    }
    return(0);
}
Exemplo n.º 18
0
static void melfas_ts_get_data(struct work_struct *work)
{
	struct melfas_ts_data *ts = container_of(work, struct melfas_ts_data, work);
	int ret = 0, i;
	uint8_t buf[TS_READ_REGS_LEN];
	int read_num, FingerID;
	int _touch_is_pressed;
#if DEBUG_PRINT
	printk(KERN_ERR "%s start\n", __func__);

	if(ts ==NULL)
			printk(KERN_ERR "%s : TS NULL\n", __func__);
#endif 

	buf[0] = TS_READ_START_ADDR;

	ret = i2c_master_send(ts->client, buf, 1);
	if(ret < 0)
	{
#if DEBUG_PRINT
		printk(KERN_ERR "%s: i2c failed(%d)\n",__func__, __LINE__);
		return ;	
#endif 
	}
	ret = i2c_master_recv(ts->client, buf, 1);
	if(ret < 0)
	{
#if DEBUG_PRINT
		printk(KERN_ERR "%s: i2c failed(%d)\n",__func__, __LINE__);
		return ;	
#endif 
	}

	read_num = buf[0];
	
	if(read_num>0)
	{
		buf[0] = TS_READ_START_ADDR2;

		ret = i2c_master_send(ts->client, buf, 1);
		if(ret < 0)
		{
#if DEBUG_PRINT
		printk(KERN_ERR "%s: i2c failed(%d)\n",__func__, __LINE__);
			return ;	
#endif 
		}
		ret = i2c_master_recv(ts->client, buf, read_num);
		if(ret < 0)
		{
#if DEBUG_PRINT
		printk(KERN_ERR "%s: i2c failed(%d)\n",__func__, __LINE__);
			return ;	
#endif 
		}

		for(i=0; i<read_num; i=i+6)
		{
			FingerID = (buf[i] & 0x0F) - 1;
			g_Mtouch_info[FingerID].posX= (uint16_t)(buf[i+1] & 0x0F) << 8 | buf[i+2];
			g_Mtouch_info[FingerID].posY= (uint16_t)(buf[i+1] & 0xF0) << 4 | buf[i+3];	
			
			if((buf[i] & 0x80)==0)
				g_Mtouch_info[FingerID].strength = 0;
			else
				g_Mtouch_info[FingerID].strength = buf[i+4];
			
			g_Mtouch_info[FingerID].width= buf[i+5];					
		}
	
	}

	_touch_is_pressed=0;
	if (ret < 0)
	{
		printk(KERN_ERR "%s: i2c failed(%d)\n",__func__, __LINE__);
		return ;	
	}
	else 
	{

		for(i=0; i<MELFAS_MAX_TOUCH; i++)
		{
			if(g_Mtouch_info[i].strength== -1)
				continue;
			
			input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, i);
			input_report_abs(ts->input_dev, ABS_MT_POSITION_X, g_Mtouch_info[i].posX);
			input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, g_Mtouch_info[i].posY);
			input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, g_Mtouch_info[i].strength );
			input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, g_Mtouch_info[i].width);
			input_mt_sync(ts->input_dev);
//#if DEBUG_PRINT
			printk(KERN_ERR "[TSP] ID: %d, State : %d, x: %d, y: %d, z: %d w: %d\n", 
				i, (g_Mtouch_info[i].strength>0), g_Mtouch_info[i].posX, g_Mtouch_info[i].posY, g_Mtouch_info[i].strength, g_Mtouch_info[i].width);
//#endif	

			if(g_Mtouch_info[i].strength == 0)
				g_Mtouch_info[i].strength = -1;

			if(g_Mtouch_info[i].strength > 0)
				_touch_is_pressed = 1;
            
		}
		input_sync(ts->input_dev);
		touch_is_pressed = _touch_is_pressed;
			
		if(touch_is_pressed >0)	// when touch is pressed.
		{
			if (lock_status == 0) {
				lock_status = 1;
			}
		}
		else	// when touch is released.
		{
			if(read_num>0)
			{
				lock_status = 0;
			}
		}	
//		printk(KERN_ERR "melfas_ts_get_data: touch_is_pressed=%d \n",touch_is_pressed);   			

	}
}
Exemplo n.º 19
0
static ssize_t barcode_emul_store(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t size)
{
	int ret, i;
	struct barcode_emul_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	struct {
		unsigned char addr;
		unsigned char data[20];
	} i2c_block_transfer;

	unsigned char barcode_data[14]={0xFF, 0xAC, 0xDB, 0x36, 0x42, 0x85, 0x0A, 0xA8, 0xD1, 0xA3, 0x46, 0xC5, 0xDA, 0xFF};

	if(gpio_get_value(GPIO_FPGA_CDONE)!=1)
	{
		printk(KERN_ERR "%s: cdone fail !!\n", __func__);
		return 0;
	}
#if 1

	ret = i2c_master_send(client, buf, size);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, buf, size);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}
/*
	for (i = 0; i < size; i++)
		i2c_block_transfer.data[i] = *buf++;

	i2c_block_transfer.addr = 0x01;
	
	printk(KERN_INFO "%s: write addr: %d, value: %d\n", __func__, i2c_block_transfer.addr, i2c_block_transfer.data[0]);
	
	ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}

	do{	
		unsigned char testbuf[10];
		struct i2c_msg msg[2];
		unsigned char addr=0x01;
		
		msg[0].addr  = client->addr;
		msg[0].flags = 0x00;
		msg[0].len   = 1;
		msg[0].buf   = &addr;

		msg[1].addr  = client->addr;
		msg[1].flags = I2C_M_RD;
		msg[1].len   = 1;
		msg[1].buf   = testbuf;

		ret=i2c_transfer(client->adapter, msg, 2); 
		if  (ret == 2) {
			printk(KERN_INFO "read value: %d\n", testbuf[0]);
		}
		else
			dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
	}while(0);
*/
#else
	i2c_block_transfer.addr = 0x00;
	i2c_block_transfer.data[0]=0x00;
	ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}

	i2c_block_transfer.addr = 0x01;
	i2c_block_transfer.data[0]=0x01;
	ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}

	i2c_block_transfer.addr = 0x02;
	for (i = 0; i < 14; i++)
		i2c_block_transfer.data[i] = barcode_data[i];
	
	ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 15);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 15);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}

	i2c_block_transfer.addr = 0x00;
	i2c_block_transfer.data[0]=0x01;
	ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
	if (ret < 0) {
		dev_err(&client->dev, "%s: err1 %d\n", __func__, ret);
		ret = i2c_master_send(client, (unsigned char *) &i2c_block_transfer, 2);
		if (ret < 0)
			dev_err(&client->dev, "%s: err2 %d\n", __func__, ret);
	}
#endif	
	return size;
}
Exemplo n.º 20
0
static int melfas_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct melfas_ts_data *ts;
	struct melfas_tsi_platform_data *data;
#ifdef SEC_TSP
	struct device *sec_touchscreen;
	struct device *qt602240_noise_test;
	char lcd_id, *temp;
#endif

	int ret = 0, i; 
	
	uint8_t buf[4] = {0,};
	
#if DEBUG_PRINT
	printk(KERN_ERR "%s start.\n", __func__);
#endif

    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
    {
        printk(KERN_ERR "%s: need I2C_FUNC_I2C\n", __func__);
        ret = -ENODEV;
        goto err_check_functionality_failed;
    }

    ts = kmalloc(sizeof(struct melfas_ts_data), GFP_KERNEL);
    if (ts == NULL)
    {
        printk(KERN_ERR "%s: failed to create a state of melfas-ts\n", __func__);
        ret = -ENOMEM;
        goto err_alloc_data_failed;
    }
	ts_data = ts;
	data = client->dev.platform_data;
	ts->power = data->power;
	ts->gpio = data->gpio;
    ts->client = client;
    i2c_set_clientdata(client, ts);
	ts->power(true);
    ret = i2c_master_send(ts->client, &buf, 1);


#if DEBUG_PRINT
	printk(KERN_ERR "%s: i2c_master_send() [%d], Add[%d]\n", __func__, ret, ts->client->addr);
#endif



#if SET_DOWNLOAD_BY_GPIO
	buf[0] = TS_READ_VERSION_ADDR;
	ret = i2c_master_send(ts->client, &buf, 1);
	if(ret < 0)
	{
		printk(KERN_ERR "%s: i2c_master_send [%d]\n", __func__, ret);			
	}

	ret = i2c_master_recv(ts->client, &buf, 4);
	if(ret < 0)
	{
		printk(KERN_ERR "%s: i2c_master_recv [%d]\n", __func__, ret);			
	}
	printk(KERN_ERR "FW_VERSION: 0x%02x\n", buf[3]);

	temp = get_s6e8aa0_id_buffer();
	lcd_id = *(temp+1);
	printk(KERN_ERR "LCD_ID : 0x%02x 0x%02x\n", *temp, lcd_id);

	if(lcd_id != 0x23 && lcd_id != 0x80 && buf[3] < FW_VERSION)
	{
		printk(KERN_ERR "FW Upgrading... FW_VERSION: 0x%02x\n", buf[3]);
		ret = mcsdl_download_binary_data(data);		
		if(ret == 0)
		{
			printk(KERN_ERR "SET Download Fail - error code [%d]\n", ret);			
		}
	}	
#endif // SET_DOWNLOAD_BY_GPIO
	
	ts->input_dev = input_allocate_device();
    if (!ts->input_dev)
    {
		printk(KERN_ERR "%s: Not enough memory\n", __func__);
		ret = -ENOMEM;
		goto err_input_dev_alloc_failed;
	} 

	ts->input_dev->name = "sec_touchscreen" ;

	ts->input_dev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
	

	ts->input_dev->keybit[BIT_WORD(KEY_MENU)] |= BIT_MASK(KEY_MENU);
	ts->input_dev->keybit[BIT_WORD(KEY_HOME)] |= BIT_MASK(KEY_HOME);
	ts->input_dev->keybit[BIT_WORD(KEY_BACK)] |= BIT_MASK(KEY_BACK);		
	ts->input_dev->keybit[BIT_WORD(KEY_SEARCH)] |= BIT_MASK(KEY_SEARCH);			


//	__set_bit(BTN_TOUCH, ts->input_dev->keybit);
//	__set_bit(EV_ABS,  ts->input_dev->evbit);
//	ts->input_dev->evbit[0] =  BIT_MASK(EV_SYN) | BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);	

	input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, TS_MAX_X_COORD, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, TS_MAX_Y_COORD, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, TS_MAX_Z_TOUCH, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, MELFAS_MAX_TOUCH-1, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, TS_MAX_W_TOUCH, 0, 0);
//	__set_bit(EV_SYN, ts->input_dev->evbit); 
//	__set_bit(EV_KEY, ts->input_dev->evbit);	


    ret = input_register_device(ts->input_dev);
    if (ret)
    {
        printk(KERN_ERR "%s: Failed to register device\n", __func__);
        ret = -ENOMEM;
        goto err_input_register_device_failed;
    }

    if (ts->client->irq)
    {
#if DEBUG_PRINT
        printk(KERN_ERR "%s: trying to request irq: %s-%d\n", __func__, ts->client->name, ts->client->irq);
#endif
		ret = request_threaded_irq(client->irq, NULL, melfas_ts_irq_handler, IRQF_ONESHOT | IRQF_TRIGGER_LOW, ts->client->name, ts);
        if (ret > 0)
        {
            printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, ts->client->irq, ret);
            ret = -EBUSY;
            goto err_request_irq;
        }
    }
	for (i = 0; i < MELFAS_MAX_TOUCH ; i++)  /* _SUPPORT_MULTITOUCH_ */
		g_Mtouch_info[i].strength = -1;	

	tsp_enabled = true;

#if DEBUG_PRINT	
	printk(KERN_ERR "%s: succeed to register input device\n", __func__);
#endif

#ifdef SEC_TSP
	sec_touchscreen = device_create(sec_class, NULL, 0, ts, "sec_touchscreen");
	if (IS_ERR(sec_touchscreen))
		pr_err("[TSP] Failed to create device for the sysfs\n");

	ret = sysfs_create_group(&sec_touchscreen->kobj, &sec_touch_attr_group);
	if (ret)
		pr_err("[TSP] Failed to create sysfs group\n");
#endif

#ifdef TSP_FACTORY_TEST
	qt602240_noise_test = device_create(sec_class, NULL, 0, ts, "qt602240_noise_test");
	if (IS_ERR(qt602240_noise_test))
		pr_err("[TSP] Failed to create device for the sysfs\n");

	ret = sysfs_create_group(&qt602240_noise_test->kobj, &sec_touch_factory_attr_group);
	if (ret)
		pr_err("[TSP] Failed to create sysfs group\n");
#endif

#if CONFIG_HAS_EARLYSUSPEND
	ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	ts->early_suspend.suspend = melfas_ts_early_suspend;
	ts->early_suspend.resume = melfas_ts_late_resume;
	register_early_suspend(&ts->early_suspend);
#endif
#ifdef SET_TSP_CONFIG
	melfas_set_config(ts->client, MIP_ACTIVE_REPORT_RATE, 60);
//	melfas_set_config(ts->client, MIP_CONTACT_ON_EVENT_THRES, 60);
//	melfas_set_config(ts->client, MIP_MOVING_EVENT_THRES, 20);
//	melfas_set_config(ts->client, MIP_POSITION_FILTER_LEVEL, 10);
#endif
#if DEBUG_PRINT
	printk(KERN_INFO "%s: Start touchscreen. name: %s, irq: %d\n", __func__, ts->client->name, ts->client->irq);
#endif
	return 0;

err_request_irq:
	printk(KERN_ERR "melfas-ts: err_request_irq failed\n");
	free_irq(client->irq, ts);
err_input_register_device_failed:
	printk(KERN_ERR "melfas-ts: err_input_register_device failed\n");
	input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
	printk(KERN_ERR "melfas-ts: err_input_dev_alloc failed\n");
err_alloc_data_failed:
	printk(KERN_ERR "melfas-ts: err_alloc_data failed_\n");	
err_detect_failed:
	printk(KERN_ERR "melfas-ts: err_detect failed\n");
	kfree(ts);
err_check_functionality_failed:
	printk(KERN_ERR "melfas-ts: err_check_functionality failed_\n");

	return ret;
}
Exemplo n.º 21
0
    *a_pu2Result = ((((u16)pGetBuff[0]) << 8) + (pGetBuff[1]))&0x3ff;

    return 0;
}

static int s4FM50AF_WriteReg(u16 a_u2Data)
{
    int  i4RetValue = 0;
    //char puSendCmd[2];

	a_u2Data = a_u2Data&0x3FF;
	
	char puSendCmd1[2]= {(char)(0x03) , (char)(a_u2Data>>8)};
    //FM50AFDB("[FM50AF] g_sr %d, write %d \n", g_sr, a_u2Data);
    i4RetValue = i2c_master_send(g_pstFM50AF_I2Cclient, puSendCmd1, 2);
	
    if (i4RetValue < 0) 
    {
        FM50AFDB("[FM50AF] I2C send failed!! \n");
        return -1;
    }
	
   char puSendCmd2[2] = {(char)(0x04) , (char)(a_u2Data&0xff)};
		
    //FM50AFDB("[FM50AF] g_sr %d, write %d \n", g_sr, a_u2Data);
    i4RetValue = i2c_master_send(g_pstFM50AF_I2Cclient, puSendCmd2, 2);
	
    if (i4RetValue < 0) 
    {
        FM50AFDB("[FM50AF] I2C send failed!! \n");
Exemplo n.º 22
0
static void hauppauge_hvr930c_init(struct em28xx *dev)
{
	int i;

	struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
		{EM2874_R80_GPIO_P0_CTRL,	0xff,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xfb,	0xff,	0x32},
		{EM2874_R80_GPIO_P0_CTRL,	0xff,	0xff,	0xb8},
		{	-1,			-1,	-1,	-1},
	};
	struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x01},
		{EM2874_R80_GPIO_P0_CTRL,	0xaf,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x76},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x01},
		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x0b},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x40},

		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x0b},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x65},

		{	-1,			-1,	-1,	-1},
	};

	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
		{{ 0x01, 0x00, 0x03, 0xa0 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0x73, 0xaf }, 4},
		{{ 0x04, 0x00 }, 2},
		{{ 0x00, 0x04 }, 2},
		{{ 0x00, 0x04, 0x00, 0x0a }, 4},
		{{ 0x04, 0x14 }, 2},
		{{ 0x04, 0x14, 0x00, 0x00 }, 4},
	};

	em28xx_gpio_set(dev, hauppauge_hvr930c_init);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
	msleep(10);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(10);

	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;

	for (i = 0; i < ARRAY_SIZE(regs); i++)
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
	em28xx_gpio_set(dev, hauppauge_hvr930c_end);

	msleep(100);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(30);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
	msleep(10);

}
Exemplo n.º 23
0
/*
static int tpd_i2c_detect(struct i2c_client *client, struct i2c_board_info *info) {
    strcpy(info->type, "mtk-tpd");
    return 0;
}
*/
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             
    int err = 0;
    char buffer[8];
    int status=0;
    i2c_client = client;    
    
    #ifdef TPD_NO_GPIO
    u16 temp;
    temp = *(volatile u16 *) TPD_RESET_PIN_ADDR;
    temp = temp | 0x40;
    *(volatile u16 *) TPD_RESET_PIN_ADDR = temp;
    #endif
    
    #ifndef TPD_NO_GPIO 
    mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);  
    msleep(10);  
#ifdef TPD_POWER_SOURCE_CUSTOM
    hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
#endif
#ifdef TPD_POWER_SOURCE_1800
    hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
#endif
#ifdef GPIO_CTP_EN_PIN
    mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
    msleep(5);
#endif
    
 //   mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
 //   mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
 //   mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
 //   msleep(10);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
    msleep(1);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);

    mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
    mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
    mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
    #endif 

    msleep(10);
    buffer[0] =  0x00;
    buffer[1] =  0x03;
    i2c_master_send(i2c_client,buffer,2);
    msleep(50);
    status = i2c_master_recv(i2c_client, buffer, 8);
    
    if(status<0) {
        TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe failed!!\n");
        return status;
    }
    TPD_DMESG("[mtk-tpd], cy8ctma300 tpd_i2c_probe success!!\n");		
    if(buffer[2] == 0x31)
    tpd_load_status = 1;
    buffer[0] =  0x00;
    buffer[1] =  0x05;
    i2c_master_send(i2c_client,buffer,2);
    //status = i2c_master_recv(i2c_client, buffer, 3);
    msleep(50);
    buffer[0] =  0x00;
    buffer[1] =  0x21;
    buffer[2] =  0x07;
    buffer[3] =  0x01;
    buffer[4] =  0x00;
    i2c_master_send(i2c_client,buffer,5);
    msleep(50);


    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
    if (IS_ERR(thread)) { 
        err = PTR_ERR(thread);
        TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }
    
    mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
    
    return 0;
}
Exemplo n.º 24
0
static int pixcir_i2c_ts_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct pixcir_i2c_ts_data *tsdata;
	struct input_dev *input;
	int error = 0;
	unsigned char Wrbuf;

	error = touch_reset();
	if (error)
		goto fail;
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(&client->dev, "i2c check functionality failed\n");
		return -ENODEV;
	}

	tsdata = kzalloc(sizeof(*tsdata), GFP_KERNEL);
	if (!tsdata) {
		dev_err(&client->dev, "failed to allocate driver data!\n");
		error = -ENOMEM;
		goto fail1;
	}

	dev_set_drvdata(&client->dev, tsdata);

	input = input_allocate_device();
	if (!input) {
		dev_err(&client->dev, "failed to allocate input device!\n");
		error = -ENOMEM;
		goto fail2;
	}

	set_bit(EV_SYN, input->evbit);
	set_bit(EV_KEY, input->evbit);
	set_bit(EV_ABS, input->evbit);
	set_bit(BTN_TOUCH, input->keybit);
	set_bit(BTN_2, input->keybit);

	input_set_abs_params(input, ABS_X, TOUCHSCREEN_MINX,
						TOUCHSCREEN_MAXX, 0, 0);
	input_set_abs_params(input, ABS_Y, TOUCHSCREEN_MINY,
						TOUCHSCREEN_MAXY, 0, 0);
	input_set_abs_params(input, ABS_HAT0X, TOUCHSCREEN_MINX,
						TOUCHSCREEN_MAXX, 0, 0);
	input_set_abs_params(input, ABS_HAT0Y, TOUCHSCREEN_MINY,
						TOUCHSCREEN_MAXY, 0, 0);
	input_set_abs_params(input, ABS_MT_POSITION_X, TOUCHSCREEN_MINX,
						TOUCHSCREEN_MAXX, 0, 0);
	input_set_abs_params(input, ABS_MT_POSITION_Y, TOUCHSCREEN_MINY,
						TOUCHSCREEN_MAXY, 0, 0);
	input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 25, 0, 0);

	input->name = client->name;
	input->id.bustype = BUS_I2C;
	input->dev.parent = &client->dev;

	input->open = pixcir_ts_open;
	input->close = pixcir_ts_close;

	input_set_drvdata(input, tsdata);

	tsdata->client = client;
	tsdata->input = input;

	INIT_WORK(&tsdata->work.work, pixcir_ts_poscheck);

	tsdata->irq = client->irq;

	error = input_register_device(input);
	if (error) {
		dev_err(&client->dev, "Could not register input device\n");
		goto fail2;
	}

	error = gpio_request(TOUCH_INT_PIN, "GPX3");
	if (error) {
			dev_err(&client->dev, "gpio_request failed\n");
			error = -ENODEV;
			goto fail3;

	} else {
		s3c_gpio_cfgpin(TOUCH_INT_PIN, S3C_GPIO_SFN(0x0F));
		s3c_gpio_setpull(TOUCH_INT_PIN, S3C_GPIO_PULL_UP);
	}

#if defined(Unidisplay_9_7inch) || defined(Unidisplay_7inch) \
	|| defined(Unidisplay_7inch)
	Wrbuf = 0xcc;
	if (i2c_master_send(tsdata->client, &Wrbuf, 1) != 1) {
		dev_err(&client->dev, "i2c transfer failed\n");
		error = -ENODEV;
		goto fail3;
	}
#endif
	pixcir_wq = create_singlethread_workqueue("pixcir_wq");
	if (!pixcir_wq) {
		error = -ENOMEM;
		goto fail3;
	}

#ifdef NAS_7inch
	error = request_irq(tsdata->irq, pixcir_ts_isr, IRQF_DISABLED |
				IRQF_TRIGGER_FALLING, client->name, tsdata);
#elif defined Unidisplay_7inch
	error = request_irq(tsdata->irq, pixcir_ts_isr, IRQF_SAMPLE_RANDOM
				, client->name, tsdata);
#endif
	if (error) {
		dev_err(&client->dev, "Failed to request irq %d\n", \
			 tsdata->irq);
		goto fail3;
	}
	if (!error) {
		device_init_wakeup(&client->dev, 1);
		dev_info(&tsdata->client->dev, "probed successfully!\n");
		return 0;
	}
fail3:
	input_unregister_device(input);
	input = NULL;
fail2:
	kfree(tsdata);
fail1:
	dev_set_drvdata(&client->dev, NULL);
fail:
	return error;

}
Exemplo n.º 25
0
static int max517_suspend(struct device *dev)
{
	u8 outbuf = COMMAND_PD;

	return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
}
Exemplo n.º 26
0
static void pixcir_ts_poscheck(struct work_struct *work)
{
	struct pixcir_i2c_ts_data *tsdata = container_of(work,
						struct pixcir_i2c_ts_data,
						work.work);
	unsigned char Rdbuf[13], Wrbuf[1], msglenth;
	int posx1, posy1, posx2, posy2;
	unsigned char touching, oldtouching;
	int ret;
	int z = 50;
	int w = 15;

	if (pixcir_touch_read_gpio())
		goto out;


	memset(Wrbuf, 0, sizeof(Wrbuf));
	memset(Rdbuf, 0, sizeof(Rdbuf));

#ifdef NAS_7inch
	Wrbuf[0] = 0xf9;
	msglenth = 13;
#elif defined MUTTO_7inch
	Wrbuf[0] = 0x02;
	msglenth = 11;
#elif defined NAS_10inch
	Wrbuf[0] = 0x0;
	msglenth = 10;
#elif defined Unidisplay_7inch
	Wrbuf[0] = 0x10;
	msglenth = 9;
#elif defined Unidisplay_9_7inch
	Wrbuf[0] = 0x10;
	msglenth = 9;
#elif defined Touch_key
	Wrbuf[0] = 0x00;
	msglenth = 4;
#endif

	ret = i2c_master_send(tsdata->client, Wrbuf, 1);

	if (ret != 1) {
		dev_err(&tsdata->client->dev,\
				 "Unable to write to i2c touchscreen!\n");
		goto out;
	}

	ret = i2c_master_recv(tsdata->client, Rdbuf, msglenth);

	if (ret != msglenth) {
		dev_err(&tsdata->client->dev, "Unable to read i2c page!\n");
		goto out;
	}


#ifdef NAS_7inch
	touching = Rdbuf[3];
	oldtouching = 0;

	if (touching == 0xff)
		goto out;

	posy1 = ((Rdbuf[5] << 8) | Rdbuf[6]);
	posx1 = ((Rdbuf[7] << 8) | Rdbuf[8]);

	posy2 = ((Rdbuf[9] << 8) | Rdbuf[10]);
	posx2 = ((Rdbuf[11] << 8) | Rdbuf[12]);

	posx1 = posx1 & 0x0fff;
	posy1 = posy1 & 0x0fff;
	posx2 = posx2 & 0x0fff;
	posy2 = posy2 & 0x0fff;

	posy1 = TOUCHSCREEN_MAXY - posy1;
	posy2 = TOUCHSCREEN_MAXY - posy2;

#elif defined MUTTO_7inch
	touching = Rdbuf[0];
	oldtouching = 0;

	posx1 = ((Rdbuf[1] << 8) | Rdbuf[2]);
	posy1 = ((Rdbuf[3] << 8) | Rdbuf[4]);

	posx2 = ((Rdbuf[7] << 8) | Rdbuf[8]);
	posy2 = ((Rdbuf[9] << 8) | Rdbuf[10]);

	posx1 = posx1 & 0x0fff;
	posy1 = posy1 & 0x0fff;
	posx2 = posx2 & 0x0fff;
	posy2 = posy2 & 0x0fff;

#elif defined NAS_10inch
	touching = Rdbuf[0];
	oldtouching = Rdbuf[1];
	posx1 = ((Rdbuf[3] << 8) | Rdbuf[2]);
	posy1 = ((Rdbuf[5] << 8) | Rdbuf[4]);

	posx2 = ((Rdbuf[7] << 8) | Rdbuf[6]);
	posy2 = ((Rdbuf[9] << 8) | Rdbuf[8]);

#elif defined Unidisplay_7inch
	touching = Rdbuf[0];

	posx1 = ((Rdbuf[2] << 8) | Rdbuf[1]);
	posy1 = ((Rdbuf[4] << 8) | Rdbuf[3]);

	posx2 = ((Rdbuf[6] << 8) | Rdbuf[5]);
	posy2 = ((Rdbuf[8] << 8) | Rdbuf[7]);

#elif defined Unidisplay_9_7inch
	touching = Rdbuf[0]&0x03;
	posx1 = ((Rdbuf[2] << 8) | Rdbuf[1]);
	posy1 = ((Rdbuf[4] << 8) | Rdbuf[3]);
	posx2 = ((Rdbuf[6] << 8) | Rdbuf[5]);
	posy2 = ((Rdbuf[8] << 8) | Rdbuf[7]);

	if (touching == 2)
		touching = 1;
	else if (touching == 3)
		touching = 2;

#elif defined Unidisplay_10inch
	touching = Rdbuf[0];
	posx1 = ((Rdbuf[2] << 8) | Rdbuf[1]);
	posy1 = ((Rdbuf[4] << 8) | Rdbuf[3]);

	posx2 = ((Rdbuf[6] << 8) | Rdbuf[5]);
	posy2 = ((Rdbuf[8] << 8) | Rdbuf[7]);
#elif defined Touch_key
	touching = Rdbuf[0];
	oldtouching = Rdbuf[1];
	posx1 = Rdbuf[2];
	posy1 = Rdbuf[3];
#endif
	input_report_key(tsdata->input, BTN_TOUCH, (touching != 0 ? 1 : 0));
	input_report_key(tsdata->input, BTN_2, (touching == 2 ? 1 : 0));

	if (touching) {
		input_report_abs(tsdata->input, ABS_X, posx1);
		input_report_abs(tsdata->input, ABS_Y, posy1);
	}

	if (touching == 2) {
		input_report_abs(tsdata->input, ABS_HAT0X, posx2);
		input_report_abs(tsdata->input, ABS_HAT0Y, posy2);
	}
	if (touching > 2)
		touching = 2;

	if (!(touching)) {
		z = 0;
		w = 0;
	}
	input_report_abs(tsdata->input, ABS_MT_TOUCH_MAJOR, z);
	input_report_abs(tsdata->input, ABS_MT_WIDTH_MAJOR, w);
	input_report_abs(tsdata->input, ABS_MT_POSITION_X, posx1);
	input_report_abs(tsdata->input, ABS_MT_POSITION_Y, posy1);
	input_mt_sync(tsdata->input);

	if (touching == 2) {
		input_report_abs(tsdata->input, ABS_MT_TOUCH_MAJOR, z);
		input_report_abs(tsdata->input, ABS_MT_WIDTH_MAJOR, w);
		input_report_abs(tsdata->input, ABS_MT_POSITION_X, posx2);
		input_report_abs(tsdata->input, ABS_MT_POSITION_Y, posy2);
		input_mt_sync(tsdata->input);
	}
	input_sync(tsdata->input);
out:
	udelay(1000);
	enable_irq(tsdata->irq);
}
Exemplo n.º 27
0
static int hdmi_sii_enable(struct i2c_client *client)
{
	int rc;
	int retries = 10;
	int count;

	rc = i2c_smbus_write_byte_data(client, 0xC7, 0x00);
	if (rc)
		goto enable_exit;

	do {
		msleep(1);
		rc = i2c_smbus_read_byte_data(client, 0x1B);
	} while ((rc != SII9022_DEVICE_ID) && retries--);

	if (rc != SII9022_DEVICE_ID)
		return -ENODEV;

	rc = i2c_smbus_write_byte_data(client, 0x1A, 0x11);
	if (rc)
		goto enable_exit;

	count = ARRAY_SIZE(video_mode_data);
	rc = i2c_master_send(client, video_mode_data, count);
	if (rc != count) {
		rc = -EIO;
		goto enable_exit;
	}

	rc = i2c_smbus_write_byte_data(client, 0x08, 0x20);
	if (rc)
		goto enable_exit;
	count = ARRAY_SIZE(avi_io_format);
	rc = i2c_master_send(client, avi_io_format, count);
	if (rc != count) {
		rc = -EIO;
		goto enable_exit;
	}

	rc = send_i2c_data(client, regset0, ARRAY_SIZE(regset0));
	if (rc)
		goto enable_exit;

	count = ARRAY_SIZE(video_infoframe);
	rc = i2c_master_send(client, video_infoframe, count);
	if (rc != count) {
		rc = -EIO;
		goto enable_exit;
	}

	rc = send_i2c_data(client, regset1, ARRAY_SIZE(regset1));
	if (rc)
		goto enable_exit;

	count = ARRAY_SIZE(misc_infoframe);
	rc = i2c_master_send(client, misc_infoframe, count);
	if (rc != count) {
		rc = -EIO;
		goto enable_exit;
	}

	rc = send_i2c_data(client, regset2, ARRAY_SIZE(regset2));
	if (rc)
		goto enable_exit;

	return 0;
enable_exit:
	printk(KERN_ERR "%s: exited rc=%d\n", __func__, rc);
	return rc;
}
Exemplo n.º 28
0
static int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
				 u8 reg, u8 andmask, u8 ormask)
{
	u8 regandval[2] = {reg, 0};
	int err;

	err = mutex_lock_interruptible(&ab3100->access_mutex);
	if (err)
		return err;

	/* First read out the target register */
	err = i2c_master_send(ab3100->i2c_client, &reg, 1);
	if (err < 0) {
		dev_err(ab3100->dev,
			"write error (maskset send address): %d\n",
			err);
		goto get_maskset_unlock;
	} else if (err != 1) {
		dev_err(ab3100->dev,
			"write error (maskset send address) "
			"%d bytes transferred (expected 1)\n",
			err);
		err = -EIO;
		goto get_maskset_unlock;
	}

	err = i2c_master_recv(ab3100->i2c_client, &regandval[1], 1);
	if (err < 0) {
		dev_err(ab3100->dev,
			"write error (maskset read register): %d\n",
			err);
		goto get_maskset_unlock;
	} else if (err != 1) {
		dev_err(ab3100->dev,
			"write error (maskset read register) "
			"%d bytes transferred (expected 1)\n",
			err);
		err = -EIO;
		goto get_maskset_unlock;
	}

	/* Modify the register */
	regandval[1] &= andmask;
	regandval[1] |= ormask;

	/* Write the register */
	err = i2c_master_send(ab3100->i2c_client, regandval, 2);
	if (err < 0) {
		dev_err(ab3100->dev,
			"write error (write register): %d\n",
			err);
		goto get_maskset_unlock;
	} else if (err != 2) {
		dev_err(ab3100->dev,
			"write error (write register) "
			"%d bytes transferred (expected 2)\n",
			err);
		err = -EIO;
		goto get_maskset_unlock;
	}

	/* All is well */
	err = 0;

 get_maskset_unlock:
	mutex_unlock(&ab3100->access_mutex);
	return err;
}
Exemplo n.º 29
0
static int bcm2079x_probe(struct i2c_client *client,
			   const struct i2c_device_id *id)
{
	int ret;
	int err;
	struct bcm2079x_platform_data *platform_data;
	struct bcm2079x_dev *bcm2079x_dev;
#ifdef DEBUG_BCM2079X_I2C_IRQ
	char tmp[5] = {0x10, 0x20, 0x00, 0x01, 0x00};
#endif
	if (client->dev.of_node) {
		platform_data = devm_kzalloc(&client->dev,
			sizeof(struct bcm2079x_platform_data), GFP_KERNEL);
		if (!platform_data) {
			dev_err(&client->dev, "Failed to allocate memory\n");
			return -ENOMEM;
		}
		err = bcm2079x_parse_dt(&client->dev, platform_data);
		if (err)
			return err;
	} else {
	platform_data = client->dev.platform_data;
	}

	dev_info(&client->dev, "%s, probing bcm2079x driver flags = %x\n",
			 __func__, client->flags);
	if (platform_data == NULL) {
		dev_err(&client->dev, "nfc probe fail\n");
		return -ENODEV;
	}

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(&client->dev, "need I2C_FUNC_I2C\n");
		return -ENODEV;
	}
	ret = gpio_request(platform_data->irq_gpio, "nfc_int");
	if (ret)
		return -ENODEV;
	gpio_direction_input(platform_data->irq_gpio);

	ret = gpio_request(platform_data->en_gpio, "nfc_en");
	if (ret)
		goto err_en;
	gpio_direction_output(platform_data->en_gpio, 0);

	ret = gpio_request(platform_data->wake_gpio, "nfc_wake");
	if (ret)
		goto err_firm;
	gpio_direction_output(platform_data->wake_gpio, 0);

#ifdef DEBUG_BCM2079X_I2C_IRQ
	msleep(100);
	gpio_set_value_cansleep(platform_data->en_gpio, 1);
	msleep(100);
#else
	gpio_set_value_cansleep(platform_data->en_gpio, 0);
#endif
	gpio_set_value_cansleep(platform_data->wake_gpio, 1);

	bcm2079x_dev = kzalloc(sizeof(*bcm2079x_dev), GFP_KERNEL);
	if (bcm2079x_dev == NULL) {
		dev_err(&client->dev,
			"failed to allocate memory for module data\n");
		ret = -ENOMEM;
		goto err_exit;
	}

	bcm2079x_dev->wake_gpio = platform_data->wake_gpio;
	bcm2079x_dev->irq_gpio = platform_data->irq_gpio;
	bcm2079x_dev->en_gpio = platform_data->en_gpio;
	bcm2079x_dev->client = client;

	/* init mutex and queues */
	init_waitqueue_head(&bcm2079x_dev->read_wq);
	mutex_init(&bcm2079x_dev->read_mutex);
	spin_lock_init(&bcm2079x_dev->irq_enabled_lock);

	bcm2079x_dev->bcm2079x_device.minor = MISC_DYNAMIC_MINOR;
	bcm2079x_dev->bcm2079x_device.name = "bcm2079x";
	bcm2079x_dev->bcm2079x_device.fops = &bcm2079x_dev_fops;

	ret = misc_register(&bcm2079x_dev->bcm2079x_device);
	if (ret) {
		dev_err(&client->dev, "misc_register failed\n");
		goto err_misc_register;
	}

	/* wake lock init */
	wake_lock_init(&bcm2079x_dev->nfc_wake_lock,
		WAKE_LOCK_SUSPEND, "nfc_wake_lock");

	/* request irq.  the irq is set whenever the chip has data available
	 * for reading.  it is cleared when all data has been read.
	 */
	 pr_info("\n client irq is %d\n",client->irq);

	dev_info(&client->dev, "requesting IRQ %d with IRQF_NO_SUSPEND\n",
		client->irq);
	ret = request_irq(client->irq, bcm2079x_dev_irq_handler,
		IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name,
		bcm2079x_dev);
	if (ret) {
		dev_err(&client->dev, "request_irq failed\n");
		goto err_request_irq_failed;
	}
	i2c_set_clientdata(client, bcm2079x_dev);
#ifndef DEBUG_BCM2079X_I2C_IRQ
	bcm2079x_dev->irq_enabled = false;
	disable_irq_nosync(bcm2079x_dev->client->irq);
#else
	/* NCI reset test */
	ret = i2c_master_send(bcm2079x_dev->client, tmp, sizeof(tmp));
	if (ret != 5)
		pr_err("%s, i2c write error, NCI rest cmd err = %d\n",
			__func__, ret);
	else
		pr_info("%s, i2c write success!!! ret = %d\n",
			__func__, ret);
#endif
	dev_info(&client->dev,
		 "%s, probing bcm2079x driver exited successfully\n",
		 __func__);
	return 0;

err_request_irq_failed:
	wake_lock_destroy(&bcm2079x_dev->nfc_wake_lock);
	misc_deregister(&bcm2079x_dev->bcm2079x_device);
err_misc_register:
	mutex_destroy(&bcm2079x_dev->read_mutex);
	kfree(bcm2079x_dev);
err_exit:
	gpio_free(platform_data->wake_gpio);
err_firm:
	gpio_free(platform_data->en_gpio);
err_en:
	gpio_free(platform_data->irq_gpio);
	return ret;
}
Exemplo n.º 30
0
static void epen_checksum_read_atBoot(struct wacom_i2c *wac_i2c)
{
	int ret;
	int val;
	int i,j;
	int retry = 3;
	unsigned char data[6] = {0,};

	{
		disable_irq(wac_i2c->client->irq);

		data[0] = COM_CHECKSUM;

		while( retry-- )
		{
			ret = i2c_master_send(wac_i2c->client, &data[0], 1);
			if( ret < 0 ){
				printk(KERN_DEBUG "[E-PEN] i2c fail, retry, %d\n", __LINE__);
				continue;
			}

			msleep(200);

			ret = i2c_master_recv(wac_i2c->client, data, 5);
			if( ret < 0 ){
				printk(KERN_DEBUG "[E-PEN] i2c fail, retry, %d\n", __LINE__);
				continue;
			}
			else if( data[0] == 0x1f )
				break;

			printk(KERN_DEBUG "[E-PEN] checksum retry\n");
		}

		if (ret >= 0) {
			printk(KERN_DEBUG "[E-PEN] received checksum %x, %x, %x, %x, %x\n", 
								data[0], data[1], data[2], data[3], data[4]);
			
			for( j = 0 ; j < 5; j++ ){
				Firmware_checksum_backup[j] = data[j];
			}
			
		}

		for( i = 0 ; i < 5; ++i ) {
			if( data[i] != Firmware_checksum[i] ){
				printk(KERN_DEBUG "[E-PEN] checksum fail %dth %d %d\n", i, data[i], Firmware_checksum[i]);
				break;
			}
		}
		if( i == 5 )
			epen_checksum_result = true;
		else
			epen_checksum_result = false;

		enable_irq(wac_i2c->client->irq);

		printk(KERN_DEBUG "[E-PEN] %s, result %d\n", __func__, epen_checksum_result);
	}

}