int crespo_ipc_fmt_client_recv(struct ipc_client *client, struct ipc_message_info *response)
{
struct modem_io modem_data;
struct ipc_header *resphdr;
int bread = 0;
memset(&modem_data, 0, sizeof(struct modem_io));
modem_data.data = malloc(MAX_MODEM_DATA_SIZE);
modem_data.size = MAX_MODEM_DATA_SIZE;
memset(response, 0, sizeof(struct ipc_message_info));
wake_lock("secril_fmt-interface", 20);
assert(client->handlers->read != NULL);
bread = client->handlers->read((uint8_t*) &modem_data, sizeof(struct modem_io) + MAX_MODEM_DATA_SIZE, client->handlers->read_data);
if (bread < 0)
{
ipc_client_log(client, "crespo_ipc_fmt_client_recv: can't receive enough bytes from modem to process incoming response!");
return -1;
}
if(modem_data.size <= 0 || modem_data.size >= MAX_MODEM_DATA_SIZE || modem_data.data == NULL)
{
ipc_client_log(client, "crespo_ipc_fmt_client_recv: we retrieve less (or fairly too much) bytes from the modem than we exepected!");
return -1;
}
resphdr = (struct ipc_header *) modem_data.data;
response->mseq = resphdr->mseq;
response->aseq = resphdr->aseq;
response->group = resphdr->group;
response->index = resphdr->index;
response->type = resphdr->type;
response->length = modem_data.size - sizeof(struct ipc_header);
response->data = NULL;
ipc_client_log(client, "crespo_ipc_fmt_client_recv: RECV FMT (id=%d cmd=%d size=%d)!", modem_data.id, modem_data.cmd, modem_data.size);
ipc_client_log(client, "crespo_ipc_fmt_client_recv: IPC response (aseq=0x%02x command=%s (0x%04x) type=%s)",
response->aseq, ipc_command_to_str(IPC_COMMAND(response)), IPC_COMMAND(response), ipc_response_type_to_str(response->type));
if(response->length > 0)
{
#ifdef DEBUG
ipc_client_log(client, "==== FMT DATA DUMP ====");
ipc_hex_dump(client, (void *) (modem_data.data + sizeof(struct ipc_header)), response->length);
#endif
response->data = malloc(response->length);
memcpy(response->data, (uint8_t *) modem_data.data + sizeof(struct ipc_header), response->length);
}
free(modem_data.data);
ipc_client_log(client, "");
wake_unlock("secril_fmt-interface", 20);
return 0;
}
int crespo_ipc_rfs_client_send(struct ipc_client *client, struct ipc_message_info *request)
{
struct modem_io modem_data;
int rc = 0;
memset(&modem_data, 0, sizeof(struct modem_io));
modem_data.id = request->mseq;
modem_data.cmd = request->index;
modem_data.size = request->length;
modem_data.data = malloc(request->length);
memcpy(modem_data.data, request->data, request->length);
assert(client->handlers->write != NULL);
ipc_client_log(client, "crespo_ipc_rfs_client_send: SEND RFS (id=%d cmd=%d size=%d)!", modem_data.id, modem_data.cmd, modem_data.size);
ipc_client_log(client, "crespo_ipc_rfs_client_send: IPC request (mseq=0x%02x command=%s (0x%04x))",
request->mseq, ipc_command_to_str(IPC_COMMAND(request)), IPC_COMMAND(request));
#ifdef DEBUG
if(request->length > 0)
{
ipc_client_log(client, "==== RFS DATA DUMP ====");
ipc_hex_dump(client, (void *) request->data, request->length);
}
#endif
ipc_client_log(client, "");
rc = client->handlers->write((uint8_t*) &modem_data, sizeof(struct modem_io), client->handlers->write_data);
return rc;
}
void ipc_parse_syssec(struct ipc_client* client, struct modem_io *ipc_frame)
{
DEBUG_I("Entering");
struct sysSecPacketHeader *rx_header;
rx_header = (struct sysSecPacketHeader*)(ipc_frame->data);
DEBUG_I("Syssec packet type = 0x%x\n Syssec packet unk1 = 0x%X\n packet length = 0x%X, unk2= 0x%X", rx_header->type, rx_header->unknown1, rx_header->bufLen, rx_header->unknown2);
ipc_hex_dump(client, ipc_frame->data, rx_header->bufLen);
DEBUG_I("Exiting");
}
void ipc_dispatch(struct ipc_client *client, struct modem_io *ipc_frame)
{
switch(ipc_frame->cmd)
{
case FIFO_PKT_SIM:
ipc_parse_sim(client, ipc_frame);
break;
case FIFO_PKT_PROTO:
ipc_parse_proto(client, ipc_frame);
break;
case FIFO_PKT_TAPI:
ipc_parse_tapi(client, ipc_frame);
break;
case FIFO_PKT_FILE:
ipc_parse_fm(client, ipc_frame);
/*
if (ret)
{
modem_send_tapi_init(ipc_frame);
sim_atk_open(0);
sim_open_to_modem(0);
}*/
break;
case FIFO_PKT_SOUND:
ipc_parse_sound(client, ipc_frame);
break;
case FIFO_PKT_DVB_H_DebugLevel:
ipc_parse_dbg_level(client, ipc_frame);
break;
case FIFO_PKT_BOOT:
ipc_parse_boot(client, ipc_frame);
break;
case FIFO_PKT_SYSTEM:
ipc_parse_system(client, ipc_frame);
break;
case FIFO_PKT_DRV:
ipc_parse_drv(client, ipc_frame);
break;
case FIFO_PKT_DEBUG:
ipc_parse_dbg(client, ipc_frame);
break;
default :
DEBUG_I("Packet type 0x%x not yet handled\n", ipc_frame->cmd);
DEBUG_I("Frame header = 0x%x\n Frame type = 0x%x\n Frame length = 0x%x\n",
ipc_frame->magic, ipc_frame->cmd, ipc_frame->datasize);
ipc_hex_dump(client, ipc_frame->data, ipc_frame->datasize);
}
}
void ipc_parse_system(struct ipc_client *client, struct modem_io *ipc_frame)
{
DEBUG_I("received SYSTEM packet with AMSS version, notifying RIL that AMSS has initialized");
uint32_t desc_size;
int suffix_size;
desc_size = strlen((const char*)ipc_frame->data);
if(desc_size > 32 || desc_size > ipc_frame->datasize)
DEBUG_E("too big desc_size: %d", desc_size);
else
memcpy(cached_sw_version, ipc_frame->data, desc_size);
cached_sw_version[desc_size] = 0x00;
suffix_size = ipc_frame->datasize - desc_size - 1;
if(suffix_size > 0) {
DEBUG_I("dumping rest of data from IPC_SYSTEM packet");
ipc_hex_dump(client, ipc_frame->data+desc_size+1, suffix_size);
}
ipc_invoke_ril_cb(CP_SYSTEM_START, ipc_frame->data);
}
int h1_ipc_send(struct ipc_client *client, struct ipc_message_info *request)
{
struct hdlc_header *hdlc;
unsigned char *frame;
unsigned char *payload;
int frame_length;
/* Frame length: HDLC/IPC header + payload length + HDLC flags (2) */
frame_length = (sizeof(*hdlc) + request->length + 2);
frame = (unsigned char*)malloc(frame_length);
frame[0] = FRAME_START;
frame[frame_length-1] = FRAME_END;
/* Setup HDLC header */
hdlc = (struct hdlc_header*)(frame + 1);
hdlc->length = (sizeof(*hdlc) + request->length);
hdlc->unknown = 0;
/* IPC header */
hdlc->ipc.length = (sizeof(hdlc->ipc) + request->length);
hdlc->ipc.mseq = request->mseq;
hdlc->ipc.aseq = request->aseq;
hdlc->ipc.group = request->group;
hdlc->ipc.index = request->index;
hdlc->ipc.type = request->type;
/* IPC payload */
payload = (frame + 1 + sizeof(*hdlc));
memcpy(payload, request->data, request->length);
ipc_client_log(client, "sending %s %s\n",
ipc_command_to_str(IPC_COMMAND(request)),
ipc_response_type_to_str(request->type));
ipc_hex_dump(client, frame, frame_length);
client->handlers->write(frame, frame_length, client->handlers->write_data);
free(frame);
return 0;
}
int h1_ipc_recv(struct ipc_client *client, struct ipc_message_info *response)
{
unsigned char buf[4];
unsigned char *data;
unsigned short *frame_length;
struct ipc_header *ipc;
int num_read;
int left;
num_read = client->handlers->read((void*)buf, sizeof(buf), client->handlers->read_data);
if(num_read == sizeof(buf) && *buf == FRAME_START) {
frame_length = (unsigned short*)&buf[1];
left = (*frame_length - 3 + 1);
data = (unsigned char*)malloc(left);
num_read = client->handlers->read((void*)data, left, client->handlers->read_data);
if(num_read == left && data[left-1] == FRAME_END) {
ipc = (struct ipc_header*)data;
response->mseq = ipc->mseq;
response->aseq = ipc->aseq;
response->group = ipc->group;
response->index = ipc->index;
response->type = ipc->type;
response->length = (ipc->length - sizeof(*ipc));
response->data = (unsigned char*)malloc(response->length);
memcpy(response->data, (data + sizeof(*ipc)), response->length);
ipc_client_log(client, "received %s %s\n",
ipc_command_to_str(IPC_COMMAND(response)),
ipc_response_type_to_str(response->type));
ipc_hex_dump(client, data, num_read-1);
return 0;
}
}
return 0;
}
int crespo_ipc_fmt_client_send(struct ipc_client *client, struct ipc_message_info *request)
{
struct modem_io modem_data;
struct ipc_header reqhdr;
int rc = 0;
memset(&modem_data, 0, sizeof(struct modem_io));
modem_data.size = request->length + sizeof(struct ipc_header);
reqhdr.mseq = request->mseq;
reqhdr.aseq = request->aseq;
reqhdr.group = request->group;
reqhdr.index = request->index;
reqhdr.type = request->type;
reqhdr.length = (uint16_t) (request->length + sizeof(struct ipc_header));
modem_data.data = malloc(reqhdr.length);
memcpy(modem_data.data, &reqhdr, sizeof(struct ipc_header));
memcpy((unsigned char *) (modem_data.data + sizeof(struct ipc_header)), request->data, request->length);
assert(client->handlers->write != NULL);
ipc_client_log(client, "crespo_ipc_fmt_client_send: SEND FMT (id=%d cmd=%d size=%d)!", modem_data.id, modem_data.cmd, modem_data.size);
ipc_client_log(client, "crespo_ipc_fmt_client_send: IPC request (mseq=0x%02x command=%s (0x%04x) type=%s)",
request->mseq, ipc_command_to_str(IPC_COMMAND(request)), IPC_COMMAND(request), ipc_request_type_to_str(request->type));
#ifdef DEBUG
if(request->length > 0)
{
ipc_client_log(client, "==== FMT DATA DUMP ====");
ipc_hex_dump(client, (void *) request->data, request->length);
}
#endif
ipc_client_log(client, "");
rc = client->handlers->write((uint8_t*) &modem_data, sizeof(struct modem_io), client->handlers->write_data);
return rc;
}
