Merge git://git.denx.de/u-boot-fsl-qoriq

master
Tom Rini 7 years ago
commit 6c7010b779
  1. 5
      arch/arm/cpu/armv8/fsl-layerscape/Kconfig
  2. 38
      arch/arm/cpu/armv8/fsl-layerscape/cpu.c
  3. 20
      arch/arm/cpu/armv8/fsl-layerscape/doc/README.core_prefetch
  4. 27
      arch/arm/cpu/armv8/fsl-layerscape/soc.c
  5. 2
      board/freescale/ls1088a/Kconfig
  6. 12
      board/freescale/ls1088a/MAINTAINERS
  7. 35
      board/freescale/ls1088a/ls1088a.c
  8. 47
      configs/ls1088aqds_qspi_SECURE_BOOT_defconfig
  9. 1
      configs/ls1088aqds_qspi_defconfig
  10. 1
      configs/ls1088aqds_sdcard_qspi_defconfig
  11. 48
      configs/ls1088ardb_qspi_SECURE_BOOT_defconfig
  12. 1
      configs/ls1088ardb_qspi_defconfig
  13. 1
      configs/ls1088ardb_sdcard_qspi_defconfig
  14. 5
      configs/ls2080aqds_SECURE_BOOT_defconfig
  15. 5
      configs/ls2080ardb_SECURE_BOOT_defconfig
  16. 42
      drivers/net/fsl-mc/dpbp.c
  17. 43
      drivers/net/fsl-mc/dpio/dpio.c
  18. 41
      drivers/net/fsl-mc/dpmac.c
  19. 332
      drivers/net/fsl-mc/dpni.c
  20. 27
      drivers/net/fsl-mc/dprc.c
  21. 5
      drivers/net/fsl-mc/fsl_dpmng_cmd.h
  22. 240
      drivers/net/fsl-mc/mc.c
  23. 283
      drivers/net/ldpaa_eth/ldpaa_eth.c
  24. 5
      drivers/net/ldpaa_eth/ldpaa_eth.h
  25. 4
      include/configs/ls1012a_common.h
  26. 2
      include/configs/ls1012afrdm.h
  27. 33
      include/configs/ls1021atwr.h
  28. 31
      include/configs/ls1043a_common.h
  29. 12
      include/configs/ls1046a_common.h
  30. 8
      include/configs/ls1046ardb.h
  31. 3
      include/configs/ls1088a_common.h
  32. 21
      include/configs/ls1088aqds.h
  33. 52
      include/configs/ls1088ardb.h
  34. 62
      include/fsl-mc/fsl_dpbp.h
  35. 64
      include/fsl-mc/fsl_dpio.h
  36. 69
      include/fsl-mc/fsl_dpmac.h
  37. 1065
      include/fsl-mc/fsl_dpni.h
  38. 79
      include/fsl-mc/fsl_dprc.h
  39. 50
      include/fsl-mc/fsl_mc_cmd.h
  40. 8
      include/fsl-mc/fsl_mc_private.h

@ -5,6 +5,10 @@ config ARCH_LS1012A
select SYS_FSL_DDR_BE
select SYS_FSL_MMDC
select SYS_FSL_ERRATUM_A010315
select SYS_FSL_ERRATUM_A009798
select SYS_FSL_ERRATUM_A008997
select SYS_FSL_ERRATUM_A009007
select SYS_FSL_ERRATUM_A009008
select ARCH_EARLY_INIT_R
select BOARD_EARLY_INIT_F
@ -244,6 +248,7 @@ config SYS_LS_PPA_ESBC_ADDR
default 0x40680000 if SYS_LS_PPA_FW_IN_XIP && ARCH_LS1012A
default 0x20680000 if SYS_LS_PPA_FW_IN_XIP && QSPI_BOOT && ARCH_LS2080A
default 0x580680000 if SYS_LS_PPA_FW_IN_XIP && ARCH_LS2080A
default 0x20680000 if SYS_LS_PPA_FW_IN_XIP && ARCH_LS1088A
default 0x680000 if SYS_LS_PPA_FW_IN_MMC
default 0x680000 if SYS_LS_PPA_FW_IN_NAND
help

@ -29,6 +29,7 @@
#include <fsl_ddr.h>
#endif
#include <asm/arch/clock.h>
#include <hwconfig.h>
DECLARE_GLOBAL_DATA_PTR;
@ -494,6 +495,41 @@ static inline int check_psci(void)
return 0;
}
static void config_core_prefetch(void)
{
char *buf = NULL;
char buffer[HWCONFIG_BUFFER_SIZE];
const char *prefetch_arg = NULL;
size_t arglen;
unsigned int mask;
struct pt_regs regs;
if (env_get_f("hwconfig", buffer, sizeof(buffer)) > 0)
buf = buffer;
prefetch_arg = hwconfig_subarg_f("core_prefetch", "disable",
&arglen, buf);
if (prefetch_arg) {
mask = simple_strtoul(prefetch_arg, NULL, 0) & 0xff;
if (mask & 0x1) {
printf("Core0 prefetch can't be disabled\n");
return;
}
#define SIP_PREFETCH_DISABLE_64 0xC200FF13
regs.regs[0] = SIP_PREFETCH_DISABLE_64;
regs.regs[1] = mask;
smc_call(&regs);
if (regs.regs[0])
printf("Prefetch disable config failed for mask ");
else
printf("Prefetch disable config passed for mask ");
printf("0x%x\n", mask);
}
}
int arch_early_init_r(void)
{
#ifdef CONFIG_SYS_FSL_ERRATUM_A009635
@ -521,6 +557,8 @@ int arch_early_init_r(void)
fsl_rgmii_init();
#endif
config_core_prefetch();
#ifdef CONFIG_SYS_HAS_SERDES
fsl_serdes_init();
#endif

@ -0,0 +1,20 @@
Core instruction prefetch disable
---------------------------------
To disable instruction prefetch of core; hwconfig needs to be updated.
for e.g.
setenv hwconfig 'fsl_ddr:bank_intlv=auto;core_prefetch:disable=0x02'
Here 0x02 can be replaced with any valid value except Mask[0] bit. It
represents 64 bit mask. The 64-bit Mask has one bit for each core.
Mask[0] = core0
Mask[1] = core1
Mask[2] = core2
etc
If the bit is set ('b1) in the mask, then prefetch is disabled for
that core when it is released from reset.
core0 prefetch should not be disabled i.e. Mask[0] should never be set.
Setting Mask[0] may lead to undefined behavior.
Once disabled, prefetch remains disabled until the next reset.
There is no function to re-enable prefetch.

@ -66,10 +66,13 @@ static void erratum_a009008(void)
#ifdef CONFIG_SYS_FSL_ERRATUM_A009008
u32 __iomem *scfg = (u32 __iomem *)SCFG_BASE;
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
set_usb_txvreftune(scfg, SCFG_USB3PRM1CR_USB1);
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
set_usb_txvreftune(scfg, SCFG_USB3PRM1CR_USB2);
set_usb_txvreftune(scfg, SCFG_USB3PRM1CR_USB3);
#endif
#elif defined(CONFIG_ARCH_LS2080A)
set_usb_txvreftune(scfg, SCFG_USB3PRM1CR);
#endif
@ -87,17 +90,21 @@ static void erratum_a009798(void)
#ifdef CONFIG_SYS_FSL_ERRATUM_A009798
u32 __iomem *scfg = (u32 __iomem *)SCFG_BASE;
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
set_usb_sqrxtune(scfg, SCFG_USB3PRM1CR_USB1);
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
set_usb_sqrxtune(scfg, SCFG_USB3PRM1CR_USB2);
set_usb_sqrxtune(scfg, SCFG_USB3PRM1CR_USB3);
#endif
#elif defined(CONFIG_ARCH_LS2080A)
set_usb_sqrxtune(scfg, SCFG_USB3PRM1CR);
#endif
#endif /* CONFIG_SYS_FSL_ERRATUM_A009798 */
}
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
static inline void set_usb_pcstxswingfull(u32 __iomem *scfg, u32 offset)
{
scfg_clrsetbits32(scfg + offset / 4,
@ -109,17 +116,21 @@ static inline void set_usb_pcstxswingfull(u32 __iomem *scfg, u32 offset)
static void erratum_a008997(void)
{
#ifdef CONFIG_SYS_FSL_ERRATUM_A008997
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
u32 __iomem *scfg = (u32 __iomem *)SCFG_BASE;
set_usb_pcstxswingfull(scfg, SCFG_USB3PRM2CR_USB1);
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
set_usb_pcstxswingfull(scfg, SCFG_USB3PRM2CR_USB2);
set_usb_pcstxswingfull(scfg, SCFG_USB3PRM2CR_USB3);
#endif
#endif
#endif /* CONFIG_SYS_FSL_ERRATUM_A008997 */
}
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
#define PROGRAM_USB_PHY_RX_OVRD_IN_HI(phy) \
out_be16((phy) + SCFG_USB_PHY_RX_OVRD_IN_HI, USB_PHY_RX_EQ_VAL_1); \
@ -139,16 +150,18 @@ static void erratum_a008997(void)
static void erratum_a009007(void)
{
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A) || \
defined(CONFIG_ARCH_LS1012A)
void __iomem *usb_phy = (void __iomem *)SCFG_USB_PHY1;
PROGRAM_USB_PHY_RX_OVRD_IN_HI(usb_phy);
#if defined(CONFIG_ARCH_LS1043A) || defined(CONFIG_ARCH_LS1046A)
usb_phy = (void __iomem *)SCFG_USB_PHY2;
PROGRAM_USB_PHY_RX_OVRD_IN_HI(usb_phy);
usb_phy = (void __iomem *)SCFG_USB_PHY3;
PROGRAM_USB_PHY_RX_OVRD_IN_HI(usb_phy);
#endif
#elif defined(CONFIG_ARCH_LS2080A) || defined(CONFIG_ARCH_LS1088A)
void __iomem *dcsr = (void __iomem *)DCSR_BASE;

@ -12,6 +12,7 @@ config SYS_SOC
config SYS_CONFIG_NAME
default "ls1088aqds"
source "board/freescale/common/Kconfig"
endif
if TARGET_LS1088ARDB
@ -28,4 +29,5 @@ config SYS_SOC
config SYS_CONFIG_NAME
default "ls1088ardb"
source "board/freescale/common/Kconfig"
endif

@ -15,3 +15,15 @@ F: board/freescale/ls1088a/
F: include/configs/ls1088aqds.h
F: configs/ls1088aqds_qspi_defconfig
F: configs/ls1088aqds_sdcard_qspi_defconfig
LS1088AQDS_QSPI_SECURE_BOOT BOARD
M: Udit Agarwal <udit.agarwal@nxp.com>
M: Vinitha Pillai-B57223 <vinitha.pillai@nxp.com>
S: Maintained
F: configs/ls1088aqds_qspi_SECURE_BOOT_defconfig
LS1088ARDB_QSPI_SECURE_BOOT BOARD
M: Udit Agarwal <udit.agarwal@nxp.com>
M: Vinitha Pillai-B57223 <vinitha.pillai@nxp.com>
S: Maintained
F: configs/ls1088ardb_qspi_SECURE_BOOT_defconfig

@ -315,6 +315,9 @@ int board_init(void)
out_le32(irq_ccsr + IRQCR_OFFSET / 4, AQR105_IRQ_MASK);
#endif
#ifdef CONFIG_FSL_CAAM
sec_init();
#endif
#ifdef CONFIG_FSL_LS_PPA
ppa_init();
#endif
@ -337,9 +340,6 @@ void detail_board_ddr_info(void)
#if defined(CONFIG_ARCH_MISC_INIT)
int arch_misc_init(void)
{
#ifdef CONFIG_FSL_CAAM
sec_init();
#endif
return 0;
}
#endif
@ -368,6 +368,33 @@ void fdt_fixup_board_enet(void *fdt)
#endif
#ifdef CONFIG_OF_BOARD_SETUP
void fsl_fdt_fixup_flash(void *fdt)
{
int offset;
/*
* IFC-NOR and QSPI are muxed on SoC.
* So disable IFC node in dts if QSPI is enabled or
* disable QSPI node in dts in case QSPI is not enabled.
*/
#ifdef CONFIG_FSL_QSPI
offset = fdt_path_offset(fdt, "/soc/ifc/nor");
if (offset < 0)
offset = fdt_path_offset(fdt, "/ifc/nor");
#else
offset = fdt_path_offset(fdt, "/soc/quadspi");
if (offset < 0)
offset = fdt_path_offset(fdt, "/quadspi");
#endif
if (offset < 0)
return;
fdt_status_disabled(fdt, offset);
}
int ft_board_setup(void *blob, bd_t *bd)
{
int err, i;
@ -394,6 +421,8 @@ int ft_board_setup(void *blob, bd_t *bd)
fdt_fixup_memory_banks(blob, base, size, CONFIG_NR_DRAM_BANKS);
fsl_fdt_fixup_flash(blob);
#ifdef CONFIG_FSL_MC_ENET
fdt_fixup_board_enet(blob);
err = fsl_mc_ldpaa_exit(bd);

@ -0,0 +1,47 @@
CONFIG_ARM=y
# CONFIG_CMD_SETEXPR is not set
CONFIG_CMD_DHCP=y
CONFIG_CMD_I2C=y
CONFIG_CMD_MMC=y
CONFIG_CMD_PING=y
CONFIG_CMD_SF=y
CONFIG_CMD_USB=y
# CONFIG_SYS_MALLOC_F is not set
CONFIG_DEFAULT_DEVICE_TREE="fsl-ls1088a-qds"
CONFIG_DM=y
CONFIG_DM_PCI=y
CONFIG_DM_PCI_COMPAT=y
CONFIG_DM_SPI=y
CONFIG_DM_SPI_FLASH=y
CONFIG_DM_USB=y
CONFIG_EFI_LOADER_BOUNCE_BUFFER=y
CONFIG_ENV_IS_IN_SPI_FLASH=y
CONFIG_E1000=y
CONFIG_FIT_VERBOSE=y
CONFIG_FSL_CAAM=y
CONFIG_FSL_DSPI=y
CONFIG_FSL_LS_PPA=y
CONFIG_HUSH_PARSER=y
CONFIG_NETDEVICES=y
CONFIG_NET_RANDOM_ETHADDR=y
CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_CONTROL=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_PCI=y
CONFIG_PCIE_LAYERSCAPE=y
CONFIG_RSA=y
CONFIG_RSA_SOFTWARE_EXP=y
CONFIG_SECURE_BOOT=y
CONFIG_SPI_FLASH=y
CONFIG_SPI_FLASH_SPANSION=y
CONFIG_SYS_EXTRA_OPTIONS="SYS_FSL_DDR4, QSPI_BOOT"
CONFIG_SYS_NS16550=y
CONFIG_TARGET_LS1088AQDS=y
CONFIG_USB=y
CONFIG_USB_DWC3=y
CONFIG_USB_GADGET=y
CONFIG_USB_STORAGE=y
CONFIG_USB_XHCI_DWC3=y
CONFIG_USB_XHCI_HCD=y
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set

@ -8,6 +8,7 @@ CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_SYS_EXTRA_OPTIONS="SYS_FSL_DDR4, QSPI_BOOT"
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set
CONFIG_HUSH_PARSER=y
CONFIG_CMD_I2C=y
CONFIG_CMD_MMC=y

@ -14,6 +14,7 @@ CONFIG_PARTITIONS=y
CONFIG_SYS_EXTRA_OPTIONS="SD_BOOT_QSPI"
CONFIG_SD_BOOT=y
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set
CONFIG_SPL=y
CONFIG_SPL_BUILD=y
CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR=y

@ -0,0 +1,48 @@
CONFIG_ARM=y
# CONFIG_CMD_SETEXPR is not set
CONFIG_CMD_DHCP=y
CONFIG_CMD_I2C=y
CONFIG_CMD_MMC=y
CONFIG_CMD_PING=y
CONFIG_CMD_SF=y
CONFIG_CMD_USB=y
# CONFIG_SYS_MALLOC_F is not set
CONFIG_DEFAULT_DEVICE_TREE="fsl-ls1088a-rdb"
CONFIG_DISTRO_DEFAULTS=y
CONFIG_DM=y
CONFIG_DM_PCI=y
CONFIG_DM_PCI_COMPAT=y
CONFIG_DM_SPI=y
CONFIG_DM_SPI_FLASH=y
CONFIG_DM_USB=y
CONFIG_EFI_LOADER_BOUNCE_BUFFER=y
CONFIG_ENV_IS_IN_SPI_FLASH=y
CONFIG_E1000=y
CONFIG_FIT_VERBOSE=y
CONFIG_FSL_CAAM=y
CONFIG_FSL_DSPI=y
CONFIG_FSL_LS_PPA=y
CONFIG_HUSH_PARSER=y
CONFIG_NETDEVICES=y
CONFIG_NET_RANDOM_ETHADDR=y
CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_CONTROL=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_PCI=y
CONFIG_PCIE_LAYERSCAPE=y
CONFIG_RSA=y
CONFIG_RSA_SOFTWARE_EXP=y
CONFIG_SECURE_BOOT=y
CONFIG_SPI_FLASH=y
CONFIG_SPI_FLASH_SPANSION=y
CONFIG_SYS_EXTRA_OPTIONS="SYS_FSL_DDR4, QSPI_BOOT"
CONFIG_SYS_NS16550=y
CONFIG_TARGET_LS1088ARDB=y
CONFIG_USB=y
CONFIG_USB_DWC3=y
CONFIG_USB_GADGET=y
CONFIG_USB_STORAGE=y
CONFIG_USB_XHCI_DWC3=y
CONFIG_USB_XHCI_HCD=y
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set

@ -9,6 +9,7 @@ CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_SYS_EXTRA_OPTIONS="SYS_FSL_DDR4, QSPI_BOOT"
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set
CONFIG_HUSH_PARSER=y
CONFIG_CMD_I2C=y
CONFIG_CMD_MMC=y

@ -15,6 +15,7 @@ CONFIG_PARTITIONS=y
CONFIG_SYS_EXTRA_OPTIONS="SD_BOOT_QSPI"
CONFIG_SD_BOOT=y
# CONFIG_DISPLAY_BOARDINFO is not set
# CONFIG_USE_BOOTCOMMAND is not set
CONFIG_SPL=y
CONFIG_SPL_BUILD=y
CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_USE_SECTOR=y

@ -1,12 +1,13 @@
CONFIG_ARM=y
CONFIG_TARGET_LS2080AQDS=y
CONFIG_FSL_LS_PPA=y
CONFIG_SECURE_BOOT=y
CONFIG_DEFAULT_DEVICE_TREE="fsl-ls2080a-qds"
# CONFIG_SYS_MALLOC_F is not set
CONFIG_FIT=y
CONFIG_FIT_VERBOSE=y
CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_ENV_IS_IN_FLASH=y
CONFIG_BOOTDELAY=10
CONFIG_USE_BOOTARGS=y
CONFIG_BOOTARGS="console=ttyS0,115200 root=/dev/ram0 earlycon=uart8250,mmio,0x21c0500 ramdisk_size=0x2000000 default_hugepagesz=2m hugepagesz=2m hugepages=256"
@ -28,6 +29,7 @@ CONFIG_CMD_DATE=y
CONFIG_OF_CONTROL=y
CONFIG_NET_RANDOM_ETHADDR=y
CONFIG_DM=y
CONFIG_FSL_CAAM=y
CONFIG_MTD_NOR_FLASH=y
CONFIG_DM_SPI_FLASH=y
CONFIG_PHYLIB=y
@ -47,6 +49,5 @@ CONFIG_USB_XHCI_HCD=y
CONFIG_USB_XHCI_DWC3=y
CONFIG_USB_STORAGE=y
CONFIG_RSA=y
CONFIG_SPL_RSA=y
CONFIG_RSA_SOFTWARE_EXP=y
CONFIG_EFI_LOADER_BOUNCE_BUFFER=y

@ -1,12 +1,13 @@
CONFIG_ARM=y
CONFIG_TARGET_LS2080ARDB=y
CONFIG_FSL_LS_PPA=y
CONFIG_SECURE_BOOT=y
CONFIG_DEFAULT_DEVICE_TREE="fsl-ls2080a-rdb"
# CONFIG_SYS_MALLOC_F is not set
CONFIG_FIT=y
CONFIG_FIT_VERBOSE=y
CONFIG_OF_BOARD_SETUP=y
CONFIG_OF_STDOUT_VIA_ALIAS=y
CONFIG_ENV_IS_IN_FLASH=y
CONFIG_BOOTDELAY=10
CONFIG_USE_BOOTARGS=y
CONFIG_BOOTARGS="console=ttyS1,115200 root=/dev/ram0 earlycon=uart8250,mmio,0x21c0600 ramdisk_size=0x2000000 default_hugepagesz=2m hugepagesz=2m hugepages=256"
@ -27,6 +28,7 @@ CONFIG_CMD_DATE=y
CONFIG_OF_CONTROL=y
CONFIG_NET_RANDOM_ETHADDR=y
CONFIG_DM=y
CONFIG_FSL_CAAM=y
CONFIG_MTD_NOR_FLASH=y
CONFIG_DM_SPI_FLASH=y
CONFIG_PHYLIB=y
@ -46,6 +48,5 @@ CONFIG_USB_XHCI_HCD=y
CONFIG_USB_XHCI_DWC3=y
CONFIG_USB_STORAGE=y
CONFIG_RSA=y
CONFIG_SPL_RSA=y
CONFIG_RSA_SOFTWARE_EXP=y
CONFIG_EFI_LOADER_BOUNCE_BUFFER=y

@ -1,8 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
* Author: German Rivera <German.Rivera@freescale.com>
* Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -50,9 +50,10 @@ int dpbp_close(struct fsl_mc_io *mc_io,
}
int dpbp_create(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
const struct dpbp_cfg *cfg,
uint16_t *token)
uint32_t *obj_id)
{
struct mc_command cmd = { 0 };
int err;
@ -62,7 +63,7 @@ int dpbp_create(struct fsl_mc_io *mc_io,
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_CREATE,
cmd_flags,
0);
dprc_token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@ -70,21 +71,25 @@ int dpbp_create(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
MC_CMD_READ_OBJ_ID(cmd, *obj_id);
return 0;
}
int dpbp_destroy(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
uint16_t token)
uint32_t obj_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_DESTROY,
cmd_flags,
token);
dprc_token);
/* set object id to destroy */
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
@ -157,3 +162,26 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
return 0;
}
int dpbp_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPBP_CMDID_GET_API_VERSION,
cmd_flags, 0);
/* send command to mc */
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}

@ -1,5 +1,6 @@
/*
* Copyright (C) 2013-2015 Freescale Semiconductor
* Copyright (C) 2013-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -10,7 +11,7 @@
int dpio_open(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
int dpio_id,
uint32_t dpio_id,
uint16_t *token)
{
struct mc_command cmd = { 0 };
@ -49,9 +50,10 @@ int dpio_close(struct fsl_mc_io *mc_io,
}
int dpio_create(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
const struct dpio_cfg *cfg,
uint16_t *token)
uint32_t *obj_id)
{
struct mc_command cmd = { 0 };
int err;
@ -59,7 +61,7 @@ int dpio_create(struct fsl_mc_io *mc_io,
/* prepare command */
cmd.header = mc_encode_cmd_header(DPIO_CMDID_CREATE,
cmd_flags,
0);
dprc_token);
DPIO_CMD_CREATE(cmd, cfg);
/* send command to mc*/
@ -68,21 +70,25 @@ int dpio_create(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
MC_CMD_READ_OBJ_ID(cmd, *obj_id);
return 0;
}
int dpio_destroy(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
uint16_t token)
uint32_t obj_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPIO_CMDID_DESTROY,
cmd_flags,
token);
dprc_token);
/* set object id to destroy */
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
@ -156,3 +162,26 @@ int dpio_get_attributes(struct fsl_mc_io *mc_io,
return 0;
}
int dpio_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_API_VERSION,
cmd_flags, 0);
/* send command to mc */
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}

@ -1,7 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2015 Freescale Semiconductor, Inc.
* Copyright (C) 2015-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
* Author: Prabhakar Kushwaha <prabhakar@freescale.com>
*
* SPDX-License-Identifier: GPL-2.0+
@ -51,9 +52,10 @@ int dpmac_close(struct fsl_mc_io *mc_io,
}
int dpmac_create(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
const struct dpmac_cfg *cfg,
uint16_t *token)
uint32_t *obj_id)
{
struct mc_command cmd = { 0 };
int err;
@ -61,7 +63,7 @@ int dpmac_create(struct fsl_mc_io *mc_io,
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CREATE,
cmd_flags,
0);
dprc_token);
DPMAC_CMD_CREATE(cmd, cfg);
/* send command to mc*/
@ -70,21 +72,25 @@ int dpmac_create(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
MC_CMD_READ_OBJ_ID(cmd, *obj_id);
return 0;
}
int dpmac_destroy(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
uint16_t token)
uint32_t obj_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMAC_CMDID_DESTROY,
cmd_flags,
token);
dprc_token);
/* set object id to destroy */
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
@ -220,3 +226,26 @@ int dpmac_get_counter(struct fsl_mc_io *mc_io,
return 0;
}
int dpmac_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_API_VERSION,
cmd_flags, 0);
/* send command to mc */
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}

@ -1,5 +1,6 @@
/*
* Copyright (C) 2013-2015 Freescale Semiconductor
* Copyright (C) 2013-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -8,22 +9,22 @@
#include <fsl-mc/fsl_mc_cmd.h>
#include <fsl-mc/fsl_dpni.h>
int dpni_prepare_extended_cfg(const struct dpni_extended_cfg *cfg,
uint8_t *ext_cfg_buf)
int dpni_prepare_cfg(const struct dpni_cfg *cfg,
uint8_t *cfg_buf)
{
uint64_t *ext_params = (uint64_t *)ext_cfg_buf;
uint64_t *params = (uint64_t *)cfg_buf;
DPNI_PREP_EXTENDED_CFG(ext_params, cfg);
DPNI_PREP_CFG(params, cfg);
return 0;
}
int dpni_extract_extended_cfg(struct dpni_extended_cfg *cfg,
const uint8_t *ext_cfg_buf)
int dpni_extract_cfg(struct dpni_cfg *cfg,
const uint8_t *cfg_buf)
{
uint64_t *ext_params = (uint64_t *)ext_cfg_buf;
uint64_t *params = (uint64_t *)cfg_buf;
DPNI_EXT_EXTENDED_CFG(ext_params, cfg);
DPNI_EXT_CFG(params, cfg);
return 0;
}
@ -69,9 +70,10 @@ int dpni_close(struct fsl_mc_io *mc_io,
}
int dpni_create(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
const struct dpni_cfg *cfg,
uint16_t *token)
uint32_t *obj_id)
{
struct mc_command cmd = { 0 };
int err;
@ -79,7 +81,7 @@ int dpni_create(struct fsl_mc_io *mc_io,
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
cmd_flags,
0);
dprc_token);
DPNI_CMD_CREATE(cmd, cfg);
/* send command to mc*/
@ -88,21 +90,25 @@ int dpni_create(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
*token = MC_CMD_HDR_READ_TOKEN(cmd.header);
MC_CMD_READ_OBJ_ID(cmd, *obj_id);
return 0;
}
int dpni_destroy(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
uint16_t token)
uint32_t obj_id)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
cmd_flags,
token);
dprc_token);
/* set object id to destroy */
CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
@ -182,8 +188,6 @@ int dpni_get_attributes(struct fsl_mc_io *mc_io,
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
cmd_flags,
token);
DPNI_CMD_GET_ATTR(cmd, attr);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
@ -212,124 +216,19 @@ int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd);
}
int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_BUFFER_LAYOUT,
cmd_flags,
token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout);
return 0;
}
int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout)
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout,
enum dpni_queue_type type)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_BUFFER_LAYOUT,
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
cmd_flags,
token);
DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_BUFFER_LAYOUT,
cmd_flags,
token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout);
return 0;
}
int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_BUFFER_LAYOUT,
cmd_flags,
token);
DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT,
cmd_flags,
token);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
return 0;
}
int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT,
cmd_flags,
token);
DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout);
DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
@ -383,50 +282,6 @@ int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
return 0;
}
int dpni_get_counter(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_counter counter,
uint64_t *value)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_COUNTER,
cmd_flags,
token);
DPNI_CMD_GET_COUNTER(cmd, counter);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_GET_COUNTER(cmd, *value);
return 0;
}
int dpni_set_counter(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_counter counter,
uint64_t value)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_COUNTER,
cmd_flags,
token);
DPNI_CMD_SET_COUNTER(cmd, counter, value);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
@ -544,46 +399,64 @@ int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
return mc_send_command(mc_io, &cmd);
}
int dpni_set_tx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t *flow_id,
const struct dpni_tx_flow_cfg *cfg)
int dpni_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_FLOW,
cmd_flags,
token);
DPNI_CMD_SET_TX_FLOW(cmd, *flow_id, cfg);
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
cmd_flags, 0);
/* send command to mc*/
/* send command to mc */
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
DPNI_RSP_SET_TX_FLOW(cmd, *flow_id);
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}
int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
struct dpni_tx_flow_attr *attr)
int dpni_set_queue(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_queue_type type,
uint8_t tc,
uint8_t index,
const struct dpni_queue *queue)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
cmd_flags,
token);
DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_get_queue(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_queue_type type,
uint8_t tc,
uint8_t index,
struct dpni_queue *queue)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_FLOW,
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
cmd_flags,
token);
DPNI_CMD_GET_TX_FLOW(cmd, flow_id);
DPNI_CMD_GET_QUEUE(cmd, type, tc, index);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@ -591,44 +464,43 @@ int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
DPNI_RSP_GET_TX_FLOW(cmd, attr);
DPNI_RSP_GET_QUEUE(cmd, queue);
return 0;
}
int dpni_set_rx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint8_t tc_id,
uint16_t flow_id,
const struct dpni_queue_cfg *cfg)
int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_confirmation_mode mode)
{
struct dpni_tx_confirmation_mode *cmd_params;
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_RX_FLOW,
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
cmd_flags,
token);
DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg);
cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
cmd_params->confirmation_mode = mode;
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint8_t tc_id,
uint16_t flow_id,
struct dpni_queue_attr *attr)
int dpni_get_statistics(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint8_t page,
struct dpni_statistics *stat)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_RX_FLOW,
cmd_flags,
token);
DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id);
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
cmd_flags, token);
DPNI_CMD_GET_STATISTICS(cmd, page);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
@ -636,50 +508,22 @@ int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
return err;
/* retrieve response parameters */
DPNI_RSP_GET_RX_FLOW(cmd, attr);
DPNI_RSP_GET_STATISTICS(cmd, stat);
return 0;
}
int dpni_set_tx_conf(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
const struct dpni_tx_conf_cfg *cfg)
int dpni_reset_statistics(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token)
{
struct mc_command cmd = { 0 };
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONF,
cmd_flags,
token);
DPNI_CMD_SET_TX_CONF(cmd, flow_id, cfg);
cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
cmd_flags, token);
/* send command to mc*/
return mc_send_command(mc_io, &cmd);
}
int dpni_get_tx_conf(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
struct dpni_tx_conf_attr *attr)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_CONF,
cmd_flags,
token);
DPNI_CMD_GET_TX_CONF(cmd, flow_id);
/* send command to mc*/
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
DPNI_RSP_GET_TX_CONF(cmd, attr);
return 0;
}

@ -1,8 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
* Author: German Rivera <German.Rivera@freescale.com>
* Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -353,3 +353,26 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,
return 0;
}
int dprc_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_command cmd = { 0 };
int err;
/* prepare command */
cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
cmd_flags, 0);
/* send command to mc */
err = mc_send_command(mc_io, &cmd);
if (err)
return err;
/* retrieve response parameters */
mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
return 0;
}

@ -1,4 +1,5 @@
/* Copyright 2013-2015 Freescale Semiconductor Inc.
/* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -6,7 +7,7 @@
#define __FSL_DPMNG_CMD_H
/* Command IDs */
#define DPMNG_CMDID_GET_VERSION 0x831
#define DPMNG_CMDID_GET_VERSION 0x8311
/* cmd, param, offset, width, type, arg_name */
#define DPMNG_RSP_GET_VERSION(cmd, mc_ver_info) \

@ -854,21 +854,25 @@ int fsl_mc_ldpaa_init(bd_t *bis)
static int dprc_version_check(struct fsl_mc_io *mc_io, uint16_t handle)
{
struct dprc_attributes attr;
int error;
uint16_t major_ver, minor_ver;
memset(&attr, 0, sizeof(struct dprc_attributes));
error = dprc_get_attributes(mc_io, MC_CMD_NO_FLAGS, handle, &attr);
if (error == 0) {
if ((attr.version.major != DPRC_VER_MAJOR) ||
(attr.version.minor != DPRC_VER_MINOR)) {
printf("DPRC version mismatch found %u.%u,",
attr.version.major,
attr.version.minor);
printf("supported version is %u.%u\n",
DPRC_VER_MAJOR, DPRC_VER_MINOR);
}
error = dprc_get_api_version(mc_io, 0,
&major_ver,
&minor_ver);
if (error < 0) {
printf("dprc_get_api_version() failed: %d\n", error);
return error;
}
if (major_ver < DPRC_VER_MAJOR || (major_ver == DPRC_VER_MAJOR &&
minor_ver < DPRC_VER_MINOR)) {
printf("DPRC version mismatch found %u.%u,",
major_ver, minor_ver);
printf("supported version is %u.%u\n",
DPRC_VER_MAJOR, DPRC_VER_MINOR);
}
return error;
}
@ -878,6 +882,7 @@ static int dpio_init(void)
struct dpio_attr attr;
struct dpio_cfg dpio_cfg;
int err = 0;
uint16_t major_ver, minor_ver;
dflt_dpio = (struct fsl_dpio_obj *)calloc(
sizeof(struct fsl_dpio_obj), 1);
@ -886,18 +891,44 @@ static int dpio_init(void)
err = -ENOMEM;
goto err_calloc;
}
dpio_cfg.channel_mode = DPIO_LOCAL_CHANNEL;
dpio_cfg.num_priorities = 8;
err = dpio_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpio_cfg,
&dflt_dpio->dpio_handle);
err = dpio_create(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
&dpio_cfg,
&dflt_dpio->dpio_id);
if (err < 0) {
printf("dpio_create() failed: %d\n", err);
err = -ENODEV;
goto err_create;
}
err = dpio_get_api_version(dflt_mc_io, 0,
&major_ver,
&minor_ver);
if (err < 0) {
printf("dpio_get_api_version() failed: %d\n", err);
goto err_get_api_ver;
}
if (major_ver < DPIO_VER_MAJOR || (major_ver == DPIO_VER_MAJOR &&
minor_ver < DPIO_VER_MINOR)) {
printf("DPRC version mismatch found %u.%u,",
major_ver,
minor_ver);
}
err = dpio_open(dflt_mc_io,
MC_CMD_NO_FLAGS,
dflt_dpio->dpio_id,
&dflt_dpio->dpio_handle);
if (err) {
printf("dpio_open() failed\n");
goto err_open;
}
memset(&attr, 0, sizeof(struct dpio_attr));
err = dpio_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpio->dpio_handle, &attr);
@ -906,15 +937,11 @@ static int dpio_init(void)
goto err_get_attr;
}
if ((attr.version.major != DPIO_VER_MAJOR) ||
(attr.version.minor != DPIO_VER_MINOR)) {
printf("DPIO version mismatch found %u.%u,",
attr.version.major, attr.version.minor);
printf("supported version is %u.%u\n",
DPIO_VER_MAJOR, DPIO_VER_MINOR);
if (dflt_dpio->dpio_id != attr.id) {
printf("dnpi object id and attribute id are not same\n");
goto err_attr_not_same;
}
dflt_dpio->dpio_id = attr.id;
#ifdef DEBUG
printf("Init: DPIO id=0x%d\n", dflt_dpio->dpio_id);
#endif
@ -945,8 +972,14 @@ err_get_swp_init:
dpio_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
err_get_enable:
err_get_attr:
err_attr_not_same:
dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
dpio_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
err_open:
err_get_api_ver:
dpio_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
dflt_dpio->dpio_id);
err_create:
free(dflt_dpio);
err_calloc:
@ -963,7 +996,16 @@ static int dpio_exit(void)
goto err;
}
err = dpio_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
dpio_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpio->dpio_handle);
if (err < 0) {
printf("dpio_close() failed: %d\n", err);
goto err;
}
err = dpio_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
dflt_dpio->dpio_id);
if (err < 0) {
printf("dpio_destroy() failed: %d\n", err);
goto err;
@ -1040,6 +1082,7 @@ static int dprc_init(void)
child_portal_id = MC_PORTAL_OFFSET_TO_PORTAL_ID(mc_portal_offset);
dflt_mc_io->mmio_regs = SOC_MC_PORTAL_ADDR(child_portal_id);
#ifdef DEBUG
printf("MC portal of child DPRC container: %d, physical addr %p)\n",
child_dprc_id, dflt_mc_io->mmio_regs);
@ -1110,6 +1153,7 @@ static int dpbp_init(void)
int err;
struct dpbp_attr dpbp_attr;
struct dpbp_cfg dpbp_cfg;
uint16_t major_ver, minor_ver;
dflt_dpbp = (struct fsl_dpbp_obj *)calloc(
sizeof(struct fsl_dpbp_obj), 1);
@ -1121,8 +1165,11 @@ static int dpbp_init(void)
dpbp_cfg.options = 512;
err = dpbp_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpbp_cfg,
&dflt_dpbp->dpbp_handle);
err = dpbp_create(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
&dpbp_cfg,
&dflt_dpbp->dpbp_id);
if (err < 0) {
err = -ENODEV;
@ -1130,6 +1177,31 @@ static int dpbp_init(void)
goto err_create;
}
err = dpbp_get_api_version(dflt_mc_io, 0,
&major_ver,
&minor_ver);
if (err < 0) {
printf("dpbp_get_api_version() failed: %d\n", err);
goto err_get_api_ver;
}
if (major_ver < DPBP_VER_MAJOR || (major_ver == DPBP_VER_MAJOR &&
minor_ver < DPBP_VER_MINOR)) {
printf("DPBP version mismatch found %u.%u,",
major_ver, minor_ver);
printf("supported version is %u.%u\n",
DPBP_VER_MAJOR, DPBP_VER_MINOR);
}
err = dpbp_open(dflt_mc_io,
MC_CMD_NO_FLAGS,
dflt_dpbp->dpbp_id,
&dflt_dpbp->dpbp_handle);
if (err) {
printf("dpbp_open() failed\n");
goto err_open;
}
memset(&dpbp_attr, 0, sizeof(struct dpbp_attr));
err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpbp->dpbp_handle,
@ -1139,17 +1211,13 @@ static int dpbp_init(void)
goto err_get_attr;
}
if ((dpbp_attr.version.major != DPBP_VER_MAJOR) ||
(dpbp_attr.version.minor != DPBP_VER_MINOR)) {
printf("DPBP version mismatch found %u.%u,",
dpbp_attr.version.major, dpbp_attr.version.minor);
printf("supported version is %u.%u\n",
DPBP_VER_MAJOR, DPBP_VER_MINOR);
if (dflt_dpbp->dpbp_id != dpbp_attr.id) {
printf("dpbp object id and attribute id are not same\n");
goto err_attr_not_same;
}
dflt_dpbp->dpbp_attr.id = dpbp_attr.id;
#ifdef DEBUG
printf("Init: DPBP id=0x%d\n", dflt_dpbp->dpbp_attr.id);
printf("Init: DPBP id=0x%x\n", dflt_dpbp->dpbp_attr.id);
#endif
err = dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
@ -1160,12 +1228,18 @@ static int dpbp_init(void)
return 0;
err_close:
free(dflt_dpbp);
err_get_attr:
err_attr_not_same:
dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
dpbp_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
dpbp_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
dflt_dpbp->dpbp_id);
err_get_api_ver:
err_close:
err_open:
err_create:
free(dflt_dpbp);
err_calloc:
return err;
}
@ -1174,15 +1248,8 @@ static int dpbp_exit(void)
{
int err;
err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
&dflt_dpbp->dpbp_handle);
if (err < 0) {
printf("dpbp_open() failed: %d\n", err);
goto err;
}
err = dpbp_destroy(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpbp->dpbp_handle);
err = dpbp_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
dflt_dpbp->dpbp_id);
if (err < 0) {
printf("dpbp_destroy() failed: %d\n", err);
goto err;
@ -1203,10 +1270,9 @@ err:
static int dpni_init(void)
{
int err;
struct dpni_attr dpni_attr;
uint8_t ext_cfg_buf[256] = {0};
struct dpni_extended_cfg dpni_extended_cfg;
uint8_t cfg_buf[256] = {0};
struct dpni_cfg dpni_cfg;
uint16_t major_ver, minor_ver;
dflt_dpni = (struct fsl_dpni_obj *)calloc(
sizeof(struct fsl_dpni_obj), 1);
@ -1216,50 +1282,53 @@ static int dpni_init(void)
goto err_calloc;
}
memset(&dpni_extended_cfg, 0, sizeof(dpni_extended_cfg));
err = dpni_prepare_extended_cfg(&dpni_extended_cfg, &ext_cfg_buf[0]);
memset(&dpni_cfg, 0, sizeof(dpni_cfg));
err = dpni_prepare_cfg(&dpni_cfg, &cfg_buf[0]);
if (err < 0) {
err = -ENODEV;
printf("dpni_prepare_extended_cfg() failed: %d\n", err);
goto err_prepare_extended_cfg;
printf("dpni_prepare_cfg() failed: %d\n", err);
goto err_prepare_cfg;
}
memset(&dpni_cfg, 0, sizeof(dpni_cfg));
dpni_cfg.adv.options = DPNI_OPT_UNICAST_FILTER |
DPNI_OPT_MULTICAST_FILTER;
dpni_cfg.adv.ext_cfg_iova = (uint64_t)&ext_cfg_buf[0];
err = dpni_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpni_cfg,
&dflt_dpni->dpni_handle);
err = dpni_create(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
&dpni_cfg,
&dflt_dpni->dpni_id);
if (err < 0) {
err = -ENODEV;
printf("dpni_create() failed: %d\n", err);
printf("dpni create() failed: %d\n", err);
goto err_create;
}
memset(&dpni_attr, 0, sizeof(struct dpni_attr));
err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dpni_attr);
err = dpni_get_api_version(dflt_mc_io, 0,
&major_ver,
&minor_ver);
if (err < 0) {
printf("dpni_get_attributes() failed: %d\n", err);
goto err_get_attr;
printf("dpni_get_api_version() failed: %d\n", err);
goto err_get_version;
}
if ((dpni_attr.version.major != DPNI_VER_MAJOR) ||
(dpni_attr.version.minor != DPNI_VER_MINOR)) {
if (major_ver < DPNI_VER_MAJOR || (major_ver == DPNI_VER_MAJOR &&
minor_ver < DPNI_VER_MINOR)) {
printf("DPNI version mismatch found %u.%u,",
dpni_attr.version.major, dpni_attr.version.minor);
major_ver, minor_ver);
printf("supported version is %u.%u\n",
DPNI_VER_MAJOR, DPNI_VER_MINOR);
}
dflt_dpni->dpni_id = dpni_attr.id;
err = dpni_open(dflt_mc_io,
MC_CMD_NO_FLAGS,
dflt_dpni->dpni_id,
&dflt_dpni->dpni_handle);
if (err) {
printf("dpni_open() failed\n");
goto err_open;
}
#ifdef DEBUG
printf("Init: DPNI id=0x%d\n", dflt_dpni->dpni_id);
#endif
err = dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
if (err < 0) {
printf("dpni_close() failed: %d\n", err);
@ -1269,11 +1338,15 @@ static int dpni_init(void)
return 0;
err_close:
err_get_attr:
dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
dpni_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
err_open:
err_get_version:
dpni_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
dflt_dpni->dpni_id);
err_create:
err_prepare_extended_cfg:
err_prepare_cfg:
free(dflt_dpni);
err_calloc:
return err;
@ -1283,15 +1356,8 @@ static int dpni_exit(void)
{
int err;
err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
&dflt_dpni->dpni_handle);
if (err < 0) {
printf("dpni_open() failed: %d\n", err);
goto err;
}
err = dpni_destroy(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle);
err = dpni_destroy(dflt_mc_io, dflt_dprc_handle, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_id);
if (err < 0) {
printf("dpni_destroy() failed: %d\n", err);
goto err;
@ -1370,12 +1436,13 @@ int fsl_mc_ldpaa_exit(bd_t *bd)
*/
if (bd && mc_boot_status && !is_dpl_apply_status) {
printf("fsl-mc: DPL not deployed, DPAA2 ethernet not work\n");
return 0;
goto mc_obj_cleanup;
}
if (bd && mc_boot_status && is_dpl_apply_status)
return 0;
mc_obj_cleanup:
err = dpbp_exit();
if (err < 0) {
printf("dpbp_exit() failed: %d\n", err);
@ -1420,6 +1487,7 @@ static int do_fsl_mc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
#endif
sub_cmd = argv[2][0];
switch (sub_cmd) {
case 'm':
if (argc < 5)

@ -1,5 +1,6 @@
/*
* Copyright (C) 2014 Freescale Semiconductor
* Copyright (C) 2014-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -42,80 +43,67 @@ static int init_phy(struct eth_device *dev)
#endif
#ifdef DEBUG
static void ldpaa_eth_get_dpni_counter(void)
{
int err = 0;
u64 value;
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_ING_FRAME,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_ING_FRAME failed\n");
return;
}
printf("DPNI_CNT_ING_FRAME=%lld\n", value);
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_ING_BYTE,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_ING_BYTE failed\n");
return;
}
printf("DPNI_CNT_ING_BYTE=%lld\n", value);
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_ING_FRAME_DROP ,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DROP failed\n");
return;
}
printf("DPNI_CNT_ING_FRAME_DROP =%lld\n", value);
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_ING_FRAME_DISCARD,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DISCARD failed\n");
return;
}
printf("DPNI_CNT_ING_FRAME_DISCARD=%lld\n", value);
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_EGR_FRAME,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_EGR_FRAME failed\n");
return;
}
printf("DPNI_CNT_EGR_FRAME=%lld\n", value);
#define DPNI_STATS_PER_PAGE 6
static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = {
{
"DPNI_CNT_ING_ALL_FRAMES",
"DPNI_CNT_ING_ALL_BYTES",
"DPNI_CNT_ING_MCAST_FRAMES",
"DPNI_CNT_ING_MCAST_BYTES",
"DPNI_CNT_ING_BCAST_FRAMES",
"DPNI_CNT_ING_BCAST_BYTES",
}, {
"DPNI_CNT_EGR_ALL_FRAMES",
"DPNI_CNT_EGR_ALL_BYTES",
"DPNI_CNT_EGR_MCAST_FRAMES",
"DPNI_CNT_EGR_MCAST_BYTES",
"DPNI_CNT_EGR_BCAST_FRAMES",
"DPNI_CNT_EGR_BCAST_BYTES",
}, {
"DPNI_CNT_ING_FILTERED_FRAMES",
"DPNI_CNT_ING_DISCARDED_FRAMES",
"DPNI_CNT_ING_NOBUFFER_DISCARDS",
"DPNI_CNT_EGR_DISCARDED_FRAMES",
"DPNI_CNT_EGR_CNF_FRAMES",
""
},
};
static void print_dpni_stats(const char *strings[],
struct dpni_statistics dpni_stats)
{
uint64_t *stat;
int i;
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_EGR_BYTE ,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_EGR_BYTE failed\n");
return;
stat = (uint64_t *)&dpni_stats;
for (i = 0; i < DPNI_STATS_PER_PAGE; i++) {
if (strcmp(strings[i], "\0") == 0)
break;
printf("%s= %llu\n", strings[i], *stat);
stat++;
}
printf("DPNI_CNT_EGR_BYTE =%lld\n", value);
}
err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CNT_EGR_FRAME_DISCARD ,
&value);
if (err < 0) {
printf("dpni_get_counter: DPNI_CNT_EGR_FRAME_DISCARD failed\n");
return;
static void ldpaa_eth_get_dpni_counter(void)
{
int err = 0;
unsigned int page = 0;
struct dpni_statistics dpni_stats;
printf("DPNI counters ..\n");
for (page = 0; page < 3; page++) {
err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, page,
&dpni_stats);
if (err < 0) {
printf("dpni_get_statistics: failed:");
printf("%d for page[%d]\n", err, page);
return;
}
print_dpni_stats(dpni_statistics[page], dpni_stats);
}
printf("DPNI_CNT_EGR_FRAME_DISCARD =%lld\n", value);
}
static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
@ -132,6 +120,7 @@ static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
return;
}
printf("\nDPMAC counters ..\n");
printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
@ -392,7 +381,6 @@ error:
static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
{
struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
struct dpni_queue_attr rx_queue_attr;
struct dpmac_link_state dpmac_link_state = { 0 };
#ifdef DEBUG
struct dpni_link_state link_state;
@ -400,6 +388,7 @@ static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
int err = 0;
struct mii_dev *bus;
phy_interface_t enet_if;
struct dpni_queue d_queue;
if (net_dev->state == ETH_STATE_ACTIVE)
return 0;
@ -508,6 +497,10 @@ static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
}
#ifdef DEBUG
printf("DPMAC link status: %d - ", dpmac_link_state.up);
dpmac_link_state.up == 0 ? printf("down\n") :
dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n");
err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, &link_state);
if (err < 0) {
@ -515,20 +508,21 @@ static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
return err;
}
printf("link status: %d - ", link_state.up);
printf("DPNI link status: %d - ", link_state.up);
link_state.up == 0 ? printf("down\n") :
link_state.up == 1 ? printf("up\n") : printf("error state\n");
#endif
/* TODO: support multiple Rx flows */
err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
memset(&d_queue, 0, sizeof(struct dpni_queue));
err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
0, 0, &d_queue);
if (err) {
printf("dpni_get_rx_flow() failed\n");
goto err_rx_flow;
printf("dpni_get_queue failed\n");
goto err_get_queue;
}
priv->rx_dflt_fqid = rx_queue_attr.fqid;
priv->rx_dflt_fqid = d_queue.fqid;
err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
&priv->tx_qdid);
@ -540,7 +534,7 @@ static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
return priv->phydev->link;
err_qdid:
err_rx_flow:
err_get_queue:
dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
err_dpni_bind:
ldpaa_dpbp_free();
@ -548,7 +542,10 @@ err_dpbp_setup:
dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
err_dpni_setup:
err_dpamc_bind:
dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
dpmac_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS, priv->dpmac_id);
err_dpmac_setup:
return err;
}
@ -575,7 +572,14 @@ static void ldpaa_eth_stop(struct eth_device *net_dev)
if (err < 0)
printf("dprc_disconnect() failed dpmac_endpoint\n");
err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
if (err < 0)
printf("dpmac_close() failed\n");
err = dpmac_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS,
priv->dpmac_id);
if (err < 0)
printf("dpmac_destroy() failed\n");
@ -593,9 +597,16 @@ static void ldpaa_eth_stop(struct eth_device *net_dev)
}
#endif
/* Free DPBP handle and reset. */
ldpaa_dpbp_free();
dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
if (err < 0)
printf("dpni_reset() failed\n");
dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
if (err < 0)
printf("dpni_close() failed\n");
}
static void ldpaa_dpbp_drain_cnt(int count)
@ -711,6 +722,7 @@ static int ldpaa_dpbp_setup(void)
}
err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
if (err) {
printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
@ -739,21 +751,19 @@ static void ldpaa_dpbp_free(void)
static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
struct ldpaa_eth_priv *priv)
{
struct dpmac_attr attr;
int error;
memset(&attr, 0, sizeof(struct dpmac_attr));
error = dpmac_get_attributes(mc_io, MC_CMD_NO_FLAGS,
priv->dpmac_handle,
&attr);
if (error == 0) {
if ((attr.version.major != DPMAC_VER_MAJOR) ||
(attr.version.minor != DPMAC_VER_MINOR)) {
printf("DPMAC version mismatch found %u.%u,",
attr.version.major, attr.version.minor);
printf("supported version is %u.%u\n",
DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
}
uint16_t major_ver, minor_ver;
error = dpmac_get_api_version(dflt_mc_io, 0,
&major_ver,
&minor_ver);
if ((major_ver < DPMAC_VER_MAJOR) ||
(major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) {
printf("DPMAC version mismatch found %u.%u,",
major_ver, minor_ver);
printf("supported version is %u.%u\n",
DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
return error;
}
return error;
@ -765,14 +775,36 @@ static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
struct dpmac_cfg dpmac_cfg;
dpmac_cfg.mac_id = priv->dpmac_id;
err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
&priv->dpmac_handle);
err = dpmac_create(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS, &dpmac_cfg,
&priv->dpmac_id);
if (err)
printf("dpmac_create() failed\n");
err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
if (err < 0)
if (err < 0) {
printf("ldpaa_dpmac_version_check() failed: %d\n", err);
goto err_version_check;
}
err = dpmac_open(dflt_mc_io,
MC_CMD_NO_FLAGS,
priv->dpmac_id,
&priv->dpmac_handle);
if (err < 0) {
printf("dpmac_open() failed: %d\n", err);
goto err_open;
}
return err;
err_open:
err_version_check:
dpmac_destroy(dflt_mc_io,
dflt_dprc_handle,
MC_CMD_NO_FLAGS, priv->dpmac_id);
return err;
}
@ -838,7 +870,6 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
printf("dpni_open() failed\n");
goto err_open;
}
err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->dpni_attrs);
@ -857,12 +888,13 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
/* HW erratum mandates data alignment in multiples of 256 */
dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
/* ...rx, ... */
err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout);
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout, DPNI_QUEUE_RX);
if (err) {
printf("dpni_set_rx_buffer_layout() failed");
printf("dpni_set_buffer_layout() failed");
goto err_buf_layout;
}
@ -870,21 +902,22 @@ static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
/* remove Rx-only options */
dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout);
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout, DPNI_QUEUE_TX);
if (err) {
printf("dpni_set_tx_buffer_layout() failed");
printf("dpni_set_buffer_layout() failed");
goto err_buf_layout;
}
/* ... tx-confirm. */
dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout);
err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
&dflt_dpni->buf_layout,
DPNI_QUEUE_TX_CONFIRM);
if (err) {
printf("dpni_set_tx_conf_buffer_layout() failed");
printf("dpni_set_buffer_layout() failed");
goto err_buf_layout;
}
@ -919,8 +952,7 @@ err_open:
static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
{
struct dpni_pools_cfg pools_params;
struct dpni_tx_flow_cfg dflt_tx_flow;
struct dpni_tx_conf_cfg tx_conf_cfg;
struct dpni_queue tx_queue;
int err = 0;
memset(&pools_params, 0, sizeof(pools_params));
@ -934,26 +966,22 @@ static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
return err;
}
priv->tx_flow_id = DPNI_NEW_FLOW_ID;
memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
memset(&tx_queue, 0, sizeof(struct dpni_queue));
err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_QUEUE_TX, 0, 0, &tx_queue);
dflt_tx_flow.use_common_tx_conf_queue = 0;
err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle, &priv->tx_flow_id,
&dflt_tx_flow);
if (err) {
printf("dpni_set_tx_flow() failed\n");
printf("dpni_set_queue() failed\n");
return err;
}
memset(&tx_conf_cfg, 0, sizeof(struct dpni_tx_conf_cfg));
tx_conf_cfg.errors_only = true;
/*Set tx-conf and error configuration*/
err = dpni_set_tx_conf(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
priv->tx_flow_id, &tx_conf_cfg);
err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
dflt_dpni->dpni_handle,
DPNI_CONF_DISABLE);
if (err) {
printf("dpni_set_tx_conf() failed\n");
printf("dpni_set_tx_confirmation_mode() failed\n");
return err;
}
@ -996,7 +1024,6 @@ int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
struct ldpaa_eth_priv *priv = NULL;
int err = 0;
/* Net device */
net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
if (!net_dev) {

@ -1,5 +1,6 @@
/*
* Copyright (C) 2014 Freescale Semiconductor
* Copyright (C) 2014-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -117,7 +118,7 @@ struct ldpaa_fas {
struct ldpaa_eth_priv {
struct eth_device *net_dev;
int dpmac_id;
uint32_t dpmac_id;
uint16_t dpmac_handle;
uint16_t tx_data_offset;

@ -65,7 +65,7 @@
#define CONFIG_ENV_OVERWRITE
#define CONFIG_ENV_SIZE 0x40000 /* 256KB */
#define CONFIG_ENV_OFFSET 0x200000 /* 2MB */
#define CONFIG_ENV_OFFSET 0x300000 /* 3MB */
#define CONFIG_ENV_SECT_SIZE 0x40000
#endif
@ -94,7 +94,7 @@
"kernel_addr=0x100000\0" \
"fdt_high=0xffffffffffffffff\0" \
"initrd_high=0xffffffffffffffff\0" \
"kernel_start=0xa00000\0" \
"kernel_start=0x1000000\0" \
"kernel_load=0xa0000000\0" \
"kernel_size=0x2800000\0" \

@ -27,7 +27,7 @@
"kernel_addr=0x100000\0" \
"fdt_high=0xffffffffffffffff\0" \
"initrd_high=0xffffffffffffffff\0" \
"kernel_start=0xa00000\0" \
"kernel_start=0x1000000\0" \
"kernel_load=0x96000000\0" \
"kernel_size=0x2800000\0"

@ -420,16 +420,22 @@
"initrd_high=0xffffffff\0" \
"fdt_high=0xffffffff\0" \
"fdt_addr=0x64f00000\0" \
"kernel_addr=0x65000000\0" \
"kernel_addr=0x61000000\0" \
"kernelheader_addr=0x60800000\0" \
"scriptaddr=0x80000000\0" \
"scripthdraddr=0x80080000\0" \
"fdtheader_addr_r=0x80100000\0" \
"kernelheader_addr_r=0x80200000\0" \
"kernel_addr_r=0x81000000\0" \
"kernelheader_size=0x40000\0" \
"fdt_addr_r=0x90000000\0" \
"ramdisk_addr_r=0xa0000000\0" \
"load_addr=0xa0000000\0" \
"kernel_size=0x2800000\0" \
"kernel_addr_sd=0x8000\0" \
"kernel_size_sd=0x14000\0" \
"kernelhdr_addr_sd=0x4000\0" \
"kernelhdr_size_sd=0x10\0" \
BOOTENV \
"boot_scripts=ls1021atwr_boot.scr\0" \
"boot_script_hdr=hdr_ls1021atwr_bs.out\0" \
@ -460,26 +466,35 @@
"source ${scriptaddr}\0" \
"qspi_bootcmd=echo Trying load from qspi..;" \
"sf probe && sf read $load_addr " \
"$kernel_addr $kernel_size && bootm $load_addr#$board\0" \
"$kernel_addr $kernel_size; env exists secureboot " \
"&& sf read $kernelheader_addr_r $kernelheader_addr " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; " \
"bootm $load_addr#$board\0" \
"nor_bootcmd=echo Trying load from nor..;" \
"cp.b $kernel_addr $load_addr " \
"$kernel_size && bootm $load_addr#$board\0" \
"$kernel_size; env exists secureboot " \
"&& cp.b $kernelheader_addr $kernelheader_addr_r " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; " \
"bootm $load_addr#$board\0" \
"sd_bootcmd=echo Trying load from SD ..;" \
"mmcinfo && mmc read $load_addr " \
"$kernel_addr_sd $kernel_size_sd && " \
"env exists secureboot && mmc read $kernelheader_addr_r " \
"$kernelhdr_addr_sd $kernelhdr_size_sd " \
" && esbc_validate ${kernelheader_addr_r};" \
"bootm $load_addr#$board\0"
#endif
#undef CONFIG_BOOTCOMMAND
#if defined(CONFIG_QSPI_BOOT) || defined(CONFIG_SD_BOOT_QSPI)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run qspi_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run qspi_bootcmd" \
"env exists secureboot && esbc_halt"
#elif defined(CONFIG_SD_BOOT)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run sd_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run sd_bootcmd; " \
"env exists secureboot && esbc_halt;"
#else
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run nor_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run nor_bootcmd;" \
"env exists secureboot && esbc_halt;"
#endif
/*

@ -252,7 +252,7 @@
"fdt_high=0xffffffffffffffff\0" \
"initrd_high=0xffffffffffffffff\0" \
"fdt_addr=0x64f00000\0" \
"kernel_addr=0x65000000\0" \
"kernel_addr=0x61000000\0" \
"scriptaddr=0x80000000\0" \
"scripthdraddr=0x80080000\0" \
"fdtheader_addr_r=0x80100000\0" \
@ -260,9 +260,13 @@
"kernel_addr_r=0x81000000\0" \
"fdt_addr_r=0x90000000\0" \
"load_addr=0xa0000000\0" \
"kernelheader_addr=0x60800000\0" \
"kernel_size=0x2800000\0" \
"kernelheader_size=0x40000\0" \
"kernel_addr_sd=0x8000\0" \
"kernel_size_sd=0x14000\0" \
"kernelhdr_addr_sd=0x4000\0" \
"kernelhdr_size_sd=0x10\0" \
"console=ttyS0,115200\0" \
"boot_os=y\0" \
"mtdparts=" CONFIG_MTDPARTS_DEFAULT "\0" \
@ -295,26 +299,35 @@
"source ${scriptaddr}\0" \
"qspi_bootcmd=echo Trying load from qspi..;" \
"sf probe && sf read $load_addr " \
"$kernel_addr $kernel_size && bootm $load_addr#$board\0" \
"$kernel_addr $kernel_size; env exists secureboot " \
"&& sf read $kernelheader_addr_r $kernelheader_addr " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; " \
"bootm $load_addr#$board\0" \
"nor_bootcmd=echo Trying load from nor..;" \
"cp.b $kernel_addr $load_addr " \
"$kernel_size && bootm $load_addr#$board\0" \
"$kernel_size; env exists secureboot " \
"&& cp.b $kernelheader_addr $kernelheader_addr_r " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; " \
"bootm $load_addr#$board\0" \
"sd_bootcmd=echo Trying load from SD ..;" \
"mmcinfo; mmc read $load_addr " \
"$kernel_addr_sd $kernel_size_sd && " \
"env exists secureboot && mmc read $kernelheader_addr_r " \
"$kernelhdr_addr_sd $kernelhdr_size_sd " \
" && esbc_validate ${kernelheader_addr_r};" \
"bootm $load_addr#$board\0"
#undef CONFIG_BOOTCOMMAND
#if defined(CONFIG_QSPI_BOOT) || defined(CONFIG_SD_BOOT_QSPI)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run qspi_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run qspi_bootcmd; " \
"env exists secureboot && esbc_halt;"
#elif defined(CONFIG_SD_BOOT)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run sd_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run sd_bootcmd; " \
"env exists secureboot && esbc_halt;"
#else
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run nor_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run nor_bootcmd; " \
"env exists secureboot && esbc_halt;"
#endif
#endif

@ -225,10 +225,14 @@
"fdt_addr_r=0x90000000\0" \
"ramdisk_addr_r=0xa0000000\0" \
"kernel_start=0x1000000\0" \
"kernelheader_start=0x800000\0" \
"kernel_load=0xa0000000\0" \
"kernel_size=0x2800000\0" \
"kernelheader_size=0x40000\0" \
"kernel_addr_sd=0x8000\0" \
"kernel_size_sd=0x14000\0" \
"kernelhdr_addr_sd=0x4000\0" \
"kernelhdr_size_sd=0x10\0" \
"console=ttyS0,115200\0" \
CONFIG_MTDPARTS_DEFAULT "\0" \
BOOTENV \
@ -261,10 +265,16 @@
"source ${scriptaddr}\0" \
"qspi_bootcmd=echo Trying load from qspi..;" \
"sf probe && sf read $load_addr " \
"$kernel_start $kernel_size && bootm $load_addr#$board\0" \
"$kernel_start $kernel_size; env exists secureboot " \
"&& sf read $kernelheader_addr_r $kernelheader_start " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; " \
"bootm $load_addr#$board\0" \
"sd_bootcmd=echo Trying load from SD ..;" \
"mmcinfo; mmc read $load_addr " \
"$kernel_addr_sd $kernel_size_sd && " \
"env exists secureboot && mmc read $kernelheader_addr_r " \
"$kernelhdr_addr_sd $kernelhdr_size_sd " \
" && esbc_validate ${kernelheader_addr_r};" \
"bootm $load_addr#$board\0"
#endif

@ -226,11 +226,11 @@
#ifndef SPL_NO_MISC
#undef CONFIG_BOOTCOMMAND
#if defined(CONFIG_QSPI_BOOT)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run qspi_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; run qspi_bootcmd; " \
"env exists secureboot && esbc_halt;;"
#elif defined(CONFIG_SD_BOOT)
#define CONFIG_BOOTCOMMAND "run distro_bootcmd; env exists secureboot" \
"&& esbc_halt; run sd_bootcmd;"
#define CONFIG_BOOTCOMMAND "run distro_bootcmd;run sd_bootcmd; " \
"env exists secureboot && esbc_halt;"
#endif
#endif

@ -144,9 +144,6 @@ unsigned long long get_qixis_addr(void);
#if defined(CONFIG_FSL_MC_ENET)
#define CONFIG_SYS_LS_MC_DRAM_BLOCK_MIN_SIZE (512UL * 1024 * 1024)
#endif
#define CONFIG_FSL_CAAM /* Enable SEC/CAAM */
/* Command line configuration */
#define CONFIG_CMD_GREPENV
#define CONFIG_CMD_CACHE

@ -335,6 +335,26 @@ unsigned long get_board_ddr_clk(void);
QIXIS_SDID_MASK) != QIXIS_ESDHC_NO_ADAPTER)
/* Initial environment variables */
#ifdef CONFIG_SECURE_BOOT
#undef CONFIG_EXTRA_ENV_SETTINGS
#define CONFIG_EXTRA_ENV_SETTINGS \
"hwconfig=fsl_ddr:bank_intlv=auto\0" \
"loadaddr=0x90100000\0" \
"kernel_addr=0x100000\0" \
"ramdisk_addr=0x800000\0" \
"ramdisk_size=0x2000000\0" \
"fdt_high=0xa0000000\0" \
"initrd_high=0xffffffffffffffff\0" \
"kernel_start=0x1000000\0" \
"kernel_load=0xa0000000\0" \
"kernel_size=0x2800000\0" \
"mcinitcmd=sf probe 0:0;sf read 0xa0a00000 0xa00000 0x100000;" \
"sf read 0xa0700000 0x700000 0x4000; esbc_validate 0xa0700000;" \
"sf read 0xa0e00000 0xe00000 0x100000;" \
"sf read 0xa0740000 0x740000 0x4000;esbc_validate 0xa0740000;" \
"fsl_mc start mc 0xa0a00000 0xa0e00000\0" \
"mcmemsize=0x70000000 \0"
#else /* if !(CONFIG_SECURE_BOOT) */
#if defined(CONFIG_QSPI_BOOT)
#undef CONFIG_EXTRA_ENV_SETTINGS
#define CONFIG_EXTRA_ENV_SETTINGS \
@ -385,6 +405,7 @@ unsigned long get_board_ddr_clk(void);
"mcinitcmd=fsl_mc start mc 0x580A00000 0x580E00000\0" \
"mcmemsize=0x70000000 \0"
#endif
#endif /* CONFIG_SECURE_BOOT */
#ifdef CONFIG_FSL_MC_ENET
#define CONFIG_FSL_MEMAC

@ -95,6 +95,7 @@
#define CONFIG_SYS_FLASH_BANKS_LIST { CONFIG_SYS_FLASH_BASE }
#endif
#endif
#define CONFIG_NAND_FSL_IFC
#define CONFIG_SYS_NAND_MAX_ECCPOS 256
#define CONFIG_SYS_NAND_MAX_OOBFREE 2
@ -132,6 +133,7 @@
#define CONFIG_SYS_NAND_BASE_LIST { CONFIG_SYS_NAND_BASE }
#define CONFIG_SYS_MAX_NAND_DEVICE 1
#define CONFIG_MTD_NAND_VERIFY_WRITE
#define CONFIG_CMD_NAND
#define CONFIG_SYS_NAND_BLOCK_SIZE (128 * 1024)
@ -261,13 +263,23 @@
#define MC_INIT_CMD \
"mcinitcmd=sf probe 0:0;sf read 0x80000000 0xA00000 0x100000;" \
"sf read 0x80100000 0xE00000 0x100000;" \
"fsl_mc start mc 0x80000000 0x80100000\0" \
"env exists secureboot && " \
"sf read 0x80700000 0x700000 0x40000 && " \
"sf read 0x80740000 0x740000 0x40000 && " \
"esbc_validate 0x80700000 && " \
"esbc_validate 0x80740000 ;" \
"fsl_mc start mc 0x80000000 0x80100000\0" \
"mcmemsize=0x70000000\0"
#elif defined(CONFIG_SD_BOOT)
#define MC_INIT_CMD \
"mcinitcmd=mmcinfo;mmc read 0x80000000 0x5000 0x800;" \
"mmc read 0x80100000 0x7000 0x800;" \
"fsl_mc start mc 0x80000000 0x80100000\0" \
"env exists secureboot && " \
"mmc read 0x80700000 0x3800 0x10 && " \
"mmc read 0x80740000 0x3A00 0x10 && " \
"esbc_validate 0x80700000 && " \
"esbc_validate 0x80740000 ;" \
"fsl_mc start mc 0x80000000 0x80100000\0" \
"mcmemsize=0x70000000\0"
#endif
@ -282,6 +294,7 @@
"fdt_addr=0x64f00000\0" \
"kernel_addr=0x1000000\0" \
"kernel_addr_sd=0x8000\0" \
"kernelhdr_addr_sd=0x4000\0" \
"kernel_start=0x580100000\0" \
"kernelheader_start=0x580800000\0" \
"scriptaddr=0x80000000\0" \
@ -295,6 +308,7 @@
"load_addr=0xa0000000\0" \
"kernel_size=0x2800000\0" \
"kernel_size_sd=0x14000\0" \
"kernelhdr_size_sd=0x10\0" \
MC_INIT_CMD \
BOOTENV \
"boot_scripts=ls1088ardb_boot.scr\0" \
@ -331,29 +345,41 @@
"bootm $load_addr#ls1088ardb\0" \
"qspi_bootcmd=echo Trying load from qspi..;" \
"sf probe && sf read $load_addr " \
"$kernel_addr $kernel_size &&" \
"$kernel_addr $kernel_size ; env exists secureboot " \
"&& sf read $kernelheader_addr_r $kernelheader_addr " \
"$kernelheader_size && esbc_validate ${kernelheader_addr_r}; "\
"bootm $load_addr#$BOARD\0" \
"sd_bootcmd=echo Trying load from sd card..;" \
"sd_bootcmd=echo Trying load from sd card..;" \
"mmcinfo; mmc read $load_addr " \
"$kernel_addr_sd $kernel_size_sd ;" \
"env exists secureboot && mmc read $kernelheader_addr_r "\
"$kernelhdr_addr_sd $kernelhdr_size_sd " \
" && esbc_validate ${kernelheader_addr_r};" \
"bootm $load_addr#$BOARD\0"
#undef CONFIG_BOOTCOMMAND
#if defined(CONFIG_QSPI_BOOT)
/* Try to boot an on-QSPI kernel first, then do normal distro boot */
#define CONFIG_BOOTCOMMAND \
"env exists mcinitcmd && run mcinitcmd && " \
"sf read 0x80200000 0xd00000 0x100000;" \
" fsl_mc apply dpl 0x80200000;" \
"run distro_bootcmd;run qspi_bootcmd"
"sf read 0x80200000 0xd00000 0x100000;" \
"env exists mcinitcmd && env exists secureboot " \
" && sf read 0x80780000 0x780000 0x100000 " \
"&& esbc_validate 0x80780000;env exists mcinitcmd " \
"&& fsl_mc apply dpl 0x80200000;" \
"run distro_bootcmd;run qspi_bootcmd;" \
"env exists secureboot && esbc_halt;"
/* Try to boot an on-SD kernel first, then do normal distro boot */
#elif defined(CONFIG_SD_BOOT)
#define CONFIG_BOOTCOMMAND \
"env exists mcinitcmd && run mcinitcmd ;" \
"&& env exists mcinitcmd && mmcinfo; " \
"mmc read 0x88000000 0x6800 0x800; " \
"&& fsl_mc apply dpl 0x88000000;" \
"run distro_bootcmd;run sd_bootcmd"
"env exists mcinitcmd && mmcinfo; " \
"mmc read 0x80200000 0x6800 0x800; " \
"env exists mcinitcmd && env exists secureboot " \
" && mmc read 0x80780000 0x3800 0x10 " \
"&& esbc_validate 0x80780000;env exists mcinitcmd " \
"&& fsl_mc apply dpl 0x80200000;" \
"run distro_bootcmd;run sd_bootcmd;" \
"env exists secureboot && esbc_halt;"
#endif
/* MAC/PHY configuration */

@ -1,8 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
* Author: German Rivera <German.Rivera@freescale.com>
* Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -14,19 +14,21 @@
#define __FSL_DPBP_H
/* DPBP Version */
#define DPBP_VER_MAJOR 2
#define DPBP_VER_MINOR 2
#define DPBP_VER_MAJOR 3
#define DPBP_VER_MINOR 3
/* Command IDs */
#define DPBP_CMDID_CLOSE 0x800
#define DPBP_CMDID_OPEN 0x804
#define DPBP_CMDID_CREATE 0x904
#define DPBP_CMDID_DESTROY 0x900
#define DPBP_CMDID_ENABLE 0x002
#define DPBP_CMDID_DISABLE 0x003
#define DPBP_CMDID_GET_ATTR 0x004
#define DPBP_CMDID_RESET 0x005
#define DPBP_CMDID_CLOSE 0x8001
#define DPBP_CMDID_OPEN 0x8041
#define DPBP_CMDID_CREATE 0x9041
#define DPBP_CMDID_DESTROY 0x9841
#define DPBP_CMDID_GET_API_VERSION 0xa041
#define DPBP_CMDID_ENABLE 0x0021
#define DPBP_CMDID_DISABLE 0x0031
#define DPBP_CMDID_GET_ATTR 0x0041
#define DPBP_CMDID_RESET 0x0051
#define DPBP_CMDID_IS_ENABLED 0x0061
/* cmd, param, offset, width, type, arg_name */
#define DPBP_CMD_OPEN(cmd, dpbp_id) \
@ -37,8 +39,6 @@
do { \
MC_RSP_OP(cmd, 0, 16, 16, uint16_t, attr->bpid); \
MC_RSP_OP(cmd, 0, 32, 32, int, attr->id);\
MC_RSP_OP(cmd, 1, 0, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, attr->version.minor);\
} while (0)
/* Data Path Buffer Pool API
@ -114,9 +114,10 @@ struct dpbp_cfg {
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_create(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
const struct dpbp_cfg *cfg,
uint16_t *token);
uint32_t *obj_id);
/**
* dpbp_destroy() - Destroy the DPBP object and release all its resources.
@ -127,8 +128,9 @@ int dpbp_create(struct fsl_mc_io *mc_io,
* Return: '0' on Success; error code otherwise.
*/
int dpbp_destroy(struct fsl_mc_io *mc_io,
uint16_t dprc_token,
uint32_t cmd_flags,
uint16_t token);
uint32_t obj_id);
/**
* dpbp_enable() - Enable the DPBP.
@ -189,16 +191,7 @@ int dpbp_reset(struct fsl_mc_io *mc_io,
* acquire/release operations on buffers
*/
struct dpbp_attr {
int id;
/**
* struct version - Structure representing DPBP version
* @major: DPBP major version
* @minor: DPBP minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
uint32_t id;
uint16_t bpid;
};
@ -217,6 +210,21 @@ int dpbp_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpbp_attr *attr);
/**
* dpbp_get_api_version - Retrieve DPBP Major and Minor version info.
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @major_ver: DPBP major version
* @minor_ver: DPBP minor version
*
* Return: '0' on Success; Error code otherwise.
*/
int dpbp_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver);
/** @} */
#endif /* __FSL_DPBP_H */

@ -1,5 +1,6 @@
/*
* Copyright (C) 2013-2015 Freescale Semiconductor
* Copyright (C) 2013-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -8,19 +9,20 @@
#define _FSL_DPIO_H
/* DPIO Version */
#define DPIO_VER_MAJOR 3
#define DPIO_VER_MAJOR 4
#define DPIO_VER_MINOR 2
/* Command IDs */
#define DPIO_CMDID_CLOSE 0x800
#define DPIO_CMDID_OPEN 0x803
#define DPIO_CMDID_CREATE 0x903
#define DPIO_CMDID_DESTROY 0x900
#define DPIO_CMDID_CLOSE 0x8001
#define DPIO_CMDID_OPEN 0x8031
#define DPIO_CMDID_CREATE 0x9031
#define DPIO_CMDID_DESTROY 0x9831
#define DPIO_CMDID_GET_API_VERSION 0xa031
#define DPIO_CMDID_ENABLE 0x002
#define DPIO_CMDID_DISABLE 0x003
#define DPIO_CMDID_GET_ATTR 0x004
#define DPIO_CMDID_RESET 0x005
#define DPIO_CMDID_ENABLE 0x0021
#define DPIO_CMDID_DISABLE 0x0031
#define DPIO_CMDID_GET_ATTR 0x0041
#define DPIO_CMDID_RESET 0x0051
/* cmd, param, offset, width, type, arg_name */
#define DPIO_CMD_OPEN(cmd, dpio_id) \
@ -43,8 +45,6 @@ do { \
MC_RSP_OP(cmd, 0, 56, 4, enum dpio_channel_mode, attr->channel_mode);\
MC_RSP_OP(cmd, 1, 0, 64, uint64_t, attr->qbman_portal_ce_offset);\
MC_RSP_OP(cmd, 2, 0, 64, uint64_t, attr->qbman_portal_ci_offset);\
MC_RSP_OP(cmd, 3, 0, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 3, 16, 16, uint16_t, attr->version.minor);\
MC_RSP_OP(cmd, 3, 32, 32, uint32_t, attr->qbman_version);\
} while (0)
@ -73,7 +73,7 @@ struct fsl_mc_io;
*/
int dpio_open(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
int dpio_id,
uint32_t dpio_id,
uint16_t *token);
/**
@ -114,9 +114,10 @@ struct dpio_cfg {
/**
* dpio_create() - Create the DPIO object.
* @mc_io: Pointer to MC portal's I/O object
* @token: Authentication token.
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
* @obj_id: Returned obj_id; use in subsequent API calls
*
* Create the DPIO object, allocate required resources and
* perform required initialization.
@ -134,21 +135,24 @@ struct dpio_cfg {
* Return: '0' on Success; Error code otherwise.
*/
int dpio_create(struct fsl_mc_io *mc_io,
uint16_t token,
uint32_t cmd_flags,
const struct dpio_cfg *cfg,
uint16_t *token);
uint32_t *obj_id);
/**
* dpio_destroy() - Destroy the DPIO object and release all its resources.
* @mc_io: Pointer to MC portal's I/O object
* @token: Authentication token.
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPIO object
* @obj_id: Object ID of DPIO
*
* Return: '0' on Success; Error code otherwise
*/
int dpio_destroy(struct fsl_mc_io *mc_io,
uint16_t token,
uint32_t cmd_flags,
uint16_t token);
uint32_t obj_id);
/**
* dpio_enable() - Enable the DPIO, allow I/O portal operations.
@ -199,16 +203,7 @@ int dpio_reset(struct fsl_mc_io *mc_io,
* @qbman_version: QBMAN version
*/
struct dpio_attr {
int id;
/**
* struct version - DPIO version
* @major: DPIO major version
* @minor: DPIO minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
uint32_t id;
uint64_t qbman_portal_ce_offset;
uint64_t qbman_portal_ci_offset;
uint16_t qbman_portal_id;
@ -231,4 +226,19 @@ int dpio_get_attributes(struct fsl_mc_io *mc_io,
uint16_t token,
struct dpio_attr *attr);
/**
* dpio_get_api_version - Retrieve DPIO Major and Minor version info.
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @major_ver: DPIO major version
* @minor_ver: DPIO minor version
*
* Return: '0' on Success; Error code otherwise.
*/
int dpio_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver);
#endif /* _FSL_DPIO_H */

@ -1,7 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2015 Freescale Semiconductor, Inc.
* Copyright (C) 2015-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
* Author: Prabhakar Kushwaha <prabhakar@freescale.com>
*
* SPDX-License-Identifier: GPL-2.0+
@ -11,27 +12,28 @@
#define __FSL_DPMAC_H
/* DPMAC Version */
#define DPMAC_VER_MAJOR 3
#define DPMAC_VER_MAJOR 4
#define DPMAC_VER_MINOR 2
/* Command IDs */
#define DPMAC_CMDID_CLOSE 0x800
#define DPMAC_CMDID_OPEN 0x80c
#define DPMAC_CMDID_CREATE 0x90c
#define DPMAC_CMDID_DESTROY 0x900
#define DPMAC_CMDID_CLOSE 0x8001
#define DPMAC_CMDID_OPEN 0x80c1
#define DPMAC_CMDID_CREATE 0x90c1
#define DPMAC_CMDID_DESTROY 0x98c1
#define DPMAC_CMDID_GET_API_VERSION 0xa0c1
#define DPMAC_CMDID_GET_ATTR 0x004
#define DPMAC_CMDID_RESET 0x005
#define DPMAC_CMDID_GET_ATTR 0x0041
#define DPMAC_CMDID_RESET 0x0051
#define DPMAC_CMDID_MDIO_READ 0x0c0
#define DPMAC_CMDID_MDIO_WRITE 0x0c1
#define DPMAC_CMDID_GET_LINK_CFG 0x0c2
#define DPMAC_CMDID_SET_LINK_STATE 0x0c3
#define DPMAC_CMDID_GET_COUNTER 0x0c4
#define DPMAC_CMDID_MDIO_READ 0x0c01
#define DPMAC_CMDID_MDIO_WRITE 0x0c11
#define DPMAC_CMDID_GET_LINK_CFG 0x0c21
#define DPMAC_CMDID_SET_LINK_STATE 0x0c31
#define DPMAC_CMDID_GET_COUNTER 0x0c41
/* cmd, param, offset, width, type, arg_name */
#define DPMAC_CMD_CREATE(cmd, cfg) \
MC_CMD_OP(cmd, 0, 0, 32, int, cfg->mac_id)
MC_CMD_OP(cmd, 0, 0, 16, uint16_t, cfg->mac_id)
/* cmd, param, offset, width, type, arg_name */
#define DPMAC_CMD_OPEN(cmd, dpmac_id) \
@ -42,8 +44,6 @@
do { \
MC_RSP_OP(cmd, 0, 0, 32, int, attr->phy_id);\
MC_RSP_OP(cmd, 0, 32, 32, int, attr->id);\
MC_RSP_OP(cmd, 1, 0, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, attr->version.minor);\
MC_RSP_OP(cmd, 1, 32, 8, enum dpmac_link_type, attr->link_type);\
MC_RSP_OP(cmd, 1, 40, 8, enum dpmac_eth_if, attr->eth_if);\
MC_RSP_OP(cmd, 2, 0, 32, uint32_t, attr->max_rate);\
@ -85,7 +85,7 @@ do { \
/* cmd, param, offset, width, type, arg_name */
#define DPMAC_CMD_GET_COUNTER(cmd, type) \
MC_CMD_OP(cmd, 0, 0, 8, enum dpmac_counter, type)
MC_CMD_OP(cmd, 1, 0, 64, enum dpmac_counter, type)
/* cmd, param, offset, width, type, arg_name */
#define DPMAC_RSP_GET_COUNTER(cmd, counter) \
@ -187,9 +187,10 @@ struct dpmac_cfg {
/**
* dpmac_create() - Create the DPMAC object.
* @mc_io: Pointer to MC portal's I/O object
* @token: Authentication token.
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @token: Returned token; use in subsequent API calls
* @obj_id: Returned obj_id; use in subsequent API calls
*
* Create the DPMAC object, allocate required resources and
* perform required initialization.
@ -206,21 +207,24 @@ struct dpmac_cfg {
* Return: '0' on Success; Error code otherwise.
*/
int dpmac_create(struct fsl_mc_io *mc_io,
uint16_t token,
uint32_t cmd_flags,
const struct dpmac_cfg *cfg,
uint16_t *token);
uint32_t *obj_id);
/**
* dpmac_destroy() - Destroy the DPMAC object and release all its resources.
* @mc_io: Pointer to MC portal's I/O object
* @token: Authentication token.
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @token: Token of DPMAC object
* @obj_id: DPMAC object id
*
* Return: '0' on Success; error code otherwise.
*/
int dpmac_destroy(struct fsl_mc_io *mc_io,
uint16_t token,
uint32_t cmd_flags,
uint16_t token);
uint32_t obj_id);
/* DPMAC IRQ Index and Events */
@ -246,15 +250,6 @@ struct dpmac_attr {
enum dpmac_link_type link_type;
enum dpmac_eth_if eth_if;
uint32_t max_rate;
/**
* struct version - Structure representing DPMAC version
* @major: DPMAC major version
* @minor: DPMAC minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
};
/**
@ -464,5 +459,19 @@ int dpmac_get_counter(struct fsl_mc_io *mc_io,
uint16_t token,
enum dpmac_counter type,
uint64_t *counter);
/**
* dpmac_get_api_version - Retrieve DPMAC Major and Minor version info.
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @major_ver: DPMAC major version
* @minor_ver: DPMAC minor version
*
* Return: '0' on Success; Error code otherwise.
*/
int dpmac_get_api_version(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t *major_ver,
uint16_t *minor_ver);
#endif /* __FSL_DPMAC_H */

File diff suppressed because it is too large Load Diff

@ -1,8 +1,8 @@
/*
* Freescale Layerscape MC I/O wrapper
*
* Copyright (C) 2013-2015 Freescale Semiconductor, Inc.
* Author: German Rivera <German.Rivera@freescale.com>
* Copyright (C) 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -10,29 +10,30 @@
#define _FSL_DPRC_H
/* DPRC Version */
#define DPRC_VER_MAJOR 5
#define DPRC_VER_MAJOR 6
#define DPRC_VER_MINOR 1
/* Command IDs */
#define DPRC_CMDID_CLOSE 0x800
#define DPRC_CMDID_OPEN 0x805
#define DPRC_CMDID_CREATE 0x905
#define DPRC_CMDID_GET_ATTR 0x004
#define DPRC_CMDID_RESET_CONT 0x005
#define DPRC_CMDID_CREATE_CONT 0x151
#define DPRC_CMDID_DESTROY_CONT 0x152
#define DPRC_CMDID_GET_CONT_ID 0x830
#define DPRC_CMDID_GET_OBJ_COUNT 0x159
#define DPRC_CMDID_GET_OBJ 0x15A
#define DPRC_CMDID_GET_RES_COUNT 0x15B
#define DPRC_CMDID_GET_RES_IDS 0x15C
#define DPRC_CMDID_GET_OBJ_REG 0x15E
#define DPRC_CMDID_CONNECT 0x167
#define DPRC_CMDID_DISCONNECT 0x168
#define DPRC_CMDID_GET_CONNECTION 0x16C
#define DPRC_CMDID_CLOSE 0x8001
#define DPRC_CMDID_OPEN 0x8051
#define DPRC_CMDID_CREATE 0x9051
#define DPRC_CMDID_GET_ATTR 0x0041
#define DPRC_CMDID_RESET_CONT 0x0051
#define DPRC_CMDID_GET_API_VERSION 0xa051
#define DPRC_CMDID_CREATE_CONT 0x1511
#define DPRC_CMDID_DESTROY_CONT 0x1521
#define DPRC_CMDID_GET_CONT_ID 0x8301
#define DPRC_CMDID_GET_OBJ_COUNT 0x1591
#define DPRC_CMDID_GET_OBJ 0x15A1
#define DPRC_CMDID_GET_RES_COUNT 0x15B1
#define DPRC_CMDID_GET_RES_IDS 0x15C1
#define DPRC_CMDID_GET_OBJ_REG 0x15E1
#define DPRC_CMDID_CONNECT 0x1671
#define DPRC_CMDID_DISCONNECT 0x1681
#define DPRC_CMDID_GET_CONNECTION 0x16C1
/* cmd, param, offset, width, type, arg_name */
#define DPRC_RSP_GET_CONTAINER_ID(cmd, container_id) \
@ -88,8 +89,6 @@ do { \
MC_RSP_OP(cmd, 0, 32, 16, uint16_t, attr->icid); \
MC_RSP_OP(cmd, 1, 0, 32, uint32_t, attr->options);\
MC_RSP_OP(cmd, 1, 32, 32, int, attr->portal_id); \
MC_RSP_OP(cmd, 2, 0, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 2, 16, 16, uint16_t, attr->version.minor);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
@ -345,9 +344,9 @@ do { \
#define DPRC_CMD_CONNECT(cmd, endpoint1, endpoint2, cfg) \
do { \
MC_CMD_OP(cmd, 0, 0, 32, int, endpoint1->id); \
MC_CMD_OP(cmd, 0, 32, 16, uint16_t, endpoint1->if_id); \
MC_CMD_OP(cmd, 0, 32, 32, int, endpoint1->if_id); \
MC_CMD_OP(cmd, 1, 0, 32, int, endpoint2->id); \
MC_CMD_OP(cmd, 1, 32, 16, uint16_t, endpoint2->if_id); \
MC_CMD_OP(cmd, 1, 32, 32, int, endpoint2->if_id); \
MC_CMD_OP(cmd, 2, 0, 8, char, endpoint1->type[0]); \
MC_CMD_OP(cmd, 2, 8, 8, char, endpoint1->type[1]); \
MC_CMD_OP(cmd, 2, 16, 8, char, endpoint1->type[2]); \
@ -410,8 +409,8 @@ do { \
/* cmd, param, offset, width, type, arg_name */
#define DPRC_CMD_GET_CONNECTION(cmd, endpoint1) \
do { \
MC_CMD_OP(cmd, 0, 0, 32, int, endpoint1->id); \
MC_CMD_OP(cmd, 0, 32, 16, uint16_t, endpoint1->if_id); \
MC_CMD_OP(cmd, 0, 0, 32, int, endpoint1->id); \
MC_CMD_OP(cmd, 0, 32, 32, int, endpoint1->if_id); \
MC_CMD_OP(cmd, 1, 0, 8, char, endpoint1->type[0]); \
MC_CMD_OP(cmd, 1, 8, 8, char, endpoint1->type[1]); \
MC_CMD_OP(cmd, 1, 16, 8, char, endpoint1->type[2]); \
@ -657,15 +656,6 @@ struct dprc_attributes {
uint16_t icid;
int portal_id;
uint64_t options;
/**
* struct version - DPRC version
* @major: DPRC major version
* @minor: DPRC minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
};
/**
@ -950,4 +940,19 @@ int dprc_get_connection(struct fsl_mc_io *mc_io,
struct dprc_endpoint *endpoint2,
int *state);
/**
* dprc_get_api_version - Retrieve DPRC Major and Minor version info.
*
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @major_ver: DPRC major version
* @minor_ver: DPRC minor version
*
* Return: '0' on Success; Error code otherwise.
*/
int dprc_get_api_version(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 *major_ver,
u16 *minor_ver);
#endif /* _FSL_DPRC_H */

@ -1,4 +1,5 @@
/* Copyright 2013-2015 Freescale Semiconductor Inc.
/* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -24,6 +25,15 @@ struct mc_command {
uint64_t params[MC_CMD_NUM_OF_PARAMS];
};
struct mc_rsp_create {
__le32 object_id;
};
struct mc_rsp_api_ver {
__le16 major_ver;
__le16 minor_ver;
};
enum mc_cmd_status {
MC_CMD_STATUS_OK = 0x0, /*!< Completed successfully */
MC_CMD_STATUS_READY = 0x1, /*!< Ready to be processed */
@ -51,15 +61,15 @@ enum mc_cmd_status {
#define MC_CMD_FLAG_INTR_DIS 0x01000000
#define MC_CMD_HDR_CMDID_O 52 /* Command ID field offset */
#define MC_CMD_HDR_CMDID_S 12 /* Command ID field size */
#define MC_CMD_HDR_CMDID_O 48 /* Command ID field offset */
#define MC_CMD_HDR_CMDID_S 16 /* Command ID field size */
#define MC_CMD_HDR_STATUS_O 16 /* Status field offset */
#define MC_CMD_HDR_TOKEN_O 38 /* Token field offset */
#define MC_CMD_HDR_TOKEN_S 10 /* Token field size */
#define MC_CMD_HDR_TOKEN_O 32 /* Token field offset */
#define MC_CMD_HDR_TOKEN_S 16 /* Token field size */
#define MC_CMD_HDR_STATUS_S 8 /* Status field size*/
#define MC_CMD_HDR_FLAGS_O 0 /* Flags field offset */
#define MC_CMD_HDR_FLAGS_S 32 /* Flags field size*/
#define MC_CMD_HDR_FLAGS_MASK 0xFF00FF00 /* Command flags mask */
#define MC_CMD_HDR_FLAGS_MASK 0x0000FFFF /* Command flags mask */
#define MC_CMD_HDR_READ_STATUS(_hdr) \
((enum mc_cmd_status)mc_dec((_hdr), \
@ -80,11 +90,19 @@ enum mc_cmd_status {
#define MC_RSP_OP(_cmd, _param, _offset, _width, _type, _arg) \
(_arg = (_type)mc_dec(_cmd.params[_param], (_offset), (_width)))
/* cmd, param, offset, width, type, arg_name */
#define MC_CMD_READ_OBJ_ID(cmd, obj_id) \
MC_RSP_OP(cmd, 0, 0, 32, uint32_t, obj_id)
/* cmd, param, offset, width, type, arg_name */
#define CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, object_id) \
MC_CMD_OP(cmd, 0, 0, 32, uint32_t, object_id)
static inline uint64_t mc_encode_cmd_header(uint16_t cmd_id,
uint32_t cmd_flags,
uint16_t token)
{
uint64_t hdr;
uint64_t hdr = 0;
hdr = mc_enc(MC_CMD_HDR_CMDID_O, MC_CMD_HDR_CMDID_S, cmd_id);
hdr |= mc_enc(MC_CMD_HDR_FLAGS_O, MC_CMD_HDR_FLAGS_S,
@ -144,4 +162,22 @@ static inline enum mc_cmd_status mc_read_response(
return status;
}
/**
* mc_read_version - read version of the given cmd
*
* @cmd: pointer to a filled command
* @major_version: major version value for the given cmd
* @minor_version: minor version value for the given cmd
*/
static inline void mc_cmd_read_api_version(struct mc_command *cmd,
u16 *major_ver,
u16 *minor_ver)
{
struct mc_rsp_api_ver *rsp_params;
rsp_params = (struct mc_rsp_api_ver *)cmd->params;
*major_ver = le16_to_cpu(rsp_params->major_ver);
*minor_ver = le16_to_cpu(rsp_params->minor_ver);
}
#endif /* __FSL_MC_CMD_H */

@ -1,5 +1,6 @@
/*
* Copyright (C) 2014 Freescale Semiconductor
* Copyright (C) 2014-2016 Freescale Semiconductor
* Copyright 2017 NXP
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -29,6 +30,7 @@ extern struct fsl_mc_io *dflt_mc_io;
* @struct dpbp_attr: DPBP attribute
*/
struct fsl_dpbp_obj {
uint32_t dpbp_id;
uint16_t dpbp_handle;
struct dpbp_attr dpbp_attr;
};
@ -41,7 +43,7 @@ extern struct fsl_dpbp_obj *dflt_dpbp;
* @struct qbman_swp *sw_portal: SW portal object
*/
struct fsl_dpio_obj {
int dpio_id;
uint32_t dpio_id;
uint16_t dpio_handle;
struct qbman_swp *sw_portal; /** SW portal object */
};
@ -56,7 +58,7 @@ extern struct fsl_dpio_obj *dflt_dpio;
* @struct dpni_buffer_layout: DPNI buffer layout
*/
struct fsl_dpni_obj {
int dpni_id;
uint32_t dpni_id;
uint16_t dpni_handle;
struct dpni_attr dpni_attrs;
struct dpni_buffer_layout buf_layout;

Loading…
Cancel
Save