drivers/regulator/rockchip_io_vol_domain.c

   1
   2
   3 #include <linux/bug.h>
   4 #include <linux/err.h>
   5 #include <linux/i2c.h>
   6 #include <linux/kernel.h>
   7 #include <linux/regulator/driver.h>
   8 #include <linux/delay.h>
   9 #include <linux/slab.h>
  10 #include <linux/mutex.h>
  11 #include <linux/module.h>
  12 #include <linux/of_irq.h>
  13 #include <linux/of_gpio.h>
  14 #include <linux/of.h>
  15 #include <linux/of_device.h>
  16 #include <linux/regulator/of_regulator.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/pinctrl/consumer.h>
  20 #include <linux/regulator/rockchip_io_vol_domain.h>
  21
  22 struct io_domain_port *g_uap;
  23
  24 int io_domain_regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
  25 {
  26         int old_voltage,ret =0;
  27
  28         old_voltage = io_domain_regulator_get_voltage(regulator);
  29         if (IS_ERR(g_uap->pins_3v3) ||IS_ERR(g_uap->pins_1v8) ){
  30                         printk("IO_DOMAIN:ERROR:The io vol domin is not exit. %s\n",__func__);
  31         }
  32
  33         if (min_uV  >= old_voltage){
  34                 if( min_uV > IO_VOL_DOMAIN_3V3){
  35                         pinctrl_select_state(g_uap->pctl, g_uap->pins_3v3);
  36                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 3.3v. %s \n",__func__);
  37                 }
  38                 else if (min_uV > IO_VOL_DOMAIN_1V8){
  39                         pinctrl_select_state(g_uap->pctl, g_uap->pins_1v8);
  40                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 1.8v. %s \n",__func__);
  41                 }
  42                 ret = regulator_set_voltage(regulator,min_uV,max_uV);
  43         }
  44         else if (min_uV  < old_voltage){
  45                 ret = regulator_set_voltage(regulator,min_uV,max_uV);
  46                 if( min_uV > IO_VOL_DOMAIN_3V3){
  47                         pinctrl_select_state(g_uap->pctl, g_uap->pins_3v3);
  48                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 3.3v. %s \n",__func__);
  49                 }
  50                 else if (min_uV > IO_VOL_DOMAIN_1V8){
  51                         pinctrl_select_state(g_uap->pctl, g_uap->pins_1v8);
  52                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 1.8v. %s \n",__func__);
  53                 }
  54         }
  55
  56         return ret;
  57
  58 }
  59
  60
  61 #if defined(CONFIG_PM)
  62 static int rk_io_vol_domain_suspend(struct platform_device *pdev, pm_message_t state)
  63 {
  64         return 0;
  65 }
  66
  67 static int rk_io_vol_domain_resume(struct platform_device *pdev)
  68 {
  69         return 0;
  70 }
  71 #else
  72 #define rk_io_vol_domain_suspend NULL
  73 #define rk_io_vol_domain_resume  NULL
  74 #endif
  75
  76 static int rk_io_vol_domain_probe(struct platform_device *pdev)
  77 {
  78         struct io_domain_port *uap;
  79         struct vd_node *vd;
  80         struct device_node *io_domain_node,*pd_dev_node ;
  81         struct regulator *vol_regulator;
  82         struct io_domain_device *io_vol_dev = NULL;
  83         int vol=0,ret =0;
  84
  85         io_vol_dev = devm_kzalloc(&pdev->dev, sizeof(struct io_domain_device), GFP_KERNEL);
  86         if (!io_vol_dev) {
  87                 dev_err(&pdev->dev, "no memory for state\n");
  88                 return -ENOMEM;
  89         }
  90         platform_set_drvdata(pdev, io_vol_dev);
  91         io_vol_dev->dev = &pdev->dev;
  92
  93         uap = devm_kzalloc(&pdev->dev, sizeof(struct io_domain_port),
  94                            GFP_KERNEL);
  95         if (uap == NULL) {
  96                 printk("uap is not set %s,line=%d\n", __func__,__LINE__);
  97
  98         }
  99         uap->pctl = devm_pinctrl_get(io_vol_dev->dev);
 100         uap->pins_default = pinctrl_lookup_state(uap->pctl,"default");
 101         uap->pins_1v8 = pinctrl_lookup_state(uap->pctl, "1.8V");
 102         uap->pins_3v3 = pinctrl_lookup_state(uap->pctl,"3.3V");
 103         g_uap = uap;
 104
 105         io_domain_node = of_node_get(pdev->dev.of_node);
 106         if (!io_domain_node) {
 107                 printk("could not find rk_io_vol_domain-node\n");
 108                 return -ENOMEM ;
 109         }
 110
 111         for_each_available_child_of_node(io_domain_node,pd_dev_node) {
 112                 vd = kzalloc(sizeof(struct vd_node), GFP_KERNEL);
 113                 if (!vd)
 114                         return -ENOMEM;
 115
 116                 vd->name = pd_dev_node->name;
 117                 pd_dev_node->name = of_get_property(pd_dev_node, "regulator-name", NULL);
 118                 if (pd_dev_node->name== NULL) {
 119                         printk("%s vd(%s) pd_dev_node->name(%s) get regulator_name err, ret:%d\n",
 120                                 __func__,vd->name , pd_dev_node->name,ret);
 121                         kfree(vd);
 122                         continue;
 123                 }
 124                 vol_regulator = regulator_get(NULL,pd_dev_node->name);
 125                 if (IS_ERR(vol_regulator)){
 126                         pinctrl_select_state(uap->pctl, uap->pins_default);
 127                         IO_DOMAIN_DBG("IO_DOMAIN:ERROR:The io vol domin is not exit,set it by defult. %s %s\n",__func__,pd_dev_node->name);
 128                         continue;
 129                 }
 130                 else{
 131                 vol = regulator_get_voltage(vol_regulator);
 132                 if (vol > IO_VOL_DOMAIN_3V3){
 133                         pinctrl_select_state(uap->pctl, uap->pins_3v3);
 134                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 3.3v. %s %s = %d\n",__func__,pd_dev_node->name,vol);
 135                         }
 136                 else if (vol > IO_VOL_DOMAIN_1V8){
 137                         pinctrl_select_state(uap->pctl, uap->pins_1v8);
 138                         IO_DOMAIN_DBG("IO_DOMAIN:set io domain 1.8v. %s %s = %d\n",__func__,pd_dev_node->name,vol);
 139                         }
 140                 else{
 141                         pinctrl_select_state(uap->pctl, uap->pins_default);
 142                         IO_DOMAIN_DBG("IO_DOMAIN:ERROR:The io vol domin is not exit,set it by defult. %s %s\n",__func__,pd_dev_node->name);
 143                         }
 144                 }
 145         }
 146
 147         return 0;
 148 }
 149
 150 static int rk_io_vol_domain_remove(struct platform_device *pdev)
 151 {
 152
 153         return 0;
 154 }
 155
 156 #if defined(CONFIG_OF)
 157 static const struct of_device_id rk_io_vol_domain_dt_ids[] = {
 158         {.compatible = "rockchip,io_vol_domain", .data = NULL, },
 159         {}
 160 };
 161 #endif
 162
 163 static struct platform_driver rk_io_vol_domain_driver = {
 164         .probe = rk_io_vol_domain_probe,
 165         .remove = rk_io_vol_domain_remove,
 166         .driver = {
 167                    .name = "rk_io_vol_domain",
 168                    .owner = THIS_MODULE,
 169                    .of_match_table = of_match_ptr(rk_io_vol_domain_dt_ids),
 170                    },
 171         .suspend = rk_io_vol_domain_suspend,
 172         .resume = rk_io_vol_domain_resume,
 173 };
 174
 175 static int __init rk_io_vol_domain_module_init(void)
 176 {
 177         return platform_driver_register(&rk_io_vol_domain_driver);
 178 }
 179
 180 static void __exit rk_io_vol_domain_module_exit(void)
 181 {
 182         platform_driver_unregister(&rk_io_vol_domain_driver);
 183 }
 184
 185 fs_initcall(rk_io_vol_domain_module_init);
 186 module_exit(rk_io_vol_domain_module_exit);
 187
 188 MODULE_LICENSE("GPL");
 189 MODULE_AUTHOR("rockchip");
 190 MODULE_DESCRIPTION("rk io domain setting");
 191
 192