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; }
static int max517_resume(struct device *dev) { u8 outbuf = 0; return i2c_master_send(to_i2c_client(dev), &outbuf, 1); }
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] = {
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, ¶m); 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; }
/* * 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, ®, 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, ®, 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; }
/* *-------------------------------------------------------------------------- * 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; }
//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; }
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; }
/* [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); }
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 ; }
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; }
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; }
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], ®, 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, ®, 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; }
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); }
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); }
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); } }
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; }
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; }
*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");
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); }
/* 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; }
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; }
static int max517_suspend(struct device *dev) { u8 outbuf = COMMAND_PD; return i2c_master_send(to_i2c_client(dev), &outbuf, 1); }
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); }
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; }
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, ®, 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, ®andval[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; }
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; }
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); } }