| #include "headers.h" | |
| /* | |
| Function: InterfaceIdleModeWakeup | |
| Description: This is the hardware specific Function for | |
| waking up HW device from Idle mode. | |
| A software abort pattern is written to the | |
| device to wake it and necessary power state | |
| transitions from host are performed here. | |
| Input parameters: IN struct bcm_mini_adapter *Adapter | |
| - Miniport Adapter Context | |
| Return: BCM_STATUS_SUCCESS - If Wakeup of the HW Interface | |
| was successful. | |
| Other - If an error occurred. | |
| */ | |
| /* | |
| Function: InterfaceIdleModeRespond | |
| Description: This is the hardware specific Function for | |
| responding to Idle mode request from target. | |
| Necessary power state transitions from host for | |
| idle mode or other device specific initializations | |
| are performed here. | |
| Input parameters: IN struct bcm_mini_adapter * Adapter | |
| - Miniport Adapter Context | |
| Return: BCM_STATUS_SUCCESS - If Idle mode response related | |
| HW configuration was successful. | |
| Other - If an error occurred. | |
| */ | |
| /* | |
| "dmem bfc02f00 100" tells how many time device went in Idle mode. | |
| this value will be at address bfc02fa4.just before value d0ea1dle. | |
| Set time value by writing at bfc02f98 7d0 | |
| checking the Ack timer expire on kannon by running command | |
| d qcslog .. if it shows e means host has not send response | |
| to f/w with in 200 ms. Response should be | |
| send to f/w with in 200 ms after the Idle/Shutdown req issued | |
| */ | |
| int InterfaceIdleModeRespond(struct bcm_mini_adapter *Adapter, | |
| unsigned int *puiBuffer) | |
| { | |
| int status = STATUS_SUCCESS; | |
| unsigned int uiRegRead = 0; | |
| int bytes; | |
| if (ntohl(*puiBuffer) == GO_TO_IDLE_MODE_PAYLOAD) { | |
| if (ntohl(*(puiBuffer+1)) == 0) { | |
| status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (status) | |
| return status; | |
| if (Adapter->ulPowerSaveMode == | |
| DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) { | |
| uiRegRead = 0x00000000; | |
| status = wrmalt(Adapter, | |
| DEBUG_INTERRUPT_GENERATOR_REGISTOR, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (status) | |
| return status; | |
| } | |
| /* Below Register should not br read in case of | |
| * Manual and Protocol Idle mode */ | |
| else if (Adapter->ulPowerSaveMode != | |
| DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) { | |
| /* clear on read Register */ | |
| bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG0, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (bytes < 0) { | |
| status = bytes; | |
| return status; | |
| } | |
| /* clear on read Register */ | |
| bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG1, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (bytes < 0) { | |
| status = bytes; | |
| return status; | |
| } | |
| } | |
| /* Set Idle Mode Flag to False and | |
| * Clear IdleMode reg. */ | |
| Adapter->IdleMode = false; | |
| Adapter->bTriedToWakeUpFromlowPowerMode = false; | |
| wake_up(&Adapter->lowpower_mode_wait_queue); | |
| } else { | |
| if (TRUE == Adapter->IdleMode) | |
| return status; | |
| uiRegRead = 0; | |
| if (Adapter->chip_id == BCS220_2 || | |
| Adapter->chip_id == BCS220_2BC || | |
| Adapter->chip_id == BCS250_BC || | |
| Adapter->chip_id == BCS220_3) { | |
| bytes = rdmalt(Adapter, HPM_CONFIG_MSW, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (bytes < 0) { | |
| status = bytes; | |
| return status; | |
| } | |
| uiRegRead |= (1<<17); | |
| status = wrmalt(Adapter, HPM_CONFIG_MSW, | |
| &uiRegRead, sizeof(uiRegRead)); | |
| if (status) | |
| return status; | |
| } | |
| SendIdleModeResponse(Adapter); | |
| } | |
| } else if (ntohl(*puiBuffer) == IDLE_MODE_SF_UPDATE_MSG) { | |
| OverrideServiceFlowParams(Adapter, puiBuffer); | |
| } | |
| return status; | |
| } | |
| static int InterfaceAbortIdlemode(struct bcm_mini_adapter *Adapter, | |
| unsigned int Pattern) | |
| { | |
| int status = STATUS_SUCCESS; | |
| unsigned int value; | |
| unsigned int chip_id; | |
| unsigned long timeout = 0, itr = 0; | |
| int lenwritten = 0; | |
| unsigned char aucAbortPattern[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, | |
| 0xFF, 0xFF, 0xFF}; | |
| struct bcm_interface_adapter *psInterfaceAdapter = | |
| Adapter->pvInterfaceAdapter; | |
| /* Abort Bus suspend if its already suspended */ | |
| if ((TRUE == psInterfaceAdapter->bSuspended) && | |
| (TRUE == Adapter->bDoSuspend)) | |
| status = usb_autopm_get_interface( | |
| psInterfaceAdapter->interface); | |
| if ((Adapter->ulPowerSaveMode == | |
| DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) || | |
| (Adapter->ulPowerSaveMode == | |
| DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)) { | |
| /* write the SW abort pattern. */ | |
| status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, | |
| &Pattern, sizeof(Pattern)); | |
| if (status) | |
| return status; | |
| } | |
| if (Adapter->ulPowerSaveMode == | |
| DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) { | |
| value = 0x80000000; | |
| status = wrmalt(Adapter, | |
| DEBUG_INTERRUPT_GENERATOR_REGISTOR, | |
| &value, sizeof(value)); | |
| if (status) | |
| return status; | |
| } else if (Adapter->ulPowerSaveMode != | |
| DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) { | |
| /* | |
| * Get a Interrupt Out URB and send 8 Bytes Down | |
| * To be Done in Thread Context. | |
| * Not using Asynchronous Mechanism. | |
| */ | |
| status = usb_interrupt_msg(psInterfaceAdapter->udev, | |
| usb_sndintpipe(psInterfaceAdapter->udev, | |
| psInterfaceAdapter->sIntrOut.int_out_endpointAddr), | |
| aucAbortPattern, | |
| 8, | |
| &lenwritten, | |
| 5000); | |
| if (status) | |
| return status; | |
| else | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, | |
| IDLE_MODE, DBG_LVL_ALL, | |
| "NOB Sent down :%d", lenwritten); | |
| /* mdelay(25); */ | |
| timeout = jiffies + msecs_to_jiffies(50); | |
| while (time_after(timeout, jiffies)) { | |
| itr++; | |
| rdmalt(Adapter, CHIP_ID_REG, &chip_id, sizeof(UINT)); | |
| if (0xbece3200 == (chip_id&~(0xF0))) | |
| chip_id = chip_id&~(0xF0); | |
| if (chip_id == Adapter->chip_id) | |
| break; | |
| } | |
| if (time_before(timeout, jiffies)) | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, | |
| IDLE_MODE, DBG_LVL_ALL, | |
| "Not able to read chip-id even after 25 msec"); | |
| else | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, | |
| IDLE_MODE, DBG_LVL_ALL, | |
| "Number of completed iteration to" | |
| "read chip-id :%lu", itr); | |
| status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, | |
| &Pattern, sizeof(status)); | |
| if (status) | |
| return status; | |
| } | |
| return status; | |
| } | |
| int InterfaceIdleModeWakeup(struct bcm_mini_adapter *Adapter) | |
| { | |
| if (Adapter->bTriedToWakeUpFromlowPowerMode) { | |
| BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, | |
| IDLE_MODE, DBG_LVL_ALL, | |
| "Wake up already attempted.. ignoring\n"); | |
| } else { | |
| Adapter->bTriedToWakeUpFromlowPowerMode = TRUE; | |
| InterfaceAbortIdlemode(Adapter, Adapter->usIdleModePattern); | |
| } | |
| return 0; | |
| } | |
| void InterfaceHandleShutdownModeWakeup(struct bcm_mini_adapter *Adapter) | |
| { | |
| unsigned int uiRegVal = 0; | |
| INT Status = 0; | |
| int bytes; | |
| if (Adapter->ulPowerSaveMode == | |
| DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) { | |
| /* clear idlemode interrupt. */ | |
| uiRegVal = 0; | |
| Status = wrmalt(Adapter, | |
| DEBUG_INTERRUPT_GENERATOR_REGISTOR, | |
| &uiRegVal, sizeof(uiRegVal)); | |
| if (Status) | |
| return; | |
| } | |
| else { | |
| /* clear Interrupt EP registers. */ | |
| bytes = rdmalt(Adapter, | |
| DEVICE_INT_OUT_EP_REG0, | |
| &uiRegVal, sizeof(uiRegVal)); | |
| if (bytes < 0) { | |
| Status = bytes; | |
| return; | |
| } | |
| bytes = rdmalt(Adapter, | |
| DEVICE_INT_OUT_EP_REG1, | |
| &uiRegVal, sizeof(uiRegVal)); | |
| if (bytes < 0) { | |
| Status = bytes; | |
| return; | |
| } | |
| } | |
| } | |