git.oblomov.eu Git - linux-2.6/blob - drivers/staging/otus/80211core/ledmgr.c

   1 /*
   2  * Copyright (c) 2007-2008 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "cprecomp.h"
  18
  19 /************************************************************************/
  20 /*                                                                      */
  21 /*    FUNCTION DESCRIPTION                  zfLedCtrlType1              */
  22 /*      Traditional single-LED state                                    */
  23 /*                                                                      */
  24 /*    INPUTS                                                            */
  25 /*      dev : device pointer                                            */
  26 /*                                                                      */
  27 /*    OUTPUTS                                                           */
  28 /*      None                                                            */
  29 /*                                                                      */
  30 /*    AUTHOR                                                            */
  31 /*      Stephen Chen        Atheros Communications, INC.    2007.6      */
  32 /*                                                                      */
  33 /************************************************************************/
  34 // bit 15-12 : Toff for Scan state
  35 //     11-8 : Ton for Scan state
  36 //     7 : Reserved
  37 //     6 : mode
  38 //--------------------------------------
  39 //     bit 6 = 0
  40 //     5-4 : Connect state
  41 //           00 => always off
  42 //           01 => always on
  43 //           10 => Idle off, acitve on
  44 //           11 => Idle on, active off
  45 //--------------------------------------
  46 //     bit 6 = 1
  47 //     5-4 : freq
  48 //           00 => 1Hz
  49 //           01 => 0.5Hz
  50 //           10 => 0.25Hz
  51 //           11 => 0.125Hz
  52 //--------------------------------------
  53 //     3 : Power save state
  54 //         0 => always off in power save state
  55 //         1 => works as connect state
  56 //     2 : Disable state
  57 //     1 : Reserved
  58 //     0 : Power-on state
  59 void zfLedCtrlType1(zdev_t* dev)
  60 {
  61     u16_t i;
  62     u32_t ton, toff, tmp, period;
  63     zmw_get_wlan_dev(dev);
  64
  65     for (i=0; i<ZM_MAX_LED_NUMBER; i++)
  66     {
  67         if (zfStaIsConnected(dev) != TRUE)
  68         {
  69             //Scan state
  70             ton = ((wd->ledStruct.ledMode[i] & 0xf00) >> 8) * 5;
  71             toff = ((wd->ledStruct.ledMode[i] & 0xf000) >> 12) * 5;
  72
  73             if ((ton + toff) != 0)
  74             {
  75                 tmp = wd->ledStruct.counter / (ton+toff);
  76                 tmp = wd->ledStruct.counter - (tmp * (ton+toff));
  77                 if (tmp < ton)
  78                 {
  79                     zfHpLedCtrl(dev, i, 1);
  80                 }
  81                 else
  82                 {
  83                     zfHpLedCtrl(dev, i, 0);
  84                 }
  85             }
  86         }
  87         else
  88         {
  89             if ((zfPowerSavingMgrIsSleeping(dev)) && ((wd->ledStruct.ledMode[i] & 0x8) == 0))
  90             {
  91                 zfHpLedCtrl(dev, i, 0);
  92             }
  93             else
  94             {
  95                 //Connect state
  96                 if ((wd->ledStruct.ledMode[i] & 0x40) == 0)
  97                 {
  98                     if ((wd->ledStruct.counter & 1) == 0)
  99                     {
 100                         zfHpLedCtrl(dev, i, (wd->ledStruct.ledMode[i] & 0x10) >> 4);
 101                     }
 102                     else
 103                     {
 104                         if ((wd->ledStruct.txTraffic > 0) || (wd->ledStruct.rxTraffic > 0))
 105                         {
 106                             wd->ledStruct.txTraffic = wd->ledStruct.rxTraffic = 0;
 107                             if ((wd->ledStruct.ledMode[i] & 0x20) != 0)
 108                             {
 109                                 zfHpLedCtrl(dev, i, ((wd->ledStruct.ledMode[i] & 0x10) >> 4)^1);
 110                             }
 111                         }
 112                     }
 113                 }// if ((wd->ledStruct.ledMode[i] & 0x40) == 0)
 114                 else
 115                 {
 116                     period = 5 * (1 << ((wd->ledStruct.ledMode[i] & 0x30) >> 4));
 117                     tmp = wd->ledStruct.counter / (period*2);
 118                     tmp = wd->ledStruct.counter - (tmp * (period*2));
 119                     if (tmp < period)
 120                     {
 121                         if ((wd->ledStruct.counter & 1) == 0)
 122                         {
 123                             zfHpLedCtrl(dev, i, 0);
 124                         }
 125                         else
 126                         {
 127                             if ((wd->ledStruct.txTraffic > 0) || (wd->ledStruct.rxTraffic > 0))
 128                             {
 129                                 wd->ledStruct.txTraffic = wd->ledStruct.rxTraffic = 0;
 130                                 zfHpLedCtrl(dev, i, 1);
 131                             }
 132                         }
 133                     }
 134                     else
 135                     {
 136                         if ((wd->ledStruct.counter & 1) == 0)
 137                         {
 138                             zfHpLedCtrl(dev, i, 1);
 139                         }
 140                         else
 141                         {
 142                             if ((wd->ledStruct.txTraffic > 0) || (wd->ledStruct.rxTraffic > 0))
 143                             {
 144                                 wd->ledStruct.txTraffic = wd->ledStruct.rxTraffic = 0;
 145                                 zfHpLedCtrl(dev, i, 0);
 146                             }
 147                         }
 148                     }
 149                 } //else, if ((wd->ledStruct.ledMode[i] & 0x40) == 0)
 150             } //else, if (zfPowerSavingMgrIsSleeping(dev))
 151         } //else : if (zfStaIsConnected(dev) != TRUE)
 152     } //for (i=0; i<ZM_MAX_LED_NUMBER; i++)
 153 }
 154
 155 /******************************************************************************/
 156 /*                                                                            */
 157 /*    FUNCTION DESCRIPTION                  zfLedCtrlType2                    */
 158 /*      Customize for Netgear Dual-LED state ((bug#31292))                    */
 159 /*                                                                            */
 160 /*      1. Status:  When dongle does not connect to 2.4G or 5G but in site    */
 161 /*                  survey/association                                        */
 162 /*         LED status: Slow blinking, Amber then Blue per 500ms               */
 163 /*      2. Status:      Connection at 2.4G in site survey/association             */
 164 /*         LED status: Slow blinking, Amber/off per 500ms                     */
 165 /*      3. Status:      Connection at 5G in site survey/association               */
 166 /*         LED status: Slow blinking, Blue/off per 500ms                      */
 167 /*      4. Status:      When transfer the packet                                  */
 168 /*         LED status: Blink per packet, including TX and RX                  */
 169 /*      5. Status:      When linking is established but no traffic                */
 170 /*         LED status: Always on                                              */
 171 /*      6. Status:      When linking is dropped but no re-connection              */
 172 /*         LED status: Always off                                             */
 173 /*      7. Status:      From one connection(2.4G or 5G) to change to another band */
 174 /*         LED status: Amber/Blue =>Slow blinking, Amber then Blue per 500ms  */
 175 /*                                                                            */
 176 /*    INPUTS                                                                  */
 177 /*      dev : device pointer                                                  */
 178 /*                                                                            */
 179 /*    OUTPUTS                                                                 */
 180 /*      None                                                                  */
 181 /*                                                                            */
 182 /*    AUTHOR                                                                  */
 183 /*      Shang-Chun Liu        Atheros Communications, INC.    2007.11         */
 184 /*                                                                            */
 185 /******************************************************************************/
 186 void zfLedCtrlType2_scan(zdev_t* dev);
 187
 188 void zfLedCtrlType2(zdev_t* dev)
 189 {
 190     u32_t ton, toff, tmp, period;
 191     u16_t OperateLED;
 192     zmw_get_wlan_dev(dev);
 193
 194     if (zfStaIsConnected(dev) != TRUE)
 195     {
 196         // Disconnect state
 197         if(wd->ledStruct.counter % 4 != 0)
 198         {
 199             // Update LED each 400ms(4*100)
 200             // Prevent this situation
 201             //              _______         ___
 202             // LED[0] ON   |       |       | x |
 203             // ------ OFF->+-+-+-+-+-+-+-+-+-+-+-+->>>...
 204             // LED[1] ON
 205             //
 206             return;
 207         }
 208
 209         if (((wd->state == ZM_WLAN_STATE_DISABLED) && (wd->sta.bChannelScan))
 210             || ((wd->state != ZM_WLAN_STATE_DISABLED) && (wd->sta.bAutoReconnect)))
 211         {
 212             // Scan/AutoReconnect state
 213             zfLedCtrlType2_scan(dev);
 214         }
 215         else
 216         {
 217             // Neither Connected nor Scan
 218             zfHpLedCtrl(dev, 0, 0);
 219             zfHpLedCtrl(dev, 1, 0);
 220         }
 221     }
 222     else
 223     {
 224         if( wd->sta.bChannelScan )
 225         {
 226             // Scan state
 227             if(wd->ledStruct.counter % 4 != 0)
 228                 return;
 229             zfLedCtrlType2_scan(dev);
 230             return;
 231         }
 232
 233         if(wd->frequency < 3000)
 234         {
 235             OperateLED = 0;     // LED[0]: work on 2.4G (b/g band)
 236             zfHpLedCtrl(dev, 1, 0);
 237         }
 238         else
 239         {
 240             OperateLED = 1;     // LED[1]: work on 5G (a band)
 241             zfHpLedCtrl(dev, 0, 0);
 242         }
 243
 244         if ((zfPowerSavingMgrIsSleeping(dev)) && ((wd->ledStruct.ledMode[OperateLED] & 0x8) == 0))
 245         {
 246             // If Sleeping, turn OFF
 247             zfHpLedCtrl(dev, OperateLED, 0);
 248         }
 249         else
 250         {
 251             //Connect state
 252             if ((wd->ledStruct.counter & 1) == 0)   // even
 253             {
 254                 // No traffic, always ON
 255                 zfHpLedCtrl(dev, OperateLED, 1);
 256             }
 257             else       // odd
 258             {
 259                 if ((wd->ledStruct.txTraffic > 0) || (wd->ledStruct.rxTraffic > 0))
 260                 {
 261                     // If have traffic, turn OFF
 262                             //                   _____   _   _   _   _____
 263                             // LED[Operate] ON        | | | | | | | |
 264                             // ------------ OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+->>>...
 265                             //
 266                     wd->ledStruct.txTraffic = wd->ledStruct.rxTraffic = 0;
 267                     zfHpLedCtrl(dev, OperateLED, 0);
 268                 }
 269             }
 270         }
 271     }
 272 }
 273
 274 void zfLedCtrlType2_scan(zdev_t* dev)
 275 {
 276     zmw_get_wlan_dev(dev);
 277
 278     // When doing scan, blink(Amber/Blue) and off per 500ms (about 400ms in our driver)
 279     //               _______                         _______
 280     // LED[0] ON    |       |       8       12      |       |
 281     // ------ OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+->>>...
 282     // LED[1] ON    0       4       |_______|       0       3
 283     //
 284
 285     switch(wd->ledStruct.counter % 16)
 286     {
 287         case 0:   // case 0~3, LED[0] on
 288             if(wd->supportMode & ZM_WIRELESS_MODE_24)
 289             {
 290                 zfHpLedCtrl(dev, 0, 1);
 291                 zfHpLedCtrl(dev, 1, 0);
 292             }
 293             else
 294             {
 295                 zfHpLedCtrl(dev, 1, 1);
 296                 zfHpLedCtrl(dev, 0, 0);
 297             }
 298             break;
 299
 300         case 8:   // case 8~11, LED[1] on
 301             if(wd->supportMode & ZM_WIRELESS_MODE_5)
 302             {
 303                 zfHpLedCtrl(dev, 1, 1);
 304                 zfHpLedCtrl(dev, 0, 0);
 305             }
 306             else
 307             {
 308                 zfHpLedCtrl(dev, 0, 1);
 309                 zfHpLedCtrl(dev, 1, 0);
 310             }
 311             break;
 312
 313         default:  // others, all off
 314             zfHpLedCtrl(dev, 0, 0);
 315             zfHpLedCtrl(dev, 1, 0);
 316             break;
 317     }
 318 }
 319
 320 /**********************************************************************************/
 321 /*                                                                                */
 322 /*    FUNCTION DESCRIPTION                  zfLedCtrlType3                        */
 323 /*      Customize for Netgear Single-LED state ((bug#32243))                      */
 324 /*                                                                                */
 325 /*  ¡EOff: when the adapter is disabled or hasn't started to associate with AP    */
 326 /*         yet.                                                                          */
 327 /*  ¡EOn: Once adpater associate with AP successfully                             */
 328 /*  ¡ESlow blinking: whenever adapters do site-survey or try to associate with AP */
 329 /*    - If there is a connection already, and adapters do site-survey or          */
 330 /*      re-associate action, the LED should keep LED backgraoud as ON, thus       */
 331 /*      the blinking behavior SHOULD be OFF (200ms) - ON (800ms) and continue this*/
 332 /*      cycle.                                                                    */
 333 /*    - If there is no connection yet, and adapters start to do site-survey or    */
 334 /*      associate action, the LED should keep LED background as OFF, thus the     */
 335 /*      blinking behavior SHOULD be ON (200ms) - OFF (800ms) and continue this    */
 336 /*      cycle.                                                                    */
 337 /*    - For the case that associate fail, adpater should keep associating, and the*/
 338 /*      LED should also keep slow blinking.                                       */
 339 /*  ¡EQuick blinking: to blink OFF-ON cycle for each time that traffic packet is  */
 340 /*    received or is transmitted.                                                 */
 341 /*                                                                                */
 342 /*    INPUTS                                                                      */
 343 /*      dev : device pointer                                                      */
 344 /*                                                                                */
 345 /*    OUTPUTS                                                                     */
 346 /*      None                                                                      */
 347 /*                                                                                */
 348 /*    AUTHOR                                                                      */
 349 /*      Shang-Chun Liu        Atheros Communications, INC.    2008.01             */
 350 /*                                                                                */
 351 /**********************************************************************************/
 352 void zfLedCtrlType3_scan(zdev_t* dev, u16_t isConnect);
 353
 354 void zfLedCtrlType3(zdev_t* dev)
 355 {
 356     zmw_get_wlan_dev(dev);
 357
 358     if (zfStaIsConnected(dev) != TRUE)
 359     {
 360         // Disconnect state
 361         if(wd->ledStruct.counter % 2 != 0)
 362         {
 363             // Update LED each 200ms(2*100)
 364             // Prevent this situation
 365             //              ___     _
 366             // LED[0] ON   |   |   |x|
 367             // ------ OFF->+-+-+-+-+-+-+->>>...
 368             //
 369             return;
 370         }
 371
 372         if (((wd->state == ZM_WLAN_STATE_DISABLED) && (wd->sta.bChannelScan))
 373             || ((wd->state != ZM_WLAN_STATE_DISABLED) && (wd->sta.bAutoReconnect)))
 374         {
 375             // Scan/AutoReconnect state
 376             zfLedCtrlType3_scan(dev, 0);
 377         }
 378         else
 379         {
 380             // Neither Connected nor Scan
 381             zfHpLedCtrl(dev, 0, 0);
 382             zfHpLedCtrl(dev, 1, 0);
 383         }
 384     }
 385     else
 386     {
 387         if( wd->sta.bChannelScan )
 388         {
 389             // Scan state
 390             if(wd->ledStruct.counter % 2 != 0)
 391                 return;
 392             zfLedCtrlType3_scan(dev, 1);
 393             return;
 394         }
 395
 396         if ((zfPowerSavingMgrIsSleeping(dev)) && ((wd->ledStruct.ledMode[0] & 0x8) == 0))
 397         {
 398             // If Sleeping, turn OFF
 399             zfHpLedCtrl(dev, 0, 0);
 400             zfHpLedCtrl(dev, 1, 0);
 401         }
 402         else
 403         {
 404             //Connect state
 405             if ((wd->ledStruct.counter & 1) == 0)   // even
 406             {
 407                 // No traffic, always ON
 408                 zfHpLedCtrl(dev, 0, 1);
 409                 zfHpLedCtrl(dev, 1, 1);
 410             }
 411             else       // odd
 412             {
 413                 if ((wd->ledStruct.txTraffic > 0) || (wd->ledStruct.rxTraffic > 0))
 414                 {
 415                     // If have traffic, turn OFF
 416                             //                   _____   _   _   _   _____
 417                             // LED[Operate] ON        | | | | | | | |
 418                             // ------------ OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+->>>...
 419                             //
 420                     wd->ledStruct.txTraffic = wd->ledStruct.rxTraffic = 0;
 421                     zfHpLedCtrl(dev, 0, 0);
 422                     zfHpLedCtrl(dev, 1, 0);
 423                 }
 424             }
 425         }
 426     }
 427 }
 428
 429 void zfLedCtrlType3_scan(zdev_t* dev, u16_t isConnect)
 430 {
 431     u32_t ton, toff, tmp;
 432     zmw_get_wlan_dev(dev);
 433
 434     // Doing scan when :
 435     // 1. Disconnected: ON (200ms) - OFF (800ms) (200ms-600ms in our driver)
 436     //               ___             ___             ___
 437     // LED[0] ON    |   |           |   |           |   |
 438     // ------ OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+->>>...
 439     //              0   2   4   6   8  10  12  14  16
 440     // 2. Connected:   ON (800ms) - OFF (200ms) (600ms-200ms in our driver)
 441     //               ___________     ___________     ______
 442     // LED[0] ON    |           |   |           |   |
 443     // ------ OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+->>>...
 444     //              0   2   4   6   8  10  12  14  16
 445
 446     //Scan state
 447     if(!isConnect)
 448         ton = 2, toff = 6;
 449     else
 450         ton = 6, toff = 2;
 451
 452     if ((ton + toff) != 0)
 453     {
 454         tmp = wd->ledStruct.counter % (ton+toff);
 455        if (tmp < ton)
 456         {
 457             zfHpLedCtrl(dev, 0, 1);
 458             zfHpLedCtrl(dev, 1, 1);
 459         }
 460         else
 461         {
 462             zfHpLedCtrl(dev, 0, 0);
 463             zfHpLedCtrl(dev, 1, 0);
 464         }
 465     }
 466 }
 467
 468 /******************************************************************************/
 469 /*                                                                            */
 470 /*    FUNCTION DESCRIPTION                  zfLedCtrl_BlinkWhenScan_Alpha     */
 471 /*      Customize for Alpha/DLink LED                                         */
 472 /*      - Blink LED 12 times within 3 seconds when doing Active Scan          */
 473 /*                            ___   ___   ___   ___                               */
 474 /*            LED[0] ON      |   | |   | |   | |   |                              */
 475 /*            -------OFF->-+-+-+-+-+-+-+-+-+-+-+-+-+--+-->>>...                   */
 476 /*                                                                            */
 477 /*    INPUTS                                                                  */
 478 /*      dev : device pointer                                                  */
 479 /*                                                                            */
 480 /*    OUTPUTS                                                                 */
 481 /*      None                                                                  */
 482 /*                                                                            */
 483 /*    AUTHOR                                                                  */
 484 /*      Shang-Chun Liu        Atheros Communications, INC.    2007.11         */
 485 /*                                                                            */
 486 /******************************************************************************/
 487 void zfLedCtrl_BlinkWhenScan_Alpha(zdev_t* dev)
 488 {
 489     static u32_t counter = 0;
 490     zmw_get_wlan_dev(dev);
 491
 492     if(counter > 34)        // counter for 3 sec
 493     {
 494         wd->ledStruct.LEDCtrlFlag &= ~(u8_t)ZM_LED_CTRL_FLAG_ALPHA;
 495         counter = 0;
 496     }
 497
 498     if( (counter % 3) < 2)
 499         zfHpLedCtrl(dev, 0, 1);
 500     else
 501         zfHpLedCtrl(dev, 0, 0);
 502
 503     counter++;
 504 }
 505
 506
 507 /************************************************************************/
 508 /*                                                                      */
 509 /*    FUNCTION DESCRIPTION                  zfLed100msCtrl              */
 510 /*      LED 100 milliseconds timer.                                     */
 511 /*                                                                      */
 512 /*    INPUTS                                                            */
 513 /*      dev : device pointer                                            */
 514 /*                                                                      */
 515 /*    OUTPUTS                                                           */
 516 /*      None                                                            */
 517 /*                                                                      */
 518 /*    AUTHOR                                                            */
 519 /*      Stephen Chen        Atheros Communications, INC.    2007.6      */
 520 /*                                                                      */
 521 /************************************************************************/
 522 void zfLed100msCtrl(zdev_t* dev)
 523 {
 524     zmw_get_wlan_dev(dev);
 525
 526     wd->ledStruct.counter++;
 527
 528     if(wd->ledStruct.LEDCtrlFlag)
 529     {
 530         switch(wd->ledStruct.LEDCtrlFlag) {
 531         case ZM_LED_CTRL_FLAG_ALPHA:
 532             zfLedCtrl_BlinkWhenScan_Alpha(dev);
 533         break;
 534         }
 535     }
 536     else
 537     {
 538         switch(wd->ledStruct.LEDCtrlType) {
 539         case 1:                 // Traditional 1 LED
 540             zfLedCtrlType1(dev);
 541         break;
 542
 543         case 2:                 // Dual-LEDs for Netgear
 544             zfLedCtrlType2(dev);
 545         break;
 546
 547         case 3:                 // Single-LED for Netgear (WN111v2)
 548             zfLedCtrlType3(dev);
 549         break;
 550
 551         default:
 552             zfLedCtrlType1(dev);
 553         break;
 554         }
 555     }
 556 }
 557