int board_cut_off_battery(void) { int rv; uint8_t buf[3]; /* Ship mode command must be sent twice to take effect */ buf[0] = SB_MANUFACTURER_ACCESS & 0xff; buf[1] = PARAM_CUT_OFF_LOW; buf[2] = PARAM_CUT_OFF_HIGH; i2c_lock(I2C_PORT_BATTERY, 1); rv = i2c_xfer(I2C_PORT_BATTERY, BATTERY_ADDR, buf, 3, NULL, 0, I2C_XFER_SINGLE); rv |= i2c_xfer(I2C_PORT_BATTERY, BATTERY_ADDR, buf, 3, NULL, 0, I2C_XFER_SINGLE); i2c_lock(I2C_PORT_BATTERY, 0); return rv; }
void ltc3589_reg_write(unsigned char reg_addr, unsigned char reg_data) { struct imx_i2c_request rq = {0}; rq.ctl_addr = g_pmic_ltc3589_i2c_device.port; rq.dev_addr = g_pmic_ltc3589_i2c_device.address; rq.reg_addr = reg_addr; rq.reg_addr_sz = 1; rq.buffer_sz = 1; rq.buffer = ®_data; i2c_xfer(&rq, I2C_WRITE); }
void cx23885_tbs(struct cx23885_dev *dev) { char buffer[2]; struct i2c_msg msg; msg.addr = 0x4c; msg.flags = I2C_M_TEN; msg.len = 2; msg.buf = buffer; buffer[0] = 0x1f; buffer[1] = 0x80; i2c_xfer(&dev->i2c_bus[2].i2c_adap, &msg, 1); buffer[0] = 0x23; buffer[1] = 0x80; i2c_xfer(&dev->i2c_bus[2].i2c_adap, &msg, 1); }
static int at24cx_write(unsigned int i2c_base_addr, unsigned int addr, unsigned char buf[]) { struct imx_i2c_request rq = {0}; rq.ctl_addr = i2c_base_addr; rq.dev_addr = g_at24cx_i2c_device.address; rq.reg_addr = addr; rq.reg_addr_sz = 2; rq.buffer_sz = 3; rq.buffer = buf; return i2c_xfer(&rq, I2C_WRITE); // return i2c_xfer(i2c_base_addr, &rq, I2C_WRITE); }
/*! * The function sends a power-up command to the FM tuner SI476x. * Command is successfull if the returned status is correct. * * @return TEST_PASSED or TEST_FAILED */ static int si476x_PowerUp(void) { unsigned char buf[10]; si476x_i2c_req.buffer = buf; /* command for power up */ si476x_i2c_req.buffer_sz = 6; buf[0] = POWER_UP_CMD; buf[1] = 0xF7; /* reserved */ buf[2] = 0x28; /* reserved */ buf[3] = 0x07; /* reserved */ buf[4] = 0x01; /* FUNC[7:4] : FREQ[3:0] */ buf[5] = 0x11; /* reserved */ i2c_xfer(&si476x_i2c_req, I2C_WRITE); /* read the status */ si476x_i2c_req.buffer_sz = 1; i2c_xfer(&si476x_i2c_req, I2C_READ); if (buf[0] != 0x80) { printf("Expected status 0x80, read 0x%X\n", buf[0]); return TEST_FAILED; } /* command for function info */ si476x_i2c_req.buffer_sz = 1; buf[0] = FUNC_INFO_CMD; i2c_xfer(&si476x_i2c_req, I2C_WRITE); /* read the status */ si476x_i2c_req.buffer_sz = 7; i2c_xfer(&si476x_i2c_req, I2C_READ); if (buf[0] != 0x80) { printf("Expected status 0x80, read 0x%X\n", buf[0]); return TEST_FAILED; } return TEST_PASSED; }
int i2c_write_read(struct i2c_master *master, u8 addr, u8 *data, int len, u8 *rxdata, int rxlen) { struct i2c_transfer transfer[2]; transfer[0].addr = addr << 1; transfer[0].data = data; transfer[0].len = len; transfer[1].addr = addr << 1 | 1; transfer[1].data = rxdata; transfer[1].len = rxlen; return i2c_xfer(master, transfer, 2); }
static int read(const struct motion_sensor_t *s, vector_3_t v) { uint8_t raw[6]; uint8_t xyz_reg; int ret, range, i, tmp = 0; struct l3gd20_data *data = s->drv_data; ret = is_data_ready(s, &tmp); if (ret != EC_SUCCESS) return ret; /* * If sensor data is not ready, return the previous read data. * Note: return success so that motion senor task can read again * to get the latest updated sensor data quickly. */ if (!tmp) { if (v != s->raw_xyz) memcpy(v, s->raw_xyz, sizeof(s->raw_xyz)); return EC_SUCCESS; } xyz_reg = get_xyz_reg(s->type); /* Read 6 bytes starting at xyz_reg */ i2c_lock(s->port, 1); ret = i2c_xfer(s->port, s->addr, &xyz_reg, 1, raw, 6, I2C_XFER_SINGLE); i2c_lock(s->port, 0); if (ret != EC_SUCCESS) { CPRINTF("[%T %s type:0x%X RD XYZ Error]", s->name, s->type); return ret; } for (i = X; i <= Z; i++) v[i] = ((int16_t)((raw[i * 2 + 1] << 8) | raw[i * 2])); if (s->rot_standard_ref) rotate(v, *s->rot_standard_ref, v); /* apply offset in the device coordinates */ range = get_range(s); for (i = X; i <= Z; i++) v[i] += (data->offset[i] << 5) / range; return EC_SUCCESS; }
static unsigned char ADP1650_reg_read(unsigned int i2c_base_addr, unsigned char reg_addr) { struct imx_i2c_request rq = {0}; unsigned char buf[1]; unsigned char reg_data = 0; rq.dev_addr = ADP1650_I2C_ADDR; rq.reg_addr = reg_addr; rq.reg_addr_sz = 1; rq.buffer_sz = 1; rq.buffer = buf; rq.ctl_addr = i2c_base_addr; i2c_xfer(&rq, I2C_READ); reg_data = buf[0]; return reg_data; }
static int ADP1650_reg_write(unsigned int i2c_base_addr, unsigned char reg_addr, unsigned char reg_val) { struct imx_i2c_request rq = {0}; unsigned char buf[1]; buf[0] = reg_val; rq.ctl_addr = i2c_base_addr; rq.dev_addr = ADP1650_I2C_ADDR; rq.reg_addr = reg_addr; rq.reg_addr_sz = 1; rq.buffer_sz = 1; rq.buffer = buf; return i2c_xfer(&rq, I2C_WRITE); }
static inline int temp_cfg_write(struct i2c_adapter *adap, uint8_t val) { uint8_t buff[2]; struct i2c_msg msg[2]; buff[0] = REG_CONFIG; buff[1] = val; msg[0].addr = 0x4f; msg[0].flags = 0; msg[0].len = 2; msg[0].buf = &buff[0]; return i2c_xfer(adap, msg, 1); }
unsigned char ltc3589_reg_read(unsigned char reg_addr) { struct imx_i2c_request rq = {0}; unsigned char buf[1]; unsigned char reg_data = 0; rq.ctl_addr = g_pmic_ltc3589_i2c_device.port; rq.dev_addr = g_pmic_ltc3589_i2c_device.address; rq.reg_addr = reg_addr; rq.reg_addr_sz = 1; rq.buffer_sz = 1; rq.buffer = buf; i2c_xfer(&rq, I2C_READ); reg_data = buf[0]; return reg_data; }
static int ppl3115_reg_write(unsigned int i2c_base_addr, unsigned char reg_addr, unsigned char reg_val) { struct imx_i2c_request rq = {0}; unsigned char buf[1]; // unsigned char reg_data = 0; buf[0] = reg_val; rq.ctl_addr = i2c_base_addr; rq.dev_addr = PPL3115_I2C_ID; rq.reg_addr = reg_addr; rq.reg_addr_sz = 1; rq.buffer_sz = 1; rq.buffer = buf; return i2c_xfer(&rq, I2C_WRITE); }
static int elan_tp_read_cmd(uint16_t reg, uint16_t *val) { uint8_t buf[2]; int rv; buf[0] = reg; buf[1] = reg >> 8; i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 1); rv = i2c_xfer(CONFIG_TOUCHPAD_I2C_PORT, CONFIG_TOUCHPAD_I2C_ADDR, buf, sizeof(buf), (uint8_t *)val, sizeof(*val), I2C_XFER_SINGLE); i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 0); return rv; }
static int elan_tp_write_cmd(uint16_t reg, uint16_t val) { uint8_t buf[4]; int rv; buf[0] = reg; buf[1] = reg >> 8; buf[2] = val; buf[3] = val >> 8; i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 1); rv = i2c_xfer(CONFIG_TOUCHPAD_I2C_PORT, CONFIG_TOUCHPAD_I2C_ADDR, buf, sizeof(buf), NULL, 0, I2C_XFER_SINGLE); i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 0); return rv; }
static int temp_cfg_read(struct i2c_adapter *adap, uint8_t *val) { uint8_t ptr = REG_CONFIG; struct i2c_msg msg[2]; msg[0].addr = 0x4f; msg[0].flags = 0; msg[0].len = 1; msg[0].buf = &ptr; msg[1].addr = 0x4f; msg[1].flags = I2C_M_RD; msg[1].len = 1; msg[1].buf = val; return i2c_xfer(adap, msg, 2); }
void ssd1306_update(ssd1306_t *ssd) { assert(ssd); ssd1306_cmd1(ssd, SSD1306_SETLOWCOLUMN | 0x0); ssd1306_cmd1(ssd, SSD1306_SETHIGHCOLUMN | 0x0); ssd1306_cmd1(ssd, SSD1306_SETSTARTLINE | 0x0); uint8_t *p = ssd->buf; uint8_t buf[17] ; buf[0] = SSD_DATA_MODE; for (uint16_t i = 0; i < (ssd->width * ssd->height / 8); i += 16) { for (uint8_t x = 1; x <= 16; x++) buf[x] = *p++; i2c_xfer(ssd->i2c_dev, sizeof(buf), buf, 0, NULL); } }
int i2c_read16(int port, int slave_addr, int offset, int *data) { int rv; uint8_t reg, buf[2]; reg = offset & 0xff; /* I2C read 16-bit word: transmit 8-bit offset, and read 16bits */ i2c_lock(port, 1); rv = i2c_xfer(port, slave_addr, ®, 1, buf, 2, I2C_XFER_SINGLE); i2c_lock(port, 0); if (rv) return rv; if (slave_addr & I2C_FLAG_BIG_ENDIAN) *data = ((int)buf[0] << 8) | buf[1]; else *data = ((int)buf[1] << 8) | buf[0]; return EC_SUCCESS; }
void cx23885_av_clk(struct cx23885_dev *dev, int enable) { /* write 0 to bus 2 addr 0x144 via i2x_xfer() */ char buffer[3]; struct i2c_msg msg; dprintk(1, "%s(enabled = %d)\n", __func__, enable); /* Register 0x144 */ buffer[0] = 0x01; buffer[1] = 0x44; if (enable == 1) buffer[2] = 0x05; else buffer[2] = 0x00; msg.addr = 0x44; msg.flags = I2C_M_TEN; msg.len = 3; msg.buf = buffer; i2c_xfer(&dev->i2c_bus[2].i2c_adap, &msg, 1); }
void sil9024_hdmi_power_on1(void) { struct imx_i2c_request rq = {0}; int rc = 0; unsigned char byteOutData; i2c_init(g_pmic_ltc3589_i2c_device.port, g_pmic_ltc3589_i2c_device.freq); /* Initialize some of the I2C imx_i2c_request structure, these parameters shouldn't need to be changed */ rq.ctl_addr = g_pmic_ltc3589_i2c_device.port; rq.dev_addr = g_pmic_ltc3589_i2c_device.address; rq.reg_addr_sz = PMIC_LTC3589_I2C_REG_BYTE; rq.buffer_sz = PMIC_LTC3589_I2C_DATA_BYTE; /* Write to R55 for 1V2 LDO6 output */ byteOutData = 0x40; rq.reg_addr = 55; rq.buffer = &byteOutData; rc = i2c_xfer(&rq, I2C_WRITE); if (rc != 0) { printf("I2C bus error, rc= %d\n", rc); return; } }
static int temp_read(struct i2c_adapter *adap, int reg, int16_t *val) { int err; uint8_t ptr = reg; uint8_t buff[2]; struct i2c_msg msg[2]; msg[0].addr = 0x4f; msg[0].flags = 0; msg[0].len = 1; msg[0].buf = &ptr; msg[1].addr = 0x4f; msg[1].flags = I2C_M_RD; msg[1].len = 2; msg[1].buf = &buff[0]; err = i2c_xfer(adap, msg, 2); if (err >= 0) { *val = ((uint16_t)buff[0] << 8) | buff[1]; } return err; }
int tcpm_get_message(int port, uint32_t *payload, int *head) { int rv, cnt, reg = TCPC_REG_RX_DATA; rv = i2c_read8(I2C_PORT_TCPC, I2C_ADDR_TCPC(port), TCPC_REG_RX_BYTE_CNT, &cnt); rv |= i2c_read16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port), TCPC_REG_RX_HDR, (int *)head); if (rv == EC_SUCCESS && cnt > 0) { i2c_lock(I2C_PORT_TCPC, 1); rv = i2c_xfer(I2C_PORT_TCPC, I2C_ADDR_TCPC(port), (uint8_t *)®, 1, (uint8_t *)payload, cnt, I2C_XFER_SINGLE); i2c_lock(I2C_PORT_TCPC, 0); } /* Read complete, clear RX status alert bit */ i2c_write16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port), TCPC_REG_ALERT, TCPC_REG_ALERT_RX_STATUS); return rv; }
int i2c_write(const imx_i2c_request_t *rq) { return i2c_xfer(rq, I2C_WRITE); }
/* Initialize the controller ICs after reset */ static int elan_tp_init(void) { int rv; uint8_t val[2]; CPRINTS("%s", __func__); elan_tp_write_cmd(ETP_I2C_STAND_CMD, ETP_I2C_RESET); msleep(100); i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 1); rv = i2c_xfer(CONFIG_TOUCHPAD_I2C_PORT, CONFIG_TOUCHPAD_I2C_ADDR, NULL, 0, val, sizeof(val), I2C_XFER_SINGLE); i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 0); CPRINTS("reset rv %d buf=%04x", rv, *((uint16_t *)val)); if (rv) goto out; /* Read min/max */ rv = elan_tp_read_cmd(ETP_I2C_MAX_X_AXIS_CMD, &elan_tp_params.max_x); if (rv) goto out; rv = elan_tp_read_cmd(ETP_I2C_MAX_Y_AXIS_CMD, &elan_tp_params.max_y); if (rv) goto out; /* Read min/max */ rv = elan_tp_read_cmd(ETP_I2C_XY_TRACENUM_CMD, (uint16_t *)val); if (rv) goto out; if (val[0] == 0 || val[1] == 0) { CPRINTS("Invalid XY_TRACENUM"); goto out; } /* ETP_FWIDTH_REDUCE reduces the apparent width to avoid treating large * finger as palm. Multiply value by 2 as HID multitouch divides it. */ elan_tp_params.width_x = 2 * ((elan_tp_params.max_x / val[0]) - ETP_FWIDTH_REDUCE); elan_tp_params.width_y = 2 * ((elan_tp_params.max_y / val[1]) - ETP_FWIDTH_REDUCE); rv = elan_tp_read_cmd(ETP_I2C_PRESSURE_CMD, (uint16_t *)val); if (rv) goto out; elan_tp_params.pressure_adj = (val[0] & 0x10) ? 0 : ETP_PRESSURE_OFFSET; CPRINTS("max=%d/%d width=%d/%d adj=%d", elan_tp_params.max_x, elan_tp_params.max_y, elan_tp_params.width_x, elan_tp_params.width_y, elan_tp_params.pressure_adj); /* Switch to absolute mode */ rv = elan_tp_write_cmd(ETP_I2C_SET_CMD, ETP_ENABLE_ABS); if (rv) goto out; /* Sleep control off */ rv = elan_tp_write_cmd(ETP_I2C_STAND_CMD, ETP_I2C_WAKE_UP); out: CPRINTS("%s:%d", __func__, rv); return rv; }
.len = 2, .buf = addr, }, { .addr = client->addr, .flags = I2C_M_RD, .len = 4, .buf = buf, } }; addr[0] = (reg_addr >> 8); addr[1] = (reg_addr & 0xff); msgs[0].addr = 0x44; msgs[1].addr = 0x44; retval = i2c_xfer(client->adapter, msgs, 2); v = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]; *value = v; return v; } int cx25821_i2c_write(struct cx25821_i2c *bus, u16 reg_addr, int value) { struct i2c_client *client = &bus->i2c_client; int retval = 0; u8 buf[6] = { 0, 0, 0, 0, 0, 0 }; struct i2c_msg msgs[1] = { {
int main_i2c(void) { THROW_BEGIN(); void *gps_socket = scl_get_socket("gps"); THROW_IF(gps_socket == NULL, -EIO); int64_t hwm = 1; zmq_setsockopt(gps_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm)); void *sats_socket = scl_get_socket("sats"); THROW_IF(sats_socket == NULL, -EIO); i2c_bus_t bus; i2c_dev_t device; uint8_t data_w[128]; uint8_t data_r[128]; if (i2c_bus_open(&bus, "/dev/i2c-1")) { syslog(LOG_CRIT, "could not open i2c device"); exit(EXIT_FAILURE); } i2c_dev_init(&device, &bus, I2C_GPS_ADDRESS); msgpack_sbuffer *msgpack_buf = msgpack_sbuffer_new(); THROW_IF(msgpack_buf == NULL, -ENOMEM); msgpack_packer *pk = msgpack_packer_new(msgpack_buf, msgpack_sbuffer_write); THROW_IF(pk == NULL, -ENOMEM); while (1) { msleep(200); data_w[0] = I2C_GPS_STATUS; i2c_xfer(&device, 1, data_w, 1, data_r); msgpack_sbuffer_clear(msgpack_buf); int status = data_r[0]; int fix = 0; if (status & I2C_GPS_STATUS_2DFIX) fix = 2; if (status & I2C_GPS_STATUS_3DFIX) fix = 3; if (fix == 2) msgpack_pack_array(pk, 7); /* 2d fix */ else if (fix == 3) msgpack_pack_array(pk, 9); /* 3d fix */ else msgpack_pack_array(pk, 1); /* no fix */ data_w[0] = I2C_GPS_TIME; i2c_xfer(&device, 1, data_w, 4, data_r); long time = (((long) data_r[3]) << 24) | (((long) data_r[2]) << 16) | (((long) data_r[1]) << 8) | (data_r[0]); time /= 1000; char *time_str = ctime(&time); size_t len = strlen(time_str); msgpack_pack_raw(pk, len); msgpack_pack_raw_body(pk, time_str, len); /* gps array index 0 */ if (fix == 2 || fix == 3) { data_w[0] = I2C_GPS_LOCATION; i2c_xfer(&device, 1, data_w, 8, data_r); PACKD(( (((long) data_r[3]) << 24) | (((long) data_r[2]) << 16) | (((long) data_r[1]) << 8) | (data_r[0])) / 10000000.0); /* latitude, gps array index 1 */ PACKD(( (((long) data_r[7]) << 24) | (((long) data_r[6]) << 16) | (((long) data_r[5]) << 8) | (data_r[4])) / 10000000.0); /* logitude, gps array index 2 */ PACKI((status & I2C_GPS_STATUS_NUMSATS) >> 4); /* gps array index 3 */ data_w[0] = I2C_GPS_GROUND_SPEED; i2c_xfer(&device, 1, data_w, 2, data_r); PACKF(((float)((data_r[1] << 8) | data_r[0])) / 100.0 * 1.94384); /* gps array index 4 */ data_w[0] = I2C_GPS_GROUND_SPEED; i2c_xfer(&device, 1, data_w, 2, data_r); PACKF((data_r[1] << 8) | data_r[0]); /* gps array index 5 */ PACKF(0 /* HDOP */); /* gps array index 6 */ } if (fix == 3) { data_w[0] = I2C_GPS_ALTITUDE; i2c_xfer(&device, 1, data_w, 2, data_r); PACKF(((data_r[1]) << 8) | data_r[0]); /* gps array index 7 */ PACKF(0 /* VDOP */); /* gps array index 8 */ } scl_copy_send_dynamic(gps_socket, msgpack_buf->data, msgpack_buf->size); }
int i2c_write(const i2c_dev_t *dev, const uint8_t val) { return i2c_xfer(dev, 1, &val, 0, NULL); }
int i2c_read_block_reg(const i2c_dev_t *dev, const uint8_t reg, uint8_t *buf, const size_t len) { return i2c_xfer(dev, 1, ®, len, buf); }
int i2c_read(const i2c_dev_t *dev) { uint8_t buf; return i2c_xfer(dev, 0, NULL, 1, &buf); }
int i2c_write_reg(const i2c_dev_t *dev, const uint8_t reg, const uint8_t val) { uint8_t buf[2] = {reg, val}; return i2c_xfer(dev, 2, buf, 0, NULL); }
static int elan_tp_read_report(void) { int rv; uint8_t tp_buf[ETP_I2C_REPORT_LEN]; int i; uint8_t touch_info; uint8_t hover_info; uint8_t *finger = tp_buf+ETP_FINGER_DATA_OFFSET; i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 1); rv = i2c_xfer(CONFIG_TOUCHPAD_I2C_PORT, CONFIG_TOUCHPAD_I2C_ADDR, NULL, 0, tp_buf, ETP_I2C_REPORT_LEN, I2C_XFER_SINGLE); i2c_lock(CONFIG_TOUCHPAD_I2C_PORT, 0); if (rv) { CPRINTS("read report error"); return rv; } CPRINTF("[%T "); #if 0 for (i = 0; i < ETP_I2C_REPORT_LEN; i++) CPRINTF("%02x", tp_buf[i]); CPRINTF(" || "); #endif if (tp_buf[ETP_REPORT_ID_OFFSET] != ETP_REPORT_ID) { CPRINTS("Invalid report id (%x)", tp_buf[ETP_REPORT_ID_OFFSET]); return -1; } touch_info = tp_buf[ETP_TOUCH_INFO_OFFSET]; hover_info = tp_buf[ETP_HOVER_INFO_OFFSET]; if (touch_info & 0x01) CPRINTF("click|"); if (hover_info & 0x40) CPRINTF("hover|"); for (i = 0; i < ETP_MAX_FINGERS; i++) { int valid = touch_info & (1 << (3+i)); if (valid) { int x = ((finger[0] & 0xf0) << 4) | finger[1]; int y = ((finger[0] & 0x0f) << 8) | finger[2]; int width = (finger[3] & 0xf0) >> 4; int height = finger[3] & 0x0f; int pressure = finger[4]; y = elan_tp_params.max_y - y; width = width * elan_tp_params.width_x; height = height * elan_tp_params.width_y; pressure = pressure + elan_tp_params.pressure_adj; if (1) CPRINTF("i=%d %d/%d %d/%d %d|", i, x, y, width, height, pressure); finger += ETP_FINGER_DATA_LEN; } } CPRINTF("]\n"); return 0; }