/*
* Send commands to EC just before last close
*/
static NvError
NvEcPrivDeinitHook( NvEcHandle hEc )
{
#if ENABLE_POWER_MODES
NvEcRequest req;
NvEcResponse resp;
NvError e;
// disable global event reporting
DISP_MESSAGE(("NvEcPrivDeinitHook: Disabling Event Reporting\n"));
req.PacketType = NvEcPacketType_Request;
req.RequestType = NvEcRequestResponseType_Sleep;
req.RequestSubtype = ((NvEcRequestResponseSubtype)
NvEcSleepSubtype_GlobalConfigureEventReporting);
req.NumPayloadBytes = 1;
req.Payload[0] = NVEC_SLEEP_GLOBAL_REPORT_ENABLE_0_ACTION_DISABLE;
NV_CHECK_ERROR( NvEcSendRequest(hEc, &req, &resp, sizeof(req), sizeof(resp)) );
if ( resp.Status != NvEcStatus_Success )
return NvError_InvalidState;
#endif // ENABLE_POWER_MODES
DISP_MESSAGE(("NvEcPrivDeinitHook: Exit success\n"));
return NvSuccess;
}
static void nvec_brightness_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
struct nvec_led_data *led_dat =
container_of(led_cdev, struct nvec_led_data, cdev);
#if 0
led_cdev->brightness = value;
led_cdev->blink_mode = BLINK_MODE_OFF;
NvError NvStatus = NvError_Force32;
NvEcRequest EcRequest = {0};
NvEcResponse EcResponse = {0};
//printk("led======================>nvec_brightness_set value=%d\n", value);
if ( ghEc )
{
EcRequest.PacketType = NvEcPacketType_Request;
EcRequest.RequestType = NvEcRequestResponseType_Led;
EcRequest.RequestSubtype = NvEcLedSubtype_Mode_OnOff;
EcRequest.NumPayloadBytes = 1;
EcRequest.Payload[0] = value;
NvStatus = NvEcSendRequest( ghEc, &EcRequest, &EcResponse,
sizeof(EcRequest), sizeof(EcResponse));
if (NvStatus != NvSuccess)
{
printk("led======================>NvEcSendRequest eror\n");
}
if ( EcResponse.Status != NvEcStatus_Success)
{
printk("led======================>EcResponse eror\n");
NvStatus = NvError_Force32;
}
}
else
{
printk("led======================>NVEC handle error\n");
}
if (NvStatus == NvSuccess)
{
led_dat->brightness = value;
led_dat->blink_mode = BLINK_MODE_OFF;
}
#endif
}
/**
* Power suspend for mouse.
*
*/
NvBool NvOdmMousePowerSuspend(NvOdmMouseDeviceHandle hDevice)
{
#if ECI_MOUSE_DISABLE_SUPPORTED
NvError e;
NvEcRequest *pRequest = hDevice->pRequest;
NvEcResponse *pResponse = hDevice->pResponse;
NvU32 Index = 0;
if (!hDevice || !pRequest || !pResponse)
return NV_FALSE;
NV_ASSERT(hDevice->hEc);
NV_ASSERT(hDevice->pRequest);
NV_ASSERT(hDevice->pResponse);
// cancel auto-receive (disables event reporting)
NVODM_PRINTF(("NvOdmMousePowerSuspend: Cancel Auto Receive\n"));
do
{
// fill up request structure
pRequest->PacketType = NvEcPacketType_Request;
pRequest->RequestType = NvEcRequestResponseType_AuxDevice;
pRequest->RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hDevice->ValidMousePorts[Index]))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_CancelAutoReceive);
pRequest->NumPayloadBytes = 0;
// Request to EC
e = NvEcSendRequest(hDevice->hEc, pRequest, pResponse, sizeof(*pRequest),
sizeof(*pResponse));
if (NvSuccess != e)
{
NVODMMOUSE_PRINTF(("NvOdmMousePowerSuspend: NvEcSendRequest failed !!"));
return NV_FALSE;
}
if (NvEcStatus_Success != pResponse->Status)
{
NVODMMOUSE_PRINTF(("NvOdmMousePowerSuspend: EC response failed !!"));
return NV_FALSE;
}
} while(hDevice->ValidMousePorts[++Index] != INVALID_MOUSE_PORT_ID);
#endif
NVODM_PRINTF(("NvOdmMousePowerSuspend: Exit success\n"));
return NV_TRUE;
}
NvBool
NvOdmMouseSendRequest(
NvOdmMouseDeviceHandle hDevice,
NvU32 cmd,
NvU32 ExpectedResponseSize,
NvU32 *NumPayLoad,
NvU8 *PayLoadBuf)
{
NvError e;
NvEcRequest *pRequest = hDevice->pRequest;
NvEcResponse *pResponse = hDevice->pResponse;
NvU32 Index = 0;
do
{
// fill up request structure
pRequest->PacketType = NvEcPacketType_Request;
pRequest->RequestType = NvEcRequestResponseType_AuxDevice;
pRequest->RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hDevice->ValidMousePorts[Index]))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_SendCommand);
pRequest->NumPayloadBytes = 2;
pRequest->Payload[0] = cmd; // set the command
pRequest->Payload[1] = ExpectedResponseSize;
// Request to EC
e = NvEcSendRequest(hDevice->hEc, pRequest, pResponse, sizeof(*pRequest),
sizeof(*pResponse));
if (NvSuccess != e)
{
NVODMMOUSE_PRINTF(("NvEcSendRequest failed !!"));
return NV_FALSE;
}
if (NvEcStatus_Success != pResponse->Status)
{
NVODMMOUSE_PRINTF(("EC response failed !!"));
return NV_FALSE;
}
// store/process the Mouse response and return to the client driver
*NumPayLoad = pResponse->NumPayloadBytes;
NvOdmOsMemcpy(PayLoadBuf, &pResponse->Payload, *NumPayLoad);
} while (hDevice->ValidMousePorts[++Index] != INVALID_MOUSE_PORT_ID);
return NV_TRUE;
}
/*
* Thread to send no-op commands to EC
*/
static void
NvEcPrivPingThread(void *args)
{
NvError NvStatus = NvError_Success;
NvEcRequest req;
NvEcResponse resp;
NvEcPrivState *ec = (NvEcPrivState *)args;
//Nvidia_patch_ for_ deviceLockup_and_audio_lost_issue[START]
//set_freezable_with_signal();
set_freezable();
//Nvidia_patch_ for_ deviceLockup_and_audio_lost_issue[END]
for (;;) {
NvOsSemaphoreWait(ec->hPingSema);
if (ec->exitPingThread)
break;
// send no-op commands
DISP_MESSAGE(("NvEcPrivPingThread: Sending no-op command\n"));
req.PacketType = NvEcPacketType_Request;
req.RequestType = NvEcRequestResponseType_Control;
req.RequestSubtype = (NvEcRequestResponseSubtype)
NvEcControlSubtype_NoOperation;
req.NumPayloadBytes = 0;
NvStatus = NvEcSendRequest(
ec->hEc,
&req,
&resp,
sizeof(req),
sizeof(resp));
if (NvStatus != NvError_Success)
DISP_MESSAGE(("NvEcPrivPingThread: no-op command send fail\n"));
if (resp.Status != NvEcStatus_Success)
DISP_MESSAGE(("NvEcPrivPingThread: no-op command fail\n"));
DISP_MESSAGE(("NvEcPrivPingThread: no-op command sent\n"));
ec->IsEcActive = NV_FALSE;
}
}
/*
* Send commands to EC just before suspend
*/
static NvError
NvEcPrivPowerSuspendHook(
NvEcHandle hEc,
NvEcPowerState PowerState)
{
#if ENABLE_POWER_MODES
NvEcRequest req;
NvEcResponse resp;
NvError e;
NvEcRequestResponseSubtype Subtype;
DISP_MESSAGE(("NvEcPrivPowerSuspendHook: PowerState = %d\n", (NvU32)PowerState));
// determine operation type
switch (PowerState)
{
case NvEcPowerState_PowerDown:
Subtype = ((NvEcRequestResponseSubtype)
NvEcSleepSubtype_ApPowerDown);
break;
case NvEcPowerState_Suspend:
Subtype = ((NvEcRequestResponseSubtype)
NvEcSleepSubtype_ApSuspend);
break;
case NvEcPowerState_Restart:
Subtype = ((NvEcRequestResponseSubtype)
NvEcSleepSubtype_ApRestart);
break;
default:
NV_ASSERT(!"NvEcPrivPowerSuspendHook: unknown power state\n");
NV_CHECK_ERROR(NvError_BadValue);
break;
}
// disable global event reporting
DISP_MESSAGE(("NvEcPrivPowerSuspendHook: Disable Event Reporting\n"));
req.PacketType = NvEcPacketType_Request;
req.RequestType = NvEcRequestResponseType_Sleep;
req.RequestSubtype = ((NvEcRequestResponseSubtype)
NvEcSleepSubtype_GlobalConfigureEventReporting);
req.NumPayloadBytes = 1;
req.Payload[0] = NVEC_SLEEP_GLOBAL_REPORT_ENABLE_0_ACTION_DISABLE;
NV_CHECK_ERROR( NvEcSendRequest(hEc, &req, &resp, sizeof(req), sizeof(resp)) );
if ( resp.Status != NvEcStatus_Success )
return NvError_InvalidState;
// instruct EC to go to sleep
DISP_MESSAGE(("NvEcPrivPowerSuspendHook: Go to sleep\n"));
req.PacketType = NvEcPacketType_Request;
req.RequestType = NvEcRequestResponseType_Sleep;
req.RequestSubtype = Subtype;
req.NumPayloadBytes = 0;
NV_CHECK_ERROR( NvEcSendRequest(hEc, &req, &resp, sizeof(req), sizeof(resp)) );
if ( resp.Status != NvEcStatus_Success )
return NvError_InvalidState;
#endif // ENABLE_POWER_MODES
DISP_MESSAGE(("NvEcPrivPowerSuspendHook: Exit success\n"));
return NvSuccess;
}
NvBool NvOdmKeyboardInit(void)
{
NvError NvStatus = NvError_Success;
NvEcRequest Request = {0};
NvEcResponse Response = {0};
/* get nvec handle */
NvStatus = NvEcOpen(&s_NvEcHandle, 0 /* instance */);
if (NvStatus != NvError_Success)
{
goto fail;
}
/* reset the EC to start the keyboard scanning */
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_Keyboard;
Request.RequestSubtype = (NvEcRequestResponseSubtype) NvEcKeyboardSubtype_Enable;
Request.NumPayloadBytes = 0;
NvStatus = NvEcSendRequest(s_NvEcHandle, &Request, &Response, sizeof(Request), sizeof(Response));
if (NvStatus != NvError_Success)
{
goto cleanup;
}
/* check if command passed */
if (Response.Status != NvEcStatus_Success)
{
goto cleanup;
}
#if WAKE_FROM_KEYBOARD
hOdm = NvOdmOsAlloc(sizeof(NvOdmKbdContext));
if (!hOdm) {
goto cleanup;
}
/* Check the supported GPIOs */
hOdm->GpioPinInfo = NvOdmQueryGpioPinMap(NvOdmGpioPinGroup_EmbeddedController,
0, &hOdm->PinCount);
NvRmGpioAcquirePinHandle(s_hGpioGlobal,
hOdm->GpioPinInfo->Port,
hOdm->GpioPinInfo->Pin,
&hOdm->hPin);
if (!hOdm->hPin) {
goto cleanup;
}
/* register to receive GPIO events */
NvStatus = NvRmGpioInterruptRegister(s_hGpioGlobal,
s_hRmGlobal,
hOdm->hPin,
(NvOsInterruptHandler)GpioInterruptHandler,
NvRmGpioPinMode_InputData,
hOdm,
&hOdm->GpioIntrHandle,
DEBOUNCE_TIME_MS);
if (NvStatus != NvError_Success) {
goto cleanup;
}
NvStatus = NvRmGpioInterruptEnable(hOdm->GpioIntrHandle);
if (NvStatus != NvError_Success) {
goto cleanup;
}
/* enable keyboard as wake up source */
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_Keyboard;
Request.RequestSubtype = (NvEcRequestResponseSubtype)
NvEcKeyboardSubtype_ConfigureWake;
Request.NumPayloadBytes = 2;
Request.Payload[0] = NVEC_KEYBOARD_WAKE_ENABLE_0_ACTION_ENABLE;
Request.Payload[1] = NVEC_KEYBOARD_EVENT_TYPE_0_ANY_KEY_PRESS_ENABLE;
NvStatus = NvEcSendRequest(s_NvEcHandle,
&Request,
&Response,
sizeof(Request),
sizeof(Response));
if (NvStatus != NvError_Success) {
goto cleanup;
}
if (Response.Status != NvEcStatus_Success) {
goto cleanup;
}
/* enable key reporting on wake up */
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_Keyboard;
Request.RequestSubtype = (NvEcRequestResponseSubtype)
NvEcKeyboardSubtype_ConfigureWakeKeyReport;
Request.NumPayloadBytes = 1;
Request.Payload[0] = NVEC_KEYBOARD_REPORT_WAKE_KEY_0_ACTION_ENABLE;
NvStatus = NvEcSendRequest(s_NvEcHandle,
&Request,
&Response,
sizeof(Request),
sizeof(Response));
if (NvStatus != NvError_Success) {
goto cleanup;
}
if (Response.Status != NvEcStatus_Success) {
goto cleanup;
}
#endif
/* create semaphore which can be used to send scan codes to the clients */
s_hKbcKeyScanRecvSema = NvOdmOsSemaphoreCreate(0);
if (!s_hKbcKeyScanRecvSema)
{
goto cleanup;
}
/* register for keyboard events */
NvStatus = NvEcRegisterForEvents(
s_NvEcHandle, // nvec handle
&s_hEcEventRegistration,
(NvOsSemaphoreHandle)s_hKbcKeyScanRecvSema,
sizeof(EventTypes)/sizeof(NvEcEventType),
EventTypes, // receive keyboard scan codes
1, // currently buffer only 1 packet from ECI at a time
sizeof(NvEcEvent));
if (NvStatus != NvError_Success)
{
goto cleanup;
}
/* success */
return NV_TRUE;
cleanup:
#if WAKE_FROM_KEYBOARD
NvRmGpioInterruptUnregister(s_hGpioGlobal, s_hRmGlobal, hOdm->GpioIntrHandle);
hOdm->GpioIntrHandle = NULL;
NvRmGpioReleasePinHandles(s_hGpioGlobal, &hOdm->hPin, hOdm->PinCount);
NvOdmOsFree(hOdm);
hOdm = NULL;
#endif
(void)NvEcUnregisterForEvents(s_hEcEventRegistration);
s_hEcEventRegistration = NULL;
NvOdmOsSemaphoreDestroy(s_hKbcKeyScanRecvSema);
s_hKbcKeyScanRecvSema = NULL;
NvEcClose(s_NvEcHandle);
fail:
s_NvEcHandle = NULL;
return NV_FALSE;
}
//for MTP
static void nvec_test_mode_set(struct led_classdev *led_cdev, enum led_test_mode on_off)
{
struct nvec_led_data *led_dat =
container_of(led_cdev, struct nvec_led_data, cdev);
int level = 0;
NvError NvStatus = NvError_Force32;
NvEcRequest EcRequest = {0};
NvEcResponse EcResponse = {0};
//printk("led======================>nvec_blink_mode_set value=%d\n", value);
led_cdev->brightness = LED_OFF;
led_cdev->blink_mode = BLINK_MODE_OFF;
if ( on_off == TEST_MODE_ON )
level = TEST_MODE_ON;
else if( on_off == TEST_MODE_OFF )
level = TEST_MODE_OFF;
else
return;
if ( ghEc )
{
EcRequest.PacketType = NvEcPacketType_Request;
EcRequest.RequestType = NvEcRequestResponseType_Led;
EcRequest.RequestSubtype = NvEcLedSubtype_Mode_Test;
EcRequest.NumPayloadBytes = 1;
EcRequest.Payload[0] = level & 0xff;
NvStatus = NvEcSendRequest( ghEc, &EcRequest, &EcResponse,
sizeof(EcRequest), sizeof(EcResponse));
if (NvStatus != NvSuccess)
{
printk("led nvec_test_mode_set======================>NvEcSendRequest eror\n");
}
if ( EcResponse.Status != NvEcStatus_Success)
{
printk("led nvec_test_mode_set======================>EcResponse eror\n");
NvStatus = NvError_Force32;
}
}
else
{
printk("led nvec_test_mode_set======================>NVEC handle error\n");
}
if (NvStatus == NvSuccess)
{
led_dat->testMode_OnOff = level;
led_dat->brightness = LED_OFF;
led_dat->blink_mode = BLINK_MODE_OFF;
}
}
////////////blink
static void nvec_blink_mode_set(struct led_classdev *led_cdev,
enum led_blink_mode value)
{
struct nvec_led_data *led_dat =
container_of(led_cdev, struct nvec_led_data, cdev);
int level;
led_cdev->blink_mode = value;
led_cdev->brightness = LED_OFF;
NvError NvStatus = NvError_Force32;
NvEcRequest EcRequest = {0};
NvEcResponse EcResponse = {0};
//printk("led======================>nvec_blink_mode_set value=%d\n", value);
if ( value == BLINK_MODE_ON1_OFF1 )
level = BLINK_MODE_ON1_OFF1;
else if( value == BLINK_MODE_ON1_OFF2 )
level = BLINK_MODE_ON1_OFF2;
else if( value == BLINK_MODE_OFF )
level = BLINK_MODE_OFF;
else
return;
if ( ghEc )
{
EcRequest.PacketType = NvEcPacketType_Request;
EcRequest.RequestType = NvEcRequestResponseType_Led;
EcRequest.RequestSubtype = NvEcLedSubtype_Mode_Blink;
EcRequest.NumPayloadBytes = 2;
if( level == BLINK_MODE_ON1_OFF1 )
{
EcRequest.Payload[0] = 0x01;
EcRequest.Payload[1] = 0x01;
}
else if( level == BLINK_MODE_ON1_OFF2 )
{
EcRequest.Payload[0] = 0x01;
EcRequest.Payload[1] = 0x02;
}
else
{
EcRequest.Payload[0] = 0x00;
EcRequest.Payload[1] = 0x00;
}
NvStatus = NvEcSendRequest( ghEc, &EcRequest, &EcResponse,
sizeof(EcRequest), sizeof(EcResponse));
if (NvStatus != NvSuccess)
{
printk("led nvec_blink_mode_set======================>NvEcSendRequest eror\n");
}
if ( EcResponse.Status != NvEcStatus_Success)
{
printk("led nvec_blink_mode_set======================>EcResponse eror\n");
NvStatus = NvError_Force32;
}
}
else
{
printk("led nvec_blink_mode_set======================>NVEC handle error\n");
}
if (NvStatus == NvSuccess)
{
led_dat->blink_mode = level;
led_dat->brightness = LED_OFF;
}
}
NvBool
NvOdmMouseDeviceOpen(
NvOdmMouseDeviceHandle *hDevice)
{
NvOdmMouseDevice *hMouseDev = NULL;
NvBool ret = NV_FALSE;
NvU32 InstanceId = 0, count = 0, MousePort = 0, i = 0;
#if WAKE_FROM_MOUSE
NvError err = NvError_Success;
NvEcRequest Request = {0};
NvEcResponse Response = {0};
#endif
// Allocate memory for request type structure
hMouseDev = (NvOdmMouseDevice *)NvOdmOsAlloc(sizeof(NvOdmMouseDevice));
if (!hMouseDev)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate hMouseDev!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev, 0, sizeof(NvOdmMouseDevice));
// open channel to the EC
if ((NvEcOpen(&hMouseDev->hEc, InstanceId)) != NvSuccess)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvEcOpen failed !!"));
goto fail_safe;
}
hMouseDev->pRequest = NULL;
hMouseDev->pResponse = NULL;
hMouseDev->pEvent = NULL;
hMouseDev->CompressionEnabled = NV_FALSE;
hMouseDev->CompressionState = 0x0;
do
{
hMouseDev->ValidMousePorts[count] = INVALID_MOUSE_PORT_ID;
count++;
} while (count <= MAX_NUM_MOUSE_PORTS);
// Allocate memory for request type structure
hMouseDev->pRequest = NvOdmOsAlloc(sizeof(NvEcRequest));
if (!hMouseDev->pRequest)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pRequest!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pRequest, 0, sizeof(NvEcRequest));
// Allocate memory for response type structure
hMouseDev->pResponse = NvOdmOsAlloc(sizeof(NvEcResponse));
if (!hMouseDev->pResponse)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pResponse!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pResponse, 0, sizeof(NvEcResponse));
// Allocate memory for event type structure
hMouseDev->pEvent = NvOdmOsAlloc(sizeof(NvEcEvent));
if (!hMouseDev->pEvent)
{
ret = NV_FALSE;
NVODMMOUSE_PRINTF(("NvOdmOsAlloc failed to allocate pEvent!!"));
goto fail_safe;
}
NvOdmOsMemset(hMouseDev->pEvent, 0, sizeof(NvEcEvent));
MousePort = MOUSE_PS2_PORT_ID_0;
count = CMD_MAX_RETRIES + 1; i = 0;
while (count--)
{
// fill up request structure
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_AuxDevice;
Request.RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,MousePort))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_SendCommand);
Request.NumPayloadBytes = 2;
Request.Payload[0] = 0xFF; // set the reset command
Request.Payload[1] = 3;
// Request to EC
err = NvEcSendRequest(hMouseDev->hEc, &Request, &Response, sizeof(Request),
sizeof(Response));
if (NvSuccess != err)
{
NVODMMOUSE_PRINTF(("NvEcSendRequest failed !!"));
break;
}
// mouse not found
if (NvEcStatus_Success != Response.Status)
{
NVODMMOUSE_PRINTF(("EC response failed !!"));
if (MousePort != MOUSE_PS2_PORT_ID_1)
{
count = CMD_MAX_RETRIES + 1;
MousePort = MOUSE_PS2_PORT_ID_1;
continue;
}
break;
}
if (Response.NumPayloadBytes != 3)
continue;
// success
if (Response.Payload[0] == 0xFA)
{
hMouseDev->ValidMousePorts[i] = MousePort;
if (MousePort != MOUSE_PS2_PORT_ID_1)
{
count = CMD_MAX_RETRIES + 1;
MousePort = MOUSE_PS2_PORT_ID_1;
i++;
continue;
}
break;
}
}
#if WAKE_FROM_MOUSE
i = 0;
do
{
/* enable mouse as wake up source */
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_AuxDevice;
Request.RequestSubtype = ((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hMouseDev->ValidMousePorts[i]))) |
(NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_ConfigureWake;
Request.NumPayloadBytes = 2;
Request.Payload[0] = NVEC_AUX_DEVICE_WAKE_ENABLE_0_ACTION_ENABLE;
Request.Payload[1] = NVEC_AUX_DEVICE_EVENT_TYPE_0_ANY_EVENT_ENABLE;
err = NvEcSendRequest(
hMouseDev->hEc,
&Request,
&Response,
sizeof(Request),
sizeof(Response));
if (err != NvError_Success)
{
ret = NV_FALSE;
goto fail_safe;
}
if (Response.Status != NvEcStatus_Success)
{
ret = NV_FALSE;
goto fail_safe;
}
} while (hMouseDev->ValidMousePorts[++i] != INVALID_MOUSE_PORT_ID);
#endif
*hDevice = (NvOdmMouseDeviceHandle)hMouseDev;
ret = NV_TRUE;
return ret;
fail_safe:
NvOdmMouseDeviceClose((NvOdmMouseDeviceHandle)hMouseDev);
hMouseDev = NULL;
return ret;
}
NvBool
NvOdmMouseStartStreaming(
NvOdmMouseDeviceHandle hDevice,
NvU32 NumBytesPerSample)
{
NvError e;
NvEcRequest *pRequest = hDevice->pRequest;
NvEcResponse *pResponse = hDevice->pResponse;
NvU32 Index = 0;
if (!hDevice)
return NV_FALSE;
hDevice->NumBytesPerSample = NumBytesPerSample;
#if ENABLE_COMPRESSION
/**
* automatically enable compression if sample size is 3 bytes
*
* compression is supported only for 3-byte data packets (which is the
* common case for ps/2 mice and mouses
*
* compression reduces communication bandwidth by eliminating the first data
* byte of the packet when it hasn't changed relative to the previous
* packet. Whenever a full-sized packet is sent, the first payload byte is
* latched so that it can be inserted into an n y following compressed packets.
*/
if (NumBytesPerSample == 3)
{
do
{
// prepare Aux Device request for Set Compression
pRequest->PacketType = NvEcPacketType_Request;
pRequest->RequestType = NvEcRequestResponseType_AuxDevice;
pRequest->RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hDevice->ValidMousePorts[Index]))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_SetCompression);
pRequest->NumPayloadBytes = 1;
pRequest->Payload[0] = 1; // enable compression
// send request to EC
e = NvEcSendRequest(hDevice->hEc, pRequest, pResponse, sizeof(*pRequest),
sizeof(*pResponse));
if (NvSuccess != e)
{
NVODMMOUSE_PRINTF(("NvEcSendRequest (compression) failed !!"));
return NV_FALSE;
}
// check status reported by EC
if (NvEcStatus_Success != pResponse->Status)
{
NVODMMOUSE_PRINTF(("EC response (compression) failed !!"));
return NV_FALSE;
}
} while(hDevice->ValidMousePorts[++Index] != INVALID_MOUSE_PORT_ID);
hDevice->CompressionEnabled = NV_TRUE;
hDevice->CompressionState = 0x0;
}
else
{
// compression not supported due to packet size (!= 3 bytes)
hDevice->CompressionEnabled = NV_FALSE;
}
#else // ENABLE_COMPRESSION
// disable compression
hDevice->CompressionEnabled = NV_FALSE;
#endif // ENABLE_COMPRESSION
// prepare Aux Device request for Auto-Receive N Bytes
Index = 0;
do
{
pRequest->PacketType = NvEcPacketType_Request;
pRequest->RequestType = NvEcRequestResponseType_AuxDevice;
pRequest->RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID,hDevice->ValidMousePorts[Index]))) |
((NvEcRequestResponseSubtype)
NvEcAuxDeviceSubtype_AutoReceiveBytes);
pRequest->NumPayloadBytes = 1;
pRequest->Payload[0] = NumBytesPerSample;
// send request to EC
e = NvEcSendRequest(hDevice->hEc, pRequest, pResponse, sizeof(*pRequest),
sizeof(*pResponse));
if (NvSuccess != e)
{
NVODMMOUSE_PRINTF(("NvEcSendRequest (auto-receive) failed !!"));
return NV_FALSE;
}
// check status reported by EC
if (NvEcStatus_Success != pResponse->Status)
{
NVODMMOUSE_PRINTF(("EC response (auto-receive) failed !!"));
return NV_FALSE;
}
} while(hDevice->ValidMousePorts[++Index] != INVALID_MOUSE_PORT_ID);
return NV_TRUE;
}
NvBool
NvOdmMouseReset(NvOdmMouseDeviceHandle hDevice)
{
NvError err = NvError_Success;
NvEcRequest Request = {0};
NvEcResponse Response = {0};
NvU32 count = 0, MousePort = 0, i = 0;
NvBool ret = NV_FALSE;
NvOdmMouseDevice *hMouseDev = (NvOdmMouseDevice *)hDevice;
MousePort = MOUSE_PS2_PORT_ID_0;
count = CMD_MAX_RETRIES + 1;
while ((ret==NV_FALSE) && (count--))
{
// fill up request structure
Request.PacketType = NvEcPacketType_Request;
Request.RequestType = NvEcRequestResponseType_AuxDevice;
Request.RequestSubtype =
((NvEcRequestResponseSubtype)
(NV_DRF_NUM(NVEC,SUBTYPE,AUX_PORT_ID, MousePort))) |
((NvEcRequestResponseSubtype)NvEcAuxDeviceSubtype_SendCommand);
Request.NumPayloadBytes = 2;
Request.Payload[0] = 0xFF; // set the reset command
Request.Payload[1] = 3;
// Request to EC
err = NvEcSendRequest(hMouseDev->hEc, &Request,
&Response, sizeof(Request), sizeof(Response));
if (NvSuccess != err)
{
//NVODMMOUSE_PRINTF(("NvEcSendRequest failed !!"));
NvOsDebugPrintf("NvEcSendRequest failed !!\n");
NvOsWaitUS(100000);
continue;
}
// mouse not found
if (NvEcStatus_Success != Response.Status)
{
//NVODMMOUSE_PRINTF(("EC response failed !!"));
NvOsDebugPrintf("EC response failed !!\n");
//if (MousePort != MOUSE_PS2_PORT_ID_1)
//{
// count = CMD_MAX_RETRIES + 1;
// MousePort = MOUSE_PS2_PORT_ID_1;
//}
NvOsWaitUS(100000);
continue;
}
if (Response.NumPayloadBytes != 3)
continue;
// success
if (Response.Payload[0] == 0xFA)
{
ret = NV_TRUE; // at lease one Mouse found!
hMouseDev->ValidMousePorts[i] = MousePort;
//if (MousePort != MOUSE_PS2_PORT_ID_1)
//{
// count = CMD_MAX_RETRIES + 1;
// MousePort = MOUSE_PS2_PORT_ID_1;
// i++;
// continue;
//}
}
}
return ret;
}
