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 = FIELD_VALUE(value, SYSTEM_CTRL, DPMS, state);
  16                 POKE32(SYSTEM_CTRL, value);
  17         }
  18 }
  19
  20 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         uint32_t gate;
 112
 113         gate = PEEK32(CURRENT_GATE);
 114         if (enable) {
 115                 gate = FIELD_SET(gate, CURRENT_GATE, DE,  ON);
 116                 gate = FIELD_SET(gate, CURRENT_GATE, CSC, ON);
 117         } else {
 118                 gate = FIELD_SET(gate, CURRENT_GATE, DE,  OFF);
 119                 gate = FIELD_SET(gate, CURRENT_GATE, CSC, OFF);
 120         }
 121
 122         setCurrentGate(gate);
 123 }
 124
 125
 126 /*
 127  * This function enable/disable the ZV Port.
 128  */
 129 void enableZVPort(unsigned int enable)
 130 {
 131         uint32_t gate;
 132
 133         /* Enable ZV Port Gate */
 134         gate = PEEK32(CURRENT_GATE);
 135         if (enable) {
 136                 gate = FIELD_SET(gate, CURRENT_GATE, ZVPORT, ON);
 137 #if 1
 138                 /* Using Software I2C */
 139                 gate = FIELD_SET(gate, CURRENT_GATE, GPIO, ON);
 140 #else
 141                 /* Using Hardware I2C */
 142                 gate = FIELD_SET(gate, CURRENT_GATE, I2C,    ON);
 143 #endif
 144         } else {
 145                 /* Disable ZV Port Gate. There is no way to know whether the
 146                 GPIO pins are being used or not. Therefore, do not disable the
 147                 GPIO gate. */
 148                 gate = FIELD_SET(gate, CURRENT_GATE, ZVPORT, OFF);
 149         }
 150
 151         setCurrentGate(gate);
 152 }
 153
 154
 155 void enableSSP(unsigned int enable)
 156 {
 157         uint32_t gate;
 158
 159         /* Enable SSP Gate */
 160         gate = PEEK32(CURRENT_GATE);
 161         if (enable)
 162                 gate = FIELD_SET(gate, CURRENT_GATE, SSP, ON);
 163         else
 164                 gate = FIELD_SET(gate, CURRENT_GATE, SSP, OFF);
 165
 166         setCurrentGate(gate);
 167 }
 168
 169 void enableDMA(unsigned int enable)
 170 {
 171         uint32_t gate;
 172
 173         /* Enable DMA Gate */
 174         gate = PEEK32(CURRENT_GATE);
 175         if (enable)
 176                 gate = FIELD_SET(gate, CURRENT_GATE, DMA, ON);
 177         else
 178                 gate = FIELD_SET(gate, CURRENT_GATE, DMA, OFF);
 179
 180         setCurrentGate(gate);
 181 }
 182
 183 /*
 184  * This function enable/disable the GPIO Engine
 185  */
 186 void enableGPIO(unsigned int enable)
 187 {
 188         uint32_t gate;
 189
 190         /* Enable GPIO Gate */
 191         gate = PEEK32(CURRENT_GATE);
 192         if (enable)
 193                 gate = FIELD_SET(gate, CURRENT_GATE, GPIO, ON);
 194         else
 195                 gate = FIELD_SET(gate, CURRENT_GATE, GPIO, OFF);
 196
 197         setCurrentGate(gate);
 198 }
 199
 200 /*
 201  * This function enable/disable the PWM Engine
 202  */
 203 void enablePWM(unsigned int enable)
 204 {
 205         uint32_t gate;
 206
 207         /* Enable PWM Gate */
 208         gate = PEEK32(CURRENT_GATE);
 209         if (enable)
 210                 gate = FIELD_SET(gate, CURRENT_GATE, PWM, ON);
 211         else
 212                 gate = FIELD_SET(gate, CURRENT_GATE, PWM, OFF);
 213
 214         setCurrentGate(gate);
 215 }
 216
 217 /*
 218  * This function enable/disable the I2C Engine
 219  */
 220 void enableI2C(unsigned int enable)
 221 {
 222         uint32_t gate;
 223
 224         /* Enable I2C Gate */
 225         gate = PEEK32(CURRENT_GATE);
 226         if (enable)
 227                 gate = FIELD_SET(gate, CURRENT_GATE, I2C, ON);
 228         else
 229         gate = FIELD_SET(gate, CURRENT_GATE, I2C, OFF);
 230
 231         setCurrentGate(gate);
 232 }
 233
 234