void NvRmPrivIoPowerControlInit(NvRmDeviceHandle hRmDeviceHandle)
{
NvU32 i, v;
NvU32 NoIoPwrMask = 0;
const NvOdmPeripheralConnectivity* pPmuRail = NULL;
if (NvRmPrivGetExecPlatform(hRmDeviceHandle) != ExecPlatform_Soc)
{
// Invalidate IO Power detect map if not SoC platform
for (i = 0; i < NV_ARRAY_SIZE(s_IoPowerDetectMap); i++)
s_IoPowerDetectMap[i].PmuRailAddress = NV_RAIL_ADDR_INVALID;
return;
}
for (i = 0; i < NV_ARRAY_SIZE(s_IoPowerDetectMap); i++)
{
// Fill in PMU rail addresses in IO Power detect map
pPmuRail = NvOdmPeripheralGetGuid(s_IoPowerDetectMap[i].PowerRailId);
NV_ASSERT(pPmuRail && pPmuRail->NumAddress);
s_IoPowerDetectMap[i].PmuRailAddress = pPmuRail->AddressList[0].Address;
// Find all unpowered rails
v = NvRmPrivPmuRailGetVoltage(
hRmDeviceHandle, s_IoPowerDetectMap[i].PowerRailId);
if (v == ODM_VOLTAGE_OFF)
NoIoPwrMask |= s_IoPowerDetectMap[i].DisableRailMask;
}
// Latch already powered IO rails
NvRmPrivIoPowerDetectLatch(hRmDeviceHandle);
// Disable IO pads for unpowered rails
if (NoIoPwrMask)
NvRmPrivIoPowerControl(hRmDeviceHandle, NoIoPwrMask, NV_FALSE);
}
const NvOdmQueryDapPortConnection*
NvOdmQueryDapPortGetConnectionTable(
NvU32 ConnectionIndex)
{
static const NvOdmQueryDapPortConnection s_Property[] =
{
{ NvOdmDapConnectionIndex_Music_Path,
2, { {NvOdmDapPort_I2s1, NvOdmDapPort_Dap1, NV_FALSE},
{NvOdmDapPort_Dap1, NvOdmDapPort_I2s1, NV_TRUE} } },
};
static const NvOdmQueryDapPortConnection s_Property_Ril_Emp_Rainbow[] =
{
{ NvOdmDapConnectionIndex_Music_Path,
2, { {NvOdmDapPort_I2s1, NvOdmDapPort_Dap1, NV_FALSE},
{NvOdmDapPort_Dap1, NvOdmDapPort_I2s1, NV_TRUE} } },
// Voicecall without Bluetooth
{ NvOdmDapConnectionIndex_VoiceCall_NoBlueTooth,
2, { {NvOdmDapPort_Dap3, NvOdmDapPort_Dap2, NV_FALSE},
{NvOdmDapPort_Dap2, NvOdmDapPort_Dap3, NV_TRUE} } },
// Voicecall with Bluetooth
{ NvOdmDapConnectionIndex_VoiceCall_WithBlueTooth,
2, { {NvOdmDapPort_Dap4, NvOdmDapPort_Dap3, NV_TRUE},
{NvOdmDapPort_Dap3, NvOdmDapPort_Dap4, NV_FALSE}
}},
};
NvU32 TableIndex = 0;
NvU32 CustOpt = GetBctKeyValue();
switch (NV_DRF_VAL(TEGRA_DEVKIT, BCT_CUSTOPT, RIL, CustOpt))
{
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_EMP_RAINBOW:
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_EMP_RAINBOW_ULPI:
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_IFX:
{
for( TableIndex = 0;
TableIndex < NV_ARRAY_SIZE(s_Property_Ril_Emp_Rainbow); TableIndex++)
{
if (s_Property_Ril_Emp_Rainbow[TableIndex].UseIndex == ConnectionIndex)
return &s_Property_Ril_Emp_Rainbow[TableIndex];
}
}
break;
default:
{
for( TableIndex = 0; TableIndex < NV_ARRAY_SIZE(s_Property); TableIndex++)
{
if (s_Property[TableIndex].UseIndex == ConnectionIndex)
return &s_Property[TableIndex];
}
}
break;
}
return NULL;
}
const NvOdmQueryDapPortProperty *
NvOdmQueryDapPortGetProperty(
NvU32 DapPortId)
{
static const NvOdmQueryDapPortProperty s_Property[] =
{
{ NvOdmDapPort_None, NvOdmDapPort_None, { 0, 0, 0, 0 } },
// I2S1 (DAC1) <-> DAP1 <-> HIFICODEC
{ NvOdmDapPort_I2s1, NvOdmDapPort_HifiCodecType,
{ 2, 16, 44100, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap1
// I2S2 (DAC2) <-> DAP2 <-> VOICECODEC
{ NvOdmDapPort_I2s2, NvOdmDapPort_VoiceCodecType,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap2
};
static const NvOdmQueryDapPortProperty s_Property_Ril_Emp_Rainbow[] =
{
{ NvOdmDapPort_None, NvOdmDapPort_None, { 0, 0, 0, 0 } },
// I2S1 (DAC1) <-> DAP1 <-> HIFICODEC
{ NvOdmDapPort_I2s1, NvOdmDapPort_HifiCodecType,
{ 2, 16, 44100, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap1
// I2S2 (DAC2) <-> DAP2 <-> VOICECODEC
{ NvOdmDapPort_I2s2, NvOdmDapPort_VoiceCodecType,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap2
// I2S2 (DAC2) <-> DAP3 <-> BASEBAND
{ NvOdmDapPort_I2s2, NvOdmDapPort_BaseBand,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap3
// I2S2 (DAC2) <-> DAP4 <-> BLUETOOTH
{ NvOdmDapPort_I2s2, NvOdmDapPort_BlueTooth,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S }
}, // Dap4
};
NvU32 CustOpt = GetBctKeyValue();
switch (NV_DRF_VAL(TEGRA_DEVKIT, BCT_CUSTOPT, RIL, CustOpt))
{
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_EMP_RAINBOW:
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_EMP_RAINBOW_ULPI:
case TEGRA_DEVKIT_BCT_CUSTOPT_0_RIL_IFX:
if (DapPortId && DapPortId<NV_ARRAY_SIZE(s_Property_Ril_Emp_Rainbow))
return &s_Property_Ril_Emp_Rainbow[DapPortId];
break;
default:
if (DapPortId && DapPortId<NV_ARRAY_SIZE(s_Property))
return &s_Property[DapPortId];
break;
}
return NULL;
}
const NvOdmUsbProperty *NvOdmQueryGetUsbProperty(
NvOdmIoModule Module,
NvU32 Instance)
{
static const NvOdmUsbProperty usb[] =
{
{
NvOdmUsbInterfaceType_Utmi,
(NvOdmUsbChargerType_SE0 | NvOdmUsbChargerType_SE1 |
NvOdmUsbChargerType_SK),
20, NV_TRUE, NvOdmUsbModeType_Device, NvOdmUsbIdPinType_CableId,
NvOdmUsbConnectorsMuxType_None, NV_TRUE, { 0, 0, 0, 0 }
},
{
NvOdmUsbInterfaceType_UlpiExternalPhy,
NvOdmUsbChargerType_UsbHost,
20, NV_TRUE, NvOdmUsbModeType_Host, NvOdmUsbIdPinType_None,
NvOdmUsbConnectorsMuxType_None, NV_TRUE, { 0, 0, 0, 0 }
},
{
NvOdmUsbInterfaceType_Utmi,
NvOdmUsbChargerType_UsbHost,
20, NV_TRUE, NvOdmUsbModeType_Host, NvOdmUsbIdPinType_None,
NvOdmUsbConnectorsMuxType_None, NV_TRUE, { 0, 0, 0, 0 }
},
};
if (Module != NvOdmIoModule_Usb || Instance >= NV_ARRAY_SIZE(usb))
return NULL;
return &usb[Instance];
}
const NvOdmQueryDapPortConnection*
NvOdmQueryDapPortGetConnectionTable(
NvU32 ConnectionIndex)
{
static const NvOdmQueryDapPortConnection s_Property[] =
{
{ NvOdmDapConnectionIndex_Music_Path,
2, { {NvOdmDapPort_I2s1, NvOdmDapPort_Dap1, NV_TRUE},
{NvOdmDapPort_Dap1, NvOdmDapPort_I2s1, NV_FALSE} } },
// Voicecall without Bluetooth
{ NvOdmDapConnectionIndex_VoiceCall_NoBlueTooth,
3, { {NvOdmDapPort_Dap3, NvOdmDapPort_Dap2, NV_TRUE},
{NvOdmDapPort_Dap2, NvOdmDapPort_Dap3, NV_FALSE},
{NvOdmDapPort_Dap2, NvOdmDapPort_I2s2, NV_FALSE} } },
// Voicecall with Bluetooth
{ NvOdmDapConnectionIndex_VoiceCall_WithBlueTooth,
2, { {NvOdmDapPort_Dap4, NvOdmDapPort_Dap3, NV_TRUE},
{NvOdmDapPort_Dap3, NvOdmDapPort_Dap4, NV_FALSE}
}},
};
NvU32 TableIndex = 0;
for( TableIndex = 0; TableIndex < NV_ARRAY_SIZE(s_Property); TableIndex++)
{
if (s_Property[TableIndex].UseIndex == ConnectionIndex)
return &s_Property[TableIndex];
}
return NULL;
}
const NvOdmQueryDapPortConnection *NvOdmQueryDapPortGetConnectionTable(
NvU32 Index)
{
static const NvOdmQueryDapPortConnection connect[] =
{
// the Default Music Path
{
NvOdmDapConnectionIndex_Music_Path, 2,
{
{ NvOdmDapPort_I2s1, NvOdmDapPort_Dap1, NV_TRUE },
{ NvOdmDapPort_Dap1, NvOdmDapPort_I2s1, NV_FALSE }
}
},
// Bluetooth to Codec
{
NvOdmDapConnectionIndex_BlueTooth_Codec, 3,
{
{ NvOdmDapPort_Dap4, NvOdmDapPort_I2s1, NV_TRUE },
{ NvOdmDapPort_I2s1, NvOdmDapPort_Dap4, NV_FALSE },
{ NvOdmDapPort_I2s2, NvOdmDapPort_Dap1, NV_FALSE }
}
}
};
NvU32 i = 0;
for(i = 0; i < NV_ARRAY_SIZE(connect); i++)
{
if (connect[i].UseIndex == Index)
return &connect[i];
}
return NULL;
}
const NvOdmQueryDapPortProperty *NvOdmQueryDapPortGetProperty(NvU32 Instance)
{
static const NvOdmQueryDapPortProperty dap[] =
{
{ NvOdmDapPort_None, NvOdmDapPort_None , {0, 0, 0, 0} }, // Reserved
// I2S1 (DAC1) <-> DAP1 <-> HIFICODEC
{
NvOdmDapPort_I2s1, NvOdmDapPort_HifiCodecType,
{ 2, 16, 44100, NvOdmQueryI2sDataCommFormat_I2S }
},
{ NvOdmDapPort_None, NvOdmDapPort_None , {0, 0, 0, 0} }, // Dap2
{ NvOdmDapPort_None, NvOdmDapPort_None , {0, 0, 0, 0} }, // Dap3
// I2S2 (DAC2) <-> DAP4 <-> BLUETOOTH
{
NvOdmDapPort_I2s2, NvOdmDapPort_BlueTooth,
{ 2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S }
}
};
if (Instance && Instance<NV_ARRAY_SIZE(dap))
return &dap[Instance];
return NULL;
}
NvBool NvOdmMouseEnableInterrupt(
NvOdmMouseDeviceHandle hDevice,
NvOdmOsSemaphoreHandle hInterruptSemaphore)
{
NvError Status = NvSuccess;
NvEcEventType EventTypes[] = {
(NvEcEventType) (NvEcEventType_AuxDevice0 + MOUSE_PS2_PORT_ID_0),
(NvEcEventType) (NvEcEventType_AuxDevice0 + MOUSE_PS2_PORT_ID_1)
};
Status = NvEcRegisterForEvents(
hDevice->hEc,
&hDevice->hEcEventRegister,
(NvOsSemaphoreHandle)hInterruptSemaphore,
NV_ARRAY_SIZE(EventTypes), // number of EventType's
EventTypes, // Auxillary 0 event
1, // One event packet is expected
// event packet size = packet overhead + size of the mouse sample;
// max sample size is 4 bytes (for an Intellimouse 5-button mouse)
NVEC_MIN_EVENT_SIZE+4);
if (Status != NvSuccess)
return NV_FALSE;
return NV_TRUE;
}
const NvOdmWakeupPadInfo *NvOdmQueryGetWakeupPadTable(NvU32 *pSize)
{
if (pSize)
*pSize = NV_ARRAY_SIZE(s_NvOdmWakeupPadInfo);
return (const NvOdmWakeupPadInfo *) s_NvOdmWakeupPadInfo;
}
NvU32
NvOdmKbcKeyMappingGetVirtualKeyMappingList(
const struct NvOdmKeyVirtTableDetail ***pVirtKeyTableList)
{
*pVirtKeyTableList = s_pVirtualKeyTables;
return NV_ARRAY_SIZE(s_pVirtualKeyTables);
}
const NvOdmQueryDapPortProperty *
NvOdmQueryDapPortGetProperty(
NvU32 DapPortId)
{
static const NvOdmQueryDapPortProperty s_Property[] =
{
{ NvOdmDapPort_None, NvOdmDapPort_None, { 0, 0, 0, 0 } },
// I2S1 (DAC1) <-> DAP1 <-> HIFICODEC
{ NvOdmDapPort_I2s1, NvOdmDapPort_HifiCodecType,
{ 2, 16, 44100, NvOdmQueryI2sDataCommFormat_I2S } }, // Dap1
// I2S2 (DAC2) <-> DAP2 <-> VOICECODEC
{NvOdmDapPort_I2s2, NvOdmDapPort_VoiceCodecType,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_Dsp } }, // Dap2
// I2S2 (DAC2) <-> DAP3 <-> BASEBAND
{NvOdmDapPort_I2s2, NvOdmDapPort_BaseBand,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S } }, // Dap3
// I2S2 (DAC2) <-> DAP4 <-> BLUETOOTH
{NvOdmDapPort_I2s2, NvOdmDapPort_BlueTooth,
{2, 16, 8000, NvOdmQueryI2sDataCommFormat_I2S } }, // Dap4
};
if (DapPortId && DapPortId<NV_ARRAY_SIZE(s_Property))
return &s_Property[DapPortId];
return NULL;
}
const NvOdmQueryDapPortProperty *
NvOdmQueryDapPortGetProperty(
NvU32 DapPortId)
{
if (DapPortId > 0 && DapPortId < NV_ARRAY_SIZE(s_NvOdmQueryDapPortInfoTable) )
return &s_NvOdmQueryDapPortInfoTable[DapPortId];
return NULL;
}
NvU32
NvOdmQueryPinAttributes(const NvOdmPinAttrib** pPinAttributes)
{
if (pPinAttributes)
{
*pPinAttributes = &pin_config[0];
return NV_ARRAY_SIZE(pin_config);
}
return 0;
}
void
Adt7461ParameterCapsGet(
NvOdmTmonDeviceHandle hTmon,
NvOdmTmonZoneID ZoneId,
NvOdmTmonConfigParam ParamId,
NvOdmTmonParameterCaps* pCaps)
{
NvBool ExtRange;
ADT7461PrivData* pPrivData;
const ADT7461ChannelInfo* pChannel;
NV_ASSERT(hTmon && hTmon->pPrivate && pCaps);
pPrivData = hTmon->pPrivate;
#if PRE_ER_GMT_THERMALSENSOR
ExtRange = 0; /* not support ADT thermal sensor*/
#else
ExtRange = ((pPrivData->ShadowConfig &
ADT7461ConfigBits_ExtendedRange) != 0);
#endif
pChannel = &pPrivData->pDeviceInfo->Channels[(
pPrivData->ConnectivityMap[ZoneId])];
switch (ParamId)
{
case NvOdmTmonConfigParam_IntrLimitHigh:
case NvOdmTmonConfigParam_IntrLimitLow:
pCaps->OdmProtected =
pChannel->ChannelPolicy.IntrLimitsOdmProtected;
break;
case NvOdmTmonConfigParam_HwLimitCrit:
pCaps->OdmProtected =
pChannel->ChannelPolicy.HwLimitCritOdmProtected;
break;
case NvOdmTmonConfigParam_SampleMs:
// smaple intervals in descending order
pCaps->MaxValue = s_Adt7461SampleIntervalsMS[0];
pCaps->MinValue = s_Adt7461SampleIntervalsMS[(
NV_ARRAY_SIZE(s_Adt7461SampleIntervalsMS) - 1)];
pCaps->OdmProtected = pChannel->ChannelPolicy.RateOdmProtected;
return;
default: // unsupported parameter
pCaps->MaxValue = ODM_TMON_PARAMETER_UNSPECIFIED;
pCaps->MinValue = ODM_TMON_PARAMETER_UNSPECIFIED;
pCaps->OdmProtected = NV_TRUE;
return;
}
// Common range for limits
pCaps->MaxValue = ADT7461_T_RANGE_LIMIT_HIGH(ExtRange);
pCaps->MinValue = ADT7461_T_RANGE_LIMIT_LOW(ExtRange);
}
NvU32
NvOdmKbcKeyMappingGetVirtualKeyMappingList(
const struct NvOdmKeyVirtTableDetail ***pVirtKeyTableList)
{
if (HWREV_REV(system_rev) <= HWREV_REV_1C)
s_ScvkKeyMap.pVirtualKeyTable = KbcLayOutVirtualKey_P1C;
*pVirtKeyTableList = s_pVirtualKeyTables;
return NV_ARRAY_SIZE(s_pVirtualKeyTables);
}
static NvBool
Adt7461ConfigureSampleInterval(
ADT7461PrivData* pPrivData,
NvBool OdmProtected,
NvS32* pTargetMs)
{
NvU8 i;
NvS32 Delta;
const ADT7461RegisterInfo* pReg = &pPrivData->pDeviceInfo->Rate;
if (OdmProtected ||
((*pTargetMs) == ODM_TMON_PARAMETER_UNSPECIFIED))
{
// Read ADT7461 rate register (fail the call if returned data
// does not make sense)
if(!Adt7461ReadReg(pPrivData, pReg, &i))
return NV_FALSE;
if (i >= NV_ARRAY_SIZE(s_Adt7461SampleIntervalsMS))
return NV_FALSE;
}
else
{
// Find and set the best floor approximation of the target sample
// interval. Note the descending order of sample intervals array.
for (i = 0; i < NV_ARRAY_SIZE(s_Adt7461SampleIntervalsMS); i++)
{
Delta = (*pTargetMs) - s_Adt7461SampleIntervalsMS[i];
if(Delta >= 0)
break;
}
if (i == NV_ARRAY_SIZE(s_Adt7461SampleIntervalsMS))
i--; // min interval is the best we can do
if(!Adt7461WriteReg(pPrivData, pReg, i))
return NV_FALSE;
pPrivData->ShadowRate = i;
}
*pTargetMs = s_Adt7461SampleIntervalsMS[i];
return NV_TRUE;
}
const NvOdmGpioPinInfo *NvOdmQueryGpioPinMap(NvOdmGpioPinGroup Group,
NvU32 Instance, NvU32 *pCount)
{
switch (Group)
{
case NvOdmGpioPinGroup_Display:
*pCount = NV_ARRAY_SIZE(s_display);
return s_display;
case NvOdmGpioPinGroup_Hdmi:
*pCount = NV_ARRAY_SIZE(s_hdmi);
return s_hdmi;
case NvOdmGpioPinGroup_Sdio:
if (Instance == 2)
{
*pCount = NV_ARRAY_SIZE(s_sdio);
return s_sdio;
}
else
{
*pCount = 0;
return NULL;
}
case NvOdmGpioPinGroup_Bluetooth:
*pCount = NV_ARRAY_SIZE(s_Bluetooth);
return s_Bluetooth;
case NvOdmGpioPinGroup_Wlan:
*pCount = NV_ARRAY_SIZE(s_Wlan);
return s_Wlan;
case NvOdmGpioPinGroup_Vi:
*pCount = NV_ARRAY_SIZE(s_vi);
return s_vi;
case NvOdmGpioPinGroup_keypadMisc:
*pCount = NV_ARRAY_SIZE(s_GpioKeyBoard);
return s_GpioKeyBoard;
case NvOdmGpioPinGroup_Battery:
*pCount = NV_ARRAY_SIZE(s_Battery);
return s_Battery;
default:
*pCount = 0;
return NULL;
}
}
NvBool NvOdmIsCpuExtSupply(void)
{
// A list of Whistler processor boards that use external DCDC as CPU
// power supply (fill in ID/SKU/FAB fields, revision fields are ignored)
static const NvOdmBoardInfo s_WhistlerCpuExtSupplyBoards[] =
{
// ID SKU FAB Rev Minor Rev
{ BOARD_ID_WHISTLER_E1108, 0x0A14, 0x01, BOARD_REV_ALL, BOARD_REV_ALL},
{ BOARD_ID_WHISTLER_E1108, 0x0A00, 0x02, BOARD_REV_ALL, BOARD_REV_ALL}
};
return NvOdmIsBoardPresent(s_WhistlerCpuExtSupplyBoards,
NV_ARRAY_SIZE(s_WhistlerCpuExtSupplyBoards));
}
static NvBool NvOdmIsE1108Elpida(void)
{
// A list of Whistler E1108 processor boards with Elpida LPDDR2
// charcterized by s_NvOdmE1108ElpidaEmcConfigTable (fill in
// ID/SKU/FAB fields, revision fields are ignored)
static const NvOdmBoardInfo s_WhistlerE1108Elpida[] =
{
// ID SKU FAB Rev Minor Rev
{ BOARD_ID_WHISTLER_E1108, 0x0D00, 0x03, BOARD_REV_ALL, BOARD_REV_ALL}
};
return NvOdmIsBoardPresent(s_WhistlerE1108Elpida,
NV_ARRAY_SIZE(s_WhistlerE1108Elpida));
}
const void*
NvOdmQuerySdramControllerConfigGet(NvU32 *pEntries, NvU32 *pRevision)
{
#if NVODM_ENABLE_EMC_DVFS
if (pRevision)
*pRevision = s_NvOdmStarSmartphoneHynixEmcConfigTable[0].Revision;
if (pEntries)
*pEntries = NV_ARRAY_SIZE(s_NvOdmStarSmartphoneHynixEmcConfigTable);
return (const void*)s_NvOdmStarSmartphoneHynixEmcConfigTable;
#endif
if (pEntries)
*pEntries = 0;
return NULL;
}
const NvOdmQueryDapPortConnection*
NvOdmQueryDapPortGetConnectionTable(
NvU32 ConnectionIndex)
{
NvU32 TableIndex = 0;
for( TableIndex = 0;
TableIndex < NV_ARRAY_SIZE(s_NvOdmQueryDapPortConnectionTable);
TableIndex++)
{
if (s_NvOdmQueryDapPortConnectionTable[TableIndex].UseIndex
== ConnectionIndex)
return &s_NvOdmQueryDapPortConnectionTable[TableIndex];
}
return NULL;
}
static NvBool NvOdmIsE1108Hynix(void)
{
// A list of Whistler E1108 processor boards with Hynix LPDDR2
// charcterized by s_NvOdmE1108HynixEmcConfigTable (fill in
// ID/SKU/FAB fields, revision fields are ignored)
static const NvOdmBoardInfo s_WhistlerE1108Hynix[] =
{
// ID SKU FAB Rev Minor Rev
{ BOARD_ID_WHISTLER_E1108, 0x0A14, 0x01, BOARD_REV_ALL, BOARD_REV_ALL},
{ BOARD_ID_WHISTLER_E1108, 0x0A1E, 0x01, BOARD_REV_ALL, BOARD_REV_ALL},
{ BOARD_ID_WHISTLER_E1108, 0x0A00, 0x02, BOARD_REV_ALL, BOARD_REV_ALL},
{ BOARD_ID_WHISTLER_E1108, 0x0A0A, 0x02, BOARD_REV_ALL, BOARD_REV_ALL}
};
return NvOdmIsBoardPresent(s_WhistlerE1108Hynix,
NV_ARRAY_SIZE(s_WhistlerE1108Hynix));
}
const NvOdmQuerySdioInterfaceProperty* NvOdmQueryGetSdioInterfaceProperty(
NvU32 Instance)
{
static const NvOdmQuerySdioInterfaceProperty sdio[] =
{
{ NV_FALSE, 10, NV_TRUE, 0x8, NvOdmQuerySdioSlotUsage_wlan },
{ NV_FALSE, 0, NV_FALSE, 0, NvOdmQuerySdioSlotUsage_unused },
{ NV_TRUE, 0, NV_FALSE, 0x6, NvOdmQuerySdioSlotUsage_Media },
{ NV_FALSE, 0, NV_FALSE, 0x4, NvOdmQuerySdioSlotUsage_Boot },
};
if (Instance < NV_ARRAY_SIZE(sdio))
return &sdio[Instance];
return NULL;
}
const NvOdmQuerySpiIdleSignalState *NvOdmQuerySpiGetIdleSignalState(
NvOdmIoModule Module,
NvU32 Instance)
{
static const NvOdmQuerySpiIdleSignalState spi[] =
{
{ NV_FALSE, NvOdmQuerySpiSignalMode_0, NV_FALSE },
};
if (Module != NvOdmIoModule_Spi)
return NULL;
if (Instance >= NV_ARRAY_SIZE(spi))
return NULL;
return &spi[Instance];
}
const NvOdmQueryI2sACodecInterfaceProp *NvOdmQueryGetI2sACodecInterfaceProperty(
NvU32 Instance)
{
static const NvOdmQueryI2sACodecInterfaceProp i2s_codec[] =
{
{
NV_FALSE, 0, 0x36, NV_FALSE,
NvOdmQueryI2sLRLineControl_LeftOnLow,
NvOdmQueryI2sDataCommFormat_I2S
},
};
if (Instance < NV_ARRAY_SIZE(i2s_codec))
return &i2s_codec[Instance];
return NULL;
}
static void
UsbPhyOpenHwInterface(
NvDdkUsbPhyHandle hUsbPhy)
{
static NvDdkUsbPhyCapabilities s_UsbPhyCap[] =
{
// AP15
{ NV_FALSE, NV_FALSE },
// AP16
{ NV_FALSE, NV_TRUE },
// AP20
{ NV_TRUE, NV_FALSE},
};
NvDdkUsbPhyCapabilities *pUsbfCap = NULL;
NvRmModuleCapability s_UsbPhyCaps[] =
{
{1, 0, 0, &s_UsbPhyCap[0]}, // AP15 A01
{1, 1, 0, &s_UsbPhyCap[0]}, // AP15 A02
{1, 2, 0, &s_UsbPhyCap[1]}, // AP16, USB1
{1, 3, 0, &s_UsbPhyCap[1]}, // AP16, USB2
{1, 5, 0, &s_UsbPhyCap[2]}, // AP20, USB1
{1, 6, 0, &s_UsbPhyCap[2]}, // AP20, USB2
{1, 7, 0, &s_UsbPhyCap[2]}, // AP20, USB3
};
NV_ASSERT_SUCCESS(
NvRmModuleGetCapabilities(hUsbPhy->hRmDevice,
NVRM_MODULE_ID(NvRmModuleID_Usb2Otg, hUsbPhy->Instance),
s_UsbPhyCaps, NV_ARRAY_SIZE(s_UsbPhyCaps),
(void**)&pUsbfCap));
// Fill the client capabilities structure.
NvOsMemcpy(&hUsbPhy->Caps, pUsbfCap, sizeof(NvDdkUsbPhyCapabilities));
//NvOsDebugPrintf("NvDdkUsbPhyCapabilities::\n");
//NvOsDebugPrintf("PhyRegInController::[%d] 0-FALSE 1-TRUE\n", hUsbPhy->Caps.PhyRegInController);
//NvOsDebugPrintf("CommonClockAndReset::[%d] 0-FALSE 1-TRUE\n", hUsbPhy->Caps.CommonClockAndReset);
if (hUsbPhy->Caps.PhyRegInController)
{
//NvOsDebugPrintf("AP20 USB Controllers\n");
Ap20UsbPhyOpenHwInterface(hUsbPhy);
}
}
static void IoPowerMapRail(
NvU32 PmuRailAddress,
NvU32* pIoPwrDetectMask,
NvU32* pNoIoPwrMask)
{
NvU32 i;
*pIoPwrDetectMask = 0;
*pNoIoPwrMask = 0;
// Find all power detect cells and controls on this IO rail
for (i = 0; i < NV_ARRAY_SIZE(s_IoPowerDetectMap); i++)
{
if (s_IoPowerDetectMap[i].PmuRailAddress == PmuRailAddress)
{
*pIoPwrDetectMask |= s_IoPowerDetectMap[i].EnablePwrDetMask;
*pNoIoPwrMask |= s_IoPowerDetectMap[i].DisableRailMask;
}
}
}
NvError NvRm_Dispatch_Others( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
{
NvU32 packid_;
NvU32 funcid_;
NvIdlDispatchTable *table_;
NV_ASSERT( InBuffer );
NV_ASSERT( OutBuffer );
packid_ = ((NvU32 *)InBuffer)[0];
funcid_ = ((NvU32 *)InBuffer)[1];
table_ = gs_DispatchTable;
switch (packid_)
{
case NvRm_nvrm_init:
if ( !(s_FuncAllowedInNvrmInitPackage & (1 << funcid_)) )
goto fail;
break;
case NvRm_nvrm_module:
if ( !(s_FuncAllowedInNvrmModulePackage & (1 << funcid_)) )
goto fail;
break;
case NvRm_nvrm_power:
if ( !(s_FuncAllowedInNvrmPowerPackage_1 & (1 << funcid_)) )
goto fail;
break;
default:
goto fail;
}
if ( packid_-1 >= NV_ARRAY_SIZE(gs_DispatchTable) ||
!table_[packid_ - 1].DispFunc )
return NvError_IoctlFailed;
return table_[packid_ - 1].DispFunc( funcid_, InBuffer, InSize,
OutBuffer, OutSize, Ctx );
fail:
pr_debug("\n\n\n\n*****nvrm dispatch permission error,"
"packid_=%d, funcid_=%d,uid=%d,gid=%d****\n\n\n\n",
packid_, funcid_, (int)sys_getuid(), (int)sys_getgid());
return NvError_IoctlFailed;
}
/** Function to take settings values to the caller modules/application
* though the use of sysfs. This function can be used to set the
* device specific caps/attributes as specidied by the caller modules/app
* This function maps to store of sysfs
*/
ssize_t write_sysfs_accel(struct device *dev,
struct device_attribute *attr, const char *buffer, size_t count)
{
NvS32 i = 0;
NvS8 *input;
NvS32 value;
count = count > READ_BUFFER_LENGTH ? READ_BUFFER_LENGTH : count;
input = kzalloc(((int)count+1), GFP_KERNEL);
if (!input) {
goto err_0;
}
memcpy(input, buffer, count);
input[count] = '\0';
for (i=0; i<NV_ARRAY_SIZE(parameter); i++) {
if (count > strlen(parameter[i]) &&
!strncmp(parameter[i], input, strlen(parameter[i]))) {
value = simple_strtol(&input[strlen(parameter[i])],
'\0', 10);
accel_enum = i;
goto proceed;
}
}
goto err_0;
proceed:
if (accel_dev->hOdmAcr)
change_nvodm_accelerometer_settings(accel_enum, value);
else
count = 0;
kfree(input);
return count;
err_0:
if(input)
kfree(input);
count = 0;
return count;
}
NvError NvRm_Dispatch( void *InBuffer, NvU32 InSize, void *OutBuffer, NvU32 OutSize, NvDispatchCtx* Ctx )
{
NvU32 packid_;
NvU32 funcid_;
NvIdlDispatchTable *table_;
NV_ASSERT( InBuffer );
NV_ASSERT( OutBuffer );
packid_ = ((NvU32 *)InBuffer)[0];
funcid_ = ((NvU32 *)InBuffer)[1];
table_ = gs_DispatchTable;
if ( packid_-1 >= NV_ARRAY_SIZE(gs_DispatchTable) ||
!table_[packid_ - 1].DispFunc )
return NvError_IoctlFailed;
return table_[packid_ - 1].DispFunc( funcid_, InBuffer, InSize,
OutBuffer, OutSize, Ctx );
}
