static int pcf8591_read_channel(struct device *dev, int channel) { u8 value; struct i2c_client *client = to_i2c_client(dev); struct pcf8591_data *data = i2c_get_clientdata(client); mutex_lock(&data->update_lock); if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) { data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK) | channel; i2c_smbus_write_byte(client, data->control); /* The first byte transmitted contains the conversion code of the previous read cycle. FLUSH IT! */ i2c_smbus_read_byte(client); } value = i2c_smbus_read_byte(client); mutex_unlock(&data->update_lock); if ((channel == 2 && input_mode == 2) || (channel != 3 && (input_mode == 1 || input_mode == 3))) return (10 * REG_TO_SIGNED(value)); else return (10 * value); }
//[*]--------------------------------------------------------------------------------------------------[*] static int bh1780_measure(struct bh1780_data *bh1780) { struct i2c_client *client = bh1780->client; int low_data, high_data; /* read light sensor data */ if(i2c_smbus_write_byte(bh1780->client, (BH1780_COMMAND_REG + BH1780_DATA_LOW_REG)) < 0) { dev_err(&client->dev, "I2C write byte error: data=0x%02x\n", (BH1780_COMMAND_REG + BH1780_DATA_LOW_REG)); goto err; } if((low_data = i2c_smbus_read_byte(client)) < 0) { dev_err(&client->dev, "I2C read byte error\n"); goto err; } if(i2c_smbus_write_byte(bh1780->client, (BH1780_COMMAND_REG + BH1780_DATA_HIGH_REG)) < 0) { dev_err(&client->dev, "I2C write byte error: data=0x%02x\n", (BH1780_COMMAND_REG + BH1780_DATA_HIGH_REG)); goto err; } if((high_data = i2c_smbus_read_byte(client)) < 0) { dev_err(&client->dev, "I2C read byte error\n"); goto err; } bh1780->light_data = BH1780_DATA_CAL(high_data, low_data); err: return 0; }
static int pcf8591_read_channel(struct device *dev, int channel) { u8 value; struct i2c_client *client = to_i2c_client(dev); struct pcf8591_data *data = i2c_get_clientdata(client); mutex_lock(&data->update_lock); if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) { data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK) | channel; i2c_smbus_write_byte(client, data->control); i2c_smbus_read_byte(client); } value = i2c_smbus_read_byte(client); mutex_unlock(&data->update_lock); if ((channel == 2 && input_mode == 2) || (channel != 3 && (input_mode == 1 || input_mode == 3))) return 10 * REG_TO_SIGNED(value); else return 10 * value; }
/** * Performs the read byte function. * * @param data The ds2482 channel pointer * @return The value read */ static u8 ds2482_w1_read_byte(void *data) { struct ds2482_w1_chan *pchan = data; struct ds2482_data *pdev = pchan->pdev; int result; mutex_lock(&pdev->access_lock); /* Select the channel */ ds2482_wait_1wire_idle(pdev); if (pdev->w1_count > 1) ds2482_set_channel(pdev, pchan->channel); /* Send the read byte command */ ds2482_send_cmd(pdev, DS2482_CMD_1WIRE_READ_BYTE); /* Wait until 1WB == 0 */ ds2482_wait_1wire_idle(pdev); /* Select the data register */ ds2482_select_register(pdev, DS2482_PTR_CODE_DATA); /* Read the data byte */ result = i2c_smbus_read_byte(pdev->client); mutex_unlock(&pdev->access_lock); return result; }
u8 SII9234_i2c_read(struct i2c_client *client, u8 reg) { u8 ret; u16 ret1; u8 ret2; u32 ret3; if(!MHL_i2c_init) { SII_DEV_DBG("I2C not ready"); return 0; } i2c_smbus_write_byte(client, reg); ret = i2c_smbus_read_byte(client); //printk("#######Read reg %x data %x\n", reg, ret); if (ret < 0) { SII_DEV_DBG("i2c read fail"); return -EIO; } return ret; }
static int mcsdl_prepare_program(void) { int i; int ret = 0; int read_data = 0; uint8_t i2c_buffer[4] = {0x0F, /* isp program flash cmd */ 0x00, /* isp program timing value 0 */ 0x00, /* isp program timing value 1 */ 0x78}; /* isp program timing value 2 */ /* Write Program timing information */ for(i=0; i<4; i++){ ret = i2c_smbus_write_byte(g_client, i2c_buffer[i]); if( 0 != ret ){ printk("mcsdl Write Program timing information error\n"); return -1; } udelay(15); } udelay(500); /* Read Result */ read_data = i2c_smbus_read_byte(g_client); if (read_data != 0x8F) { /* 0x8F is prepare program flash OK status */ printk("mcsdl prepare program error\n"); return -1; } ndelay(100); return 0; }
static void qcikbd_work_handler(struct work_struct *_work) { unsigned char scancode; unsigned int keycode; struct i2ckbd_drv_data *ikbd_drv_data = container_of(_work, struct i2ckbd_drv_data, work); struct i2c_client *ikbdclient = ikbd_drv_data->ki2c_client; struct input_dev *ikbdev = ikbd_drv_data->qcikbd_dev; scancode = i2c_smbus_read_byte(ikbdclient); if (scancode == KEY_ACK_FA) { return; } else if (scancode == RC_KEY_FN) { ikbd_drv_data->fn = 0x80; /* select keycode table > 0x7F */ } else { ikbd_drv_data->key_down = 1; if (scancode & RC_KEY_BREAK) { ikbd_drv_data->key_down = 0; if ((scancode & 0x7F) == RC_KEY_FN) ikbd_drv_data->fn = 0; } keycode = on2_keycode[(scancode & 0x7F) | ikbd_drv_data->fn]; if (keycode != NOKEY) { input_report_key(ikbdev, keycode, ikbd_drv_data->key_down); input_sync(ikbdev); } } }
static u8 l3g4200d_read_reg(struct i2c_client *client, u8 addr){ s32 err = i2c_smbus_write_byte(client,addr); s32 val = i2c_smbus_read_byte(client); return (u8) val; }
int main (void){ int device_handle; if ((device_handle = open("/dev/i2c-1", O_RDWR)) < 0){ printf("Error: Couldn't open device %d\n", device_handle); return 1; } if (ioctl(device_handle, I2C_SLAVE, 4) < 0){ printf("Error: Couldn't find arduino on address!\n"); return 1; } char data[4] = {0x65, 0x66, 0x67, 0x68}; i2c_smbus_write_byte(device_handle, data[0]); i2c_smbus_write_byte(device_handle, data[1]); i2c_smbus_write_byte(device_handle, data[2]); i2c_smbus_write_byte(device_handle, data[3]); //write(device_handle, data, 4); char b = i2c_smbus_read_byte(device_handle); printf("%i\n",b); close(device_handle); return 0; }
/* Single byte -- assumes channel selection already done */ static GOOD_OR_BAD DS2482_send_and_get(FILE_DESCRIPTOR_OR_ERROR file_descriptor, const BYTE wr, BYTE * rd) { int read_back; BYTE c; /* Write data byte */ if (i2c_smbus_write_byte_data(file_descriptor, DS2482_CMD_1WIRE_WRITE_BYTE, wr) < 0) { return gbBAD; } /* read status for done */ RETURN_BAD_IF_BAD( DS2482_readstatus(&c, file_descriptor, DS2482_1wire_write_usec) ) ; /* Select the data register */ if (i2c_smbus_write_byte_data(file_descriptor, DS2482_CMD_SET_READ_PTR, DS2482_READ_DATA_REGISTER) < 0) { return gbBAD; } /* Read the data byte */ read_back = i2c_smbus_read_byte(file_descriptor); if (read_back < 0) { return gbBAD; } rd[0] = (BYTE) read_back; return gbGOOD; }
static inline int aps_i2c_reg_read(struct aps_data *aps , int reg) { int val = 0; int ret = 0; int i = 0; mutex_lock(&aps->mlock); /* First write reg, then read reg data, resolve i2c error */ //val = i2c_smbus_read_byte_data(aps->client, reg); for( i = 0; i < 3; i++){ ret = i2c_smbus_write_byte(aps->client, reg); if(ret >= 0) break; } if ( 3 == i ) printk(KERN_ERR "%s: failed to write reg[%d], err=%d\n", __FUNCTION__, reg, val); for( i = 0; i < 3; i++){ val = i2c_smbus_read_byte(aps->client); if(val >= 0) break; } if ( 3 == i ) printk(KERN_ERR "%s: failed to read reg[%d], err=%d\n", __FUNCTION__, reg, val); mutex_unlock(&aps->mlock); return val; }
int ps5101_i2c_read(struct i2c_client *client, u8 reg, u8* value) { int ret; if (!MHL_i2c_init) { print_err("I2C not ready\n"); return -EIO; } ret = i2c_smbus_write_byte(client, reg); if (ret < 0) { print_err("Write reg 0x%02x error\n", reg); return ret; } ret = i2c_smbus_read_byte(client); if (ret < 0) { print_err("I2C read fail\n"); return -EIO; } *value = ret & 0x000000ff; return ret; }
u8 sii9234_i2c_read(struct i2c_client *client, u8 reg) { u8 ret; if (!mhl_i2c_init) { SII_DEV_DBG("I2C not ready"); return 0; } ret = i2c_smbus_write_byte(client, reg); if (ret < 0) { printk(KERN_ERR "%s() I2C cmd write error", __func__); return -EIO; } ret = i2c_smbus_read_byte(client); if (ret < 0) { SII_DEV_DBG("i2c read fail"); return -EIO; } return ret; }
static int pure_sensord(void *arg) { struct pure *p = arg; int s, slow, shigh, sxor; /* TODO: finish me! */ while (!kthread_should_stop()) { set_current_state(TASK_INTERRUPTIBLE); schedule(); pr_err("%s: running!\n", __func__); s = i2c_smbus_read_byte(&p->client); slow = (s & 0xf); shigh = (s & 0xf0) >> 4; sxor = slow ^ shigh; /* TODO: this isn't entirely correct! */ if (sxor & 1) { p->a = (slow & 1) ? 1 : 0; complete(&p->ca); } if (sxor & 2) { p->b = (slow & 2) ? 1 : 0; complete(&p->cb); } } return 0; }
static int i2c_touchkey_read_byte(struct cypress_touchkey_devdata *devdata, u8 *val) { int ret; int retry = 2; down(&i2c_sem); while (true) { ret = i2c_smbus_read_byte(devdata->client); if (ret >= 0 ) { *val = ret; up(&i2c_sem); return 0; } dev_err(&devdata->client->dev, "i2c read error\n"); if (!retry--) break; msleep(10); } up(&i2c_sem); return ret; }
static int clear_alert(struct tmon_info *data) { struct i2c_client *ara = data->ara; int alrt_stat; alrt_stat = i2c_smbus_read_byte(ara); return 0; }
static int mcsdl_enter_download_mode(void) { int i; int ret = 0; int read_data = 0; uint8_t enter_code[14] = { 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1 }; /* CE set output and low */ ret = gpio_tlmm_config(GPIO_CFG(TS_RESET_GPIO, 0, GPIO_OUTPUT, GPIO_PULL_UP, GPIO_2MA), GPIO_ENABLE); ret = gpio_direction_output(TS_RESET_GPIO, 0); /* config SCL/SDA output mode and set low */ ret = gpio_tlmm_config(GPIO_CFG(TS_SCL_GPIO, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE); ret = gpio_tlmm_config(GPIO_CFG(TS_SDA_GPIO, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE); ret = gpio_direction_output(TS_SCL_GPIO, 0); ret = gpio_direction_output(TS_SDA_GPIO, 0); /* INTR set output and low */ ret = gpio_tlmm_config(GPIO_CFG(TS_INT_GPIO, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE); ret = gpio_direction_output(TS_INT_GPIO, 0); mdelay(100); ret = gpio_direction_output(TS_RESET_GPIO, 1); /* CE set high */ ret = gpio_direction_output(TS_SDA_GPIO, 1); /* SDA set high */ mdelay(25); /* must delay 25msec */ /* input download mode single */ for (i=0; i<14; i++) { if( enter_code[i] ){ ret = gpio_direction_output(TS_INT_GPIO, 1); /* INTR set high */ } else { ret = gpio_direction_output(TS_INT_GPIO, 0); /* INTR set low */ } ret = gpio_direction_output(TS_SCL_GPIO, 1); /* SCL set high */ udelay(15); ret = gpio_direction_output(TS_SCL_GPIO, 0); /* SCL set low */ ret = gpio_direction_output(TS_INT_GPIO, 0); /* INTR set low */ udelay(100); } ret = gpio_direction_output(TS_SCL_GPIO, 1); /* SCL set high */ udelay(100); ret = gpio_direction_output(TS_INT_GPIO, 1); /* INTR set high */ mdelay(1); /* config I/O to i2c mode */ ret = gpio_tlmm_config(GPIO_CFG(TS_SCL_GPIO, 1, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE); ret = gpio_tlmm_config(GPIO_CFG(TS_SDA_GPIO, 1, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE); mdelay(1); read_data = i2c_smbus_read_byte(g_client); if (read_data != 0x55) { /* 0x55 is i2c slave ready status */ printk("mcsdl enter download mode error\n"); return -1; } return 0; /* success */ }
int i2c_readbyte(int i2c_fd) { int byte; if ((byte = i2c_smbus_read_byte(i2c_fd)) < 0) { // perror("Failed to read byte from I2C slave"); return -1; } return byte; }
uint8_t mraa_i2c_read_byte(mraa_i2c_context dev) { uint8_t byte = i2c_smbus_read_byte(dev->fh); if (byte < 0) { return -1; } return byte; }
static int gw_pld_get8(struct gpio_chip *gc, unsigned offset) { struct gw_pld *gw = gpiochip_get_data(gc); s32 val; val = i2c_smbus_read_byte(gw->client); return (val < 0) ? 0 : !!(val & BIT(offset)); }
static void tegra_camera_dump_port_switch_regs(struct nvhost_device *ndev) { #ifdef DEBUG u8 val; val = i2c_smbus_read_byte(port_switch); dev_info(&ndev->dev, "I2C switch reg = 0x%02x\n", val); #endif }
__u8 sensor_read(__u8 uRegAddr) { u8 val; //printk("sensor_read i2c_smbus_read_byte uRegAddr=0x%x\n",uRegAddr); i2c_smbus_write_byte(save_client, uRegAddr); //printk("sensor_read i2c_smbus_write_byte\n"); val = i2c_smbus_read_byte(save_client); return val; }
static int bh1780_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct bh1780_data *bh1780; int err; /* setup private data */ bh1780 = kzalloc(sizeof(struct bh1780_data), GFP_KERNEL); if (!bh1780) { err = -ENOMEM; goto error_0; } mutex_init(&bh1780->enable_mutex); mutex_init(&bh1780->data_mutex); /* setup i2c client */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { err = -ENODEV; goto error_1; } i2c_set_clientdata(client, bh1780); bh1780->client = client; /* detect and init hardware */ if ((err = bh1780_detect(client, NULL))) { goto error_1; } if((err = i2c_smbus_write_byte(bh1780->client, (BH1780_COMMAND_REG + BH1780_PART_REV_REG))) < 0) { dev_err(&client->dev, "I2C write byte error: data=0x%02x\n", (BH1780_COMMAND_REG + BH1780_PART_REV_REG)); goto error_1; } if((err = i2c_smbus_read_byte(client)) < 0) { dev_err(&client->dev, "I2C read byte error\n"); goto error_1; } dev_info(&client->dev, "%s found\n", id->name); dev_info(&client->dev, "part number=%d, rev=%d\n", ((err >> 4) & 0x0F), (err & 0x0F)); bh1780_power_up(bh1780); bh1780_set_delay(&client->dev, BH1780_DEFAULT_DELAY); /* setup driver interfaces */ INIT_DELAYED_WORK(&bh1780->work, bh1780_work_func); if ((err = bh1780_input_init(bh1780)) < 0) goto error_1; if ((err = sysfs_create_group(&bh1780->input->dev.kobj, &bh1780_attribute_group)) < 0) goto error_2; return 0; error_2: bh1780_input_fini(bh1780); error_1: kfree(bh1780); error_0: return err; }
int i2cget(int file,int address) { int i; i = -1; ioctl(file,I2C_SLAVE_FORCE,address); i = i2c_smbus_read_byte(file); printf("read = %d",i); return i; }
int i2c_readbyte(int i2c_id) { // printf ("Read byte %d\n", i2c_id); int data; data = i2c_smbus_read_byte(i2c_buses[i2c_id]); // data = wiringPiI2CRead (i2c_buses[i2c_id]); if (data < 0) return -1; else return data; //return mraa_i2c_read_byte (i2c_buses[i2c_bus]); }
static int ricoh_pmu_check_device(struct i2c_client *client) { int ret = -1; ret = i2c_smbus_read_byte(client); if (ret < 0) { RICOH_DBG("%s, i2c xfer failed, ret:%d\n", __func__, ret); } return ret; }
static int mcsdl_erase_flash(void) { int i; int ret = 0; int read_data = 0; uint8_t i2c_buffer[4] = {0x0F, /* isp erase timing cmd */ 0x01, /* isp erase timing value 0 */ 0xD4, /* isp erase timing value 1 */ 0xC0}; /* isp erase timing value 2 */ /* Send Erase Setting code */ for(i=0; i<4; i++){ ret = i2c_smbus_write_byte(g_client, i2c_buffer[i]); if( 0 != ret ){ printk("mcsdl prepare erase flash error\n"); return -1; } udelay(15); } udelay(500); /* Read Result */ read_data = i2c_smbus_read_byte(g_client); if (read_data != 0x8F) { /* isp ack prepare erase done */ printk("mcsdl erase flash error0\n"); return -1; } mdelay(1); /*Send Erase code */ ret = i2c_smbus_write_byte(g_client, 0x02); if( 0 != ret ){ printk("mcsdl send erase code error\n"); return -1; } mdelay(45); read_data = i2c_smbus_read_byte(g_client); if (read_data != 0x82) { printk("mcsdl erase flash error1\n"); return -1; } return 0; }
static void pcf8591_init_client(struct i2c_client *client) { struct pcf8591_data *data = i2c_get_clientdata(client); data->control = PCF8591_INIT_CONTROL; data->aout = PCF8591_INIT_AOUT; i2c_smbus_write_byte_data(client, data->control, data->aout); i2c_smbus_read_byte(client); }
static int qcikbd_resume(struct device *dev) { struct i2ckbd_drv_data *context = input_get_drvdata(g_qci_keyboard_dev); struct i2c_client *ikbdclient = context->ki2c_client; disable_irq_wake(context->qcikbd_irq); /* consume any keypress generated while suspended */ i2c_smbus_read_byte(ikbdclient); return 0; }
//[*]--------------------------------------------------------------------------------------------------[*] static int bh1780_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct bh1780_data *bh1780; int err; /* setup private data */ bh1780 = kzalloc(sizeof(struct bh1780_data), GFP_KERNEL); if (!bh1780) { pr_err("%s: failed to allocate memory for module\n", __func__); return -ENOMEM; } i2c_set_clientdata(client, bh1780); dev_set_drvdata(&client->dev, bh1780); bh1780->client = client; /* detect and init hardware */ if ((err = bh1780_detect(client, NULL)) != 0) goto error; if((err = i2c_smbus_write_byte(bh1780->client, (BH1780_COMMAND_REG + BH1780_PART_REV_REG))) < 0) { dev_err(&client->dev, "I2C write byte error: data=0x%02x\n", (BH1780_COMMAND_REG + BH1780_PART_REV_REG)); goto error; } if((err = i2c_smbus_read_byte(client)) < 0) { dev_err(&client->dev, "I2C read byte error\n"); goto error; } dev_info(&client->dev, "%s found\n", id->name); dev_info(&client->dev, "part number=%d, rev=%d\n", ((err >> 4) & 0x0F), (err & 0x0F)); bh1780_power_up(bh1780); INIT_DELAYED_WORK(&bh1780->work, bh1780_work_func); #if defined(CONFIG_ODROID_EXYNOS5_IOBOARD_DEBUG) bh1780->enabled = 1; #endif if(bh1780->enabled) schedule_delayed_work(&bh1780->work, BH1780_WORK_PERIOD); if ((err = sysfs_create_group(&client->dev.kobj, &bh1780_attribute_group)) < 0) goto error; printk("\n=================== ioboard_%s ===================\n\n", __func__); return 0; error: printk("\n=================== ioboard_%s FAIL! ===================\n\n", __func__); return err; }