//******************************************************************************
/// \brief Handle calibration messages
/// \return #mxt_rc
static int handle_calibrate_msg(struct mxt_device *mxt, uint8_t *msg,
void *context, uint8_t size)
{
int *last_status = context;
int status = msg[1];
if (mxt_report_id_to_type(mxt, msg[0]) == GEN_COMMANDPROCESSOR_T6) {
if (status & 0x10) {
mxt_dbg(mxt->ctx, "Device calibrating");
} else if (!(status & 0x10) && (*last_status & 0x10)) {
mxt_info(mxt->ctx, "Device calibrated");
return MXT_SUCCESS;
}
*last_status = status;
}
return MXT_MSG_CONTINUE;
}
//******************************************************************************
/// \brief Handle status messages from the T68 Serial Data Command object
/// \return #mxt_rc
static int mxt_t68_get_status(struct mxt_device *mxt, uint8_t *msg,
void *context, uint8_t size)
{
struct t68_ctx *ctx = context;
unsigned int object_type = mxt_report_id_to_type(mxt, msg[0]);
uint8_t status;
mxt_verb(mxt->ctx, "Received message from T%u", object_type);
if (object_type == SERIAL_DATA_COMMAND_T68) {
/* mask off reserved bits */
status = msg[1] & 0x0F;
mxt_t68_print_status(ctx, status);
return (status == 0) ? MXT_SUCCESS : MXT_ERROR_SERIAL_DATA_FAILURE;
} else if (object_type == GEN_COMMANDPROCESSOR_T6) {
print_t6_status(msg[1]);
}
return MXT_MSG_CONTINUE;
}
//******************************************************************************
/// \brief Check status of previously sent command
/// \return #mxt_rc
static int mxt_self_cap_command(struct mxt_device *mxt, uint8_t *msg,
void *context, uint8_t size)
{
unsigned int object_type = mxt_report_id_to_type(mxt, msg[0]);
uint8_t *cmd = context;
mxt_verb(mxt->ctx, "Received message from T%u", object_type);
if (object_type == SPT_SELFCAPGLOBALCONFIG_T109) {
if (msg[1] == *cmd) {
switch (msg[2]) {
case 0:
return MXT_SUCCESS;
case 1:
return MXT_ERROR_SELFCAP_TUNE;
}
}
} else if (object_type == GEN_COMMANDPROCESSOR_T6) {
print_t6_status(msg[1]);
}
return MXT_MSG_CONTINUE;
}
//******************************************************************************
/// \brief Handle messages from the self test object
/// \return #mxt_rc
static int self_test_handle_messages(struct mxt_device *mxt)
{
bool done = false;
int count, i;
time_t now;
time_t start_time = time(NULL);
static const uint8_t TIMEOUT = 10; // seconds
uint8_t buf[10];
int len;
unsigned int object_type;
int ret;
while (!done)
{
mxt_msg_wait(mxt, 100);
now = time(NULL);
if ((now - start_time) > TIMEOUT)
{
mxt_err(mxt->ctx, "Timeout");
return MXT_ERROR_TIMEOUT;
}
ret = mxt_get_msg_count(mxt, &count);
if (ret)
return ret;
if (count > 0)
{
for (i = 0; i < count; i++)
{
ret = mxt_get_msg_bytes(mxt, buf, sizeof(buf), &len);
if (ret)
return ret;
if (len > 0)
{
object_type = mxt_report_id_to_type(mxt, buf[0]);
mxt_verb(mxt->ctx, "Received message from T%u", object_type);
if (object_type == SPT_SELFTEST_T25)
{
switch (buf[1])
{
case SELF_TEST_ALL:
mxt_info(mxt->ctx, "PASS: All tests passed");
ret = MXT_SUCCESS;
break;
case SELF_TEST_INVALID:
mxt_err(mxt->ctx, "FAIL: Invalid test command");
ret = MXT_ERROR_NOT_SUPPORTED;
break;
case SELF_TEST_TIMEOUT:
mxt_err(mxt->ctx, "FAIL: Test timeout");
ret = MXT_ERROR_TIMEOUT;
break;
case SELF_TEST_ANALOG:
mxt_err(mxt->ctx, "FAIL: AVdd Analog power is not present");
ret = MXT_ERROR_SELF_TEST_ANALOG;
break;
case SELF_TEST_PIN_FAULT:
mxt_err(mxt->ctx, "FAIL: Pin fault");
ret = MXT_ERROR_SELF_TEST_PIN_FAULT;
break;
case SELF_TEST_PIN_FAULT_2:
mxt_err(mxt->ctx, "FAIL: Pin fault 2");
ret = MXT_ERROR_SELF_TEST_PIN_FAULT;
break;
case SELF_TEST_AND_GATE:
mxt_err(mxt->ctx, "FAIL: AND Gate Fault");
ret = MXT_ERROR_SELF_TEST_AND_GATE;
break;
case SELF_TEST_SIGNAL_LIMIT:
mxt_err(mxt->ctx, "FAIL: Signal limit fault");
ret = MXT_ERROR_SELF_TEST_SIGNAL_LIMIT;
break;
case SELF_TEST_GAIN:
mxt_err(mxt->ctx, "FAIL: Gain error");
ret = MXT_ERROR_SELF_TEST_GAIN;
break;
default:
mxt_err(mxt->ctx, "Unrecognised status %02X", buf[1]);
ret = MXT_ERROR_UNEXPECTED_DEVICE_STATE;
break;
}
done = true;
}
}
}
}
}
return ret;
}
