//******************************************************************************
/// \brief Write packet to MXT chip
/// \return Number of databytes sent
static int hidraw_write_packet(struct mxt_device *mxt, struct hid_packet *write_pkt, uint8_t *byte_count)
{
int ret;
uint8_t pkt_size = write_pkt->rx_bytes + 4; /* allowing for header */
if ((ret = write(mxt->conn->hidraw.fd, write_pkt, pkt_size)) != pkt_size) {
mxt_verb(mxt->ctx, "HIDRAW retry");
usleep(HIDRAW_WRITE_RETRY_DELAY_US);
if ((ret = write(mxt->conn->hidraw.fd, &write_pkt, pkt_size)) != pkt_size) {
mxt_err(mxt->ctx, "Error %s (%d) writing to hidraw",
strerror(errno), errno);
ret = mxt_errno_to_rc(errno);
}
}
mxt_log_buffer(mxt->ctx, LOG_VERBOSE, "PKT TX:",
(const unsigned char *) write_pkt, pkt_size);
*byte_count = ret - 6;
mxt_dbg(mxt->ctx, "Sending packet: size: %d No. data bytes TX: %d",
pkt_size, *byte_count);
return MXT_SUCCESS;
}
//******************************************************************************
/// \brief Read packet from MXT chip
/// \return #mxt_rc
static int hidraw_read_response(struct mxt_device *mxt, struct hid_packet *read_pkt,
size_t count)
{
ssize_t ret = 0;
size_t t_count = 0;
int timeout = 0;
do {
ret = read(mxt->conn->hidraw.fd, read_pkt + t_count, count);
if ((size_t)ret != count) {
mxt_dbg(mxt->ctx, "Error %s (%d) reading from hidraw",
strerror(errno), errno);
ret = mxt_errno_to_rc(errno);
} else {
t_count += (size_t)ret;
}
usleep(HIDRAW_READ_RETRY_DELAY_US);
} while (timeout++ <= HIDRAW_TIMEOUT_DELAY_US && t_count != count);
mxt_dbg(mxt->ctx, "No. bytes requested: %zu, No. of bytes read: %zu",
count, t_count);
mxt_log_buffer(mxt->ctx, LOG_VERBOSE, "RD PKT RX:",
(const unsigned char *) read_pkt, count);
return MXT_SUCCESS;
}
//******************************************************************************
/// \brief Get T5 message as byte array
/// \param mxt Maxtouch Device
/// \param buf Pointer to buffer
/// \param buflen Length of buffer
/// \param count length of message in bytes
/// \return #mxt_rc
int mxt_get_msg_bytes(struct mxt_device *mxt, unsigned char *buf,
size_t buflen, int *count)
{
int ret;
switch (mxt->conn->type) {
case E_SYSFS:
if (sysfs_has_debug_v2(mxt))
ret = sysfs_get_msg_bytes_v2(mxt, buf, buflen, count);
else
ret = dmesg_get_msg_bytes(mxt, buf, buflen, count);
break;
#ifdef HAVE_LIBUSB
case E_USB:
#endif /* HAVE_LIBUSB */
case E_I2C_DEV:
case E_HIDRAW:
ret = t44_get_msg_bytes(mxt, buf, buflen, count);
break;
default:
mxt_err(mxt->ctx, "Device type not supported");
ret = MXT_ERROR_NOT_SUPPORTED;
break;
}
if (ret == MXT_SUCCESS)
mxt_log_buffer(mxt->ctx, LOG_DEBUG, MSG_PREFIX, buf, *count);
return ret;
}
//******************************************************************************
/// \brief Read registers from MXT chip, in blocks
/// \return #mxt_rc
int mxt_read_register(struct mxt_device *mxt, uint8_t *buf,
int start_register, size_t count)
{
int ret;
size_t received;
size_t off = 0;
mxt_verb(mxt->ctx, "%s start_register:%d count:%zu", __func__,
start_register, count);
while (off < count) {
ret = mxt_read_register_block(mxt, buf + off, start_register + off,
count - off, &received);
if (ret)
return ret;
off += received;
}
mxt_log_buffer(mxt->ctx, LOG_VERBOSE, "RX:", buf, count);
return MXT_SUCCESS;
}
//******************************************************************************
/// \brief Write register to MXT chip
/// \return #mxt_rc
int mxt_write_register(struct mxt_device *mxt, uint8_t const *buf,
int start_register, size_t count)
{
int ret;
mxt_verb(mxt->ctx, "%s start_register:%d count:%zu", __func__,
start_register, count);
switch (mxt->conn->type) {
case E_SYSFS:
ret = sysfs_write_register(mxt, buf, start_register, count);
break;
case E_I2C_DEV:
ret = i2c_dev_write_register(mxt, buf, start_register, count);
break;
#ifdef HAVE_LIBUSB
case E_USB:
ret = usb_write_register(mxt, buf, start_register, count);
break;
#endif /* HAVE_LIBUSB */
case E_HIDRAW:
ret = hidraw_write_register(mxt, buf, start_register, count);
break;
default:
mxt_err(mxt->ctx, "Device type not supported");
ret = MXT_ERROR_NOT_SUPPORTED;
}
if (ret == MXT_SUCCESS)
mxt_log_buffer(mxt->ctx, LOG_VERBOSE, "TX:", buf, count);
return ret;
}