kernel/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 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 = 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 void enableDMA(unsigned int enable)
 126 {
 127         u32 gate;
 128
 129         /* Enable DMA Gate */
 130         gate = PEEK32(CURRENT_GATE);
 131         if (enable)
 132                 gate = FIELD_SET(gate, CURRENT_GATE, DMA, ON);
 133         else
 134                 gate = FIELD_SET(gate, CURRENT_GATE, DMA, OFF);
 135
 136         setCurrentGate(gate);
 137 }
 138
 139 /*
 140  * This function enable/disable the GPIO Engine
 141  */
 142 void enableGPIO(unsigned int enable)
 143 {
 144         u32 gate;
 145
 146         /* Enable GPIO Gate */
 147         gate = PEEK32(CURRENT_GATE);
 148         if (enable)
 149                 gate = FIELD_SET(gate, CURRENT_GATE, GPIO, ON);
 150         else
 151                 gate = FIELD_SET(gate, CURRENT_GATE, GPIO, OFF);
 152
 153         setCurrentGate(gate);
 154 }
 155
 156 /*
 157  * This function enable/disable the I2C Engine
 158  */
 159 void enableI2C(unsigned int enable)
 160 {
 161         u32 gate;
 162
 163         /* Enable I2C Gate */
 164         gate = PEEK32(CURRENT_GATE);
 165         if (enable)
 166                 gate = FIELD_SET(gate, CURRENT_GATE, I2C, ON);
 167         else
 168         gate = FIELD_SET(gate, CURRENT_GATE, I2C, OFF);
 169
 170         setCurrentGate(gate);
 171 }
 172
 173