mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-31 06:18:51 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
432 lines
12 KiB
C
432 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright 2009-2011 Freescale Semiconductor, Inc.
|
|
* Dave Liu <daveliu@freescale.com>
|
|
*/
|
|
#include <common.h>
|
|
#include <malloc.h>
|
|
#include <asm/io.h>
|
|
#include <linux/errno.h>
|
|
|
|
#include "fm.h"
|
|
#include <fsl_qe.h> /* For struct qe_firmware */
|
|
|
|
#ifdef CONFIG_SYS_QE_FMAN_FW_IN_NAND
|
|
#include <nand.h>
|
|
#elif defined(CONFIG_SYS_QE_FW_IN_SPIFLASH)
|
|
#include <spi_flash.h>
|
|
#elif defined(CONFIG_SYS_QE_FMAN_FW_IN_MMC)
|
|
#include <mmc.h>
|
|
#endif
|
|
|
|
struct fm_muram muram[CONFIG_SYS_NUM_FMAN];
|
|
|
|
void *fm_muram_base(int fm_idx)
|
|
{
|
|
return muram[fm_idx].base;
|
|
}
|
|
|
|
void *fm_muram_alloc(int fm_idx, size_t size, ulong align)
|
|
{
|
|
void *ret;
|
|
ulong align_mask;
|
|
size_t off;
|
|
void *save;
|
|
|
|
align_mask = align - 1;
|
|
save = muram[fm_idx].alloc;
|
|
|
|
off = (ulong)save & align_mask;
|
|
if (off != 0)
|
|
muram[fm_idx].alloc += (align - off);
|
|
off = size & align_mask;
|
|
if (off != 0)
|
|
size += (align - off);
|
|
if ((muram[fm_idx].alloc + size) >= muram[fm_idx].top) {
|
|
muram[fm_idx].alloc = save;
|
|
printf("%s: run out of ram.\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
ret = muram[fm_idx].alloc;
|
|
muram[fm_idx].alloc += size;
|
|
memset((void *)ret, 0, size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void fm_init_muram(int fm_idx, void *reg)
|
|
{
|
|
void *base = reg;
|
|
|
|
muram[fm_idx].base = base;
|
|
muram[fm_idx].size = CONFIG_SYS_FM_MURAM_SIZE;
|
|
muram[fm_idx].alloc = base + FM_MURAM_RES_SIZE;
|
|
muram[fm_idx].top = base + CONFIG_SYS_FM_MURAM_SIZE;
|
|
}
|
|
|
|
/*
|
|
* fm_upload_ucode - Fman microcode upload worker function
|
|
*
|
|
* This function does the actual uploading of an Fman microcode
|
|
* to an Fman.
|
|
*/
|
|
static void fm_upload_ucode(int fm_idx, struct fm_imem *imem,
|
|
u32 *ucode, unsigned int size)
|
|
{
|
|
unsigned int i;
|
|
unsigned int timeout = 1000000;
|
|
|
|
/* enable address auto increase */
|
|
out_be32(&imem->iadd, IRAM_IADD_AIE);
|
|
/* write microcode to IRAM */
|
|
for (i = 0; i < size / 4; i++)
|
|
out_be32(&imem->idata, (be32_to_cpu(ucode[i])));
|
|
|
|
/* verify if the writing is over */
|
|
out_be32(&imem->iadd, 0);
|
|
while ((in_be32(&imem->idata) != be32_to_cpu(ucode[0])) && --timeout)
|
|
;
|
|
if (!timeout)
|
|
printf("Fman%u: microcode upload timeout\n", fm_idx + 1);
|
|
|
|
/* enable microcode from IRAM */
|
|
out_be32(&imem->iready, IRAM_READY);
|
|
}
|
|
|
|
/*
|
|
* Upload an Fman firmware
|
|
*
|
|
* This function is similar to qe_upload_firmware(), exception that it uploads
|
|
* a microcode to the Fman instead of the QE.
|
|
*
|
|
* Because the process for uploading a microcode to the Fman is similar for
|
|
* that of the QE, the QE firmware binary format is used for Fman microcode.
|
|
* It should be possible to unify these two functions, but for now we keep them
|
|
* separate.
|
|
*/
|
|
static int fman_upload_firmware(int fm_idx,
|
|
struct fm_imem *fm_imem,
|
|
const struct qe_firmware *firmware)
|
|
{
|
|
unsigned int i;
|
|
u32 crc;
|
|
size_t calc_size = sizeof(struct qe_firmware);
|
|
size_t length;
|
|
const struct qe_header *hdr;
|
|
|
|
if (!firmware) {
|
|
printf("Fman%u: Invalid address for firmware\n", fm_idx + 1);
|
|
return -EINVAL;
|
|
}
|
|
|
|
hdr = &firmware->header;
|
|
length = be32_to_cpu(hdr->length);
|
|
|
|
/* Check the magic */
|
|
if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
|
|
(hdr->magic[2] != 'F')) {
|
|
printf("Fman%u: Data at %p is not a firmware\n", fm_idx + 1,
|
|
firmware);
|
|
return -EPERM;
|
|
}
|
|
|
|
/* Check the version */
|
|
if (hdr->version != 1) {
|
|
printf("Fman%u: Unsupported firmware version %u\n", fm_idx + 1,
|
|
hdr->version);
|
|
return -EPERM;
|
|
}
|
|
|
|
/* Validate some of the fields */
|
|
if ((firmware->count != 1)) {
|
|
printf("Fman%u: Invalid data in firmware header\n", fm_idx + 1);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Validate the length and check if there's a CRC */
|
|
calc_size += (firmware->count - 1) * sizeof(struct qe_microcode);
|
|
|
|
for (i = 0; i < firmware->count; i++)
|
|
/*
|
|
* For situations where the second RISC uses the same microcode
|
|
* as the first, the 'code_offset' and 'count' fields will be
|
|
* zero, so it's okay to add those.
|
|
*/
|
|
calc_size += sizeof(u32) *
|
|
be32_to_cpu(firmware->microcode[i].count);
|
|
|
|
/* Validate the length */
|
|
if (length != calc_size + sizeof(u32)) {
|
|
printf("Fman%u: Invalid length in firmware header\n",
|
|
fm_idx + 1);
|
|
return -EPERM;
|
|
}
|
|
|
|
/*
|
|
* Validate the CRC. We would normally call crc32_no_comp(), but that
|
|
* function isn't available unless you turn on JFFS support.
|
|
*/
|
|
crc = be32_to_cpu(*(u32 *)((void *)firmware + calc_size));
|
|
if (crc != (crc32(-1, (const void *)firmware, calc_size) ^ -1)) {
|
|
printf("Fman%u: Firmware CRC is invalid\n", fm_idx + 1);
|
|
return -EIO;
|
|
}
|
|
|
|
/* Loop through each microcode. */
|
|
for (i = 0; i < firmware->count; i++) {
|
|
const struct qe_microcode *ucode = &firmware->microcode[i];
|
|
|
|
/* Upload a microcode if it's present */
|
|
if (be32_to_cpu(ucode->code_offset)) {
|
|
u32 ucode_size;
|
|
u32 *code;
|
|
printf("Fman%u: Uploading microcode version %u.%u.%u\n",
|
|
fm_idx + 1, ucode->major, ucode->minor,
|
|
ucode->revision);
|
|
code = (void *)firmware +
|
|
be32_to_cpu(ucode->code_offset);
|
|
ucode_size = sizeof(u32) * be32_to_cpu(ucode->count);
|
|
fm_upload_ucode(fm_idx, fm_imem, code, ucode_size);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static u32 fm_assign_risc(int port_id)
|
|
{
|
|
u32 risc_sel, val;
|
|
risc_sel = (port_id & 0x1) ? FMFPPRC_RISC2 : FMFPPRC_RISC1;
|
|
val = (port_id << FMFPPRC_PORTID_SHIFT) & FMFPPRC_PORTID_MASK;
|
|
val |= ((risc_sel << FMFPPRC_ORA_SHIFT) | risc_sel);
|
|
|
|
return val;
|
|
}
|
|
|
|
static void fm_init_fpm(struct fm_fpm *fpm)
|
|
{
|
|
int i, port_id;
|
|
u32 val;
|
|
|
|
setbits_be32(&fpm->fmfpee, FMFPEE_EHM | FMFPEE_UEC |
|
|
FMFPEE_CER | FMFPEE_DER);
|
|
|
|
/* IM mode, each even port ID to RISC#1, each odd port ID to RISC#2 */
|
|
|
|
/* offline/parser port */
|
|
for (i = 0; i < MAX_NUM_OH_PORT; i++) {
|
|
port_id = OH_PORT_ID_BASE + i;
|
|
val = fm_assign_risc(port_id);
|
|
out_be32(&fpm->fpmprc, val);
|
|
}
|
|
/* Rx 1G port */
|
|
for (i = 0; i < MAX_NUM_RX_PORT_1G; i++) {
|
|
port_id = RX_PORT_1G_BASE + i;
|
|
val = fm_assign_risc(port_id);
|
|
out_be32(&fpm->fpmprc, val);
|
|
}
|
|
/* Tx 1G port */
|
|
for (i = 0; i < MAX_NUM_TX_PORT_1G; i++) {
|
|
port_id = TX_PORT_1G_BASE + i;
|
|
val = fm_assign_risc(port_id);
|
|
out_be32(&fpm->fpmprc, val);
|
|
}
|
|
/* Rx 10G port */
|
|
port_id = RX_PORT_10G_BASE;
|
|
val = fm_assign_risc(port_id);
|
|
out_be32(&fpm->fpmprc, val);
|
|
/* Tx 10G port */
|
|
port_id = TX_PORT_10G_BASE;
|
|
val = fm_assign_risc(port_id);
|
|
out_be32(&fpm->fpmprc, val);
|
|
|
|
/* disable the dispatch limit in IM case */
|
|
out_be32(&fpm->fpmflc, FMFP_FLC_DISP_LIM_NONE);
|
|
/* clear events */
|
|
out_be32(&fpm->fmfpee, FMFPEE_CLEAR_EVENT);
|
|
|
|
/* clear risc events */
|
|
for (i = 0; i < 4; i++)
|
|
out_be32(&fpm->fpmcev[i], 0xffffffff);
|
|
|
|
/* clear error */
|
|
out_be32(&fpm->fpmrcr, FMFP_RCR_MDEC | FMFP_RCR_IDEC);
|
|
}
|
|
|
|
static int fm_init_bmi(int fm_idx, struct fm_bmi_common *bmi)
|
|
{
|
|
int blk, i, port_id;
|
|
u32 val;
|
|
size_t offset;
|
|
void *base;
|
|
|
|
/* alloc free buffer pool in MURAM */
|
|
base = fm_muram_alloc(fm_idx, FM_FREE_POOL_SIZE, FM_FREE_POOL_ALIGN);
|
|
if (!base) {
|
|
printf("%s: no muram for free buffer pool\n", __func__);
|
|
return -ENOMEM;
|
|
}
|
|
offset = base - fm_muram_base(fm_idx);
|
|
|
|
/* Need 128KB total free buffer pool size */
|
|
val = offset / 256;
|
|
blk = FM_FREE_POOL_SIZE / 256;
|
|
/* in IM, we must not begin from offset 0 in MURAM */
|
|
val |= ((blk - 1) << FMBM_CFG1_FBPS_SHIFT);
|
|
out_be32(&bmi->fmbm_cfg1, val);
|
|
|
|
/* disable all BMI interrupt */
|
|
out_be32(&bmi->fmbm_ier, FMBM_IER_DISABLE_ALL);
|
|
|
|
/* clear all events */
|
|
out_be32(&bmi->fmbm_ievr, FMBM_IEVR_CLEAR_ALL);
|
|
|
|
/*
|
|
* set port parameters - FMBM_PP_x
|
|
* max tasks 10G Rx/Tx=12, 1G Rx/Tx 4, others is 1
|
|
* max dma 10G Rx/Tx=3, others is 1
|
|
* set port FIFO size - FMBM_PFS_x
|
|
* 4KB for all Rx and Tx ports
|
|
*/
|
|
/* offline/parser port */
|
|
for (i = 0; i < MAX_NUM_OH_PORT; i++) {
|
|
port_id = OH_PORT_ID_BASE + i - 1;
|
|
/* max tasks=1, max dma=1, no extra */
|
|
out_be32(&bmi->fmbm_pp[port_id], 0);
|
|
/* port FIFO size - 256 bytes, no extra */
|
|
out_be32(&bmi->fmbm_pfs[port_id], 0);
|
|
}
|
|
/* Rx 1G port */
|
|
for (i = 0; i < MAX_NUM_RX_PORT_1G; i++) {
|
|
port_id = RX_PORT_1G_BASE + i - 1;
|
|
/* max tasks=4, max dma=1, no extra */
|
|
out_be32(&bmi->fmbm_pp[port_id], FMBM_PP_MXT(4));
|
|
/* FIFO size - 4KB, no extra */
|
|
out_be32(&bmi->fmbm_pfs[port_id], FMBM_PFS_IFSZ(0xf));
|
|
}
|
|
/* Tx 1G port FIFO size - 4KB, no extra */
|
|
for (i = 0; i < MAX_NUM_TX_PORT_1G; i++) {
|
|
port_id = TX_PORT_1G_BASE + i - 1;
|
|
/* max tasks=4, max dma=1, no extra */
|
|
out_be32(&bmi->fmbm_pp[port_id], FMBM_PP_MXT(4));
|
|
/* FIFO size - 4KB, no extra */
|
|
out_be32(&bmi->fmbm_pfs[port_id], FMBM_PFS_IFSZ(0xf));
|
|
}
|
|
/* Rx 10G port */
|
|
port_id = RX_PORT_10G_BASE - 1;
|
|
/* max tasks=12, max dma=3, no extra */
|
|
out_be32(&bmi->fmbm_pp[port_id], FMBM_PP_MXT(12) | FMBM_PP_MXD(3));
|
|
/* FIFO size - 4KB, no extra */
|
|
out_be32(&bmi->fmbm_pfs[port_id], FMBM_PFS_IFSZ(0xf));
|
|
|
|
/* Tx 10G port */
|
|
port_id = TX_PORT_10G_BASE - 1;
|
|
/* max tasks=12, max dma=3, no extra */
|
|
out_be32(&bmi->fmbm_pp[port_id], FMBM_PP_MXT(12) | FMBM_PP_MXD(3));
|
|
/* FIFO size - 4KB, no extra */
|
|
out_be32(&bmi->fmbm_pfs[port_id], FMBM_PFS_IFSZ(0xf));
|
|
|
|
/* initialize internal buffers data base (linked list) */
|
|
out_be32(&bmi->fmbm_init, FMBM_INIT_START);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fm_init_qmi(struct fm_qmi_common *qmi)
|
|
{
|
|
/* disable all error interrupts */
|
|
out_be32(&qmi->fmqm_eien, FMQM_EIEN_DISABLE_ALL);
|
|
/* clear all error events */
|
|
out_be32(&qmi->fmqm_eie, FMQM_EIE_CLEAR_ALL);
|
|
|
|
/* disable all interrupts */
|
|
out_be32(&qmi->fmqm_ien, FMQM_IEN_DISABLE_ALL);
|
|
/* clear all interrupts */
|
|
out_be32(&qmi->fmqm_ie, FMQM_IE_CLEAR_ALL);
|
|
}
|
|
|
|
/* Init common part of FM, index is fm num# like fm as above */
|
|
int fm_init_common(int index, struct ccsr_fman *reg)
|
|
{
|
|
int rc;
|
|
#if defined(CONFIG_SYS_QE_FMAN_FW_IN_NOR)
|
|
void *addr = (void *)CONFIG_SYS_FMAN_FW_ADDR;
|
|
#elif defined(CONFIG_SYS_QE_FMAN_FW_IN_NAND)
|
|
size_t fw_length = CONFIG_SYS_QE_FMAN_FW_LENGTH;
|
|
void *addr = malloc(CONFIG_SYS_QE_FMAN_FW_LENGTH);
|
|
|
|
rc = nand_read(get_nand_dev_by_index(0),
|
|
(loff_t)CONFIG_SYS_FMAN_FW_ADDR,
|
|
&fw_length, (u_char *)addr);
|
|
if (rc == -EUCLEAN) {
|
|
printf("NAND read of FMAN firmware at offset 0x%x failed %d\n",
|
|
CONFIG_SYS_FMAN_FW_ADDR, rc);
|
|
}
|
|
#elif defined(CONFIG_SYS_QE_FW_IN_SPIFLASH)
|
|
struct spi_flash *ucode_flash;
|
|
void *addr = malloc(CONFIG_SYS_QE_FMAN_FW_LENGTH);
|
|
int ret = 0;
|
|
|
|
#ifdef CONFIG_DM_SPI_FLASH
|
|
struct udevice *new;
|
|
|
|
/* speed and mode will be read from DT */
|
|
ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
|
|
0, 0, &new);
|
|
|
|
ucode_flash = dev_get_uclass_priv(new);
|
|
#else
|
|
ucode_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
|
|
CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
|
|
#endif
|
|
if (!ucode_flash)
|
|
printf("SF: probe for ucode failed\n");
|
|
else {
|
|
ret = spi_flash_read(ucode_flash, CONFIG_SYS_FMAN_FW_ADDR,
|
|
CONFIG_SYS_QE_FMAN_FW_LENGTH, addr);
|
|
if (ret)
|
|
printf("SF: read for ucode failed\n");
|
|
spi_flash_free(ucode_flash);
|
|
}
|
|
#elif defined(CONFIG_SYS_QE_FMAN_FW_IN_MMC)
|
|
int dev = CONFIG_SYS_MMC_ENV_DEV;
|
|
void *addr = malloc(CONFIG_SYS_QE_FMAN_FW_LENGTH);
|
|
u32 cnt = CONFIG_SYS_QE_FMAN_FW_LENGTH / 512;
|
|
u32 blk = CONFIG_SYS_FMAN_FW_ADDR / 512;
|
|
struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
|
|
|
|
if (!mmc)
|
|
printf("\nMMC cannot find device for ucode\n");
|
|
else {
|
|
printf("\nMMC read: dev # %u, block # %u, count %u ...\n",
|
|
dev, blk, cnt);
|
|
mmc_init(mmc);
|
|
(void)mmc->block_dev.block_read(&mmc->block_dev, blk, cnt,
|
|
addr);
|
|
}
|
|
#elif defined(CONFIG_SYS_QE_FMAN_FW_IN_REMOTE)
|
|
void *addr = (void *)CONFIG_SYS_FMAN_FW_ADDR;
|
|
#else
|
|
void *addr = NULL;
|
|
#endif
|
|
|
|
/* Upload the Fman microcode if it's present */
|
|
rc = fman_upload_firmware(index, ®->fm_imem, addr);
|
|
if (rc)
|
|
return rc;
|
|
env_set_addr("fman_ucode", addr);
|
|
|
|
fm_init_muram(index, ®->muram);
|
|
fm_init_qmi(®->fm_qmi_common);
|
|
fm_init_fpm(®->fm_fpm);
|
|
|
|
/* clear DMA status */
|
|
setbits_be32(®->fm_dma.fmdmsr, FMDMSR_CLEAR_ALL);
|
|
|
|
/* set DMA mode */
|
|
setbits_be32(®->fm_dma.fmdmmr, FMDMMR_SBER);
|
|
|
|
return fm_init_bmi(index, ®->fm_bmi_common);
|
|
}
|