sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
205c8934a3
nuttx/drivers/mtd/rpmsgmtd_server.c
wangbowen6 c754df6411 drivers/mtd: add rpmsg mtd support 
Signed-off-by: wangbowen6 <wangbowen6@xiaomi.com>
2022-09-09 19:27:57 +08:00

421 lines
14 KiB
C
Raw Blame History

/****************************************************************************
* drivers/mtd/rpmsgmtd_server.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 <string.h>
#include <fcntl.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs/fs.h>
#include <nuttx/mtd/mtd.h>
#include <nuttx/rptun/openamp.h>
#include "rpmsgmtd.h"
/****************************************************************************
* Pre-processor definitions
****************************************************************************/
/****************************************************************************
* Private Types
****************************************************************************/
struct rpmsgmtd_server_s
{
struct rpmsg_endpoint ept;
FAR struct mtd_dev_s *dev;
FAR struct inode *mtdnode;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Functions handle the messages from the client cpu */
static int rpmsgmtd_erase_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgmtd_bread_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgmtd_bwrite_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgmtd_read_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgmtd_write_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
static int rpmsgmtd_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv);
/* Functions for creating communication with client cpu */
static bool rpmsgmtd_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv, FAR const char *name,
uint32_t dest);
static void rpmsgmtd_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv, FAR const char *name,
uint32_t dest);
static void rpmsgmtd_ns_unbind(FAR struct rpmsg_endpoint *ept);
static int rpmsgmtd_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv);
/****************************************************************************
* Private Data
****************************************************************************/
static const rpmsg_ept_cb g_rpmsgmtd_handler[] =
{
[RPMSGMTD_ERASE] = rpmsgmtd_erase_handler,
[RPMSGMTD_BREAD] = rpmsgmtd_bread_handler,
[RPMSGMTD_BWRITE] = rpmsgmtd_bwrite_handler,
[RPMSGMTD_READ] = rpmsgmtd_read_handler,
[RPMSGMTD_WRITE] = rpmsgmtd_write_handler,
[RPMSGMTD_IOCTL] = rpmsgmtd_ioctl_handler,
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: rpmsgmtd_erase_handler
****************************************************************************/
static int rpmsgmtd_erase_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_erase_s *msg = data;
msg->header.result = MTD_ERASE(server->dev, msg->startblock, msg->nblocks);
return rpmsg_send(ept, msg, sizeof(*msg));
}
/****************************************************************************
* Name: rpmsgmtd_bread_handler
****************************************************************************/
static int rpmsgmtd_bread_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_bread_s *msg = data;
FAR struct rpmsgmtd_bread_s *rsp;
int ret = -ENOENT;
size_t read = 0;
size_t nblocks;
uint32_t space;
while (read < msg->nblocks)
{
rsp = rpmsg_get_tx_payload_buffer(ept, &space, true);
if (rsp == NULL)
{
ferr("get tx payload failed or no enough space\n");
return -ENOMEM;
}
DEBUGASSERT(space >= sizeof(*msg) - 1 + msg->blocksize);
*rsp = *msg;
nblocks = (space - sizeof(*msg) + 1) / msg->blocksize;
if (nblocks > msg->nblocks - read)
{
nblocks = msg->nblocks - read;
}
ret = MTD_BREAD(server->dev, msg->startblock + read, nblocks,
rsp->buf);
rsp->header.result = ret;
rpmsg_send_nocopy(ept, rsp, (ret < 0 ? 0 : ret * msg->blocksize) +
sizeof(*rsp) - 1);
if (ret <= 0)
{
ferr("mtd block read failed\n");
break;
}
read += ret;
}
return 0;
}
/****************************************************************************
* Name: rpmsgmtd_bwrite_handler
****************************************************************************/
static int rpmsgmtd_bwrite_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_bwrite_s *msg = data;
int ret;
ret = MTD_BWRITE(server->dev, msg->startblock, msg->nblocks, msg->buf);
if (ret <= 0)
{
ferr("mtd block write failed\n");
}
/* cookie != 0 indicate the data has been sent complete, so send back
* the total written blocks.
*/
if (msg->header.cookie != 0)
{
msg->header.result = ret;
rpmsg_send(ept, msg, sizeof(*msg) - 1);
}
return 0;
}
/****************************************************************************
* Name: rpmsgmtd_read_handler
****************************************************************************/
static int rpmsgmtd_read_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_read_s *msg = data;
FAR struct rpmsgmtd_read_s *rsp;
int ret = -ENOENT;
size_t read = 0;
uint32_t space;
while (read < msg->nbytes)
{
rsp = rpmsg_get_tx_payload_buffer(ept, &space, true);
if (rsp == NULL)
{
ferr("get tx payload failed\n");
return -ENOMEM;
}
*rsp = *msg;
space -= sizeof(*msg) - 1;
if (space > msg->nbytes - read)
{
space = msg->nbytes - read;
}
ret = MTD_READ(server->dev, msg->offset + read, space,
(FAR uint8_t *)rsp->buf);
rsp->header.result = ret;
rpmsg_send_nocopy(ept, rsp, (ret < 0 ? 0 : ret) + sizeof(*rsp) - 1);
if (ret <= 0)
{
break;
}
read += ret;
}
return 0;
}
/****************************************************************************
* Name: rpmsgmtd_write_handler
****************************************************************************/
static int rpmsgmtd_write_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_write_s *msg = data;
int ret;
ret = MTD_WRITE(server->dev, msg->offset, msg->nbytes, msg->buf);
if (ret <= 0)
{
ferr("mtd write failed\n");
}
/* cookie != 0 indicate the data has been sent complete, so send back
* the total written bytes.
*/
if (msg->header.cookie != 0)
{
msg->header.result = ret;
rpmsg_send(ept, msg, sizeof(*msg) - 1);
}
return 0;
}
/****************************************************************************
* Name: rpmsgmtd_ioctl_handler
****************************************************************************/
static int rpmsgmtd_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
FAR struct rpmsgmtd_ioctl_s *msg = data;
msg->header.result = MTD_IOCTL(server->dev, msg->request,
msg->arglen > 0 ? (unsigned long)msg->buf :
msg->arg);
return rpmsg_send(ept, msg, len);
}
/****************************************************************************
* Name: rpmsgmtd_ns_match
****************************************************************************/
static bool rpmsgmtd_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv, FAR const char *name,
uint32_t dest)
{
return !strncmp(name, RPMSGMTD_NAME_PREFIX, RPMSGMTD_NAME_PREFIX_LEN);
}
/****************************************************************************
* Name: rpmsgmtd_ns_bind
****************************************************************************/
static void rpmsgmtd_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv, FAR const char *name,
uint32_t dest)
{
FAR struct rpmsgmtd_server_s *server;
FAR struct inode *mtdnode;
int ret;
server = kmm_zalloc(sizeof(*server));
if (server == NULL)
{
ferr("mtd server malloced failed\n");
return;
}
ret = find_mtddriver(&name[RPMSGMTD_NAME_PREFIX_LEN], &mtdnode);
if (ret < 0)
{
ferr("mtd device find failed, ret=%d\n", ret);
goto errout;
}
server->ept.priv = server;
server->mtdnode = mtdnode;
server->dev = mtdnode->u.i_mtd;
ret = rpmsg_create_ept(&server->ept, rdev, name,
RPMSG_ADDR_ANY, dest,
rpmsgmtd_ept_cb, rpmsgmtd_ns_unbind);
if (ret < 0)
{
ferr("endpoint create failed, ret=%d\n", ret);
close_mtddriver(mtdnode);
goto errout;
}
return;
errout:
kmm_free(server);
}
/****************************************************************************
* Name: rpmsgmtd_ns_unbind
****************************************************************************/
static void rpmsgmtd_ns_unbind(FAR struct rpmsg_endpoint *ept)
{
FAR struct rpmsgmtd_server_s *server = ept->priv;
rpmsg_destroy_ept(&server->ept);
close_mtddriver(server->mtdnode);
kmm_free(server);
}
/****************************************************************************
* Name: rpmsgmtd_ept_cb
****************************************************************************/
static int rpmsgmtd_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv)
{
FAR struct rpmsgmtd_header_s *header = data;
uint32_t command = header->command;
if (command < ARRAY_SIZE(g_rpmsgmtd_handler))
{
return g_rpmsgmtd_handler[command](ept, data, len, src, priv);
}
return -EINVAL;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: rpmsgmtd_server_init
*
* Description:
* Rpmsg-mtd server initialize function, the server cpu should call
* this function.
*
* Parameters:
* None
*
* Returned Values:
* OK on success; A negated errno value is returned on any failure.
*
****************************************************************************/
int rpmsgmtd_server_init(void)
{
return rpmsg_register_callback(NULL,
NULL,
NULL,
rpmsgmtd_ns_match,
rpmsgmtd_ns_bind);
}
Reference in New Issue View Git Blame Copy Permalink