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_DEBUG static 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; return 0; } #endif static const struct v4l2_queryctrl mt9v022_controls[] = { { .id = V4L2_CID_VFLIP, .type = V4L2_CTRL_TYPE_BOOLEAN, .name = "Flip Vertically", .minimum = 0, .maximum = 1, .step = 1, .default_value = 0, }, { .id = V4L2_CID_HFLIP,
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); }