static void fsa9480_reg_init(struct fsa9480_usbsw *usbsw) { struct i2c_client *client = usbsw->client; unsigned int ctrl = CON_MASK; int ret; /* mask interrupts (unmask attach/detach only) */ ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0x1ffc); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* mask all car kit interrupts */ ret = i2c_smbus_write_word_data(client, FSA9480_REG_CK_INTMASK1, 0x07ff); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* ADC Detect Time: 500ms */ ret = i2c_smbus_write_byte_data(client, FSA9480_REG_TIMING1, 0x6); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); usbsw->mansw = i2c_smbus_read_byte_data(client, FSA9480_REG_MANSW1); if (usbsw->mansw < 0) dev_err(&client->dev, "%s: err %d\n", __func__, usbsw->mansw); if (usbsw->mansw) ctrl &= ~CON_MANUAL_SW; /* Manual Switching Mode */ ret = i2c_smbus_write_byte_data(client, FSA9480_REG_CTRL, ctrl); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); }
static void fsa9485_reg_init(struct fsa9485_usbsw *usbsw) { struct i2c_client *client = usbsw->client; unsigned int ctrl = CON_MASK; int ret; /* fsa9485_reset */ pr_info("fsa9485_reset\n"); ret = i2c_smbus_write_byte_data(client, FSA9485_REG_MANUAL_OVERRIDES1, 0x01); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); pr_info("fsa9485_reg_init is called\n"); /* mask interrupts (unmask attach/detach only) */ ret = i2c_smbus_write_word_data(client, FSA9485_REG_INT1_MASK, 0x18fc); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* mask all car kit interrupts */ ret = i2c_smbus_write_word_data(client, FSA9485_REG_CK_INTMASK1, 0x07ff); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* ADC Detect Time: 500ms */ ret = i2c_smbus_write_byte_data(client, FSA9485_REG_TIMING1, 0x0); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); usbsw->mansw = i2c_smbus_read_byte_data(client, FSA9485_REG_MANSW1); if (usbsw->mansw < 0) dev_err(&client->dev, "%s: err %d\n", __func__, usbsw->mansw); if (usbsw->mansw) ctrl &= ~CON_MANUAL_SW; /* Manual Switching Mode */ else ctrl &= ~(CON_INT_MASK); ret = i2c_smbus_write_byte_data(client, FSA9485_REG_CTRL, ctrl); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* apply Battery Charging Spec. 1.1 @TA/USB detect */ ret = i2c_smbus_write_byte_data(client, FSA9485_REG_RESERVED_20, 0x04); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); ret = i2c_smbus_read_byte_data(client, FSA9485_REG_DEVID); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); dev_info(&client->dev, " fsa9485_reg_init dev ID: 0x%x\n", ret); }
void dump_info() { #define DEVICE_TYPE 0x0001 #define FW_VERSION 0x0002 #define HW_VERSION 0x0003 #define DF_VERSION 0x001F int res; short data; res = ioctl(i2c_fd, I2C_SLAVE_FORCE, I2C_DEV_NORMAL_ADDR); CHECK(res); printf("===== DUMP INFO 0x%x =====\n", I2C_DEV_NORMAL_ADDR); i2c_smbus_write_word_data(i2c_fd, 0x00, DEVICE_TYPE); i2c_smbus_write_word_data(i2c_fd, 0x01, DEVICE_TYPE); data = i2c_smbus_read_word_data(i2c_fd, 0x00); printf("DEVICE_TYPE: %x\n", data); i2c_smbus_write_word_data(i2c_fd, 0x00, FW_VERSION); i2c_smbus_write_word_data(i2c_fd, 0x01, FW_VERSION); data = i2c_smbus_read_word_data(i2c_fd, 0x00); printf("FW_VERSION: %x\n", data); i2c_smbus_write_word_data(i2c_fd, 0x00, HW_VERSION); i2c_smbus_write_word_data(i2c_fd, 0x01, HW_VERSION); data = i2c_smbus_read_word_data(i2c_fd, 0x00); printf("HW_VERSION: %x\n", data); i2c_smbus_write_word_data(i2c_fd, 0x00, DF_VERSION); i2c_smbus_write_word_data(i2c_fd, 0x01, DF_VERSION); data = i2c_smbus_read_word_data(i2c_fd, 0x00); printf("DF_VERSION: %x\n", data); printf("=====================\n"); }
static int us5182d_setup_prox(struct iio_dev *indio_dev, enum iio_event_direction dir, u16 val) { struct us5182d_data *data = iio_priv(indio_dev); if (dir == IIO_EV_DIR_FALLING) return i2c_smbus_write_word_data(data->client, US5182D_REG_PXL_TH, val); else if (dir == IIO_EV_DIR_RISING) return i2c_smbus_write_word_data(data->client, US5182D_REG_PXH_TH, val); return 0; }
static s32 __locked_start_current_mon(struct i2c_client *client) { s32 retval; s32 shunt_uV; s16 shunt_limit; s16 alert_mask; struct ina230_data *data = i2c_get_clientdata(client); if (!data->pdata->current_threshold) { dev_err(&client->dev, "no current threshold specified\n"); return -EINVAL; } retval = i2c_smbus_write_word_data(client, INA230_CONFIG, __constant_cpu_to_be16(INA230_CONT_CONFIG)); if (retval < 0) { dev_err(&client->dev, "config data write failed sts: 0x%x\n", retval); return retval; } shunt_uV = data->pdata->resistor * data->pdata->current_threshold; if (data->pdata->shunt_polarity_inverted) shunt_uV *= -1; shunt_limit = (s16) uv_to_alert_register(shunt_uV); retval = i2c_smbus_write_word_data(client, INA230_ALERT, cpu_to_be16(shunt_limit)); if (retval < 0) { dev_err(&client->dev, "alert data write failed sts: 0x%x\n", retval); return retval; } alert_mask = shunt_limit >= 0 ? INA230_MASK_SOL : INA230_MASK_SUL; retval = i2c_smbus_write_word_data(client, INA230_MASK, cpu_to_be16(alert_mask)); if (retval < 0) { dev_err(&client->dev, "mask data write failed sts: 0x%x\n", retval); return retval; } data->running = true; return 0; }
// ----------------------------------------------------------------------------- int iI2cWriteReg16 (int fd, uint8_t reg, uint16_t value) { int i = i2c_smbus_write_word_data (fd, reg, value); vI2cPrintDebug (i, __func__); return i; }
static void menf21bmc_wdt_shutdown(struct platform_device *pdev) { struct menf21bmc_wdt *drv_data = platform_get_drvdata(pdev); i2c_smbus_write_word_data(drv_data->i2c_client, BMC_CMD_WD_OFF, BMC_WD_OFF_VAL); }
static ssize_t show_alarm(struct device *dev, struct device_attribute *da, char *buf) { struct sensor_device_attribute *attr = to_sensor_dev_attr(da); struct ds620_data *data = ds620_update_client(dev); struct i2c_client *client = to_i2c_client(dev); u16 conf, new_conf; int res; if (IS_ERR(data)) return PTR_ERR(data); /* reset alarms if necessary */ res = i2c_smbus_read_word_data(client, DS620_REG_CONF); if (res < 0) return res; conf = swab16(res); new_conf = conf; new_conf &= ~attr->index; if (conf != new_conf) { res = i2c_smbus_write_word_data(client, DS620_REG_CONF, swab16(new_conf)); if (res < 0) return res; } return sprintf(buf, "%d\n", !!(conf & attr->index)); }
/* NOTE: we can't currently rely on fault codes to come from SMBus * calls, so we map all errors to EIO here and return zero otherwise. */ static int pca9539_write_reg(struct pca9539_chip *chip, int reg, uint16_t val) { if (i2c_smbus_write_word_data(chip->client, reg, val) < 0) return -EIO; else return 0; }
void setAudioTable(int table_value) { AcousticTable_val = table_value; i2c_smbus_write_word_data(EC_Bat_device->client,0x44,table_value); }
static void ds620_init_client(struct i2c_client *client) { struct ds620_platform_data *ds620_info = client->dev.platform_data; u16 conf, new_conf; new_conf = conf = swab16(i2c_smbus_read_word_data(client, DS620_REG_CONF)); /* switch to continuous conversion mode */ new_conf &= ~DS620_REG_CONFIG_1SHOT; /* already high at power-on, but don't trust the BIOS! */ new_conf |= DS620_REG_CONFIG_PO2; /* thermostat mode according to platform data */ if (ds620_info && ds620_info->pomode == 1) new_conf &= ~DS620_REG_CONFIG_PO1; /* PO_LOW */ else if (ds620_info && ds620_info->pomode == 2) new_conf |= DS620_REG_CONFIG_PO1; /* PO_HIGH */ else new_conf &= ~DS620_REG_CONFIG_PO2; /* always low */ /* with highest precision */ new_conf |= DS620_REG_CONFIG_R1 | DS620_REG_CONFIG_R0; if (conf != new_conf) i2c_smbus_write_word_data(client, DS620_REG_CONF, swab16(new_conf)); /* start conversion */ i2c_smbus_write_byte(client, DS620_COM_START); }
static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value) { if ((reg >= 0x07) && (reg <= 0x0c)) return i2c_smbus_write_word_data(client, reg, swab16(value)); else return i2c_smbus_write_byte_data(client, reg, value); }
/** * cm32181_write_als_it() - Write sensor integration time * @cm32181: pointer of struct cm32181. * @val: integration time by millisecond. * * Convert integration time (ms) to sensor value. * * Return: i2c_smbus_write_word_data command return value. */ static int cm32181_write_als_it(struct cm32181_chip *cm32181, int val) { struct i2c_client *client = cm32181->client; u16 als_it; int ret, i, n; n = ARRAY_SIZE(als_it_value); for (i = 0; i < n; i++) if (val <= als_it_value[i]) break; if (i >= n) i = n - 1; als_it = als_it_bits[i]; als_it <<= CM32181_CMD_ALS_IT_SHIFT; mutex_lock(&cm32181->lock); cm32181->conf_regs[CM32181_REG_ADDR_CMD] &= ~CM32181_CMD_ALS_IT_MASK; cm32181->conf_regs[CM32181_REG_ADDR_CMD] |= als_it; ret = i2c_smbus_write_word_data(client, CM32181_REG_ADDR_CMD, cm32181->conf_regs[CM32181_REG_ADDR_CMD]); mutex_unlock(&cm32181->lock); return ret; }
/** * cm32181_reg_init() - Initialize CM32181 registers * @cm32181: pointer of struct cm32181. * * Initialize CM32181 ambient light sensor register to default values. * * Return: 0 for success; otherwise for error code. */ static int cm32181_reg_init(struct cm32181_chip *cm32181) { struct i2c_client *client = cm32181->client; int i; s32 ret; ret = i2c_smbus_read_word_data(client, CM32181_REG_ADDR_ID); if (ret < 0) return ret; /* check device ID */ if ((ret & 0xFF) != 0x81) return -ENODEV; /* Default Values */ cm32181->conf_regs[CM32181_REG_ADDR_CMD] = CM32181_CMD_ALS_ENABLE | CM32181_CMD_ALS_IT_DEFAULT | CM32181_CMD_ALS_SM_DEFAULT; cm32181->calibscale = CM32181_CALIBSCALE_DEFAULT; /* Initialize registers*/ for (i = 0; i < CM32181_CONF_REG_NUM; i++) { ret = i2c_smbus_write_word_data(client, cm32181_reg[i], cm32181->conf_regs[i]); if (ret < 0) return ret; } return 0; }
static ssize_t bq275x0_attr_store(struct device_driver *driver, char *buf) { int iRet = 0; if(NULL == buf) { return -1; } if(0 == strncmp(buf, BSP_UPGRADE_FIRMWARE_BQFS_CMD, strlen(BSP_UPGRADE_FIRMWARE_BQFS_CMD))) { /*enter firmware bqfs download*/ gBq275x0DownloadFirmwareFlag = BSP_FIRMWARE_DOWNLOAD_MODE; iRet = bq275x0_update_firmware(g_battery_measure_by_bq275x0_i2c_client, BSP_UPGRADE_FIRMWARE_BQFS_NAME); gBq275x0DownloadFirmwareFlag = BSP_NORMAL_MODE; } else if(0 == strncmp(buf, BSP_UPGRADE_FIRMWARE_DFFS_CMD, strlen(BSP_UPGRADE_FIRMWARE_DFFS_CMD))) { /*enter firmware dffs download*/ gBq275x0DownloadFirmwareFlag = BSP_FIRMWARE_DOWNLOAD_MODE; iRet = bq275x0_update_firmware(g_battery_measure_by_bq275x0_i2c_client, BSP_UPGRADE_FIRMWARE_DFFS_NAME); gBq275x0DownloadFirmwareFlag = BSP_NORMAL_MODE; } i2c_smbus_write_word_data(g_battery_measure_by_bq275x0_i2c_client,0x00,0x0021); return iRet; }
/** * cm3218_write_als_it() - Write sensor integration time * @cm3218: pointer of struct cm3218. * @val: integration time in second. * @val2: integration time in millisecond. * * Convert integration time to sensor value. * * Return: i2c_smbus_write_word_data command return value. */ static int cm3218_write_als_it(struct cm3218_chip *chip, int val, int val2) { u16 als_it, cmd; int i; s32 ret; for (i = 0; i < ARRAY_SIZE(cm3218_als_it_scales); i++) { if (val == cm3218_als_it_scales[i].val && val2 == cm3218_als_it_scales[i].val2) { als_it = cm3218_als_it_scales[i].it; als_it <<= CM3218_CMD_ALS_IT_SHIFT; cmd = chip->conf_regs[CM3218_REG_ADDR_CMD] & ~CM3218_CMD_ALS_IT_MASK; cmd |= als_it; ret = i2c_smbus_write_word_data( chip->als_client, CM3218_REG_ADDR_CMD, cmd); if (ret < 0) return ret; chip->conf_regs[CM3218_REG_ADDR_CMD] = cmd; return 0; } } return -EINVAL; }
static inline int tsc2004_write_word_data(struct tsc2004 *tsc, u8 cmd, u16 data) { u16 val; val = cpu_to_be16(data); return i2c_smbus_write_word_data(tsc->client, cmd, val); }
static int __devinit stv_mbx_poweroff_probe(struct i2c_client *client, const struct i2c_device_id *id) { u16 data; int res = 0; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { pr_err("%s: i2c_check_functionality failed\n", __FUNCTION__); res = -ENODEV; goto out; } /* remember our client */ stv_mbx_poweroff_client = client; /* setup power handling */ data = i2c_smbus_read_word_data(stv_mbx_poweroff_client, STV_MBX_PWR_ADDRESS); printk("stv_mbx_poweroff_probe, status reg = 0x%x\n", data); /* enable power control */ data &= ~ATV_MBX_PWR_DISABLE; /* set hw power button to power off when held for > 3 seconds. */ data |= ATV_MBX_PWR_HW_BUTTON; /* set ir power button to power off when held for > 3 seconds. */ data |= ATV_MBX_PWR_IR_BUTTON; i2c_smbus_write_word_data(stv_mbx_poweroff_client, STV_MBX_PWR_ADDRESS, data); /* hook the poweroff power mananger routine*/ pm_power_off = stv_mbx_poweroff; out: return res; }
/* ALS polling routine */ static void tmd2771x_als_polling_work_handler(struct work_struct *work) { struct i2c_client *client=data->client; int cdata, irdata, pdata; int luxValue=0; //1. work queue is reentrant in SMP. //2. serveral function here calls need mutex. mutex_lock(&data->update_lock); cdata = i2c_smbus_read_word_data(client, CMD_WORD|TMD2771X_CDATAL_REG); irdata = i2c_smbus_read_word_data(client, CMD_WORD|TMD2771X_IRDATAL_REG); pdata = i2c_smbus_read_word_data(client, CMD_WORD|TMD2771X_PDATAL_REG); if ((cdata < 0) || (irdata < 0) || (pdata < 0)) { mutex_unlock(&data->update_lock); return; } luxValue = LuxCalculation(client, cdata, irdata); luxValue = luxValue>0 ? luxValue : 0; luxValue = luxValue<10000 ? luxValue : 10000; light_data = luxValue; //printk("%s: lux = %d cdata = %x irdata = %x pdata = %x \n", __func__, luxValue, cdata, irdata, pdata); // check PS under sunlight if ( (data->ps_detection == 1) && (cdata > (75*(1024*(256-data->atime)))/100)) // PS was previously in far-to-near condition { // need to inform input event as there will be no interrupt from the PS input_report_abs(data->input_dev_ps, ABS_DISTANCE, 1);/* NEAR-to-FAR detection */ input_sync(data->input_dev_ps); i2c_smbus_write_word_data(client, CMD_WORD|TMD2771X_PILTL_REG, 0); i2c_smbus_write_word_data(client, CMD_WORD|TMD2771X_PIHTL_REG, data->ps_threshold); data->pilt = 0; data->piht = data->ps_threshold; data->ps_detection = 0; /* near-to-far detected */ printk("tmd2771x_proximity_handler = FAR\n"); } input_report_abs(data->input_dev_als, ABS_MISC, luxValue); // report the lux level input_sync(data->input_dev_als); schedule_delayed_work(&data->als_dwork, msecs_to_jiffies(data->als_poll_delay)); // restart timer mutex_unlock(&data->update_lock); }
static void apds990x_change_als_threshold(struct i2c_client *client) { struct apds990x_data *data = i2c_get_clientdata(client); int cdata, irdata; int luxValue=0; cdata = i2c_smbus_read_word_data(client, CMD_WORD|APDS990x_CDATAL_REG); irdata = i2c_smbus_read_word_data(client, CMD_WORD|APDS990x_IRDATAL_REG); luxValue = LuxCalculation(client, cdata, irdata); luxValue = luxValue>0 ? luxValue : 0; luxValue = luxValue<10000 ? luxValue : 10000; // check PS under sunlight if ( (data->ps_detection == 1) && (cdata > (75*(1024*(256-data->atime)))/100)) // PS was previously in far-to-near condition { // need to inform input event as there will be no interrupt from the PS input_report_abs(data->input_dev_ps, ABS_DISTANCE, 0);/* NEAR-to-FAR detection */ input_sync(data->input_dev_ps); i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_PILTL_REG, 0); i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_PIHTL_REG, data->ps_threshold); data->pilt = 0; data->piht = data->ps_threshold; data->ps_detection = 0; /* near-to-far detected */ printk("apds_990x_proximity_handler = FAR\n"); } input_report_abs(data->input_dev_als, ABS_MISC, luxValue); // report the lux level input_sync(data->input_dev_als); data->als_data = cdata; data->als_threshold_l = (data->als_data * (100-APDS990x_ALS_THRESHOLD_HSYTERESIS) ) /100; data->als_threshold_h = (data->als_data * (100+APDS990x_ALS_THRESHOLD_HSYTERESIS) ) /100; if (data->als_threshold_h >= 65535) data->als_threshold_h = 65535; i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_AILTL_REG, data->als_threshold_l); i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_AIHTL_REG, data->als_threshold_h); }
static void fsa9480_reg_init(struct fsa9480_usbsw *usbsw, int mansw_set) { struct i2c_client *client = usbsw->client; unsigned int ctrl = CON_MASK; int ret; /* mask interrupts (unmask attach/detach/ovp_dcp_dis/ ovp_en only) */ ret = i2c_smbus_write_word_data(client, FSA9480_REG_INT1_MASK, 0xFF5C); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* mask all car kit interrupts */ ret = i2c_smbus_write_word_data(client, FSA9480_REG_CK_INTMASK1, 0x07ff); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); /* ADC Detect Time: 500ms */ ret = i2c_smbus_write_byte_data(client, FSA9480_REG_TIMING1, 0x6); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); if (mansw_set) { if (usbsw->mansw) { ret = i2c_smbus_write_byte_data(client, FSA9480_REG_MANSW1, usbsw->mansw); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); ctrl &= ~CON_MANUAL_SW; /* Manual Switching Mode */ } ret = i2c_smbus_write_byte_data(client, FSA9480_REG_CTRL, ctrl); } else { usbsw->mansw = i2c_smbus_read_byte_data(client, FSA9480_REG_MANSW1); if (usbsw->mansw < 0) dev_err(&client->dev, "%s: err %d\n", __func__, usbsw->mansw); } #if (defined(CONFIG_MHL_SWITCH) && defined(CONFIG_MHL_SII9234)) i2c_smbus_write_byte_data(client, FSA9480_REG_INT2_MASK, 0xFE & i2c_smbus_read_byte_data(client, 0x06)); #endif if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); }
static int __devinit ina3221_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ina3221_data *data; int ret, i; data = devm_kzalloc(&client->dev, sizeof(struct ina3221_data), GFP_KERNEL); if (!data) { ret = -ENOMEM; goto exit; } i2c_set_clientdata(client, data); data->plat_data = client->dev.platform_data; mutex_init(&data->mutex); data->mode = TRIGGERED; data->shutdown_complete = 0; /* reset ina3221 */ ret = i2c_smbus_write_word_data(client, INA3221_CONFIG, __constant_cpu_to_be16((INA3221_RESET))); if (ret < 0) { dev_err(&client->dev, "ina3221 reset failure status: 0x%x\n", ret); goto exit_free; } for (i = 0; i < ARRAY_SIZE(ina3221); i++) { ret = device_create_file(&client->dev, &ina3221[i].dev_attr); if (ret) { dev_err(&client->dev, "device_create_file failed.\n"); goto exit_remove; } } data->client = client; data->nb.notifier_call = ina3221_hotplug_notify; register_hotcpu_notifier(&(data->nb)); data->hwmon_dev = hwmon_device_register(&client->dev); if (IS_ERR(data->hwmon_dev)) { ret = PTR_ERR(data->hwmon_dev); goto exit_remove; } /* set ina3221 to power down mode */ ret = __locked_power_down_ina3221(client); if (ret < 0) goto exit_remove; return 0; exit_remove: while (i--) device_remove_file(&client->dev, &ina3221[i].dev_attr); exit_free: devm_kfree(&client->dev, data); exit: return ret; }
static int maven_set_reg_pair(struct i2c_client* c, int reg, int val) { s32 err; err = i2c_smbus_write_word_data(c, reg, val); if (err) printk(KERN_INFO "WriteRegPair(%d) failed\n", reg); return err; }
static int tmd2771x_set_piht(struct i2c_client *client, int threshold) { int ret; ret = i2c_smbus_write_word_data(client, CMD_WORD|TMD2771X_PIHTL_REG, threshold); data->piht = threshold; return ret; }
/*! * Writes to the register via I2C. */ static inline int mt9v111_write_reg(u8 reg, u16 val) { pr_debug("In mt9v111_write_reg (0x%x, 0x%x)\n", reg, val); pr_debug(" write reg %x val %x.\n", reg, val); return i2c_smbus_write_word_data(mt9v111_data.i2c_client, reg, cpu_to_be16(val)); }
s32 ina230_get_current(void) { struct i2c_client *client; struct ina230_data *data; s32 current_mA; int retval; if (!p_ina230_data) return INA230_ERROR; client = p_ina230_data->client; data = p_ina230_data; mutex_lock(&data->mutex); /* fill calib data */ retval = i2c_smbus_write_word_data(client, INA230_CAL, __constant_cpu_to_be16(data->pdata->calibration_data)); if (retval < 0) { dev_err(&client->dev, "calibration data write failed sts: 0x%x\n", retval); mutex_unlock(&data->mutex); return INA230_ERROR; } retval = ensure_enabled_start(client); if (retval < 0) { mutex_unlock(&data->mutex); return INA230_ERROR; } retval = __locked_wait_for_conversion(&client->dev); if (retval) { mutex_unlock(&data->mutex); return INA230_ERROR; } /* getting current readings in milli amps*/ retval = i2c_smbus_read_word_data(client, INA230_CURRENT); if (retval < 0) { mutex_unlock(&data->mutex); return INA230_ERROR; } current_mA = (s16) be16_to_cpu(retval); ensure_enabled_end(client); mutex_unlock(&data->mutex); if (data->pdata->shunt_polarity_inverted) current_mA *= -1; current_mA *= (s16) data->pdata->power_lsb; if (data->pdata->divisor) current_mA /= (s16) data->pdata->divisor; if (data->pdata->precision_multiplier) current_mA /= (s16) data->pdata->precision_multiplier; return current_mA; }
/* ALS polling routine */ static void apds990x_als_polling_work_handler(struct work_struct *work) { struct apds990x_data *data = container_of(work, struct apds990x_data, als_dwork.work); struct i2c_client *client=data->client; int cdata, irdata, pdata; int luxValue=0; cdata = i2c_smbus_read_word_data(client, CMD_WORD|APDS990x_CDATAL_REG); irdata = i2c_smbus_read_word_data(client, CMD_WORD|APDS990x_IRDATAL_REG); pdata = i2c_smbus_read_word_data(client, CMD_WORD|APDS990x_PDATAL_REG); luxValue = LuxCalculation(client, cdata, irdata); luxValue = luxValue>0 ? luxValue : 0; luxValue = luxValue<10000 ? luxValue : 10000; APDSDBG("%s: lux = %d cdata = %x irdata = %x pdata = %x \n", __func__, luxValue, cdata, irdata, pdata); testmode_prox = pdata; testmode_lux = luxValue; // check PS under sunlight if ( (data->ps_detection == 1) && (cdata > (75*(1024*(256-data->atime)))/100)) // PS was previously in far-to-near condition { // need to inform input event as there will be no interrupt from the PS input_report_abs(data->input_dev_ps, ABS_DISTANCE, 0);/* NEAR-to-FAR detection */ input_sync(data->input_dev_ps); i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_PILTL_REG, 0); i2c_smbus_write_word_data(client, CMD_WORD|APDS990x_PIHTL_REG, data->ps_threshold); data->pilt = 0; data->piht = data->ps_threshold; data->ps_detection = 0; /* near-to-far detected */ printk("apds_990x_proximity_handler = FAR\n"); } input_report_abs(data->input_dev_als, ABS_MISC, luxValue); // report the lux level data->input_dev_als->absinfo[ABS_MISC].value = -1; input_sync(data->input_dev_als); schedule_delayed_work(&data->als_dwork, msecs_to_jiffies(data->als_poll_delay)); // restart timer }
static int max17042_write_reg(struct i2c_client *client, u8 reg, u16 value) { int ret = i2c_smbus_write_word_data(client, reg, value); if (ret < 0) dev_err(&client->dev, "%s: err %d\n", __func__, ret); return ret; }
void enter_rom_mode() { printf("enter_rom_mode\n"); int res; res = ioctl(i2c_fd, I2C_SLAVE_FORCE, I2C_DEV_NORMAL_ADDR); CHECK(res); i2c_smbus_write_word_data(i2c_fd, 0x00, 0x0F00); res = ioctl(i2c_fd, I2C_SLAVE, I2C_DEV_ROM_ADDR); CHECK(res); }
static int max17048_write_word(struct i2c_client *client, int reg, u16 value) { int ret; ret = i2c_smbus_write_word_data(client, reg, swab16(value)); if (ret < 0) dev_err(&client->dev, "%s(): Failed in writing register " "0x%02x err %d\n", __func__, reg, ret); return ret; }