tmfat32sd.c

PNX1500上Fat32文件系统源代码

        d->eventNotify(d->vol, TM_FAT32_EVENT_WRITE);

    data_ptr = buffer;
    sec_size = d->bytesPerSector;

    errorCode = tmdlSdWrite (p->sdInstance, sector * sec_size ,sec_size * count, data_ptr);

    TMFAT_DEBUG1("-tmFat32_Sd_Write_Sectors() returning 0x%x\n", errorCode);
    return errorCode;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Sd_Term
//
// DESCRIPTION:
//
// RETURN:      tmErrorCode_t: Status of operation (TM_OK = PASS)
//
// NOTES:
//-----------------------------------------------------------------------------
//

static tmErrorCode_t
tmFat32_Sd_Term (
    ptmFat32_Dev_t  d     // IO: Pointer to tmFat32_Dev_t structure
    )
{
    tmErrorCode_t err = TM_OK;
    tmFat32_Sd_t  *p;

    TMFAT_DEBUG1("+tmFat32_Sd_Term(d=0x%x)\n", d);

    TMFAT_ASSERT (d != Null);

    p = &sd_device[d->unit];

    p->init_count--;
    p->connected = False;

    if (p->init_count == 0)
    {
        if( (err = tmdlSdStop(p->sdInstance)) != TM_OK )
            goto done;

        // Close internal (non-removable) devices
        if (0 == d->unit)
        {
            if( (err = tmdlSdClose(p->sdInstance)) != TM_OK )
                goto done;
        }
    }

done:
    TMFAT_DEBUG1("-tmFat32_Sd_Term() returning 0x%x\n", err);
    return err;
}

//-----------------------------------------------------------------------------
// External Functions:
//-----------------------------------------------------------------------------
//

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Sd_Install
//
// DESCRIPTION: Install Sd Card tmFat32 device driver
//
// RETURN:      Pointer ptmFat32_DeviceDriver_t. Return Null on failure.
//
// NOTES:
//-----------------------------------------------------------------------------
//

ptmFat32_DeviceDriver_t
tmFat32_Sd_Install (
    UInt32     unit   // I: Unit number, we support NUM_SD_CARD units
    )
{
    ptmFat32_DeviceDriver_t    p = Null;
    ptmFat32_Sd_t              d;

    TMFAT_DEBUG1("+tmFat32_Sd_Install(unit=%d)\n", unit);

    if (unit >= NUM_SD_CARD)
        goto bail;

    d = &sd_device[unit];

    if (!d->installed)
    {
        // Not installed.

        p = &d->driver;

        d->common.numUnits = NUM_SD_CARD;
        d->common.unit = unit;
        d->common.bytesPerSector = TMFAT_SD_SECTORSIZE; // should be set in different way
        d->common.type = tmFat32_SdDevice;
        d->common.removable = (Bool) (unit != 0);

        p->Info = (ptmFat32_Dev_t) &d->common;
        p->Init = tmFat32_Sd_Init;
        p->Term = tmFat32_Sd_Term;
        p->Read = tmFat32_Sd_Read_Sectors;
        p->Write = tmFat32_Sd_Write_Sectors;

        d->installed = True;
    }

bail:
    TMFAT_DEBUG1("-tmFat32_Sd_Install() returning 0x%X\n", p);

    return p;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Sd_Uninstall
//
// DESCRIPTION: Uninstall Sd Card tmFat32 device driver
//
// RETURN:      void
//
// NOTES:
//-----------------------------------------------------------------------------
//

void
tmFat32_Sd_Uninstall (
    ptmFat32_DeviceDriver_t     p   // IO: Pointer to tmFat32_DeviceDriver_t structure
    )
{
    UInt32  unit;
    ptmFat32_Sd_t              d;

    TMFAT_DEBUG1("+tmFat32_Sd_Uninstall(p=0x%x)\n", p);

    TMFAT_ASSERT (p != Null);
    unit = p->Info->unit;

    if (unit >= NUM_SD_CARD)
    {
        TMFAT_DEBUG2("-tmFat32_Sd_Uninstall() unit=%d >= NUM_SD_CARD=%d\n", unit, NUM_SD_CARD);
        return;
    }

    d = &sd_device[unit];

    if (d->installed && d->init_count == 0)
    {
        d->installed = False;
    }
    TMFAT_DEBUG0("-tmFat32_Sd_Uninstall()\n");
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Sd_GetInfo
//
// DESCRIPTION: Get information about the Sd Card tmFat32 device driver
//
// RETURN:      void
//
// NOTES:       Return numUnits (number of units supported). No other
//              fields are set.
//-----------------------------------------------------------------------------
//

void
tmFat32_Sd_GetInfo (
    ptmFat32_Dev_t     p   // IO: Pointer to tmFat32_Dev_t structure
    )
{
    TMFAT_ASSERT (p != Null);

    p->numUnits = NUM_SD_CARD;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Sd_Event
//
// DESCRIPTION: USB tmFat32 device event notification
//
// RETURN:      tmErrorCode_t: Status of operation (TM_OK = PASS)
//
// NOTES:       This function is called whenever an SD device is inserted
//              or removed. It must be called by the application after a device
//              is inserted but before the application mounts a tmFat32 file
//              system with tmFat32_Init() for this SD device. It should be
//              called by the application after a device is removed but before
//              the application dismounts a tmFat32 file system with
//              tmFat32_Term(). The function passes an array of UInt32 values
//              which contain the following information:
//
//              data[0]   Event (TM_FAT32_EVENT_INSERT or TM_FAT32_EVENT_EJECT).
//              data[1]   Unit number for the SD device. First unit is 0. The
//                        tmdlSd component assumes unit 0 is the internal device
//                        and unit 1 and higher are removable devices.
//                        The following are provided for an insert event only.
//              data[2]   tmdlSd instance.
//-----------------------------------------------------------------------------
//
tmErrorCode_t
tmFat32_Sd_Event (
    UInt32     *data   // I: Pointer to data describing the event
)
{
    tmFat32_Sd_t   *p;
    UInt32          event;
    UInt32          unit;
    tmErrorCode_t   err = TM_OK;

    TMFAT_ASSERT (data != Null);
    event = data[0];
    unit = data[1];
    TMFAT_ASSERT (unit < NUM_SD_CARD);

    // Ignore events for unit 0 (internal, non-removable unit)
    
    if (0 == unit)
        goto done;
    
    p = &sd_device[unit];

    if (event & TM_FAT32_EVENT_EJECT)
    {
//    	TMFAT_DEBUG2("SD unit %d disconnected for volume 0x%x.\n",
//    	              unit, p->driver.Info->vol);
        p->connected = False;
    }
    else if (event & TM_FAT32_EVENT_INSERT)
    {
        ptmdlSdInstanceSetup_t  ptmsdsetup;
        UInt64              maxLba;
        UInt32              bytesPerSector;
        tmInstance_t        sdInstance;

        sdInstance = data[2];

        if( (err = tmdlSdGetInstanceSetup(sdInstance, &ptmsdsetup )) != TM_OK )
        {
            TMFAT_DEBUG1("tmFat32_Sd_Event: tmdlSdGetInstanceSetup() failed, err=0x%X\n", err);
            goto done;
        }

        if( (err = tmdlSdInstanceSetup(sdInstance, ptmsdsetup )) != TM_OK )
        {
            TMFAT_DEBUG1("tmFat32_Sd_Event: tmdlSdInstanceSetup() failed, err=0x%X\n", err);
            goto done;
        }

        if( (err = tmdlSdStart(sdInstance)) != TM_OK )
        {
            TMFAT_DEBUG1("tmFat32_Sd_Event: tmdlSdStart() failed, err=0x%X\n", err);
            goto done;
        }

        if( (err = tmdlSdGetSectorInfo(sdInstance, &maxLba, &bytesPerSector)) == TM_OK)
        {
            p->sdInstance = sdInstance;
            p->common.devInstance = (UInt32) &p->sdInstance;
            p->common.lbaMax = maxLba - 1;
            p->common.bytesPerSector = bytesPerSector;
            p->connected = True;
//            TMFAT_DEBUG2("tmFat32_Sd_Event OK: bytesPerSector=%u,lbaMax=%llu\n", 
//                          p->common.bytesPerSector, p->common.lbaMax);
        }
        else
        {
            TMFAT_DEBUG1("tmFat32_Sd_Event: tmdlSdGetSectorInfo() failed, err=0x%X\n", err);
        }
    }
    else
    {
    	TMFAT_DEBUG1("tmFat32_Sd_Event: unknown event=0x%X.\n", event);
    	err = TM_FAT32_ERR_NOT_SUPPORTED;
    }
done:
    return err;
}