Pileus Git - ~andy/linux/blob - drivers/staging/bcm/led_control.c

   1 #include "headers.h"
   2
   3 #define STATUS_IMAGE_CHECKSUM_MISMATCH -199
   4 #define EVENT_SIGNALED 1
   5
   6 static B_UINT16 CFG_CalculateChecksum(B_UINT8 *pu8Buffer, B_UINT32 u32Size)
   7 {
   8         B_UINT16 u16CheckSum = 0;
   9         while (u32Size--) {
  10                 u16CheckSum += (B_UINT8)~(*pu8Buffer);
  11                 pu8Buffer++;
  12         }
  13         return u16CheckSum;
  14 }
  15
  16 BOOLEAN IsReqGpioIsLedInNVM(struct bcm_mini_adapter *Adapter, UINT gpios)
  17 {
  18         INT Status;
  19         Status = (Adapter->gpioBitMap & gpios) ^ gpios;
  20         if (Status)
  21                 return FALSE;
  22         else
  23                 return TRUE;
  24 }
  25
  26 static INT LED_Blink(struct bcm_mini_adapter *Adapter, UINT GPIO_Num, UCHAR uiLedIndex,
  27                 ULONG timeout, INT num_of_time, enum bcm_led_events currdriverstate)
  28 {
  29         int Status = STATUS_SUCCESS;
  30         BOOLEAN bInfinite = FALSE;
  31
  32         /* Check if num_of_time is -ve. If yes, blink led in infinite loop */
  33         if (num_of_time < 0) {
  34                 bInfinite = TRUE;
  35                 num_of_time = 1;
  36         }
  37         while (num_of_time) {
  38                 if (currdriverstate == Adapter->DriverState)
  39                         TURN_ON_LED(GPIO_Num, uiLedIndex);
  40
  41                 /* Wait for timeout after setting on the LED */
  42                 Status = wait_event_interruptible_timeout(
  43                                 Adapter->LEDInfo.notify_led_event,
  44                                 currdriverstate != Adapter->DriverState ||
  45                                         kthread_should_stop(),
  46                                 msecs_to_jiffies(timeout));
  47
  48                 if (kthread_should_stop()) {
  49                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
  50                                 DBG_LVL_ALL,
  51                                 "Led thread got signal to exit..hence exiting");
  52                         Adapter->LEDInfo.led_thread_running =
  53                                         BCM_LED_THREAD_DISABLED;
  54                         TURN_OFF_LED(GPIO_Num, uiLedIndex);
  55                         Status = EVENT_SIGNALED;
  56                         break;
  57                 }
  58                 if (Status) {
  59                         TURN_OFF_LED(GPIO_Num, uiLedIndex);
  60                         Status = EVENT_SIGNALED;
  61                         break;
  62                 }
  63
  64                 TURN_OFF_LED(GPIO_Num, uiLedIndex);
  65                 Status = wait_event_interruptible_timeout(
  66                                 Adapter->LEDInfo.notify_led_event,
  67                                 currdriverstate != Adapter->DriverState ||
  68                                         kthread_should_stop(),
  69                                 msecs_to_jiffies(timeout));
  70                 if (bInfinite == FALSE)
  71                         num_of_time--;
  72         }
  73         return Status;
  74 }
  75
  76 static INT ScaleRateofTransfer(ULONG rate)
  77 {
  78         if (rate <= 3)
  79                 return rate;
  80         else if ((rate > 3) && (rate <= 100))
  81                 return 5;
  82         else if ((rate > 100) && (rate <= 200))
  83                 return 6;
  84         else if ((rate > 200) && (rate <= 300))
  85                 return 7;
  86         else if ((rate > 300) && (rate <= 400))
  87                 return 8;
  88         else if ((rate > 400) && (rate <= 500))
  89                 return 9;
  90         else if ((rate > 500) && (rate <= 600))
  91                 return 10;
  92         else
  93                 return MAX_NUM_OF_BLINKS;
  94 }
  95
  96
  97
  98 static INT LED_Proportional_Blink(struct bcm_mini_adapter *Adapter, UCHAR GPIO_Num_tx,
  99                 UCHAR uiTxLedIndex, UCHAR GPIO_Num_rx, UCHAR uiRxLedIndex,
 100                 enum bcm_led_events currdriverstate)
 101 {
 102         /* Initial values of TX and RX packets */
 103         ULONG64 Initial_num_of_packts_tx = 0, Initial_num_of_packts_rx = 0;
 104         /* values of TX and RX packets after 1 sec */
 105         ULONG64 Final_num_of_packts_tx = 0, Final_num_of_packts_rx = 0;
 106         /* Rate of transfer of Tx and Rx in 1 sec */
 107         ULONG64 rate_of_transfer_tx = 0, rate_of_transfer_rx = 0;
 108         int Status = STATUS_SUCCESS;
 109         INT num_of_time = 0, num_of_time_tx = 0, num_of_time_rx = 0;
 110         UINT remDelay = 0;
 111         BOOLEAN bBlinkBothLED = TRUE;
 112         /* UINT GPIO_num = DISABLE_GPIO_NUM; */
 113         ulong timeout = 0;
 114
 115         /* Read initial value of packets sent/received */
 116         Initial_num_of_packts_tx = Adapter->dev->stats.tx_packets;
 117         Initial_num_of_packts_rx = Adapter->dev->stats.rx_packets;
 118
 119         /* Scale the rate of transfer to no of blinks. */
 120         num_of_time_tx = ScaleRateofTransfer((ULONG)rate_of_transfer_tx);
 121         num_of_time_rx = ScaleRateofTransfer((ULONG)rate_of_transfer_rx);
 122
 123         while ((Adapter->device_removed == FALSE)) {
 124                 timeout = 50;
 125                 /*
 126                  * Blink Tx and Rx LED when both Tx and Rx is
 127                  * in normal bandwidth
 128                  */
 129                 if (bBlinkBothLED) {
 130                         /*
 131                          * Assign minimum number of blinks of
 132                          * either Tx or Rx.
 133                          */
 134                         if (num_of_time_tx > num_of_time_rx)
 135                                 num_of_time = num_of_time_rx;
 136                         else
 137                                 num_of_time = num_of_time_tx;
 138                         if (num_of_time > 0) {
 139                                 /* Blink both Tx and Rx LEDs */
 140                                 if (LED_Blink(Adapter, 1 << GPIO_Num_tx,
 141                                                 uiTxLedIndex, timeout,
 142                                                 num_of_time, currdriverstate)
 143                                                         == EVENT_SIGNALED)
 144                                         return EVENT_SIGNALED;
 145
 146                                 if (LED_Blink(Adapter, 1 << GPIO_Num_rx,
 147                                                 uiRxLedIndex, timeout,
 148                                                 num_of_time, currdriverstate)
 149                                                         == EVENT_SIGNALED)
 150                                         return EVENT_SIGNALED;
 151
 152                         }
 153
 154                         if (num_of_time == num_of_time_tx) {
 155                                 /* Blink pending rate of Rx */
 156                                 if (LED_Blink(Adapter, (1 << GPIO_Num_rx),
 157                                                 uiRxLedIndex, timeout,
 158                                                 num_of_time_rx-num_of_time,
 159                                                 currdriverstate)
 160                                                         == EVENT_SIGNALED)
 161                                         return EVENT_SIGNALED;
 162
 163                                 num_of_time = num_of_time_rx;
 164                         } else {
 165                                 /* Blink pending rate of Tx */
 166                                 if (LED_Blink(Adapter, 1 << GPIO_Num_tx,
 167                                                 uiTxLedIndex, timeout,
 168                                                 num_of_time_tx-num_of_time,
 169                                                 currdriverstate)
 170                                                         == EVENT_SIGNALED)
 171                                         return EVENT_SIGNALED;
 172
 173                                 num_of_time = num_of_time_tx;
 174                         }
 175                 } else {
 176                         if (num_of_time == num_of_time_tx) {
 177                                 /* Blink pending rate of Rx */
 178                                 if (LED_Blink(Adapter, 1 << GPIO_Num_tx,
 179                                                 uiTxLedIndex, timeout,
 180                                                 num_of_time, currdriverstate)
 181                                                         == EVENT_SIGNALED)
 182                                         return EVENT_SIGNALED;
 183                         } else {
 184                                 /* Blink pending rate of Tx */
 185                                 if (LED_Blink(Adapter, 1 << GPIO_Num_rx,
 186                                                 uiRxLedIndex, timeout,
 187                                                 num_of_time, currdriverstate)
 188                                                         == EVENT_SIGNALED)
 189                                         return EVENT_SIGNALED;
 190                         }
 191                 }
 192
 193                 /*
 194                  * If Tx/Rx rate is less than maximum blinks per second,
 195                  * wait till delay completes to 1 second
 196                  */
 197                 remDelay = MAX_NUM_OF_BLINKS - num_of_time;
 198                 if (remDelay > 0) {
 199                         timeout = 100 * remDelay;
 200                         Status = wait_event_interruptible_timeout(
 201                                         Adapter->LEDInfo.notify_led_event,
 202                                         currdriverstate != Adapter->DriverState
 203                                                 || kthread_should_stop(),
 204                                         msecs_to_jiffies(timeout));
 205
 206                         if (kthread_should_stop()) {
 207                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS,
 208                                         LED_DUMP_INFO, DBG_LVL_ALL,
 209                                         "Led thread got signal to exit..hence exiting");
 210                                 Adapter->LEDInfo.led_thread_running =
 211                                                 BCM_LED_THREAD_DISABLED;
 212                                 return EVENT_SIGNALED;
 213                         }
 214                         if (Status)
 215                                 return EVENT_SIGNALED;
 216                 }
 217
 218                 /* Turn off both Tx and Rx LEDs before next second */
 219                 TURN_OFF_LED(1 << GPIO_Num_tx, uiTxLedIndex);
 220                 TURN_OFF_LED(1 << GPIO_Num_rx, uiTxLedIndex);
 221
 222                 /*
 223                  * Read the Tx & Rx packets transmission after 1 second and
 224                  * calculate rate of transfer
 225                  */
 226                 Final_num_of_packts_tx = Adapter->dev->stats.tx_packets;
 227                 Final_num_of_packts_rx = Adapter->dev->stats.rx_packets;
 228
 229                 rate_of_transfer_tx = Final_num_of_packts_tx -
 230                                                 Initial_num_of_packts_tx;
 231                 rate_of_transfer_rx = Final_num_of_packts_rx -
 232                                                 Initial_num_of_packts_rx;
 233
 234                 /* Read initial value of packets sent/received */
 235                 Initial_num_of_packts_tx = Final_num_of_packts_tx;
 236                 Initial_num_of_packts_rx = Final_num_of_packts_rx;
 237
 238                 /* Scale the rate of transfer to no of blinks. */
 239                 num_of_time_tx =
 240                         ScaleRateofTransfer((ULONG)rate_of_transfer_tx);
 241                 num_of_time_rx =
 242                         ScaleRateofTransfer((ULONG)rate_of_transfer_rx);
 243
 244         }
 245         return Status;
 246 }
 247
 248 /*
 249  * -----------------------------------------------------------------------------
 250  * Procedure:   ValidateDSDParamsChecksum
 251  *
 252  * Description: Reads DSD Params and validates checkusm.
 253  *
 254  * Arguments:
 255  *      Adapter - Pointer to Adapter structure.
 256  *      ulParamOffset - Start offset of the DSD parameter to be read and
 257  *                      validated.
 258  *      usParamLen - Length of the DSD Parameter.
 259  *
 260  * Returns:
 261  *  <OSAL_STATUS_CODE>
 262  * -----------------------------------------------------------------------------
 263  */
 264 static INT ValidateDSDParamsChecksum(struct bcm_mini_adapter *Adapter, ULONG ulParamOffset,
 265                                         USHORT usParamLen)
 266 {
 267         INT Status = STATUS_SUCCESS;
 268         PUCHAR puBuffer = NULL;
 269         USHORT usChksmOrg = 0;
 270         USHORT usChecksumCalculated = 0;
 271
 272         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 273                 "LED Thread:ValidateDSDParamsChecksum: 0x%lx 0x%X",
 274                 ulParamOffset, usParamLen);
 275
 276         puBuffer = kmalloc(usParamLen, GFP_KERNEL);
 277         if (!puBuffer) {
 278                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 279                         DBG_LVL_ALL,
 280                         "LED Thread: ValidateDSDParamsChecksum Allocation failed");
 281                 return -ENOMEM;
 282
 283         }
 284
 285         /* Read the DSD data from the parameter offset. */
 286         if (STATUS_SUCCESS != BeceemNVMRead(Adapter, (PUINT)puBuffer,
 287                         ulParamOffset, usParamLen)) {
 288                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 289                         DBG_LVL_ALL,
 290                         "LED Thread: ValidateDSDParamsChecksum BeceemNVMRead failed");
 291                 Status = STATUS_IMAGE_CHECKSUM_MISMATCH;
 292                 goto exit;
 293         }
 294
 295         /* Calculate the checksum of the data read from the DSD parameter. */
 296         usChecksumCalculated = CFG_CalculateChecksum(puBuffer, usParamLen);
 297         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 298                 "LED Thread: usCheckSumCalculated = 0x%x\n",
 299                 usChecksumCalculated);
 300
 301         /*
 302          * End of the DSD parameter will have a TWO bytes checksum stored in it.
 303          * Read it and compare with the calculated Checksum.
 304          */
 305         if (STATUS_SUCCESS != BeceemNVMRead(Adapter, (PUINT)&usChksmOrg,
 306                         ulParamOffset+usParamLen, 2)) {
 307                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 308                         DBG_LVL_ALL,
 309                         "LED Thread: ValidateDSDParamsChecksum BeceemNVMRead failed");
 310                 Status = STATUS_IMAGE_CHECKSUM_MISMATCH;
 311                 goto exit;
 312         }
 313         usChksmOrg = ntohs(usChksmOrg);
 314         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 315                 "LED Thread: usChksmOrg = 0x%x", usChksmOrg);
 316
 317         /*
 318          * Compare the checksum calculated with the checksum read
 319          * from DSD section
 320          */
 321         if (usChecksumCalculated ^ usChksmOrg) {
 322                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 323                         DBG_LVL_ALL,
 324                         "LED Thread: ValidateDSDParamsChecksum: Checksums don't match");
 325                 Status = STATUS_IMAGE_CHECKSUM_MISMATCH;
 326                 goto exit;
 327         }
 328
 329 exit:
 330         kfree(puBuffer);
 331         return Status;
 332 }
 333
 334
 335 /*
 336  * -----------------------------------------------------------------------------
 337  * Procedure:   ValidateHWParmStructure
 338  *
 339  * Description: Validates HW Parameters.
 340  *
 341  * Arguments:
 342  *      Adapter - Pointer to Adapter structure.
 343  *      ulHwParamOffset - Start offset of the HW parameter Section to be read
 344  *                              and validated.
 345  *
 346  * Returns:
 347  *  <OSAL_STATUS_CODE>
 348  * -----------------------------------------------------------------------------
 349  */
 350 static INT ValidateHWParmStructure(struct bcm_mini_adapter *Adapter, ULONG ulHwParamOffset)
 351 {
 352
 353         INT Status = STATUS_SUCCESS;
 354         USHORT HwParamLen = 0;
 355         /*
 356          * Add DSD start offset to the hwParamOffset to get
 357          * the actual address.
 358          */
 359         ulHwParamOffset += DSD_START_OFFSET;
 360
 361         /* Read the Length of HW_PARAM structure */
 362         BeceemNVMRead(Adapter, (PUINT)&HwParamLen, ulHwParamOffset, 2);
 363         HwParamLen = ntohs(HwParamLen);
 364         if (0 == HwParamLen || HwParamLen > Adapter->uiNVMDSDSize)
 365                 return STATUS_IMAGE_CHECKSUM_MISMATCH;
 366
 367         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 368                 "LED Thread:HwParamLen = 0x%x", HwParamLen);
 369         Status = ValidateDSDParamsChecksum(Adapter, ulHwParamOffset,
 370                                                 HwParamLen);
 371         return Status;
 372 } /* ValidateHWParmStructure() */
 373
 374 static int ReadLEDInformationFromEEPROM(struct bcm_mini_adapter *Adapter,
 375                                         UCHAR GPIO_Array[])
 376 {
 377         int Status = STATUS_SUCCESS;
 378
 379         ULONG  dwReadValue      = 0;
 380         USHORT usHwParamData    = 0;
 381         USHORT usEEPROMVersion  = 0;
 382         UCHAR  ucIndex          = 0;
 383         UCHAR  ucGPIOInfo[32]   = {0};
 384
 385         BeceemNVMRead(Adapter, (PUINT)&usEEPROMVersion,
 386                         EEPROM_VERSION_OFFSET, 2);
 387
 388         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 389                 "usEEPROMVersion: Minor:0x%X Major:0x%x",
 390                 usEEPROMVersion&0xFF, ((usEEPROMVersion>>8)&0xFF));
 391
 392
 393         if (((usEEPROMVersion>>8)&0xFF) < EEPROM_MAP5_MAJORVERSION) {
 394                 BeceemNVMRead(Adapter, (PUINT)&usHwParamData,
 395                         EEPROM_HW_PARAM_POINTER_ADDRESS, 2);
 396                 usHwParamData = ntohs(usHwParamData);
 397                 dwReadValue   = usHwParamData;
 398         } else {
 399                 /*
 400                  * Validate Compatibility section and then read HW param
 401                  * if compatibility section is valid.
 402                  */
 403                 Status = ValidateDSDParamsChecksum(Adapter,
 404                                 DSD_START_OFFSET,
 405                                 COMPATIBILITY_SECTION_LENGTH_MAP5);
 406
 407                 if (Status != STATUS_SUCCESS)
 408                         return Status;
 409
 410                 BeceemNVMRead(Adapter, (PUINT)&dwReadValue,
 411                         EEPROM_HW_PARAM_POINTER_ADDRRES_MAP5, 4);
 412                 dwReadValue = ntohl(dwReadValue);
 413         }
 414
 415
 416         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 417                 "LED Thread: Start address of HW_PARAM structure = 0x%lx",
 418                 dwReadValue);
 419
 420         /*
 421          * Validate if the address read out is within the DSD.
 422          * Adapter->uiNVMDSDSize gives whole DSD size inclusive of Autoinit.
 423          * lower limit should be above DSD_START_OFFSET and
 424          * upper limit should be below (Adapter->uiNVMDSDSize-DSD_START_OFFSET)
 425          */
 426         if (dwReadValue < DSD_START_OFFSET ||
 427                         dwReadValue > (Adapter->uiNVMDSDSize-DSD_START_OFFSET))
 428                 return STATUS_IMAGE_CHECKSUM_MISMATCH;
 429
 430         Status = ValidateHWParmStructure(Adapter, dwReadValue);
 431         if (Status)
 432                 return Status;
 433
 434         /*
 435          * Add DSD_START_OFFSET to the offset read from the EEPROM.
 436          * This will give the actual start HW Parameters start address.
 437          * To read GPIO section, add GPIO offset further.
 438          */
 439
 440         dwReadValue +=
 441                 DSD_START_OFFSET; /* = start address of hw param section. */
 442         dwReadValue += GPIO_SECTION_START_OFFSET;
 443                         /* = GPIO start offset within HW Param section. */
 444
 445         /*
 446          * Read the GPIO values for 32 GPIOs from EEPROM and map the function
 447          * number to GPIO pin number to GPIO_Array
 448          */
 449         BeceemNVMRead(Adapter, (UINT *)ucGPIOInfo, dwReadValue, 32);
 450         for (ucIndex = 0; ucIndex < 32; ucIndex++) {
 451
 452                 switch (ucGPIOInfo[ucIndex]) {
 453                 case RED_LED:
 454                         GPIO_Array[RED_LED] = ucIndex;
 455                         Adapter->gpioBitMap |= (1 << ucIndex);
 456                         break;
 457                 case BLUE_LED:
 458                         GPIO_Array[BLUE_LED] = ucIndex;
 459                         Adapter->gpioBitMap |= (1 << ucIndex);
 460                         break;
 461                 case YELLOW_LED:
 462                         GPIO_Array[YELLOW_LED] = ucIndex;
 463                         Adapter->gpioBitMap |= (1 << ucIndex);
 464                         break;
 465                 case GREEN_LED:
 466                         GPIO_Array[GREEN_LED] = ucIndex;
 467                         Adapter->gpioBitMap |= (1 << ucIndex);
 468                         break;
 469                 default:
 470                         break;
 471                 }
 472
 473         }
 474         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 475                 "GPIO's bit map correspond to LED :0x%X", Adapter->gpioBitMap);
 476         return Status;
 477 }
 478
 479
 480 static int ReadConfigFileStructure(struct bcm_mini_adapter *Adapter,
 481                                         BOOLEAN *bEnableThread)
 482 {
 483         int Status = STATUS_SUCCESS;
 484         /* Array to store GPIO numbers from EEPROM */
 485         UCHAR GPIO_Array[NUM_OF_LEDS+1];
 486         UINT uiIndex = 0;
 487         UINT uiNum_of_LED_Type = 0;
 488         PUCHAR puCFGData        = NULL;
 489         UCHAR bData = 0;
 490         memset(GPIO_Array, DISABLE_GPIO_NUM, NUM_OF_LEDS+1);
 491
 492         if (!Adapter->pstargetparams || IS_ERR(Adapter->pstargetparams)) {
 493                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 494                         DBG_LVL_ALL, "Target Params not Avail.\n");
 495                 return -ENOENT;
 496         }
 497
 498         /* Populate GPIO_Array with GPIO numbers for LED functions */
 499         /* Read the GPIO numbers from EEPROM */
 500         Status = ReadLEDInformationFromEEPROM(Adapter, GPIO_Array);
 501         if (Status == STATUS_IMAGE_CHECKSUM_MISMATCH) {
 502                 *bEnableThread = FALSE;
 503                 return STATUS_SUCCESS;
 504         } else if (Status) {
 505                 *bEnableThread = FALSE;
 506                 return Status;
 507         }
 508
 509         /*
 510          * CONFIG file read successfully. Deallocate the memory of
 511          * uiFileNameBufferSize
 512          */
 513         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL,
 514                 "LED Thread: Config file read successfully\n");
 515         puCFGData = (PUCHAR) &Adapter->pstargetparams->HostDrvrConfig1;
 516
 517         /*
 518          * Offset for HostDrvConfig1, HostDrvConfig2, HostDrvConfig3 which
 519          * will have the information of LED type, LED on state for different
 520          * driver state and LED blink state.
 521          */
 522
 523         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 524                 bData = *puCFGData;
 525
 526                 /*
 527                  * Check Bit 8 for polarity. If it is set,
 528                  * polarity is reverse polarity
 529                  */
 530                 if (bData & 0x80) {
 531                         Adapter->LEDInfo.LEDState[uiIndex].BitPolarity = 0;
 532                         /* unset the bit 8 */
 533                         bData = bData & 0x7f;
 534                 }
 535
 536                 Adapter->LEDInfo.LEDState[uiIndex].LED_Type = bData;
 537                 if (bData <= NUM_OF_LEDS)
 538                         Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num =
 539                                                         GPIO_Array[bData];
 540                 else
 541                         Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num =
 542                                                         DISABLE_GPIO_NUM;
 543
 544                 puCFGData++;
 545                 bData = *puCFGData;
 546                 Adapter->LEDInfo.LEDState[uiIndex].LED_On_State = bData;
 547                 puCFGData++;
 548                 bData = *puCFGData;
 549                 Adapter->LEDInfo.LEDState[uiIndex].LED_Blink_State = bData;
 550                 puCFGData++;
 551         }
 552
 553         /*
 554          * Check if all the LED settings are disabled. If it is disabled,
 555          * dont launch the LED control thread.
 556          */
 557         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 558                 if ((Adapter->LEDInfo.LEDState[uiIndex].LED_Type == DISABLE_GPIO_NUM) ||
 559                         (Adapter->LEDInfo.LEDState[uiIndex].LED_Type == 0x7f) ||
 560                         (Adapter->LEDInfo.LEDState[uiIndex].LED_Type == 0))
 561                         uiNum_of_LED_Type++;
 562         }
 563         if (uiNum_of_LED_Type >= NUM_OF_LEDS)
 564                 *bEnableThread = FALSE;
 565
 566         return Status;
 567 }
 568
 569 /*
 570  * -----------------------------------------------------------------------------
 571  * Procedure:   LedGpioInit
 572  *
 573  * Description: Initializes LED GPIOs. Makes the LED GPIOs to OUTPUT mode
 574  *                        and make the initial state to be OFF.
 575  *
 576  * Arguments:
 577  *      Adapter - Pointer to MINI_ADAPTER structure.
 578  *
 579  * Returns: VOID
 580  *
 581  * -----------------------------------------------------------------------------
 582  */
 583 static VOID LedGpioInit(struct bcm_mini_adapter *Adapter)
 584 {
 585         UINT uiResetValue = 0;
 586         UINT uiIndex      = 0;
 587
 588         /* Set all LED GPIO Mode to output mode */
 589         if (rdmalt(Adapter, GPIO_MODE_REGISTER, &uiResetValue,
 590                         sizeof(uiResetValue)) < 0)
 591                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 592                         DBG_LVL_ALL, "LED Thread: RDM Failed\n");
 593         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 594                 if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num !=
 595                                 DISABLE_GPIO_NUM)
 596                         uiResetValue |= (1 << Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num);
 597                 TURN_OFF_LED(1 << Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num,
 598                                 uiIndex);
 599         }
 600         if (wrmalt(Adapter, GPIO_MODE_REGISTER, &uiResetValue,
 601                         sizeof(uiResetValue)) < 0)
 602                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 603                         DBG_LVL_ALL, "LED Thread: WRM Failed\n");
 604
 605         Adapter->LEDInfo.bIdle_led_off = FALSE;
 606 }
 607
 608 static INT BcmGetGPIOPinInfo(struct bcm_mini_adapter *Adapter, UCHAR *GPIO_num_tx,
 609                 UCHAR *GPIO_num_rx, UCHAR *uiLedTxIndex, UCHAR *uiLedRxIndex,
 610                 enum bcm_led_events currdriverstate)
 611 {
 612         UINT uiIndex = 0;
 613
 614         *GPIO_num_tx = DISABLE_GPIO_NUM;
 615         *GPIO_num_rx = DISABLE_GPIO_NUM;
 616
 617         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 618
 619                 if ((currdriverstate == NORMAL_OPERATION) ||
 620                                 (currdriverstate == IDLEMODE_EXIT) ||
 621                                 (currdriverstate == FW_DOWNLOAD)) {
 622                         if (Adapter->LEDInfo.LEDState[uiIndex].LED_Blink_State &
 623                                         currdriverstate) {
 624                                 if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num
 625                                                 != DISABLE_GPIO_NUM) {
 626                                         if (*GPIO_num_tx == DISABLE_GPIO_NUM) {
 627                                                 *GPIO_num_tx = Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num;
 628                                                 *uiLedTxIndex = uiIndex;
 629                                         } else {
 630                                                 *GPIO_num_rx = Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num;
 631                                                 *uiLedRxIndex = uiIndex;
 632                                         }
 633                                 }
 634                         }
 635                 } else {
 636                         if (Adapter->LEDInfo.LEDState[uiIndex].LED_On_State
 637                                         & currdriverstate) {
 638                                 if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num
 639                                                 != DISABLE_GPIO_NUM) {
 640                                         *GPIO_num_tx = Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num;
 641                                         *uiLedTxIndex = uiIndex;
 642                                 }
 643                         }
 644                 }
 645         }
 646         return STATUS_SUCCESS;
 647 }
 648 static VOID LEDControlThread(struct bcm_mini_adapter *Adapter)
 649 {
 650         UINT uiIndex = 0;
 651         UCHAR GPIO_num = 0;
 652         UCHAR uiLedIndex = 0;
 653         UINT uiResetValue = 0;
 654         enum bcm_led_events currdriverstate = 0;
 655         ulong timeout = 0;
 656
 657         INT Status = 0;
 658
 659         UCHAR dummyGPIONum = 0;
 660         UCHAR dummyIndex = 0;
 661
 662         /* currdriverstate = Adapter->DriverState; */
 663         Adapter->LEDInfo.bIdleMode_tx_from_host = FALSE;
 664
 665         /*
 666          * Wait till event is triggered
 667          *
 668          * wait_event(Adapter->LEDInfo.notify_led_event,
 669          *      currdriverstate!= Adapter->DriverState);
 670          */
 671
 672         GPIO_num = DISABLE_GPIO_NUM;
 673
 674         while (TRUE) {
 675                 /* Wait till event is triggered */
 676                 if ((GPIO_num == DISABLE_GPIO_NUM)
 677                                                 ||
 678                                 ((currdriverstate != FW_DOWNLOAD) &&
 679                                  (currdriverstate != NORMAL_OPERATION) &&
 680                                  (currdriverstate != LOWPOWER_MODE_ENTER))
 681                                                 ||
 682                                 (currdriverstate == LED_THREAD_INACTIVE))
 683                         Status = wait_event_interruptible(
 684                                         Adapter->LEDInfo.notify_led_event,
 685                                         currdriverstate != Adapter->DriverState
 686                                                 || kthread_should_stop());
 687
 688                 if (kthread_should_stop() || Adapter->device_removed) {
 689                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 690                                 DBG_LVL_ALL,
 691                                 "Led thread got signal to exit..hence exiting");
 692                         Adapter->LEDInfo.led_thread_running =
 693                                                 BCM_LED_THREAD_DISABLED;
 694                         TURN_OFF_LED(1 << GPIO_num, uiLedIndex);
 695                         return; /* STATUS_FAILURE; */
 696                 }
 697
 698                 if (GPIO_num != DISABLE_GPIO_NUM)
 699                         TURN_OFF_LED(1 << GPIO_num, uiLedIndex);
 700
 701                 if (Adapter->LEDInfo.bLedInitDone == FALSE) {
 702                         LedGpioInit(Adapter);
 703                         Adapter->LEDInfo.bLedInitDone = TRUE;
 704                 }
 705
 706                 switch (Adapter->DriverState) {
 707                 case DRIVER_INIT:
 708                         currdriverstate = DRIVER_INIT;
 709                                         /* Adapter->DriverState; */
 710                         BcmGetGPIOPinInfo(Adapter, &GPIO_num, &dummyGPIONum,
 711                                 &uiLedIndex, &dummyIndex, currdriverstate);
 712
 713                         if (GPIO_num != DISABLE_GPIO_NUM)
 714                                 TURN_ON_LED(1 << GPIO_num, uiLedIndex);
 715
 716                         break;
 717                 case FW_DOWNLOAD:
 718                         /*
 719                          * BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS,
 720                          *      LED_DUMP_INFO, DBG_LVL_ALL,
 721                          *      "LED Thread: FW_DN_DONE called\n");
 722                          */
 723                         currdriverstate = FW_DOWNLOAD;
 724                         BcmGetGPIOPinInfo(Adapter, &GPIO_num, &dummyGPIONum,
 725                                 &uiLedIndex, &dummyIndex, currdriverstate);
 726
 727                         if (GPIO_num != DISABLE_GPIO_NUM) {
 728                                 timeout = 50;
 729                                 LED_Blink(Adapter, 1 << GPIO_num, uiLedIndex,
 730                                         timeout, -1, currdriverstate);
 731                         }
 732                         break;
 733                 case FW_DOWNLOAD_DONE:
 734                         currdriverstate = FW_DOWNLOAD_DONE;
 735                         BcmGetGPIOPinInfo(Adapter, &GPIO_num, &dummyGPIONum,
 736                                 &uiLedIndex, &dummyIndex, currdriverstate);
 737                         if (GPIO_num != DISABLE_GPIO_NUM)
 738                                 TURN_ON_LED(1 << GPIO_num, uiLedIndex);
 739                         break;
 740
 741                 case SHUTDOWN_EXIT:
 742                         /*
 743                          * no break, continue to NO_NETWORK_ENTRY
 744                          * state as well.
 745                          */
 746                 case NO_NETWORK_ENTRY:
 747                         currdriverstate = NO_NETWORK_ENTRY;
 748                         BcmGetGPIOPinInfo(Adapter, &GPIO_num, &dummyGPIONum,
 749                                 &uiLedIndex, &dummyGPIONum, currdriverstate);
 750                         if (GPIO_num != DISABLE_GPIO_NUM)
 751                                 TURN_ON_LED(1 << GPIO_num, uiLedIndex);
 752                         break;
 753                 case NORMAL_OPERATION:
 754                         {
 755                                 UCHAR GPIO_num_tx = DISABLE_GPIO_NUM;
 756                                 UCHAR GPIO_num_rx = DISABLE_GPIO_NUM;
 757                                 UCHAR uiLEDTx = 0;
 758                                 UCHAR uiLEDRx = 0;
 759                                 currdriverstate = NORMAL_OPERATION;
 760                                 Adapter->LEDInfo.bIdle_led_off = FALSE;
 761
 762                                 BcmGetGPIOPinInfo(Adapter, &GPIO_num_tx,
 763                                         &GPIO_num_rx, &uiLEDTx, &uiLEDRx,
 764                                         currdriverstate);
 765                                 if ((GPIO_num_tx == DISABLE_GPIO_NUM) &&
 766                                                 (GPIO_num_rx ==
 767                                                  DISABLE_GPIO_NUM)) {
 768                                         GPIO_num = DISABLE_GPIO_NUM;
 769                                 } else {
 770                                         /*
 771                                          * If single LED is selected, use same
 772                                          * for both Tx and Rx
 773                                          */
 774                                         if (GPIO_num_tx == DISABLE_GPIO_NUM) {
 775                                                 GPIO_num_tx = GPIO_num_rx;
 776                                                 uiLEDTx = uiLEDRx;
 777                                         } else if (GPIO_num_rx ==
 778                                                         DISABLE_GPIO_NUM) {
 779                                                 GPIO_num_rx = GPIO_num_tx;
 780                                                 uiLEDRx = uiLEDTx;
 781                                         }
 782                                         /*
 783                                          * Blink the LED in proportionate
 784                                          * to Tx and Rx transmissions.
 785                                          */
 786                                         LED_Proportional_Blink(Adapter,
 787                                                 GPIO_num_tx, uiLEDTx,
 788                                                 GPIO_num_rx, uiLEDRx,
 789                                                 currdriverstate);
 790                                 }
 791                         }
 792                         break;
 793                 case LOWPOWER_MODE_ENTER:
 794                         currdriverstate = LOWPOWER_MODE_ENTER;
 795                         if (DEVICE_POWERSAVE_MODE_AS_MANUAL_CLOCK_GATING ==
 796                                         Adapter->ulPowerSaveMode) {
 797                                 /* Turn OFF all the LED */
 798                                 uiResetValue = 0;
 799                                 for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 800                                         if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num != DISABLE_GPIO_NUM)
 801                                                 TURN_OFF_LED((1 << Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num), uiIndex);
 802                                 }
 803
 804                         }
 805                         /* Turn off LED And WAKE-UP for Sendinf IDLE mode ACK */
 806                         Adapter->LEDInfo.bLedInitDone = FALSE;
 807                         Adapter->LEDInfo.bIdle_led_off = TRUE;
 808                         wake_up(&Adapter->LEDInfo.idleModeSyncEvent);
 809                         GPIO_num = DISABLE_GPIO_NUM;
 810                         break;
 811                 case IDLEMODE_CONTINUE:
 812                         currdriverstate = IDLEMODE_CONTINUE;
 813                         GPIO_num = DISABLE_GPIO_NUM;
 814                         break;
 815                 case IDLEMODE_EXIT:
 816                         break;
 817                 case DRIVER_HALT:
 818                         currdriverstate = DRIVER_HALT;
 819                         GPIO_num = DISABLE_GPIO_NUM;
 820                         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 821                                 if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num
 822                                                 != DISABLE_GPIO_NUM)
 823                                         TURN_OFF_LED((1 << Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num), uiIndex);
 824                         }
 825                         /* Adapter->DriverState = DRIVER_INIT; */
 826                         break;
 827                 case LED_THREAD_INACTIVE:
 828                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 829                                 DBG_LVL_ALL, "InActivating LED thread...");
 830                         currdriverstate = LED_THREAD_INACTIVE;
 831                         Adapter->LEDInfo.led_thread_running =
 832                                         BCM_LED_THREAD_RUNNING_INACTIVELY;
 833                         Adapter->LEDInfo.bLedInitDone = FALSE;
 834                         /* disable ALL LED */
 835                         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++) {
 836                                 if (Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num
 837                                                 != DISABLE_GPIO_NUM)
 838                                         TURN_OFF_LED((1 << Adapter->LEDInfo.LEDState[uiIndex].GPIO_Num), uiIndex);
 839                         }
 840                         break;
 841                 case LED_THREAD_ACTIVE:
 842                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 843                                 DBG_LVL_ALL, "Activating LED thread again...");
 844                         if (Adapter->LinkUpStatus == FALSE)
 845                                 Adapter->DriverState = NO_NETWORK_ENTRY;
 846                         else
 847                                 Adapter->DriverState = NORMAL_OPERATION;
 848
 849                         Adapter->LEDInfo.led_thread_running =
 850                                         BCM_LED_THREAD_RUNNING_ACTIVELY;
 851                         break;
 852                         /* return; */
 853                 default:
 854                         break;
 855                 }
 856         }
 857         Adapter->LEDInfo.led_thread_running = BCM_LED_THREAD_DISABLED;
 858 }
 859
 860 int InitLedSettings(struct bcm_mini_adapter *Adapter)
 861 {
 862         int Status = STATUS_SUCCESS;
 863         BOOLEAN bEnableThread = TRUE;
 864         UCHAR uiIndex = 0;
 865
 866         /*
 867          * Initially set BitPolarity to normal polarity. The bit 8 of LED type
 868          * is used to change the polarity of the LED.
 869          */
 870
 871         for (uiIndex = 0; uiIndex < NUM_OF_LEDS; uiIndex++)
 872                 Adapter->LEDInfo.LEDState[uiIndex].BitPolarity = 1;
 873
 874         /*
 875          * Read the LED settings of CONFIG file and map it
 876          * to GPIO numbers in EEPROM
 877          */
 878         Status = ReadConfigFileStructure(Adapter, &bEnableThread);
 879         if (STATUS_SUCCESS != Status) {
 880                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 881                         DBG_LVL_ALL,
 882                         "LED Thread: FAILED in ReadConfigFileStructure\n");
 883                 return Status;
 884         }
 885
 886         if (Adapter->LEDInfo.led_thread_running) {
 887                 if (bEnableThread) {
 888                         ;
 889                 } else {
 890                         Adapter->DriverState = DRIVER_HALT;
 891                         wake_up(&Adapter->LEDInfo.notify_led_event);
 892                         Adapter->LEDInfo.led_thread_running =
 893                                                 BCM_LED_THREAD_DISABLED;
 894                 }
 895
 896         } else if (bEnableThread) {
 897                 /* Create secondary thread to handle the LEDs */
 898                 init_waitqueue_head(&Adapter->LEDInfo.notify_led_event);
 899                 init_waitqueue_head(&Adapter->LEDInfo.idleModeSyncEvent);
 900                 Adapter->LEDInfo.led_thread_running =
 901                                         BCM_LED_THREAD_RUNNING_ACTIVELY;
 902                 Adapter->LEDInfo.bIdle_led_off = FALSE;
 903                 Adapter->LEDInfo.led_cntrl_threadid =
 904                         kthread_run((int (*)(void *)) LEDControlThread,
 905                         Adapter, "led_control_thread");
 906                 if (IS_ERR(Adapter->LEDInfo.led_cntrl_threadid)) {
 907                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LED_DUMP_INFO,
 908                                 DBG_LVL_ALL,
 909                                 "Not able to spawn Kernel Thread\n");
 910                         Adapter->LEDInfo.led_thread_running =
 911                                 BCM_LED_THREAD_DISABLED;
 912                         return PTR_ERR(Adapter->LEDInfo.led_cntrl_threadid);
 913                 }
 914         }
 915         return Status;
 916 }