mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2025-04-21 12:27:27 +03:00
Split up brcm63xx into files/
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@6848 3c298f89-4303-0410-b956-a3cf2f4a3e73
This commit is contained in:
florian
582
target/linux/brcm63xx-2.6/files/arch/mips/bcm963xx/bcm63xx_led.c
Normal file
582
target/linux/brcm63xx-2.6/files/arch/mips/bcm963xx/bcm63xx_led.c
Normal file
@@ -0,0 +1,582 @@
|
||||
/*
|
||||
<:copyright-gpl
|
||||
Copyright 2002 Broadcom Corp. All Rights Reserved.
|
||||
|
||||
This program is free software; you can distribute it and/or modify it
|
||||
under the terms of the GNU General Public License (Version 2) as
|
||||
published by the Free Software Foundation.
|
||||
|
||||
This program is distributed in the hope it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
|
||||
:>
|
||||
*/
|
||||
/***************************************************************************
|
||||
* File Name : bcm63xx_led.c
|
||||
*
|
||||
* Description:
|
||||
*
|
||||
* This file contains bcm963xx board led control API functions.
|
||||
*
|
||||
* To use it, do the following
|
||||
*
|
||||
* 1). define in the board.c the following led mappping (this is for 6345GW board):
|
||||
* const LED_MAP_PAIR cLedMapping45GW[] =
|
||||
* { // led name Initial state physical pin (ledMask)
|
||||
* {kLedUsb, kLedStateOff, GPIO_LED_PIN_7},
|
||||
* {kLedAdsl, kLedStateOff, GPIO_LED_PIN_8},
|
||||
* {kLedPPP, kLedStateOff, GPIO_LED_PIN_9}, // PPP and WanData share PIN_9
|
||||
* {kLedWanData, kLedStateOff, GPIO_LED_PIN_9},
|
||||
* {kLedWireless, kLedStateOff, GPIO_LED_PIN_10},
|
||||
* {kLedEnd, kLedStateOff, 0 } // NOTE: kLedEnd has to be at the end.
|
||||
*
|
||||
* 2). };To initialize led API and initial state of the leds, call the following function with the mapping
|
||||
* pointer from the above struct
|
||||
*
|
||||
* boardLedInit((PLED_MAP_PAIR) &cLedMapping45R);
|
||||
*
|
||||
* 3). Sample call for kernel mode:
|
||||
*
|
||||
* kerSysLedCtrl(kLedAdsl, kLedStateBlinkOnce); // kLedxxx defines in board.h
|
||||
*
|
||||
* 4). Sample call for user mode
|
||||
*
|
||||
* sysLedCtrl(kLedAdsl, kLedStateBlinkOnce); // kLedxxx defines in board_api.h
|
||||
*
|
||||
*
|
||||
* Created on : 10/28/2002 seanl
|
||||
*
|
||||
***************************************************************************/
|
||||
|
||||
/* Includes. */
|
||||
#include <linux/init.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/capability.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include <bcm_map_part.h>
|
||||
#include <board.h>
|
||||
|
||||
#define k100ms (HZ / 10) // ~100 ms
|
||||
#define kFastBlinkCount 0 // ~100ms
|
||||
#define kSlowBlinkCount 5 // ~600ms
|
||||
|
||||
#define MAX_VIRT_LEDS 12
|
||||
|
||||
// uncomment // for debug led
|
||||
//#define DEBUG_LED
|
||||
|
||||
// global variables:
|
||||
struct timer_list gLedTimer;
|
||||
int gTimerOn = FALSE;
|
||||
int gLedCount = 0;
|
||||
|
||||
typedef struct ledinfo
|
||||
{
|
||||
unsigned short ledMask; // mask for led: ie. giop 10 = 0x0400
|
||||
unsigned short ledActiveLow; // GPIO bit reset to turn on LED
|
||||
unsigned short ledMaskFail; // mask for led: ie. giop 10 = 0x0400
|
||||
unsigned short ledActiveLowFail;// GPIO bit reset to turn on LED
|
||||
BOARD_LED_STATE ledState; // current led state
|
||||
BOARD_LED_STATE savedLedState; // used in blink once for restore to the orignal ledState
|
||||
int blinkCountDown; // if == 0, do blink (toggle). Is assgined value and dec by 1 at each timer.
|
||||
} LED_INFO, *PLED_INFO;
|
||||
|
||||
static PLED_INFO gLed = NULL;
|
||||
static PLED_INFO gpVirtLeds[MAX_VIRT_LEDS];
|
||||
static HANDLE_LED_FUNC gLedHwFunc[MAX_VIRT_LEDS];
|
||||
static HANDLE_LED_FUNC gLedHwFailFunc[MAX_VIRT_LEDS];
|
||||
|
||||
#if 0 /* BROKEN */
|
||||
#if defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)
|
||||
static int gLedOffInBridgeMode = 1;
|
||||
#elif defined(CONFIG_BCM96345)
|
||||
static int gLedOffInBridgeMode = 0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void ledTimerExpire(void);
|
||||
int initLedInfo( PLED_MAP_PAIR pCurMap, PLED_INFO pCurLed );
|
||||
|
||||
//**************************************************************************************
|
||||
// LED operations
|
||||
//**************************************************************************************
|
||||
|
||||
// turn led on and set the ledState
|
||||
void ledOn(PLED_INFO pLed)
|
||||
{
|
||||
if( pLed->ledMask )
|
||||
{
|
||||
GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
|
||||
if( pLed->ledActiveLow )
|
||||
GPIO->GPIOio &= ~pLed->ledMask; // turn on the led
|
||||
else
|
||||
GPIO->GPIOio |= pLed->ledMask; // turn on the led
|
||||
pLed->ledState = pLed->savedLedState = kLedStateOn;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// turn led off and set the ledState
|
||||
void ledOff(PLED_INFO pLed)
|
||||
{
|
||||
if( pLed->ledMask )
|
||||
{
|
||||
GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
|
||||
if( pLed->ledActiveLow )
|
||||
GPIO->GPIOio |= pLed->ledMask; // turn off the led
|
||||
else
|
||||
GPIO->GPIOio &= ~pLed->ledMask; // turn off the led
|
||||
pLed->ledState = pLed->savedLedState = kLedStateOff;
|
||||
}
|
||||
}
|
||||
|
||||
// turn led on and set the ledState
|
||||
void ledOnFail(PLED_INFO pLed)
|
||||
{
|
||||
if( pLed->ledMaskFail )
|
||||
{
|
||||
GPIO->GPIODir |= pLed->ledMaskFail; // turn on the direction bit in case was turned off by some one
|
||||
if( pLed->ledActiveLowFail )
|
||||
GPIO->GPIOio &= ~pLed->ledMaskFail;// turn on the led
|
||||
else
|
||||
GPIO->GPIOio |= pLed->ledMaskFail; // turn on the led
|
||||
pLed->ledState = pLed->savedLedState = kLedStateFail;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// turn led off and set the ledState
|
||||
void ledOffFail(PLED_INFO pLed)
|
||||
{
|
||||
if( pLed->ledMaskFail )
|
||||
{
|
||||
GPIO->GPIODir |= pLed->ledMaskFail; // turn on the direction bit in case was turned off by some one
|
||||
if( pLed->ledActiveLowFail )
|
||||
GPIO->GPIOio |= pLed->ledMaskFail; // turn off the led
|
||||
else
|
||||
GPIO->GPIOio &= ~pLed->ledMaskFail;// turn off the led
|
||||
pLed->ledState = pLed->savedLedState = kLedStateOff;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// toggle the led and return the current ledState
|
||||
BOARD_LED_STATE ledToggle(PLED_INFO pLed)
|
||||
{
|
||||
GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
|
||||
if (GPIO->GPIOio & pLed->ledMask)
|
||||
{
|
||||
GPIO->GPIOio &= ~(pLed->ledMask);
|
||||
return( (pLed->ledActiveLow) ? kLedStateOn : kLedStateOff );
|
||||
}
|
||||
else
|
||||
{
|
||||
GPIO->GPIOio |= pLed->ledMask;
|
||||
return( (pLed->ledActiveLow) ? kLedStateOff : kLedStateOn );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// led timer. Will return if timer is already on
|
||||
void ledTimerStart(void)
|
||||
{
|
||||
if (gTimerOn)
|
||||
return;
|
||||
|
||||
#if defined(DEBUG_LED)
|
||||
printk("led: add_timer\n");
|
||||
#endif
|
||||
|
||||
init_timer(&gLedTimer);
|
||||
gLedTimer.function = (void*)ledTimerExpire;
|
||||
gLedTimer.expires = jiffies + k100ms; // timer expires in ~100ms
|
||||
add_timer (&gLedTimer);
|
||||
gTimerOn = TRUE;
|
||||
}
|
||||
|
||||
|
||||
// led timer expire kicks in about ~100ms and perform the led operation according to the ledState and
|
||||
// restart the timer according to ledState
|
||||
void ledTimerExpire(void)
|
||||
{
|
||||
int i;
|
||||
PLED_INFO pCurLed;
|
||||
|
||||
gTimerOn = FALSE;
|
||||
|
||||
for (i = 0, pCurLed = gLed; i < gLedCount; i++, pCurLed++)
|
||||
{
|
||||
#if defined(DEBUG_LED)
|
||||
printk("led[%d]: Mask=0x%04x, State = %d, blcd=%d\n", i, pCurLed->ledMask, pCurLed->ledState, pCurLed->blinkCountDown);
|
||||
#endif
|
||||
switch (pCurLed->ledState)
|
||||
{
|
||||
case kLedStateOn:
|
||||
case kLedStateOff:
|
||||
case kLedStateFail:
|
||||
pCurLed->blinkCountDown = 0; // reset the blink count down
|
||||
break;
|
||||
|
||||
case kLedStateBlinkOnce:
|
||||
ledToggle(pCurLed);
|
||||
pCurLed->blinkCountDown = 0; // reset to 0
|
||||
pCurLed->ledState = pCurLed->savedLedState;
|
||||
if (pCurLed->ledState == kLedStateSlowBlinkContinues ||
|
||||
pCurLed->ledState == kLedStateFastBlinkContinues)
|
||||
ledTimerStart(); // start timer if in blinkContinues stats
|
||||
break;
|
||||
|
||||
case kLedStateSlowBlinkContinues:
|
||||
if (pCurLed->blinkCountDown-- == 0)
|
||||
{
|
||||
pCurLed->blinkCountDown = kSlowBlinkCount;
|
||||
ledToggle(pCurLed);
|
||||
}
|
||||
ledTimerStart();
|
||||
break;
|
||||
|
||||
case kLedStateFastBlinkContinues:
|
||||
if (pCurLed->blinkCountDown-- == 0)
|
||||
{
|
||||
pCurLed->blinkCountDown = kFastBlinkCount;
|
||||
ledToggle(pCurLed);
|
||||
}
|
||||
ledTimerStart();
|
||||
break;
|
||||
|
||||
default:
|
||||
printk("Invalid state = %d\n", pCurLed->ledState);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// initialize the gLedCount and allocate and fill gLed struct
|
||||
void __init boardLedInit(PLED_MAP_PAIR cLedMapping)
|
||||
{
|
||||
PLED_MAP_PAIR p1, p2;
|
||||
PLED_INFO pCurLed;
|
||||
int needTimer = FALSE;
|
||||
int alreadyUsed = 0;
|
||||
|
||||
#if defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)
|
||||
/* Set blink rate for BCM6348/BCM6338 hardware LEDs. */
|
||||
GPIO->LEDCtrl &= ~LED_INTERVAL_SET_MASK;
|
||||
GPIO->LEDCtrl |= LED_INTERVAL_SET_80MS;
|
||||
#endif
|
||||
|
||||
memset( gpVirtLeds, 0x00, sizeof(gpVirtLeds) );
|
||||
memset( gLedHwFunc, 0x00, sizeof(gLedHwFunc) );
|
||||
memset( gLedHwFailFunc, 0x00, sizeof(gLedHwFailFunc) );
|
||||
|
||||
gLedCount = 0;
|
||||
|
||||
// Check for multiple LED names and multiple LED GPIO pins that share the
|
||||
// same physical board LED.
|
||||
for( p1 = cLedMapping; p1->ledName != kLedEnd; p1++ )
|
||||
{
|
||||
alreadyUsed = 0;
|
||||
for( p2 = cLedMapping; p2 != p1; p2++ )
|
||||
{
|
||||
if( (p1->ledMask && p1->ledMask == p2->ledMask) ||
|
||||
(p1->ledMaskFail && p1->ledMaskFail == p2->ledMaskFail) )
|
||||
{
|
||||
alreadyUsed = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( alreadyUsed == 0 )
|
||||
gLedCount++;
|
||||
}
|
||||
|
||||
gLed = (PLED_INFO) kmalloc((gLedCount * sizeof(LED_INFO)), GFP_KERNEL);
|
||||
if( gLed == NULL )
|
||||
{
|
||||
printk( "LED memory allocation error.\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
memset( gLed, 0x00, gLedCount * sizeof(LED_INFO) );
|
||||
|
||||
// initial the gLed with unique ledMask and initial state. If more than 1 ledNames share the physical led
|
||||
// (ledMask) the first defined led's ledInitState will be used.
|
||||
pCurLed = gLed;
|
||||
for( p1 = cLedMapping; p1->ledName != kLedEnd; p1++ )
|
||||
{
|
||||
if( (int) p1->ledName > MAX_VIRT_LEDS )
|
||||
continue;
|
||||
|
||||
alreadyUsed = 0;
|
||||
for( p2 = cLedMapping; p2 != p1; p2++ )
|
||||
{
|
||||
if( (p1->ledMask && p1->ledMask == p2->ledMask) ||
|
||||
(p1->ledMaskFail && p1->ledMaskFail == p2->ledMaskFail) )
|
||||
{
|
||||
alreadyUsed = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( alreadyUsed == 0 )
|
||||
{
|
||||
// Initialize the board LED for the first time.
|
||||
needTimer = initLedInfo( p1, pCurLed );
|
||||
gpVirtLeds[(int) p1->ledName] = pCurLed;
|
||||
pCurLed++;
|
||||
}
|
||||
else
|
||||
{
|
||||
PLED_INFO pLed;
|
||||
for( pLed = gLed; pLed != pCurLed; pLed++ )
|
||||
{
|
||||
// Find the LED_INFO structure that has already been initialized.
|
||||
if((pLed->ledMask && pLed->ledMask == p1->ledMask) ||
|
||||
(pLed->ledMaskFail && pLed->ledMaskFail==p1->ledMaskFail))
|
||||
{
|
||||
// The board LED has already been initialized but possibly
|
||||
// not completely initialized.
|
||||
if( p1->ledMask )
|
||||
{
|
||||
pLed->ledMask = p1->ledMask;
|
||||
pLed->ledActiveLow = p1->ledActiveLow;
|
||||
}
|
||||
if( p1->ledMaskFail )
|
||||
{
|
||||
pLed->ledMaskFail = p1->ledMaskFail;
|
||||
pLed->ledActiveLowFail = p1->ledActiveLowFail;
|
||||
}
|
||||
gpVirtLeds[(int) p1->ledName] = pLed;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (needTimer)
|
||||
ledTimerStart();
|
||||
|
||||
#if defined(DEBUG_LED)
|
||||
int i;
|
||||
for (i=0; i < gLedCount; i++)
|
||||
printk("initLed: led[%d]: mask=0x%04x, state=%d\n", i,(gLed+i)->ledMask, (gLed+i)->ledState);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
// Initialize a structure that contains information about a physical board LED
|
||||
// control. The board LED may contain more than one GPIO pin to control a
|
||||
// normal condition (green) or a failure condition (red).
|
||||
int initLedInfo( PLED_MAP_PAIR pCurMap, PLED_INFO pCurLed )
|
||||
{
|
||||
int needTimer = FALSE;
|
||||
pCurLed->ledState = pCurLed->savedLedState = pCurMap->ledInitState;
|
||||
pCurLed->ledMask = pCurMap->ledMask;
|
||||
pCurLed->ledActiveLow = pCurMap->ledActiveLow;
|
||||
pCurLed->ledMaskFail = pCurMap->ledMaskFail;
|
||||
pCurLed->ledActiveLowFail = pCurMap->ledActiveLowFail;
|
||||
|
||||
switch (pCurLed->ledState)
|
||||
{
|
||||
case kLedStateOn:
|
||||
pCurLed->blinkCountDown = 0; // reset the blink count down
|
||||
ledOn(pCurLed);
|
||||
break;
|
||||
case kLedStateOff:
|
||||
pCurLed->blinkCountDown = 0; // reset the blink count down
|
||||
ledOff(pCurLed);
|
||||
break;
|
||||
case kLedStateFail:
|
||||
pCurLed->blinkCountDown = 0; // reset the blink count down
|
||||
ledOnFail(pCurLed);
|
||||
break;
|
||||
case kLedStateBlinkOnce:
|
||||
pCurLed->blinkCountDown = 1;
|
||||
needTimer = TRUE;
|
||||
break;
|
||||
case kLedStateSlowBlinkContinues:
|
||||
pCurLed->blinkCountDown = kSlowBlinkCount;
|
||||
needTimer = TRUE;
|
||||
break;
|
||||
case kLedStateFastBlinkContinues:
|
||||
pCurLed->blinkCountDown = kFastBlinkCount;
|
||||
needTimer = TRUE;
|
||||
break;
|
||||
default:
|
||||
printk("Invalid state = %d\n", pCurLed->ledState);
|
||||
}
|
||||
|
||||
return( needTimer );
|
||||
}
|
||||
|
||||
#if 0 /* BROKEN */
|
||||
// Determines if there is at least one interface in bridge mode. Bridge mode
|
||||
// is determined by the cfm convention of naming bridge interfaces nas17
|
||||
// through nas24.
|
||||
static int isBridgedProtocol(void)
|
||||
{
|
||||
extern int dev_get(const char *name);
|
||||
const int firstBridgeId = 17;
|
||||
const int lastBridgeId = 24;
|
||||
int i;
|
||||
int ret = FALSE;
|
||||
char name[16];
|
||||
|
||||
for( i = firstBridgeId; i <= lastBridgeId; i++ )
|
||||
{
|
||||
sprintf( name, "nas%d", i );
|
||||
|
||||
if( dev_get(name) )
|
||||
{
|
||||
ret = TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return(ret);
|
||||
}
|
||||
#endif
|
||||
|
||||
// led ctrl. Maps the ledName to the corresponding ledInfoPtr and perform the led operation
|
||||
void boardLedCtrl(BOARD_LED_NAME ledName, BOARD_LED_STATE ledState)
|
||||
{
|
||||
PLED_INFO ledInfoPtr;
|
||||
|
||||
// do the mapping from virtual to physical led
|
||||
if( (int) ledName < MAX_VIRT_LEDS )
|
||||
ledInfoPtr = gpVirtLeds[(int) ledName];
|
||||
else
|
||||
ledInfoPtr = NULL;
|
||||
|
||||
if (ledInfoPtr == NULL)
|
||||
return;
|
||||
|
||||
if( ledState != kLedStateFail && gLedHwFunc[(int) ledName] )
|
||||
{
|
||||
(*gLedHwFunc[(int) ledName]) (ledName, ledState);
|
||||
ledOffFail(ledInfoPtr);
|
||||
return;
|
||||
}
|
||||
else
|
||||
if( ledState == kLedStateFail && gLedHwFailFunc[(int) ledName] )
|
||||
{
|
||||
(*gLedHwFailFunc[(int) ledName]) (ledName, ledState);
|
||||
ledOff(ledInfoPtr);
|
||||
return;
|
||||
}
|
||||
|
||||
#if 0 /* BROKEN */
|
||||
// Do not blink the WAN Data LED if at least one interface is in bridge mode.
|
||||
if(gLedOffInBridgeMode == 1 && (ledName == kLedWanData || ledName == kLedPPP))
|
||||
{
|
||||
static int BridgedProtocol = -1;
|
||||
|
||||
if( BridgedProtocol == -1 )
|
||||
BridgedProtocol = isBridgedProtocol();
|
||||
|
||||
if( BridgedProtocol == TRUE )
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
// If the state is kLedStateFail and there is not a failure LED defined
|
||||
// in the board parameters, change the state to kLedStateFastBlinkContinues.
|
||||
if( ledState == kLedStateFail && ledInfoPtr->ledMaskFail == 0 )
|
||||
ledState = kLedStateFastBlinkContinues;
|
||||
|
||||
switch (ledState)
|
||||
{
|
||||
case kLedStateOn:
|
||||
// First, turn off the complimentary (failure) LED GPIO.
|
||||
if( ledInfoPtr->ledMaskFail )
|
||||
ledOffFail(ledInfoPtr);
|
||||
else
|
||||
if( gLedHwFailFunc[(int) ledName] )
|
||||
(*gLedHwFailFunc[(int) ledName]) (ledName, kLedStateOff);
|
||||
|
||||
// Next, turn on the specified LED GPIO.
|
||||
ledOn(ledInfoPtr);
|
||||
break;
|
||||
|
||||
case kLedStateOff:
|
||||
// First, turn off the complimentary (failure) LED GPIO.
|
||||
if( ledInfoPtr->ledMaskFail )
|
||||
ledOffFail(ledInfoPtr);
|
||||
else
|
||||
if( gLedHwFailFunc[(int) ledName] )
|
||||
(*gLedHwFailFunc[(int) ledName]) (ledName, kLedStateOff);
|
||||
|
||||
// Next, turn off the specified LED GPIO.
|
||||
ledOff(ledInfoPtr);
|
||||
break;
|
||||
|
||||
case kLedStateFail:
|
||||
// First, turn off the complimentary (normal) LED GPIO.
|
||||
if( ledInfoPtr->ledMask )
|
||||
ledOff(ledInfoPtr);
|
||||
else
|
||||
if( gLedHwFunc[(int) ledName] )
|
||||
(*gLedHwFunc[(int) ledName]) (ledName, kLedStateOff);
|
||||
|
||||
// Next, turn on (red) the specified LED GPIO.
|
||||
ledOnFail(ledInfoPtr);
|
||||
break;
|
||||
|
||||
case kLedStateBlinkOnce:
|
||||
// skip blinkOnce if it is already in Slow/Fast blink continues state
|
||||
if (ledInfoPtr->savedLedState == kLedStateSlowBlinkContinues ||
|
||||
ledInfoPtr->savedLedState == kLedStateFastBlinkContinues)
|
||||
;
|
||||
else
|
||||
{
|
||||
if (ledInfoPtr->blinkCountDown == 0) // skip the call if it is 1
|
||||
{
|
||||
ledToggle(ledInfoPtr);
|
||||
ledInfoPtr->blinkCountDown = 1; // it will be reset to 0 when timer expires
|
||||
ledInfoPtr->ledState = kLedStateBlinkOnce;
|
||||
ledTimerStart();
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case kLedStateSlowBlinkContinues:
|
||||
ledInfoPtr->blinkCountDown = kSlowBlinkCount;
|
||||
ledInfoPtr->ledState = kLedStateSlowBlinkContinues;
|
||||
ledInfoPtr->savedLedState = kLedStateSlowBlinkContinues;
|
||||
ledTimerStart();
|
||||
break;
|
||||
|
||||
case kLedStateFastBlinkContinues:
|
||||
ledInfoPtr->blinkCountDown = kFastBlinkCount;
|
||||
ledInfoPtr->ledState = kLedStateFastBlinkContinues;
|
||||
ledInfoPtr->savedLedState = kLedStateFastBlinkContinues;
|
||||
ledTimerStart();
|
||||
break;
|
||||
|
||||
default:
|
||||
printk("Invalid led state\n");
|
||||
}
|
||||
}
|
||||
|
||||
// This function is called for an LED that is controlled by hardware.
|
||||
void kerSysLedRegisterHwHandler( BOARD_LED_NAME ledName,
|
||||
HANDLE_LED_FUNC ledHwFunc, int ledFailType )
|
||||
{
|
||||
if( (int) ledName < MAX_VIRT_LEDS )
|
||||
{
|
||||
if( ledFailType == 1 )
|
||||
gLedHwFailFunc[(int) ledName] = ledHwFunc;
|
||||
else
|
||||
gLedHwFunc[(int) ledName] = ledHwFunc;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user