cedriver.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_GET_STORAGEID Recieved an exception, probably due to bad output pointer.\r\n")));
                SetLastError(ERROR_INVALID_PARAMETER);
                retStatus = FALSE;
            }
            break;
        }
  
        case IOCTL_DISK_READ:               // Read / write sectors 
        case DISK_IOCTL_READ:
        case IOCTL_DISK_WRITE:
        case DISK_IOCTL_WRITE:
        {
            HANDLE hfolding = NULL;
            DWORD dwThreadID;
            DWORD expectedInSize = 0;

            DBGMSG(ZONE_RDWR, (TEXT("TrueFFS, IO: processing IOCTL_DISK_READ / IOCTL_DISK_WRITE operation.\r\n")));

            if (pInBuf == NULL ||
                dwInBufSize < sizeof (SG_REQ) + ((((PSG_REQ)pInBuf)->sr_num_sg - 1) * sizeof(SG_BUF)))
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                retStatus = FALSE;
                break;
            }
                
            try
            {
                if(dwIoControlCode == IOCTL_DISK_WRITE || 
                    dwIoControlCode == DISK_IOCTL_WRITE)
                { 
                    //If acumulated number of sectors exeeded limit, start folding thread
                    pDisk->totalSectorWrite+=((PSG_REQ)pInBuf)->sr_num_sec;
                    pDisk->sectorWriteSinceFolding += ((PSG_REQ)pInBuf)->sr_num_sec;
                    
                    if(pDisk->foldingResolution > 0 &&
                       pDisk->sectorWriteSinceFolding > pDisk->foldingResolution &&
                       pDisk->foldingThreadInProcess == FALSE) 
                    {
                      DBGMSG(ZONE_RDWR, (TEXT("TrueFFS, IO: IOCTL_DISK_WRITE exeeded folding resolution - launching folding thread.\r\n")));              
                      hfolding = CreateThread(NULL, 0, AutoFolding, pDisk, CREATE_SUSPENDED, &dwThreadID);
                      if(NULL != hfolding)
                      {
                          SetThreadPriority(hfolding,THREAD_PRIORITY_IDLE);
                          pDisk->foldingThreadInProcess = TRUE;
                          ResumeThread(hfolding);
                          CloseHandle(hfolding);                  
                      }
                    }
                }
                else
                {
                    pDisk->totalSectorRead+=((PSG_REQ)pInBuf)->sr_num_sec;
                }
                
                status = doDiskIo(pDisk, dwIoControlCode, (PSG_REQ)pInBuf, pBytesReturned);
                if(status != 0) 
                {
                    DBGMSG(ZONE_RDWR | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_READ / IOCTL_DISK_WRITE failed.\r\n")));
                    SetLastError(status);
                    retStatus = FALSE;
                }
                else
                {
                    DBGMSG(ZONE_RDWR, (TEXT("TrueFFS, IO: IOCTL_DISK_READ / IOCTL_DISK_WRITE ended successfully.\r\n")));
                    SetLastError(ERROR_SUCCESS);
                    retStatus = TRUE;
                }
            }
            except(EXCEPTION_EXECUTE_HANDLER)
            {
                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_READ / IOCTL_DISK_WRITE Recieved an exception, probably due to bad output pointer.\r\n")));
                SetLastError(ERROR_INVALID_PARAMETER);
                retStatus = FALSE;
            }

            break;
        }

        case DISK_IOCTL_GETINFO:
        case IOCTL_DISK_GETINFO:
        {
            if (dwInBufSize < sizeof (DISK_INFO) ||
                pInBuf == NULL)
            {
                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, checkCommandParams(): IOCTL_DISK_GETINFO Recieved bad parameters.\r\n")));
                SetLastError(ERROR_INVALID_PARAMETER);
                retStatus = FALSE;
                break;
            }

            try
            {
                if (0 == CeSafeCopyMemory((LPVOID)pInBuf, (LPVOID)&(pDisk->diskInfo), sizeof(DISK_INFO)))
                {
                    SetLastError (ERROR_INVALID_PARAMETER);
                    retStatus = FALSE;
                }
                else
                {
                    if (pBytesReturned)
                    {
                        *pBytesReturned = sizeof(DISK_INFO);          
                    }

                    retStatus = TRUE;
                    SetLastError(ERROR_SUCCESS);
                }
            }
            except(EXCEPTION_EXECUTE_HANDLER)
            {
                DBGMSG(ZONE_ERROR, (TEXT("TrueFFS, DSK_IOControl(): IOCTL_DISK_GETINFO Got exception, probably recieved invalid pointer.\r\n")));
                SetLastError (ERROR_INVALID_PARAMETER);
                retStatus = FALSE;
            }

            break;
        }

        case DISK_IOCTL_FORMAT_MEDIA:
        case IOCTL_DISK_FORMAT_MEDIA:
        {
            DBGMSG(ZONE_IO, (TEXT("TrueFFS, IO: processing IOCTL_DISK_FORMAT_MEDIA\r\n")));

            //delete all logical sectors 
            // 
            //dismount first
            ioreq.irHandle = BSP_MDOC_USERSTORE_PARTITION_HANDLE;
            flStatus = flOK;
            while (pDisk->numberOfMounts > 0 && flStatus == flOK)
            {
                flStatus = flDismountVolume(&ioreq);
                if (flStatus == flOK)
                {
                    pDisk->numberOfMounts--;
                }
            }

            //perform delete
            ioreq.irFlags = 0;
            ioreq.irPath = NULL;
            flStatus = flEraseBD(&ioreq);
            if(flStatus != flOK) 
            {
                // On unsuccessful format, attempt remounting the volume.
                // If this fails ignore mount status and refer to actual operation status (failed format).
                flStatus = flAbsMountVolume(&ioreq);
                if (flStatus == flOK)
                {
                    pDisk->numberOfMounts++;
                }

                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_FORMAT_MEDIA failed to erase BD partition. TrueFFS returned %d\r\n"), flStatus));
                SetLastError (statusTranslate(flStatus));
                retStatus = FALSE;
                break;
            }

            // Remount the volume on successful format
            flStatus = flAbsMountVolume(&ioreq);
            if(flStatus != flOK) 
            {
                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_FORMAT_MEDIA failed to mount. TrueFFS returned %d\r\n"), flStatus));
                SetLastError (statusTranslate(flStatus));
                retStatus = FALSE;
                break;
            }

            pDisk->numberOfMounts++;

            SetLastError(ERROR_SUCCESS);
            retStatus = TRUE;
            break;
        }

        case IOCTL_DISK_DELETE_SECTORS:
        {
            HANDLE hfolding = NULL;
            DWORD dwThreadID;
            PDELETE_SECTOR_INFO psds = (PDELETE_SECTOR_INFO)pInBuf;
            
            DBGMSG(ZONE_IO, (TEXT("TrueFFS, IO: processing IOCTL_DISK_DELETE_SECTORS\r\n")));

            if (dwInBufSize < sizeof (DELETE_SECTOR_INFO) || 
                pInBuf == NULL ||
                (psds->cbSize < sizeof (DELETE_SECTOR_INFO)))
            {
                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, checkCommandParams(): IOCTL_DISK_DELETE_SECTORS Recieved bad parameters.\r\n")));
                status = ERROR_INVALID_PARAMETER;
                break;
            }

            try
            {
                if (pBytesReturned != NULL)
                {
                    *pBytesReturned = 0;
                }

                DBGMSG(ZONE_IO && ZONE_DETAILS, (TEXT("TrueFFS, IO: IOCTL_DISK_DELETE_SECTORS, Sectors 0x%x - 0x%x\r\n"), 
                                          psds->startsector, psds->startsector+psds->numsectors-1));
                ioreq.irHandle = BSP_MDOC_USERSTORE_PARTITION_HANDLE;
                ioreq.irSectorNo = psds->startsector;
                ioreq.irSectorCount = psds->numsectors;

                flStatus = flAbsDelete(&ioreq);
                if(flStatus != flOK) 
                {
                    DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_DELETE_SECTORS failed. Recieved status %d from TrueFFS.\r\n"), flStatus));
                    SetLastError(statusTranslate(flStatus));
                    retStatus = FALSE;
                }
                else
                {
                    //Treat Deletes the same as writes for the purpose of folding intervals determination
                    // If acumulated number of sectors exeeded limit, start folding thread
                    pDisk->totalSectorWrite += psds->numsectors;
                    pDisk->sectorWriteSinceFolding += psds->numsectors;
                    
                    if(pDisk->foldingResolution > 0 &&
                       pDisk->sectorWriteSinceFolding > pDisk->foldingResolution &&
                       pDisk->foldingThreadInProcess == FALSE) 
                    {
                        DBGMSG(ZONE_RDWR, (TEXT("TrueFFS, IO: IOCTL_DISK_DELETE_SECTORS exeeded folding resolution - launching folding thread.\r\n")));              
                        hfolding = CreateThread(NULL, 0, AutoFolding, pDisk, CREATE_SUSPENDED, &dwThreadID);
                        if(NULL != hfolding)
                        {
                          SetThreadPriority(hfolding,THREAD_PRIORITY_IDLE);
                          pDisk->foldingThreadInProcess = TRUE;
                          ResumeThread(hfolding);
                          CloseHandle(hfolding);                  
                        }
                    }

                    SetLastError(ERROR_SUCCESS);
                    retStatus = TRUE;
                }
            }

            except(EXCEPTION_EXECUTE_HANDLER)
            {
                DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: IOCTL_DISK_DELETE_SECTORS got exception. Probably recieved bad pointer to input structure.\r\n")));
                retStatus = FALSE;
                SetLastError(ERROR_INVALID_PARAMETER);
            }

            break;
        }

        default:
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            DBGMSG(ZONE_IO | ZONE_ERROR, (TEXT("TrueFFS, IO: Recieved Invalid command code, returning FALSE, dwIoControlCode=0x%x\r\n"), dwIoControlCode));
            retStatus = FALSE;
            break;
        }
    }

Leave:
    LeaveCriticalSection(&pDisk->cs);
    return retStatus;
}



//----------------------------------------------------------------------------
// Function Name: DSK_Read                                                    
// Purpose......: Stub - this routine does nothing and actually - never called. 
// Returns......: 0                                                           
//----------------------------------------------------------------------------
DWORD DSK_Read(DWORD dwOpenContext, LPCVOID pBuf, DWORD len)
{
    DBGMSG(ZONE_IO, (TEXT("TrueFFS, DSK_Read() was called\r\n")));
    return 0;
}

//-----------------------------------------------------------------------------
// Function Name: DSK_Write                                                    
// Purpose......: Stub - this routine does nothing and actually - never called. 
// Returns......: 0                                                            
//-----------------------------------------------------------------------------
DWORD DSK_Write(DWORD dwOpenContext, LPCVOID pBuf, DWORD len)
{
    DBGMSG(ZONE_IO, (TEXT("TrueFFS, DSK_Write was called\r\n")));
    return 0;
}

//------------------------------------------------------------------------------
// Function Name: DSK_Seek                                                      
// Purpose......: Stub - this routine does nothing and actually - never called. 
// Returns......: 0                                                             
//------------------------------------------------------------------------------
DWORD DSK_Seek(DWORD dwOpenContext, long lDistance, WORD dwMoveMethod)
{
    DBGMSG(ZONE_IO, (TEXT("TrueFFS, DSK_Seek was called.\r\n")));
    return 0;
}