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 PEEK32(POWER_MODE_CTRL) & POWER_MODE_CTRL_MODE_MASK;
  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) & ~POWER_MODE_CTRL_MODE_MASK;
  37
  38         if (getChipType() == SM750LE)
  39                 return;
  40
  41         switch (powerMode) {
  42         case POWER_MODE_CTRL_MODE_MODE0:
  43                 control_value |= POWER_MODE_CTRL_MODE_MODE0;
  44                 break;
  45
  46         case POWER_MODE_CTRL_MODE_MODE1:
  47                 control_value |= POWER_MODE_CTRL_MODE_MODE1;
  48                 break;
  49
  50         case POWER_MODE_CTRL_MODE_SLEEP:
  51                 control_value |= POWER_MODE_CTRL_MODE_SLEEP;
  52                 break;
  53
  54         default:
  55                 break;
  56         }
  57
  58         /* Set up other fields in Power Control Register */
  59         if (powerMode == POWER_MODE_CTRL_MODE_SLEEP) {
  60                 control_value &= ~POWER_MODE_CTRL_OSC_INPUT;
  61 #ifdef VALIDATION_CHIP
  62                 control_value &= ~POWER_MODE_CTRL_336CLK;
  63 #endif
  64         } else {
  65                 control_value |= POWER_MODE_CTRL_OSC_INPUT;
  66 #ifdef VALIDATION_CHIP
  67                 control_value |= POWER_MODE_CTRL_336CLK;
  68 #endif
  69         }
  70
  71         /* Program new power mode. */
  72         POKE32(POWER_MODE_CTRL, control_value);
  73 }
  74
  75 void setCurrentGate(unsigned int gate)
  76 {
  77         unsigned int gate_reg;
  78         unsigned int mode;
  79
  80         /* Get current power mode. */
  81         mode = getPowerMode();
  82
  83         switch (mode) {
  84         case POWER_MODE_CTRL_MODE_MODE0:
  85                 gate_reg = MODE0_GATE;
  86                 break;
  87
  88         case POWER_MODE_CTRL_MODE_MODE1:
  89                 gate_reg = MODE1_GATE;
  90                 break;
  91
  92         default:
  93                 gate_reg = MODE0_GATE;
  94                 break;
  95         }
  96         POKE32(gate_reg, gate);
  97 }
  98
  99
 100
 101 /*
 102  * This function enable/disable the 2D engine.
 103  */
 104 void enable2DEngine(unsigned int enable)
 105 {
 106         u32 gate;
 107
 108         gate = PEEK32(CURRENT_GATE);
 109         if (enable) {
 110                 gate |= (CURRENT_GATE_DE | CURRENT_GATE_CSC);
 111         } else {
 112                 gate &= ~(CURRENT_GATE_DE | CURRENT_GATE_CSC);
 113         }
 114
 115         setCurrentGate(gate);
 116 }
 117
 118 void enableDMA(unsigned int enable)
 119 {
 120         u32 gate;
 121
 122         /* Enable DMA Gate */
 123         gate = PEEK32(CURRENT_GATE);
 124         if (enable)
 125                 gate |= CURRENT_GATE_DMA;
 126         else
 127                 gate &= ~CURRENT_GATE_DMA;
 128
 129         setCurrentGate(gate);
 130 }
 131
 132 /*
 133  * This function enable/disable the GPIO Engine
 134  */
 135 void enableGPIO(unsigned int enable)
 136 {
 137         u32 gate;
 138
 139         /* Enable GPIO Gate */
 140         gate = PEEK32(CURRENT_GATE);
 141         if (enable)
 142                 gate |= CURRENT_GATE_GPIO;
 143         else
 144                 gate &= ~CURRENT_GATE_GPIO;
 145
 146         setCurrentGate(gate);
 147 }
 148
 149 /*
 150  * This function enable/disable the I2C Engine
 151  */
 152 void enableI2C(unsigned int enable)
 153 {
 154         u32 gate;
 155
 156         /* Enable I2C Gate */
 157         gate = PEEK32(CURRENT_GATE);
 158         if (enable)
 159                 gate |= CURRENT_GATE_I2C;
 160         else
 161                 gate &= ~CURRENT_GATE_I2C;
 162
 163         setCurrentGate(gate);
 164 }
 165
 166