自学教程：C++ to_i2c_client函数代码示例

static int max517_resume(struct device *dev){	u8 outbuf = 0;	return i2c_master_send(to_i2c_client(dev), &outbuf, 1);}

int tps6586x_write(struct device *dev, int reg, uint8_t val){	return __tps6586x_write(to_i2c_client(dev), reg, val);}

static struct lm87_data *lm87_update_device(struct device *dev){	struct i2c_client *client = to_i2c_client(dev);	struct lm87_data *data = i2c_get_clientdata(client);	mutex_lock(&data->update_lock);	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {		int i, j;		dev_dbg(&client->dev, "Updating data./n");		i = (data->channel & CHAN_TEMP3) ? 1 : 0;		j = (data->channel & CHAN_TEMP3) ? 5 : 6;		for (; i < j; i++) {			data->in[i] = lm87_read_value(client,				      LM87_REG_IN(i));			data->in_min[i] = lm87_read_value(client,					  LM87_REG_IN_MIN(i));			data->in_max[i] = lm87_read_value(client,					  LM87_REG_IN_MAX(i));		}		for (i = 0; i < 2; i++) {			if (data->channel & CHAN_NO_FAN(i)) {				data->in[6+i] = lm87_read_value(client,						LM87_REG_AIN(i));				data->in_max[6+i] = lm87_read_value(client,						    LM87_REG_AIN_MAX(i));				data->in_min[6+i] = lm87_read_value(client,						    LM87_REG_AIN_MIN(i));			} else {				data->fan[i] = lm87_read_value(client,					       LM87_REG_FAN(i));				data->fan_min[i] = lm87_read_value(client,						   LM87_REG_FAN_MIN(i));			}		}		j = (data->channel & CHAN_TEMP3) ? 3 : 2;		for (i = 0 ; i < j; i++) {			data->temp[i] = lm87_read_value(client,					LM87_REG_TEMP[i]);			data->temp_high[i] = lm87_read_value(client,					     LM87_REG_TEMP_HIGH[i]);			data->temp_low[i] = lm87_read_value(client,					    LM87_REG_TEMP_LOW[i]);		}		i = lm87_read_value(client, LM87_REG_TEMP_HW_INT_LOCK);		j = lm87_read_value(client, LM87_REG_TEMP_HW_INT);		data->temp_crit_int = min(i, j);		i = lm87_read_value(client, LM87_REG_TEMP_HW_EXT_LOCK);		j = lm87_read_value(client, LM87_REG_TEMP_HW_EXT);		data->temp_crit_ext = min(i, j);		i = lm87_read_value(client, LM87_REG_VID_FAN_DIV);		data->fan_div[0] = (i >> 4) & 0x03;		data->fan_div[1] = (i >> 6) & 0x03;		data->vid = (i & 0x0F)			  | (lm87_read_value(client, LM87_REG_VID4) & 0x01)			     << 4;		data->alarms = lm87_read_value(client, LM87_REG_ALARMS1)			     | (lm87_read_value(client, LM87_REG_ALARMS2)				<< 8);		data->aout = lm87_read_value(client, LM87_REG_AOUT);		data->last_updated = jiffies;		data->valid = 1;	}

static int isl29020_runtime_resume(struct device *dev){	struct i2c_client *client = to_i2c_client(dev);	als_set_power_state(client, 1);	return 0;}

static int da311_resume(struct device *dev){	return da311_enable(to_i2c_client(dev), true);}

static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm){	return pcf8563_set_datetime(to_i2c_client(dev), tm);}

int adp5520_write(struct device *dev, int reg, uint8_t val){	return __adp5520_write(to_i2c_client(dev), reg, val);}

static int rv3029c2_rtc_set_time(struct device *dev, struct rtc_time *tm){	return rv3029c2_i2c_set_time(to_i2c_client(dev), tm);}

static int max7300_i2c_read(struct device *dev, unsigned int reg){	struct i2c_client *client = to_i2c_client(dev);	return i2c_smbus_read_byte_data(client, reg);}

static int rx8010_set_alarm(struct device *dev, struct rtc_wkalrm *t){	struct i2c_client *client = to_i2c_client(dev);	struct rx8010_data *rx8010 = dev_get_drvdata(dev);	u8 alarmvals[3];	int extreg, flagreg;	int err;	flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG);	if (flagreg < 0) {		return flagreg;	}	if (rx8010->ctrlreg & (RX8010_CTRL_AIE | RX8010_CTRL_UIE)) {		rx8010->ctrlreg &= ~(RX8010_CTRL_AIE | RX8010_CTRL_UIE);		err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL,						rx8010->ctrlreg);		if (err < 0) {			return err;		}	}	flagreg &= ~RX8010_FLAG_AF;	err = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, flagreg);	if (err < 0)		return err;	alarmvals[0] = bin2bcd(t->time.tm_min);	alarmvals[1] = bin2bcd(t->time.tm_hour);	alarmvals[2] = bin2bcd(t->time.tm_mday);	err = i2c_smbus_write_i2c_block_data(rx8010->client, RX8010_ALMIN,					     2, alarmvals);	if (err < 0)		return err;	extreg = i2c_smbus_read_byte_data(client, RX8010_EXT);	if (extreg < 0)		return extreg;	extreg |= RX8010_EXT_WADA;	err = i2c_smbus_write_byte_data(rx8010->client, RX8010_EXT, extreg);	if (err < 0)		return err;	if (alarmvals[2] == 0)		alarmvals[2] |= RX8010_ALARM_AE;	err = i2c_smbus_write_byte_data(rx8010->client, RX8010_ALWDAY,					alarmvals[2]);	if (err < 0)		return err;	if (t->enabled) {		if (rx8010->rtc->uie_rtctimer.enabled)			rx8010->ctrlreg |= RX8010_CTRL_UIE;		if (rx8010->rtc->aie_timer.enabled)			rx8010->ctrlreg |=				(RX8010_CTRL_AIE | RX8010_CTRL_UIE);		err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL,						rx8010->ctrlreg);		if (err < 0)			return err;	}	return 0;}

static int rv3029c2_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm){	return rv3029c2_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);}

/* Interface active, can use i2c. If it fails, it can indeed mean, that * this wasn't our capture interface, so, we wait for the right one */static int mt9v022_video_probe(struct soc_camera_device *icd){	struct i2c_client *client = to_i2c_client(icd->control);	struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);	struct soc_camera_link *icl = client->dev.platform_data;	s32 data;	int ret;	unsigned long flags;	if (!icd->dev.parent ||	    to_soc_camera_host(icd->dev.parent)->nr != icd->iface)		return -ENODEV;	/* Read out the chip version register */	data = reg_read(client, MT9V022_CHIP_VERSION);	/* must be 0x1311 or 0x1313 */	if (data != 0x1311 && data != 0x1313) {		ret = -ENODEV;		dev_info(&icd->dev, "No MT9V022 detected, ID register 0x%x/n",			 data);		goto ei2c;	}	/* Soft reset */	ret = reg_write(client, MT9V022_RESET, 1);	if (ret < 0)		goto ei2c;	/* 15 clock cycles */	udelay(200);	if (reg_read(client, MT9V022_RESET)) {		dev_err(&icd->dev, "Resetting MT9V022 failed!/n");		goto ei2c;	}	/* Set monochrome or colour sensor type */	if (sensor_type && (!strcmp("colour", sensor_type) ||			    !strcmp("color", sensor_type))) {		ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 4 | 0x11);		mt9v022->model = V4L2_IDENT_MT9V022IX7ATC;		icd->formats = mt9v022_colour_formats;	} else {		ret = reg_write(client, MT9V022_PIXEL_OPERATION_MODE, 0x11);		mt9v022->model = V4L2_IDENT_MT9V022IX7ATM;		icd->formats = mt9v022_monochrome_formats;	}	if (ret < 0)		goto eisis;	icd->num_formats = 0;	/*	 * This is a 10bit sensor, so by default we only allow 10bit.	 * The platform may support different bus widths due to	 * different routing of the data lines.	 */	if (icl->query_bus_param)		flags = icl->query_bus_param(icl);	else		flags = SOCAM_DATAWIDTH_10;	if (flags & SOCAM_DATAWIDTH_10)		icd->num_formats++;	else		icd->formats++;	if (flags & SOCAM_DATAWIDTH_8)		icd->num_formats++;	ret = soc_camera_video_start(icd);	if (ret < 0)		goto eisis;	dev_info(&icd->dev, "Detected a MT9V022 chip ID %x, %s sensor/n",		 data, mt9v022->model == V4L2_IDENT_MT9V022IX7ATM ?		 "monochrome" : "colour");	return 0;eisis:ei2c:	return ret;}

static int mt9v022_set_control(struct soc_camera_device *icd,			       struct v4l2_control *ctrl){	int data;	struct i2c_client *client = to_i2c_client(icd->control);	const struct v4l2_queryctrl *qctrl;	qctrl = soc_camera_find_qctrl(&mt9v022_ops, ctrl->id);	if (!qctrl)		return -EINVAL;	switch (ctrl->id) {	case V4L2_CID_VFLIP:		if (ctrl->value)			data = reg_set(client, MT9V022_READ_MODE, 0x10);		else			data = reg_clear(client, MT9V022_READ_MODE, 0x10);		if (data < 0)			return -EIO;		break;	case V4L2_CID_HFLIP:		if (ctrl->value)			data = reg_set(client, MT9V022_READ_MODE, 0x20);		else			data = reg_clear(client, MT9V022_READ_MODE, 0x20);		if (data < 0)			return -EIO;		break;	case V4L2_CID_GAIN:		/* mt9v022 has minimum == default */		if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)			return -EINVAL;		else {			unsigned long range = qctrl->maximum - qctrl->minimum;			/* Datasheet says 16 to 64. autogain only works properly			 * after setting gain to maximum 14. Larger values			 * produce "white fly" noise effect. On the whole,			 * manually setting analog gain does no good. */			unsigned long gain = ((ctrl->value - qctrl->minimum) *					      10 + range / 2) / range + 4;			if (gain >= 32)				gain &= ~1;			/* The user wants to set gain manually, hope, she			 * knows, what she's doing... Switch AGC off. */			if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x2) < 0)				return -EIO;			dev_info(&icd->dev, "Setting gain from %d to %lu/n",				 reg_read(client, MT9V022_ANALOG_GAIN), gain);			if (reg_write(client, MT9V022_ANALOG_GAIN, gain) < 0)				return -EIO;			icd->gain = ctrl->value;		}		break;	case V4L2_CID_EXPOSURE:		/* mt9v022 has maximum == default */		if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)			return -EINVAL;		else {			unsigned long range = qctrl->maximum - qctrl->minimum;			unsigned long shutter = ((ctrl->value - qctrl->minimum) *						 479 + range / 2) / range + 1;			/* The user wants to set shutter width manually, hope,			 * she knows, what she's doing... Switch AEC off. */			if (reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x1) < 0)				return -EIO;			dev_dbg(&icd->dev, "Shutter width from %d to %lu/n",				reg_read(client, MT9V022_TOTAL_SHUTTER_WIDTH),				shutter);			if (reg_write(client, MT9V022_TOTAL_SHUTTER_WIDTH,				      shutter) < 0)				return -EIO;			icd->exposure = ctrl->value;		}		break;	case V4L2_CID_AUTOGAIN:		if (ctrl->value)			data = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x2);		else			data = reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x2);		if (data < 0)			return -EIO;		break;	case V4L2_CID_EXPOSURE_AUTO:		if (ctrl->value)			data = reg_set(client, MT9V022_AEC_AGC_ENABLE, 0x1);		else			data = reg_clear(client, MT9V022_AEC_AGC_ENABLE, 0x1);		if (data < 0)			return -EIO;		break;	}	return 0;}

static int mt9v022_set_fmt(struct soc_camera_device *icd,			   struct v4l2_format *f){	struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);	struct v4l2_pix_format *pix = &f->fmt.pix;	struct v4l2_rect rect = {		.left	= icd->x_current,		.top	= icd->y_current,		.width	= pix->width,		.height	= pix->height,	};	/* The caller provides a supported format, as verified per call to	 * icd->try_fmt(), datawidth is from our supported format list */	switch (pix->pixelformat) {	case V4L2_PIX_FMT_GREY:	case V4L2_PIX_FMT_Y16:		if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATM)			return -EINVAL;		break;	case V4L2_PIX_FMT_SBGGR8:	case V4L2_PIX_FMT_SBGGR16:		if (mt9v022->model != V4L2_IDENT_MT9V022IX7ATC)			return -EINVAL;		break;	case 0:		/* No format change, only geometry */		break;	default:		return -EINVAL;	}	/* No support for scaling on this camera, just crop. */	return mt9v022_set_crop(icd, &rect);}static int mt9v022_try_fmt(struct soc_camera_device *icd,			   struct v4l2_format *f){	struct v4l2_pix_format *pix = &f->fmt.pix;	v4l_bound_align_image(&pix->width, 48, 752, 2 /* ? */,			      &pix->height, 32 + icd->y_skip_top,			      480 + icd->y_skip_top, 0, 0);	return 0;}static int mt9v022_get_chip_id(struct soc_camera_device *icd,			       struct v4l2_dbg_chip_ident *id){	struct mt9v022 *mt9v022 = container_of(icd, struct mt9v022, icd);	if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)		return -EINVAL;	if (id->match.addr != mt9v022->client->addr)		return -ENODEV;	id->ident	= mt9v022->model;	id->revision	= 0;	return 0;}#ifdef CONFIG_VIDEO_ADV_DEBUGstatic int mt9v022_get_register(struct soc_camera_device *icd,				struct v4l2_dbg_register *reg){	struct i2c_client *client = to_i2c_client(icd->control);	if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)		return -EINVAL;	if (reg->match.addr != client->addr)		return -ENODEV;	reg->size = 2;	reg->val = reg_read(client, reg->reg);	if (reg->val > 0xffff)		return -EIO;	return 0;}static int mt9v022_set_register(struct soc_camera_device *icd,				struct v4l2_dbg_register *reg){	struct i2c_client *client = to_i2c_client(icd->control);	if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)		return -EINVAL;	if (reg->match.addr != client->addr)		return -ENODEV;	if (reg_write(client, reg->reg, reg->val) < 0)		return -EIO;//.........这里部分代码省略.........

static int hym8563_rtc_set_time(struct device *dev, struct rtc_time *tm){	return hym8563_set_time(to_i2c_client(dev), tm);}

static int match_name(struct device *dev, void *data){	const char *name = data;	struct i2c_client *client = to_i2c_client(dev);	return !strncmp(client->name, name, strlen(client->name));}

static int hym8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm){		struct i2c_client *client = to_i2c_client(dev);	struct hym8563 *hym8563 = i2c_get_clientdata(client);	struct rtc_time now, *tm = &alarm->time;	u8 regs[4] = { 0, };	u8 mon_day;		unsigned long	alarm_sec, now_sec;	int diff_sec = 0;		pr_debug("%4d-%02d-%02d(%d) %02d:%02d:%02d enabled %d/n",		1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,		tm->tm_hour, tm->tm_min, tm->tm_sec, alarm->enabled);			hym8563_read_datetime(client, &now);		mutex_lock(&hym8563->mutex);	rtc_tm_to_time(tm, &alarm_sec);	rtc_tm_to_time(&now, &now_sec);		diff_sec = alarm_sec - now_sec;		if((diff_sec > 0) && (diff_sec < 256))	{			printk("%s:diff_sec= %ds , use time/n",__func__, diff_sec);											if (alarm->enabled == 1)		{			hym8563_set_count(client, diff_sec);			hym8563_enable_count(client, 1);		}					else		{			hym8563_enable_count(client, 0);		}			}	else	{						printk("%s:diff_sec= %ds , use alarm/n",__func__, diff_sec);		hym8563_enable_count(client, 0);				if(tm->tm_sec > 0)		{			rtc_tm_to_time(tm, &alarm_sec);			rtc_time_to_tm(alarm_sec, tm);		}		hym8563->alarm = *alarm;		regs[0] = 0x0;		hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);		mon_day = rtc_month_days(tm->tm_mon, tm->tm_year + 1900);		hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);		if (tm->tm_min >= 60 || tm->tm_min < 0)		//set  min		regs[0x00] = bin2bcd(0x00) & 0x7f;		else		regs[0x00] = bin2bcd(tm->tm_min) & 0x7f;		if (tm->tm_hour >= 24 || tm->tm_hour < 0)	//set  hour		regs[0x01] = bin2bcd(0x00) & 0x7f;		else		regs[0x01] = bin2bcd(tm->tm_hour) & 0x7f;		regs[0x03] = bin2bcd (tm->tm_wday) & 0x7f;		/* if the input month day is bigger than the biggest day of this month, set the biggest day */		if (tm->tm_mday > mon_day)		regs[0x02] = bin2bcd(mon_day) & 0x7f;		else if (tm->tm_mday > 0)		regs[0x02] = bin2bcd(tm->tm_mday) & 0x7f;		else if (tm->tm_mday <= 0)		regs[0x02] = bin2bcd(0x01) & 0x7f;		hym8563_i2c_set_regs(client, RTC_A_MIN, regs, 4);			hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);			hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);		if (alarm->enabled == 1)		regs[0] |= AIE;		else		regs[0] &= 0x0;		hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);		hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);		if(diff_sec <= 0)		{					pr_info("alarm sec  <= now sec/n");		}				}		mutex_unlock(&hym8563->mutex);	return 0;}

struct i2c_client *i2c_find_client_by_name(char *name){	struct device *dev = bus_find_device(&i2c_bus_type, NULL,						name, match_name);	return dev ? to_i2c_client(dev) : NULL;}

static struct gl520_data *gl520_update_device(struct device *dev){    struct i2c_client *client = to_i2c_client(dev);    struct gl520_data *data = i2c_get_clientdata(client);    int val, i;    mutex_lock(&data->update_lock);    if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {        dev_dbg(&client->dev, "Starting gl520sm update/n");        data->alarms = gl520_read_value(client, GL520_REG_ALARMS);        data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);        data->vid = gl520_read_value(client,                                     GL520_REG_VID_INPUT) & 0x1f;        for (i = 0; i < 4; i++) {            data->in_input[i] = gl520_read_value(client,                                                 GL520_REG_IN_INPUT[i]);            val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);            data->in_min[i] = val & 0xff;            data->in_max[i] = (val >> 8) & 0xff;        }        val = gl520_read_value(client, GL520_REG_FAN_INPUT);        data->fan_input[0] = (val >> 8) & 0xff;        data->fan_input[1] = val & 0xff;        val = gl520_read_value(client, GL520_REG_FAN_MIN);        data->fan_min[0] = (val >> 8) & 0xff;        data->fan_min[1] = val & 0xff;        data->temp_input[0] = gl520_read_value(client,                                               GL520_REG_TEMP_INPUT[0]);        data->temp_max[0] = gl520_read_value(client,                                             GL520_REG_TEMP_MAX[0]);        data->temp_max_hyst[0] = gl520_read_value(client,                                 GL520_REG_TEMP_MAX_HYST[0]);        val = gl520_read_value(client, GL520_REG_FAN_DIV);        data->fan_div[0] = (val >> 6) & 0x03;        data->fan_div[1] = (val >> 4) & 0x03;        data->fan_off = (val >> 2) & 0x01;        data->alarms &= data->alarm_mask;        val = gl520_read_value(client, GL520_REG_CONF);        data->beep_enable = !((val >> 2) & 1);        /* Temp1 and Vin4 are the same input */        if (data->two_temps) {            data->temp_input[1] = gl520_read_value(client,                                                   GL520_REG_TEMP_INPUT[1]);            data->temp_max[1] = gl520_read_value(client,                                                 GL520_REG_TEMP_MAX[1]);            data->temp_max_hyst[1] = gl520_read_value(client,                                     GL520_REG_TEMP_MAX_HYST[1]);        } else {            data->in_input[4] = gl520_read_value(client,                                                 GL520_REG_IN_INPUT[4]);            data->in_min[4] = gl520_read_value(client,                                               GL520_REG_IN_MIN[4]);            data->in_max[4] = gl520_read_value(client,                                               GL520_REG_IN_MAX[4]);        }        data->last_updated = jiffies;        data->valid = 1;    }

/* pec used for ADM1032 only */static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,			char *buf){	struct i2c_client *client = to_i2c_client(dev);	return sprintf(buf, "%d/n", !!(client->flags & I2C_CLIENT_PEC));}

int adp5520_read(struct device *dev, int reg, uint8_t *val){	return __adp5520_read(to_i2c_client(dev), reg, val);}

static struct lm90_data *lm90_update_device(struct device *dev){	struct i2c_client *client = to_i2c_client(dev);	struct lm90_data *data = i2c_get_clientdata(client);	mutex_lock(&data->update_lock);	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {		u8 h, l;		dev_dbg(&client->dev, "Updating lm90 data./n");		lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);		lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);		lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);		lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);		if (data->kind == max6657 || data->kind == max6646) {			lm90_read16(client, LM90_REG_R_LOCAL_TEMP,				    MAX6657_REG_R_LOCAL_TEMPL,				    &data->temp11[4]);		} else {			if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,					  &h) == 0)				data->temp11[4] = h << 8;		}		lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,			    LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {			data->temp11[1] = h << 8;			if (data->kind != max6657 && data->kind != max6680			 && data->kind != max6646			 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,					  &l) == 0)				data->temp11[1] |= l;		}		if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {			data->temp11[2] = h << 8;			if (data->kind != max6657 && data->kind != max6680			 && data->kind != max6646			 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,					  &l) == 0)				data->temp11[2] |= l;		}		if (data->kind != max6657 && data->kind != max6646) {			if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,					  &h) == 0			 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,					  &l) == 0)				data->temp11[3] = (h << 8) | l;		}		lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);		data->last_updated = jiffies;		data->valid = 1;	}	mutex_unlock(&data->update_lock);	return data;}

static int da311_suspend(struct device *dev){	return da311_enable(to_i2c_client(dev), false);}

static int lis2ds12_resume(struct device *dev){	struct lis2ds12_data *cdata = i2c_get_clientdata(to_i2c_client(dev));	return lis2ds12_common_resume(cdata);}

static int mma8451_suspend(struct device *dev){	struct i2c_client *client = to_i2c_client(dev);	return mma8451_stop_chip(client);}

static int max7310_set_ouputs(struct device *dev, int outputs){	struct i2c_client *client = to_i2c_client(dev);	return max7310_write(client, MAX7310_OUTPUT, outputs);}

int tps6586x_reads(struct device *dev, int reg, int len, uint8_t *val){	return __tps6586x_reads(to_i2c_client(dev), reg, len, val);}

static int hym8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm){		struct i2c_client *client = to_i2c_client(dev);	struct hym8563 *hym8563 = i2c_get_clientdata(client);	struct rtc_time now, *tm = &alarm->time;	u8 regs[4] = { 0, };	u8 mon_day;	pr_debug("%4d-%02d-%02d(%d) %02d:%02d:%02d enabled %d/n",		1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, tm->tm_wday,		tm->tm_hour, tm->tm_min, tm->tm_sec, alarm->enabled);	hym8563_read_datetime(client, &now);	if (alarm->enabled && now.tm_year == tm->tm_year &&	    now.tm_mon == tm->tm_mon && now.tm_mday == tm->tm_mday &&	    now.tm_hour == tm->tm_hour && now.tm_min == tm->tm_min &&	    tm->tm_sec > now.tm_sec) {		long timeout = tm->tm_sec - now.tm_sec + 1;		pr_info("stay awake %lds/n", timeout);		wake_lock_timeout(&hym8563->wake_lock, timeout * HZ);	}	mutex_lock(&hym8563->mutex);	hym8563->alarm = *alarm;	regs[0] = 0x0;	hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);	mon_day = rtc_month_days(tm->tm_mon, tm->tm_year + 1900);	hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);		if (tm->tm_min >= 60 || tm->tm_min < 0)		//set  min		regs[0x00] = bin2bcd(0x00) & 0x7f;	else		regs[0x00] = bin2bcd(tm->tm_min) & 0x7f;	if (tm->tm_hour >= 24 || tm->tm_hour < 0)	//set  hour		regs[0x01] = bin2bcd(0x00) & 0x7f;	else		regs[0x01] = bin2bcd(tm->tm_hour) & 0x7f;	regs[0x03] = bin2bcd (tm->tm_wday) & 0x7f;	/* if the input month day is bigger than the biggest day of this month, set the biggest day */	if (tm->tm_mday > mon_day)		regs[0x02] = bin2bcd(mon_day) & 0x7f;	else if (tm->tm_mday > 0)		regs[0x02] = bin2bcd(tm->tm_mday) & 0x7f;	else if (tm->tm_mday <= 0)		regs[0x02] = bin2bcd(0x01) & 0x7f;	hym8563_i2c_set_regs(client, RTC_A_MIN, regs, 4);		hym8563_i2c_read_regs(client, RTC_A_MIN, regs, 4);		hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);	if (alarm->enabled == 1)		regs[0] |= AIE;	else		regs[0] &= 0x0;	hym8563_i2c_set_regs(client, RTC_CTL2, regs, 1);	hym8563_i2c_read_regs(client, RTC_CTL2, regs, 1);	mutex_unlock(&hym8563->mutex);	return 0;}

static int hinge_bl_read_generic_response(struct hinge_data *data, uint32_t *resp){	int err, retries;	struct i2c_client *client;	struct i2c_msg msg[1];	uint8_t buf[38]; /* framing and command packet with up to 7 args */	uint16_t crc, len;	uint32_t *args;	if (!data || !resp)		return -EINVAL;	client = to_i2c_client(data->dev);	msg[0].addr = HINGE_BL_SLAVE_ADDRESS;	msg[0].flags = I2C_M_RD;	msg[0].len = 1;	msg[0].buf = (void *) buf;	retries = 100;	do {		err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));		CHECK_ERROR(err < 0, error, "Failed to read start byte: %d/n", err);	} while (buf[0] != MCU_PACKET_START_BYTE && retries--);	if (retries < 0) {		err = -ETIMEDOUT;		goto error;	}	msg[0].buf = (void *) &buf[1];	err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));	CHECK_ERROR(err < 0, error, "Failed ready type byte: %d/n", err);	if (buf[1] != MCU_PACKET_TYPE_COMMAND) {		dev_err(data->dev, "Received unexpected type byte while reading response: %02x/n",				buf[1]);		err = -EIO;		goto error;	}	/* read crc and length fields */	msg[0].len = 4;	msg[0].buf = (void *) &buf[2];	err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));	CHECK_ERROR(err < 0, error, "Failed to read payload: %d/n", err);	/* NOTE: assumes little endian host */	len = *((uint16_t *) &buf[2]);	crc = *((uint16_t *) &buf[4]);	if (len > 32) {		dev_err(data->dev, "Slave responded with a payload larger than 32 bytes (%d)./n",				len);		err = -EIO;		goto error;	}	/* read the payload */	msg[0].len = len;	msg[0].buf = (void *) &buf[6];	err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));	CHECK_ERROR(err < 0, error, "Failed to read payload: %d/n", err);	/* validate the response */	if (crc16_packet(buf, 6 + len) != crc) {		dev_err(data->dev, "CRC failure in response packet/n");		err = -EIO;		goto error;	}	dev_info(data->dev, "Response packet: TAG=%02x param count=%02x/n", buf[6], buf[9]);	if (buf[9] != 2) {		dev_err(data->dev, "Expected param count to be 2, found %d/n", buf[9]);		err = -EIO;		goto error;	}	/* read the args */	args = (uint32_t *) &buf[10];	*resp = args[0];	dev_info(data->dev, "Response packet: return code=%u command=%u/n", args[0], args[1]);	return 0;error:	return err;}

static int max517_suspend(struct device *dev){	u8 outbuf = COMMAND_PD;	return i2c_master_send(to_i2c_client(dev), &outbuf, 1);}