sysflashmem.c

vxworks MPC8541 BSP

                break;
            curPos += dev->portSize;
            tempBuf += dev->portSize;
            }
        if (curPos == (pos + dataSize))
            return OK;
        }

    if (dev->writeBufMod)
        {
        for (j = 0; j < dev->portSize; j += dev->portSize / dev->bankCount)
            {
            (*dev->get)(dev, pos, stat);
            if (stat[j + dev->portSize / dev->bankCount - 1] & 0x02)
                {
                printf("flash write buffer aborted!\n");
                (*dev->set)(dev, 0x5555 * dev->portSize, (char *)&amdFlashCmd[0]);
                (*dev->set)(dev, 0x2AAA * dev->portSize, (char *)&amdFlashCmd[1]);
                (*dev->set)(dev, 0x5555 * dev->portSize, (char *)&amdFlashCmd[7]);
                return ERROR;
                }
            }
        }

    printf("flash check timeout!\n");

    amdFlashReset(dev);

    return ERROR;
    }

/*******************************************************************************
*
* intelFlashReset - 
*
*/
static void intelFlashReset(FLASH_DEV *dev)
    {
    (*dev->set)(dev, 0x0, (char *)&intelFlashCmd[4]);
    (*dev->set)(dev, 0x0, (char *)&intelFlashCmd[0]);
    }

/*******************************************************************************
*
* intelFlashProbe - 
*
*/
static STATUS intelFlashProbe(FLASH_DEV *dev)
    {
    FLASH_UNIT *unit = &flashUnit[dev->unitNo];
    FLASH_PHY *phy = flashPhy;
    UINT8 offset = dev->portSize > 1 ? 0 : 1;

    if (unit->inited && unit->phy->isAmdType)
        return ERROR;

    if (!unit->inited)
        {
        unit->unitAddr = dev->devAddr;

        memset(&tempID, 0, sizeof(tempID));
        memset(&buffID, 0, sizeof(buffID));

        flashCmdRawSet(dev, 0x0, (char *)&intelFlashCmd[1]);

        taskDelay(1);

        if (dev->portSize == 1 && dev->unitNo != 0)
            {
            flashCfgRawGet(dev, 0x0, (char *)&tempID.vendorID);
            flashCfgRawGet(dev, 0x2, (char *)&tempID.deviceID);
            }
        else
            {
            flashCfgRawGet(dev, 0x0, (char *)&tempID.vendorID);
            flashCfgRawGet(dev, 0x1, (char *)&tempID.deviceID);
            }

        flashCmdRawSet(dev, 0x0, (char *)&intelFlashCmd[4]);
        flashCmdRawSet(dev, 0x0, (char *)&intelFlashCmd[0]);

        if (*(char *)&tempID.vendorID != (char)0xFF)
            buffID = tempID;

        do
            {
            if ((memcmp((char *)&tempID.vendorID, (char *)&phy->flashID->vendorID + offset, dev->portSize) == OK) &&
                (memcmp((char *)&tempID.deviceID, (char *)&phy->flashID->deviceID + offset, dev->portSize) == OK) &&
                !phy->isAmdType)
                {
                unit->phy = phy;
                unit->inited = 1;
                break;
                }
            phy++;
            } while (phy->flashID != (FLASH_ID *)-1);

        if (!unit->inited)
            return ERROR;
        }

    flashPartIdentify(dev, unit->phy->flashPart, unit->phy->partCount);

    unit->devCount++;

    switch (dev->portSize)
        {
    case 8:
        dev->get = flashGetOctet8;
        dev->set = flashSetOctet8;
        break;

    case 4:
        dev->get = flashGetOctet4;
        dev->set = flashSetOctet4;
        break;

    case 2:
        dev->get = flashGetOctet2;
        dev->set = flashSetOctet2;
        break;

    case 1:
        dev->get = flashGetOctet1;
        dev->set = flashSetOctet1;
        break;

    default:
        return ERROR;
        }

    if (dev->writeBufMod && unit->phy->writeBufMod)
        dev->write = intelFlashBWrite;
    else
        {
        dev->write = intelFlashWrite;
        dev->writeBufMod = 0;
        }

    dev->erase = intelFlashErase;

    if (!unit->unitSem)
        {
        unit->unitSem = semBCreate(SEM_Q_FIFO, SEM_FULL);
        if (unit->unitSem == NULL)
            return ERROR;
        }
    dev->devSem = unit->unitSem;

    dev->unit = unit;

    intelFlashUnlockAll(dev);

    dev->inited = 1;

    return OK;
    }

/*******************************************************************************
*
* intelFlashUnlock - 
*
*/
static STATUS intelFlashUnlock(FLASH_DEV *dev, UINT32 pos)
    {
    char stat[8];
    int retVal = OK;
    UINT32 i;

    (*dev->set)(dev, pos, (char *)&intelFlashCmd[1]);
    if (dev->portSize != 1)
        (*dev->get)(dev, pos + dev->portSize * 2, stat);
    else
        (*dev->get)(dev, pos + dev->portSize * 4, stat);

    intelFlashReset(dev);

    for (i = 0; i < dev->portSize; i += dev->portSize / dev->bankCount)
        {
        if (stat[i + dev->portSize / dev->bankCount - 1] & 0x1)
            {
            retVal = ERROR;
            break;
            }
        }

    if (retVal == OK)
        return retVal;

    (*dev->set)(dev, pos, (char *)&intelFlashCmd[9]);
    (*dev->set)(dev, pos, (char *)&intelFlashCmd[8]);

    return intelFlashCheck(dev, pos, FLASH_POLL_UNLOCK);
    }

/*******************************************************************************
*
* intelFlashUnlockAll - 
*
*/
static STATUS intelFlashUnlockAll(FLASH_DEV *dev)
    {
    FLASH_PART *part;
    UINT32 blkPos = 0;
    UINT32 i, j;

    for (i = 0; i < dev->partCount; i++)
        {
        part = dev->devPart + i;
        for (j = 0; j < part->blockCount; j++)
            {
            if (intelFlashUnlock(dev, blkPos) == ERROR)
                return ERROR;

            blkPos += dev->bankCount * part->blockSize;
            }
        }

    return OK;
    }

/*******************************************************************************
*
* intelFlashErase - 
*
*/
static STATUS intelFlashErase(FLASH_DEV *dev, UINT32 pos)
    {
    (*dev->set)(dev, pos, (char *)&intelFlashCmd[6]);
    (*dev->set)(dev, pos, (char *)&intelFlashCmd[8]);

    return intelFlashCheck(dev, pos, FLASH_POLL_ERASE);
    }

/*******************************************************************************
*
* intelFlashWrite - 
*
*/
static STATUS intelFlashWrite(FLASH_DEV *dev, UINT32 pos, char *buf)
    {
    (*dev->set)(dev, pos, (char *)&intelFlashCmd[5]);
    (*dev->set)(dev, pos, buf);

    return intelFlashCheck(dev, pos, FLASH_POLL_WRITE);
    }

/*******************************************************************************
*
* intelFlashBWrite - 
*
*/
static STATUS intelFlashBWrite(FLASH_DEV *dev, UINT32 pos, char *buf)
    {
    UINT32 curPos = pos;
    int intLevel;
    UINT32 i;

    (*dev->set)(dev, pos, (char *)&intelFlashCmd[13]);
    if (dev->portSize != 1)
        (*dev->set)(dev, pos, (char *)&intelFlashCmd[14]);
    else
        (*dev->set)(dev, pos, (char *)&intelFlashCmd[15]);

    intLevel = intLock();
    for (i = 0; i < WRITE_BUF_SIZE * dev->bankCount / dev->portSize; i++)
        {
        (*dev->set)(dev, curPos, buf);
        curPos += dev->portSize;
        buf += dev->portSize;
        }
    intUnlock(intLevel);

    (*dev->set)(dev, pos, (char *)&intelFlashCmd[8]);

    return intelFlashCheck(dev, pos, FLASH_POLL_WRITE);
    }

/*******************************************************************************
*
* intelFlashCheck - 
*
*/
static STATUS intelFlashCheck(FLASH_DEV *dev, UINT32 pos, int option)
    {
    int retVal = ERROR, chkGo = FALSE;
    UINT32 i, j;
    UINT32 polls;
    char stat[8];

    if (option == FLASH_POLL_ERASE)
        polls = FLASH_ERASE_TIMEOUT;
    else
        polls = FLASH_WRITE_TIMEOUT;

    for (i = 0; i < polls; i++)
        {
        if (option == FLASH_POLL_ERASE)
            {
            SYS_FLASH_TIMER_RESET();
            taskDelay(1);
            }

        (*dev->get)(dev, pos, stat);

        chkGo = FALSE;
        for (j = 0; j < dev->portSize; j += dev->portSize / dev->bankCount)
            {
            if ((stat[j + dev->portSize / dev->bankCount - 1] & 0x80) != 0x80)
                {
                chkGo = TRUE;
                break;
                }
            }

        if (!chkGo)
            {
            retVal = OK;
            break;
            }
        }

    SYS_FLASH_TIMER_RESET();

    if (retVal == OK)
        {
        (*dev->get)(dev, pos, stat);
        for (i = 0; i < dev->portSize; i += dev->portSize / dev->bankCount)
            {
            if (stat[i + dev->portSize / dev->bankCount - 1] & 0x3A)
                {
                printf("flash write error!\n");
                intelFlashReset(dev);
                return ERROR;
                }
            }
        }
    else
        printf("flash check timeout!\n");

    intelFlashReset(dev);

    return retVal;
    }

/*******************************************************************************
*
* flashInit - 
*
*/
STATUS flashInit(void)
    {
   /* int retVal;*/
    int unit;
    int i;

    if (flashInited)
        return OK;

    flashInited = 1;

    SYS_FLASH_HW_INIT();

    SYS_FLASH_HW_ENABLE();

    for (i = 0; i < FLASH_UNIT_NUM; i++)
        {
        memset((char *)(flashUnit + i), 0, sizeof(FLASH_UNIT));
        flashUnit[i].unitNo = i;
        }

    for (
#ifdef __BOOTROM__
        i = 0,
#else
        i = 1,
#endif /* __BOOTROM__ */
        unit = i;
        i < devCount;
        i++
        )
        {
        if ((/*retVal = */amdFlashProbe(flashDev + i)) == ERROR)
            if ((/*retVal = */intelFlashProbe(flashDev + i)) == ERROR)
                {
                if ((flashDev + i)->unitNo == unit)
                    {
                    switch ((flashDev + i)->portSize)
                        {
                    case 8:
                        printf("flash unit %d init failed! VendorID = 0x%08x%08x DeviceID = 0x%08x%08x\n",
                               unit,
                               *(UINT32 *)&buffID.vendorID,
                               *(UINT32 *)((char *)&buffID.vendorID + 4),
                               *(UINT32 *)&buffID.deviceID,
                               *(UINT32 *)((char *)&buffID.deviceID + 4));
                        break;

                    case 4:
                        printf("flash unit %d init failed! VendorID = 0x%08x DeviceID = 0x%08x\n",
                               unit,
                               *(UINT32 *)&buffID.vendorID,
                               *(UINT32 *)&buffID.deviceID);
                        break;

                    case 2:
                        printf("flash unit %d init failed! VendorID = 0x%04x DeviceID = 0x%04x\n",
                               unit,
                               *(UINT16 *)&buffID.vendorID,
                               *(UINT16 *)&buffID.deviceID);
                        break;

                    case 1:
                        printf("flash unit %d init failed! VendorID = 0x%02x DeviceID = 0x%02x\n",
                               unit,
                               *(UINT8 *)&buffID.vendorID,
                               *(UINT8 *)&buffID.deviceID);
                        break;

                    default:
                        break;
                        }

                    unit++;
                    }

                flashInited = 0;

                continue;
                }

        if ((flashDev + i)->unitNo == unit)
            {
            printf("flash unit %d init OK!\n", unit);
            unit++;
            }
        }

    SYS_FLASH_HW_DISABLE();

    return flashInited == 1 ? OK : ERROR;
    }

/*******************************************************************************
*
* flashCheck - 
*
*/
static STATUS flashCheck(FLASH_DEV *dev)
    {
    if (!flashInited)
        {
        printf("flash not initialized!\n");
        return ERROR;
        }

    if (dev < &flashDev[0] || dev >= &flashDev[devCount])
        {
        printf("flash dev parameter error!\n");
        return ERROR;
        }

    if (!dev->inited)
        {
        printf("flash device %d not available!\n", (int)(dev - flashDev));
        return ERROR;
        }

    return OK;
    }

/*******************************************************************************
*
* flashRead - 
*
*/
STATUS flashRead(FLASH_DEV *dev, UINT32 pos, char *buf, UINT32 len)
    {
    if (!dev->inited)
        {
        if (flashInit() == ERROR)
            return ERROR;
        }

    if (pos + len > dev->devSize)
        {
        printf("flash read position out of range!\n");
        return ERROR;
        }

    if (len == 0)
        return OK;

    semTake(dev->devSem, WAIT_FOREVER);

    memcpy(buf, (char *)(dev->devAddr + pos), len);

    semGive(dev->devSem);

    return OK;
    }

/*******************************************************************************
*
* flashWrite - 
*
*/
STATUS flashWrite(FLASH_DEV *dev, UINT32 pos, char *buf, UINT32 len)
    {
    UINT32 curPos;
    char *dataBuf;
    char tempBuf[WRITE_BUF_SIZE * FLASH_BANK_MAX];
    UINT32 dataSize = dev->writeBufMod ? WRITE_BUF_SIZE * dev->bankCount : dev->portSize;
    UINT32 overSize = 0;
    int scanLen = 0;

    if (!dev->inited)
        {
        if (flashInit() == ERROR)
            return ERROR;
        }

    if (pos + len > dev->devSize)
        {
        printf("flash write position out of range!\n");
        return ERROR;
        }

    if (len == 0)
        return OK;

    semTake(dev->devSem, WAIT_FOREVER);