sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
2f280f4dc8
nuttx-apps/lte/alt1250/usock_handlers/alt1250_ioctl_fwupdate.c
SPRESENSE 3650251c5e lte/alt1250: Fix bug that caused stack when executing the socket API 
Fix a bug that caused the application to get stuck when executing
the socket API after waking up from hibernation and before executing
lte_hibernation_resume().
2024-02-09 14:52:05 +02:00

465 lines
15 KiB
C
Raw Blame History

/****************************************************************************
* apps/lte/alt1250/usock_handlers/alt1250_ioctl_fwupdate.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/crc32.h>
#include <nuttx/net/usrsock.h>
#include "alt1250_dbg.h"
#include "alt1250_daemon.h"
#include "alt1250_fwupdate.h"
#include "alt1250_container.h"
#include "alt1250_socket.h"
#include "alt1250_usrsock_hdlr.h"
#include "alt1250_devif.h"
#include "alt1250_usockevent.h"
#include "alt1250_postproc.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define DELTA_MAGICNO (('D') + ('T' << 8) + ('F' << 16) + ('W' << 24))
#define IS_IN_RANGE(a, l, h) (((a) >= (l)) && ((a) < (h)))
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: postprochdlr_fwgetimglen
****************************************************************************/
static int postproc_fwgetimglen(FAR struct alt1250_s *dev,
FAR struct alt_container_s *reply,
FAR struct usock_s *usock,
FAR int32_t *usock_result,
FAR uint32_t *usock_xid,
FAR struct usock_ackinfo_s *ackinfo,
unsigned long arg)
{
if (CONTAINER_RESPRES(reply) >= 0)
{
/* When modem returned non-zero value,
* some data have already injected.
* But additional header is not counted.
* Here is adjustement code for it.
*/
if (dev->fwup_info.act_injected == -1)
{
/* First call */
dev->fwup_info.act_injected = CONTAINER_RESPRES(reply);
dev->fwup_info.hdr_injected = (dev->fwup_info.act_injected > 0) ?
sizeof(struct delta_header_s) : 0;
}
else if (dev->fwup_info.act_injected >= LTE_IMAGE_PERT_SIZE)
{
/* Injection is already done until pert area. */
if (CONTAINER_RESPRES(reply) == 0)
{
/* Modem should returl non-zero value.
* This is error case because of mis-matched.
*/
/* Notice: This case can be happened in normal case
* when injection done just until pert area.
* But it can't be rescued.
*/
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
}
else
{
dev->fwup_info.act_injected = CONTAINER_RESPRES(reply);
}
}
if (dev->fwup_info.act_injected == -1)
{
CONTAINER_RESPRES(reply) = -ENODATA;
}
else
{
/* Reply size should include header injected size */
CONTAINER_RESPRES(reply) =
dev->fwup_info.act_injected + dev->fwup_info.hdr_injected;
}
}
else
{
/* In error case from modem, injection is reset. */
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
}
*usock_result = CONTAINER_RESPRES(reply);
return REP_SEND_ACK;
}
/****************************************************************************
* Name: postprochdlr_fwupdate_injection
****************************************************************************/
static int postproc_fwupdate_injection(FAR struct alt1250_s *dev,
FAR struct alt_container_s *reply,
FAR struct usock_s *usock,
FAR int32_t *usock_result,
FAR uint32_t *usock_xid,
FAR struct usock_ackinfo_s *ackinfo,
unsigned long arg)
{
int app_injected = (int)arg;
if (CONTAINER_RESPRES(reply) < 0)
{
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
}
else if (app_injected >= 0)
{
CONTAINER_RESPRES(reply) = app_injected;
}
*usock_result = CONTAINER_RESPRES(reply);
return REP_SEND_ACK;
}
/****************************************************************************
* Name: fwupdate_dummy_postproc
****************************************************************************/
static int postproc_fwupdate_dummy(FAR struct alt1250_s *dev,
FAR struct alt_container_s *reply,
FAR struct usock_s *usock,
FAR int32_t *usock_result,
FAR uint32_t *usock_xid,
FAR struct usock_ackinfo_s *ackinfo,
unsigned long arg)
{
*usock_result = CONTAINER_RESPRES(reply);
return REP_SEND_ACK;
}
/****************************************************************************
* Name: store_injection_data
****************************************************************************/
static bool store_injection_data(FAR char *dist, FAR int *ofst, int sz,
FAR uint8_t **src, FAR int *len)
{
bool ret = false;
int rest;
if (IS_IN_RANGE(*ofst, 0, sz))
{
rest = sz - *ofst;
rest = (rest > *len) ? *len : rest;
memcpy(&dist[*ofst], *src, rest);
*len -= rest;
*ofst += rest;
*src += rest;
if (*ofst == sz)
{
ret = true;
}
}
return ret;
}
/****************************************************************************
* Name: verify_header_crc32
****************************************************************************/
static bool verify_header_crc32(FAR struct alt1250_s *dev)
{
uint32_t crc_result = crc32((uint8_t *)&dev->fwup_info.hdr,
sizeof(struct delta_header_s));
return (crc_result == 0);
}
/****************************************************************************
* Name: verify_pert_crc32
****************************************************************************/
static bool verify_pert_crc32(FAR struct alt1250_s *dev)
{
uint32_t crc_result = crc32((uint8_t *)dev->fwup_info.img_pert,
LTE_IMAGE_PERT_SIZE);
return (crc_result == dev->fwup_info.hdr.pert_crc);
}
/****************************************************************************
* Name: fwupdate_header_injection
****************************************************************************/
static int fwupdate_header_injection(FAR struct alt1250_s *dev,
FAR struct lte_ioctl_data_s *cmd,
FAR bool *send_pert)
{
FAR uint8_t *data = (FAR uint8_t *)cmd->inparam[0];
int len = *(FAR int *)cmd->inparam[1];
bool init = *(FAR bool *)cmd->inparam[2];
bool filled_all;
if (init)
{
dev->fwup_info.act_injected = 0;
dev->fwup_info.hdr_injected = 0;
}
*send_pert = false;
/* Make sure lte_get_version() and
* ltefwupdate_injected_datasize() have been already called.
*/
if ((dev->fw_version[0] == 'R') && (dev->fw_version[1] == 'K')
&& (dev->fwup_info.act_injected != -1) && (len > 0))
{
/* Check if under header injection phase */
if (dev->fwup_info.act_injected == 0)
{
filled_all
= store_injection_data((char *)&dev->fwup_info.hdr,
&dev->fwup_info.hdr_injected,
sizeof(struct delta_header_s), &data,
&len);
if (filled_all)
{
if (!verify_header_crc32(dev) ||
(dev->fwup_info.hdr.chunk_code != DELTA_MAGICNO) ||
strncmp(dev->fw_version, dev->fwup_info.hdr.np_package,
LTE_VER_NP_PACKAGE_LEN))
{
/* CRC error or Version mis-match */
dbg_alt1250("FWUP: Error CRC Header\n");
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
return -EINVAL;
}
}
}
/* Check if under pert injection phase */
if ((dev->fwup_info.hdr_injected >= sizeof(struct delta_header_s)) &&
(len > 0))
{
filled_all
= store_injection_data(dev->fwup_info.img_pert,
&dev->fwup_info.act_injected,
LTE_IMAGE_PERT_SIZE, &data, &len);
if (filled_all)
{
if (!verify_pert_crc32(dev))
{
/* CRC error */
dbg_alt1250("FWUP: Error CRC Pertition\n");
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
return -EINVAL;
}
else
{
*send_pert = true;
}
}
}
return len;
}
else
{
dbg_alt1250("FWUP: Not initialized.\n");
return -ENODATA;
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* name: usockreq_ioctl_fwupdate
****************************************************************************/
int usockreq_ioctl_fwupdate(FAR struct alt1250_s *dev,
FAR struct usrsock_request_buff_s *req,
FAR int32_t *usock_result,
FAR uint32_t *usock_xid,
FAR struct usock_ackinfo_s *ackinfo)
{
FAR struct usrsock_request_ioctl_s *request = &req->request.ioctl_req;
FAR struct lte_ioctl_data_s *ltecmd = &req->req_ioctl.ltecmd;
FAR struct usock_s *usock = NULL;
int ret = REP_SEND_ACK_WOFREE;
FAR struct alt_container_s *container;
postproc_hdlr_t postproc_hdlr = NULL;
bool send_cmd = true;
int postproc_priv = -1;
dbg_alt1250("%s start\n", __func__);
*usock_result = OK;
*usock_xid = request->head.xid;
usock = usocket_search(dev, request->usockid);
if (usock == NULL)
{
dbg_alt1250("Failed to get socket context: %u\n",
request->usockid);
*usock_result = -EBADFD;
return REP_SEND_ACK_WOFREE;
}
/* FW Update APIs are all synchronouse. */
if ((ltecmd->cmdid & LTE_CMDOPT_ASYNC_BIT) || (ltecmd->cb != NULL))
{
*usock_result = -EINVAL;
return REP_SEND_ACK_WOFREE;
}
container = container_alloc();
if (container == NULL)
{
dbg_alt1250("no container\n");
return REP_NO_CONTAINER;
}
/* Special operation for each commands */
switch (ltecmd->cmdid)
{
case LTE_CMDID_INJECTIMAGE:
{
*usock_result = fwupdate_header_injection(dev, ltecmd, &send_cmd);
if (*usock_result < 0)
{
container_free(container);
return REP_SEND_ACK_WOFREE;
}
else
{
/* That send_cmd is set to true means
* that pert image should be sent.
*/
if (send_cmd)
{
/* Need to care for reply value as actual injected
* size from application point of view
*/
postproc_priv
= *(FAR int *)ltecmd->inparam[1] - *usock_result;
ltecmd->inparam[0] = dev->fwup_info.img_pert;
*(FAR int *)ltecmd->inparam[1] = LTE_IMAGE_PERT_SIZE;
*(FAR bool *)ltecmd->inparam[2] = true;
}
else if (*usock_result > 0)
{
send_cmd = true;
}
else /* In case of *result == 0 */
{
/* No send injecting data to modem,
* but the data is all accepted.
*/
*usock_result = *(FAR int *)ltecmd->inparam[1];
container_free(container);
}
postproc_hdlr = postproc_fwupdate_injection;
}
}
break;
case LTE_CMDID_GETIMAGELEN:
{
postproc_hdlr = postproc_fwgetimglen;
}
break;
case LTE_CMDID_EXEUPDATE:
{
/* When execution starts, injection is reset */
reset_fwupdate_info(dev);
postproc_hdlr = postproc_fwupdate_dummy;
}
break;
default:
{
*usock_result = -EINVAL;
container_free(container);
return REP_SEND_ACK_WOFREE;
}
break;
}
if (send_cmd)
{
USOCKET_SET_REQUEST(usock, request->head.reqid, request->head.xid);
set_container_ids(container, USOCKET_USOCKID(usock), ltecmd->cmdid);
set_container_argument(container, ltecmd->inparam, ltecmd->inparamlen);
set_container_response(container, ltecmd->outparam,
ltecmd->outparamlen);
set_container_postproc(container, postproc_hdlr, postproc_priv);
ret = altdevice_send_command(dev, dev->altfd, container, usock_result);
if (IS_NEED_CONTAINER_FREE(ret))
{
container_free(container);
}
}
return ret;
}
void reset_fwupdate_info(FAR struct alt1250_s *dev)
{
dev->fwup_info.hdr_injected = 0;
dev->fwup_info.act_injected = -1;
dev->fw_version[0] = '\0';
}
Reference in New Issue View Git Blame Copy Permalink