static void ipc_cleanup_reply(void)
{
if ((ipc_read(1) & 0x14) != 0x14)
return;
ipc_read(2);
ipc_bell(4);
ipc_irq_ack();
ipc_bell(8);
}
int ipc_u32_read(int fd, u32 *n)
{
if (ipc_read(fd, n, sizeof(*n)))
return -1;
*n = ntohl(*n);
return 0;
}
gint
ipc_timeout(gpointer data __attribute__((unused)))
{
ipc_read();
return 1;
}
/* Task that listens for incomming IPC messages from Host and initiate host
* command processing.
*/
void ipc_comm_task(void)
{
int ret = 0;
uint32_t out_drbl, pkt_len;
for (;;) {
ret = task_wait_event_mask(EVENT_FLAG_BIT_READ_IPC
| EVENT_FLAG_BIT_WRITE_IPC, -1);
if ((ret & EVENT_FLAG_BIT_WRITE_IPC))
continue;
else if (!(ret & EVENT_FLAG_BIT_READ_IPC))
continue;
/* Read the command byte. This clears the FRMH bit in
* the status byte.
*/
out_drbl = REG32(IPC_HOST2ISH_DOORBELL);
pkt_len = out_drbl & IPC_HEADER_LENGTH_MASK;
ret = ipc_read(IPC_PEER_HOST_ID, ipc_host_args, pkt_len);
host_cmd_args.command = EC_COMMAND_PROTOCOL_3;
host_cmd_args.result = EC_RES_SUCCESS;
host_cmd_flags = ipc_host_args->flags;
/* We only support new style command (v3) now */
if (host_cmd_args.command == EC_COMMAND_PROTOCOL_3) {
ipc_packet.send_response = ipc_send_response_packet;
ipc_packet.request =
(const void *)ipc_get_hostcmd_data_range();
ipc_packet.request_temp = params_copy;
ipc_packet.request_max = sizeof(params_copy);
/* Don't know the request size so pass in
* the entire buffer
*/
ipc_packet.request_size = EC_LPC_HOST_PACKET_SIZE;
ipc_packet.response =
(void *)ipc_get_hostcmd_data_range();
ipc_packet.response_max = EC_LPC_HOST_PACKET_SIZE;
ipc_packet.response_size = 0;
ipc_packet.driver_result = EC_RES_SUCCESS;
host_packet_receive(&ipc_packet);
usleep(10); /* To force yield */
continue;
} else {
/* Old style command unsupported */
host_cmd_args.result = EC_RES_INVALID_COMMAND;
}
/* Hand off to host command handler */
host_command_received(&host_cmd_args);
}
}
void check_msg()
{
static MENU tmenu = {"User msg", 1 };
ui_nextstate(0);
while(ipc_read(tmenu.cmd[0], MCMDLEN)>0)
if(tmenu.cmd[0][0]=='>')
exec_menu(tmenu);
ui_nextstate(1);
}
bool ipc_read_uint32_t(struct ipc *ipc, uint32_t *p)
{
uint32_t x;
if (!ipc_read(ipc, &x, sizeof(x)))
return false;
*p = ntohl(x);
return true;
}
/* For reading data from a socket - use it in the module task. */
int ipc_accept_buf_read(int server_fd, void *data, int data_len)
{
int fd, rc;
if ((fd = ipc_accept(server_fd)) < 0)
return -1;
rc = ipc_read(fd, data, data_len);
ipc_server_close(fd, rc);
return rc;
}
static int ipc_varbuf_read(int fd, char **data, int *len)
{
if (ipc_u32_read(fd, len))
return -1;
if (!(*data = malloc_l(*len)))
goto Error;
if (ipc_read(fd, *data, *len))
goto Error;
return 0;
Error:
nfree(*data);
return -1;
}
void vfss()
{
IPC ipc;
VFSS_TYPE vfss;
#if (VFS_DEBUG_INFO) || (VFS_DEBUG_ERRORS)
open_stdout();
#endif //(VFS_DEBUG_INFO) || (VFS_DEBUG_ERRORS)
vfss_init(&vfss);
for (;;)
{
ipc_read(&ipc);
vfss_request(&vfss, &ipc);
ipc_write(&ipc);
}
}
static void ipc_recv_reply(void)
{
for (;;) {
u32 reply;
ipc_wait_reply();
reply = ipc_read(2);
ipc_bell(4);
ipc_irq_ack();
ipc_bell(8);
if (reply == virt_to_phys(&ipc))
break;
}
sync_before_read(&ipc, sizeof ipc);
}
void app()
{
APP app;
CC1101 cc1101;
IPC ipc;
app_init(&app);
cc1101_hw_init(&cc1101);
for (;;)
{
ipc_read(&ipc);
switch (HAL_GROUP(ipc.cmd))
{
default:
error(ERROR_NOT_SUPPORTED);
break;
}
ipc_write(&ipc);
}
}
void loras_main()
{
IPC ipc;
LORA lora;
#if (LORA_DEBUG)
open_stdout();
#endif //LORA_DEBUG
init(&lora);
for (;;)
{
ipc_read(&ipc);
switch (HAL_GROUP(ipc.cmd))
{
case HAL_LORA:
loras_request(&lora, &ipc);
break;
default:
error(ERROR_NOT_SUPPORTED);
break;
}
ipc_write(&ipc);
}
}
static void ipc_bell(u32 w)
{
ipc_write(1, (ipc_read(1) & 0x30) | w);
}
void Connector::ThreadEntry(__unused Thread *thread)
{
// Register
{
struct
{
ipc_header_t header;
char name[255];
} message;
message.header.flags = IPC_HEADER_FLAG_RESPONSE | IPC_HEADER_FLAG_GET_RESPONSE_BITS(IPC_MESSAGE_RIGHT_COPY_SEND);
message.header.reply = _port;
message.header.port = ipc_get_special_port(0);
message.header.size = _name->GetLength();
message.header.id = 0;
strcpy(message.name, _name->GetCString());
ipc_write(&message.header);
}
// Work loop
uint8_t *receiveBuffer = new uint8_t[8192 + sizeof(ipc_header_t)];
uint8_t *responseBuffer = new uint8_t[8192 + sizeof(ipc_header_t)];
ipc_header_t *receive = reinterpret_cast<ipc_header_t *>(receiveBuffer);
ipc_header_t *response = reinterpret_cast<ipc_header_t *>(responseBuffer);
while(!_thread->IsCancelled())
{
receive->port = _port;
receive->flags = IPC_HEADER_FLAG_BLOCK;
receive->size = 8192;
ipc_return_t result = ipc_read(receive);
if(result == KERN_SUCCESS)
{
size_t responseSize = 8192;
bool hasResponse = DispatchMessage(receive->id, receiveBuffer, receive->size, responseBuffer + sizeof(ipc_header_t), responseSize);
if(hasResponse)
{
response->port = receive->port;
response->flags = 0;
response->size = responseSize;
ipc_write(response);
}
}
}
delete[] receiveBuffer;
delete[] responseBuffer;
// Unregister
{
struct
{
ipc_header_t header;
char name[255];
} message;
message.header.flags = 0;
message.header.reply = _port;
message.header.port = ipc_get_special_port(0);
message.header.size = _name->GetLength();
message.header.id = 1;
strcpy(message.name, _name->GetCString());
ipc_write(&message.header);
}
}
static void ipc_wait_ack(void)
{
while ((ipc_read(1) & 0x22) != 0x22)
;
}
static void ipc_cleanup_request(void)
{
if ((ipc_read(1) & 0x22) == 0x22)
ipc_bell(2);
}
static void ipc_wait_reply(void)
{
while ((ipc_read(1) & 0x14) != 0x14)
;
}
