Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#include "headers.h"
2
3/*
4Function: InterfaceIdleModeWakeup
5
6Description: This is the hardware specific Function for waking up HW device from Idle mode.
7 A software abort pattern is written to the device to wake it and necessary power state
8 transitions from host are performed here.
9
10Input parameters: IN struct bcm_mini_adapter *Adapter - Miniport Adapter Context
11
12
13Return: BCM_STATUS_SUCCESS - If Wakeup of the HW Interface was successful.
14 Other - If an error occurred.
15*/
16
17
18/*
19Function: InterfaceIdleModeRespond
20
21Description: This is the hardware specific Function for responding to Idle mode request from target.
22 Necessary power state transitions from host for idle mode or other device specific
23 initializations are performed here.
24
25Input parameters: IN struct bcm_mini_adapter * Adapter - Miniport Adapter Context
26
27
28Return: BCM_STATUS_SUCCESS - If Idle mode response related HW configuration was successful.
29 Other - If an error occurred.
30*/
31
32/*
33"dmem bfc02f00 100" tells how many time device went in Idle mode.
34this value will be at address bfc02fa4.just before value d0ea1dle.
35
36Set time value by writing at bfc02f98 7d0
37
38checking the Ack timer expire on kannon by running command
39d qcslog .. if it shows e means host has not send response to f/w with in 200 ms. Response should be
40send to f/w with in 200 ms after the Idle/Shutdown req issued
41
42*/
43
44
45int InterfaceIdleModeRespond(struct bcm_mini_adapter *Adapter, unsigned int *puiBuffer)
46{
47 int status = STATUS_SUCCESS;
48 unsigned int uiRegRead = 0;
49 int bytes;
50
51 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "SubType of Message :0x%X", ntohl(*puiBuffer));
52
53 if (ntohl(*puiBuffer) == GO_TO_IDLE_MODE_PAYLOAD) {
54 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, " Got GO_TO_IDLE_MODE_PAYLOAD(210) Msg Subtype");
55 if (ntohl(*(puiBuffer+1)) == 0 ) {
56 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Got IDLE MODE WAKE UP Response From F/W");
57
58 status = wrmalt (Adapter, SW_ABORT_IDLEMODE_LOC, &uiRegRead, sizeof(uiRegRead));
59 if (status) {
60 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed while clearing Idle Mode Reg");
61 return status;
62 }
63
64 if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
65 uiRegRead = 0x00000000 ;
66 status = wrmalt (Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegRead, sizeof(uiRegRead));
67 if (status) {
68 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed while clearing Idle Mode Reg");
69 return status;
70 }
71 }
72 /* Below Register should not br read in case of Manual and Protocol Idle mode */
73 else if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
74 /* clear on read Register */
75 bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG0, &uiRegRead, sizeof(uiRegRead));
76 if (bytes < 0) {
77 status = bytes;
78 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed while clearing H/W Abort Reg0");
79 return status;
80 }
81 /* clear on read Register */
82 bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG1, &uiRegRead, sizeof(uiRegRead));
83 if (bytes < 0) {
84 status = bytes;
85 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed while clearing H/W Abort Reg1");
86 return status;
87 }
88 }
89 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Device Up from Idle Mode");
90
91 /* Set Idle Mode Flag to False and Clear IdleMode reg. */
92 Adapter->IdleMode = FALSE;
93 Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
94
95 wake_up(&Adapter->lowpower_mode_wait_queue);
96
97 } else {
98 if (TRUE == Adapter->IdleMode)
99 {
100 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Device is already in Idle mode....");
101 return status ;
102 }
103
104 uiRegRead = 0;
105 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Got Req from F/W to go in IDLE mode \n");
106
107 if (Adapter->chip_id == BCS220_2 ||
108 Adapter->chip_id == BCS220_2BC ||
109 Adapter->chip_id == BCS250_BC ||
110 Adapter->chip_id == BCS220_3) {
111
112 bytes = rdmalt(Adapter, HPM_CONFIG_MSW, &uiRegRead, sizeof(uiRegRead));
113 if (bytes < 0) {
114 status = bytes;
115 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "rdm failed while Reading HPM_CONFIG_LDO145 Reg 0\n");
116 return status;
117 }
118
119
120 uiRegRead |= (1<<17);
121
122 status = wrmalt (Adapter, HPM_CONFIG_MSW, &uiRegRead, sizeof(uiRegRead));
123 if (status) {
124 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed while clearing Idle Mode Reg\n");
125 return status;
126 }
127
128 }
129 SendIdleModeResponse(Adapter);
130 }
131 } else if (ntohl(*puiBuffer) == IDLE_MODE_SF_UPDATE_MSG) {
132 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "OverRiding Service Flow Params");
133 OverrideServiceFlowParams(Adapter, puiBuffer);
134 }
135 return status;
136}
137
138static int InterfaceAbortIdlemode(struct bcm_mini_adapter *Adapter, unsigned int Pattern)
139{
140 int status = STATUS_SUCCESS;
141 unsigned int value;
142 unsigned int chip_id ;
143 unsigned long timeout = 0, itr = 0;
144
145 int lenwritten = 0;
146 unsigned char aucAbortPattern[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
147 struct bcm_interface_adapter *psInterfaceAdapter = Adapter->pvInterfaceAdapter;
148
149 /* Abort Bus suspend if its already suspended */
150 if ((TRUE == psInterfaceAdapter->bSuspended) && (TRUE == Adapter->bDoSuspend)) {
151 status = usb_autopm_get_interface(psInterfaceAdapter->interface);
152 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Bus got wakeup..Aborting Idle mode... status:%d \n", status);
153
154 }
155
156 if ((Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING)
157 ||
158 (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)) {
159 /* write the SW abort pattern. */
160 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Writing pattern<%d> to SW_ABORT_IDLEMODE_LOC\n", Pattern);
161 status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(Pattern));
162 if (status) {
163 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "WRM to Register SW_ABORT_IDLEMODE_LOC failed..");
164 return status;
165 }
166 }
167
168 if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
169 value = 0x80000000;
170 status = wrmalt(Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &value, sizeof(value));
171 if (status)
172 {
173 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "WRM to DEBUG_INTERRUPT_GENERATOR_REGISTOR Register failed");
174 return status;
175 }
176 } else if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
177 /*
178 * Get a Interrupt Out URB and send 8 Bytes Down
179 * To be Done in Thread Context.
180 * Not using Asynchronous Mechanism.
181 */
182 status = usb_interrupt_msg (psInterfaceAdapter->udev,
183 usb_sndintpipe(psInterfaceAdapter->udev,
184 psInterfaceAdapter->sIntrOut.int_out_endpointAddr),
185 aucAbortPattern,
186 8,
187 &lenwritten,
188 5000);
189 if (status) {
190 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Sending Abort pattern down fails with status:%d..\n", status);
191 return status;
192 } else {
193 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "NOB Sent down :%d", lenwritten);
194 }
195
196 /* mdelay(25); */
197
198 timeout = jiffies + msecs_to_jiffies(50) ;
199 while ( timeout > jiffies ) {
200 itr++ ;
201 rdmalt(Adapter, CHIP_ID_REG, &chip_id, sizeof(UINT));
202 if (0xbece3200 == (chip_id&~(0xF0)))
203 chip_id = chip_id&~(0xF0);
204 if (chip_id == Adapter->chip_id)
205 break;
206 }
207 if (timeout < jiffies )
208 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Not able to read chip-id even after 25 msec");
209 else
210 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Number of completed iteration to read chip-id :%lu", itr);
211
212 status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, &Pattern, sizeof(status));
213 if (status) {
214 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM to Register SW_ABORT_IDLEMODE_LOC failed..");
215 return status;
216 }
217 }
218 return status;
219}
220int InterfaceIdleModeWakeup(struct bcm_mini_adapter *Adapter)
221{
222 ULONG Status = 0;
223 if (Adapter->bTriedToWakeUpFromlowPowerMode) {
224 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Wake up already attempted.. ignoring\n");
225 } else {
226 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, IDLE_MODE, DBG_LVL_ALL, "Writing Low Power Mode Abort pattern to the Device\n");
227 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
228 InterfaceAbortIdlemode(Adapter, Adapter->usIdleModePattern);
229
230 }
231 return Status;
232}
233
234void InterfaceHandleShutdownModeWakeup(struct bcm_mini_adapter *Adapter)
235{
236 unsigned int uiRegVal = 0;
237 INT Status = 0;
238 int bytes;
239
240 if (Adapter->ulPowerSaveMode == DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING) {
241 /* clear idlemode interrupt. */
242 uiRegVal = 0;
243 Status = wrmalt(Adapter, DEBUG_INTERRUPT_GENERATOR_REGISTOR, &uiRegVal, sizeof(uiRegVal));
244 if (Status) {
245 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM to DEBUG_INTERRUPT_GENERATOR_REGISTOR Failed with err :%d", Status);
246 return;
247 }
248 }
249
250 else {
251
252 /* clear Interrupt EP registers. */
253 bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG0, &uiRegVal, sizeof(uiRegVal));
254 if (bytes < 0) {
255 Status = bytes;
256 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "RDM of DEVICE_INT_OUT_EP_REG0 failed with Err :%d", Status);
257 return;
258 }
259
260 bytes = rdmalt(Adapter, DEVICE_INT_OUT_EP_REG1, &uiRegVal, sizeof(uiRegVal));
261 if (bytes < 0) {
262 Status = bytes;
263 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "RDM of DEVICE_INT_OUT_EP_REG1 failed with Err :%d", Status);
264 return;
265 }
266 }
267}
268