firmware/target/arm/s3c2440/gigabeat-fx/backlight-meg-fx.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Linus Nielsen Feltzing
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include "config.h"
  20 #include "cpu.h"
  21 #include "system.h"
  22 #include "backlight-target.h"
  23 #include "backlight.h"
  24 #include "lcd.h"
  25 #include "sc606-meg-fx.h"
  26 #include "power.h"
  27
  28 #define BUTTONLIGHT_MENU (SC606_LED_B1)
  29 #define BUTTONLIGHT_ALL  (SC606_LED_B1 | SC606_LED_B2 | SC606_LED_C1 | SC606_LED_C2)
  30
  31 static const int log_brightness[12] = {0,1,2,3,5,7,10,15,22,31,44,63};
  32
  33 #ifndef BOOTLOADER
  34 static void led_control_service(void);
  35
  36 static enum sc606_states
  37 {
  38     SC606_CONTROL_IDLE,
  39     SC606_CONTROL_A12,
  40     SC606_CONTROL_B12,
  41     SC606_CONTROL_C12,
  42     SC606_CONTROL_CONF
  43 } sc606_control;
  44 #endif /* BOOTLOADER */
  45
  46 static enum backlight_states
  47 {
  48     BACKLIGHT_CONTROL_IDLE,
  49     BACKLIGHT_CONTROL_OFF,
  50     BACKLIGHT_CONTROL_ON,
  51     BACKLIGHT_CONTROL_SET,
  52     BACKLIGHT_CONTROL_FADE
  53 } backlight_control;
  54
  55 enum buttonlight_states
  56 {
  57     BUTTONLIGHT_CONTROL_IDLE,
  58     BUTTONLIGHT_CONTROL_OFF,
  59     BUTTONLIGHT_CONTROL_ON,
  60     BUTTONLIGHT_CONTROL_SET,
  61     BUTTONLIGHT_CONTROL_FADE,
  62 } buttonlight_control;
  63
  64
  65 static unsigned char backlight_brightness;
  66 static unsigned char buttonlight_brightness;
  67 static unsigned char backlight_target;
  68 static unsigned char buttonlight_target;
  69
  70 static unsigned short buttonlight_trigger_now;
  71
  72 /* Assumes that the backlight has been initialized */
  73 void _backlight_set_brightness(int brightness)
  74 {
  75     /* clamp the brightness value */
  76     brightness = MAX(1, MIN(12, brightness));
  77     /* stop the interrupt from messing us up */
  78     backlight_control = BACKLIGHT_CONTROL_IDLE;
  79     backlight_brightness = log_brightness[brightness - 1];
  80     backlight_control = BACKLIGHT_CONTROL_SET;
  81 }
  82
  83 /* only works if the buttonlight mode is set to triggered mode */
  84 void __buttonlight_trigger(void)
  85 {
  86     buttonlight_trigger_now = 1;
  87 }
  88
  89 /* map the mode from the command into the state machine entries */
  90 void __buttonlight_mode(enum buttonlight_mode mode)
  91 {
  92     /* choose stop to setup mode */
  93     buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
  94
  95     /* which mode to use */
  96     switch (mode)
  97     {
  98         case BUTTONLIGHT_OFF:
  99         buttonlight_control = BUTTONLIGHT_CONTROL_OFF;
 100         break;
 101
 102         case BUTTONLIGHT_ON:
 103         buttonlight_control = BUTTONLIGHT_CONTROL_ON;
 104         break;
 105
 106         case BUTTONLIGHT_FOLLOW:
 107         buttonlight_control = BUTTONLIGHT_CONTROL_FADE;
 108         break;
 109
 110         default:
 111         return; /* unknown mode */
 112     }
 113 }
 114
 115 /* led_control_service runs in interrupt context - be brief!
 116  * This service is called once per interrupt timer tick - 100 times a second.
 117  *
 118  * There should be at most only one i2c operation per call - if more are need
 119  *  the calls should be spread across calls.
 120  *
 121  * Putting all led servicing in one thread means that we wont step on any
 122  * i2c operations - they are all serialized here in the ISR tick. It also
 123  * insures that we get called at equal timing for good visual effect.
 124  */
 125 #ifndef BOOTLOADER
 126 static void led_control_service(void)
 127 {
 128     static unsigned char
 129         sc606regAval=DEFAULT_BRIGHTNESS_SETTING,
 130         sc606regBval=0,
 131         sc606regCval=0,
 132         sc606regCONFval=0x03;
 133
 134     static bool sc606_changed=false, sc606_CONF_changed=false;
 135
 136     if(sc606_changed==false)
 137     {
 138         switch (backlight_control)
 139         {
 140             case BACKLIGHT_CONTROL_IDLE:
 141                 backlight_control = BACKLIGHT_CONTROL_IDLE;
 142                 break;
 143             case BACKLIGHT_CONTROL_OFF:
 144                 sc606_changed=true;
 145                 sc606_CONF_changed=true;
 146                 sc606regCONFval &= ~0x03;
 147                 sc606regAval=0;
 148                 backlight_control = BACKLIGHT_CONTROL_IDLE;
 149                 break;
 150             case BACKLIGHT_CONTROL_ON:
 151                 sc606_changed=true;
 152                 sc606_CONF_changed=true;
 153                 sc606regCONFval |= 0x03;
 154                 sc606regAval=backlight_brightness;
 155                 backlight_control = BACKLIGHT_CONTROL_IDLE;
 156                 break;
 157             case BACKLIGHT_CONTROL_SET:
 158                 if(!(sc606regCONFval&0x03))
 159                     break;
 160                 sc606_changed=true;
 161                 sc606regAval=backlight_brightness;
 162                 backlight_control = BACKLIGHT_CONTROL_IDLE;
 163                 break;
 164             case BACKLIGHT_CONTROL_FADE:
 165                 /* Was this mode set while the backlight is already on/off? */
 166                 if(backlight_target==sc606regAval)
 167                 {
 168                     backlight_control = BACKLIGHT_CONTROL_IDLE;
 169                     break;
 170                 }
 171                 sc606_changed=true;
 172                 if(!(sc606regCONFval&0x03))
 173                 {
 174                     sc606_CONF_changed=true;
 175                     sc606regCONFval |= 0x03;
 176                 }
 177                 if(backlight_target>sc606regAval)
 178                 {
 179                     sc606regAval++;
 180                     if(backlight_target==sc606regAval)
 181                         backlight_control = BACKLIGHT_CONTROL_IDLE;
 182                 }
 183                 else
 184                 {
 185                     sc606regAval--;
 186                     if(sc606regAval==0)
 187                         backlight_control = BACKLIGHT_CONTROL_OFF;
 188                     else if (backlight_target==sc606regAval)
 189                         backlight_control = BACKLIGHT_CONTROL_IDLE;
 190                 }
 191
 192                 break;
 193             default:
 194                 backlight_control = BACKLIGHT_CONTROL_IDLE;
 195                 break;
 196         }
 197         switch (buttonlight_control)
 198         {
 199             case BUTTONLIGHT_CONTROL_IDLE:
 200                 buttonlight_control=BUTTONLIGHT_CONTROL_IDLE;
 201                 break;
 202             case BUTTONLIGHT_CONTROL_OFF:
 203                 sc606_changed=true;
 204                 sc606_CONF_changed=true;
 205                 sc606regCONFval &= ~BUTTONLIGHT_ALL;
 206                 sc606regBval=sc606regCval=0;
 207                 buttonlight_control=BUTTONLIGHT_CONTROL_IDLE;
 208                 break;
 209             case BUTTONLIGHT_CONTROL_ON:
 210                 sc606_changed=true;
 211                 sc606_CONF_changed=true;
 212                 sc606regCONFval |= BUTTONLIGHT_ALL;
 213                 sc606regBval=sc606regCval=buttonlight_brightness;
 214                 buttonlight_control=BUTTONLIGHT_CONTROL_IDLE;
 215                 break;
 216             case BUTTONLIGHT_CONTROL_SET:
 217                 if(!(sc606regCONFval&BUTTONLIGHT_ALL))
 218                     break;
 219                 sc606_changed=true;
 220                 sc606regBval=sc606regCval=buttonlight_brightness;
 221                 buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 222                 break;
 223             case BUTTONLIGHT_CONTROL_FADE:
 224                 /* Was this mode set while the button light is already on? */
 225                 if(buttonlight_target==sc606regBval)
 226                 {
 227                     buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 228                     break;
 229                 }
 230                 sc606_changed=true;
 231                 if(!(sc606regCONFval&BUTTONLIGHT_ALL))
 232                 {
 233                     sc606_CONF_changed=true;
 234                     sc606regCONFval |= BUTTONLIGHT_ALL;
 235                 }
 236                 if(buttonlight_target>sc606regBval)
 237                 {
 238                     sc606regCval=++sc606regBval;
 239                     if(buttonlight_target==sc606regBval)
 240                         buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 241                 }
 242                 else
 243                 {
 244                     sc606regCval=--sc606regBval;
 245                     if(sc606regBval==0)
 246                         buttonlight_control = BUTTONLIGHT_CONTROL_OFF;
 247                     else if (buttonlight_target==sc606regBval)
 248                         backlight_control = BACKLIGHT_CONTROL_IDLE;
 249                 }
 250
 251                 break;
 252             default:
 253                 buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 254                 break;
 255         }
 256     }
 257
 258     switch (sc606_control)
 259     {
 260         case SC606_CONTROL_IDLE:
 261             if(sc606_changed)
 262                 sc606_control=SC606_CONTROL_A12;
 263             else
 264                 sc606_control=SC606_CONTROL_IDLE;
 265             break;
 266
 267         case SC606_CONTROL_A12:
 268             sc606_write(SC606_REG_A , sc606regAval);
 269             sc606_control=SC606_CONTROL_B12;
 270             break;
 271
 272         case SC606_CONTROL_B12:
 273             sc606_write(SC606_REG_B , sc606regBval);
 274             sc606_control=SC606_CONTROL_C12;
 275             break;
 276
 277         case SC606_CONTROL_C12:
 278             sc606_write(SC606_REG_C , sc606regCval);
 279             if(sc606_CONF_changed!=true)
 280             {
 281                 sc606_changed=false;
 282                 if(backlight_control != BACKLIGHT_CONTROL_IDLE ||
 283                     buttonlight_control != BUTTONLIGHT_CONTROL_IDLE)
 284                 {
 285                     sc606_control=SC606_CONTROL_A12;
 286                 }
 287                 else
 288                 {
 289                     sc606_control=SC606_CONTROL_IDLE;
 290                 }
 291             }
 292             else
 293             {
 294                 sc606_control=SC606_CONTROL_CONF;
 295             }
 296             break;
 297
 298         case SC606_CONTROL_CONF:
 299             sc606_write(SC606_REG_CONF , sc606regCONFval);
 300             sc606_changed=false;
 301             sc606_CONF_changed=false;
 302             if(backlight_control != BACKLIGHT_CONTROL_IDLE ||
 303                 buttonlight_control != BUTTONLIGHT_CONTROL_IDLE)
 304             {
 305                 sc606_control=SC606_CONTROL_A12;
 306             }
 307             else
 308             {
 309                 sc606_control=SC606_CONTROL_IDLE;
 310             }
 311             break;
 312
 313         default:
 314             sc606_control=SC606_CONTROL_IDLE;
 315             break;
 316     }
 317
 318     if(sc606regCONFval&0x03)
 319         lcd_enable(true);
 320     else
 321         lcd_enable(false);
 322 }
 323 #endif /* BOOTLOADER */
 324
 325 static void __backlight_dim(bool dim_now)
 326 {
 327     /* dont let the interrupt tick happen */
 328     backlight_control = BACKLIGHT_CONTROL_IDLE;
 329     backlight_target = (dim_now == true) ? 0 : backlight_brightness;
 330     if(backlight_target==0 && backlight_brightness==0)
 331     {
 332         if(dim_now == false)
 333             backlight_control = BACKLIGHT_CONTROL_ON;
 334         else
 335             backlight_control = BACKLIGHT_CONTROL_OFF;
 336     }
 337     else
 338         backlight_control = BACKLIGHT_CONTROL_FADE;
 339 }
 340
 341 void _backlight_on(void)
 342 {
 343     lcd_enable(true);
 344     __backlight_dim(false);
 345 }
 346
 347 void _backlight_off(void)
 348 {
 349     __backlight_dim(true);
 350 }
 351
 352 static inline void __buttonlight_on(void)
 353 {
 354     buttonlight_control = BUTTONLIGHT_CONTROL_ON;
 355 }
 356
 357 static inline void __buttonlight_off(void)
 358 {
 359     buttonlight_control = BUTTONLIGHT_CONTROL_OFF;
 360 }
 361
 362 static void __buttonlight_dim(bool dim_now)
 363 {
 364     buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 365     buttonlight_target = (dim_now == true) ? 0 : buttonlight_brightness;
 366     if(buttonlight_target==0 && buttonlight_brightness==0)
 367     {
 368         if(dim_now == false)
 369             buttonlight_control = BUTTONLIGHT_CONTROL_ON;
 370         else
 371             buttonlight_control = BUTTONLIGHT_CONTROL_OFF;
 372     }
 373     else
 374         buttonlight_control = BUTTONLIGHT_CONTROL_FADE;
 375 }
 376
 377 void _buttonlight_on(void)
 378 {
 379     __buttonlight_dim(false);
 380 }
 381
 382 void _buttonlight_off(void)
 383 {
 384 #ifndef BOOTLOADER
 385     if(_buttonlight_timeout>0)
 386         __buttonlight_dim(true);
 387     else
 388 #endif
 389         __buttonlight_off();
 390 }
 391
 392 void _buttonlight_set_brightness(int brightness)
 393 {
 394     /* clamp the brightness value */
 395     brightness = MAX(1, MIN(12, brightness));
 396     /* stop the interrupt from messing us up */
 397     buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 398     buttonlight_brightness = log_brightness[brightness - 1];
 399     buttonlight_control = BUTTONLIGHT_CONTROL_SET;
 400 }
 401
 402 bool _backlight_init(void)
 403 {
 404     buttonlight_brightness = DEFAULT_BRIGHTNESS_SETTING;
 405     backlight_brightness = DEFAULT_BRIGHTNESS_SETTING;
 406
 407     buttonlight_control = BUTTONLIGHT_CONTROL_IDLE;
 408     backlight_control = BACKLIGHT_CONTROL_ON;
 409
 410     /* Set the backlight up in a known state */
 411     sc606_init();
 412     sc606_write(SC606_REG_A , DEFAULT_BRIGHTNESS_SETTING);
 413     sc606_write(SC606_REG_B , 0);
 414     sc606_write(SC606_REG_C , 0);
 415     sc606_write(SC606_REG_CONF , 0x03);
 416 #ifndef BOOTLOADER
 417     /* put the led control on the tick list */
 418     tick_add_task(led_control_service);
 419 #endif
 420     return true;
 421 }