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;
}
