drivers/staging/bcm/InterfaceIdleMode.c

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