コード例 #1
0
ファイル: ami304.c プロジェクト: Axelfox/2.6.35
static int AMI304_ReadSensorData(char *buf, int bufsize)
{
	char cmd;
	int mode = 0;
	unsigned char databuf[10] = {0,};
	int res = 0;

	if ((!buf)||(bufsize<=80))
		return -1;

	if (!ami304_i2c_client) {
		*buf = 0;
		return -2;
	}

	read_lock(&ami304_data.lock);
	mode = ami304_data.mode;
	read_unlock(&ami304_data.lock);

	databuf[0] = AMI304_REG_CTRL3;
	databuf[1] = AMI304_CTRL3_FORCE_BIT;
	res = i2c_master_send(ami304_i2c_client, databuf, 2);	
	if (res <= 0) 
		goto exit_AMI304_ReadSensorData;
	//udelay(700);
	msleep(1);
	// We can read all measured data in once
	cmd = AMI304_REG_DATAXH;
	res = i2c_master_send(ami304_i2c_client, &cmd, 1);	
	if (res <= 0) 
		goto exit_AMI304_ReadSensorData;
//	udelay(20);
	res = i2c_master_recv(ami304_i2c_client, &(databuf[0]), 6);
	if (res <= 0) 
		goto exit_AMI304_ReadSensorData;

	sprintf(buf, "%02x %02x %02x %02x %02x %02x", 
			databuf[0], databuf[1], databuf[2], 
			databuf[3], databuf[4], databuf[5]);

	if (AMI304_DEBUG_DEV_STATUS & ami304_debug_mask) {
		int mx, my, mz;
		mx = my = mz = 0;

		mx = (int)(databuf[0] | (databuf[1] << 8));
		my = (int)(databuf[2] | (databuf[3] << 8));
		mz = (int)(databuf[4] | (databuf[5] << 8));

		if (mx>32768)  mx = mx-65536;
		if (my>32768)  my = my-65536;
		if (mz>32768)  mz = mz-65536;

		AMID("Magnetic Raw Data: X=%d, Y=%d, Z=%d\n", mx, my, mz);
	}

exit_AMI304_ReadSensorData:
	if (res <= 0) {
		if (printk_ratelimit()) {
			AMIE("I2C error: ret value=%d\n", res);
		}
		return -3;
	}
	return 0;
}
コード例 #2
0
ファイル: pn547_lge.c プロジェクト: Vagelis1608/-V-_Kernel_2
static ssize_t pn547_dev_read(struct file *filp, char __user *buf,
        size_t count, loff_t *offset)
{
    struct pn547_dev *pn547_dev = filp->private_data;
    static char tmp[MAX_BUFFER_SIZE];
    int ret;
    static bool isFinalPacket = true;
    unsigned long flags;

    if (count > MAX_BUFFER_SIZE)
        count = MAX_BUFFER_SIZE;

    //pr_err("%s : reading %zu bytes.\n", __func__, count); // for debug

wait:
    if (isFinalPacket == true) {
        ret = wait_event_interruptible_timeout(pn547_dev->read_wq, gpio_get_value(pn547_dev->irq_gpio), msecs_to_jiffies(NFC_TIMEOUT_MS));
        if (ret == 0) {
            pr_err("%s: event_interruptible!\n", __func__); // NFC_TIMEOUT_MS for debug
            spin_lock_irqsave(&pn547_dev->irq_enabled_lock, flags);
            if (sIsWakeLocked == true) {
                wake_unlock(&nfc_wake_lock);
                sIsWakeLocked = false;
            }
            spin_unlock_irqrestore(&pn547_dev->irq_enabled_lock, flags);
            //pr_err("%s: wake_unlock\n", __func__); // for debug
            isFinalPacket = false;
            goto wait;
        }
    }
    else {
        ret = wait_event_interruptible(pn547_dev->read_wq, gpio_get_value(pn547_dev->irq_gpio));
        isFinalPacket = true;
    }

    if (ret == -ERESTARTSYS) {
        //pr_err("%s: pass wait_event_interruptible by signal. Skip!\n", __func__); // for debug
        return -0xFF;
    }
    else {
        //pr_err("%s: pass wait_event_interruptible by condition (%d)\n", __func__, gpio_get_value(pn547_dev->irq_gpio)); // for debug
    }

    /* Read data */
    mutex_lock(&pn547_dev->read_mutex);
    memset(tmp, 0x00, MAX_BUFFER_SIZE);
    ret = i2c_master_recv(pn547_dev->client, tmp, count);
    mutex_unlock(&pn547_dev->read_mutex);

    if (count == 0) {
        pr_err("%s: reading 0 bytes! skip! (%d)\n", __func__, ret);
        return ret;
    }

    if (ret < 0) {
        pr_err("%s: i2c_master_recv returned %d\n", __func__, ret);
        return ret;
    }
    if (ret > count) {
        pr_err("%s: received too many bytes from i2c (%d)\n",
            __func__, ret);
        return -EIO;
    }
    if (copy_to_user(buf, tmp, ret)) {
        pr_warning("%s : failed to copy to user space\n", __func__);
        return -EFAULT;
    }

    //pr_err("%s: i2c_master_recv success (%d)\n", __func__, ret); // for debug
    return ret;
}
コード例 #3
0
ファイル: ssp_firmware.c プロジェクト: AndreiLux/Perseus-S3
static int check_bootloader(struct i2c_client *client, unsigned int uState)
{
	u8 uVal;
	u8 uTemp;

recheck:
	if (i2c_master_recv(client, &uVal, 1) != 1)
		return -EIO;

	if (uVal & 0x20) {
		if (i2c_master_recv(client, &uTemp, 1) != 1) {
			pr_err("[SSP]: %s - i2c recv fail\n", __func__);
			return -EIO;
		}

		if (i2c_master_recv(client, &uTemp, 1) != 1) {
			pr_err("[SSP]: %s - i2c recv fail\n", __func__);
			return -EIO;
		}

		uVal &= ~0x20;
	}

	if ((uVal & 0xF0) == BL_APP_CRC_FAIL) {
		pr_info("[SSP] SSP_APP_CRC_FAIL - There is no bootloader.\n");
		if (i2c_master_recv(client, &uVal, 1) != 1) {
			pr_err("[SSP]: %s - i2c recv fail\n", __func__);
			return -EIO;
		}

		if (uVal & 0x20) {
			if (i2c_master_recv(client, &uTemp, 1) != 1) {
				pr_err("[SSP]: %s - i2c recv fail\n", __func__);
				return -EIO;
			}

			if (i2c_master_recv(client, &uTemp, 1) != 1) {
				pr_err("[SSP]: %s - i2c recv fail\n", __func__);
				return -EIO;
			}

			uVal &= ~0x20;
		}
	}

	switch (uState) {
	case BL_WAITING_BOOTLOAD_CMD:
	case BL_WAITING_FRAME_DATA:
		uVal &= ~BL_BOOT_STATUS_MASK;
		break;
	case BL_FRAME_CRC_PASS:
		if (uVal == BL_FRAME_CRC_CHECK)
			goto recheck;
		break;
	default:
		return -EINVAL;
	}

	if (uVal != uState) {
		pr_err("[SSP]: %s - Unvalid bootloader mode state\n", __func__);
		return -EINVAL;
	}

	return 0;
}
コード例 #4
0
static ssize_t bcm2079x_dev_read(struct file *filp, char __user *buf,
				  size_t count, loff_t *offset)
{
	struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
	unsigned char tmp[MAX_BUFFER_SIZE];
	int total, len, ret;

	total = 0;
	len = 0;

	if (bcm2079x_dev->count_irq > 0)
		bcm2079x_dev->count_irq--;

	bcm2079x_dev->count_read++;
	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	mutex_lock(&bcm2079x_dev->read_mutex);

	/** Read the first 4 bytes to include the length of the NCI or HCI.
	**/
	ret = i2c_master_recv(bcm2079x_dev->client, tmp, 4);
	if (ret == 4) {
		total = ret;
		/** First byte is the packet type
		**/
		switch (tmp[0]) {
		case PACKET_TYPE_NCI:
			len = tmp[PACKET_HEADER_SIZE_NCI-1];
			break;

		case PACKET_TYPE_HCIEV:
			len = tmp[PACKET_HEADER_SIZE_HCI-1];
			if (len == 0)
				/* Since payload is 0, decrement total size
				(from 4 to 3) */
				total--;
			else
				/*First byte of payload is in tmp[3] already */
				len--;
			break;
		default:
			/*Unknown packet byte */
			len = 0;
			break;
		} /* switch*/

		/** make sure full packet fits in the buffer **/
		if (len > 0 && (len + total) <= count) {
			/** read the remainder of the packet. **/
			ret = i2c_master_recv(bcm2079x_dev->client, tmp+total, len);
			if (ret == len)
				total += len;
		} /* if */
	} /* if */

	mutex_unlock(&bcm2079x_dev->read_mutex);

	if (total > count || copy_to_user(buf, tmp, total)) {
		dev_err(&bcm2079x_dev->client->dev,
			"failed to copy to user space, total = %d\n", total);
		total = -EFAULT;
		bcm2079x_dev->error_read++;
	}

	return total;
}
コード例 #5
0
ファイル: pn544.c プロジェクト: jiankeliu5/v889d_ics_3.0
/* ------------------------------------------------------------------------- */
static ssize_t pn544_dev_read (struct file *filp, char __user *buf, size_t count,
                              loff_t *offset)
{
   struct pn544_dev  *pn544 = (struct pn544_dev *)filp->private_data;
   struct i2c_client *client = (struct i2c_client *)pn544->client;
   char *tmp;
   int ret;
 //  int irq_gpio = irq_to_gpio(client->irq);
  int irq_gpio = INT_TO_MSM_GPIO(client->irq);

   if (count > MAX_BUFFER_SIZE) {
      count = MAX_BUFFER_SIZE;
   }

   tmp = kmalloc(count,GFP_KERNEL);
   if (tmp == NULL) {
      return -ENOMEM;
   }

#ifdef ZTE_NFC_DEBUG
   printk("pn544-dev: reading %zu bytes.\n", count);
#else
   pr_debug("pn544-dev: reading %zu bytes.\n", count);
#endif

   /* Lock semaphore */
   if (down_interruptible(&pn544->sem)) {
      return -ERESTARTSYS;
   }
   /* Wait for IRQ if not already pending */
   if(pn544_dev->int_active_low==1)
   {
        while (gpio_get_value(irq_gpio)) {
           /* Not ready to read data, release semaphore */
           up(&pn544->sem);
           /* Handle non-blocking calls */
           if (filp->f_flags & O_NONBLOCK) {
              return -EAGAIN;
           }
     
     #ifdef ZTE_NFC_DEBUG
         printk("pn544-dev: wait for incoming data1.\n");
     #else
           pr_debug("pn544-dev: wait for incoming data1.\n");
     #endif

#if 0
          /* Sleep until the IRQ comes */
         /*这个函数睡眠之后不会被调度,需要在中断或定时器中wake_up_interruptible()	  
             之后才会被调度去判决gpio_get_value(irq_gpio)!=0  */
        if (wait_event_interruptible(pn544->read_queue, (gpio_get_value(irq_gpio)==0))) {
                             printk(KERN_ERR"pn544-dev: wait for interrupt error1.\n");
				 return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
              	}
#else
	 if(wait_event_interruptible_timeout(pn544->read_queue, 
				(gpio_get_value(irq_gpio)==0), 
				msecs_to_jiffies(5000))<=0){
				
		printk(KERN_ERR"pn544-dev: wait for interrupt error1.\n");
		return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
     	}
#endif
     
           /* Loop, but first reacquire the lock (to avoid multiple read concurrency) */
           if (down_interruptible(&pn544->sem)) {
		printk(KERN_ERR"pn544-dev: wait for interrupt sem error1.\n");   	
              return -ERESTARTSYS;
           }
        }
   }
   else
   {
           while (!gpio_get_value(irq_gpio)) {
           /* Not ready to read data, release semaphore */
           up(&pn544->sem);
           /* Handle non-blocking calls */
           if (filp->f_flags & O_NONBLOCK) {
              return -EAGAIN;
           }
     
     #ifdef ZTE_NFC_DEBUG
          printk("pn544-dev: wait for incoming data2.\n");
     #else
           pr_debug("pn544-dev: wait for incoming data2.\n");
     #endif

#if 1  //NXP CODE
          /* Sleep until the IRQ comes */
         /*这个函数睡眠之后不会被调度,需要在中断或定时器中wake_up_interruptible()	  
             之后才会被调度去判决gpio_get_value(irq_gpio)!=0  */
         if (wait_event_interruptible(pn544->read_queue, (gpio_get_value(irq_gpio)!=0))) {
                             printk(KERN_ERR"pn544-dev: wait for interrupt error2.\n");
				 return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
     		}
#else
         if(wait_event_interruptible_timeout(pn544->read_queue, 
				(gpio_get_value(irq_gpio)!=0), 
				msecs_to_jiffies(5000))<=0){
		printk(KERN_ERR"pn544-dev: wait for interrupt error2.\n");
		return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
     	}
#endif
     
           /* Loop, but first reacquire the lock (to avoid multiple read concurrency) */
           if (down_interruptible(&pn544->sem)) {
		printk(KERN_ERR"pn544-dev: wait for interrupt sem error2.\n");   
              return -ERESTARTSYS;
           }
        }
  }

   /* Read data */
   ret = i2c_master_recv(client, tmp, count);
   if (ret >= 0) {
      ret = copy_to_user(buf, tmp, count)?-EFAULT:ret;

#ifdef ZTE_NFC_DEBUG 
      printk("pn544_dev_read: received ");
      printk_buffer(tmp, count);
      printk("\n");
#else	
      pr_debug("pn544_dev_read: received ");
      pr_debug_buffer(tmp, count);
      pr_debug("\n");
#endif	  
   }
   else if (ret < 0) {
      printk(KERN_WARNING "pn544_dev: failed to read from i2c (error code  %d)\n", ret);
   }

   /* Release semaphore */
   up (&pn544->sem);
   kfree(tmp);

   return ret;
}
コード例 #6
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);
	}

}
コード例 #7
0
ファイル: pn544_lge.c プロジェクト: Ntemis/LG_X3_P880_v20a
static ssize_t pn544_dev_read(struct file *filp, char __user *buf,
		size_t count, loff_t *offset)
{
	struct pn544_dev *pn544_dev = filp->private_data;
	static char tmp[MAX_BUFFER_SIZE];
	int ret;
	int irq_gpio_val = 0;

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	pr_debug("%s : reading %zu bytes.\n", __func__, count);

	mutex_lock(&pn544_dev->read_mutex);

	if (!stReadIntFlag) {
		irq_gpio_val = gpio_get_value(pn544_dev->irq_gpio);
		dprintk(PN544_DRV_NAME ":IRQ GPIO = %d\n", irq_gpio_val);
		if (irq_gpio_val == 0) {
			if (filp->f_flags & O_NONBLOCK) {
				pr_err(PN544_DRV_NAME ":f_falg has O_NONBLOCK. EAGAIN!\n");
				ret = -EAGAIN;
				goto fail;
			}

			pn544_dev->irq_enabled = true;
#ifdef LGE_NFC_READ_IRQ_MODIFY
		do_reading=0;//DY_TEST
#endif
//                                                             
#if !defined(LGE_NFC_HW_QCT_MSM8660)
			enable_irq_wake(pn544_get_irq_pin(pn544_dev));
#endif
			enable_irq(pn544_get_irq_pin(pn544_dev));
#ifdef LGE_NFC_READ_IRQ_MODIFY
		ret = wait_event_interruptible(pn544_dev->read_wq, do_reading);
#else
			ret = wait_event_interruptible(pn544_dev->read_wq,
					gpio_get_value(pn544_dev->irq_gpio));
#endif
			pn544_disable_irq(pn544_dev);
			//dprintk(PN544_DRV_NAME ":wait_event_interruptible : %d\n", ret);
#ifdef LGE_NFC_READ_IRQ_MODIFY
        //DY_TEST
        if(cancle_read == true)
        {
            cancle_read = false;
            ret = -1;
            goto fail;
        }
#endif
			if (ret)
				goto fail;
		}
	}

	/* Read data */
	memset(tmp, 0x00, MAX_BUFFER_SIZE);
	ret = i2c_master_recv(pn544_dev->client, tmp, count);
	mutex_unlock(&pn544_dev->read_mutex);

	if (ret < 0) {
		pr_err("%s: i2c_master_recv returned %d\n", __func__, ret);
		return ret;
	}
	if (ret > count) {
		pr_err("%s: received too many bytes from i2c (%d)\n",
			__func__, ret);
		return -EIO;
	}
	if (copy_to_user(buf, tmp, ret)) {
		pr_warning("%s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}

	return ret;

fail:
	mutex_unlock(&pn544_dev->read_mutex);
	return ret;
}
コード例 #8
0
static ssize_t pn544_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset)
{
	struct pn544_dev *pn544_dev = filp->private_data;
	int ret,i;
	char tmp[MAX_BUFFER_SIZE];

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	printk("pn544 %s : reading %zu bytes.\n", __func__, count);

	mutex_lock(&pn544_dev->read_mutex);

	if (!mt_get_gpio_in(IRQ_PIN)) {
        
		printk("pn544 read no event\n");
		
		if (filp->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			goto fail;
		}
		
		printk("pn544 read wait event\n");
		
		pn544_dev->irq_enabled = true;
		mt65xx_eint_unmask(EINT_NUM);
		ret = wait_event_interruptible(pn544_dev->read_wq, mt_get_gpio_in(IRQ_PIN));

		pn544_disable_irq(pn544_dev);

		if (ret) {
			printk("pn544 read wait event error\n");
			goto fail;
		}
	}

	/* Read data */
	ret = i2c_master_recv(pn544_dev->client, tmp, count);
	mutex_unlock(&pn544_dev->read_mutex);

	if (ret < 0) {
		pr_err("pn544 %s: i2c_master_recv returned %d\n", __func__, ret);
		return ret;
	}
	if (ret > count) {
		pr_err("pn544 %s: received too many bytes from i2c (%d)\n", __func__, ret);
		return -EIO;
	}
	
	if (copy_to_user(buf, tmp, ret)) {
		pr_warning("pn544 %s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}

	printk("pn544 IFD->PC:");
	for(i = 0; i < ret; i++) {
		printk(" %02X", tmp[i]);
	}
	printk("\n");

	return ret;

fail:
	mutex_unlock(&pn544_dev->read_mutex);
	return ret;
}
コード例 #9
0
int pn544_i2c_read(struct i2c_client *client, u8 *buf, int buflen) 
{ 
	int ret=0; 
	u8 len=0; 
	int i = 0;

	PN544_DEBUG("%s:entered\n",__func__);

	/* You could read a packet in one go, but then you'd need to read 
	 * max size and rest would be 0xff fill, so we do split reads. 
	 */ 

	ret = i2c_master_recv(client, &len, sizeof(len)); 
	PN544_DEBUG("%s:recv1: ret=%d,len=%d\n",
		__func__, ret , len); 

	if (0==pn544_use_read_irq)
	{
		/* if we do not use irq when the data is not ready we need to delay 
		 * sometime to receive again
		 */
		if(len==PN544_NODATA)
		{
			mdelay(10);
			ret = i2c_master_recv(client, &len, sizeof(len)); 
			PN544_DEBUG("%s:recv2: ret=%d,len=%d\n",
				__func__, ret , len); 
		}
	}

	if (ret != 1) 
		return -EREMOTEIO; 

	if(PN544_NODATA == len)
		return -EREMOTEIO; 

	/* we make sure the length is legal for the LLC Layer*/
	if (len < PN544_LLC_HCI_OVERHEAD) 
		len = PN544_LLC_HCI_OVERHEAD; 
	else if (len > (PN544_MSG_MAX_SIZE - 1)) 
		len = PN544_MSG_MAX_SIZE - 1; 

	if (1 + len > buflen) /* len+(data+crc16) */ 
		return -EMSGSIZE; 

	buf[0] = len; 

	ret = i2c_master_recv(client, buf + 1, len); 

	if (ret != len) 
		return -EREMOTEIO; 

	usleep_range(3000, 6000); 
	PN544_DEBUG("IFD->PC:  ");
	for(i = 0; i < len; i++)
	{
		PN544_DEBUG("%02X", buf[i]);
	}
	PN544_DEBUG("\n");
	return ret + 1; 
} 
コード例 #10
0
int wacom_i2c_coord(struct wacom_i2c *wac_i2c)
{
	bool prox = false;
	int ret = 0;
	u8 *data;
	int rubber, stylus;
	static u16 x, y, pressure;
	static u16 tmp;
	int rdy = 0;

	data = wac_i2c->wac_feature->data;
	ret = i2c_master_recv(wac_i2c->client, data, COM_COORD_NUM);

	if (ret >= 0) {
#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
		pr_debug("[E-PEN] %x, %x, %x, %x, %x, %x, %x\n",
			 data[0], data[1], data[2], data[3], data[4], data[5],
			 data[6]);
#endif

		if (data[0] & 0x80) {
			/* enable emr device */
			if (!wac_i2c->pen_prox) {

				wac_i2c->pen_prox = 1;

				if (data[0] & 0x40)
					wac_i2c->tool = BTN_TOOL_RUBBER;
				else
					wac_i2c->tool = BTN_TOOL_PEN;
#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
				pr_debug("[E-PEN] is in(%d)\n", wac_i2c->tool);
#endif
			}

			prox = !!(data[0] & 0x10);
			stylus = !!(data[0] & 0x20);
			rubber = !!(data[0] & 0x40);
			rdy = !!(data[0] & 0x80);

			x = ((u16) data[1] << 8) + (u16) data[2];
			y = ((u16) data[3] << 8) + (u16) data[4];
			pressure = ((u16) data[5] << 8) + (u16) data[6];

#ifdef WACOM_IMPORT_FW_ALGO
			/* Change Position to Active Area */
			if (x <= origin_offset[0])
				x = 0;
			else
				x = x - origin_offset[0];
			if (y <= origin_offset[1])
				y = 0;
			else
				y = y - origin_offset[1];
#ifdef COOR_WORK_AROUND
			wacom_i2c_coord_offset(&x, &y);
			wacom_i2c_coord_average(&x, &y, rdy);
#endif
#endif

			if (wac_i2c->wac_pdata->x_invert)
				x = wac_i2c->wac_feature->x_max - x;
			if (wac_i2c->wac_pdata->y_invert)
				y = wac_i2c->wac_feature->y_max - y;

			if (wac_i2c->wac_pdata->xy_switch) {
				tmp = x;
				x = y;
				y = tmp;
			}
#ifdef COOR_WORK_AROUND
			/* Add offset */
			x = x + tilt_offsetX[user_hand][screen_rotate];
			y = y + tilt_offsetY[user_hand][screen_rotate];
#endif
			if (wacom_i2c_coord_range(&x, &y)) {
				input_report_abs(wac_i2c->input_dev, ABS_X, x);
				input_report_abs(wac_i2c->input_dev, ABS_Y, y);
				input_report_abs(wac_i2c->input_dev,
						 ABS_PRESSURE, pressure);
				input_report_key(wac_i2c->input_dev,
						 BTN_STYLUS, stylus);
				input_report_key(wac_i2c->input_dev, BTN_TOUCH,
						 prox);
				input_report_key(wac_i2c->input_dev,
						 wac_i2c->tool, 1);
				input_sync(wac_i2c->input_dev);

				if (prox && !wac_i2c->pen_pressed) {
#ifdef SEC_DVFS_LOCK
					set_dvfs_lock(wac_i2c, true);
#endif
#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
					printk(KERN_DEBUG
						"[E-PEN] is pressed(%d,%d,%d)(%d)\n",
						x, y, pressure, wac_i2c->tool);
#else
					printk(KERN_DEBUG "[E-PEN] pressed\n");
#endif

				} else if (!prox && wac_i2c->pen_pressed) {
#ifdef SEC_DVFS_LOCK
					set_dvfs_lock(wac_i2c, false);
#endif
#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
					printk(KERN_DEBUG
						"[E-PEN] is released(%d,%d,%d)(%d)\n",
						x, y, pressure, wac_i2c->tool);
#else
					printk(KERN_DEBUG "[E-PEN] released\n");
#endif
				}

				wac_i2c->pen_pressed = prox;

#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
				if (stylus && !wac_i2c->side_pressed)
					printk(KERN_DEBUG "[E-PEN] side on");
				else if (!stylus && wac_i2c->side_pressed)
					printk(KERN_DEBUG "[E-PEN] side off");
#endif
				wac_i2c->side_pressed = stylus;
			}
#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
			else
			   printk("[E-PEN] raw data x=0x%x, y=0x%x\n",
			   x, y);
#endif
		} else {
#ifdef COOR_WORK_AROUND
			/* enable emr device */
			wacom_i2c_coord_average(0, 0, 0);
#endif

			if (wac_i2c->pen_prox) {
				/* input_report_abs(wac->input_dev,
				ABS_X, x); */
				/* input_report_abs(wac->input_dev,
				ABS_Y, y); */
				input_report_abs(wac_i2c->input_dev,
						 ABS_PRESSURE, 0);
				input_report_key(wac_i2c->input_dev,
						 BTN_STYLUS, 0);
				input_report_key(wac_i2c->input_dev, BTN_TOUCH,
						 0);
				input_report_key(wac_i2c->input_dev,
						 wac_i2c->tool, 0);
				input_sync(wac_i2c->input_dev);

#if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER)
				if (wac_i2c->pen_pressed
					|| wac_i2c->side_pressed)
					printk(KERN_DEBUG "[E-PEN] is out");
				else
					printk(KERN_DEBUG "[E-PEN] is out");
#endif
			}
			wac_i2c->pen_prox = 0;
			wac_i2c->pen_pressed = 0;
			wac_i2c->side_pressed = 0;

#ifdef SEC_DVFS_LOCK
			set_dvfs_lock(wac_i2c, false);
#endif
		}
	} else {
		printk(KERN_ERR "[E-PEN]: failed to read i2c\n");
		return -1;
	}

	return 0;
}
コード例 #11
0
static void adp5588_work_func( struct work_struct *work)
{
    int rc,i;
    uint8_t reg=ADP5588_REG_KEY_EVENTA;
    struct adp5588_keypad_data *kp = container_of(work, struct adp5588_keypad_data, work);
    struct i2c_client *client=kp->client;
    uint8_t  scan_code;


    /* set  read address */

    I2C_MUTEX_LOCK;

    if ((rc = i2c_master_send(client, &reg, 1)) <0)
    {
        dev_err(&client->dev," %s(%s):i2c_master_send error %d\n",
                __FILE__, __FUNCTION__, rc);
        /* I2c Write error  .  exit now , enable IRQ and read again if IRQ pin  still low */

    } else {

        /* read scancodes until queue is empty */
        i=0;
        do {
            scan_code =ADP5588_KEY_FIFO_EMPTY;

            if ((rc = i2c_master_recv(client, &scan_code,1 )) < 0 )
            {
                dev_err(&client->dev," %s(%s):i2c_master_recv error %d\n",
                        __FILE__, __FUNCTION__, rc);
                break;
            }

            if( scan_code != ADP5588_KEY_FIFO_EMPTY )
            {
                kp->last_key = ADP5588_KEY_CODE & scan_code ;
                kp->last_key_state  = !!(ADP5588_KEY_RELEASE & scan_code);

                dev_dbg(&client->dev,"ADP5588 got scancode %d ,keycode 0x%x ( %d ) state %d \n",

                        scan_code, kp->last_key, kp->last_key,kp->last_key_state );
                if(  kp->last_key == ADP5588_GPIO_KEY )
                {
                    /* got   RINGER/SILENCE  switch event */
                    adp5588_data.ringer_switch = kp->last_key_state;
                    switch_set_state(&adp5588_data.sw_mute_dev, !adp5588_data.ringer_switch);
                } else {
                    /* got   regular key event */
                    input_report_key(kp->input_dev, kp->last_key, kp->last_key_state);
                }

                //  Sync is removed.  It does not required  for key event
                //	  input_sync(kp->input_dev);
            } else  if( i == 0 ) { /*IRQ without the code ? , must be  key release  HW problem , Wait  5ms  */

                clk_busy_wait(5000);
            }

        } while( scan_code && (i++ <10) );
    }
    I2C_MUTEX_UNLOCK;

    /* Clear IRQ and enable it */
    if (kp->use_irq) {
        if ( adp5588_clear_irq(client)<0)
        {   /* I2c Problem , do not enable IRQ but wait 1 sec */
            hrtimer_start(&kp->timer, ktime_set(1,0), HRTIMER_MODE_REL);
        } else  enable_irq(client->irq);
    }

}
コード例 #12
0
ファイル: i2c.c プロジェクト: Chong-Li/cse522
static int fdp_nci_i2c_read(struct fdp_i2c_phy *phy, struct sk_buff **skb)
{
	int r, len;
	u8 tmp[FDP_NCI_I2C_MAX_PAYLOAD], lrc, k;
	u16 i;
	struct i2c_client *client = phy->i2c_dev;

	*skb = NULL;

	/* Read the length packet and the data packet */
	for (k = 0; k < 2; k++) {

		len = phy->next_read_size;

		r = i2c_master_recv(client, tmp, len);
		if (r != len) {
			dev_dbg(&client->dev, "%s: i2c recv err: %d\n",
				__func__, r);
			goto flush;
		}

		/* Check packet integruty */
		for (lrc = i = 0; i < r; i++)
			lrc ^= tmp[i];

		/*
		 * LRC check failed. This may due to transmission error or
		 * desynchronization between driver and FDP. Drop the paquet
		 * and force resynchronization
		 */
		if (lrc) {
			dev_dbg(&client->dev, "%s: corrupted packet\n",
				__func__);
			phy->next_read_size = 5;
			goto flush;
		}

		/* Packet that contains a length */
		if (tmp[0] == 0 && tmp[1] == 0) {
			phy->next_read_size = (tmp[2] << 8) + tmp[3] + 3;
		} else {
			phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD;

			*skb = alloc_skb(len, GFP_KERNEL);
			if (*skb == NULL) {
				r = -ENOMEM;
				goto flush;
			}

			memcpy(skb_put(*skb, len), tmp, len);
			fdp_nci_i2c_dump_skb(&client->dev, "fdp_rd", *skb);

			fdp_nci_i2c_remove_len_lrc(*skb);
		}
	}

	return 0;

flush:
	/* Flush the remaining data */
	if (i2c_master_recv(client, tmp, sizeof(tmp)) < 0)
		r = -EREMOTEIO;

	return r;
}
コード例 #13
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, retry;
	int sleep_timing;
	int end_data;
	int emission_time;
	int ack_pin_onoff;
#ifdef DEBUG
	u8 buf[8];
#endif
	if (count_number >= 100)
		count_number = 0;

	count_number++;
	data->on_off = 1;
	irda_vdd_onoff(1);

	gpio_set_value(data->pdata->irda_poweron, 0);
	data->pdata->ir_wake_en(data->pdata, 0);
	msleep(100);
	gpio_set_value(data->pdata->irda_poweron, 1);
	data->pdata->ir_wake_en(data->pdata,1);
	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);
	msleep(125);

	printk(KERN_INFO "%s: total buf_size: %d\n", __func__, buf_size);
#ifdef DEBUG
	ret = i2c_master_recv(client, buf, MC96_READ_LENGTH);
	if (ret < 0)
		printk(KERN_CRIT "%s: I2C read err %d\n", __func__, ret);

	print_hex_dump(KERN_CRIT, "irda: IRDA Master Rx: ", 16, 1,
				DUMP_PREFIX_ADDRESS, buf, 8, 1);
#endif
	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);
	}

	msleep(10);
	ack_pin_onoff = 0;
	for(retry = 0; retry < 10; retry++) {
		if (gpio_get_value(data->pdata->irda_irq_gpio)) {
			if(retry == 9) {
			printk(KERN_INFO "%s : %d Checksum NG!\n",
				__func__, count_number);
			}
			ack_pin_onoff = 1;
			msleep(3);
		} else {
			printk(KERN_INFO "%s : %d Checksum OK!\n",
				__func__, count_number);
			ack_pin_onoff = 2;
			break;
		}
	}
	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);
	for(retry = 0; retry < 30; retry++) {
		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;
			break;
		} else {
			if(retry == 29) {
			printk(KERN_INFO "%s : %d Sending IR NG!\n",
					__func__, count_number);
			}
			ack_pin_onoff = 2;
			msleep(65);
		}
	}

	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_poweron, 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);
}
コード例 #14
0
static int cypress_touchkey_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct input_dev *input_dev;
	struct cypress_touchkey_devdata *devdata;
	u8 data[3];
	int err;
	int cnt;

	if (!dev->platform_data) {
		dev_err(dev, "%s: Platform data is NULL\n", __func__);
		return -EINVAL;
	}

	devdata = kzalloc(sizeof(*devdata), GFP_KERNEL);
	if (devdata == NULL) {
		dev_err(dev, "%s: failed to create our state\n", __func__);
		return -ENODEV;
	}

	devdata->client = client;
	i2c_set_clientdata(client, devdata);

	devdata->pdata = client->dev.platform_data;
	if (!devdata->pdata->keycode) {
		dev_err(dev, "%s: Invalid platform data\n", __func__);
		err = -EINVAL;
		goto err_null_keycodes;
	}

	strlcpy(devdata->client->name, DEVICE_NAME, I2C_NAME_SIZE);

	input_dev = input_allocate_device();
	if (!input_dev) {
		err = -ENOMEM;
		goto err_input_alloc_dev;
	}

	devdata->input_dev = input_dev;
	dev_set_drvdata(&input_dev->dev, devdata);
	input_dev->name = DEVICE_NAME;
	input_dev->id.bustype = BUS_HOST;

	for (cnt = 0; cnt < devdata->pdata->keycode_cnt; cnt++)
		input_set_capability(input_dev, EV_KEY,
					devdata->pdata->keycode[cnt]);

	devdata->is_powering_on = true;

	devdata->pdata->touchkey_onoff(TOUCHKEY_ON);

	err = i2c_master_recv(client, data, sizeof(data));
	if (err < sizeof(data)) {
		if (err >= 0)
			err = -EIO;
		dev_err(dev, "%s: error reading hardware version\n", __func__);
		goto err_read;
	}

	dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__,
				data[1], data[2]);

	if (data[1] != 0xa || data[2] < 0x9)
		input_dev->open = cypress_touchkey_open;

	err = input_register_device(input_dev);
	if (err)
		goto err_input_reg_dev;

	set_device_params(devdata, data);

	err = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
	if (err) {
		dev_err(dev, "%s: touch keypad backlight on failed\n",
				__func__);
		/* The device may not be responding because of bad firmware
		 * Allow the firmware to be reflashed if it needs to be
		 */
		if (!input_dev->open)
			goto err_backlight_on;
	}

	err = request_threaded_irq(client->irq, touchkey_interrupt_handler,
				touchkey_interrupt_thread, IRQF_TRIGGER_FALLING,
				DEVICE_NAME, devdata);
	if (err) {
		dev_err(dev, "%s: Can't allocate irq.\n", __func__);
		goto err_req_irq;
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	devdata->early_suspend.suspend = cypress_touchkey_early_suspend;
	devdata->early_suspend.resume = cypress_touchkey_early_resume;
#endif
	register_early_suspend(&devdata->early_suspend);

	devdata->is_powering_on = false;

 
#ifdef CONFIG_GENERIC_BLN
	blndevdata = devdata;
	register_bln_implementation(&cypress_touchkey_bln);
#endif
    
#ifdef CONFIG_BLD
	blddevdata = devdata;
	register_bld_implementation(&cypress_touchkey_bld);
#endif

#ifdef CONFIG_TOUCH_WAKE
	touchwakedevdata = devdata;
	register_touchwake_implementation(&cypress_touchwake);
#endif

	return 0;

err_req_irq:
err_backlight_on:
	input_unregister_device(input_dev);
	goto touchkey_off;
err_input_reg_dev:
err_read:
	input_free_device(input_dev);
touchkey_off:
	devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
err_input_alloc_dev:
err_null_keycodes:
	kfree(devdata);
	return err;
}
コード例 #15
0
/*
[function]: 
    read out data from ctpm,the destination address is 0.
[parameters]:
    pbt_buf[out]    :point to data buffer;
    bt_len[in]        :the data numbers;    
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
FTS_BOOL byte_read(struct i2c_client *client,FTS_BYTE* pbt_buf, FTS_BYTE bt_len)
{
    return i2c_master_recv(client, pbt_buf, bt_len);
}
コード例 #16
0
static ssize_t pn544_read(struct file *file, char __user *buf, 
						  size_t count, loff_t *offset) 
{ 
	/*use global var instead of container_of funcation*/
    struct pn544_info *info = pn544_info;	
    /*unused var variable 'len'*/
	int ret = -1;
	int i = 0;
	char tmp[PN544_MAX_PACK_LEN];

	PN544_DEBUG("%s:entered\n",__func__);

	if (count > PN544_MAX_PACK_LEN)
		count = PN544_MAX_PACK_LEN;

	PN544_DEBUG("%s : reading %zu bytes.\n", __func__, count);

	//mutex_lock(&info->mutex);
	/*if gpio value is high we should enable irq*/
	PN544_DEBUG("%s:GPIO_NFC_INT value %d\n", __func__, gpio_get_value(GPIO_NFC_INT)); 
	
	if(!gpio_get_value(GPIO_NFC_INT))
	{
		PN544_DEBUG("%s:enable pn544irq !\n", __func__); 
		pn544_info->irq_enabled = true;
		enable_irq(pn544_info->i2c_dev ->irq);
		ret = wait_event_interruptible(pn544_info->read_wait, 
		                               gpio_get_value(GPIO_NFC_INT));
		pn544_disable_irq(pn544_info);
		PN544_DEBUG("%s:enable pn544irq! ret=%d!\n", __func__, ret);
		if (ret)
		{
			goto out;
		}	
	}
	if (update)
	{
		PN544_DEBUG("updateing****!\n");
	}

	/* Read data */
	ret = i2c_master_recv(info->i2c_dev, tmp, count);
	PN544_DEBUG("%s:read datasize: ret=%d count=%d\n", __func__, ret, count);
	//mutex_unlock(&info->mutex);
	
	if (ret < 0) {
		printk("%s: receive error! i2c_master_recv returned %d\n", __func__, ret);
		return ret;
	}
	if (ret > count) {
		printk("%s: received too many bytes from i2c (%d)\n",
			__func__, ret);
		return -EIO;
	}
	PN544_DEBUG("IFD->PC: ");
	for(i = 0; i < count; i++)
	{
		PN544_DEBUG("%02X", tmp[i]);
	}
	PN544_DEBUG("\n");
	if (copy_to_user(buf, tmp, ret)) {
		printk("%s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}
	PN544_DEBUG("%s:exit ret=%d\n",__func__,ret);
	return ret;

out: 
	//mutex_unlock(&info->mutex);
	return ret;
} 
コード例 #17
0
static int bh1721_read_value(struct i2c_client *client, char *buf)
{
    return i2c_master_recv(client, buf, NUM_OF_BYTES_READ);
}
コード例 #18
0
static ssize_t pn547_dev_read(struct file *filp, char __user *buf,
			      size_t count, loff_t *offset)
{
	struct pn547_dev *pn547_dev = filp->private_data;
	char tmp[MAX_BUFFER_SIZE];
	int ret = 0;

	if (count > MAX_BUFFER_SIZE) {
		count = MAX_BUFFER_SIZE;
	} else if (count == 0) {
		dev_info(&pn547_dev->client->dev, "pn547 : read 0bytes\n");
		return ret;
	}
#if NFC_DEBUG
	dev_info(&pn547_dev->client->dev, "%s : reading %zu bytes. irq=%s\n",
		__func__, count,
		gpio_get_value(pn547_dev->irq_gpio) ? "1" : "0");
	dev_info(&pn547_dev->client->dev, "pn547 : + r\n");
#endif

	mutex_lock(&pn547_dev->read_mutex);

	if (!gpio_get_value(pn547_dev->irq_gpio)) {
#ifdef NXP_KR_READ_IRQ_MODIFY
		do_reading = false;
#endif
		if (filp->f_flags & O_NONBLOCK) {
			dev_info(&pn547_dev->client->dev, "%s : O_NONBLOCK\n",
				 __func__);
			ret = -EAGAIN;
			goto fail;
		}
#if NFC_DEBUG
		dev_info(&pn547_dev->client->dev,
			"wait_event_interruptible : in\n");
#endif

#ifdef NXP_KR_READ_IRQ_MODIFY
		ret = wait_event_interruptible(pn547_dev->read_wq,
			do_reading);
#else
		ret = wait_event_interruptible(pn547_dev->read_wq,
			gpio_get_value(pn547_dev->irq_gpio));
#endif

#if NFC_DEBUG
		dev_info(&pn547_dev->client->dev,
			"wait_event_interruptible : out\n");
#endif

#ifdef NXP_KR_READ_IRQ_MODIFY
		if (cancle_read == true) {
			cancle_read = false;
			ret = -1;
			goto fail;
		}
#endif

		if (ret)
			goto fail;
	}

	/* Read data */
	ret = i2c_master_recv(pn547_dev->client, tmp, count);

	mutex_unlock(&pn547_dev->read_mutex);

	if (ret < 0) {
		dev_err(&pn547_dev->client->dev,
			"%s: i2c_master_recv returned %d\n",
				__func__, ret);
		return ret;
	}
	if (ret > count) {
		dev_err(&pn547_dev->client->dev,
			"%s: received too many bytes from i2c (%d)\n",
			__func__, ret);
		return -EIO;
	}

	if (copy_to_user(buf, tmp, ret)) {
		dev_err(&pn547_dev->client->dev,
			"%s : failed to copy to user space\n",
			__func__);
		return -EFAULT;
	}
	return ret;

fail:
	mutex_unlock(&pn547_dev->read_mutex);
	return ret;
}
コード例 #19
0
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;
	u8 buf_ir_test[8];

	data->pdata->ir_vdd_onoff(&client->dev, 0);
	data->pdata->ir_wake_en(data->pdata, 0);
	msleep(100);
	data->pdata->ir_vdd_onoff(&client->dev, 1);
	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__);
			retry_count = 1;
		}
	}
	
#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 == 0x101) {
		data->pdata->ir_wake_en(data->pdata,0);
		data->pdata->ir_vdd_onoff(&client->dev,0);
		data->on_off = 0;
		msleep(100);
		download_pass = 1;
		return 0;
	}
	if ((ret != FW_VERSION) || (retry_count != 0)) {
		printk(KERN_INFO "2. %s: chip : %04x, bin : %04x, need update!\n",
						__func__, ret, FW_VERSION);
		data->pdata->ir_vdd_onoff(&client->dev, 0);
		data->pdata->ir_wake_en(data->pdata, 0);
		msleep(100);
		data->pdata->ir_vdd_onoff(&client->dev,1);
		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_binary[i * 70], 6);
				if (ret < 0)
					goto err_update;
			} else {
				ret = i2c_master_send(client,
						&IRDA_binary[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 {
			retry_count++;
			printk(KERN_ERR "FW Checksum fail. Retry = %d\n",
						retry_count);
			goto err_bootmode;
		}

		data->pdata->ir_vdd_onoff(&client->dev, 0);
		msleep(100);
		data->pdata->ir_vdd_onoff(&client->dev, 1);
		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);
		data->pdata->ir_vdd_onoff(&client->dev,0);
		data->on_off = 0;

	} else {
		if (ret != DUMMY)
			printk(KERN_INFO "8. %s: chip : %04x, bin : %04x, latest FW_ver\n",
						__func__, ret, FW_VERSION);
		data->pdata->ir_wake_en(data->pdata,0);
		data->pdata->ir_vdd_onoff(&client->dev,0);
		data->on_off = 0;
		msleep(100);

		if (ret == FW_VERSION)
			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);
	data->pdata->ir_vdd_onoff(&client->dev,0);
	data->on_off = 0;
	return ret;
}
コード例 #20
0
ファイル: saa6752hs.c プロジェクト: wxlong/Test
static int saa6752hs_chip_command(struct i2c_client* client,
                                  enum saa6752hs_command command)
{
    unsigned char buf[3];
    unsigned long timeout;
    int status = 0;

    // execute the command
    switch(command) {
    case SAA6752HS_COMMAND_RESET:
        buf[0] = 0x00;
        break;

    case SAA6752HS_COMMAND_STOP:
        buf[0] = 0x03;
        break;

    case SAA6752HS_COMMAND_START:
        buf[0] = 0x02;
        break;

    case SAA6752HS_COMMAND_PAUSE:
        buf[0] = 0x04;
        break;

    case SAA6752HS_COMMAND_RECONFIGURE:
        buf[0] = 0x05;
        break;

    case SAA6752HS_COMMAND_SLEEP:
        buf[0] = 0x06;
        break;

    case SAA6752HS_COMMAND_RECONFIGURE_FORCE:
        buf[0] = 0x07;
        break;

    default:
        return -EINVAL;
    }

    // set it and wait for it to be so
    i2c_master_send(client, buf, 1);
    timeout = jiffies + HZ * 3;
    for (;;) {
        // get the current status
        buf[0] = 0x10;
        i2c_master_send(client, buf, 1);
        i2c_master_recv(client, buf, 1);

        if (!(buf[0] & 0x20))
            break;
        if (time_after(jiffies,timeout)) {
            status = -ETIMEDOUT;
            break;
        }

        // wait a bit
        set_current_state(TASK_INTERRUPTIBLE);
        schedule_timeout(HZ/100);
    }

    // delay a bit to let encoder settle
    set_current_state(TASK_INTERRUPTIBLE);
    schedule_timeout(HZ/20);

    // done
    return status;
}
コード例 #21
0
ファイル: ab3100-core.c プロジェクト: 3null/fastsocket
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;
}
コード例 #22
0
ファイル: max1363_core.c プロジェクト: CSCLOG/beaglebone
static int max1363_read_single_chan(struct iio_dev *indio_dev,
				    struct iio_chan_spec const *chan,
				    int *val,
				    long m)
{
	int ret = 0;
	s32 data;
	char rxbuf[2];
	long mask;
	struct max1363_state *st = iio_priv(indio_dev);
	struct i2c_client *client = st->client;

	mutex_lock(&indio_dev->mlock);
	/*
	 * If monitor mode is enabled, the method for reading a single
	 * channel will have to be rather different and has not yet
	 * been implemented.
	 */
	if (st->monitor_on) {
		ret = -EBUSY;
		goto error_ret;
	}

	/* If ring buffer capture is occurring, query the buffer */
	if (iio_ring_enabled(indio_dev)) {
		mask = max1363_mode_table[chan->address].modemask;
		data = max1363_single_channel_from_ring(mask, st);
		if (data < 0) {
			ret = data;
			goto error_ret;
		}
	} else {
		/* Check to see if current scan mode is correct */
		if (st->current_mode != &max1363_mode_table[chan->address]) {
			/* Update scan mode if needed */
			st->current_mode = &max1363_mode_table[chan->address];
			ret = max1363_set_scan_mode(st);
			if (ret < 0)
				goto error_ret;
		}
		if (st->chip_info->bits != 8) {
			/* Get reading */
			data = i2c_master_recv(client, rxbuf, 2);
			if (data < 0) {
				ret = data;
				goto error_ret;
			}
			data = (s32)(rxbuf[1]) | ((s32)(rxbuf[0] & 0x0F)) << 8;
		} else {
			/* Get reading */
			data = i2c_master_recv(client, rxbuf, 1);
			if (data < 0) {
				ret = data;
				goto error_ret;
			}
			data = rxbuf[0];
		}
	}
	*val = data;
error_ret:
	mutex_unlock(&indio_dev->mlock);
	return ret;

}
コード例 #23
0
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;
	u8 buf_ir_test[8];

	msleep(20);
	data->pdata->ir_vdd_onoff(0);
	msleep(20);
	data->pdata->ir_vdd_onoff(1);
	data->pdata->ir_wake_en(data->pdata,1);
	msleep(100);

	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__);
			retry_count = 1;
		}
	}
	ret = buf_ir_test[2] << 8 | buf_ir_test[3];
	if ((ret != FW_VERSION) || (retry_count != 0)) {
		printk(KERN_INFO "2. %s: chip : %04x, bin : %04x, need update!\n",
						__func__, ret, FW_VERSION);
		data->pdata->ir_vdd_onoff(0);
		data->pdata->ir_wake_en(data->pdata,0);
		msleep(20);
		data->pdata->ir_vdd_onoff(1);
		msleep(100);

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

		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_binary[i * 70], 6);
				if (ret < 0)
					goto err_update;
			} else {
				ret = i2c_master_send(client,
						&IRDA_binary[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);

		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 {
			retry_count++;
			printk(KERN_ERR "FW Checksum fail. Retry = %d\n",
						retry_count);
			goto err_bootmode;
		}

		data->pdata->ir_vdd_onoff(0);
		msleep(20);
		data->pdata->ir_vdd_onoff(1);
		data->pdata->ir_wake_en(data->pdata,1);
		msleep(60);
		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);
		data->pdata->ir_wake_en(data->pdata,0);
		data->pdata->ir_vdd_onoff(0);
		data->on_off = 0;
		msleep(100);

	} else {
		if (ret != DUMMY)
			printk(KERN_INFO "8. %s: chip : %04x, bin : %04x, latest FW_ver\n",
						__func__, ret, FW_VERSION);
		data->pdata->ir_wake_en(data->pdata,0);
		data->pdata->ir_vdd_onoff(0);
		data->on_off = 0;
		msleep(100);

		if (ret == FW_VERSION)
			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);
	data->pdata->ir_vdd_onoff(0);
	data->on_off = 0;
	return ret;
}
コード例 #24
0
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) {
		pr_err("%s: err %d\n", __func__, ret);
		ret = i2c_master_recv(client, buf_ir_test, MC96_READ_LENGTH);
		if (ret < 0) {
			pr_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) {
		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;
	}

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

	pr_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)
		pr_err(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)
		pr_info("%s: boot mode, FW download start! ret=%04x\n",
							__func__, ret);
	else {
		pr_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)
		pr_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)
			pr_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) {
			pr_info("1. %s: boot down complete\n",
				__func__);
			download_pass = 1;
		} else if (ret2 == checksum2) {
			pr_info("2. %s: boot down complete\n",
				__func__);
			download_pass = 1;
		} else {
			pr_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];
		pr_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)
		download_pass = 1;

	return 0;
err_update:
	pr_err("%s: update fail! count : %x, ret = %x\n",
							__func__, i, ret);
	return ret;
err_bootmode:
	pr_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;
}
コード例 #25
0
static int synaptics_ts_probe(
	struct i2c_client *client, const struct i2c_device_id *id)
{
	struct synaptics_ts_data *ts;
	uint8_t i2c_addr = 0x1B;
  	uint8_t buf[3], buf_tmp[3]={0,0,0};  
	uint8_t addr[1];
	int i, ret;

#if defined (CONFIG_TOUCHSCREEN_MMS128_TASSCOOPER)
        printk("[TSP][Synaptics][%s] %s\n", __func__,"Called");

        if(Is_MMS128_Connected()== 1)
        {
            printk("[TSP][Synaptics][%s] %s\n", __func__,"Melfas already detected !!");

            return -ENXIO;
        }
#endif

	printk("[TSP] %s, %d\n", __func__, __LINE__ );

	touch_ctrl_regulator(TOUCH_ON);
	msleep(100);	
	touch_ctrl_regulator(TOUCH_OFF);
	msleep(200);
	touch_ctrl_regulator(TOUCH_ON);
	msleep(100);

	ts = kzalloc(sizeof(*ts), GFP_KERNEL);
	if (ts == NULL) {
		ret = -ENOMEM;
		goto err_alloc_data_failed;
	}
	
	#if USE_THREADED_IRQ

	#else
	INIT_WORK(&ts->work, synaptics_ts_work_func);
	#endif

	ts->client = client;
	i2c_set_clientdata(client, ts);

	ts_global = ts;

	tsp_irq=client->irq;


#if defined (CONFIG_TOUCHSCREEN_MMS128_TASSCOOPER)
    ret = synaptics_ts_check();
    if (ret <= 0) {
         i2c_release_client(client);		
         touch_ctrl_regulator(TOUCH_OFF);

         ret = -ENXIO;
         goto err_input_dev_alloc_failed;
     }
#else
	/* Check point - i2c check - start */	
    //ret = tsp_i2c_read( 0x1B, buf_tmp, sizeof(buf_tmp));
    for (i = 0; i < 1; i++)
	{
		printk("[TSP] %s, %d, send\n", __func__, __LINE__ );
		addr[0] = 0x1B; //address
		ret = i2c_master_send(ts_global->client, addr, 1);

		if (ret >= 0)
		{
			printk("[TSP] %s, %d, receive\n", __func__, __LINE__ );
			ret = i2c_master_recv(ts_global->client, buf_tmp, 3);
			if (ret >= 0)
				break; // i2c success
		}

		printk("[TSP] %s, %d, fail\n", __func__, __LINE__ );
	}

	touch_vendor_id = buf_tmp[0];
	touch_hw_ver = buf_tmp[1];
	touch_sw_ver = buf_tmp[2];
	printk("[TSP] %s:%d, ver tsp=%x, HW=%x, SW=%x\n", __func__,__LINE__, touch_vendor_id, touch_hw_ver, touch_sw_ver);
#endif

	HW_ver = touch_hw_ver;

	if (ret <= 0) {
		printk("[TSP] %s, ln:%d, Failed to register TSP!!!\n\tcheck the i2c line!!!, ret=%d\n", __func__,__LINE__, ret);
		goto err_check_functionality_failed;
	}
	/* Check point - i2c check - end */


	ts->input_dev = input_allocate_device();
	if (ts->input_dev == NULL) {
		ret = -ENOMEM;
		printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device\n");
		goto err_input_dev_alloc_failed;
	}
	ts->input_dev->name = "synaptics-rmi-touchscreen";

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

	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, MAX_X, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, MAX_Y, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
    
	set_bit(EV_SYN, ts->input_dev->evbit);
	set_bit(EV_KEY, ts->input_dev->evbit);
    
	/* ts->input_dev->name = ts->keypad_info->name; */
	ret = input_register_device(ts->input_dev);
	if (ret) {
		printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
		goto err_input_register_device_failed;
	}

    	printk("[TSP] %s, irq=%d\n", __func__, client->irq );

    if (client->irq) {
		#if USE_THREADED_IRQ
		ret = request_threaded_irq(client->irq, synaptics_ts_irq_handler, synaptics_ts_work_func, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, client->name, ts);
		#else		
		ret = request_irq(client->irq, synaptics_ts_irq_handler, IRQF_TRIGGER_FALLING, client->name, ts);
		#endif
		
		if (ret == 0)
			ts->use_irq = 1;
		else
			dev_err(&client->dev, "request_irq failed\n");
	}

	if (!ts->use_irq) {
		hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
		ts->timer.function = synaptics_ts_timer_func;
		hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
	}
#if 1
#ifdef CONFIG_HAS_EARLYSUSPEND
	ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	ts->early_suspend.suspend = synaptics_ts_early_suspend;
	ts->early_suspend.resume = synaptics_ts_late_resume;
	register_early_suspend(&ts->early_suspend);
#endif
#endif
	printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");

	/* sys fs */
	touch_class = class_create(THIS_MODULE, "touch");
	if (IS_ERR(touch_class))
		pr_err("Failed to create class(touch)!\n");

	firmware_dev = device_create(touch_class, NULL, 0, NULL, "firmware");
	if (IS_ERR(firmware_dev))
		pr_err("Failed to create device(firmware)!\n");

	if (device_create_file(firmware_dev, &dev_attr_firmware) < 0)
		pr_err("Failed to create device file(%s)!\n", dev_attr_firmware.attr.name);
	if (device_create_file(firmware_dev, &dev_attr_firmware_ret) < 0)
		pr_err("Failed to create device file(%s)!\n", dev_attr_firmware_ret.attr.name);

	/* sys fs */
    

#if 0
	if(buf_tmp[0]<HEX_HW_VER){	//Firmware Update
		firm_update();
	}else if((buf_tmp[1]<HEX_SW_VER)||((buf_tmp[1]&0xF0)==0xF0)||(buf_tmp[1]==0)){
		printk("[TSP] firm_update START!!, ln=%d\n",__LINE__);
		firm_update();
	}else{
		printk("[TSP] Firmware Version is Up-to-date.\n");
	}
#endif


	return 0;

err_input_register_device_failed:
	input_free_device(ts->input_dev);

err_input_dev_alloc_failed:
	kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
	return ret;
}
コード例 #26
0
static ssize_t pn547_dev_read(struct file *filp, char __user *buf,
			      size_t count, loff_t *offset)
{
	struct pn547_dev *pn547_dev = filp->private_data;
	char tmp[MAX_BUFFER_SIZE] = {0, };
	int ret = 0;
#ifdef CONFIG_NFC_PN544
	int readingWatchdog = 0;
#endif

	if (count > MAX_BUFFER_SIZE)
		count = MAX_BUFFER_SIZE;

	pr_debug("%s : reading %zu bytes. irq=%s\n", __func__, count,
		 gpio_get_value(pn547_dev->irq_gpio) ? "1" : "0");

#if NFC_DEBUG
	pr_info("pn547 : + r\n");
#endif

	mutex_lock(&pn547_dev->read_mutex);

#ifdef CONFIG_NFC_PN544
wait_irq:
#endif

	if (!gpio_get_value(pn547_dev->irq_gpio)) {
		atomic_set(&pn547_dev->read_flag, 0);
		if (filp->f_flags & O_NONBLOCK) {
			pr_info("%s : O_NONBLOCK\n", __func__);
			ret = -EAGAIN;
			goto fail;
		}

#if NFC_DEBUG
		pr_info("pn547: wait_event_interruptible : in\n");
#endif
		if (!gpio_get_value(pn547_dev->irq_gpio))
			ret = wait_event_interruptible(pn547_dev->read_wq,
				atomic_read(&pn547_dev->read_flag));

#if NFC_DEBUG
		pr_info("pn547 :   h\n");
#endif

		if (pn547_dev->cancel_read) {
			pn547_dev->cancel_read = false;
			ret = -1;
			goto fail;
		}

		if (ret)
			goto fail;

	}

	/* Read data */
	ret = i2c_master_recv(pn547_dev->client, tmp, count);

#ifdef CONFIG_NFC_PN544
	/* If bad frame(from 0x51 to 0x57) is received from pn65n,
	* we need to read again after waiting that IRQ is down.
	* if data is not ready, pn65n will send from 0x51 to 0x57. */
	if ((I2C_ADDR_READ_L <= tmp[0] && tmp[0] <= I2C_ADDR_READ_H)
		&& readingWatchdog < MAX_TRY_I2C_READ) {
		pr_warn("%s: data is not ready yet.data = 0x%x, cnt=%d\n",
			__func__, tmp[0], readingWatchdog);
		usleep_range(2000, 2000); /* sleep 2ms to wait for IRQ */
		readingWatchdog++;
		goto wait_irq;
	}
#endif

#if NFC_DEBUG
	pr_info("pn547: i2c_master_recv\n");
#endif
	mutex_unlock(&pn547_dev->read_mutex);
	if (ret < 0) {
		pr_err("%s: i2c_master_recv returned %d\n", __func__,
				ret);
#ifdef CONFIG_SEC_K_PROJECT
		pn547_i2c_recovery(pn547_dev);
#endif
		return ret;
	}

	if (ret > count) {
		pr_err("%s: received too many bytes from i2c (%d)\n",
				__func__, ret);
		return -EIO;
	}

	if (copy_to_user(buf, tmp, ret)) {
		pr_err("%s : failed to copy to user space\n", __func__);
		return -EFAULT;
	}
	return ret;

fail:
	mutex_unlock(&pn547_dev->read_mutex);
	return ret;
}
コード例 #27
0
static int cypress_touchkey_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct input_dev *input_dev;
	struct cypress_touchkey_devdata *devdata;
	u8 data[3];
	int err;
	int cnt;
#if defined(TOUCH_UPDATE)
	int ret;
	int retry = 10;
#endif

	if (!dev->platform_data) {
		dev_err(dev, "%s: Platform data is NULL\n", __func__);
		return -EINVAL;
	}

	devdata = kzalloc(sizeof(*devdata), GFP_KERNEL);
	if (devdata == NULL) {
		dev_err(dev, "%s: failed to create our state\n", __func__);
		return -ENODEV;
	}

	devdata->client = client;
	i2c_set_clientdata(client, devdata);

	devdata->pdata = client->dev.platform_data;
	if (!devdata->pdata->keycode) {
		dev_err(dev, "%s: Invalid platform data\n", __func__);
		err = -EINVAL;
		goto err_null_keycodes;
	}

	strlcpy(devdata->client->name, DEVICE_NAME, I2C_NAME_SIZE);

	input_dev = input_allocate_device();
	if (!input_dev) {
		err = -ENOMEM;
		goto err_input_alloc_dev;
	}

	devdata->input_dev = input_dev;
	dev_set_drvdata(&input_dev->dev, devdata);
	input_dev->name = DEVICE_NAME;
	input_dev->id.bustype = BUS_HOST;

	for (cnt = 0; cnt < devdata->pdata->keycode_cnt; cnt++)
		input_set_capability(input_dev, EV_KEY,
					devdata->pdata->keycode[cnt]);

	err = input_register_device(input_dev);
	if (err)
		goto err_input_reg_dev;

	devdata->is_powering_on = true;

	devdata->pdata->touchkey_onoff(TOUCHKEY_ON);

	err = i2c_master_recv(client, data, sizeof(data));
	if (err < sizeof(data)) {
		if (err >= 0)
			err = -EIO;
		dev_err(dev, "%s: error reading hardware version\n", __func__);
		goto err_read;
	}

	dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__,
				data[1], data[2]);

	devdata->backlight_on = BACKLIGHT_ON;
	devdata->backlight_off = BACKLIGHT_OFF;

	devdata->has_legacy_keycode = 1;
#if 0
	err = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
	if (err) {
		dev_err(dev, "%s: touch keypad backlight on failed\n",
				__func__);
		goto err_backlight_on;
	}
#endif
	if (request_threaded_irq(client->irq, touchkey_interrupt_handler,
				touchkey_interrupt_thread, IRQF_TRIGGER_FALLING,
				DEVICE_NAME, devdata)) {
		dev_err(dev, "%s: Can't allocate irq.\n", __func__);
		goto err_req_irq;
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	devdata->early_suspend.suspend = cypress_touchkey_early_suspend;
	devdata->early_suspend.resume = cypress_touchkey_early_resume;
#endif
	register_early_suspend(&devdata->early_suspend);

	devdata->is_powering_on = false;
    
#if defined(TOUCH_UPDATE)
	ret = misc_register(&touchkey_update_device);
	if (ret) {
		printk("%s misc_register fail\n", __FUNCTION__);
		goto err_misc_reg;
	}

	dev_set_drvdata(touchkey_update_device.this_device, devdata);

	if (device_create_file
	    (touchkey_update_device.this_device, &dev_attr_touch_version) < 0) {
		printk("%s device_create_file fail dev_attr_touch_version\n",
		       __FUNCTION__);
		pr_err("Failed to create device file(%s)!\n",
		       dev_attr_touch_version.attr.name);
	}

	if (device_create_file
	    (touchkey_update_device.this_device, &dev_attr_touch_update) < 0) {
		printk("%s device_create_file fail dev_attr_touch_update\n",
		       __FUNCTION__);
		pr_err("Failed to create device file(%s)!\n",
		       dev_attr_touch_update.attr.name);
	}

	if (device_create_file
	    (touchkey_update_device.this_device, &dev_attr_brightness) < 0) {
		printk("%s device_create_file fail dev_attr_touch_update\n",
		       __FUNCTION__);
		pr_err("Failed to create device file(%s)!\n",
		       dev_attr_brightness.attr.name);
	}

	if (device_create_file
	    (touchkey_update_device.this_device,
	     &dev_attr_enable_disable) < 0) {
		printk("%s device_create_file fail dev_attr_touch_update\n",
		       __FUNCTION__);
		pr_err("Failed to create device file(%s)!\n",
		       dev_attr_enable_disable.attr.name);
	}

	touchkey_wq = create_singlethread_workqueue(DEVICE_NAME);
	if (!touchkey_wq)
		goto err_create_wq;

	while (retry--) {
		if (get_touchkey_firmware(data) == 0)	//melfas need delay for multiple read
			break;
	}
	printk("%s F/W version: 0x%x, Module version:0x%x\n", __FUNCTION__,
	       data[1], data[2]);
#endif

#ifdef CONFIG_KEYPAD_CYPRESS_TOUCH_BLN
	pr_info("%s misc_register(%s)\n", __FUNCTION__, backlightnotification_device.name);
	err = misc_register(&backlightnotification_device);
	if (err) {
		pr_err("%s misc_register(%s) fail\n", __FUNCTION__, backlightnotification_device.name);
	}else {
		/*
		 *  keep a reference to the devdata,
		 *  misc driver does not give access to it (or i missed that somewhere)
		 */
		bln_devdata = devdata;

		/* add the backlightnotification attributes */
		if (sysfs_create_group(&backlightnotification_device.this_device->kobj, &bln_interface_attributes_group) < 0)
		{
			pr_err("%s sysfs_create_group fail\n", __FUNCTION__);
			pr_err("Failed to create sysfs group for device (%s)!\n", backlightnotification_device.name);
		}
	}
#endif
    setup_timer(&bl_timer, bl_timer_callback, 0);
	return 0;

err_create_wq:
#if defined(TOUCH_UPDATE)
	misc_deregister(&touchkey_update_device);
#endif
err_misc_reg:
err_req_irq:
err_backlight_on:
err_read:
	devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
	input_unregister_device(input_dev);
	goto err_input_alloc_dev;
err_input_reg_dev:
	input_free_device(input_dev);
err_input_alloc_dev:
err_null_keycodes:
	kfree(devdata);
	return err;
}
コード例 #28
0
ファイル: main.c プロジェクト: ECEEmbedded/PicRouter2
Something is messed up
#endif
#endif
#endif

void main(void) {
    //Tmp Code
    unsigned char ADCbufferI2C[8];
    unsigned char ADCBufferLen;

    char c;
    signed char length;
    unsigned char msgtype;
    unsigned char last_reg_recvd;
    uart_comm uc;
//    i2c_comm ic;
    unsigned char msgbuffer[MSGLEN + 1];
    unsigned char i;
    uart_thread_struct uthread_data; // info for uart_lthread
    timer1_thread_struct t1thread_data; // info for timer1_lthread
    timer0_thread_struct t0thread_data; // info for timer0_lthread

#ifdef __USE18F2680
    OSCCON = 0xFC; // see datasheet
    // We have enough room below the Max Freq to enable the PLL for this chip
    OSCTUNEbits.PLLEN = 1; // 4x the clock speed in the previous line
#else
#ifdef __USE18F45J10
    OSCCON = 0x82; // see datasheeet
    OSCTUNEbits.PLLEN = 0; // Makes the clock exceed the PIC's rated speed if the PLL is on
#else
#ifdef __USE18F26J50
    OSCCON = 0xE0; // see datasheeet
    OSCTUNEbits.PLLEN = 1;
#else
    Something is wrong
#endif
#endif
#endif

    // initialize my uart recv handling code
    init_uart_snd_rcv(&uc);

    // initialize the i2c code
  //   init_i2c(&ic);

    // init the timer1 lthread
    init_timer1_lthread(&t1thread_data);

    // initialize message queues before enabling any interrupts
    init_queues();

    // set direction for PORTA to output
    TRISA = 0x00;
    LATA = 0x00;

    // how to set up PORTA for input (for the V4 board with the PIC2680)
    /*
            PORTA = 0x0;	// clear the port
            LATA = 0x0;		// clear the output latch
            ADCON1 = 0x0F;	// turn off the A2D function on these pins
            // Only for 40-pin version of this chip CMCON = 0x07;	// turn the comparator off
            TRISA = 0x0F;	// set RA3-RA0 to inputs
     */

    // initialize Timers
    OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_128);
#ifdef __USE18F26J50
    // MTJ added second argument for OpenTimer1()
    OpenTimer1(TIMER_INT_ON & T1_SOURCE_FOSC_4 & T1_PS_1_4 & T1_16BIT_RW & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF,0x0);
#else
    OpenTimer1(TIMER_INT_ON & T1_PS_1_8 & T1_16BIT_RW & T1_SOURCE_INT & T1_OSC1EN_OFF & T1_SYNC_EXT_OFF);
#endif

    // Decide on the priority of the enabled peripheral interrupts
    // 0 is low, 1 is high
    // Timer1 interrupt
    IPR1bits.TMR1IP = 0;
    // USART RX interrupt
    IPR1bits.RCIP = 0;
    // I2C interrupt
    IPR1bits.SSPIP = 1;

    // configure the hardware i2c device as a slave (0x9E -> 0x4F) or (0x9A -> 0x4D)
#if 1
    // Note that the temperature sensor Address bits (A0, A1, A2) are also the
    // least significant bits of LATB -- take care when changing them
    // They *are* changed in the timer interrupt handlers if those timers are
    //   enabled.  They are just there to make the lights blink and can be
    //   disabled.
   // i2c_configure_slave(0x9E);
#else
    // If I want to test the temperature sensor from the ARM, I just make
    // sure this PIC does not have the same address and configure the
    // temperature sensor address bits and then just stay in an infinite loop
    i2c_configure_slave(0x9A);
#ifdef __USE18F2680
    LATBbits.LATB1 = 1;
    LATBbits.LATB0 = 1;
    LATBbits.LATB2 = 1;
#endif
    for (;;);
#endif

    // must specifically enable the I2C interrupts
    PIE1bits.SSPIE = 1;

    // configure the hardware USART device
#ifdef __USE18F26J50
    Open1USART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
        USART_CONT_RX & USART_BRGH_LOW, 0x19);
#else
 //   OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE & USART_EIGHT_BIT &
        //    USART_CONT_RX & USART_BRGH_LOW, 0x19);
#endif

    // Peripheral interrupts can have their priority set to high or low
    // enable high-priority interrupts and low-priority interrupts
    enable_interrupts();

    /* Junk to force an I2C interrupt in the simulator (if you wanted to)
    PIR1bits.SSPIF = 1;
    _asm
    goto 0x08
    _endasm;
     */

    // printf() is available, but is not advisable.  It goes to the UART pin
    // on the PIC and then you must hook something up to that to view it.
    // It is also slow and is blocking, so it will perturb your code's operation
    // Here is how it looks: printf("Hello\r\n");

    //Setup ad
   // adcInit();

    // loop forever
    // This loop is responsible for "handing off" messages to the subroutines
    // that should get them.  Although the subroutines are not threads, but
    // they can be equated with the tasks in your task diagram if you
    // structure them properly

    //Init I2C
    I2CInit();
//    OpenI2C(MASTER, SLEW_OFF);

    //Load Drivers
    DriverColorAdd(0x4F);
    DriverIRAdd(0x49);

    while (1) {

        // Call a routine that blocks until either on the incoming
        // messages queues has a message (this may put the processor into
        // an idle mode)
        block_on_To_msgqueues();

        // At this point, one or both of the queues has a message.  It
        // makes sense to check the high-priority messages first -- in fact,
        // you may only want to check the low-priority messages when there
        // is not a high priority message.  That is a design decision and
        // I haven't done it here.
        length = ToMainHigh_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer);
        if (length < 0) {
            // no message, check the error code to see if it is concern
            if (length != MSGQUEUE_EMPTY) {
                // This case be handled by your code.
            }
        } else {
            switch (msgtype) {
                case MSGT_TIMER0:
                {
                    timer0_lthread(&t0thread_data, msgtype, length, msgbuffer);
                    break;
                };
                case MSGT_I2C_DATA:
                {
                    if (msgbuffer[0] != 0xFF) {

//LATAbits.LA3 = !LATAbits.LA3;

                    }
                    break;
                };
                case MSGT_I2C_DBG:
                {
                    // Here is where you could handle debugging, if you wanted
                    // keep track of the first byte received for later use (if desired)
                    last_reg_recvd = msgbuffer[0];
                    break;
                };
                case MSGT_I2C_RQST:
                {
                    // Generally, this is *NOT* how I recommend you handle an I2C slave request
                    // I recommend that you handle it completely inside the i2c interrupt handler
                    // by reading the data from a queue (i.e., you would not send a message, as is done
                    // now, from the i2c interrupt handler to main to ask for data).
                    //
                    // The last byte received is the "register" that is trying to be read
                    // The response is dependent on the register.
//                    last_reg_recvd = msgbuffer[length-1];
/*                    i2cmsg *tmpPtr = i2c_addressable_registers + 2;//(last_reg_recvd - 0xA8);
                    start_i2c_slave_reply(tmpPtr->length, tmpPtr->data);
*/
                   // start_i2c_slave_reply(ADCBufferLen, ADCbufferI2C);

                    break;
                };
                default:
                {
                    // Your code should handle this error
                    break;
                };
            };
        }

        // Check the low priority queue
        length = ToMainLow_recvmsg(MSGLEN, &msgtype, (void *) msgbuffer);
        if (length < 0) {
            // no message, check the error code to see if it is concern
            if (length != MSGQUEUE_EMPTY) {
                // Your code should handle this situation
            }
        } else {
            switch (msgtype) {
                case MSGT_TIMER1:
                {
//                    for (unsigned char i = 0; i < NumberOfDrivers; ++i)
//                        DriverTable[i].poll(DriverTable[i].context);

//                    msgbuffer[0] = 0x10;
//                    msgbuffer[1] = 0x5A;
//                    i2c_master_send(0x4F, 1, msgbuffer);
                    i2c_master_recv(0x4F, 0x10, 8);
                    timer1_lthread(&t1thread_data, msgtype, length, msgbuffer);
                    break;
                };
             
                case MSGT_OVERRUN:
                case MSGT_UART_DATA:
                {
                    uart_lthread(&uthread_data, msgtype, length, msgbuffer);
                    break;
                };
                default:
                {
                    // Your code should handle this error
                    break;
                };
            };
        }
    }

}
コード例 #29
0
static void pixcir_ts_poscheck(struct pixcir_i2c_ts_data *data)
{
	struct pixcir_i2c_ts_data *tsdata = data;
	u8 rdbuf[10], wrbuf[1] = { 0 };
	u8 touch;
	int ret;

	ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf));
	if (ret != sizeof(wrbuf)) {
		dev_err(&tsdata->client->dev,
			"%s: i2c_master_send failed(), ret=%d\n",
			__func__, ret);
		return;
	}

	ret = i2c_master_recv(tsdata->client, rdbuf, sizeof(rdbuf));
	if (ret != sizeof(rdbuf)) {
		dev_err(&tsdata->client->dev,
			"%s: i2c_master_recv failed(), ret=%d\n",
			__func__, ret);
		return;
	}

	touch = rdbuf[0];
	if (touch) {
		u16 posx1 = (rdbuf[3] << 8) | rdbuf[2];
		u16 posy1 = (rdbuf[5] << 8) | rdbuf[4];
		u16 posx2 = (rdbuf[7] << 8) | rdbuf[6];
		u16 posy2 = (rdbuf[9] << 8) | rdbuf[8];
		
		/* HACK 
 		* Even though Tango M32 specification gives data in following order
 		* {touch, old_touch, x1, y1, x2, y2, ...}, we are not receiving data in
 		* this order, may be bacause of worng orientation of LCD and touch panel
 		* following hack will give us correct x,y coordinates
 		*/ 	
		pixcir_ts_swap(&posx1, &posy1);
		pixcir_ts_swap(&posx2, &posy2);
		posx1 = tsdata->chip->x_max - posx1;

		input_report_key(tsdata->input, BTN_TOUCH, 1);
		input_report_abs(tsdata->input, ABS_X, posx1);
		input_report_abs(tsdata->input, ABS_Y, posy1);

		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 (touch == 2) {
			posx2 = tsdata->chip->x_max - posx2;

			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);
		}
	} else {
		input_report_key(tsdata->input, BTN_TOUCH, 0);
	}

	input_sync(tsdata->input);
}
コード例 #30
0
ファイル: ami304.c プロジェクト: Axelfox/2.6.35
static int AMI304_Chipset_Init(int mode, int chipset)
{
	u8 databuf[10];
	u8 regaddr;
	u8 ctrl1, ctrl2, ctrl3;
	unsigned char ctrl4[2];
	
	regaddr = AMI304_REG_CTRL1;
	i2c_master_send(ami304_i2c_client, &regaddr, 1);
	i2c_master_recv(ami304_i2c_client, &ctrl1, 1);

	regaddr = AMI304_REG_CTRL2;
	i2c_master_send(ami304_i2c_client, &regaddr, 1);
	i2c_master_recv(ami304_i2c_client, &ctrl2, 1);
	
	regaddr = AMI304_REG_CTRL3;
	i2c_master_send(ami304_i2c_client, &regaddr, 1);
	i2c_master_recv(ami304_i2c_client, &ctrl3, 1);		

//	regaddr = AMI304_REG_CTRL4; //2 bytes
//	i2c_master_send(ami304_i2c_client, &regaddr, 1);
//	i2c_master_recv(ami304_i2c_client, &(ctrl4[0]), 2);
	
	databuf[0] = AMI304_REG_CTRL1;
	if( mode == AMI304_FORCE_MODE ) {
		databuf[1] = ctrl1 | AMI304_CTRL1_PC1 | AMI304_CTRL1_FS1_FORCE;
		write_lock(&ami304_data.lock);
		ami304_data.mode = AMI304_FORCE_MODE;
		write_unlock(&ami304_data.lock);
	}
	else {
		databuf[1] = ctrl1 | AMI304_CTRL1_PC1 | AMI304_CTRL1_FS1_NORMAL | AMI304_CTRL1_ODR1;
		write_lock(&ami304_data.lock);
		ami304_data.mode = AMI304_NORMAL_MODE;
		write_unlock(&ami304_data.lock);
	}
	i2c_master_send(ami304_i2c_client, databuf, 2);		
	
	databuf[0] = AMI304_REG_CTRL2;
	databuf[1] = ctrl2 | AMI304_CTRL2_DREN | AMI304_CTRL2_DRP;
	i2c_master_send(ami304_i2c_client, databuf, 2);		
	
	databuf[0] = AMI304_REG_CTRL3;
	databuf[1] = ctrl3 | AMI304_CTRL3_B0_LO_CLR;
	i2c_master_send(ami304_i2c_client, databuf, 2);
	
	databuf[0] = AMI304_REG_CTRL4;	
	if( chipset == AMI304_CHIPSET ) //AMI304
	{
//		ctrl4[1]   = ctrl4[1] & AMI304_CTRL4_COMPASS_MODE; 	 //0x5D
		ctrl4[0] = 0x00;
		ctrl4[1] = 0x00;
	}
	else	//AMI306	//AMI306_CHIPSET
	{
//		ctrl4[1]   = ctrl4[1] | AMI306_CTRL4_HIGHSPEED_MODE; //0x5D
		ctrl4[0] = 0x7e;
		ctrl4[1] = 0xa0;
	}	
	databuf[1] = ctrl4[0];
	databuf[2] = ctrl4[1];
	i2c_master_send(ami304_i2c_client, databuf, 3);				
	
	return 0;
}