码迷,mamicode.com
首页 > 其他好文 > 详细

电源管理之pmu驱动分析

时间:2014-10-29 14:33:18      阅读:309      评论:0      收藏:0      [点我收藏+]

标签:des   io   os   ar   使用   for   sp   文件   数据   

电源管理芯片可以为多设备供电,且这些设备电压电流有所不同。为这些设备提供的稳压器代码模型即为regulator。

说白了regulator就是稳压器,它提供电源供给.简单的可以gpio操作,高电平开电,低电平关电.一般的还包括电流值,

电压值等.

一般regulator有两种不同的电源,即:ldo和sd.

Ldo适合电压要求比较稳,但是功率不是很大的设备.

Sd适合功率要求比较大,但可以接受较小的纹波的设备.

除此之外pmu还可能集成,charger,battery, 音频功放等等.

 

首先我们分析pmu驱动的平台设备注册部分.

我以max77663这款pmu芯片为分析对象, cpu用的是nvidia的tegra3.

Pmu的板级初始化文件:kernel\arch\arm\mach-tegra\board-kai-power.c

主要代码如下:

#define PMC_CTRL             0x0

#define PMC_CTRL_INTR_LOW         (1 << 17)

#define REBOOT_FLAG"rebooting"

#define DEVICE_PATH  "/dev/block/platform/sdhci-tegra.3/by-name/UDE"

static structregulator_consumer_supply max77663_sd0_supply[] = {

  REGULATOR_SUPPLY("vdd_cpu",NULL),

};

 

static structregulator_consumer_supply max77663_sd1_supply[] = {

  REGULATOR_SUPPLY("vdd_core",NULL),

};

 

static struct regulator_consumer_supplymax77663_sd2_supply[] = {

  REGULATOR_SUPPLY("vdd_gen1v8",NULL),

  REGULATOR_SUPPLY("avdd_hdmi_pll",NULL),

  REGULATOR_SUPPLY("avdd_usb_pll",NULL),

  REGULATOR_SUPPLY("avdd_osc",NULL),

  REGULATOR_SUPPLY("vddio_sys",NULL),

  REGULATOR_SUPPLY("vddio_sdmmc","sdhci-tegra.3"),

  REGULATOR_SUPPLY("pwrdet_sdmmc4",NULL),

  REGULATOR_SUPPLY("vddio_uart",NULL),

  REGULATOR_SUPPLY("pwrdet_uart",NULL),

  REGULATOR_SUPPLY("vddio_bb",NULL),

  REGULATOR_SUPPLY("pwrdet_bb",NULL),

  REGULATOR_SUPPLY("vddio_lcd_pmu",NULL),

  REGULATOR_SUPPLY("pwrdet_lcd",NULL),

  REGULATOR_SUPPLY("vddio_audio",NULL),

  REGULATOR_SUPPLY("pwrdet_audio",NULL),

  REGULATOR_SUPPLY("vddio_cam",NULL),

  REGULATOR_SUPPLY("pwrdet_cam",NULL),

  REGULATOR_SUPPLY("vddio_sdmmc","sdhci-tegra.2"),

  REGULATOR_SUPPLY("pwrdet_sdmmc3",NULL),

  REGULATOR_SUPPLY("vddio_vi",NULL),

  REGULATOR_SUPPLY("pwrdet_vi",NULL),

  REGULATOR_SUPPLY("vcore_nand",NULL),

  REGULATOR_SUPPLY("pwrdet_nand",NULL),

};

 

static structregulator_consumer_supply max77663_sd3_supply[] = {

  REGULATOR_SUPPLY("vdd_ddr3l_1v35",NULL),

};

 

static structregulator_consumer_supply max77663_ldo0_supply[] = {

  REGULATOR_SUPPLY("vdd_ddr_hs",NULL),

};

 

static structregulator_consumer_supply max77663_ldo1_supply[] = {

};

 

static structregulator_consumer_supply max77663_ldo2_supply[] = {

  REGULATOR_SUPPLY("vdd_ddr_rx",NULL),

};

 

static structregulator_consumer_supply max77663_ldo3_supply[] = {

  REGULATOR_SUPPLY("vmmc",NULL),

};

 

static structregulator_consumer_supply max77663_ldo4_supply[] = {

  REGULATOR_SUPPLY("vdd_rtc",NULL),

};

 

static structregulator_consumer_supply max77663_ldo5_supply[] = {

  REGULATOR_SUPPLY("vdd_sensor_2v8",NULL),

};

 

static structregulator_consumer_supply max77663_ldo6_supply[] = {

  REGULATOR_SUPPLY("vddio_sdmmc","sdhci-tegra.0"),

  REGULATOR_SUPPLY("pwrdet_sdmmc1",NULL),

};

 

static structregulator_consumer_supply max77663_ldo7_supply[] = {

  REGULATOR_SUPPLY("avdd_dsi_csi",NULL),

  REGULATOR_SUPPLY("pwrdet_mipi",NULL),

};

 

static struct regulator_consumer_supplymax77663_ldo8_supply[] = {

  REGULATOR_SUPPLY("avdd_plla_p_c_s",NULL),

  REGULATOR_SUPPLY("avdd_pllm",NULL),

  REGULATOR_SUPPLY("avdd_pllu_d",NULL),

  REGULATOR_SUPPLY("avdd_pllu_d2",NULL),

  REGULATOR_SUPPLY("avdd_pllx",NULL),

};

 

static structmax77663_regulator_fps_cfg max77663_fps_cfgs[] = {

  {

            .src= FPS_SRC_0,

            .en_src= FPS_EN_SRC_EN0,

            .time_period= FPS_TIME_PERIOD_DEF,

  },

  {

            .src= FPS_SRC_1,

            .en_src= FPS_EN_SRC_EN1,

            .time_period= FPS_TIME_PERIOD_DEF,

  },

  {

            .src= FPS_SRC_2,

            .en_src= FPS_EN_SRC_EN0,

            .time_period= FPS_TIME_PERIOD_DEF,

  },

};

 

#define MAX77663_PDATA_INIT(_id,_min_uV, _max_uV, _supply_reg,                   \

                         _always_on, _boot_on, _apply_uV,                  \

                         _init_apply, _init_enable, _init_uV,          \

                         _fps_src, _fps_pu_period, _fps_pd_period,_flags) \

  staticstruct max77663_regulator_platform_data max77663_regulator_pdata_##_id = \

  {                                                                         \

            .init_data= {                                                   \

                     .constraints= {                                     \

                              .min_uV= _min_uV,                            \

                              .max_uV= _max_uV,                          \

                              .valid_modes_mask= (REGULATOR_MODE_NORMAL |  \

                                                      REGULATOR_MODE_STANDBY), \

                              .valid_ops_mask= (REGULATOR_CHANGE_MODE |    \

                                                    REGULATOR_CHANGE_STATUS |  \

                                                    REGULATOR_CHANGE_VOLTAGE), \

                              .always_on= _always_on,                \

                              .boot_on= _boot_on,                         \

                              .apply_uV= _apply_uV,                      \

                     },                                                     \

                     .num_consumer_supplies=                       \

                              ARRAY_SIZE(max77663_##_id##_supply),      \

                     .consumer_supplies= max77663_##_id##_supply,        \

                     .supply_regulator= _supply_reg,             \

            },                                                               \

            .init_apply= _init_apply,                             \

            .init_enable= _init_enable,                                 \

            .init_uV= _init_uV,                                       \

            .fps_src= _fps_src,                                      \

            .fps_pu_period= _fps_pu_period,                     \

            .fps_pd_period= _fps_pd_period,                     \

            .fps_cfgs= max77663_fps_cfgs,                                 \

            .flags= _flags,                                      \

  }

 

MAX77663_PDATA_INIT(sd0,  600000, 3387500, NULL, 1, 0, 0,0, 0, -1,FPS_SRC_NONE, -1, -1, EN2_CTRL_SD0);

 

MAX77663_PDATA_INIT(sd1,  800000, 1587500, NULL, 1, 0, 0,1, 1, -1,FPS_SRC_1, FPS_POWER_PERIOD_1, FPS_POWER_PERIOD_6, 0);

 

MAX77663_PDATA_INIT(sd2,  1800000, 1800000, NULL, 1, 0, 0,1, 1, -1,FPS_SRC_0, -1, -1, 0);

 

MAX77663_PDATA_INIT(sd3,  600000, 3387500, NULL, 1, 0, 0,1, 1, -1,FPS_SRC_0, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo0, 800000,2350000, max77663_rails(sd3), 1, 0, 0,1, 1, -1, FPS_SRC_1, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo1, 800000,2350000, max77663_rails(sd3), 0, 0, 0,0, 0, -1, FPS_SRC_NONE, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo2, 800000,3950000, NULL, 1, 0, 0,1, 1, -1, FPS_SRC_1, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo3, 800000,3950000, NULL, 1, 0, 0,1, 1, -1, FPS_SRC_1, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo4, 800000,1587500, NULL, 0, 0, 0,1, 1, 1000000, FPS_SRC_0, -1, -1, LDO4_EN_TRACKING);

 

MAX77663_PDATA_INIT(ldo5, 800000,2800000, NULL, 0, 0, 0,1, 1, -1, FPS_SRC_NONE, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo6, 800000,3950000, NULL, 0, 0, 0,0, 0, -1, FPS_SRC_NONE, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo7, 800000,3950000, max77663_rails(sd3), 0, 0, 0,0, 0, -1, FPS_SRC_NONE, -1, -1, 0);

 

MAX77663_PDATA_INIT(ldo8, 800000,3950000, max77663_rails(sd3), 0, 0, 0,1, 1, -1, FPS_SRC_1, -1, -1, 0);

 

#define MAX77663_REG(_id, _data)                                               \

  {                                                                         \

            .name= "max77663-regulator",                                 \

            .id= MAX77663_REGULATOR_ID_##_id,                           \

            .platform_data= &max77663_regulator_pdata_##_data,   \

            .pdata_size= sizeof(max77663_regulator_pdata_##_data),         \

  }

 

#define MAX77663_RTC()                                                         \

  {                                                                         \

            .name= "max77663-rtc",                                             \

            .id= 0,                                                     \

  }

 

static struct mfd_cellmax77663_subdevs[] = {

  MAX77663_REG(SD0,sd0),

  MAX77663_REG(SD1,sd1),

  MAX77663_REG(SD2,sd2),

  MAX77663_REG(SD3,sd3),

  MAX77663_REG(LDO0,ldo0),

  MAX77663_REG(LDO1,ldo1),

  MAX77663_REG(LDO2,ldo2),

  MAX77663_REG(LDO3,ldo3),

  MAX77663_REG(LDO4,ldo4),

  MAX77663_REG(LDO5,ldo5),

  MAX77663_REG(LDO6,ldo6),

  MAX77663_REG(LDO7,ldo7),

  MAX77663_REG(LDO8,ldo8),

  MAX77663_RTC(),

};

 

static structmax77663_gpio_config max77663_gpio_cfgs[] = {

  {

            .gpio= MAX77663_GPIO0,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_LOW,

            .out_drv= GPIO_OUT_DRV_PUSH_PULL,

            .alternate= GPIO_ALT_DISABLE,

  },

  {

            .gpio= MAX77663_GPIO1,

            .dir= GPIO_DIR_IN,

            .dout= GPIO_DOUT_LOW,

            .out_drv= GPIO_OUT_DRV_PUSH_PULL,

            .alternate= GPIO_ALT_DISABLE,

  },

  {

            .gpio= MAX77663_GPIO2,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_HIGH,

            .out_drv= GPIO_OUT_DRV_OPEN_DRAIN,

            .alternate= GPIO_ALT_DISABLE,

  },

  {

            .gpio= MAX77663_GPIO3,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_LOW,

            .out_drv= GPIO_OUT_DRV_OPEN_DRAIN,

            .alternate= GPIO_ALT_ENABLE,

  },

  {

            .gpio= MAX77663_GPIO4,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_HIGH,

            .out_drv= GPIO_OUT_DRV_PUSH_PULL,

            .alternate= GPIO_ALT_ENABLE,

  },

  {

            .gpio= MAX77663_GPIO5,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_LOW,

            .out_drv= GPIO_OUT_DRV_PUSH_PULL,

            .alternate= GPIO_ALT_DISABLE,

  },

  {

            .gpio= MAX77663_GPIO6,

            .dir= GPIO_DIR_IN,

            .alternate= GPIO_ALT_DISABLE,

  },

  {

            .gpio= MAX77663_GPIO7,

            .dir= GPIO_DIR_OUT,

            .dout= GPIO_DOUT_LOW,

            .out_drv= GPIO_OUT_DRV_OPEN_DRAIN,

            .alternate= GPIO_ALT_DISABLE,

  },

};

 

static structmax77663_platform_data max7763_pdata = {

  .irq_base = MAX77663_IRQ_BASE,

  .gpio_base       = MAX77663_GPIO_BASE,

  .flags=SLP_MONITORS_ENABLE|SLP_LPM_ENABLE,

  .num_gpio_cfgs       = ARRAY_SIZE(max77663_gpio_cfgs),

  .gpio_cfgs         = max77663_gpio_cfgs,

 

  .num_subdevs = ARRAY_SIZE(max77663_subdevs),

  .sub_devices    = max77663_subdevs,

 

  .rtc_i2c_addr   = 0x68,

 

  .use_power_off        = true,

};

 

static struct i2c_board_info__initdata max77663_regulators[] = {

  {

            /*The I2C address was determined by OTP factory setting */

            I2C_BOARD_INFO("max77663",0x3c),

            .irq            = INT_EXTERNAL_PMU,

            .platform_data         = &max7763_pdata,

  },

};

 

static int __initkai_max77663_regulator_init(void)

{

  void__iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);

  u32pmc_ctrl;

 

  /*configure the power management controller to trigger PMU

   * interrupts when low */

  pmc_ctrl= readl(pmc + PMC_CTRL);

  writel(pmc_ctrl| PMC_CTRL_INTR_LOW, pmc + PMC_CTRL);

 

  i2c_register_board_info(4,max77663_regulators,

                              ARRAY_SIZE(max77663_regulators));

 

  return0;

}

 

static structregulator_consumer_supply fixed_reg_en_1v8_cam_supply[] = {      

  REGULATOR_SUPPLY("vdd_1v8_cam1",NULL),

};

 

static structregulator_consumer_supply fixed_reg_en_cam1_ldo_supply[] = {     

  REGULATOR_SUPPLY("vdd_cam1",NULL),

};

 

 

static structregulator_consumer_supply fixed_reg_en_3v3_sys_a01_supply[] = {

  REGULATOR_SUPPLY("vdd_3v3",NULL),

  REGULATOR_SUPPLY("vdd_3v3_devices",NULL),

  REGULATOR_SUPPLY("debug_cons",NULL),

  REGULATOR_SUPPLY("pwrdet_pex_ctl",NULL),

  REGULATOR_SUPPLY("vddio_gmi",NULL),

};

 

static structregulator_consumer_supply fixed_reg_en_avdd_hdmi_usb_a01_supply[] = {

  REGULATOR_SUPPLY("avdd_hdmi",NULL),

  REGULATOR_SUPPLY("avdd_usb",NULL),

};

 

static structregulator_consumer_supply fixed_reg_en_vddio_vid_supply[] = {

  REGULATOR_SUPPLY("vdd_hdmi_con",NULL),

};

 

static structregulator_consumer_supply fixed_reg_en_vdd_sdmmc1_supply[] = {

  REGULATOR_SUPPLY("vddio_sd_slot","sdhci-tegra.0"),

};

 

static structregulator_consumer_supply fixed_reg_en_3v3_fuse_supply[] = {

  REGULATOR_SUPPLY("vdd_fuse",NULL),

};

 

/* Macro for defining fixedregulator sub device data */

#define FIXED_SUPPLY(_name)"fixed_reg_"#_name

#define FIXED_REG(_id, _var,_name, _in_supply, _always_on, _boot_on,     \

  _gpio_nr,_active_high, _boot_state, _millivolts)  \

  staticstruct regulator_init_data ri_data_##_var =                  \

  {                                                                         \

            .supply_regulator= _in_supply,                                   \

            .num_consumer_supplies=                                \

                     ARRAY_SIZE(fixed_reg_##_name##_supply),                   \

            .consumer_supplies= fixed_reg_##_name##_supply,   \

            .constraints= {                                              \

                     .valid_modes_mask= (REGULATOR_MODE_NORMAL |         \

                                        REGULATOR_MODE_STANDBY),     \

                     .valid_ops_mask= (REGULATOR_CHANGE_MODE |      \

                                        REGULATOR_CHANGE_STATUS|    \

                                        REGULATOR_CHANGE_VOLTAGE), \

                     .always_on= _always_on,                         \

                     .boot_on= _boot_on,                                  \

            },                                                               \

  };                                                                        \

  staticstruct fixed_voltage_config fixed_reg_##_var##_pdata =   \

  {                                                                         \

            .supply_name= FIXED_SUPPLY(_name),                            \

            .microvolts= _millivolts * 1000,                         \

            .gpio= _gpio_nr,                                           \

            .enable_high= _active_high,                              \

            .enabled_at_boot= _boot_state,                               \

            .init_data= &ri_data_##_var,                                     \

  };                                                                        \

  staticstruct platform_device fixed_reg_##_var##_dev = {    \

            .name= "reg-fixed-voltage",                              \

            .id= _id,                                                 \

            .dev= {                                                    \

                     .platform_data= &fixed_reg_##_var##_pdata,     \

            },                                                               \

  }

 

/* A01 specific */

FIXED_REG(1, en_3v3_sys_a01,        en_3v3_sys_a01,              NULL,

  1,      0,      MAX77663_GPIO_BASE+ MAX77663_GPIO3,        true,         1,      3300);

FIXED_REG(2,en_avdd_hdmi_usb_a01, en_avdd_hdmi_usb_a01, FIXED_SUPPLY(en_3v3_sys_a01),

  0,      0,      MAX77663_GPIO_BASE+ MAX77663_GPIO2,        true,         0,      3300);

FIXED_REG(4, en_vddio_vid_a01,     en_vddio_vid,           NULL,

  0,      0,      TEGRA_GPIO_PB2,                             true,         0,      5000);

FIXED_REG(9,  en_vdd_sdmmc1_a01, en_vdd_sdmmc1,                FIXED_SUPPLY(en_3v3_sys_a01),

  0,      0,      TEGRA_GPIO_PC6,                             true,         0,      3300);

FIXED_REG(10, en_3v3_fuse_a01,   en_3v3_fuse,            FIXED_SUPPLY(en_3v3_sys_a01),

  0,      0,      TEGRA_GPIO_PC1,                             true,         0,      3300);

 

FIXED_REG(11, en_1v8_cam_a01,   en_1v8_cam,            NULL,

  0,      0,      TEGRA_GPIO_PS0,                              true,         0,      1800);

 

FIXED_REG(12, en_cam1_ldo_a01,  en_cam1_ldo,           FIXED_SUPPLY(en_3v3_sys_a01),  

  0,      0,      TEGRA_GPIO_PR6,                             true,         0,      2800);

/*

 * Creating the fixed regulator device tables

 */

 

#define ADD_FIXED_REG(_name)     (&fixed_reg_##_name##_dev)

 

/* A01 specific */

#define E1565_A01_FIXED_REG \

  ADD_FIXED_REG(en_3v3_sys_a01),                \

  ADD_FIXED_REG(en_avdd_hdmi_usb_a01),  \

  ADD_FIXED_REG(en_vddio_vid_a01),    \

  ADD_FIXED_REG(en_vdd_sdmmc1_a01),      \

  ADD_FIXED_REG(en_3v3_fuse_a01),     \

  ADD_FIXED_REG(en_1v8_cam_a01),\

  ADD_FIXED_REG(en_cam1_ldo_a01)

 

/* Gpio switch regulator platformdata for Kai A01 */

static struct platform_device*fixed_reg_devs_a01[] = {

  E1565_A01_FIXED_REG

};

 

static int __initkai_fixed_regulator_init(void)

{

  inti;

  structboard_info board_info;

  structplatform_device **fixed_reg_devs;

  intnfixreg_devs;

 

  tegra_get_board_info(&board_info);

 

 

  fixed_reg_devs= fixed_reg_devs_a01;

  nfixreg_devs= ARRAY_SIZE(fixed_reg_devs_a01);

 

 

  for(i = 0; i < nfixreg_devs; ++i) {

            intgpio_nr;

            structfixed_voltage_config *fixed_reg_pdata =

                     fixed_reg_devs[i]->dev.platform_data;

            gpio_nr= fixed_reg_pdata->gpio;

 

  }

 

  printk("kai_fixed_regulator_initnfixreg_devs=%d\n",nfixreg_devs);

 

  returnplatform_add_devices(fixed_reg_devs, nfixreg_devs);

}

subsys_initcall_sync(kai_fixed_regulator_init);

 

int __initkai_regulator_init(void)

{

  void__iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);

  u32pmc_ctrl;

  intret;

 

  /*configure the power management controller to trigger PMU

   * interrupts when low */

 

  pmc_ctrl= readl(pmc + PMC_CTRL);

  writel(pmc_ctrl| PMC_CTRL_INTR_LOW, pmc + PMC_CTRL);

 

  ret= kai_max77663_regulator_init();

  if(ret < 0)

            returnret;

 

  return0;

}

分析:

 

首先看__init函数int __initkai_regulator_init(void)

àkai_max77663_regulator_init(); //max77663设备初始化函数

ài2c_register_board_info(4,max77663_regulators,ARRAY_SIZE(max77663_regulators)); //注册i2c硬件信息

->static structi2c_board_info __initdata max77663_regulators[] = {

  {

            /* The I2C address was determined byOTP factory setting */

            I2C_BOARD_INFO("max77663",0x3c),   //i2c地址

            .irq            =INT_EXTERNAL_PMU,           //pmu中断

            .platform_data         = &max7763_pdata, //要传的平台数据,

  },

};

接下来看平台数据:

static structmax77663_platform_data max7763_pdata = {

  .irq_base =MAX77663_IRQ_BASE,

  .gpio_base       =MAX77663_GPIO_BASE,

  .flags=SLP_MONITORS_ENABLE|SLP_LPM_ENABLE,

  .num_gpio_cfgs       =ARRAY_SIZE(max77663_gpio_cfgs),

  .gpio_cfgs         =max77663_gpio_cfgs,

 

  .num_subdevs =ARRAY_SIZE(max77663_subdevs),

  .sub_devices    =max77663_subdevs,

 

  .rtc_i2c_addr   =0x68, //rtc i2c地址

 

  .use_power_off        =true,

};

  max77663_gpio_cfgs函数主要是一些gpio引脚的初始化.

  接下来最重要的函数是: max77663_subdevs

static structmfd_cell max77663_subdevs[] = {

  MAX77663_REG(SD0, sd0),

  MAX77663_REG(SD1, sd1),

……….

};

MAX77663_REG它是一个宏,我们展开看一下.

#defineMAX77663_REG(_id, _data)                                               \

  {                                                                         \

            .name ="max77663-regulator",                                 \

            .id = MAX77663_REGULATOR_ID_##_id,                           \

            .platform_data =&max77663_regulator_pdata_##_data,   \

            .pdata_size =sizeof(max77663_regulator_pdata_##_data),         \

  }

 

很明显他是要给一些参数赋值.

不过,到这里好像我们的跟踪断了...

不用着急我们再看下面一个宏.

MAX77663_PDATA_INIT(sd0,  600000, 3387500, NULL, 1, 0, 0,0, 0, -1,FPS_SRC_NONE, -1, -1, EN2_CTRL_SD0);

MAX77663_PDATA_INIT(sd1,  800000, 1587500, NULL, 1, 0, 0,1, 1, -1,FPS_SRC_1, FPS_POWER_PERIOD_1, FPS_POWER_PERIOD_6, 0);

……

先猜想一下,这个应该是赋值的地方. 接下来我们看MAX77663_PDATA_INIT是一个什么东东.

 

#defineMAX77663_PDATA_INIT(_id, _min_uV, _max_uV, _supply_reg,                   \

                         _always_on, _boot_on, _apply_uV,                  \

                         _init_apply, _init_enable, _init_uV,          \

                         _fps_src, _fps_pu_period, _fps_pd_period,_flags) \

  static struct max77663_regulator_platform_datamax77663_regulator_pdata_##_id = \

  {                                                                         \

            .init_data = {                                                   \

                     .constraints = {                                     \

                              .min_uV = _min_uV,                            \

                              .max_uV = _max_uV,                          \

                              .valid_modes_mask= (REGULATOR_MODE_NORMAL |  \

                                                      REGULATOR_MODE_STANDBY), \

                              .valid_ops_mask =(REGULATOR_CHANGE_MODE |    \

                                                    REGULATOR_CHANGE_STATUS |  \

                                                    REGULATOR_CHANGE_VOLTAGE), \

                              .always_on =_always_on,                \

                              .boot_on =_boot_on,                         \

                              .apply_uV =_apply_uV,                      \

                     },                                                     \

                     .num_consumer_supplies =                       \

                              ARRAY_SIZE(max77663_##_id##_supply),      \

                     .consumer_supplies =max77663_##_id##_supply,        \

                     .supply_regulator =_supply_reg,             \

            },                                                               \

            .init_apply = _init_apply,                             \

            .init_enable = _init_enable,                                 \

            .init_uV = _init_uV,                                       \

            .fps_src = _fps_src,                                      \

            .fps_pu_period = _fps_pu_period,                     \

            .fps_pd_period = _fps_pd_period,                     \

            .fps_cfgs = max77663_fps_cfgs,                                 \

            .flags = _flags,                                      \

  }

哇~~~ 这又是一个宏.

不用头晕.

我们对比一个这两个东东: 1.                                        .platform_data =  &max77663_regulator_pdata_##_data,        

2.               staticstruct max77663_regulator_platform_data   max77663_regulator_pdata_##_id =

明白了,程序执行MAX77663_REG(SD0, sd0),这一句的时候

会执行这个&max77663_regulator_pdata_##_data,  (注意,data=sd0)

然后会执行max77663_regulator_pdata_##_id   (_id传过来的是值是sd0)

就等于执行了这个宏:

#defineMAX77663_PDATA_INIT(_id, _min_uV, _max_uV, _supply_reg,                   \

                         _always_on, _boot_on, _apply_uV,                  \

                         _init_apply, _init_enable, _init_uV,          \

                         _fps_src, _fps_pu_period, _fps_pd_period,_flags) \

         static structmax77663_regulator_platform_data max77663_regulator_pdata_##_id =

这个宏是怎么赋值参数的, 参数在哪里传进来呢?

答案就是这个宏: MAX77663_PDATA_INIT

别忘记了这个函数max77663_regulator_pdata_##_id ,传进来的_id=sd0

那么等于这组参数会被调用:

MAX77663_PDATA_INIT(sd0, 600000, 3387500, NULL, 1, 0, 0,0, 0, -1, FPS_SRC_NONE, -1, -1,EN2_CTRL_SD0);

好了,在这里参数值传进来了,可以赋值了.

赋值:

#defineMAX77663_PDATA_INIT(_id, _min_uV, _max_uV, _supply_reg,                   \

                         _always_on, _boot_on, _apply_uV,                  \

                         _init_apply, _init_enable, _init_uV,          \

                         _fps_src, _fps_pu_period, _fps_pd_period,_flags) \

  static struct max77663_regulator_platform_datamax77663_regulator_pdata_##_id = \

  {                                                                         \

            .init_data = {                                                   \

                     .constraints = {                                     \

                              .min_uV = _min_uV,                            \

                              .max_uV = _max_uV,                          \

                              .valid_modes_mask= (REGULATOR_MODE_NORMAL |  \

                                                      REGULATOR_MODE_STANDBY), \

                              .valid_ops_mask =(REGULATOR_CHANGE_MODE |    \

                                                    REGULATOR_CHANGE_STATUS |  \

                                                    REGULATOR_CHANGE_VOLTAGE), \

                              .always_on =_always_on,                \

                              .boot_on =_boot_on,                         \

                              .apply_uV =_apply_uV,                      \

                     },                                                     \

                     .num_consumer_supplies =                       \

                              ARRAY_SIZE(max77663_##_id##_supply),      \

                     .consumer_supplies =max77663_##_id##_supply,        \

                     .supply_regulator =_supply_reg,             \

            },                                                               \

            .init_apply = _init_apply,                             \

            .init_enable = _init_enable,                                 \

            .init_uV = _init_uV,                                       \

            .fps_src = _fps_src,                                      \

            .fps_pu_period = _fps_pu_period,                     \

            .fps_pd_period = _fps_pd_period,                     \

            .fps_cfgs = max77663_fps_cfgs,                                 \

            .flags = _flags,                                      \

  }

 

接下来我们需要关心消费者的问题,就是我们注册了regulator,谁去使用它呢?

注意这个函数: .consumer_supplies = max77663_##_id##_supply,        \

又是一个宏, ##_id## ,我们知道了,刚刚我们传进来的_id是sd0,那么该函数就是:max77663_sd0_supply.

查找一下函数试试~~~

~~~找到了.

static struct regulator_consumer_supply max77663_sd0_supply[] ={

         REGULATOR_SUPPLY("vdd_cpu",NULL),

};

 

static struct regulator_consumer_supply max77663_sd1_supply[] ={

         REGULATOR_SUPPLY("vdd_core",NULL),

};

….

Ok! 终于对上了.

REGULATOR_SUPPLY("vdd_cpu", NULL),

"vdd_cpu"是代表一路regulator

后面的NULL代表消费者, 

注意一个regulator可以包括很多消费者的.

为NULL那我们get的时候就不用关心消费者,只关心是哪一路regulator就好

 

其它路的regulator流程完全一样.

 

还有一点要特别指出的是:

#defineMAX77663_REG(_id, _data)                                               \

  {                                                                         \

            .name ="max77663-regulator",                                 \

            .id = MAX77663_REGULATOR_ID_##_id,                           \

            .platform_data =&max77663_regulator_pdata_##_data,   \

            .pdata_size =sizeof(max77663_regulator_pdata_##_data),         \

  }

这个宏它会多次被调用, 就是说他有多路regulator的平台设备name都一样, .name ="max77663-regulator".

那么我们可以大胆的设想一下,是不是平台驱动会probe很多次?

Yes,答案是肯定的,这个等我们分析平台驱动的时候就会知道.

 

 

到这里为止平台设备注册成功了.下一步需要关心驱动了.

Regulator驱动:      kernel\drivers\regulator\max77663-regulator.c

                                     kernel\include\linux\regulator\max77663-regulator.h

首先看init函数:

static int __init max77663_regulator_init(void)

{

         returnplatform_driver_register(&max77663_regulator_driver);

}

注册了一个max77663_regulator_driver的平台驱动.

 

static struct platform_driver max77663_regulator_driver = {

         .probe =max77663_regulator_probe,

         .remove =__devexit_p(max77663_regulator_remove),

         .driver = {

                   .name ="max77663-regulator",

                   .owner =THIS_MODULE,

         },

};

重点关心probe函数: .probe = max77663_regulator_probe,

static int max77663_regulator_probe(struct platform_device*pdev)

{

         structregulator_desc *rdesc;

         structmax77663_regulator *reg;

         int ret = 0;

 

         if ((pdev->id< 0) || (pdev->id >= MAX77663_REGULATOR_ID_NR)) {

                   dev_err(&pdev->dev,"Invalid device id %d\n", pdev->id);

                   return-ENODEV;

         }

 

         rdesc =&max77663_rdesc[pdev->id];

         reg =&max77663_regs[pdev->id];

         reg->dev =&pdev->dev;

         reg->pdata =dev_get_platdata(&pdev->dev);

 

         dev_dbg(&pdev->dev,"probe: name=%s\n", rdesc->name);

 

         ret =max77663_regulator_preinit(reg);

         if (ret) {

                   dev_err(&pdev->dev,"probe: Failed to preinit regulator %s\n",

                            rdesc->name);

                   returnret;

         }

 

         reg->rdev =regulator_register(rdesc, &pdev->dev,

                                            &reg->pdata->init_data, reg);

         if(IS_ERR(reg->rdev)) {

                   dev_err(&pdev->dev,"probe: Failed to register regulator %s\n",

                            rdesc->name);

                   returnPTR_ERR(reg->rdev);

         }

 

         return 0;

}

这几条用于得到平台设备传过来的平台数据:

         rdesc =&max77663_rdesc[pdev->id];

         reg =&max77663_regs[pdev->id];

         reg->dev =&pdev->dev;

         reg->pdata =dev_get_platdata(&pdev->dev);

注意这里只传过来一路regulator的信息, 所以我们之前的猜想完全是对的,

就是这个probe函数会多次被调用,每一路regulator设备会调用一次.

那么是不是意味着这不是一个驱动而是一组驱动呢?

嗯,或许你可以这样理解.

这里我们分析一路就好了,其它的也就完全一样了.

其中这两句比较重要:

         rdesc =&max77663_rdesc[pdev->id];

         reg =&max77663_regs[pdev->id];

先看rdesc =&max77663_rdesc[pdev->id];

static struct regulator_descmax77663_rdesc[MAX77663_REGULATOR_ID_NR] = {

         REGULATOR_DESC(SD0,sd0),

         REGULATOR_DESC(DVSSD0,dvssd0),

……

};

我们展开宏: REGULATOR_DESC

#define REGULATOR_DESC(_id, _name)                            \

         [MAX77663_REGULATOR_ID_##_id]= {          \

                   .name =max77663_rails(_name),           \

                   .id =MAX77663_REGULATOR_ID_##_id,        \

                   .ops =&max77663_ldo_ops,            \

                   .type =REGULATOR_VOLTAGE,                \

                   .owner =THIS_MODULE,                           \

         }

 

明白了,他是注册了一个opration操作函数.

static struct regulator_ops max77663_ldo_ops = {

         .set_voltage =max77663_regulator_set_voltage,

         .get_voltage =max77663_regulator_get_voltage,

         .enable =max77663_regulator_enable,

         .disable =max77663_regulator_disable,

         .is_enabled =max77663_regulator_is_enabled,

         .set_mode =max77663_regulator_set_mode,

         .get_mode =max77663_regulator_get_mode,

};

看见了没有?这是有设置regulator的电压,和得到电压,以及enabled等函数.

很明显,这些函数是留给消费者使用的.

好了,消费者怎么使用的问题有了头绪了,可是还有一个问题,硬件信息呢?

接下来我们看: reg =&max77663_regs[pdev->id];

static struct max77663_regulatormax77663_regs[MAX77663_REGULATOR_ID_NR] = {

         REGULATOR_SD(SD0,    SDX, SD0, 600000, 3387500, 12500),

         REGULATOR_SD(DVSSD0,SDX, NONE, 600000, 3387500, 12500),

……

}

这好像是设置一些电压,电流值的,怎么这么熟悉呢?

对了,我们在平台设备注册的时候见过类似的.

MAX77663_PDATA_INIT(sd0, 600000, 3387500, NULL, 1, 0, 0,0, 0, -1, FPS_SRC_NONE, -1, -1,EN2_CTRL_SD0);

……

继续展开宏:REGULATOR_SD

#define REGULATOR_LDO(_id, _type, _min_uV, _max_uV, _step_uV)  \

         [MAX77663_REGULATOR_ID_##_id]= {                   \

                   .id =MAX77663_REGULATOR_ID_##_id,                 \

                   .type =REGULATOR_TYPE_LDO_##_type,               \

                   .volt_mask= LDO_VOLT_MASK,                         \

                   .regs ={                                         \

                            [VOLT_REG]= {                                     \

                                     .addr= MAX77663_REG_##_id##_CFG, \

                            },                                            \

                            [CFG_REG]= {                              \

                                     .addr= MAX77663_REG_##_id##_CFG2, \

                            },                                            \

                            [FPS_REG]= {                               \

                                     .addr= MAX77663_REG_FPS_##_id,       \

                            },                                            \

                   },                                                     \

                   .min_uV= _min_uV,                                     \

                   .max_uV= _max_uV,                                   \

                   .step_uV= _step_uV,                                  \

                   .regulator_mode= REGULATOR_MODE_NORMAL,       \

                   .power_mode= POWER_MODE_NORMAL,             \

                   .power_mode_mask= LDO_POWER_MODE_MASK,               \

                   .power_mode_shift= LDO_POWER_MODE_SHIFT,        \

         }

好了,这就是要设置的硬件信息了, 电压值, 寄存器地址都有了.

寄存器.regs = {                                             \

                            [VOLT_REG]= {                                     \

                                     .addr= MAX77663_REG_##_id##_CFG, \

                            },                                            \

                            [CFG_REG]= {                              \

                                     .addr= MAX77663_REG_##_id##_CFG2, \

                            },                                            \

                            [FPS_REG]= {                               \

                                     .addr= MAX77663_REG_FPS_##_id,       \

                            },                        

我们猜想一下这三个词的意思:

 VOLT_REG  电压寄存器

CFG_REG   config寄存器

FPS_REG   频率寄存器

…..先到这吧.

 

大家一定也想到了:

         rdesc =&max77663_rdesc[pdev->id];

         reg =&max77663_regs[pdev->id];

这两个值好像有着某种对应关系, 一个可以提供操作函数,一个可以提供硬件的操作信息.那他们俩合在一起的话驱动不就完整了吗?

 

接下来看这个函数:

ret = max77663_regulator_preinit(reg);

顾名思义,对这些传过来的数据进行初始化.

 

staticint max77663_regulator_preinit(struct max77663_regulator *reg)

{

         struct max77663_regulator_platform_data*pdata = _to_pdata(reg);

         struct device *parent =_to_parent(reg);

         int i;

         u8 val, mask;

         int ret;

 

         /* Update registers */

         for (i = 0; i <= FPS_REG; i++) {

                   ret = max77663_read(parent,reg->regs[i].addr,

                                         &reg->regs[i].val, 1, 0);

                   if (ret < 0) {

                            dev_err(reg->dev,

                                     "preinit:Failed to get register 0x%x\n",

                                     reg->regs[i].addr);

                            return ret;

                   }

         }

 

         /* Update FPS source */

         if (reg->regs[FPS_REG].addr ==MAX77663_REG_FPS_NONE)

                   reg->fps_src =FPS_SRC_NONE;

         else

                   reg->fps_src =(reg->regs[FPS_REG].val & FPS_SRC_MASK)

                                     >>FPS_SRC_SHIFT;

 

         dev_dbg(reg->dev, "preinit:initial fps_src=%s\n",

                   fps_src_name(reg->fps_src));

 

         /* Update power mode */

         max77663_regulator_get_power_mode(reg);

 

         /* Check Chip Identification */

         ret = max77663_read(parent,MAX77663_REG_CID5, &val, 1, 0);

         if (ret < 0) {

                   dev_err(reg->dev,"preinit: Failed to get register 0x%x\n",

                            MAX77663_REG_CID5);

                   return ret;

         }

 

         /* If metal revision is less thanrev.3,

          * set safe_down_uV for stable down scaling. */

         if ((reg->type == REGULATOR_TYPE_SD)&&

                            ((val &CID_DIDM_MASK) >> CID_DIDM_SHIFT) <= 2)

                   reg->safe_down_uV =SD_SAFE_DOWN_UV;

         else

                   reg->safe_down_uV = 0;

 

         /* Set FPS */

         ret =max77663_regulator_set_fps_cfgs(reg, pdata->fps_cfgs,

                                                     pdata->num_fps_cfgs);

         if (ret < 0) {

                   dev_err(reg->dev,"preinit: Failed to set FPSCFG\n");

                   return ret;

         }

 

         /* N-Channel LDOs don‘t supportLow-Power mode. */

         if ((reg->type ==REGULATOR_TYPE_LDO_N) &&

                            (pdata->flags& GLPM_ENABLE))

                   pdata->flags &=~GLPM_ENABLE;

 

         /* To prevent power rail turn-off whenchange FPS source,

          * it must set power mode to NORMAL beforechange FPS source to NONE

          * from SRC_0, SRC_1 and SRC_2. */

         if ((reg->fps_src != FPS_SRC_NONE)&& (pdata->fps_src == FPS_SRC_NONE)

                            &&(reg->power_mode != POWER_MODE_NORMAL)) {

                   val = (pdata->flags &GLPM_ENABLE) ?

                         POWER_MODE_GLPM : POWER_MODE_NORMAL;

                   ret =max77663_regulator_set_power_mode(reg, val);

                   if (ret < 0) {

                            dev_err(reg->dev,"preinit: Failed to "

                                     "setpower mode to POWER_MODE_NORMAL\n");

                            return ret;

                   }

         }

 

         ret =max77663_regulator_set_fps_src(reg, pdata->fps_src);

         if (ret < 0) {

                   dev_err(reg->dev,"preinit: Failed to set FPSSRC to %d\n",

                            pdata->fps_src);

                   return ret;

         }

 

         ret = max77663_regulator_set_fps(reg);

         if (ret < 0) {

                   dev_err(reg->dev,"preinit: Failed to set FPS\n");

                   return ret;

         }

 

         /* Set initial state */

         if (!pdata->init_apply)

                   goto skip_init_apply;

 

         if (pdata->init_uV >= 0) {

                   ret =max77663_regulator_do_set_voltage(reg, pdata->init_uV,

                                                                 pdata->init_uV);

                   if (ret < 0) {

                            dev_err(reg->dev,"preinit: Failed to set voltage to "

                                     "%d\n",pdata->init_uV);

                            return ret;

                   }

         }

 

         if (pdata->init_enable)

                   val = (pdata->flags &GLPM_ENABLE) ?

                         POWER_MODE_GLPM : POWER_MODE_NORMAL;

         else

                   val = POWER_MODE_DISABLE;

 

         ret =max77663_regulator_set_power_mode(reg, val);

         if (ret < 0) {

                   dev_err(reg->dev,

                            "preinit:Failed to set power mode to %d\n", val);

                   return ret;

         }

 

skip_init_apply:

         if (reg->type == REGULATOR_TYPE_SD){

                   val = 0;

                   mask = 0;

 

                   if (pdata->flags &SD_SLEW_RATE_MASK) {

                            mask |= SD_SR_MASK;

                            if (pdata->flags& SD_SLEW_RATE_SLOWEST)

                                     val |=(SD_SR_13_75 << SD_SR_SHIFT);

                            else if(pdata->flags & SD_SLEW_RATE_SLOW)

                                     val |=(SD_SR_27_5 << SD_SR_SHIFT);

                            else if(pdata->flags & SD_SLEW_RATE_FAST)

                                     val |=(SD_SR_55 << SD_SR_SHIFT);

                            else

                                     val |=(SD_SR_100 << SD_SR_SHIFT);

                   }

 

                   mask |= SD_FPWM_MASK;

                   if (pdata->flags &SD_FORCED_PWM_MODE)

                            val |= SD_FPWM_MASK;

 

                   mask |= SD_FSRADE_MASK;

                   if (pdata->flags &SD_FSRADE_DISABLE)

                            val |=SD_FSRADE_MASK;

 

                   ret =max77663_regulator_cache_write(reg,

                                     reg->regs[CFG_REG].addr,mask, val,

                                     &reg->regs[CFG_REG].val);

                   if (ret < 0) {

                            dev_err(reg->dev,"preinit: "

                                     "Failedto set register 0x%x\n",

                                     reg->regs[CFG_REG].addr);

                            return ret;

                   }

 

                   if ((reg->id ==MAX77663_REGULATOR_ID_SD0)

                                     &&(pdata->flags & EN2_CTRL_SD0)) {

                            val =POWER_MODE_DISABLE;

                            ret =max77663_regulator_set_power_mode(reg, val);

                            if (ret < 0) {

                                     dev_err(reg->dev,"preinit: "

                                               "Failedto set power mode to %d for "

                                               "EN2_CTRL_SD0\n",val);

                                     return ret;

                            }

 

                            ret =max77663_regulator_set_fps_src(reg, FPS_SRC_NONE);

                            if (ret < 0) {

                                     dev_err(reg->dev,"preinit: "

                                               "Failedto set FPSSRC to FPS_SRC_NONE "

                                               "forEN2_CTRL_SD0\n");

                                     return ret;

                            }

                   }

         }

 

         if ((reg->id ==MAX77663_REGULATOR_ID_LDO4)

                            &&(pdata->flags & LDO4_EN_TRACKING)) {

                   val = TRACK4_MASK;

                   ret = max77663_write(parent,MAX77663_REG_LDO_CFG3, &val, 1, 0);

                   if (ret < 0) {

                            dev_err(reg->dev,"preinit: "

                                     "Failedto set register 0x%x\n",

                                     MAX77663_REG_LDO_CFG3);

                            return ret;

                   }

         }

 

         return 0;

}

 

哇,好像有点长.

         structmax77663_regulator_platform_data *pdata = _to_pdata(reg);

         struct device*parent = _to_parent(reg);

第一句是得到平台设备数据,在平台设备注册的时候也有一个max77663_regulator_platform_data哦,可别忘记了.

第二句是得到一个父regulator,你的regulator可以给子的regulator供电嘛. 好像也没看见怎么使用,不用管了.

/* Update registers */

         for (i = 0; i<= FPS_REG; i++) {

                   ret =max77663_read(parent, reg->regs[i].addr,

                                         &reg->regs[i].val, 1, 0);

                   if (ret< 0) {

                            dev_err(reg->dev,

                                     "preinit:Failed to get register 0x%x\n",

                                     reg->regs[i].addr);

                            returnret;

                   }

         }

 

         /* Update FPSsource */

         if(reg->regs[FPS_REG].addr == MAX77663_REG_FPS_NONE)

                   reg->fps_src= FPS_SRC_NONE;

         else

                   reg->fps_src= (reg->regs[FPS_REG].val & FPS_SRC_MASK)

                                     >>FPS_SRC_SHIFT;

 

         dev_dbg(reg->dev,"preinit: initial fps_src=%s\n",

                   fps_src_name(reg->fps_src));

 

         /* Update powermode */

         max77663_regulator_get_power_mode(reg);

这一部分好像都是更新什么寄存器, 都是读的我们不管它.

Pmu珍对某个cpu出厂都会预设一组参数进去的,保证cpu最低限度的正常上电时序.

….

ret = max77663_regulator_set_fps_cfgs(reg,pdata->fps_cfgs,pdata->num_fps_cfgs);

进函数:

 

static int  max77663_regulator_set_fps_cfgs(structmax77663_regulator *reg,

                                     structmax77663_regulator_fps_cfg *fps_cfgs,

                                     intnum_fps_cfgs)

{

         ……

                   ret =max77663_regulator_set_fps_cfg(reg, &fps_cfgs[i]);

…..

}

很明显,设置 config寄存器.

接着往下看:

….

ret = max77663_regulator_set_power_mode(reg, val);

….

ret = max77663_regulator_set_fps_src(reg, pdata->fps_src);

….

ret = max77663_regulator_set_fps(reg);

….

ret = max77663_regulator_do_set_voltage(reg,pdata->init_uV,pdata->init_uV);

….

不想看了,写的很长,但无非全是些初始化操作, 什么config寄存器呀,频率寄存器呀,电压寄存器呀.

初始化函数到此为止吧.

我们接着probe函数往下看:

         reg->rdev =regulator_register(rdesc, &pdev->dev,&reg->pdata->init_data,reg);

这就是注册regulator了.

和我们之前说的一样.

         rdesc =&max77663_rdesc[pdev->id];

         reg =&max77663_regs[pdev->id];

这两个结构合作了, 一个有硬件,寄存器配制信息,一个有opration操作函数,驱动完整了.

接下个完成各自的opration操作函数就ok了.

 

static struct regulator_ops max77663_ldo_ops = {

         .set_voltage =max77663_regulator_set_voltage,

         .get_voltage =max77663_regulator_get_voltage,

         .enable =max77663_regulator_enable,

         .disable =max77663_regulator_disable,

         .is_enabled =max77663_regulator_is_enabled,

         .set_mode =max77663_regulator_set_mode,

         .get_mode =max77663_regulator_get_mode,

};

到此为止,流程全通了,实现这些函数应该没难度,和平常写函数的思路大同小异.

其实max77663驱动除了,regulator驱动部分还有.

Regulator驱动:      kernel\drivers\regulator\max77663-regulator.c

                                     kernel\include\linux\regulator\max77663-regulator.h

rtc驱动:         kernel\drivers\rtc\rtc-max77663.c

max77663  core驱动:      kernel\drivers\mfd\max77663-core.c

                                kernel\linux\mfd\max77663-core.h

细心的人一定发现了,我们在平台设备注册的时候有两个i2c地址,

其中一个是regulator的i2c地址,另一个则是rtc的i2c地址.

max77663  Core驱动其实是包括了一些regulator的具体硬件最终的操作, 我们的opration的最终操作函数会调用到里面.

 

这些部分和平常的驱动几乎一样,所以也没有必要分析了.

Regulator讲完了,pmu的流程其实都已经清楚了.

 

最后还要就是regulator怎么使用? 我们注册了regulator,也初始化了它,还注册了opration函数.但并没有消费者真正去使用它.

记得我们刚学linux驱动的时候, 有一个file_opration函数,

这里的操作函数是让上层c语言应用程序调用的.

可是我们这里的opration函数不是这样的,他是给其它模块使用的. 即:其它驱动程序使用.

比如:触摸屏它使用了一路regulator,他在机器suspend的时候要求关电(或者说低电),在机器开屏的时候才要求上电使用.

那么:

使用过程是这样的:

1.我们先注册一个全局的regulator

static struct regulator *nabi2_dsi_reg = NULL;

 

2.然后get regulator

nabi2_dsi_reg = regulator_get(NULL, "avdd_dsi_csi");

这个我们应该有印象,在平台设备注册的时候我们有注册它.

如:

static struct regulator_consumer_supply max77663_ldo7_supply[] ={

         REGULATOR_SUPPLY("avdd_dsi_csi",NULL),

         REGULATOR_SUPPLY("pwrdet_mipi",NULL),

};

Ok,之前我们注册了它,现在我们得到它

 

 

3.给它上电就使能它

regulator_enable(nabi2_dsi_reg);

 

4.我们不再需要的时候就禁止它,以及放回它的使用权.

         regulator_disable(nabi2_dsi_reg);

         regulator_put(nabi2_dsi_reg);

 

还有一些操作函数如:

int regulator_get_voltage(struct regulator *regulator)

int regulator_set_current_limit(struct regulator *regulator,intmin_uA, int max_uA)

….

具体请参考: kernel\drivers\regulator\core.c

Over!

电源管理之pmu驱动分析

标签:des   io   os   ar   使用   for   sp   文件   数据   

原文地址:http://www.cnblogs.com/biglucky/p/4059386.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!