sdbus.cpp

6410BSP3

            }
        }
        else {
            dwErr = ERROR_INVALID_PARAMETER;
        }
        break;

      case IOCTL_SD_BUS_DRIVER_SLOT_CARD_SELECT:
        if (sizeof(DWORD) == dwLenIn && pBufIn) {
            DWORD dwSlotIndex = *(PDWORD)pBufIn;
            if (!SlotCardSelectDeselect(dwSlotIndex, SlotSelectRequest)) {
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
        else {
            dwErr = ERROR_INVALID_PARAMETER;
        }
        break;
        
      case IOCTL_SD_BUS_DRIVER_SLOT_CARD_DESELECT:
        if (sizeof(DWORD) == dwLenIn && pBufIn) {
            DWORD dwSlotIndex = *(PDWORD)pBufIn;
            if (!SlotCardSelectDeselect(dwSlotIndex, SlotDeselectRequest)) {
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
        else {
            dwErr = ERROR_INVALID_PARAMETER;
        }
        break;
 
      default:
        dwErr = ERROR_INVALID_PARAMETER;
        break;
    }

    if (cbActualOut != -1 && pdwActualOut && dwErr == ERROR_SUCCESS) {
        *pdwActualOut = cbActualOut;
    }

    DEBUGMSG(SDCARD_ZONE_FUNC, (TEXT("SDBusDriver: -SDC_IOControl 0x%X\n"), dwErr));
    if (dwErr != ERROR_SUCCESS) {
        SetLastError(dwErr);
        return FALSE;
    }
    else
        return TRUE;
}

CSDDevice * CSDHostContainer::GetDeviceByDevice(HANDLE hDevice)
{
    SDBUS_DEVICE_HANDLE deviceHandle;
    deviceHandle.hValue = hDevice;
    
    CSDDevice * pReturn = NULL;
    CSDHost *pHost = GetSDHost(deviceHandle.bit.sdBusIndex);
    if (hDevice!=NULL && deviceHandle.bit.sdF == 0xf) {
        if (pHost) {
            CSDSlot * pSlot = pHost->GetSlot(deviceHandle.bit.sdSlotIndex);
            if (pSlot) {
                pReturn = pSlot->GetFunctionDevice(deviceHandle.bit.sdFunctionIndex,deviceHandle.bit.sdRandamNumber);
                
            }
            pHost->DeRef();
        }
    }
    return pReturn;
}
CSDDevice * CSDHostContainer::GetDeviceByRequest(HANDLE hRequest)
{
    SDBUS_REQUEST_HANDLE requestHandle;
    requestHandle.hValue = hRequest;
    
    CSDDevice * pReturn = NULL;
    CSDHost *pHost = GetSDHost(requestHandle.bit.sdBusIndex);
    if (hRequest!=NULL && requestHandle.bit.sd1f == 0x1f) {
        if (pHost) {
            CSDSlot * pSlot = pHost->GetSlot(requestHandle.bit.sdSlotIndex);
            if (pSlot) {
                pReturn = pSlot->GetFunctionDevice(requestHandle.bit.sdFunctionIndex);                
            }
            pHost->DeRef();
        }
    }
    else
        ASSERT(FALSE);
    return pReturn;
}
BOOL 
CSDHostContainer::IOControl(DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,
                      PDWORD pdwActualOut)
{
    BOOL fRet = FALSE;

    switch (dwCode) {
    case IOCTL_BUS_TRANSLATE_BUS_ADDRESS:        
    case IOCTL_BUS_TRANSLATE_SYSTEM_ADDRESS:
    case IOCTL_BUS_ACTIVATE_CHILD:
    case IOCTL_BUS_DEACTIVATE_CHILD:
    case IOCTL_BUS_IS_CHILD_REMOVED:
    case IOCTL_BUS_GET_CONFIGURE_DATA:        
    case IOCTL_BUS_SET_CONFIGURE_DATA:
        SetLastError(ERROR_NOT_SUPPORTED);
        fRet = FALSE;
        break;
    case IOCTL_BUS_SD_SET_CARD_FEATURE:
        if (pBufIn && dwLenIn>=sizeof(IO_SD_SET_CARD_FEATURE) ) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_SET_CARD_FEATURE SdSetCardFeature = *(PIO_SD_SET_CARD_FEATURE) pBufIn;
            CSDDevice * pDevice = GetDeviceByDevice (SdSetCardFeature.hDevice);
            if (pDevice) {
                MarshalledBuffer_t UserBuffer((PVOID) SdSetCardFeature.pInBuf,SdSetCardFeature.nInBufSize,ARG_I_PTR, FALSE, FALSE);
                status = pDevice->SDSetCardFeature_I(SdSetCardFeature.CardFeature,UserBuffer.ptr(),SdSetCardFeature.nInBufSize) ;
                pDevice->DeRef();
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else 
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_READ_WRITE_REGISTERS_DIRECT: 
        if (pBufIn && dwLenIn>= sizeof(IO_SD_CARD_INFO_QUERY)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_READ_WRITE_REGISTERS_DIRECT ReadWriteRegisterDirect = *(PIO_SD_READ_WRITE_REGISTERS_DIRECT) pBufIn;
            CSDDevice * pDevice = GetDeviceByDevice(ReadWriteRegisterDirect.hDevice);
            if (pDevice) {
                DWORD dwArg = (ReadWriteRegisterDirect.ReadWrite==SD_IO_WRITE? ARG_I_PTR: ARG_O_PTR);
                if (ReadWriteRegisterDirect.ReadAfterWrite)
                    dwArg|= ARG_O_PTR ;
                MarshalledBuffer_t UserBuffer((PVOID)ReadWriteRegisterDirect.pBuffer,ReadWriteRegisterDirect.Length,dwArg,FALSE,FALSE);
                DEBUGMSG(SDCARD_ZONE_ERROR && (ReadWriteRegisterDirect.pBuffer!=NULL && UserBuffer.ptr()==0 ), 
                    (TEXT("IOCTL_BUS_SD_READ_WRITE_REGISTERS_DIRECT: Failed to marshal point 0x%x \n"),ReadWriteRegisterDirect.pBuffer));
                status = pDevice->SDReadWriteRegistersDirect_I(ReadWriteRegisterDirect.ReadWrite,
                            ReadWriteRegisterDirect.Address,ReadWriteRegisterDirect.ReadAfterWrite,
                            (PUCHAR)UserBuffer.ptr(),ReadWriteRegisterDirect.Length);
                pDevice->DeRef();
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else 
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;         
    case IOCTL_BUS_SD_REGISTER_CLIENT:
        if (pBufIn && dwLenIn>=sizeof(IO_SD_REGISTERCLIENTDEVICE)) {
            IO_SD_REGISTERCLIENTDEVICE RegisterClientDriver = *(PIO_SD_REGISTERCLIENTDEVICE) pBufIn;
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            CSDDevice * pDevice = GetDeviceByDevice(RegisterClientDriver.hDevice);
            if (pDevice) {
                status = pDevice->RegisterClient(RegisterClientDriver.hCallbackAPI,
                    RegisterClientDriver.pDeviceContext, &RegisterClientDriver.sdClientRegistrationInfo);
                if (status != SD_API_STATUS_SUCCESS) {
                    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDRegisterClient: Failed to register client 0x%08X \n"),status));
                }
                pDevice->DeRef();
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
            
        }
        else
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_SYNCHRONOUS_BUS_REQUEST:
        if (pBufIn && dwLenIn>= sizeof(IO_SD_SYNCHRONOUS_BUS_REQUEST)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_SYNCHRONOUS_BUS_REQUEST SdSyncBusRequest = *(PIO_SD_SYNCHRONOUS_BUS_REQUEST)pBufIn;
            SD_COMMAND_RESPONSE sdResponse;
            // Mapping Embedded pointer.
            CSDDevice * pDevice = GetDeviceByDevice(SdSyncBusRequest.hDevice);
            if (pDevice) {
                MarshalledBuffer_t UserBuffer((PVOID)SdSyncBusRequest.pBuffer,
                    SdSyncBusRequest.BlockSize* SdSyncBusRequest.NumBlocks,
                    SdSyncBusRequest.TransferClass==SD_READ ? ARG_O_PTR: ARG_I_PTR, FALSE, TRUE); // no duplicate and Async(because it could call BusRequest , read & write.            
                DEBUGMSG(SDCARD_ZONE_ERROR && (SdSyncBusRequest.pBuffer!=NULL && UserBuffer.ptr()==0 ), 
                    (TEXT("IOCTL_BUS_SD_SYNCHRONOUS_BUS_REQUEST: Failed to marshal point 0x%x \n"),SdSyncBusRequest.pBuffer));
                status =  pDevice->SDSynchronousBusRequest_I(
                    SdSyncBusRequest.Command,SdSyncBusRequest.Argument,
                    SdSyncBusRequest.TransferClass,SdSyncBusRequest.ResponseType,&sdResponse,
                    SdSyncBusRequest.NumBlocks,SdSyncBusRequest.BlockSize,(PUCHAR)UserBuffer.ptr(),
                    SdSyncBusRequest.Flags &~SD_BUS_REQUEST_PHYS_BUFFER, 0, NULL);
                if (pBufOut && dwLenOut>= sizeof(SD_COMMAND_RESPONSE)) { // Response can be optional.
                    *(PSD_COMMAND_RESPONSE)pBufOut = sdResponse ;
                }
                pDevice->DeRef();
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_BUS_REQUEST:
        if (pBufIn && dwLenIn>= sizeof(IO_SD_BUS_REQUEST) && pBufOut && dwLenOut>= sizeof(HANDLE)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_BUS_REQUEST SdBusRequest = *(PIO_SD_BUS_REQUEST)pBufIn;
            HANDLE hBusRequest = NULL ;
            // Mapping Embedded pointer.
            CSDDevice * pDevice = GetDeviceByDevice(SdBusRequest.hDevice);
            if (pDevice) {
                MarshalledBuffer_t UserBuffer((PVOID)SdBusRequest.pBuffer,
                    SdBusRequest.BlockSize* SdBusRequest.NumBlocks,
                    SdBusRequest.TransferClass==SD_READ ? ARG_O_PTR: ARG_I_PTR, FALSE,FALSE); // no duplicate and no Async , read & write.
                DEBUGMSG(SDCARD_ZONE_ERROR && (SdBusRequest.pBuffer!=NULL && UserBuffer.ptr()==0 ), 
                    (TEXT("IOCTL_BUS_SD_BUS_REQUEST: Failed to marshal point 0x%x \n"),SdBusRequest.pBuffer));
                ASSERT(pDevice->GetCallbackHandle()!= NULL);
                status =  pDevice->SDBusRequest_I(SdBusRequest.Command,SdBusRequest.Argument,
                    SdBusRequest.TransferClass,SdBusRequest.ResponseType,
                    SdBusRequest.NumBlocks,SdBusRequest.BlockSize,(PUCHAR)UserBuffer.ptr(),
                    SdBusRequest.ceDriverCallbackParam.pRequestCallback, SdBusRequest.ceDriverCallbackParam.dwRequestParam,
                    &hBusRequest,SdBusRequest.Flags & ~SD_BUS_REQUEST_PHYS_BUFFER, 0, NULL);
                pDevice->DeRef();
                * (HANDLE *)pBufOut  = hBusRequest ;
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_SYNCHRONOUS_BUS_REQUEST_EX:
        if (pBufIn && dwLenIn>= sizeof(IO_SD_SYNCHRONOUS_BUS_REQUEST_EX)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_SYNCHRONOUS_BUS_REQUEST_EX SdSyncBusRequest = *(PIO_SD_SYNCHRONOUS_BUS_REQUEST_EX)pBufIn;
            SD_COMMAND_RESPONSE sdResponse;
            // Mapping Embedded pointer.
            CSDDevice * pDevice = GetDeviceByDevice(SdSyncBusRequest.hDevice);
            if (pDevice) {
                MarshalledBuffer_t UserBuffer((PVOID)SdSyncBusRequest.pBuffer,
                    SdSyncBusRequest.BlockSize* SdSyncBusRequest.NumBlocks,
                    SdSyncBusRequest.TransferClass==SD_READ ? ARG_O_PTR: ARG_I_PTR, FALSE, TRUE); // no duplicate and Async(because it could call BusRequest , read & write.            
                MarshalledBuffer_t UserDmaBuffer (SdSyncBusRequest.pPhysBuffList,SdSyncBusRequest.cbSize,ARG_I_PTR,FALSE,FALSE);
                DEBUGMSG(SDCARD_ZONE_ERROR && (SdSyncBusRequest.pBuffer!=NULL && UserBuffer.ptr()==0 ), 
                    (TEXT("IOCTL_BUS_SD_SYNCHRONOUS_BUS_REQUEST: Failed to marshal point 0x%x \n"),SdSyncBusRequest.pBuffer));
                status =  pDevice->SDSynchronousBusRequest_I(
                    SdSyncBusRequest.Command,SdSyncBusRequest.Argument,
                    SdSyncBusRequest.TransferClass,SdSyncBusRequest.ResponseType,&sdResponse,
                    SdSyncBusRequest.NumBlocks,SdSyncBusRequest.BlockSize,(PUCHAR)UserBuffer.ptr(),
                    SdSyncBusRequest.Flags,SdSyncBusRequest.cbSize, (PPHYS_BUFF_LIST)UserDmaBuffer.ptr());
                if (pBufOut && dwLenOut>= sizeof(SD_COMMAND_RESPONSE)) { // Response can be optional.
                    *(PSD_COMMAND_RESPONSE)pBufOut = sdResponse ;
                }
                pDevice->DeRef();
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_BUS_REQUEST_EX:
        if (pBufIn && dwLenIn>= sizeof(IO_SD_BUS_REQUEST_EX) && pBufOut && dwLenOut>= sizeof(HANDLE)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            IO_SD_BUS_REQUEST_EX SdBusRequest = *(PIO_SD_BUS_REQUEST_EX)pBufIn;
            HANDLE hBusRequest = NULL ;
            // Mapping Embedded pointer.
            CSDDevice * pDevice = GetDeviceByDevice(SdBusRequest.hDevice);
            if (pDevice) {
                MarshalledBuffer_t UserBuffer((PVOID)SdBusRequest.pBuffer,
                    SdBusRequest.BlockSize* SdBusRequest.NumBlocks,
                    SdBusRequest.TransferClass==SD_READ ? ARG_O_PTR: ARG_I_PTR, FALSE,FALSE); // no duplicate and no Async , read & write.
                MarshalledBuffer_t UserDmaBuffer (SdBusRequest.pPhysBuffList,SdBusRequest.cbSize,ARG_I_PTR,FALSE,FALSE);
                    
                DEBUGMSG(SDCARD_ZONE_ERROR && (SdBusRequest.pBuffer!=NULL && UserBuffer.ptr()==0 ), 
                    (TEXT("IOCTL_BUS_SD_BUS_REQUEST: Failed to marshal point 0x%x \n"),SdBusRequest.pBuffer));
                ASSERT(pDevice->GetCallbackHandle()!= NULL);
                status =  pDevice->SDBusRequest_I(SdBusRequest.Command,SdBusRequest.Argument,
                    SdBusRequest.TransferClass,SdBusRequest.ResponseType,
                    SdBusRequest.NumBlocks,SdBusRequest.BlockSize,(PUCHAR)UserBuffer.ptr(),
                    SdBusRequest.ceDriverCallbackParam.pRequestCallback, SdBusRequest.ceDriverCallbackParam.dwRequestParam,
                    &hBusRequest,SdBusRequest.Flags,SdBusRequest.cbSize,(PPHYS_BUFF_LIST)UserDmaBuffer.ptr() );
                pDevice->DeRef();
                * (HANDLE *)pBufOut  = hBusRequest ;
            }
            SetLastError(status);
            fRet = SD_API_SUCCESS(status);
        }
        else
            SetLastError(SD_API_STATUS_INVALID_PARAMETER);
        break;
    case IOCTL_BUS_SD_FREE_BUS_REQUEST: 
        if (pBufIn && dwLenIn>= sizeof(HANDLE)) {
            HANDLE hRequest = *(HANDLE *)pBufIn;
            CSDDevice * pDevice =  GetDeviceByRequest(hRequest);
            if (pDevice) {
                pDevice->SDFreeBusRequest_I(hRequest );
                pDevice->DeRef();
                fRet = TRUE;
            }
        }
        break;
    case IOCTL_BUS_SD_REQUEST_RESPONSE: 
        if (pBufIn && dwLenIn>= sizeof(HANDLE) && pBufOut && dwLenOut>=sizeof(SD_COMMAND_RESPONSE)) {
            SD_API_STATUS status = SD_API_STATUS_INVALID_PARAMETER; 
            HANDLE hRequest = *(HANDLE *)pBufIn;
            SD_COMMAND_RESPONSE Response;
            CSDDevice * pDevice =  GetDeviceByRequest(hRequest);
            if (pDevice) {
                status = pDevice->SDBusRequestResponse_I(hRequest,&Response );
                pDevice->DeRef();
                if (SD_API_SUCCESS(status)) {
                    *(PSD_COMMAND_RESPONSE)pBufOut = Response;