Imagelibrary/rtems
1
0
Fork 1
mirror of https://gitlab.rtems.org/rtems/rtos/rtems.git synced 2026-02-05 13:11:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

bsps/aarch64/xilinx-zynqmp: Obsolete direct JFFS2 adapters

Browse Source 
This removes the adapters that provide glue code directly from JFFS2 to
backend storage drivers since JFFS2, the NAND driver, and the QSPI NOR
driver all support the flashdev interface.
This commit is contained in:
Kinsey Moore
2026-01-26 10:03:16 -06:00
committed by Joel Sherrill
parent 1eac734295
commit f2b6a2383b
8 changed files with 0 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
bsps/aarch64/xilinx-zynqmp/include/bsp/jffs2_xnandpsu.h
View File

@@ -1,56 +0,0 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2023 On-Line Applications Research Corporation (OAR)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LIBBSP_XILINX_ZYNQMP_JFFS2_XNANDPSU_H
#define LIBBSP_XILINX_ZYNQMP_JFFS2_XNANDPSU_H
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#include <dev/nand/xnandpsu.h>
#include <rtems/jffs2.h>
/**
* @brief Mount JFFS2 filesystem on NAND device.
*
* @param[in] mount_dir The directory to mount the filesystem at.
* @param[in] NandPsuInstancePtr A pointer to an initialized NAND instance.
*
* @retval 0 Successful operation. Negative number otherwise.
*/
int xilinx_zynqmp_nand_jffs2_initialize(
const char *mount_dir,
XNandPsu *NandPsuInstancePtr
);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LIBBSP_XILINX_ZYNQMP_JFFS2_XNANDPSU_H */

62
bsps/aarch64/xilinx-zynqmp/include/bsp/jffs2_xqspipsu.h
View File

@@ -1,62 +0,0 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSBSPsAArch64XilinxZynqMP
*
* @brief XilinxZynqMP QSPI JFFS2 flash driver definitions
*/
/*
* Copyright (C) 2022 On-Line Applications Research Corporation (OAR)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef LIBBSP_XILINX_ZYNQMP_JFFS2_XQSPIPSU_H
#define LIBBSP_XILINX_ZYNQMP_JFFS2_XQSPIPSU_H
#include <dev/spi/xqspipsu.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/**
* @brief Mount jffs2 filesystem.
*
* @param[in] mount_dir The directory to mount the filesystem at.
* @param[in] qspipsu_ptr A pointer to an initialized QSPI instance.
*
* @retval 0 Successful operation. Negative number otherwise.
*/
int xilinx_zynqmp_nor_jffs2_initialize(
const char *mount_dir,
XQspiPsu *qspipsu_ptr
);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LIBBSP_XILINX_ZYNQMP_JFFS2_XQSPIPSU_H */

375
bsps/aarch64/xilinx-zynqmp/jffs2_xnandpsu.c
View File

@@ -1,375 +0,0 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2023 On-Line Applications Research Corporation (OAR)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This file contains an implementation of a basic JFFS2 filesystem adapter for
* the NandPsu peripheral that uses the entirety of the available NAND chip(s)
* for a JFFS2 filesystem or up to the maximum size possible. If an
* implementation would prefer to only use a portion of the NAND flash chip,
* this template would need rework to account for a reduced size and possibly a
* start offset while also taking into account the driver's handling of bad
* blocks and how that might affect the offset.
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <bsp/jffs2_xnandpsu.h>
#include <rtems/libio.h>
#include <rtems/libcsupport.h>
#include <rtems/malloc.h>
#include <rtems/thread.h>
#include <dev/nand/xnandpsu_bbm.h>
typedef struct {
rtems_jffs2_flash_control super;
XNandPsu *nandpsu;
rtems_mutex access_lock;
} flash_control;
static flash_control *get_flash_control(rtems_jffs2_flash_control *super)
{
return (flash_control *) super;
}
static int flash_read(
rtems_jffs2_flash_control *super,
uint32_t offset,
unsigned char *buffer,
size_t size_of_buffer
)
{
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
rtems_status_code sc;
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
sc = XNandPsu_Read(nandpsu, offset, size_of_buffer, buffer);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
if (sc) {
return -EIO;
}
return 0;
}
static int flash_write(
rtems_jffs2_flash_control *super,
uint32_t offset,
const unsigned char *buffer,
size_t size_of_buffer
)
{
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
rtems_status_code sc;
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
sc = XNandPsu_Write(nandpsu, offset, size_of_buffer, (void *)buffer);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
if (sc) {
return -EIO;
}
return 0;
}
static int flash_erase(
rtems_jffs2_flash_control *super,
uint32_t offset
)
{
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
rtems_status_code sc;
uint64_t BlockSize = nandpsu->Geometry.BlockSize;
if (offset > nandpsu->Geometry.DeviceSize) {
return -EIO;
}
/* Perform erase operation. */
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
sc = XNandPsu_Erase(nandpsu, RTEMS_ALIGN_DOWN(offset, BlockSize), BlockSize);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
if (sc ) {
return -EIO;
}
return 0;
}
static int flash_block_is_bad(
rtems_jffs2_flash_control *super,
uint32_t offset,
bool *bad
)
{
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
uint32_t BlockIndex;
uint8_t BlockData;
uint8_t BlockShift;
uint8_t BlockType;
uint32_t BlockOffset;
assert(bad);
if (offset > nandpsu->Geometry.DeviceSize) {
return -EIO;
}
*bad = true;
BlockIndex = offset / nandpsu->Geometry.BlockSize;
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
/* XNandPsu_IsBlockBad() is insufficient for this use case */
BlockOffset = BlockIndex >> XNANDPSU_BBT_BLOCK_SHIFT;
BlockShift = XNandPsu_BbtBlockShift(BlockIndex);
BlockData = nandpsu->Bbt[BlockOffset];
BlockType = (BlockData >> BlockShift) & XNANDPSU_BLOCK_TYPE_MASK;
if (BlockType == XNANDPSU_BLOCK_GOOD) {
*bad = false;
}
int TargetBlockIndex = BlockIndex % nandpsu->Geometry.NumTargetBlocks;
/* The last 4 blocks of every device target are reserved for the BBT */
if (nandpsu->Geometry.NumTargetBlocks - TargetBlockIndex <= 4) {
*bad = true;
}
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
return 0;
}
static int flash_block_mark_bad(
rtems_jffs2_flash_control *super,
uint32_t offset
)
{
rtems_status_code sc;
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
uint32_t BlockIndex;
if (offset > nandpsu->Geometry.DeviceSize) {
return -EIO;
}
BlockIndex = offset / nandpsu->Geometry.BlockSize;
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
sc = XNandPsu_MarkBlockBad(nandpsu, BlockIndex);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
if ( sc != XST_SUCCESS ) {
return -EIO;
}
return RTEMS_SUCCESSFUL;
}
static int flash_read_oob_locked(
rtems_jffs2_flash_control *super,
uint32_t offset,
uint8_t *oobbuf,
uint32_t ooblen
)
{
uint8_t *spare_bytes;
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
uint32_t SpareBytesPerPage = nandpsu->Geometry.SpareBytesPerPage;
if (offset > nandpsu->Geometry.DeviceSize) {
return -EIO;
}
/* Can't request more spare bytes than exist */
if (ooblen > SpareBytesPerPage * nandpsu->Geometry.PagesPerBlock) {
return -EIO;
}
/* Get page index */
uint32_t PageIndex = offset / nandpsu->Geometry.BytesPerPage;
spare_bytes = rtems_malloc(SpareBytesPerPage);
if (spare_bytes == NULL) {
return -ENOMEM;
}
while (ooblen) {
int rv = XNandPsu_ReadSpareBytes(nandpsu, PageIndex, spare_bytes);
/* no guarantee oobbuf can hold all of spare bytes, so read and then copy */
uint32_t readlen = SpareBytesPerPage;
if (ooblen < readlen) {
readlen = ooblen;
}
if (rv) {
free(spare_bytes);
return -EIO;
}
memcpy(oobbuf, spare_bytes, readlen);
PageIndex++;
ooblen -= readlen;
oobbuf += readlen;
}
free(spare_bytes);
return RTEMS_SUCCESSFUL;
}
static int flash_read_oob(
rtems_jffs2_flash_control *super,
uint32_t offset,
uint8_t *oobbuf,
uint32_t ooblen
)
{
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
int ret = flash_read_oob_locked(super, offset, oobbuf, ooblen);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
return ret;
}
static int flash_write_oob(
rtems_jffs2_flash_control *super,
uint32_t offset,
uint8_t *oobbuf,
uint32_t ooblen
)
{
rtems_status_code sc;
uint8_t *spare_bytes;
uint8_t *buffer = oobbuf;
XNandPsu *nandpsu = get_flash_control(super)->nandpsu;
uint32_t SpareBytesPerPage = nandpsu->Geometry.SpareBytesPerPage;
if (offset > nandpsu->Geometry.DeviceSize) {
return -EIO;
}
/* Writing a page spare area to large will result in ignored data. */
if (ooblen > SpareBytesPerPage) {
return -EIO;
}
spare_bytes = rtems_malloc(SpareBytesPerPage);
if (spare_bytes == NULL) {
return -ENOMEM;
}
/* Writing a page spare area to small will result in invalid accesses */
rtems_mutex_lock(&(get_flash_control(super)->access_lock));
if (ooblen < SpareBytesPerPage) {
int rv = flash_read_oob_locked(super, offset, spare_bytes, SpareBytesPerPage);
if (rv) {
free(spare_bytes);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
return rv;
}
buffer = spare_bytes;
memcpy(buffer, oobbuf, ooblen);
}
/* Get page index */
uint32_t PageIndex = offset / nandpsu->Geometry.BytesPerPage;
sc = XNandPsu_WriteSpareBytes(nandpsu, PageIndex, buffer);
rtems_mutex_unlock(&(get_flash_control(super)->access_lock));
free(spare_bytes);
if ( sc != XST_SUCCESS ) {
return -EIO;
}
return RTEMS_SUCCESSFUL;
}
static uint32_t flash_get_oob_size(
rtems_jffs2_flash_control *super
)
{
flash_control *self = get_flash_control(super);
return self->nandpsu->Geometry.SpareBytesPerPage;
}
static flash_control flash_instance = {
.super = {
.read = flash_read,
.write = flash_write,
.erase = flash_erase,
.block_is_bad = flash_block_is_bad,
.block_mark_bad = flash_block_mark_bad,
.oob_read = flash_read_oob,
.oob_write = flash_write_oob,
.get_oob_size = flash_get_oob_size,
}
};
static rtems_jffs2_compressor_control compressor_instance = {
.compress = rtems_jffs2_compressor_rtime_compress,
.decompress = rtems_jffs2_compressor_rtime_decompress
};
static rtems_jffs2_mount_data mount_data;
int xilinx_zynqmp_nand_jffs2_initialize(
const char *mount_dir,
XNandPsu *NandInstPtr
)
{
flash_instance.super.block_size = NandInstPtr->Geometry.BlockSize;
uint64_t max_size = 0x100000000LU - flash_instance.super.block_size;
/* JFFS2 maximum FS size is one block less than 4GB */
if (NandInstPtr->Geometry.DeviceSize > max_size) {
flash_instance.super.flash_size = max_size;
} else {
flash_instance.super.flash_size = NandInstPtr->Geometry.DeviceSize;
}
flash_instance.super.write_size = NandInstPtr->Geometry.BytesPerPage;
flash_instance.nandpsu = NandInstPtr;
rtems_mutex_init(&flash_instance.access_lock, "XNandPsu JFFS2 adapter lock");
mount_data.flash_control = &flash_instance.super;
mount_data.compressor_control = &compressor_instance;
int rv = 0;
rv = mount(
NULL,
mount_dir,
RTEMS_FILESYSTEM_TYPE_JFFS2,
RTEMS_FILESYSTEM_READ_WRITE,
&mount_data
);
if ( rv != 0 ) {
return rv;
}
return 0;
}

186
bsps/aarch64/xilinx-zynqmp/jffs2_xqspipsu.c
View File

@@ -1,186 +0,0 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2022 On-Line Applications Research Corporation (OAR)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h>
#include <bsp/irq.h>
#include <bsp/jffs2_xqspipsu.h>
#include <rtems/jffs2.h>
#include <rtems/libio.h>
#include <xqspipsu-flash-helper.h>
typedef struct {
rtems_jffs2_flash_control super;
XQspiPsu *qspipsu;
} flash_control;
#define FLASH_DEVICE_ID 0xbb20 /* Type: 0xbb, Capacity: 0x20 */
static flash_control *get_flash_control( rtems_jffs2_flash_control *super )
{
return (flash_control *) super;
}
static int do_read(
rtems_jffs2_flash_control *super,
uint32_t offset,
unsigned char *buffer,
size_t size_of_buffer
)
{
int Status;
flash_control *self = get_flash_control( super );
XQspiPsu *QspiPsuPtr = self->qspipsu;
u8* ReadBuffer = NULL;
Status = QspiPsu_NOR_Read_Page(
QspiPsuPtr,
offset,
size_of_buffer,
&ReadBuffer
);
if ( Status != XST_SUCCESS ) {
return Status;
}
/*
* We have to copy since we can't be sure that buffer is properly aligned.
*/
memcpy( buffer, ReadBuffer, size_of_buffer );
return 0;
}
static int do_write(
rtems_jffs2_flash_control *super,
uint32_t offset,
const unsigned char *buffer,
size_t size_of_buffer
)
{
int Status;
flash_control *self = get_flash_control( super );
XQspiPsu *QspiPsuPtr = self->qspipsu;
Status = QspiPsu_NOR_Write(
QspiPsuPtr,
offset,
size_of_buffer,
(unsigned char *) buffer
);
if ( Status != XST_SUCCESS ) {
return Status;
}
return 0;
}
static int do_erase(
rtems_jffs2_flash_control *super,
uint32_t offset
)
{
int Status;
flash_control *self = get_flash_control( super );
XQspiPsu *QspiPsuPtr = self->qspipsu;
Status = QspiPsu_NOR_Erase(
QspiPsuPtr,
offset,
super->block_size
);
if ( Status != XST_SUCCESS ) {
return Status;
}
return 0;
}
static void do_destroy( rtems_jffs2_flash_control *super )
{
flash_control *self = get_flash_control( super );
rtems_interrupt_handler_remove(
ZYNQMP_IRQ_QSPI,
(rtems_interrupt_handler) XQspiPsu_InterruptHandler,
self->qspipsu
);
}
static flash_control flash_instance = {
.super = {
.read = do_read,
.write = do_write,
.erase = do_erase,
.destroy = do_destroy,
.device_identifier = FLASH_DEVICE_ID
}
};
static rtems_jffs2_mount_data mount_data = {
.flash_control = &flash_instance.super,
.compressor_control = NULL
};
int xilinx_zynqmp_nor_jffs2_initialize(
const char *mount_dir,
XQspiPsu *qspipsu_ptr
)
{
int rv = 0;
flash_instance.qspipsu = qspipsu_ptr;
rv = QspiPsu_NOR_Initialize(
flash_instance.qspipsu,
ZYNQMP_IRQ_QSPI
);
if ( rv != 0 ) {
return rv;
}
uint32_t sect_size = QspiPsu_NOR_Get_Sector_Size(qspipsu_ptr);
uint32_t flash_size = QspiPsu_NOR_Get_Device_Size(qspipsu_ptr);
flash_instance.super.flash_size = flash_size;
flash_instance.super.block_size = sect_size;
rv = mount(
NULL,
mount_dir,
RTEMS_FILESYSTEM_TYPE_JFFS2,
RTEMS_FILESYSTEM_READ_WRITE,
&mount_data
);
if ( rv != 0 ) {
return rv;
}
return 0;
}

2
spec/build/bsps/aarch64/xilinx-zynqmp/grp.yml
View File

@@ -22,8 +22,6 @@ links:
uid: abi
- role: build-dependency
uid: obj
- role: build-dependency
uid: objjffs2qspinor
- role: build-dependency
uid: objsmp
- role: build-dependency

2
spec/build/bsps/aarch64/xilinx-zynqmp/grp_hardware.yml
View File

@@ -12,8 +12,6 @@ ldflags: []
links:
- role: build-dependency
uid: ../../objnandpsu
- role: build-dependency
uid: objnandjffs2
- role: build-dependency
uid: grp
- role: build-dependency

20
spec/build/bsps/aarch64/xilinx-zynqmp/objjffs2qspinor.yml
View File

@@ -1,20 +0,0 @@
SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
build-type: objects
cflags: []
copyrights:
- Copyright (C) 2022 On-Line Applications Research (OAR)
cppflags: []
cxxflags: []
enabled-by: true
includes:
- bsps/include/dev/spi/
install:
- destination: ${BSP_INCLUDEDIR}/bsp
source:
- bsps/aarch64/xilinx-zynqmp/include/bsp/jffs2_xqspipsu.h
links:
- role: build-dependency
uid: ../../objqspipsu
source:
- bsps/aarch64/xilinx-zynqmp/jffs2_xqspipsu.c
type: build

18
spec/build/bsps/aarch64/xilinx-zynqmp/objnandjffs2.yml
View File

@@ -1,18 +0,0 @@
SPDX-License-Identifier: CC-BY-SA-4.0 OR BSD-2-Clause
build-type: objects
cflags: []
copyrights:
- Copyright (C) 2023 On-Line Applications Research (OAR)
cppflags: []
cxxflags: []
enabled-by: true
includes:
- bsps/include/dev/nand/
install:
- destination: ${BSP_INCLUDEDIR}/bsp
source:
- bsps/aarch64/xilinx-zynqmp/include/bsp/jffs2_xnandpsu.h
links: []
source:
- bsps/aarch64/xilinx-zynqmp/jffs2_xnandpsu.c
type: build