GfxTextBuffer::GfxTextBuffer (GfxFont *font)
: font(font), currentDrawnDimensions(0,0), currentLeft(0), currentTop(0),
lastTop(0), lastBottom(0), wrap(0), dirty(false)
{
APP_ASSERT(font != NULL);
vBuf.setNull();
iBuf.setNull();
vData.vertexBufferBinding->setBinding(0, vBuf);
vData.vertexStart = 0;
vData.vertexCount = 0;
iData.indexBuffer = iBuf;
iData.indexStart = 0;
iData.indexCount = 0;
currentGPUCapacity = 0;
op.useIndexes = true;
op.vertexData = &vData;
op.indexData = &iData;
op.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
unsigned vdecl_sz = 0;
vdecl_sz += vData.vertexDeclaration->addElement(0, vdecl_sz, Ogre::VET_FLOAT2, Ogre::VES_POSITION, 0).getSize();
vdecl_sz += vData.vertexDeclaration->addElement(0, vdecl_sz, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0).getSize(); // uv
vdecl_sz += vData.vertexDeclaration->addElement(0, vdecl_sz, Ogre::VET_FLOAT4, Ogre::VES_TEXTURE_COORDINATES, 1).getSize(); // colour
APP_ASSERT(vdecl_sz == VERT_BYTE_SZ);
}
/**************************************************************************//**
*
* task_2
*
* @brief task 2 example
*
* @param[in] param task parameter input (unused)
*
* @return -
*
******************************************************************************/
void task_2(void *param)
{
static uint8_t counter = 0;
mss_mque_msg_t* msg;
MSS_BEGIN(task2_ctx)
while(1)
{
switch(counter)
{
case 0:
// allocate msg
msg = (mss_mque_msg_t*) mss_mem_alloc(mem_hdl);
APP_ASSERT(msg != NULL);
// create message
memcpy(msg->data, "LED1", 4);
// send message
mss_mque_send(mque_hdl, msg);
case 1:
// allocate msg
msg = (mss_mque_msg_t*) mss_mem_alloc(mem_hdl);
APP_ASSERT(msg != NULL);
// create message
memcpy(msg->data, "LED2", 4);
// send message
mss_mque_send(mque_hdl, msg);
break;
}
// increment counter
counter = ++counter & 0x01;
// delay
MSS_TIMER_DELAY_MS(timer_hdl, 500, task2_ctx);
}
MSS_FINISH();
}
void GfxBody::Sub::getWorldTransforms(Ogre::Matrix4* xform) const
{
if (!parent->numBoneMatrixes) {
// No skeletal animation, or software skinning
*xform = parent->node->_getFullTransform();
return;
}
// Hardware skinning, pass all actually used matrices
const Ogre::Mesh::IndexMap& indexMap = subMesh->useSharedVertices ?
subMesh->parent->sharedBlendIndexToBoneIndexMap : subMesh->blendIndexToBoneIndexMap;
APP_ASSERT(indexMap.size() <= parent->numBoneMatrixes);
if (parent->boneWorldMatrixes) {
// Bones, use cached matrices built when _updateRenderQueue was called
for (Ogre::Mesh::IndexMap::const_iterator i=indexMap.begin(),i_=indexMap.end() ; i!=i_; ++i) {
*(xform++) = parent->boneWorldMatrixes[*i];
}
} else {
// All animations disabled, use parent GfxBody world transform only
std::fill_n(xform, indexMap.size(), parent->node->_getFullTransform());
}
}
// handle .. in paths
static std::string path_collapse (const std::string &p, bool &err)
{
APP_ASSERT(p[0] == '/');
std::vector<std::string> new_path;
size_t last = 0;
//CVERB<<"Starting with: "<<p<<std::endl;
do {
size_t next = p.find('/', last+1);
std::string dir(p, last+1, next-last-1);
//CVERB<<"Piece: "<<last<<" "<<next<<" "<<dir<<std::endl;
if (dir == "..") {
if (new_path.size()==0) {
err = true;
return "";
}
new_path.pop_back();
} else {
new_path.push_back(dir);
}
if (next == std::string::npos) break;
last = next;
} while (true);
std::string r;
for (size_t i=0 ; i<new_path.size(); ++i) {
r.append("/");
r.append(new_path[i]);
}
return r;
}
static int disconnect_server(void)
{
APP_ASSERT(sockfd2 > 0);
close(sockfd2);
sockfd2 = -1;
return 0;
}
static int start_server(void)
{
int flag = 1;
struct sockaddr_in server_addr;
APP_ASSERT(sockfd <= 0);
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
APP_ERROR("socket failed %d !\n", sockfd);
return -1;
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)) < 0) {
APP_ERROR("setsockopt\n");
return -1;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(IMAGE_SERVER_PORT);
server_addr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
APP_ERROR("bind\n");
return -1;
}
if (listen(sockfd, 10) < 0) {
APP_ERROR("listen\n");
return -1;
}
return 0;
}
void net_send(NetChannel channel, NetAddress& address, const char* packet, uint32_t packetLength)
{
APP_ASSERT(netManager != NULL);
std::string s = std::string(packet, packetLength);
netManager->sendPacket(channel, address, s);
}
void GfxNode::notifyParentDead (void)
{
ensureAlive();
APP_ASSERT(!par.isNull());
par = GfxNodePtr(NULL);
updateParentBoneId();
}
void net_set_callbacks(ExternalTable& table, lua_State* L)
{
APP_ASSERT(netManager != NULL);
netManager->setCBTable(table);
table.clear(L); //ensure setNil() is called so we don't get LuaPtr shutdown error
}
void input_filter_shutdown (lua_State *L)
{
IFMap m = ifmap;
for (IFMap::const_iterator i=m.begin(), i_=m.end() ; i != i_ ; ++i) {
InputFilter *f = i->second;
f->destroy(L);
}
APP_ASSERT(ifmap.size() == 0);
}
/**************************************************************************//**
*
* init_task_1
*
* @brief initialize task 1 example
*
* @param -
*
* @return -
*
******************************************************************************/
void init_task_app(void)
{
// init hal
hal_init();
// initialize parameters
task1_ctx.led_num = 1;
task1_ctx.freq = LED_1_FREQ_MS;
task2_ctx.led_num = 2;
task2_ctx.freq = LED_2_FREQ_MS;
// create timers
task1_ctx.timer_hdl = mss_timer_create(TASK_1_ID);
APP_ASSERT(task1_ctx.timer_hdl != MSS_TIMER_INVALID_HDL);
task2_ctx.timer_hdl = mss_timer_create(TASK_2_ID);
APP_ASSERT(task2_ctx.timer_hdl != MSS_TIMER_INVALID_HDL);
}
static std::pair<Combo, std::string> split_bind (const std::string &bind)
{
// This code assumes keys do not contain - and are non-empty.
size_t last = bind.rfind('-');
if (last == std::string::npos) return std::pair<Combo, std::string>(empty_combo, bind);
APP_ASSERT(last + 1 < bind.length());
std::string prefix = bind.substr(0, last + 1);
std::string button = bind.substr(last + 1);
return std::pair<Combo, std::string>(prefix_to_combo(prefix), button);
}
void InputFilter::flushAll (lua_State *L)
{
ensureAlive();
// 'down' modified by acceptButton (and also potentially by callbacks).
ButtonStatus d = down;
for (ButtonStatus::iterator i=d.begin(), i_=d.end() ; i != i_ ; ++i) {
acceptButton(L, "-" + i->first);
}
APP_ASSERT(down.size() == 0);
}
void InputFilter::flushSet (lua_State *L, const BindingSet &s)
{
ensureAlive();
// 'down' modified by acceptButton (and also potentially by callbacks).
ButtonStatus d = down;
for (ButtonStatus::iterator i=d.begin(), i_=d.end() ; i != i_ ; ++i) {
if (masked_by(i->second, s))
acceptButton(L, "-" + i->first);
}
APP_ASSERT(down.size() == 0);
}
struct sockaddr_in HICHIP_DISCOVER_multicast_addr()
{
int ret = 0;
struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons(HICHIP_MULTICAST_PORT);
ret = inet_aton(HICHIP_MULTICAST_IPADDR, &sock_addr.sin_addr);
APP_ASSERT(ret > 0, "HICHIP get multicast address error!");
return sock_addr;
}
/**************************************************************************//**
*
* init_tasks
*
* @brief initialize tasks
*
* @param -
*
* @return -
*
******************************************************************************/
static void init_tasks(void)
{
// initialize hal module for MSS demo
hal_init();
// create memory for message queue
mem_hdl = mss_mem_create(MQUE_MEM_BLK_SIZE + sizeof(void*),
MQUE_MEM_NUM_OF_BLKS);
APP_ASSERT(mem_hdl != MSS_MEM_INVALID_HDL);
// activate task 1 for the first time
mss_activate_task(TASK_1_ID);
// create message queue
mque_hdl = mss_mque_create(TASK_1_ID);
APP_ASSERT(mque_hdl != MSS_MQUE_INVALID_HDL);
// create timer
timer_hdl = mss_timer_create(TASK_2_ID);
APP_ASSERT(timer_hdl != MSS_TIMER_INVALID_HDL);
}
int HICHIP_DISCOVER_sock_create(const char *local_ip)
{
int sock = 0;
int ret = 0, flag = 0;
struct sockaddr_in my_addr, to_addr;
struct ip_mreq mreq;
memset(&my_addr, 0, sizeof(struct sockaddr_in));
memset(&to_addr, 0, sizeof(struct sockaddr_in));
memset(&mreq, 0, sizeof(struct ip_mreq));
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(HICHIP_MULTICAST_PORT);
inet_aton(HICHIP_MULTICAST_IPADDR, &my_addr.sin_addr);
// create udp socket
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
APP_ASSERT(sock > 0, "HICHIP create udp socket failed!");
ret = bind(sock, (struct sockaddr *)&my_addr, sizeof(my_addr));
APP_ASSERT(0 == ret, "HICHIP udp socket bind failed!");
inet_aton(HICHIP_MULTICAST_IPADDR, &mreq.imr_multiaddr);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
ret = setsockopt(sock, SOL_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
APP_ASSERT(0 == ret, "HICHP add member failed!");
flag = 0; // not backrush
ret = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &flag, sizeof(flag));
APP_ASSERT(0 == ret, "HICHIP clear multicast loop failed!");
ret = fcntl(sock, F_SETFL,O_NONBLOCK);
assert(0 == ret);
return sock;
}
unsigned short GfxBody::Sub::getNumWorldTransforms(void) const
{
if (!parent->numBoneMatrixes) {
// No skeletal animation, or software skinning
return 1;
}
// Hardware skinning, count all actually used matrices
const Ogre::Mesh::IndexMap& indexMap = subMesh->useSharedVertices ?
subMesh->parent->sharedBlendIndexToBoneIndexMap : subMesh->blendIndexToBoneIndexMap;
APP_ASSERT(indexMap.size() <= parent->numBoneMatrixes);
return static_cast<unsigned short>(indexMap.size());
}
void nrx_write(int nrx_fd, struct ifreq* ifr)
{
int status;
struct nanoioctl* nr = (struct nanoioctl*) ifr->ifr_data;
APP_INFO("Writing packet to target\n");
APP_ASSERT(ifr != NULL);
status = ioctl(nrx_fd, SIOCNRXRAWTX, ifr);
if(status < 0) err(1, "ioctl (rawtx)");
}
static int connect_server(void)
{
struct sockaddr_in client_addr;
APP_ASSERT(sockfd2 <= 0);
socklen_t length = sizeof(client_addr);
APP_INFO("Listen to %d\n", IMAGE_SERVER_PORT);
if ((sockfd2 = accept(sockfd, (struct sockaddr *)&client_addr, &length)) < 0) {
APP_PRINTF("accept failed %d\n", sockfd2);
return -1;
}
APP_INFO("Port [%d] connected!\n", IMAGE_SERVER_PORT);
return 0;
}
/*******************************************************************************
* @brief Configures the GPIO for ADC1
* @param void
* @retval void
*******************************************************************************/
float ADC_SampleAndConv(ADC_TypeDef* ADCx)
{
/* Check the parameters */
APP_ASSERT(ADCx == ADC1);
uint32_t TimeCnt=0;
#ifdef DYNAMENT_DEBUG
printf("batt require start \r\n");
#endif
/* Re-enable DMA and ADC conf and start Temperature Data acquisition */
acquireVoltageValue();
TimeCnt = 160000;
/* for DEBUG purpose uncomment the following line and comment the __WFI call to do not enter STOP mode */
while ((!flag_ADCDMA_TransferComplete) && (TimeCnt !=0))
{
TimeCnt--;
}
if(!TimeCnt)
{
#ifdef DYNAMENT_DEBUG
printf("ADC timeout.\r\n");
#endif
}
/* Clear global flag for DMA transfert complete */
ClearADCDMA_TransferComplete();
#ifdef DYNAMENT_DEBUG
printf("batt require stop \r\n");
#endif
powerDownADC();
#ifdef DYNAMENT_DEBUG
// for(int32_t index = 0;index < ADC_CONV_BUFF_SIZE;index ++)
// {
// printf("ADC_ConvertedValueBuff[%d] = 0x%x.\r\n",index,ADC_ConvertedValueBuff[index]);
// }
#endif
return (ComputeRealVoltage());
}
// searching for the i such that cT[i].top <= top && cT[i+1].top > top, or sz-1 if cT[sz-1] < top
unsigned long GfxTextBuffer::binaryChopBottom (unsigned long begin, unsigned long end, unsigned long bottom_top)
{
unsigned long middle = (end + begin) / 2;
if (middle == colouredText.size() - 1) return middle;
const ColouredChar &c = colouredText[middle];
const ColouredChar &d = colouredText[middle+1];
if (c.top > bottom_top) {
// too close to the end of the text, look left
APP_ASSERT(middle != end); // this leads to infinite recursion
return binaryChopBottom(begin, middle, bottom_top);
} else if (d.top > bottom_top) {
// found it
return middle;
} else {
// too close to the beginning of the text, look right
return binaryChopBottom(middle+1, end, bottom_top);
}
}
void InputFilter::triggerFunc (lua_State *L, const std::string &bind, const LuaPtr &func)
{
ensureAlive();
APP_ASSERT(!func.isNil());
STACK_BASE;
//stack is empty
// error handler in case there is a problem during
// the callback
push_cfunction(L, my_lua_error_handler);
int error_handler = lua_gettop(L);
//stack: err
// get the function
func.push(L);
//stack: err, callback
STACK_CHECK_N(2);
// call (1 arg), pops function too
int status = lua_pcall(L, 0, 0, error_handler);
if (status) {
STACK_CHECK_N(2);
//stack: err, error
// pop the error message since the error handler will
// have already printed it out
lua_pop(L, 2);
STACK_CHECK;
CERR << "InputFilter \"" << description << "\" "
<< "raised an error on bind "<<bind<<"." << std::endl;
//stack is empty
} else {
//stack: err
STACK_CHECK_N(1);
lua_pop(L, 1);
//stack is empty
}
//stack is empty
STACK_CHECK;
}
// searching for the i such that cT[i-1].top < top && cT[i].top >= top, or 0 if cT[0] >= top
unsigned long GfxTextBuffer::binaryChopTop (unsigned long begin, unsigned long end, unsigned long top)
{
unsigned long middle = (end + begin + 1) / 2;
if (middle == 0) return middle;
if (middle == colouredText.size() - 1) return middle+1;
const ColouredChar &c = colouredText[middle];
const ColouredChar &b = colouredText[middle-1];
if (c.top < top) {
// too close to the beginning of the text, look right
APP_ASSERT(begin != middle); // this leads to infinite recursion
return binaryChopTop(middle, end, top);
} else if (b.top < top) {
// found it
return middle;
} else {
// too close to the end of the text, look left
return binaryChopTop(begin, middle-1, top);
}
}
int
GGI_kgi_setPalette(struct ggi_visual *vis, size_t start, size_t len, const ggi_color *colormap)
{
kgic_ilut_set_request_t ilut;
size_t nocols = 1 << GT_DEPTH(LIBGGI_GT(vis));
APP_ASSERT(colormap != NULL,
"GGI_kgi_setPalette() - colormap == NULL");
DPRINT_COLOR("display-kgi: SetPalVec(%d,%d)\n", start, len);
if (start == (size_t)GGI_PALETTE_DONTCARE) {
start = 0;
}
if ((start < 0) || (len < 0) || (start+len > nocols)) {
return GGI_ENOSPACE;
}
memcpy(LIBGGI_PAL(vis)->clut.data, colormap, len*sizeof(ggi_color));
ilut.image = 0;
ilut.resource = 0;
ilut.lut = 0;
ilut.idx = start;
ilut.cnt = len;
ilut.am = KGI_AM_COLORS;
ilut.data = (kgi_u16_t *)KGI_PRIV(vis);
for (start = 0; len > 0; start++, colormap++, len--) {
ilut.data[start*3] = colormap->r;
ilut.data[start*3 + 1] = colormap->g;
ilut.data[start*3 + 2] = colormap->b;
}
if(kgiSetIlut(&KGI_CTX(vis), &ilut) != KGI_EOK) {
DPRINT_COLOR("display-kgi: PUTCMAP failed.");
return -1;
}
return 0;
}
void InputFilter::bind (lua_State *L, const std::string &button)
{
ensureAlive();
Callback &c = buttonCallbacks[button];
c.down.setNil(L);
c.up.setNil(L);
c.repeat.setNil(L);
APP_ASSERT(lua_gettop(L) >= 3);
// DOWN
if (!lua_isnil(L, -3)) {
if (!lua_isfunction(L, -3)) {
EXCEPT << "Expected a function for down binding of " << button << ENDL;
}
c.down.setNoPop(L, -3);
}
// UP
if (!lua_isnil(L, -2)) {
if (!lua_isfunction(L, -2)) {
EXCEPT << "Expected a function for up binding of " << button << ENDL;
}
c.up.setNoPop(L, -2);
}
// REPEAT
if (!lua_isnil(L, -1)) {
if (lua_isboolean(L, -1)) {
if (lua_toboolean(L, -1)) {
if (lua_isnil(L, -3)) {
c.repeat.setNoPop(L, -3);
}
}
// it's false, treat the same as nil
} else {
if (!lua_isfunction(L, -1)) {
EXCEPT << "Expected a function or true for repeat binding of " << button << ENDL;
}
c.repeat.setNoPop(L, -1);
}
}
}
void GfxBody::reinitialise (void)
{
APP_ASSERT(mesh->isLoaded());
destroyGraphics();
for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i) {
Ogre::SubMesh *sm = mesh->getSubMesh(i);
Sub* sub = new Sub(this, sm);
subList.push_back(sub);
GFX_MAT_SYNC;
std::string matname = apply_map(initialMaterialMap, sm->getMaterialName());
if (!gfx_material_has(matname)) {
CERR << "Mesh \"/"<<mesh->getName()<<"\" references non-existing material "
<< "\""<<matname<<"\""<<std::endl;
matname = "/system/FallbackMaterial";
}
sub->material = gfx_material_get(matname);
}
if (!mesh->getSkeleton().isNull()) {
skeleton = OGRE_NEW Ogre::SkeletonInstance(mesh->getSkeleton());
skeleton->load();
numBoneMatrixes = skeleton->getNumBones();
boneMatrixes = static_cast<Ogre::Matrix4*>(OGRE_MALLOC_SIMD(sizeof(Ogre::Matrix4) * numBoneMatrixes, Ogre::MEMCATEGORY_ANIMATION));
boneWorldMatrixes = static_cast<Ogre::Matrix4*>(OGRE_MALLOC_SIMD(sizeof(Ogre::Matrix4) * numBoneMatrixes, Ogre::MEMCATEGORY_ANIMATION));
mesh->_initAnimationState(&animationState);
} else {
skeleton = NULL;
numBoneMatrixes = 0;
boneMatrixes = NULL;
boneWorldMatrixes = NULL;
}
updateBones();
}
void Img::init (std::istream &f, std::string name_)
{
name = name_;
unsigned long version = ios_read_u32(f);
APP_ASSERT(version==0x32524556);
numFiles = ios_read_u32(f);
names.resize(numFiles);
offsets.resize(numFiles);
sizes.resize(numFiles);
for (size_t i=0 ; i<numFiles ; i++) {
offsets[i] = ios_read_u32(f) * BLK_SZ;
sizes[i]= ios_read_u32(f) * BLK_SZ;
names[i] = ios_read_fixedstr(f,24);
strlower(names[i]);
}
if (dir.size()==numFiles) return;
for (unsigned long i=0 ; i<numFiles ; ++i) {
dir[names[i]] = i;
}
}
void * flash_cmd(struct ifreq* ifr, void * handle, char * filename)
{
static int host_flash_active = 0;
int data_index;
int vendor;
int sector;
int message_id;
struct nanoioctl* nr = (struct nanoioctl*) ifr->ifr_data;
message_id = nr->data[ID_INDEX];
data_index = nr->data[HEADER_PAD_INDEX] + 4;
APP_DEBUG("flash message id: %d\n",message_id);
switch(message_id) {
case HIC_MAC_START_PRG_REQ:
//start a flash write
vendor = nr->data[data_index];
sector = nr->data[data_index+1];
if(vendor == HOST_FLASH_VENDOR)
{
APP_DEBUG("host flash command \n");
host_flash_active = 1;
handle = host_flash_open(filename,HOST_FLASH_WRITE_FLAG);
if (handle) nr->data[data_index] = 0;
else nr->data[data_index] = 1;
//reply
nr->data[ID_INDEX] = HIC_MAC_START_PRG_CFM;
}
else return NULL;
break;
case HIC_MAC_WRITE_FLASH_REQ:
if(host_flash_active)
{
//start to write flash data
nr->data[data_index] = host_flash_write(&nr->data[data_index],nr->length - data_index,handle);
//reply
nr->data[ID_INDEX] = HIC_MAC_WRITE_FLASH_CFM;;
}
else return NULL;
break;
case HIC_MAC_END_PRG_REQ:
if(host_flash_active)
{
//stop write to flash
//reply
nr->data[ID_INDEX] = HIC_MAC_END_PRG_CFM;
nr->data[data_index] = host_flash_close(handle);
host_flash_active = 0;
}
else return NULL;
break;
case HIC_MAC_START_READ_REQ:
//start a flash read cmd
vendor = nr->data[data_index];
sector = nr->data[data_index+1];
if(vendor == HOST_FLASH_VENDOR)
{
host_flash_active = 1;
//reply
nr->data[ID_INDEX] = HIC_MAC_START_READ_CFM;
handle = host_flash_open(filename,HOST_FLASH_READ_FLAG);
if (handle) nr->data[data_index] = 0;
else nr->data[data_index] = 1;
}
else return NULL;
break;
case HIC_MAC_READ_FLASH_REQ:
//start to read flash data
if(host_flash_active)
{
nr->data[ID_INDEX] = HIC_MAC_READ_FLASH_CFM;
nr->data[TYPE_INDEX] = HIC_MESSAGE_TYPE_FLASH_PRG;
nr->data[PAYLOAD_PAD_INDEX] = 0;
{
int i;
i = host_flash_read(&nr->data[data_index],HOST_FLASH_MAX_READ_SIZE,handle);
APP_ASSERT(i);
nr->length = data_index + i;
*(uint16_t*)nr->data = (nr->length - 2);
}
}
else return NULL;
break;
case HIC_MAC_END_READ_REQ:
if(host_flash_active)
{
host_flash_active = 0;
//stop read from flash
//reply
nr->data[ID_INDEX] = HIC_MAC_END_READ_CFM;
nr->data[data_index] = host_flash_close(handle);
}
else return NULL;
break;
default:
APP_ASSERT(0);
break;
}
if (message_id != HIC_MAC_READ_FLASH_REQ) {
//Common reply data
*(uint16_t*)nr->data = (data_index - 1);
nr->data[TYPE_INDEX] = HIC_MESSAGE_TYPE_FLASH_PRG;
nr->data[PAYLOAD_PAD_INDEX] = 0;
nr->length = (*(uint16_t*)nr->data) + 2;
}
return handle;
}
int poll_host(int host_fd, struct ifreq *ifr)
{
int status;
int message_type;
size_t num_read = 0, len;
char buf[1024];
struct nanoioctl* nr = (struct nanoioctl*) ifr->ifr_data;
int host_fd_flags;
int flags;
status = read(host_fd, buf, 2);
if(status == 0)
return 0;
if(status < 0)
{
if (errno == EAGAIN)
return 0;
else
err(1,"read");
}
num_read += status;
while(num_read < 2) {
status = read(host_fd, buf + num_read, 2 - num_read);
if(status < 0)
{
if(errno != EAGAIN)
err(1, "read");
}
else
num_read += status;
}
/* Ok, we got 2 bytes from nanoloader */
len = *((uint16_t*) buf);
APP_ASSERT((len > 0 && len < 1022));
APP_DEBUG("Packet size is %d\n", len);
/* Read the rest of the packet */
while(num_read < len + 2) {
status = read(host_fd, buf + num_read, (len + 2 ) - num_read);
if(status < 0)
{
if(errno != EAGAIN)
err(1, "read");
}
else
{
num_read += status;
}
}
APP_DEBUG("Packet recieved\n");
memcpy(nr->data, buf, num_read);
nr->length = num_read;
return num_read;
}