tmfat32usb.c

PNX1500上Fat32文件系统源代码

    TMFAT_ASSERT (d != Null);
    TMFAT_ASSERT (buffer != Null);

    if (sector + count > d->lbaMax + 1)
        return TM_FAT32_ERR_WRITE;

	r = &usb_device[d->unit];

    // If the driver is installed but the device is disconnected we may
    // be dismounting the file system. This could potentially issue write
    // operations which must be ignored.

    if (r->installed && !r->connected)
    {
        TMFAT_DEBUG2("tmFat32_Usb_Write_Sectors(sector=%llu,count=%d) while not connected.\n",
                      sector, count);
        return TM_OK;
    }

    if (d->eventNotify && (d->eventMask & TM_FAT32_EVENT_WRITE))
        d->eventNotify(d->vol, TM_FAT32_EVENT_WRITE);

    cmd.op = tmUsbIspHost_CmdMsWriteSectors;
    cmd.control[0] = r->uAppHandle;
    cmd.control[1] = r->LogUnitNo;
    cmd.control[4] = d->bytesPerSector;

    // We may not be cache-line aligned.

    if (r->manageCache && ((UInt32) buffer % TMFAT32_USB_CACHE_ALIGN))
    {
        pBuf = pScratchPad;

        while (count > 0)
        {
            nsec = count;
            if (nsec > SCRATCH_SECTORS)
                nsec = SCRATCH_SECTORS;

            memcpy(pBuf, buffer, nsec * d->bytesPerSector);
        	tmmlCacheFlush((void *)(pBuf), nsec * (d->bytesPerSector));

            cmd.control[2] = (UInt32) sector;
            cmd.control[3] = nsec;
            cmd.control[5] = (UInt32) pBuf;
            status = tmUsbIspHost_Command(&cmd);
        	if (status != 0)
        	{
        	    TMFAT_DEBUG1("tmFat32_Usb_Write_Sectors failed: 0x%X\n", status);
        	    return TM_FAT32_ERR_WRITE;
        	}

            sector += nsec;
            buffer += nsec * d->bytesPerSector;
            count -= nsec;
        }
    }
    else
    {
        if (r->manageCache)
        {
        	tmmlCacheFlush((void *)(buffer), count * (d->bytesPerSector));
    	}

    	cmd.control[2] = (UInt32) sector;
        cmd.control[3] = count;
        cmd.control[5] = (UInt32) buffer;
        status = tmUsbIspHost_Command(&cmd);
    	if (status != 0)
    	{
    	    TMFAT_DEBUG1("tmFat32_Usb_Write_Sectors failed: 0x%X\n", status);
    	    return TM_FAT32_ERR_READ;
    	}
    }

	return TM_OK;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Usb_Install
//
// DESCRIPTION: Install USB tmFat32 device driver
//
// RETURN:      Pointer ptmFat32_DeviceDriver_t. Return Null on failure.
//
// NOTES:       The device bytesPerSector must be set so the Init function
//              can read from the device.
//-----------------------------------------------------------------------------
//

ptmFat32_DeviceDriver_t
tmFat32_Usb_Install (
    UInt32     unit   // I: Unit number
    )
{
    ptmFat32_DeviceDriver_t     p = Null;
    ptmFat32_Usb_t              d;

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

    if (unit >= USB_MAX_UNITS)
        goto bail;

    d = &usb_device[unit];

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

        p = &d->driver;

        d->common.numUnits = USB_MAX_UNITS;
        d->common.unit = unit;
        d->common.type = tmFat32_UsbDevice;
        d->common.removable = True;
        d->manageCache = (Bool) (MANAGE_CACHE == 1);

        pScratchPad = (pVoid)(((UInt32)&myBuffer[0] / TMFAT32_USB_CACHE_ALIGN) *
                      TMFAT32_USB_CACHE_ALIGN + TMFAT32_USB_CACHE_ALIGN);

        p->Info = (ptmFat32_Dev_t) &d->common;
        p->Init = tmFat32_Usb_Init;
        p->Term = tmFat32_Usb_Term;
        p->Read = tmFat32_Usb_Read_Sectors;
        p->Write = tmFat32_Usb_Write_Sectors;

        d->installed = True;
    }
    else
    {
        // Already installed

        p = &d->driver;
    }

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

    return p;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Usb_Uninstall
//
// DESCRIPTION: Uninstall USB tmFat32 device driver
//
// RETURN:      void
//
// NOTES:
//-----------------------------------------------------------------------------
//

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

    TMFAT_DEBUG1("tmFat32_Usb_Uninstall(p=0x%X)\n", p);

    TMFAT_ASSERT (p != Null);

    unit = p->Info->unit;

    if (unit >= USB_MAX_UNITS)
        return;

    d = &usb_device[unit];
    if (d->installed && d->init_count == 0)
    {
        pScratchPad = Null;
        d->installed = False;
    }
}

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

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

    p->numUnits = USB_MAX_UNITS;
}

//-----------------------------------------------------------------------------
// FUNCTION:    tmFat32_Usb_Event
//
// DESCRIPTION: USB tmFat32 device event notification
//
// DESCRIPTION: USB tmFat32 device event notification
//
// NOTES:       This function is called whenever a USB 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 USB 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]   tmFat32 USB unit. First unit is 0.
//                        The following are provided for an insert event only,.
//              data[2]   USB device driver application handle.
//              data[3]   USB device driver logical unit number.
//              data[4]   Capacity, in sectors.
//              data[5]   Sector size, in bytes.
//-----------------------------------------------------------------------------
//
tmErrorCode_t
tmFat32_Usb_Event (
    UInt32     *data   // I: Pointer to data describing the event
)
{
    tmErrorCode_t   err = TM_OK;
    tmFat32_Usb_t  *p;
    UInt32          event;
    UInt32          unit;

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

    p = &usb_device[unit];

    if (event & TM_FAT32_EVENT_EJECT)
    {
    	TMFAT_DEBUG2("USB unit %d disconnected for volume 0x%x.\n",
    	              unit, p->driver.Info->vol);
        p->connected = False;
    }
    else if (event & TM_FAT32_EVENT_INSERT)
    {
    	TMFAT_DEBUG1("USB unit %d connected.\n", unit);
    	TMFAT_DEBUG1("uAppHandle=0x%X.\n", data[2]);
    	TMFAT_DEBUG1("LogUnitNo=0x%X.\n", data[3]);
    	TMFAT_DEBUG1("lbaMax=%d.\n", data[4] - 1);
    	TMFAT_DEBUG1("bytesPerSector=%d.\n", data[5]);
        p->uAppHandle = data[2];
        p->LogUnitNo = data[3];
        p->common.lbaMax = (UInt64) (data[4] - 1);
        p->common.bytesPerSector = data[5];
        p->connected = True;
    }
    else
    {
    	TMFAT_DEBUG1("tmFat32_Usb_Event: unknown event=0x%X.\n", event);
    	err = TM_FAT32_ERR_NOT_SUPPORTED;
    }
    return err;
}