G_MODULE_EXPORT gchar * request_interface_version(gint *len)
{
OutputData *output = NULL;
GAsyncQueue *queue = NULL;
FreeEMS_Packet *packet = NULL;
gchar *version = NULL;
GTimeVal tval;
Serial_Params *serial_params = NULL;
guint8 *buf = NULL;
/* Raw packet */
guint8 pkt[INTVER_REQ_PKT_LEN];
gint res = 0;
gint i = 0;
guint8 sum = 0;
gint tmit_len = 0;
serial_params = DATA_GET(global_data,"serial_params");
g_return_val_if_fail(serial_params,NULL);
if (DATA_GET(global_data,"offline"))
return g_strdup("Offline");
pkt[HEADER_IDX] = 0;
pkt[H_PAYLOAD_IDX] = (REQUEST_INTERFACE_VERSION & 0xff00 ) >> 8;
pkt[L_PAYLOAD_IDX] = (REQUEST_INTERFACE_VERSION & 0x00ff );
for (i=0;i<INTVER_REQ_PKT_LEN-1;i++)
sum += pkt[i];
pkt[INTVER_REQ_PKT_LEN-1] = sum;
buf = finalize_packet((guint8 *)&pkt,INTVER_REQ_PKT_LEN,&tmit_len);
queue = g_async_queue_new();
register_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
if (!write_wrapper_f(serial_params->fd,buf, tmit_len, NULL))
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
g_free(buf);
g_async_queue_unref(queue);
return NULL;
}
g_free(buf);
g_get_current_time(&tval);
g_time_val_add(&tval,500000);
packet = g_async_queue_timed_pop(queue,&tval);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
g_async_queue_unref(queue);
/*
if (packet)
printf("Firmware version PACKET ARRIVED!\n");
else
printf("TIMEOUT\n");
*/
if (packet)
{
version = g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length);
if (len)
*len = packet->payload_length;
freeems_packet_cleanup(packet);
}
return version;
}
/*
\brief Per plugin handler which shuts down the RTV stuff. Kills off the
rtv_subscriber thread, dismantles the queue in preparation for plugin shutdown
\returns TRUE
*/
G_MODULE_EXPORT gboolean teardown_rtv(void)
{
GAsyncQueue *queue = NULL;
GThread *thread = NULL;
GMutex *mutex = (GMutex *)DATA_GET(global_data,"rtv_subscriber_mutex");
ENTER();
/* This sends packets to the rtv_subscriber queue */
thread = (GThread *)DATA_GET(global_data,"rtv_subscriber_thread");
if (thread)
{
DATA_SET(global_data,"rtv_subscriber_thread_exit",GINT_TO_POINTER(1));
g_thread_join(thread);
DATA_SET(global_data,"rtv_subscriber_thread",NULL);
DATA_SET(global_data,"rtv_subscriber_thread_exit",NULL);
}
g_mutex_lock(mutex);
queue = (GAsyncQueue *)DATA_GET(global_data,"rtv_subscriber_queue");
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_BASIC_DATALOG);
g_async_queue_unref(queue);
DATA_SET(global_data,"rtv_subscriber_queue",NULL);
g_mutex_unlock(mutex);
DATA_SET(global_data,"realtime_id",NULL);
EXIT();
return TRUE;
}
/*
\brief Queries the ECU for a location ID list
*/
G_MODULE_EXPORT Location_Details *request_location_id_details(guint16 loc_id)
{
OutputData *output = NULL;
GAsyncQueue *queue = NULL;
FreeEMS_Packet *packet = NULL;
GTimeVal tval;
GList *list = NULL;
Serial_Params *serial_params = NULL;
guint8 *buf = NULL;
Location_Details *details = NULL;
/* Raw packet */
guint8 pkt[LOC_ID_DETAILS_REQ_PKT_LEN];
gint res = 0;
gint i = 0;
gint h = 0;
gint l = 0;
gint tmpi = 0;
guint8 sum = 0;
gint tmit_len = 0;
serial_params = DATA_GET(global_data,"serial_params");
g_return_val_if_fail(serial_params,NULL);
pkt[HEADER_IDX] = 0;
pkt[H_PAYLOAD_IDX] = (REQUEST_RETRIEVE_LOCATION_ID_DETAILS & 0xff00 ) >> 8;
pkt[L_PAYLOAD_IDX] = (REQUEST_RETRIEVE_LOCATION_ID_DETAILS & 0x00ff );
pkt[L_PAYLOAD_IDX+1] = (loc_id & 0xff00) >> 8; /* H location bits */
pkt[L_PAYLOAD_IDX+2] = (loc_id & 0x00ff); /* L location bits */
for (i=0;i<LOC_ID_DETAILS_REQ_PKT_LEN-1;i++)
sum += pkt[i];
pkt[LOC_ID_DETAILS_REQ_PKT_LEN-1] = sum;
buf = finalize_packet((guint8 *)&pkt,LOC_ID_DETAILS_REQ_PKT_LEN,&tmit_len);
queue = g_async_queue_new();
register_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LOCATION_ID_DETAILS);
if (!write_wrapper_f(serial_params->fd,buf, tmit_len, NULL))
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LOCATION_ID_DETAILS);
g_free(buf);
g_async_queue_unref(queue);
return NULL;
}
g_free(buf);
g_get_current_time(&tval);
g_time_val_add(&tval,500000);
packet = g_async_queue_timed_pop(queue,&tval);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LOCATION_ID_DETAILS);
g_async_queue_unref(queue);
if (packet)
{
/*printf("packet payload length %i\n",packet->payload_length);*/
if (packet->payload_length != 12)
printf("ERROR in locationID details response!\n");
details = g_new0(Location_Details, 1);
tmpi = 0;
h = packet->data[packet->payload_base_offset];
l = packet->data[packet->payload_base_offset+1];
details->flags = (h << 8) + l;
/*printf("loc id details flags %i\n",details->flags);*/
h = packet->data[packet->payload_base_offset+2];
l = packet->data[packet->payload_base_offset+3];
details->parent = (h << 8) + l;
/*printf("loc id details parent %i\n",details->parent);*/
details->ram_page = packet->data[packet->payload_base_offset+4];
details->flash_page = packet->data[packet->payload_base_offset+5];
/*printf("loc id details ram_page %i\n",details->ram_page);*/
/*printf("loc id details flash_page %i\n",details->flash_page);*/
h = packet->data[packet->payload_base_offset+6];
l = packet->data[packet->payload_base_offset+7];
details->ram_address = (h << 8) + l;
/*printf("loc id details ram_address %0x\n",details->ram_address);*/
h = packet->data[packet->payload_base_offset+8];
l = packet->data[packet->payload_base_offset+9];
details->flash_address = (h << 8) + l;
/*printf("loc id details flash_address %0x\n",details->flash_address);*/
h = packet->data[packet->payload_base_offset+10];
l = packet->data[packet->payload_base_offset+11];
details->length = (h << 8) + l;
/*printf("loc id details length %i\n",details->length);*/
freeems_packet_cleanup(packet);
}
return details;
}
/*
\brief Queries the ECU for a location ID list
*/
G_MODULE_EXPORT GList *request_location_ids(gint * len)
{
OutputData *output = NULL;
GAsyncQueue *queue = NULL;
FreeEMS_Packet *packet = NULL;
GTimeVal tval;
GList *list = NULL;
Serial_Params *serial_params = NULL;
guint8 *buf = NULL;
/* Raw packet */
guint8 pkt[LOC_ID_LIST_REQ_PKT_LEN];
gint res = 0;
gint i = 0;
gint h = 0;
gint l = 0;
gint tmpi = 0;
guint8 sum = 0;
gint tmit_len = 0;
guint8 flag = BLOCK_BITS_AND;
guint16 bits = 0;
serial_params = DATA_GET(global_data,"serial_params");
g_return_val_if_fail(serial_params,NULL);
pkt[HEADER_IDX] = 0;
pkt[H_PAYLOAD_IDX] = (REQUEST_RETRIEVE_LIST_OF_LOCATION_IDS & 0xff00 ) >> 8;
pkt[L_PAYLOAD_IDX] = (REQUEST_RETRIEVE_LIST_OF_LOCATION_IDS & 0x00ff );
pkt[L_PAYLOAD_IDX+1] = flag; /* AND/OR */
bits |= BLOCK_IS_INDEXABLE | BLOCK_IN_RAM;
pkt[L_PAYLOAD_IDX+2] = (bits & 0xff00) >> 8; /* H bits */
pkt[L_PAYLOAD_IDX+3] = (bits & 0x00ff); /* L bits */
for (i=0;i<LOC_ID_LIST_REQ_PKT_LEN-1;i++)
sum += pkt[i];
pkt[LOC_ID_LIST_REQ_PKT_LEN-1] = sum;
buf = finalize_packet((guint8 *)&pkt,LOC_ID_LIST_REQ_PKT_LEN,&tmit_len);
queue = g_async_queue_new();
register_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LIST_OF_LOCATION_IDS);
if (!write_wrapper_f(serial_params->fd,buf, tmit_len, NULL))
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LIST_OF_LOCATION_IDS);
g_free(buf);
g_async_queue_unref(queue);
return NULL;
}
g_free(buf);
g_get_current_time(&tval);
g_time_val_add(&tval,500000);
packet = g_async_queue_timed_pop(queue,&tval);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_RETRIEVE_LIST_OF_LOCATION_IDS);
g_async_queue_unref(queue);
if (packet)
{
for (i=0;i<packet->payload_length;i++)
{
tmpi = 0;
h = packet->data[packet->payload_base_offset+i];
i++;
l = packet->data[packet->payload_base_offset+i];
tmpi = (h << 8) + l;
list = g_list_append(list,GINT_TO_POINTER(tmpi));
}
if (len)
*len = packet->payload_length;
freeems_packet_cleanup(packet);
}
return list;
}
G_MODULE_EXPORT void plugin_shutdown()
{
GThread *thread = NULL;
GCond *cond = NULL;
GAsyncQueue *queue = NULL;
GHashTable *hash = NULL;
GMutex *mutex = NULL;
gint id = 0;
freeems_serial_disable();
thread = DATA_GET(global_data,"packet_handler_thread");
if (thread)
{
DATA_SET(global_data,"packet_handler_thread_exit",GINT_TO_POINTER(TRUE));
g_thread_join(thread);
DATA_SET(global_data,"packet_handler_thread",NULL);
DATA_SET(global_data,"packet_handler_thread_exit",NULL);
}
queue = DATA_GET(global_data,"burn_queue");
if (queue)
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_BURN_BLOCK_FROM_RAM_TO_FLASH);
g_async_queue_unref(queue);
DATA_SET(global_data,"burn_queue",NULL);
queue = NULL;
}
queue = DATA_GET(global_data,"FLASH_write_queue");
if (queue)
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_REPLACE_BLOCK_IN_FLASH);
g_async_queue_unref(queue);
DATA_SET(global_data,"FLASH_write_queue",NULL);
queue = NULL;
}
queue = DATA_GET(global_data,"RAM_write_queue");
if (queue)
{
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_UPDATE_BLOCK_IN_RAM);
g_async_queue_unref(queue);
DATA_SET(global_data,"RAM_write_queue",NULL);
queue = NULL;
}
queue = DATA_GET(global_data,"packet_queue");
if (queue)
{
g_async_queue_unref(queue);
DATA_SET(global_data,"packet_queue",NULL);
queue = NULL;
}
hash = DATA_GET(global_data,"payload_id_queue_hash");
if (hash)
g_hash_table_destroy(hash);
hash = NULL;
DATA_SET(global_data,"payload_id_queue_hash",NULL);
hash = DATA_GET(global_data,"sequence_num_queue_hash");
if (hash)
g_hash_table_destroy(hash);
hash = NULL;
DATA_SET(global_data,"sequence_num_queue_hash",NULL);
cond = DATA_GET(global_data,"packet_handler_cond");
if (cond)
g_cond_free(cond);
cond = NULL;
DATA_SET(global_data,"packet_handler_cond",NULL);
cond = DATA_GET(global_data,"serial_reader_cond");
if (cond)
g_cond_free(cond);
cond = NULL;
DATA_SET(global_data,"serial_reader_cond",NULL);
mutex = DATA_GET(global_data,"queue_mutex");
if (mutex)
g_mutex_free(mutex);
DATA_SET(global_data,"queue_mutex",NULL);
deregister_common_enums();
return;
}
/*!
\brief Simple communication test, Assembles a packet, sends it,
subscribes to the response and waits for it, or a timeout.
\returns TRUE on success, FALSE on failure
*/
G_MODULE_EXPORT gboolean comms_test(void)
{
GAsyncQueue *queue = NULL;
LibreEMS_Packet *packet = NULL;
GCond *cond = NULL;
gboolean res = FALSE;
gint len = 0;
/* Packet sends back Interface Version */
/* START, Header, Payload ID H, PAyload ID L, CKsum, STOP */
guint8 *buf = NULL;
/* Raw packet */
guint8 pkt[INTERFACE_VERSION_REQ_PKT_LEN];
gint tmit_len = 0;
ENTER();
Serial_Params *serial_params = NULL;
serial_params = (Serial_Params *)DATA_GET(global_data,"serial_params");
queue = (GAsyncQueue *)DATA_GET(global_data,"packet_queue");
MTXDBG(SERIAL_RD,_("Entered...\n"));
if (!serial_params)
{
EXIT();
return FALSE;
}
queue = g_async_queue_new();
register_packet_queue(PAYLOAD_ID,queue,RESPONSE_BASIC_DATALOG);
packet = (LibreEMS_Packet *)g_async_queue_timeout_pop(queue,250000);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_BASIC_DATALOG);
if (packet)
{
MTXDBG(SERIAL_RD,_("Found streaming ECU!!\n"));
g_async_queue_unref(queue);
libreems_packet_cleanup(packet);
DATA_SET(global_data,"connected",GINT_TO_POINTER(TRUE));
EXIT();
return TRUE;
}
else
{ /* Assume ECU is in non-streaming mode, try and probe it */
gint sum = 0;
MTXDBG(SERIAL_RD,_("Requesting LibreEMS Interface Version\n"));
register_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
pkt[HEADER_IDX] = 0;
pkt[H_PAYLOAD_IDX] = (REQUEST_INTERFACE_VERSION & 0xff00 ) >> 8;
pkt[L_PAYLOAD_IDX] = (REQUEST_INTERFACE_VERSION & 0x00ff );
for (gint i=0;i<INTERFACE_VERSION_REQ_PKT_LEN-1;i++)
sum += pkt[i];
pkt[INTERFACE_VERSION_REQ_PKT_LEN-1] = sum;
buf = finalize_packet((guint8 *)&pkt,INTERFACE_VERSION_REQ_PKT_LEN,&tmit_len);
if (!write_wrapper_f(serial_params->fd, buf, tmit_len, &len))
{
g_free(buf);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
g_async_queue_unref(queue);
EXIT();
return FALSE;
}
g_free(buf);
packet = (LibreEMS_Packet *)g_async_queue_timeout_pop(queue,250000);
deregister_packet_queue(PAYLOAD_ID,queue,RESPONSE_INTERFACE_VERSION);
g_async_queue_unref(queue);
if (packet)
{
MTXDBG(SERIAL_RD,_("Found via probing!!\n"));
libreems_packet_cleanup(packet);
DATA_SET(global_data,"connected",GINT_TO_POINTER(TRUE));
EXIT();
return TRUE;
}
}
DATA_SET(global_data,"connected",GINT_TO_POINTER(FALSE));
MTXDBG(SERIAL_RD,_("No device found...\n"));
EXIT();
return FALSE;
}
/*
*\brief handle_transaction_hf is defined in comm.xml to handle the results
of certain IO operations. This runs in the IOthread context so it CAN NOT
do any GUI operations, but can queue gui ops via the thread_update_* calls
\param data is a pointer to an Io_Message structure
\param type is the FuncCall enumeration
\see Io_Message
\see FuncCall
*/
G_MODULE_EXPORT void handle_transaction_hf(void * data, FuncCall type)
{
static Firmware_Details *firmware = NULL;
Io_Message *message = NULL;
OutputData *output = NULL;
OutputData *retry = NULL;
GAsyncQueue *queue = NULL;
LibreEMS_Packet *packet = NULL;
gint payload_id = 0;
gint seq = 0;
gint clock = 0;
gint id = 0;
gint tmpi = 0;
gint canID = 0;
gint length = 0;
gint locID = 0;
gint offset = 0;
gint size = 0;
gint page = 0;
gint errorcode = 0;
const gchar * errmsg = NULL;
GTimeVal tval;
ENTER();
if (!firmware)
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
message = (Io_Message *)data;
output = (OutputData *)message->payload;
g_return_if_fail(firmware);
g_return_if_fail(message);
g_return_if_fail(output);
/* Get common data */
seq = (GINT)DATA_GET(output->data,"sequence_num");
canID = (GINT)DATA_GET(output->data,"canID");
locID = (GINT)DATA_GET(output->data,"location_id");
offset = (GINT)DATA_GET(output->data,"offset");
size = (GINT)DATA_GET(output->data,"num_wanted");
length = (GINT)DATA_GET(output->data,"length");
switch (type)
{
case GENERIC_READ:
packet = retrieve_packet(output->data,NULL);
queue = (GAsyncQueue *)DATA_GET(output->data,"queue");
if (queue)
{
deregister_packet_queue(SEQUENCE_NUM,queue,seq);
g_async_queue_unref(queue);
DATA_SET(output->data,"queue",NULL);
}
if (packet)
{
if (packet->is_nack)
printf("GENERIC_READ packet ACK FAILURE!\n");
else
{
/*printf("Packet arrived for GENERIC_READ case with sequence %i (%.2X), locID %i\n",seq,seq,locID);
printf("store new block locid %i, offset %i, data %p raw pkt len %i, payload len %i, num_wanted %i\n",locID,offset,packet->data+packet->payload_base_offset,packet->raw_length,packet->payload_length,size);
*/
libreems_store_new_block(canID,locID,offset,packet->data+packet->payload_base_offset,size);
libreems_backup_current_data(canID,locID);
libreems_packet_cleanup(packet);
tmpi = (GINT)DATA_GET(global_data,"ve_goodread_count");
DATA_SET(global_data,"ve_goodread_count",GINT_TO_POINTER(++tmpi));
}
}
else
{
printf("timeout, no packet found in GENERIC_READ queue for sequence %i (%.2X), locID %i\n",seq,seq,locID);
retry = initialize_outputdata_f();
seq = atomic_sequence();
DATA_SET(retry->data,"canID",DATA_GET(output->data,"canID"));
DATA_SET(retry->data,"sequence_num",GINT_TO_POINTER(seq));
DATA_SET(retry->data,"location_id",DATA_GET(output->data,"location_id"));
DATA_SET(retry->data,"payload_id",DATA_GET(output->data,"payload_id"));
DATA_SET(retry->data,"offset",DATA_GET(output->data,"offset"));
DATA_SET(retry->data,"num_wanted",DATA_GET(output->data,"num_wanted"));
DATA_SET(retry->data,"mode",DATA_GET(output->data,"mode"));
queue = g_async_queue_new();
register_packet_queue(SEQUENCE_NUM,queue,seq);
DATA_SET(retry->data,"queue",queue);
io_cmd_f(firmware->read_command,retry);
printf("Re-issued command sent, seq %i!\n",seq);
}
break;
case BENCHTEST_RESPONSE:
packet = retrieve_packet(output->data,NULL);
queue = (GAsyncQueue *)DATA_GET(output->data,"queue");
if (queue)
{
deregister_packet_queue(SEQUENCE_NUM,queue,seq);
g_async_queue_unref(queue);
DATA_SET(output->data,"queue",NULL);
}
if (packet)
{
if (packet->is_nack)
{
errorcode = ((guint8)packet->data[packet->payload_base_offset] << 8) + (guint8)packet->data[packet->payload_base_offset+1];
errmsg = lookup_error(errorcode);
thread_update_logbar_f("libreems_benchtest_view","warning",g_strdup_printf(_("Benchtest Packet ERROR, Code (0X%.4X), \"%s\"\n"),errorcode,errmsg),FALSE,FALSE);
}
else
{
/* get the current clock/addition value*/
clock = (GINT)DATA_GET(output->data,"clock");
/* If bumping, increase the total time */
if (DATA_GET(output->data,"bump"))
{
thread_update_logbar_f("libreems_benchtest_view",NULL,g_strdup_printf(_("Benchtest bumped by the user (added %.2f seconds to the clock), Total time remaining is now %.2f seconds\n"),clock/1000.0, ((GINT)DATA_GET(global_data,"benchtest_total")+clock)/1000.0),FALSE,FALSE);
DATA_SET(global_data,"benchtest_total",GINT_TO_POINTER(((GINT)DATA_GET(global_data,"benchtest_total")+clock)));
}
else if (DATA_GET(output->data, "start")) /* start */
{
thread_update_logbar_f("libreems_benchtest_view",NULL,g_strdup_printf(_("Initiating LibreEMS Benchtest: Run time should be about %.1f seconds...\n"),clock/1000.0),FALSE,FALSE);
id = g_timeout_add(500,benchtest_clock_update_wrapper,GINT_TO_POINTER(clock));
DATA_SET(global_data,"benchtest_clock_id",GINT_TO_POINTER(id));
}
else if (DATA_GET(output->data, "stop")) /* stop */
thread_update_logbar_f("libreems_benchtest_view",NULL,g_strdup_printf(_("Benchtest stopped by the user...\n")),FALSE,FALSE);
}
libreems_packet_cleanup(packet);
}
break;
case GENERIC_FLASH_WRITE:
packet = retrieve_packet(output->data,"FLASH_write_queue");
goto handle_write;
break;
case GENERIC_RAM_WRITE:
packet = retrieve_packet(output->data,"RAM_write_queue");
handle_write:
if (packet)
{
/*printf("Packet arrived for GENERIC_RAM_WRITE case locID %i\n",locID);*/
if (packet->is_nack)
{
printf("DATA Write Response PACKET NACK ERROR, rollback not implemented yet!!!!\n");
message->status = FALSE;
}
update_write_status(data);
libreems_packet_cleanup(packet);
}
else
{
printf("timeout, no packet found in GENERIC_[RAM|FLASH]_WRITE queue for sequence %i (%.2X), locID %i\n",seq,seq,locID);
retry = initialize_outputdata_f();
seq = atomic_sequence();
DATA_SET(retry->data,"canID",DATA_GET(output->data,"canID"));
DATA_SET(retry->data,"page",DATA_GET(output->data,"page"));
DATA_SET(retry->data,"sequence_num",GINT_TO_POINTER(seq));
DATA_SET(retry->data,"location_id",DATA_GET(output->data,"location_id"));
DATA_SET(retry->data,"payload_id",DATA_GET(output->data,"payload_id"));
DATA_SET(retry->data,"offset",DATA_GET(output->data,"offset"));
DATA_SET(retry->data,"size",DATA_GET(output->data,"size"));
DATA_SET(retry->data,"value",DATA_GET(output->data,"value"));
DATA_SET(retry->data,"length",DATA_GET(output->data,"length"));
DATA_SET(retry->data,"data",DATA_GET(output->data,"data"));
DATA_SET(retry->data,"mode",DATA_GET(output->data,"mode"));
queue = g_async_queue_new();
register_packet_queue(SEQUENCE_NUM,queue,seq);
DATA_SET(retry->data,"queue",queue);
if (type == GENERIC_RAM_WRITE)
io_cmd_f(firmware->write_command,retry);
if (type == GENERIC_FLASH_WRITE)
io_cmd_f("generic_FLASH_write",retry);
printf("Re-issued command sent, seq %i!\n",seq);
}
break;
case GENERIC_BURN:
packet = retrieve_packet(output->data,"burn_queue");
if (packet)
{
/*printf("Packet arrived for GENERIC_BURN case locID %i\n",locID);*/
if (packet->is_nack)
{
printf("BURN Flash Response PACKET NACK ERROR. Ack! I Don't know what to do now!!!!\n");
message->status = FALSE;
}
else
{
/*printf("burn success!\n");*/
post_single_burn_pf(data);
}
update_write_status(data);
libreems_packet_cleanup(packet);
}
else
{
printf("timeout, no packet found in GENERIC_BURN queue for sequence %i (%.2X), locID %i\n",seq,seq,locID);
retry = initialize_outputdata_f();
seq = atomic_sequence();
DATA_SET(retry->data,"canID",DATA_GET(output->data,"canID"));
DATA_SET(retry->data,"page",DATA_GET(output->data,"page"));
DATA_SET(retry->data,"sequence_num",GINT_TO_POINTER(seq));
DATA_SET(retry->data,"location_id",DATA_GET(output->data,"location_id"));
DATA_SET(retry->data,"payload_id",DATA_GET(output->data,"payload_id"));
DATA_SET(retry->data,"offset",DATA_GET(output->data,"offset"));
DATA_SET(retry->data,"length",DATA_GET(output->data,"length"));
DATA_SET(retry->data,"mode",DATA_GET(output->data,"mode"));
queue = g_async_queue_new();
register_packet_queue(SEQUENCE_NUM,queue,seq);
DATA_SET(retry->data,"queue",queue);
io_cmd_f(firmware->burn_command,retry);
}
break;
case EMPTY_PAYLOAD:
packet = retrieve_packet(output->data,NULL);
queue = (GAsyncQueue *)DATA_GET(output->data,"queue");
if (queue)
{
deregister_packet_queue(SEQUENCE_NUM,queue,seq);
g_async_queue_unref(queue);
DATA_SET(output->data,"queue",NULL);
}
if (packet)
{
payload_id = packet->payload_id;
switch (payload_id)
{
case RESPONSE_FIRMWARE_VERSION:
DATA_SET_FULL(global_data,"fw_version",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
case RESPONSE_INTERFACE_VERSION:
DATA_SET_FULL(global_data,"int_version",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
case RESPONSE_DECODER_NAME:
DATA_SET_FULL(global_data,"decoder_name",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
case RESPONSE_FIRMWARE_BUILD_DATE:
DATA_SET_FULL(global_data,"build_date",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
case RESPONSE_FIRMWARE_COMPILER_VERSION:
DATA_SET_FULL(global_data,"compiler",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
case RESPONSE_FIRMWARE_COMPILER_OS:
DATA_SET_FULL(global_data,"build_os",g_strndup((const gchar *)(packet->data+packet->payload_base_offset),packet->payload_length),g_free);
update_ecu_info();
break;
default:
printf("payload ID not matched, %i!\n",payload_id);
break;
}
libreems_packet_cleanup(packet);
}
else
printf("EMPTY PAYLOAD PACKET TIMEOUT, retry not implemented for this one yet!!\n");
break;
default:
printf("MegaTunix does NOT know how to handle this packet response type..\n");
break;
}
EXIT();
return;
}
