LXR linux/drivers/staging/rtl8712/rtl8712

   1// SPDX-License-Identifier: GPL-2.0
   2/******************************************************************************
   3 * rtl8712_led.c
   4 *
   5 * Copyright(c) 2007 - 2010  Realtek Corporation. All rights reserved.
   6 * Linux device driver for RTL8192SU
   7 *
   8 * Modifications for inclusion into the Linux staging tree are
   9 * Copyright(c) 2010 Larry Finger. All rights reserved.
  10 *
  11 * Contact information:
  12 * WLAN FAE <wlanfae@realtek.com>
  13 * Larry Finger <Larry.Finger@lwfinger.net>
  14 *
  15 ******************************************************************************/
  16
  17#include "drv_types.h"
  18
  19/*===========================================================================
  20 *      Constant.
  21 *===========================================================================
  22
  23 *
  24 * Default LED behavior.
  25 */
  26#define LED_BLINK_NORMAL_INTERVAL       100
  27#define LED_BLINK_SLOWLY_INTERVAL       200
  28#define LED_BLINK_LONG_INTERVAL 400
  29
  30#define LED_BLINK_NO_LINK_INTERVAL_ALPHA        1000
  31#define LED_BLINK_LINK_INTERVAL_ALPHA           500
  32#define LED_BLINK_SCAN_INTERVAL_ALPHA           180
  33#define LED_BLINK_FASTER_INTERVAL_ALPHA         50
  34#define LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA    5000
  35
  36/*===========================================================================
  37 * LED object.
  38 *===========================================================================
  39 */
  40enum _LED_STATE_871x {
  41        LED_UNKNOWN = 0,
  42        LED_STATE_ON = 1,
  43        LED_STATE_OFF = 2,
  44        LED_BLINK_NORMAL = 3,
  45        LED_BLINK_SLOWLY = 4,
  46        LED_POWER_ON_BLINK = 5,
  47        LED_SCAN_BLINK = 6, /* LED is blinking during scanning period,
  48                             * the # of times to blink is depend on time
  49                             * for scanning.
  50                             */
  51        LED_NO_LINK_BLINK = 7, /* LED is blinking during no link state. */
  52        LED_BLINK_StartToBlink = 8,/* Customized for Sercomm Printer
  53                                    * Server case
  54                                    */
  55        LED_BLINK_WPS = 9,      /* LED is blinkg during WPS communication */
  56        LED_TXRX_BLINK = 10,
  57        LED_BLINK_WPS_STOP = 11,        /*for ALPHA */
  58        LED_BLINK_WPS_STOP_OVERLAP = 12,        /*for BELKIN */
  59};
  60
  61/*===========================================================================
  62 *      Prototype of protected function.
  63 *===========================================================================
  64 */
  65static void BlinkTimerCallback(struct timer_list *t);
  66
  67static void BlinkWorkItemCallback(struct work_struct *work);
  68/*===========================================================================
  69 * LED_819xUsb routines.
  70 *===========================================================================
  71 *
  72 *
  73 *
  74 *      Description:
  75 *              Initialize an LED_871x object.
  76 */
  77static void InitLed871x(struct _adapter *padapter, struct LED_871x *pLed,
  78                 enum LED_PIN_871x      LedPin)
  79{
  80        pLed->padapter = padapter;
  81        pLed->LedPin = LedPin;
  82        pLed->CurrLedState = LED_STATE_OFF;
  83        pLed->bLedOn = false;
  84        pLed->bLedBlinkInProgress = false;
  85        pLed->BlinkTimes = 0;
  86        pLed->BlinkingLedState = LED_UNKNOWN;
  87        timer_setup(&pLed->BlinkTimer, BlinkTimerCallback, 0);
  88        INIT_WORK(&pLed->BlinkWorkItem, BlinkWorkItemCallback);
  89}
  90
  91/*
  92 *      Description:
  93 *              DeInitialize an LED_871x object.
  94 */
  95static void DeInitLed871x(struct LED_871x *pLed)
  96{
  97        del_timer_sync(&pLed->BlinkTimer);
  98        /* We should reset bLedBlinkInProgress if we cancel
  99         * the LedControlTimer,
 100         */
 101        pLed->bLedBlinkInProgress = false;
 102}
 103
 104/*
 105 *      Description:
 106 *              Turn on LED according to LedPin specified.
 107 */
 108static void SwLedOn(struct _adapter *padapter, struct LED_871x *pLed)
 109{
 110        u8      LedCfg;
 111
 112        if (padapter->surprise_removed || padapter->driver_stopped)
 113                return;
 114        LedCfg = r8712_read8(padapter, LEDCFG);
 115        switch (pLed->LedPin) {
 116        case LED_PIN_GPIO0:
 117                break;
 118        case LED_PIN_LED0:
 119                /* SW control led0 on.*/
 120                r8712_write8(padapter, LEDCFG, LedCfg & 0xf0);
 121                break;
 122        case LED_PIN_LED1:
 123                /* SW control led1 on.*/
 124                r8712_write8(padapter, LEDCFG, LedCfg & 0x0f);
 125                break;
 126        default:
 127                break;
 128        }
 129        pLed->bLedOn = true;
 130}
 131
 132/*
 133 *      Description:
 134 *              Turn off LED according to LedPin specified.
 135 */
 136static void SwLedOff(struct _adapter *padapter, struct LED_871x *pLed)
 137{
 138        u8      LedCfg;
 139
 140        if (padapter->surprise_removed || padapter->driver_stopped)
 141                return;
 142        LedCfg = r8712_read8(padapter, LEDCFG);
 143        switch (pLed->LedPin) {
 144        case LED_PIN_GPIO0:
 145                break;
 146        case LED_PIN_LED0:
 147                LedCfg &= 0xf0; /* Set to software control.*/
 148                r8712_write8(padapter, LEDCFG, (LedCfg | BIT(3)));
 149                break;
 150        case LED_PIN_LED1:
 151                LedCfg &= 0x0f; /* Set to software control.*/
 152                r8712_write8(padapter, LEDCFG, (LedCfg | BIT(7)));
 153                break;
 154        default:
 155                break;
 156        }
 157        pLed->bLedOn = false;
 158}
 159
 160/*===========================================================================
 161 * Interface to manipulate LED objects.
 162 *===========================================================================
 163 *
 164 *      Description:
 165 *              Initialize all LED_871x objects.
 166 */
 167void r8712_InitSwLeds(struct _adapter *padapter)
 168{
 169        struct led_priv *pledpriv = &padapter->ledpriv;
 170
 171        pledpriv->LedControlHandler = LedControl871x;
 172        InitLed871x(padapter, &pledpriv->SwLed0, LED_PIN_LED0);
 173        InitLed871x(padapter, &pledpriv->SwLed1, LED_PIN_LED1);
 174}
 175
 176/*      Description:
 177 *              DeInitialize all LED_819xUsb objects.
 178 */
 179void r8712_DeInitSwLeds(struct _adapter *padapter)
 180{
 181        struct led_priv *ledpriv = &padapter->ledpriv;
 182
 183        DeInitLed871x(&ledpriv->SwLed0);
 184        DeInitLed871x(&ledpriv->SwLed1);
 185}
 186
 187/*      Description:
 188 *              Implementation of LED blinking behavior.
 189 *              It toggle off LED and schedule corresponding timer if necessary.
 190 */
 191static void SwLedBlink(struct LED_871x *pLed)
 192{
 193        struct _adapter *padapter = pLed->padapter;
 194        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 195        u8 bStopBlinking = false;
 196
 197        /* Change LED according to BlinkingLedState specified. */
 198        if (pLed->BlinkingLedState == LED_STATE_ON)
 199                SwLedOn(padapter, pLed);
 200        else
 201                SwLedOff(padapter, pLed);
 202        /* Determine if we shall change LED state again. */
 203        pLed->BlinkTimes--;
 204        switch (pLed->CurrLedState) {
 205        case LED_BLINK_NORMAL:
 206                if (pLed->BlinkTimes == 0)
 207                        bStopBlinking = true;
 208                break;
 209        case LED_BLINK_StartToBlink:
 210                if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 211                    (pmlmepriv->fw_state & WIFI_STATION_STATE))
 212                        bStopBlinking = true;
 213                if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 214                    ((pmlmepriv->fw_state & WIFI_ADHOC_STATE) ||
 215                    (pmlmepriv->fw_state & WIFI_ADHOC_MASTER_STATE)))
 216                        bStopBlinking = true;
 217                else if (pLed->BlinkTimes == 0)
 218                        bStopBlinking = true;
 219                break;
 220        case LED_BLINK_WPS:
 221                if (pLed->BlinkTimes == 0)
 222                        bStopBlinking = true;
 223                break;
 224        default:
 225                bStopBlinking = true;
 226                break;
 227        }
 228        if (bStopBlinking) {
 229                if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 230                    !pLed->bLedOn)
 231                        SwLedOn(padapter, pLed);
 232                else if (check_fwstate(pmlmepriv, _FW_LINKED) &&  pLed->bLedOn)
 233                        SwLedOff(padapter, pLed);
 234                pLed->BlinkTimes = 0;
 235                pLed->bLedBlinkInProgress = false;
 236        } else {
 237                /* Assign LED state to toggle. */
 238                if (pLed->BlinkingLedState == LED_STATE_ON)
 239                        pLed->BlinkingLedState = LED_STATE_OFF;
 240                else
 241                        pLed->BlinkingLedState = LED_STATE_ON;
 242
 243                /* Schedule a timer to toggle LED state. */
 244                switch (pLed->CurrLedState) {
 245                case LED_BLINK_NORMAL:
 246                        mod_timer(&pLed->BlinkTimer, jiffies +
 247                                  msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 248                        break;
 249                case LED_BLINK_SLOWLY:
 250                case LED_BLINK_StartToBlink:
 251                        mod_timer(&pLed->BlinkTimer, jiffies +
 252                                  msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 253                        break;
 254                case LED_BLINK_WPS:
 255                        mod_timer(&pLed->BlinkTimer, jiffies +
 256                                  msecs_to_jiffies(LED_BLINK_LONG_INTERVAL));
 257                        break;
 258                default:
 259                        mod_timer(&pLed->BlinkTimer, jiffies +
 260                                  msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 261                        break;
 262                }
 263        }
 264}
 265
 266static void SwLedBlink1(struct LED_871x *pLed)
 267{
 268        struct _adapter *padapter = pLed->padapter;
 269        struct led_priv *ledpriv = &padapter->ledpriv;
 270        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 271        struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
 272        struct LED_871x *pLed1 = &ledpriv->SwLed1;
 273        u8 bStopBlinking = false;
 274
 275        if (peeprompriv->CustomerID == RT_CID_819x_CAMEO)
 276                pLed = &ledpriv->SwLed1;
 277        /* Change LED according to BlinkingLedState specified. */
 278        if (pLed->BlinkingLedState == LED_STATE_ON)
 279                SwLedOn(padapter, pLed);
 280        else
 281                SwLedOff(padapter, pLed);
 282        if (peeprompriv->CustomerID == RT_CID_DEFAULT) {
 283                if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 284                        if (!pLed1->bSWLedCtrl) {
 285                                SwLedOn(padapter, pLed1);
 286                                pLed1->bSWLedCtrl = true;
 287                        } else if (!pLed1->bLedOn) {
 288                                SwLedOn(padapter, pLed1);
 289                        }
 290                } else {
 291                        if (!pLed1->bSWLedCtrl) {
 292                                SwLedOff(padapter, pLed1);
 293                                pLed1->bSWLedCtrl = true;
 294                        } else if (pLed1->bLedOn) {
 295                                SwLedOff(padapter, pLed1);
 296                        }
 297                }
 298        }
 299        switch (pLed->CurrLedState) {
 300        case LED_BLINK_SLOWLY:
 301                if (pLed->bLedOn)
 302                        pLed->BlinkingLedState = LED_STATE_OFF;
 303                else
 304                        pLed->BlinkingLedState = LED_STATE_ON;
 305                mod_timer(&pLed->BlinkTimer, jiffies +
 306                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 307                break;
 308        case LED_BLINK_NORMAL:
 309                if (pLed->bLedOn)
 310                        pLed->BlinkingLedState = LED_STATE_OFF;
 311                else
 312                        pLed->BlinkingLedState = LED_STATE_ON;
 313                mod_timer(&pLed->BlinkTimer, jiffies +
 314                          msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 315                break;
 316        case LED_SCAN_BLINK:
 317                pLed->BlinkTimes--;
 318                if (pLed->BlinkTimes == 0)
 319                        bStopBlinking = true;
 320                if (bStopBlinking) {
 321                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 322                                pLed->bLedLinkBlinkInProgress = true;
 323                                pLed->CurrLedState = LED_BLINK_NORMAL;
 324                                if (pLed->bLedOn)
 325                                        pLed->BlinkingLedState = LED_STATE_OFF;
 326                                else
 327                                        pLed->BlinkingLedState = LED_STATE_ON;
 328                                mod_timer(&pLed->BlinkTimer, jiffies +
 329                                          msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 330                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 331                                pLed->bLedNoLinkBlinkInProgress = true;
 332                                pLed->CurrLedState = LED_BLINK_SLOWLY;
 333                                if (pLed->bLedOn)
 334                                        pLed->BlinkingLedState = LED_STATE_OFF;
 335                                else
 336                                        pLed->BlinkingLedState = LED_STATE_ON;
 337                                mod_timer(&pLed->BlinkTimer, jiffies +
 338                                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 339                        }
 340                        pLed->bLedScanBlinkInProgress = false;
 341                } else {
 342                        if (pLed->bLedOn)
 343                                pLed->BlinkingLedState = LED_STATE_OFF;
 344                        else
 345                                pLed->BlinkingLedState = LED_STATE_ON;
 346                        mod_timer(&pLed->BlinkTimer, jiffies +
 347                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 348                }
 349                break;
 350        case LED_TXRX_BLINK:
 351                pLed->BlinkTimes--;
 352                if (pLed->BlinkTimes == 0)
 353                        bStopBlinking = true;
 354                if (bStopBlinking) {
 355                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 356                                pLed->bLedLinkBlinkInProgress = true;
 357                                pLed->CurrLedState = LED_BLINK_NORMAL;
 358                                if (pLed->bLedOn)
 359                                        pLed->BlinkingLedState = LED_STATE_OFF;
 360                                else
 361                                        pLed->BlinkingLedState = LED_STATE_ON;
 362                                mod_timer(&pLed->BlinkTimer, jiffies +
 363                                          msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 364                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 365                                pLed->bLedNoLinkBlinkInProgress = true;
 366                                pLed->CurrLedState = LED_BLINK_SLOWLY;
 367                                if (pLed->bLedOn)
 368                                        pLed->BlinkingLedState = LED_STATE_OFF;
 369                                else
 370                                        pLed->BlinkingLedState = LED_STATE_ON;
 371                                mod_timer(&pLed->BlinkTimer, jiffies +
 372                                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 373                        }
 374                        pLed->BlinkTimes = 0;
 375                        pLed->bLedBlinkInProgress = false;
 376                } else {
 377                        if (pLed->bLedOn)
 378                                pLed->BlinkingLedState = LED_STATE_OFF;
 379                        else
 380                                pLed->BlinkingLedState = LED_STATE_ON;
 381                        mod_timer(&pLed->BlinkTimer, jiffies +
 382                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 383                }
 384                break;
 385        case LED_BLINK_WPS:
 386                if (pLed->bLedOn)
 387                        pLed->BlinkingLedState = LED_STATE_OFF;
 388                else
 389                        pLed->BlinkingLedState = LED_STATE_ON;
 390                mod_timer(&pLed->BlinkTimer, jiffies +
 391                          msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 392                break;
 393        case LED_BLINK_WPS_STOP:        /* WPS success */
 394                if (pLed->BlinkingLedState == LED_STATE_ON) {
 395                        pLed->BlinkingLedState = LED_STATE_OFF;
 396                        mod_timer(&pLed->BlinkTimer, jiffies +
 397                                  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
 398                        bStopBlinking = false;
 399                } else {
 400                        bStopBlinking = true;
 401                }
 402                if (bStopBlinking) {
 403                        pLed->bLedLinkBlinkInProgress = true;
 404                        pLed->CurrLedState = LED_BLINK_NORMAL;
 405                        if (pLed->bLedOn)
 406                                pLed->BlinkingLedState = LED_STATE_OFF;
 407                        else
 408                                pLed->BlinkingLedState = LED_STATE_ON;
 409                        mod_timer(&pLed->BlinkTimer, jiffies +
 410                                  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 411                }
 412                pLed->bLedWPSBlinkInProgress = false;
 413                break;
 414        default:
 415                break;
 416        }
 417}
 418
 419static void SwLedBlink2(struct LED_871x *pLed)
 420{
 421        struct _adapter *padapter = pLed->padapter;
 422        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 423        u8 bStopBlinking = false;
 424
 425        /* Change LED according to BlinkingLedState specified. */
 426        if (pLed->BlinkingLedState == LED_STATE_ON)
 427                SwLedOn(padapter, pLed);
 428        else
 429                SwLedOff(padapter, pLed);
 430        switch (pLed->CurrLedState) {
 431        case LED_SCAN_BLINK:
 432                pLed->BlinkTimes--;
 433                if (pLed->BlinkTimes == 0)
 434                        bStopBlinking = true;
 435                if (bStopBlinking) {
 436                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 437                                pLed->CurrLedState = LED_STATE_ON;
 438                                pLed->BlinkingLedState = LED_STATE_ON;
 439                                SwLedOn(padapter, pLed);
 440                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 441                                pLed->CurrLedState = LED_STATE_OFF;
 442                                pLed->BlinkingLedState = LED_STATE_OFF;
 443                                SwLedOff(padapter, pLed);
 444                        }
 445                        pLed->bLedScanBlinkInProgress = false;
 446                } else {
 447                        if (pLed->bLedOn)
 448                                pLed->BlinkingLedState = LED_STATE_OFF;
 449                        else
 450                                pLed->BlinkingLedState = LED_STATE_ON;
 451                        mod_timer(&pLed->BlinkTimer, jiffies +
 452                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 453                }
 454                break;
 455        case LED_TXRX_BLINK:
 456                pLed->BlinkTimes--;
 457                if (pLed->BlinkTimes == 0)
 458                        bStopBlinking = true;
 459                if (bStopBlinking) {
 460                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 461                                pLed->CurrLedState = LED_STATE_ON;
 462                                pLed->BlinkingLedState = LED_STATE_ON;
 463                                SwLedOn(padapter, pLed);
 464                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 465                                pLed->CurrLedState = LED_STATE_OFF;
 466                                pLed->BlinkingLedState = LED_STATE_OFF;
 467                                SwLedOff(padapter, pLed);
 468                        }
 469                        pLed->bLedBlinkInProgress = false;
 470                } else {
 471                        if (pLed->bLedOn)
 472                                pLed->BlinkingLedState = LED_STATE_OFF;
 473                        else
 474                                pLed->BlinkingLedState = LED_STATE_ON;
 475                        mod_timer(&pLed->BlinkTimer, jiffies +
 476                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 477                }
 478                break;
 479        default:
 480                break;
 481        }
 482}
 483
 484static void SwLedBlink3(struct LED_871x *pLed)
 485{
 486        struct _adapter *padapter = pLed->padapter;
 487        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 488        u8 bStopBlinking = false;
 489
 490        /* Change LED according to BlinkingLedState specified. */
 491        if (pLed->BlinkingLedState == LED_STATE_ON)
 492                SwLedOn(padapter, pLed);
 493        else
 494                if (pLed->CurrLedState != LED_BLINK_WPS_STOP)
 495                        SwLedOff(padapter, pLed);
 496        switch (pLed->CurrLedState) {
 497        case LED_SCAN_BLINK:
 498                pLed->BlinkTimes--;
 499                if (pLed->BlinkTimes == 0)
 500                        bStopBlinking = true;
 501                if (bStopBlinking) {
 502                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 503                                pLed->CurrLedState = LED_STATE_ON;
 504                                pLed->BlinkingLedState = LED_STATE_ON;
 505                                if (!pLed->bLedOn)
 506                                        SwLedOn(padapter, pLed);
 507                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 508                                pLed->CurrLedState = LED_STATE_OFF;
 509                                pLed->BlinkingLedState = LED_STATE_OFF;
 510                                if (pLed->bLedOn)
 511                                        SwLedOff(padapter, pLed);
 512                        }
 513                        pLed->bLedScanBlinkInProgress = false;
 514                } else {
 515                        if (pLed->bLedOn)
 516                                pLed->BlinkingLedState = LED_STATE_OFF;
 517                        else
 518                                pLed->BlinkingLedState = LED_STATE_ON;
 519                        mod_timer(&pLed->BlinkTimer, jiffies +
 520                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 521                }
 522                break;
 523        case LED_TXRX_BLINK:
 524                pLed->BlinkTimes--;
 525                if (pLed->BlinkTimes == 0)
 526                        bStopBlinking = true;
 527                if (bStopBlinking) {
 528                        if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 529                                pLed->CurrLedState = LED_STATE_ON;
 530                                pLed->BlinkingLedState = LED_STATE_ON;
 531                                if (!pLed->bLedOn)
 532                                        SwLedOn(padapter, pLed);
 533                        } else if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
 534                                pLed->CurrLedState = LED_STATE_OFF;
 535                                pLed->BlinkingLedState = LED_STATE_OFF;
 536                                if (pLed->bLedOn)
 537                                        SwLedOff(padapter, pLed);
 538                        }
 539                        pLed->bLedBlinkInProgress = false;
 540                } else {
 541                        if (pLed->bLedOn)
 542                                pLed->BlinkingLedState = LED_STATE_OFF;
 543                        else
 544                                pLed->BlinkingLedState = LED_STATE_ON;
 545                        mod_timer(&pLed->BlinkTimer, jiffies +
 546                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 547                }
 548                break;
 549        case LED_BLINK_WPS:
 550                if (pLed->bLedOn)
 551                        pLed->BlinkingLedState = LED_STATE_OFF;
 552                else
 553                        pLed->BlinkingLedState = LED_STATE_ON;
 554                mod_timer(&pLed->BlinkTimer, jiffies +
 555                          msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 556                break;
 557        case LED_BLINK_WPS_STOP:        /*WPS success*/
 558                if (pLed->BlinkingLedState == LED_STATE_ON) {
 559                        pLed->BlinkingLedState = LED_STATE_OFF;
 560                        mod_timer(&pLed->BlinkTimer, jiffies +
 561                                  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
 562                        bStopBlinking = false;
 563                } else {
 564                        bStopBlinking = true;
 565                }
 566                if (bStopBlinking) {
 567                        pLed->CurrLedState = LED_STATE_ON;
 568                        pLed->BlinkingLedState = LED_STATE_ON;
 569                        SwLedOn(padapter, pLed);
 570                        pLed->bLedWPSBlinkInProgress = false;
 571                }
 572                break;
 573        default:
 574                break;
 575        }
 576}
 577
 578static void SwLedBlink4(struct LED_871x *pLed)
 579{
 580        struct _adapter *padapter = pLed->padapter;
 581        struct led_priv *ledpriv = &padapter->ledpriv;
 582        struct LED_871x *pLed1 = &ledpriv->SwLed1;
 583        u8 bStopBlinking = false;
 584
 585        /* Change LED according to BlinkingLedState specified. */
 586        if (pLed->BlinkingLedState == LED_STATE_ON)
 587                SwLedOn(padapter, pLed);
 588        else
 589                SwLedOff(padapter, pLed);
 590        if (!pLed1->bLedWPSBlinkInProgress &&
 591            pLed1->BlinkingLedState == LED_UNKNOWN) {
 592                pLed1->BlinkingLedState = LED_STATE_OFF;
 593                pLed1->CurrLedState = LED_STATE_OFF;
 594                SwLedOff(padapter, pLed1);
 595        }
 596        switch (pLed->CurrLedState) {
 597        case LED_BLINK_SLOWLY:
 598                if (pLed->bLedOn)
 599                        pLed->BlinkingLedState = LED_STATE_OFF;
 600                else
 601                        pLed->BlinkingLedState = LED_STATE_ON;
 602                mod_timer(&pLed->BlinkTimer, jiffies +
 603                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 604                break;
 605        case LED_BLINK_StartToBlink:
 606                if (pLed->bLedOn) {
 607                        pLed->BlinkingLedState = LED_STATE_OFF;
 608                        mod_timer(&pLed->BlinkTimer, jiffies +
 609                                  msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 610                } else {
 611                        pLed->BlinkingLedState = LED_STATE_ON;
 612                        mod_timer(&pLed->BlinkTimer, jiffies +
 613                                  msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 614                }
 615                break;
 616        case LED_SCAN_BLINK:
 617                pLed->BlinkTimes--;
 618                if (pLed->BlinkTimes == 0)
 619                        bStopBlinking = true;
 620                if (bStopBlinking) {
 621                        pLed->bLedNoLinkBlinkInProgress = true;
 622                        pLed->CurrLedState = LED_BLINK_SLOWLY;
 623                        if (pLed->bLedOn)
 624                                pLed->BlinkingLedState = LED_STATE_OFF;
 625                        else
 626                                pLed->BlinkingLedState = LED_STATE_ON;
 627                        mod_timer(&pLed->BlinkTimer, jiffies +
 628                                  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 629                        pLed->bLedScanBlinkInProgress = false;
 630                } else {
 631                        if (pLed->bLedOn)
 632                                pLed->BlinkingLedState = LED_STATE_OFF;
 633                        else
 634                                pLed->BlinkingLedState = LED_STATE_ON;
 635                        mod_timer(&pLed->BlinkTimer, jiffies +
 636                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 637                }
 638                break;
 639        case LED_TXRX_BLINK:
 640                pLed->BlinkTimes--;
 641                if (pLed->BlinkTimes == 0)
 642                        bStopBlinking = true;
 643                if (bStopBlinking) {
 644                        pLed->bLedNoLinkBlinkInProgress = true;
 645                        pLed->CurrLedState = LED_BLINK_SLOWLY;
 646                        if (pLed->bLedOn)
 647                                pLed->BlinkingLedState = LED_STATE_OFF;
 648                        else
 649                                pLed->BlinkingLedState = LED_STATE_ON;
 650                        mod_timer(&pLed->BlinkTimer, jiffies +
 651                                  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 652                        pLed->bLedBlinkInProgress = false;
 653                } else {
 654                        if (pLed->bLedOn)
 655                                pLed->BlinkingLedState = LED_STATE_OFF;
 656                        else
 657                                pLed->BlinkingLedState = LED_STATE_ON;
 658                        mod_timer(&pLed->BlinkTimer, jiffies +
 659                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 660                }
 661                break;
 662        case LED_BLINK_WPS:
 663                if (pLed->bLedOn) {
 664                        pLed->BlinkingLedState = LED_STATE_OFF;
 665                        mod_timer(&pLed->BlinkTimer, jiffies +
 666                                  msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
 667                } else {
 668                        pLed->BlinkingLedState = LED_STATE_ON;
 669                        mod_timer(&pLed->BlinkTimer, jiffies +
 670                                  msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 671                }
 672                break;
 673        case LED_BLINK_WPS_STOP:        /*WPS authentication fail*/
 674                if (pLed->bLedOn)
 675                        pLed->BlinkingLedState = LED_STATE_OFF;
 676                else
 677                        pLed->BlinkingLedState = LED_STATE_ON;
 678                mod_timer(&pLed->BlinkTimer, jiffies +
 679                          msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 680                break;
 681        case LED_BLINK_WPS_STOP_OVERLAP:        /*WPS session overlap */
 682                pLed->BlinkTimes--;
 683                if (pLed->BlinkTimes == 0) {
 684                        if (pLed->bLedOn)
 685                                pLed->BlinkTimes = 1;
 686                        else
 687                                bStopBlinking = true;
 688                }
 689                if (bStopBlinking) {
 690                        pLed->BlinkTimes = 10;
 691                        pLed->BlinkingLedState = LED_STATE_ON;
 692                        mod_timer(&pLed->BlinkTimer, jiffies +
 693                                  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 694                } else {
 695                        if (pLed->bLedOn)
 696                                pLed->BlinkingLedState = LED_STATE_OFF;
 697                        else
 698                                pLed->BlinkingLedState = LED_STATE_ON;
 699                        mod_timer(&pLed->BlinkTimer, jiffies +
 700                                  msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
 701                }
 702                break;
 703        default:
 704                break;
 705        }
 706}
 707
 708static void SwLedBlink5(struct LED_871x *pLed)
 709{
 710        struct _adapter *padapter = pLed->padapter;
 711        u8 bStopBlinking = false;
 712
 713        /* Change LED according to BlinkingLedState specified. */
 714        if (pLed->BlinkingLedState == LED_STATE_ON)
 715                SwLedOn(padapter, pLed);
 716        else
 717                SwLedOff(padapter, pLed);
 718        switch (pLed->CurrLedState) {
 719        case LED_SCAN_BLINK:
 720                pLed->BlinkTimes--;
 721                if (pLed->BlinkTimes == 0)
 722                        bStopBlinking = true;
 723                if (bStopBlinking) {
 724                        pLed->CurrLedState = LED_STATE_ON;
 725                        pLed->BlinkingLedState = LED_STATE_ON;
 726                        if (!pLed->bLedOn)
 727                                mod_timer(&pLed->BlinkTimer, jiffies +
 728                                          msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 729                        pLed->bLedScanBlinkInProgress = false;
 730                } else {
 731                        if (pLed->bLedOn)
 732                                pLed->BlinkingLedState = LED_STATE_OFF;
 733                        else
 734                                pLed->BlinkingLedState = LED_STATE_ON;
 735                        mod_timer(&pLed->BlinkTimer, jiffies +
 736                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 737                }
 738                break;
 739        case LED_TXRX_BLINK:
 740                pLed->BlinkTimes--;
 741                if (pLed->BlinkTimes == 0)
 742                        bStopBlinking = true;
 743                if (bStopBlinking) {
 744                        pLed->CurrLedState = LED_STATE_ON;
 745                        pLed->BlinkingLedState = LED_STATE_ON;
 746                        if (!pLed->bLedOn)
 747                                mod_timer(&pLed->BlinkTimer, jiffies +
 748                                          msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 749                        pLed->bLedBlinkInProgress = false;
 750                } else {
 751                        if (pLed->bLedOn)
 752                                pLed->BlinkingLedState = LED_STATE_OFF;
 753                        else
 754                                pLed->BlinkingLedState = LED_STATE_ON;
 755                        mod_timer(&pLed->BlinkTimer, jiffies +
 756                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 757                }
 758                break;
 759        default:
 760                break;
 761        }
 762}
 763
 764static void SwLedBlink6(struct LED_871x *pLed)
 765{
 766        struct _adapter *padapter = pLed->padapter;
 767        u8 bStopBlinking = false;
 768
 769        /* Change LED according to BlinkingLedState specified. */
 770        if (pLed->BlinkingLedState == LED_STATE_ON)
 771                SwLedOn(padapter, pLed);
 772        else
 773                SwLedOff(padapter, pLed);
 774        switch (pLed->CurrLedState) {
 775        case LED_TXRX_BLINK:
 776                pLed->BlinkTimes--;
 777                if (pLed->BlinkTimes == 0)
 778                        bStopBlinking = true;
 779                if (bStopBlinking) {
 780                        pLed->CurrLedState = LED_STATE_ON;
 781                        pLed->BlinkingLedState = LED_STATE_ON;
 782                        if (!pLed->bLedOn)
 783                                SwLedOn(padapter, pLed);
 784                        pLed->bLedBlinkInProgress = false;
 785                } else {
 786                        if (pLed->bLedOn)
 787                                pLed->BlinkingLedState = LED_STATE_OFF;
 788                        else
 789                                pLed->BlinkingLedState = LED_STATE_ON;
 790                        mod_timer(&pLed->BlinkTimer, jiffies +
 791                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 792                }
 793                break;
 794        case LED_BLINK_WPS:
 795                if (pLed->bLedOn)
 796                        pLed->BlinkingLedState = LED_STATE_OFF;
 797                else
 798                        pLed->BlinkingLedState = LED_STATE_ON;
 799                mod_timer(&pLed->BlinkTimer, jiffies +
 800                          msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 801                break;
 802
 803        default:
 804                break;
 805        }
 806}
 807
 808/*      Description:
 809 *              Callback function of LED BlinkTimer,
 810 *              it just schedules to corresponding BlinkWorkItem.
 811 */
 812static void BlinkTimerCallback(struct timer_list *t)
 813{
 814        struct LED_871x  *pLed = from_timer(pLed, t, BlinkTimer);
 815
 816        /* This fixed the crash problem on Fedora 12 when trying to do the
 817         * insmod;ifconfig up;rmmod commands.
 818         */
 819        if (pLed->padapter->surprise_removed || pLed->padapter->driver_stopped)
 820                return;
 821        schedule_work(&pLed->BlinkWorkItem);
 822}
 823
 824/*      Description:
 825 *              Callback function of LED BlinkWorkItem.
 826 *              We dispatch actual LED blink action according to LedStrategy.
 827 */
 828static void BlinkWorkItemCallback(struct work_struct *work)
 829{
 830        struct LED_871x *pLed = container_of(work, struct LED_871x,
 831                                BlinkWorkItem);
 832        struct led_priv *ledpriv = &pLed->padapter->ledpriv;
 833
 834        switch (ledpriv->LedStrategy) {
 835        case SW_LED_MODE0:
 836                SwLedBlink(pLed);
 837                break;
 838        case SW_LED_MODE1:
 839                SwLedBlink1(pLed);
 840                break;
 841        case SW_LED_MODE2:
 842                SwLedBlink2(pLed);
 843                break;
 844        case SW_LED_MODE3:
 845                SwLedBlink3(pLed);
 846                break;
 847        case SW_LED_MODE4:
 848                SwLedBlink4(pLed);
 849                break;
 850        case SW_LED_MODE5:
 851                SwLedBlink5(pLed);
 852                break;
 853        case SW_LED_MODE6:
 854                SwLedBlink6(pLed);
 855                break;
 856        default:
 857                SwLedBlink(pLed);
 858                break;
 859        }
 860}
 861
 862/*============================================================================
 863 * Default LED behavior.
 864 *============================================================================
 865 *
 866 *      Description:
 867 *              Implement each led action for SW_LED_MODE0.
 868 *              This is default strategy.
 869 */
 870
 871static void SwLedControlMode1(struct _adapter *padapter,
 872                              enum LED_CTL_MODE LedAction)
 873{
 874        struct led_priv *ledpriv = &padapter->ledpriv;
 875        struct LED_871x *pLed = &ledpriv->SwLed0;
 876        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 877        struct sitesurvey_ctrl *psitesurveyctrl = &pmlmepriv->sitesurveyctrl;
 878
 879        if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
 880                pLed = &ledpriv->SwLed1;
 881        switch (LedAction) {
 882        case LED_CTL_START_TO_LINK:
 883        case LED_CTL_NO_LINK:
 884                if (!pLed->bLedNoLinkBlinkInProgress) {
 885                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
 886                            IS_LED_WPS_BLINKING(pLed))
 887                                return;
 888                        if (pLed->bLedLinkBlinkInProgress) {
 889                                del_timer(&pLed->BlinkTimer);
 890                                pLed->bLedLinkBlinkInProgress = false;
 891                        }
 892                        if (pLed->bLedBlinkInProgress) {
 893                                del_timer(&pLed->BlinkTimer);
 894                                pLed->bLedBlinkInProgress = false;
 895                        }
 896                        pLed->bLedNoLinkBlinkInProgress = true;
 897                        pLed->CurrLedState = LED_BLINK_SLOWLY;
 898                        if (pLed->bLedOn)
 899                                pLed->BlinkingLedState = LED_STATE_OFF;
 900                        else
 901                                pLed->BlinkingLedState = LED_STATE_ON;
 902                        mod_timer(&pLed->BlinkTimer, jiffies +
 903                                  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
 904                }
 905                break;
 906        case LED_CTL_LINK:
 907                if (!pLed->bLedLinkBlinkInProgress) {
 908                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
 909                            IS_LED_WPS_BLINKING(pLed))
 910                                return;
 911                        if (pLed->bLedNoLinkBlinkInProgress) {
 912                                del_timer(&pLed->BlinkTimer);
 913                                pLed->bLedNoLinkBlinkInProgress = false;
 914                        }
 915                        if (pLed->bLedBlinkInProgress) {
 916                                del_timer(&pLed->BlinkTimer);
 917                                pLed->bLedBlinkInProgress = false;
 918                        }
 919                        pLed->bLedLinkBlinkInProgress = true;
 920                        pLed->CurrLedState = LED_BLINK_NORMAL;
 921                        if (pLed->bLedOn)
 922                                pLed->BlinkingLedState = LED_STATE_OFF;
 923                        else
 924                                pLed->BlinkingLedState = LED_STATE_ON;
 925                        mod_timer(&pLed->BlinkTimer, jiffies +
 926                                  msecs_to_jiffies(LED_BLINK_LINK_INTERVAL_ALPHA));
 927                }
 928                break;
 929        case LED_CTL_SITE_SURVEY:
 930                if (psitesurveyctrl->traffic_busy &&
 931                    check_fwstate(pmlmepriv, _FW_LINKED))
 932                        ; /* dummy branch */
 933                else if (!pLed->bLedScanBlinkInProgress) {
 934                        if (IS_LED_WPS_BLINKING(pLed))
 935                                return;
 936                        if (pLed->bLedNoLinkBlinkInProgress) {
 937                                del_timer(&pLed->BlinkTimer);
 938                                pLed->bLedNoLinkBlinkInProgress = false;
 939                        }
 940                        if (pLed->bLedLinkBlinkInProgress) {
 941                                del_timer(&pLed->BlinkTimer);
 942                                pLed->bLedLinkBlinkInProgress = false;
 943                        }
 944                        if (pLed->bLedBlinkInProgress) {
 945                                del_timer(&pLed->BlinkTimer);
 946                                pLed->bLedBlinkInProgress = false;
 947                        }
 948                        pLed->bLedScanBlinkInProgress = true;
 949                        pLed->CurrLedState = LED_SCAN_BLINK;
 950                        pLed->BlinkTimes = 24;
 951                        if (pLed->bLedOn)
 952                                pLed->BlinkingLedState = LED_STATE_OFF;
 953                        else
 954                                pLed->BlinkingLedState = LED_STATE_ON;
 955                        mod_timer(&pLed->BlinkTimer, jiffies +
 956                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
 957                }
 958                break;
 959        case LED_CTL_TX:
 960        case LED_CTL_RX:
 961                if (!pLed->bLedBlinkInProgress) {
 962                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
 963                            IS_LED_WPS_BLINKING(pLed))
 964                                return;
 965                        if (pLed->bLedNoLinkBlinkInProgress) {
 966                                del_timer(&pLed->BlinkTimer);
 967                                pLed->bLedNoLinkBlinkInProgress = false;
 968                        }
 969                        if (pLed->bLedLinkBlinkInProgress) {
 970                                del_timer(&pLed->BlinkTimer);
 971                                pLed->bLedLinkBlinkInProgress = false;
 972                        }
 973                        pLed->bLedBlinkInProgress = true;
 974                        pLed->CurrLedState = LED_TXRX_BLINK;
 975                        pLed->BlinkTimes = 2;
 976                        if (pLed->bLedOn)
 977                                pLed->BlinkingLedState = LED_STATE_OFF;
 978                        else
 979                                pLed->BlinkingLedState = LED_STATE_ON;
 980                        mod_timer(&pLed->BlinkTimer, jiffies +
 981                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
 982                }
 983                break;
 984
 985        case LED_CTL_START_WPS: /*wait until xinpin finish */
 986        case LED_CTL_START_WPS_BOTTON:
 987                if (!pLed->bLedWPSBlinkInProgress) {
 988                        if (pLed->bLedNoLinkBlinkInProgress) {
 989                                del_timer(&pLed->BlinkTimer);
 990                                pLed->bLedNoLinkBlinkInProgress = false;
 991                        }
 992                        if (pLed->bLedLinkBlinkInProgress) {
 993                                del_timer(&pLed->BlinkTimer);
 994                                pLed->bLedLinkBlinkInProgress = false;
 995                        }
 996                        if (pLed->bLedBlinkInProgress) {
 997                                del_timer(&pLed->BlinkTimer);
 998                                pLed->bLedBlinkInProgress = false;
 999                        }
1000                        if (pLed->bLedScanBlinkInProgress) {

1001                                del_timer(&pLed->BlinkTimer);
1002                                pLed->bLedScanBlinkInProgress = false;
1003                        }
1004                        pLed->bLedWPSBlinkInProgress = true;
1005                        pLed->CurrLedState = LED_BLINK_WPS;
1006                        if (pLed->bLedOn)
1007                                pLed->BlinkingLedState = LED_STATE_OFF;
1008                        else
1009                                pLed->BlinkingLedState = LED_STATE_ON;
1010                        mod_timer(&pLed->BlinkTimer, jiffies +
1011                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1012                }
1013                break;
1014        case LED_CTL_STOP_WPS:
1015                if (pLed->bLedNoLinkBlinkInProgress) {
1016                        del_timer(&pLed->BlinkTimer);
1017                        pLed->bLedNoLinkBlinkInProgress = false;
1018                }
1019                if (pLed->bLedLinkBlinkInProgress) {
1020                        del_timer(&pLed->BlinkTimer);
1021                        pLed->bLedLinkBlinkInProgress = false;
1022                }
1023                if (pLed->bLedBlinkInProgress) {
1024                        del_timer(&pLed->BlinkTimer);
1025                        pLed->bLedBlinkInProgress = false;
1026                }
1027                if (pLed->bLedScanBlinkInProgress) {
1028                        del_timer(&pLed->BlinkTimer);
1029                        pLed->bLedScanBlinkInProgress = false;
1030                }
1031                if (pLed->bLedWPSBlinkInProgress)
1032                        del_timer(&pLed->BlinkTimer);
1033                else
1034                        pLed->bLedWPSBlinkInProgress = true;
1035                pLed->CurrLedState = LED_BLINK_WPS_STOP;
1036                if (pLed->bLedOn) {
1037                        pLed->BlinkingLedState = LED_STATE_OFF;
1038                        mod_timer(&pLed->BlinkTimer, jiffies +
1039                                  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1040                } else {
1041                        pLed->BlinkingLedState = LED_STATE_ON;
1042                        mod_timer(&pLed->BlinkTimer,
1043                                  jiffies + msecs_to_jiffies(0));
1044                }
1045                break;
1046        case LED_CTL_STOP_WPS_FAIL:
1047                if (pLed->bLedWPSBlinkInProgress) {
1048                        del_timer(&pLed->BlinkTimer);
1049                        pLed->bLedWPSBlinkInProgress = false;
1050                }
1051                pLed->bLedNoLinkBlinkInProgress = true;
1052                pLed->CurrLedState = LED_BLINK_SLOWLY;
1053                if (pLed->bLedOn)
1054                        pLed->BlinkingLedState = LED_STATE_OFF;
1055                else
1056                        pLed->BlinkingLedState = LED_STATE_ON;
1057                mod_timer(&pLed->BlinkTimer, jiffies +
1058                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1059                break;
1060        case LED_CTL_POWER_OFF:
1061                pLed->CurrLedState = LED_STATE_OFF;
1062                pLed->BlinkingLedState = LED_STATE_OFF;
1063                if (pLed->bLedNoLinkBlinkInProgress) {
1064                        del_timer(&pLed->BlinkTimer);
1065                        pLed->bLedNoLinkBlinkInProgress = false;
1066                }
1067                if (pLed->bLedLinkBlinkInProgress) {
1068                        del_timer(&pLed->BlinkTimer);
1069                        pLed->bLedLinkBlinkInProgress = false;
1070                }
1071                if (pLed->bLedBlinkInProgress) {
1072                        del_timer(&pLed->BlinkTimer);
1073                        pLed->bLedBlinkInProgress = false;
1074                }
1075                if (pLed->bLedWPSBlinkInProgress) {
1076                        del_timer(&pLed->BlinkTimer);
1077                        pLed->bLedWPSBlinkInProgress = false;
1078                }
1079                if (pLed->bLedScanBlinkInProgress) {
1080                        del_timer(&pLed->BlinkTimer);
1081                        pLed->bLedScanBlinkInProgress = false;
1082                }
1083                mod_timer(&pLed->BlinkTimer,
1084                          jiffies + msecs_to_jiffies(0));
1085                break;
1086        default:
1087                break;
1088        }
1089}
1090
1091static void SwLedControlMode2(struct _adapter *padapter,
1092                              enum LED_CTL_MODE LedAction)
1093{
1094        struct led_priv  *ledpriv = &padapter->ledpriv;
1095        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1096        struct LED_871x *pLed = &ledpriv->SwLed0;
1097
1098        switch (LedAction) {
1099        case LED_CTL_SITE_SURVEY:
1100                if (pmlmepriv->sitesurveyctrl.traffic_busy)
1101                        ; /* dummy branch */
1102                else if (!pLed->bLedScanBlinkInProgress) {
1103                        if (IS_LED_WPS_BLINKING(pLed))
1104                                return;
1105
1106                        if (pLed->bLedBlinkInProgress) {
1107                                del_timer(&pLed->BlinkTimer);
1108                                pLed->bLedBlinkInProgress = false;
1109                        }
1110                        pLed->bLedScanBlinkInProgress = true;
1111                        pLed->CurrLedState = LED_SCAN_BLINK;
1112                        pLed->BlinkTimes = 24;
1113                        if (pLed->bLedOn)
1114                                pLed->BlinkingLedState = LED_STATE_OFF;
1115                        else
1116                                pLed->BlinkingLedState = LED_STATE_ON;
1117                        mod_timer(&pLed->BlinkTimer, jiffies +
1118                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1119                }
1120                break;
1121
1122        case LED_CTL_TX:
1123        case LED_CTL_RX:
1124                if (!pLed->bLedBlinkInProgress &&
1125                    check_fwstate(pmlmepriv, _FW_LINKED)) {
1126                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
1127                            IS_LED_WPS_BLINKING(pLed))
1128                                return;
1129                        pLed->bLedBlinkInProgress = true;
1130                        pLed->CurrLedState = LED_TXRX_BLINK;
1131                        pLed->BlinkTimes = 2;
1132                        if (pLed->bLedOn)
1133                                pLed->BlinkingLedState = LED_STATE_OFF;
1134                        else
1135                                pLed->BlinkingLedState = LED_STATE_ON;
1136                        mod_timer(&pLed->BlinkTimer, jiffies +
1137                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1138                }
1139                break;
1140
1141        case LED_CTL_LINK:
1142                pLed->CurrLedState = LED_STATE_ON;
1143                pLed->BlinkingLedState = LED_STATE_ON;
1144                if (pLed->bLedBlinkInProgress) {
1145                        del_timer(&pLed->BlinkTimer);
1146                        pLed->bLedBlinkInProgress = false;
1147                }
1148                if (pLed->bLedScanBlinkInProgress) {
1149                        del_timer(&pLed->BlinkTimer);
1150                        pLed->bLedScanBlinkInProgress = false;
1151                }
1152
1153                mod_timer(&pLed->BlinkTimer,
1154                          jiffies + msecs_to_jiffies(0));
1155                break;
1156
1157        case LED_CTL_START_WPS: /*wait until xinpin finish*/
1158        case LED_CTL_START_WPS_BOTTON:
1159                if (!pLed->bLedWPSBlinkInProgress) {
1160                        if (pLed->bLedBlinkInProgress) {
1161                                del_timer(&pLed->BlinkTimer);
1162                                pLed->bLedBlinkInProgress = false;
1163                        }
1164                        if (pLed->bLedScanBlinkInProgress) {
1165                                del_timer(&pLed->BlinkTimer);
1166                                pLed->bLedScanBlinkInProgress = false;
1167                        }
1168                        pLed->bLedWPSBlinkInProgress = true;
1169                        pLed->CurrLedState = LED_STATE_ON;
1170                        pLed->BlinkingLedState = LED_STATE_ON;
1171                        mod_timer(&pLed->BlinkTimer,
1172                                  jiffies + msecs_to_jiffies(0));
1173                }
1174                break;
1175
1176        case LED_CTL_STOP_WPS:
1177                pLed->bLedWPSBlinkInProgress = false;
1178                pLed->CurrLedState = LED_STATE_ON;
1179                pLed->BlinkingLedState = LED_STATE_ON;
1180                mod_timer(&pLed->BlinkTimer,
1181                          jiffies + msecs_to_jiffies(0));
1182                break;
1183
1184        case LED_CTL_STOP_WPS_FAIL:
1185                pLed->bLedWPSBlinkInProgress = false;
1186                pLed->CurrLedState = LED_STATE_OFF;
1187                pLed->BlinkingLedState = LED_STATE_OFF;
1188                mod_timer(&pLed->BlinkTimer,
1189                          jiffies + msecs_to_jiffies(0));
1190                break;
1191
1192        case LED_CTL_START_TO_LINK:
1193        case LED_CTL_NO_LINK:
1194                if (!IS_LED_BLINKING(pLed)) {
1195                        pLed->CurrLedState = LED_STATE_OFF;
1196                        pLed->BlinkingLedState = LED_STATE_OFF;
1197                        mod_timer(&pLed->BlinkTimer,
1198                                  jiffies + msecs_to_jiffies(0));
1199                }
1200                break;
1201        case LED_CTL_POWER_OFF:
1202                pLed->CurrLedState = LED_STATE_OFF;
1203                pLed->BlinkingLedState = LED_STATE_OFF;
1204                if (pLed->bLedBlinkInProgress) {
1205                        del_timer(&pLed->BlinkTimer);
1206                        pLed->bLedBlinkInProgress = false;
1207                }
1208                if (pLed->bLedScanBlinkInProgress) {
1209                        del_timer(&pLed->BlinkTimer);
1210                        pLed->bLedScanBlinkInProgress = false;
1211                }
1212                if (pLed->bLedWPSBlinkInProgress) {
1213                        del_timer(&pLed->BlinkTimer);
1214                        pLed->bLedWPSBlinkInProgress = false;
1215                }
1216                mod_timer(&pLed->BlinkTimer,
1217                          jiffies + msecs_to_jiffies(0));
1218                break;
1219        default:
1220                break;
1221        }
1222}
1223
1224static void SwLedControlMode3(struct _adapter *padapter,
1225                              enum LED_CTL_MODE LedAction)
1226{
1227        struct led_priv *ledpriv = &padapter->ledpriv;
1228        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1229        struct LED_871x *pLed = &ledpriv->SwLed0;
1230
1231        switch (LedAction) {
1232        case LED_CTL_SITE_SURVEY:
1233                if (pmlmepriv->sitesurveyctrl.traffic_busy)
1234                        ; /* dummy branch */
1235                else if (!pLed->bLedScanBlinkInProgress) {
1236                        if (IS_LED_WPS_BLINKING(pLed))
1237                                return;
1238                        if (pLed->bLedBlinkInProgress) {
1239                                del_timer(&pLed->BlinkTimer);
1240                                pLed->bLedBlinkInProgress = false;
1241                        }
1242                        pLed->bLedScanBlinkInProgress = true;
1243                        pLed->CurrLedState = LED_SCAN_BLINK;
1244                        pLed->BlinkTimes = 24;
1245                        if (pLed->bLedOn)
1246                                pLed->BlinkingLedState = LED_STATE_OFF;
1247                        else
1248                                pLed->BlinkingLedState = LED_STATE_ON;
1249                        mod_timer(&pLed->BlinkTimer, jiffies +
1250                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1251                }
1252                break;
1253        case LED_CTL_TX:
1254        case LED_CTL_RX:
1255                if (!pLed->bLedBlinkInProgress &&
1256                    check_fwstate(pmlmepriv, _FW_LINKED)) {
1257                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
1258                            IS_LED_WPS_BLINKING(pLed))
1259                                return;
1260                        pLed->bLedBlinkInProgress = true;
1261                        pLed->CurrLedState = LED_TXRX_BLINK;
1262                        pLed->BlinkTimes = 2;
1263                        if (pLed->bLedOn)
1264                                pLed->BlinkingLedState = LED_STATE_OFF;
1265                        else
1266                                pLed->BlinkingLedState = LED_STATE_ON;
1267                        mod_timer(&pLed->BlinkTimer, jiffies +
1268                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1269                }
1270                break;
1271        case LED_CTL_LINK:
1272                if (IS_LED_WPS_BLINKING(pLed))
1273                        return;
1274                pLed->CurrLedState = LED_STATE_ON;
1275                pLed->BlinkingLedState = LED_STATE_ON;
1276                if (pLed->bLedBlinkInProgress) {
1277                        del_timer(&pLed->BlinkTimer);
1278                        pLed->bLedBlinkInProgress = false;
1279                }
1280                if (pLed->bLedScanBlinkInProgress) {
1281                        del_timer(&pLed->BlinkTimer);
1282                        pLed->bLedScanBlinkInProgress = false;
1283                }
1284                mod_timer(&pLed->BlinkTimer,
1285                          jiffies + msecs_to_jiffies(0));
1286                break;
1287        case LED_CTL_START_WPS: /* wait until xinpin finish */
1288        case LED_CTL_START_WPS_BOTTON:
1289                if (!pLed->bLedWPSBlinkInProgress) {
1290                        if (pLed->bLedBlinkInProgress) {
1291                                del_timer(&pLed->BlinkTimer);
1292                                pLed->bLedBlinkInProgress = false;
1293                        }
1294                        if (pLed->bLedScanBlinkInProgress) {
1295                                del_timer(&pLed->BlinkTimer);
1296                                pLed->bLedScanBlinkInProgress = false;
1297                        }
1298                        pLed->bLedWPSBlinkInProgress = true;
1299                        pLed->CurrLedState = LED_BLINK_WPS;
1300                        if (pLed->bLedOn)
1301                                pLed->BlinkingLedState = LED_STATE_OFF;
1302                        else
1303                                pLed->BlinkingLedState = LED_STATE_ON;
1304                        mod_timer(&pLed->BlinkTimer, jiffies +
1305                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1306                }
1307                break;
1308        case LED_CTL_STOP_WPS:
1309                if (pLed->bLedWPSBlinkInProgress) {
1310                        del_timer(&pLed->BlinkTimer);
1311                        pLed->bLedWPSBlinkInProgress = false;
1312                } else {
1313                        pLed->bLedWPSBlinkInProgress = true;
1314                }
1315                pLed->CurrLedState = LED_BLINK_WPS_STOP;
1316                if (pLed->bLedOn) {
1317                        pLed->BlinkingLedState = LED_STATE_OFF;
1318                        mod_timer(&pLed->BlinkTimer, jiffies +
1319                                  msecs_to_jiffies(LED_BLINK_WPS_SUCCESS_INTERVAL_ALPHA));
1320                } else {
1321                        pLed->BlinkingLedState = LED_STATE_ON;
1322                        mod_timer(&pLed->BlinkTimer,
1323                                  jiffies + msecs_to_jiffies(0));
1324                }
1325                break;
1326        case LED_CTL_STOP_WPS_FAIL:
1327                if (pLed->bLedWPSBlinkInProgress) {
1328                        del_timer(&pLed->BlinkTimer);
1329                        pLed->bLedWPSBlinkInProgress = false;
1330                }
1331                pLed->CurrLedState = LED_STATE_OFF;
1332                pLed->BlinkingLedState = LED_STATE_OFF;
1333                mod_timer(&pLed->BlinkTimer,
1334                          jiffies + msecs_to_jiffies(0));
1335                break;
1336        case LED_CTL_START_TO_LINK:
1337        case LED_CTL_NO_LINK:
1338                if (!IS_LED_BLINKING(pLed)) {
1339                        pLed->CurrLedState = LED_STATE_OFF;
1340                        pLed->BlinkingLedState = LED_STATE_OFF;
1341                        mod_timer(&pLed->BlinkTimer,
1342                                  jiffies + msecs_to_jiffies(0));
1343                }
1344                break;
1345        case LED_CTL_POWER_OFF:
1346                pLed->CurrLedState = LED_STATE_OFF;
1347                pLed->BlinkingLedState = LED_STATE_OFF;
1348                if (pLed->bLedBlinkInProgress) {
1349                        del_timer(&pLed->BlinkTimer);
1350                        pLed->bLedBlinkInProgress = false;
1351                }
1352                if (pLed->bLedScanBlinkInProgress) {
1353                        del_timer(&pLed->BlinkTimer);
1354                        pLed->bLedScanBlinkInProgress = false;
1355                }
1356                if (pLed->bLedWPSBlinkInProgress) {
1357                        del_timer(&pLed->BlinkTimer);
1358                        pLed->bLedWPSBlinkInProgress = false;
1359                }
1360                mod_timer(&pLed->BlinkTimer,
1361                          jiffies + msecs_to_jiffies(0));
1362                break;
1363        default:
1364                break;
1365        }
1366}
1367
1368static void SwLedControlMode4(struct _adapter *padapter,
1369                              enum LED_CTL_MODE LedAction)
1370{
1371        struct led_priv *ledpriv = &padapter->ledpriv;
1372        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1373        struct LED_871x *pLed = &ledpriv->SwLed0;
1374        struct LED_871x *pLed1 = &ledpriv->SwLed1;
1375
1376        switch (LedAction) {
1377        case LED_CTL_START_TO_LINK:
1378                if (pLed1->bLedWPSBlinkInProgress) {
1379                        pLed1->bLedWPSBlinkInProgress = false;
1380                        del_timer(&pLed1->BlinkTimer);
1381                        pLed1->BlinkingLedState = LED_STATE_OFF;
1382                        pLed1->CurrLedState = LED_STATE_OFF;
1383                        if (pLed1->bLedOn)
1384                                mod_timer(&pLed->BlinkTimer,
1385                                          jiffies + msecs_to_jiffies(0));
1386                }
1387                if (!pLed->bLedStartToLinkBlinkInProgress) {
1388                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
1389                            IS_LED_WPS_BLINKING(pLed))
1390                                return;
1391                        if (pLed->bLedBlinkInProgress) {
1392                                del_timer(&pLed->BlinkTimer);
1393                                pLed->bLedBlinkInProgress = false;
1394                        }
1395                        if (pLed->bLedNoLinkBlinkInProgress) {
1396                                del_timer(&pLed->BlinkTimer);
1397                                pLed->bLedNoLinkBlinkInProgress = false;
1398                        }
1399                        pLed->bLedStartToLinkBlinkInProgress = true;
1400                        pLed->CurrLedState = LED_BLINK_StartToBlink;
1401                        if (pLed->bLedOn) {
1402                                pLed->BlinkingLedState = LED_STATE_OFF;
1403                                mod_timer(&pLed->BlinkTimer, jiffies +
1404                                          msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1405                        } else {
1406                                pLed->BlinkingLedState = LED_STATE_ON;
1407                                mod_timer(&pLed->BlinkTimer, jiffies +
1408                                          msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1409                        }
1410                }
1411                break;
1412        case LED_CTL_LINK:
1413        case LED_CTL_NO_LINK:
1414                /*LED1 settings*/
1415                if (LedAction == LED_CTL_LINK) {
1416                        if (pLed1->bLedWPSBlinkInProgress) {
1417                                pLed1->bLedWPSBlinkInProgress = false;
1418                                del_timer(&pLed1->BlinkTimer);
1419                                pLed1->BlinkingLedState = LED_STATE_OFF;
1420                                pLed1->CurrLedState = LED_STATE_OFF;
1421                                if (pLed1->bLedOn)
1422                                        mod_timer(&pLed->BlinkTimer,
1423                                                  jiffies + msecs_to_jiffies(0));
1424                        }
1425                }
1426                if (!pLed->bLedNoLinkBlinkInProgress) {
1427                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
1428                            IS_LED_WPS_BLINKING(pLed))
1429                                return;
1430                        if (pLed->bLedBlinkInProgress) {
1431                                del_timer(&pLed->BlinkTimer);
1432                                pLed->bLedBlinkInProgress = false;
1433                        }
1434                        pLed->bLedNoLinkBlinkInProgress = true;
1435                        pLed->CurrLedState = LED_BLINK_SLOWLY;
1436                        if (pLed->bLedOn)
1437                                pLed->BlinkingLedState = LED_STATE_OFF;
1438                        else
1439                                pLed->BlinkingLedState = LED_STATE_ON;
1440                        mod_timer(&pLed->BlinkTimer, jiffies +
1441                                  msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1442                }
1443                break;
1444        case LED_CTL_SITE_SURVEY:
1445                if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1446                    check_fwstate(pmlmepriv, _FW_LINKED))
1447                        ;
1448                else if (!pLed->bLedScanBlinkInProgress) {
1449                        if (IS_LED_WPS_BLINKING(pLed))
1450                                return;
1451                        if (pLed->bLedNoLinkBlinkInProgress) {
1452                                del_timer(&pLed->BlinkTimer);
1453                                pLed->bLedNoLinkBlinkInProgress = false;
1454                        }
1455                        if (pLed->bLedBlinkInProgress) {
1456                                del_timer(&pLed->BlinkTimer);
1457                                pLed->bLedBlinkInProgress = false;
1458                        }
1459                        pLed->bLedScanBlinkInProgress = true;
1460                        pLed->CurrLedState = LED_SCAN_BLINK;
1461                        pLed->BlinkTimes = 24;
1462                        if (pLed->bLedOn)
1463                                pLed->BlinkingLedState = LED_STATE_OFF;
1464                        else
1465                                pLed->BlinkingLedState = LED_STATE_ON;
1466                        mod_timer(&pLed->BlinkTimer, jiffies +
1467                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1468                }
1469                break;
1470        case LED_CTL_TX:
1471        case LED_CTL_RX:
1472                if (!pLed->bLedBlinkInProgress) {
1473                        if (pLed->CurrLedState == LED_SCAN_BLINK ||
1474                            IS_LED_WPS_BLINKING(pLed))
1475                                return;
1476                        if (pLed->bLedNoLinkBlinkInProgress) {
1477                                del_timer(&pLed->BlinkTimer);
1478                                pLed->bLedNoLinkBlinkInProgress = false;
1479                        }
1480                        pLed->bLedBlinkInProgress = true;
1481                        pLed->CurrLedState = LED_TXRX_BLINK;
1482                        pLed->BlinkTimes = 2;
1483                        if (pLed->bLedOn)
1484                                pLed->BlinkingLedState = LED_STATE_OFF;
1485                        else
1486                                pLed->BlinkingLedState = LED_STATE_ON;
1487                        mod_timer(&pLed->BlinkTimer, jiffies +
1488                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1489                }
1490                break;
1491        case LED_CTL_START_WPS: /*wait until xinpin finish*/
1492        case LED_CTL_START_WPS_BOTTON:
1493                if (pLed1->bLedWPSBlinkInProgress) {
1494                        pLed1->bLedWPSBlinkInProgress = false;
1495                        del_timer(&pLed1->BlinkTimer);
1496                        pLed1->BlinkingLedState = LED_STATE_OFF;
1497                        pLed1->CurrLedState = LED_STATE_OFF;
1498                        if (pLed1->bLedOn)
1499                                mod_timer(&pLed->BlinkTimer,
1500                                          jiffies + msecs_to_jiffies(0));
1501                }
1502                if (!pLed->bLedWPSBlinkInProgress) {
1503                        if (pLed->bLedNoLinkBlinkInProgress) {
1504                                del_timer(&pLed->BlinkTimer);
1505                                pLed->bLedNoLinkBlinkInProgress = false;
1506                        }
1507                        if (pLed->bLedBlinkInProgress) {
1508                                del_timer(&pLed->BlinkTimer);
1509                                pLed->bLedBlinkInProgress = false;
1510                        }
1511                        if (pLed->bLedScanBlinkInProgress) {
1512                                del_timer(&pLed->BlinkTimer);
1513                                pLed->bLedScanBlinkInProgress = false;
1514                        }
1515                        pLed->bLedWPSBlinkInProgress = true;
1516                        pLed->CurrLedState = LED_BLINK_WPS;
1517                        if (pLed->bLedOn) {
1518                                pLed->BlinkingLedState = LED_STATE_OFF;
1519                                mod_timer(&pLed->BlinkTimer, jiffies +
1520                                          msecs_to_jiffies(LED_BLINK_SLOWLY_INTERVAL));
1521                        } else {
1522                                pLed->BlinkingLedState = LED_STATE_ON;
1523                                mod_timer(&pLed->BlinkTimer, jiffies +
1524                                          msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1525                        }
1526                }
1527                break;
1528        case LED_CTL_STOP_WPS:  /*WPS connect success*/
1529                if (pLed->bLedWPSBlinkInProgress) {
1530                        del_timer(&pLed->BlinkTimer);
1531                        pLed->bLedWPSBlinkInProgress = false;
1532                }
1533                pLed->bLedNoLinkBlinkInProgress = true;
1534                pLed->CurrLedState = LED_BLINK_SLOWLY;
1535                if (pLed->bLedOn)
1536                        pLed->BlinkingLedState = LED_STATE_OFF;
1537                else
1538                        pLed->BlinkingLedState = LED_STATE_ON;
1539                mod_timer(&pLed->BlinkTimer, jiffies +
1540                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1541                break;
1542        case LED_CTL_STOP_WPS_FAIL:     /*WPS authentication fail*/
1543                if (pLed->bLedWPSBlinkInProgress) {
1544                        del_timer(&pLed->BlinkTimer);
1545                        pLed->bLedWPSBlinkInProgress = false;
1546                }
1547                pLed->bLedNoLinkBlinkInProgress = true;
1548                pLed->CurrLedState = LED_BLINK_SLOWLY;
1549                if (pLed->bLedOn)
1550                        pLed->BlinkingLedState = LED_STATE_OFF;
1551                else
1552                        pLed->BlinkingLedState = LED_STATE_ON;
1553                mod_timer(&pLed->BlinkTimer, jiffies +
1554                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1555                /*LED1 settings*/
1556                if (pLed1->bLedWPSBlinkInProgress)
1557                        del_timer(&pLed1->BlinkTimer);
1558                else
1559                        pLed1->bLedWPSBlinkInProgress = true;
1560                pLed1->CurrLedState = LED_BLINK_WPS_STOP;
1561                if (pLed1->bLedOn)
1562                        pLed1->BlinkingLedState = LED_STATE_OFF;
1563                else
1564                        pLed1->BlinkingLedState = LED_STATE_ON;
1565                mod_timer(&pLed->BlinkTimer, jiffies +
1566                          msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1567                break;
1568        case LED_CTL_STOP_WPS_FAIL_OVERLAP:     /*WPS session overlap*/
1569                if (pLed->bLedWPSBlinkInProgress) {
1570                        del_timer(&pLed->BlinkTimer);
1571                        pLed->bLedWPSBlinkInProgress = false;
1572                }
1573                pLed->bLedNoLinkBlinkInProgress = true;
1574                pLed->CurrLedState = LED_BLINK_SLOWLY;
1575                if (pLed->bLedOn)
1576                        pLed->BlinkingLedState = LED_STATE_OFF;
1577                else
1578                        pLed->BlinkingLedState = LED_STATE_ON;
1579                mod_timer(&pLed->BlinkTimer, jiffies +
1580                          msecs_to_jiffies(LED_BLINK_NO_LINK_INTERVAL_ALPHA));
1581                /*LED1 settings*/
1582                if (pLed1->bLedWPSBlinkInProgress)
1583                        del_timer(&pLed1->BlinkTimer);
1584                else
1585                        pLed1->bLedWPSBlinkInProgress = true;
1586                pLed1->CurrLedState = LED_BLINK_WPS_STOP_OVERLAP;
1587                pLed1->BlinkTimes = 10;
1588                if (pLed1->bLedOn)
1589                        pLed1->BlinkingLedState = LED_STATE_OFF;
1590                else
1591                        pLed1->BlinkingLedState = LED_STATE_ON;
1592                mod_timer(&pLed->BlinkTimer, jiffies +
1593                          msecs_to_jiffies(LED_BLINK_NORMAL_INTERVAL));
1594                break;
1595        case LED_CTL_POWER_OFF:
1596                pLed->CurrLedState = LED_STATE_OFF;
1597                pLed->BlinkingLedState = LED_STATE_OFF;
1598                if (pLed->bLedNoLinkBlinkInProgress) {
1599                        del_timer(&pLed->BlinkTimer);
1600                        pLed->bLedNoLinkBlinkInProgress = false;
1601                }
1602                if (pLed->bLedLinkBlinkInProgress) {
1603                        del_timer(&pLed->BlinkTimer);
1604                        pLed->bLedLinkBlinkInProgress = false;
1605                }
1606                if (pLed->bLedBlinkInProgress) {
1607                        del_timer(&pLed->BlinkTimer);
1608                        pLed->bLedBlinkInProgress = false;
1609                }
1610                if (pLed->bLedWPSBlinkInProgress) {
1611                        del_timer(&pLed->BlinkTimer);
1612                        pLed->bLedWPSBlinkInProgress = false;
1613                }
1614                if (pLed->bLedScanBlinkInProgress) {
1615                        del_timer(&pLed->BlinkTimer);
1616                        pLed->bLedScanBlinkInProgress = false;
1617                }
1618                if (pLed->bLedStartToLinkBlinkInProgress) {
1619                        del_timer(&pLed->BlinkTimer);
1620                        pLed->bLedStartToLinkBlinkInProgress = false;
1621                }
1622                if (pLed1->bLedWPSBlinkInProgress) {
1623                        del_timer(&pLed1->BlinkTimer);
1624                        pLed1->bLedWPSBlinkInProgress = false;
1625                }
1626                pLed1->BlinkingLedState = LED_UNKNOWN;
1627                SwLedOff(padapter, pLed);
1628                SwLedOff(padapter, pLed1);
1629                break;
1630        default:
1631                break;
1632        }
1633}
1634
1635static void SwLedControlMode5(struct _adapter *padapter,
1636                              enum LED_CTL_MODE LedAction)
1637{
1638        struct led_priv *ledpriv = &padapter->ledpriv;
1639        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1640        struct LED_871x *pLed = &ledpriv->SwLed0;
1641
1642        if (padapter->eeprompriv.CustomerID == RT_CID_819x_CAMEO)
1643                pLed = &ledpriv->SwLed1;
1644
1645        switch (LedAction) {
1646        case LED_CTL_POWER_ON:
1647        case LED_CTL_NO_LINK:
1648        case LED_CTL_LINK:      /* solid blue */
1649                if (pLed->CurrLedState == LED_SCAN_BLINK)
1650                        return;
1651                pLed->CurrLedState = LED_STATE_ON;
1652                pLed->BlinkingLedState = LED_STATE_ON;
1653                pLed->bLedBlinkInProgress = false;
1654                mod_timer(&pLed->BlinkTimer,
1655                          jiffies + msecs_to_jiffies(0));
1656                break;
1657        case LED_CTL_SITE_SURVEY:
1658                if (pmlmepriv->sitesurveyctrl.traffic_busy &&
1659                    check_fwstate(pmlmepriv, _FW_LINKED))
1660                        ; /* dummy branch */
1661                else if (!pLed->bLedScanBlinkInProgress) {
1662                        if (pLed->bLedBlinkInProgress) {
1663                                del_timer(&pLed->BlinkTimer);
1664                                pLed->bLedBlinkInProgress = false;
1665                        }
1666                        pLed->bLedScanBlinkInProgress = true;
1667                        pLed->CurrLedState = LED_SCAN_BLINK;
1668                        pLed->BlinkTimes = 24;
1669                        if (pLed->bLedOn)
1670                                pLed->BlinkingLedState = LED_STATE_OFF;
1671                        else
1672                                pLed->BlinkingLedState = LED_STATE_ON;
1673                        mod_timer(&pLed->BlinkTimer, jiffies +
1674                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1675                }
1676                break;
1677        case LED_CTL_TX:
1678        case LED_CTL_RX:
1679                if (!pLed->bLedBlinkInProgress) {
1680                        if (pLed->CurrLedState == LED_SCAN_BLINK)
1681                                return;
1682                        pLed->bLedBlinkInProgress = true;
1683                        pLed->CurrLedState = LED_TXRX_BLINK;
1684                        pLed->BlinkTimes = 2;
1685                        if (pLed->bLedOn)
1686                                pLed->BlinkingLedState = LED_STATE_OFF;
1687                        else
1688                                pLed->BlinkingLedState = LED_STATE_ON;
1689                        mod_timer(&pLed->BlinkTimer, jiffies +
1690                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1691                }
1692                break;
1693        case LED_CTL_POWER_OFF:
1694                pLed->CurrLedState = LED_STATE_OFF;
1695                pLed->BlinkingLedState = LED_STATE_OFF;
1696                if (pLed->bLedBlinkInProgress) {
1697                        del_timer(&pLed->BlinkTimer);
1698                        pLed->bLedBlinkInProgress = false;
1699                }
1700                SwLedOff(padapter, pLed);
1701                break;
1702        default:
1703                break;
1704        }
1705}
1706
1707static void SwLedControlMode6(struct _adapter *padapter,
1708                              enum LED_CTL_MODE LedAction)
1709{
1710        struct led_priv *ledpriv = &padapter->ledpriv;
1711        struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1712        struct LED_871x *pLed = &ledpriv->SwLed0;
1713
1714        switch (LedAction) {
1715        case LED_CTL_POWER_ON:
1716        case LED_CTL_NO_LINK:
1717        case LED_CTL_LINK:      /*solid blue*/
1718        case LED_CTL_SITE_SURVEY:
1719                if (IS_LED_WPS_BLINKING(pLed))
1720                        return;
1721                pLed->CurrLedState = LED_STATE_ON;
1722                pLed->BlinkingLedState = LED_STATE_ON;
1723                pLed->bLedBlinkInProgress = false;
1724                mod_timer(&pLed->BlinkTimer, jiffies + msecs_to_jiffies(0));
1725                break;
1726        case LED_CTL_TX:
1727        case LED_CTL_RX:
1728                if (!pLed->bLedBlinkInProgress &&
1729                    check_fwstate(pmlmepriv, _FW_LINKED)) {
1730                        if (IS_LED_WPS_BLINKING(pLed))
1731                                return;
1732                        pLed->bLedBlinkInProgress = true;
1733                        pLed->CurrLedState = LED_TXRX_BLINK;
1734                        pLed->BlinkTimes = 2;
1735                        if (pLed->bLedOn)
1736                                pLed->BlinkingLedState = LED_STATE_OFF;
1737                        else
1738                                pLed->BlinkingLedState = LED_STATE_ON;
1739                        mod_timer(&pLed->BlinkTimer, jiffies +
1740                                  msecs_to_jiffies(LED_BLINK_FASTER_INTERVAL_ALPHA));
1741                }
1742                break;
1743        case LED_CTL_START_WPS: /*wait until xinpin finish*/
1744        case LED_CTL_START_WPS_BOTTON:
1745                if (!pLed->bLedWPSBlinkInProgress) {
1746                        if (pLed->bLedBlinkInProgress) {
1747                                del_timer(&pLed->BlinkTimer);
1748                                pLed->bLedBlinkInProgress = false;
1749                        }
1750                        pLed->bLedWPSBlinkInProgress = true;
1751                        pLed->CurrLedState = LED_BLINK_WPS;
1752                        if (pLed->bLedOn)
1753                                pLed->BlinkingLedState = LED_STATE_OFF;
1754                        else
1755                                pLed->BlinkingLedState = LED_STATE_ON;
1756                        mod_timer(&pLed->BlinkTimer, jiffies +
1757                                  msecs_to_jiffies(LED_BLINK_SCAN_INTERVAL_ALPHA));
1758                }
1759                break;
1760        case LED_CTL_STOP_WPS_FAIL:
1761        case LED_CTL_STOP_WPS:
1762                if (pLed->bLedWPSBlinkInProgress) {
1763                        del_timer(&pLed->BlinkTimer);
1764                        pLed->bLedWPSBlinkInProgress = false;
1765                }
1766                pLed->CurrLedState = LED_STATE_ON;
1767                pLed->BlinkingLedState = LED_STATE_ON;
1768                mod_timer(&pLed->BlinkTimer,
1769                          jiffies + msecs_to_jiffies(0));
1770                break;
1771        case LED_CTL_POWER_OFF:
1772                pLed->CurrLedState = LED_STATE_OFF;
1773                pLed->BlinkingLedState = LED_STATE_OFF;
1774                if (pLed->bLedBlinkInProgress) {
1775                        del_timer(&pLed->BlinkTimer);
1776                        pLed->bLedBlinkInProgress = false;
1777                }
1778                if (pLed->bLedWPSBlinkInProgress) {
1779                        del_timer(&pLed->BlinkTimer);
1780                        pLed->bLedWPSBlinkInProgress = false;
1781                }
1782                SwLedOff(padapter, pLed);
1783                break;
1784        default:
1785                break;
1786        }
1787}
1788
1789/*      Description:
1790 *              Dispatch LED action according to pHalData->LedStrategy.
1791 */
1792void LedControl871x(struct _adapter *padapter, enum LED_CTL_MODE LedAction)
1793{
1794        struct led_priv *ledpriv = &padapter->ledpriv;
1795
1796        if (!ledpriv->bRegUseLed)
1797                return;
1798        switch (ledpriv->LedStrategy) {
1799        case SW_LED_MODE0:
1800                break;
1801        case SW_LED_MODE1:
1802                SwLedControlMode1(padapter, LedAction);
1803                break;
1804        case SW_LED_MODE2:
1805                SwLedControlMode2(padapter, LedAction);
1806                break;
1807        case SW_LED_MODE3:
1808                SwLedControlMode3(padapter, LedAction);
1809                break;
1810        case SW_LED_MODE4:
1811                SwLedControlMode4(padapter, LedAction);
1812                break;
1813        case SW_LED_MODE5:
1814                SwLedControlMode5(padapter, LedAction);
1815                break;
1816        case SW_LED_MODE6:
1817                SwLedControlMode6(padapter, LedAction);
1818                break;
1819        default:
1820                break;
1821        }
1822}
1823