drivers/staging/sm750fb/ddk750_power.c

   1 #include "ddk750_help.h"
   2 #include "ddk750_reg.h"
   3 #include "ddk750_power.h"
   4
   5 void ddk750_setDPMS(DPMS_t state)
   6 {
   7         unsigned int value;
   8
   9         if (getChipType() == SM750LE) {
  10                 value = PEEK32(CRT_DISPLAY_CTRL);
  11                 POKE32(CRT_DISPLAY_CTRL, FIELD_VALUE(value, CRT_DISPLAY_CTRL,
  12                                                      DPMS, state));
  13         } else {
  14                 value = PEEK32(SYSTEM_CTRL);
  15                 value = (value & ~SYSTEM_CTRL_DPMS_MASK) | state;
  16                 POKE32(SYSTEM_CTRL, value);
  17         }
  18 }
  19
  20 static unsigned int getPowerMode(void)
  21 {
  22         if (getChipType() == SM750LE)
  23                 return 0;
  24         return FIELD_GET(PEEK32(POWER_MODE_CTRL), POWER_MODE_CTRL, MODE);
  25 }
  26
  27
  28 /*
  29  * SM50x can operate in one of three modes: 0, 1 or Sleep.
  30  * On hardware reset, power mode 0 is default.
  31  */
  32 void setPowerMode(unsigned int powerMode)
  33 {
  34         unsigned int control_value = 0;
  35
  36         control_value = PEEK32(POWER_MODE_CTRL);
  37
  38         if (getChipType() == SM750LE)
  39                 return;
  40
  41         switch (powerMode) {
  42         case POWER_MODE_CTRL_MODE_MODE0:
  43                 control_value = FIELD_SET(control_value, POWER_MODE_CTRL, MODE,
  44                                           MODE0);
  45                 break;
  46
  47         case POWER_MODE_CTRL_MODE_MODE1:
  48                 control_value = FIELD_SET(control_value, POWER_MODE_CTRL, MODE,
  49                                           MODE1);
  50                 break;
  51
  52         case POWER_MODE_CTRL_MODE_SLEEP:
  53                 control_value = FIELD_SET(control_value, POWER_MODE_CTRL, MODE,
  54                                           SLEEP);
  55                 break;
  56
  57         default:
  58                 break;
  59         }
  60
  61         /* Set up other fields in Power Control Register */
  62         if (powerMode == POWER_MODE_CTRL_MODE_SLEEP) {
  63                 control_value =
  64 #ifdef VALIDATION_CHIP
  65                 FIELD_SET(control_value, POWER_MODE_CTRL, 336CLK, OFF) |
  66 #endif
  67                 FIELD_SET(control_value, POWER_MODE_CTRL, OSC_INPUT,  OFF);
  68         } else {
  69                 control_value =
  70 #ifdef VALIDATION_CHIP
  71                 FIELD_SET(control_value, POWER_MODE_CTRL, 336CLK, ON) |
  72 #endif
  73                 FIELD_SET(control_value, POWER_MODE_CTRL, OSC_INPUT,  ON);
  74         }
  75
  76         /* Program new power mode. */
  77         POKE32(POWER_MODE_CTRL, control_value);
  78 }
  79
  80 void setCurrentGate(unsigned int gate)
  81 {
  82         unsigned int gate_reg;
  83         unsigned int mode;
  84
  85         /* Get current power mode. */
  86         mode = getPowerMode();
  87
  88         switch (mode) {
  89         case POWER_MODE_CTRL_MODE_MODE0:
  90                 gate_reg = MODE0_GATE;
  91                 break;
  92
  93         case POWER_MODE_CTRL_MODE_MODE1:
  94                 gate_reg = MODE1_GATE;
  95                 break;
  96
  97         default:
  98                 gate_reg = MODE0_GATE;
  99                 break;
 100         }
 101         POKE32(gate_reg, gate);
 102 }
 103
 104
 105
 106 /*
 107  * This function enable/disable the 2D engine.
 108  */
 109 void enable2DEngine(unsigned int enable)
 110 {
 111         u32 gate;
 112
 113         gate = PEEK32(CURRENT_GATE);
 114         if (enable) {
 115                 gate |= (CURRENT_GATE_DE | CURRENT_GATE_CSC);
 116         } else {
 117                 gate &= ~(CURRENT_GATE_DE | CURRENT_GATE_CSC);
 118         }
 119
 120         setCurrentGate(gate);
 121 }
 122
 123 void enableDMA(unsigned int enable)
 124 {
 125         u32 gate;
 126
 127         /* Enable DMA Gate */
 128         gate = PEEK32(CURRENT_GATE);
 129         if (enable)
 130                 gate |= CURRENT_GATE_DMA;
 131         else
 132                 gate &= ~CURRENT_GATE_DMA;
 133
 134         setCurrentGate(gate);
 135 }
 136
 137 /*
 138  * This function enable/disable the GPIO Engine
 139  */
 140 void enableGPIO(unsigned int enable)
 141 {
 142         u32 gate;
 143
 144         /* Enable GPIO Gate */
 145         gate = PEEK32(CURRENT_GATE);
 146         if (enable)
 147                 gate |= CURRENT_GATE_GPIO;
 148         else
 149                 gate &= ~CURRENT_GATE_GPIO;
 150
 151         setCurrentGate(gate);
 152 }
 153
 154 /*
 155  * This function enable/disable the I2C Engine
 156  */
 157 void enableI2C(unsigned int enable)
 158 {
 159         u32 gate;
 160
 161         /* Enable I2C Gate */
 162         gate = PEEK32(CURRENT_GATE);
 163         if (enable)
 164                 gate |= CURRENT_GATE_I2C;
 165         else
 166                 gate &= ~CURRENT_GATE_I2C;
 167
 168         setCurrentGate(gate);
 169 }
 170
 171