API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 18th, 2022
72
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 24.73 KB | None | 0 0
raw download clone embed print report
  1.  /*
  2.  * Copyright (C) 2010 Freescale Semiconductor, Inc. All Rights Reserved.
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License along
  15.  * with this program; if not, write to the Free Software Foundation, Inc.,
  16.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17.  */
  18.  
  19. /*!
  20.  * @file ltc3589-regulator.c
  21.  * @brief This is the main file for the Linear PMIC regulator driver. i2c
  22.  * should be providing the interface between the PMIC and the MCU.
  23.  *
  24.  * @ingroup PMIC_CORE
  25.  */
  26.  
  27. #include <linux/kernel.h>
  28. #include <linux/module.h>
  29. #include <linux/init.h>
  30. #include <linux/err.h>
  31. #include <linux/platform_device.h>
  32. #include <linux/regulator/driver.h>
  33. #include <linux/regulator/machine.h>
  34. #include <linux/regulator/ltc3589.h>
  35. #include <linux/i2c.h>
  36. #include <linux/delay.h>
  37. #include <linux/mfd/ltc3589/core.h>
  38. #include <mach/hardware.h>
  39.  
  40. /* Register definitions */
  41. #define LTC3589_REG_IRSTAT      0x02
  42. #define LTC3589_REG_SCR1        0x07
  43. #define LTC3589_REG_OVEN        0x10
  44. #define LTC3589_REG_SCR2        0x12
  45. #define LTC3589_REG_PGSTAT      0x13
  46. #define LTC3589_REG_VCCR        0x20
  47. #define LTC3589_REG_CLIRQ       0x21
  48. #define LTC3589_REG_B1DTV1      0x23
  49. #define LTC3589_REG_B1DTV2      0x24
  50. #define LTC3589_REG_VRRCR       0x25
  51. #define LTC3589_REG_B2DTV1      0x26
  52. #define LTC3589_REG_B2DTV2      0x27
  53. #define LTC3589_REG_B3DTV1      0x29
  54. #define LTC3589_REG_B3DTV2      0x2A
  55. #define LTC3589_REG_L2DTV1      0x32
  56. #define LTC3589_REG_L2DTV2      0x33
  57.  
  58. /* SCR1 bitfields */
  59. #define LTC3589_SCR1_   BIT(7)
  60. #define LTC3589_PGOODZ_LOWBATTZ BIT(6)
  61. #define LTC3589_PGOODZ_VDCDC1       BIT(5)
  62. #define LTC3589_PGOODZ_VDCDC2       BIT(4)
  63. #define LTC3589_PGOODZ_VDCDC3       BIT(3)
  64. #define LTC3589_PGOODZ_LDO2     BIT(2)
  65. #define LTC3589_PGOODZ_LDO1     BIT(1)
  66.  
  67. /* MASK bitfields */
  68. #define LTC3589_MASK_PWRFAILZ       BIT(7)
  69. #define LTC3589_MASK_LOWBATTZ       BIT(6)
  70. #define LTC3589_MASK_VDCDC1     BIT(5)
  71. #define LTC3589_MASK_VDCDC2     BIT(4)
  72. #define LTC3589_MASK_VDCDC3     BIT(3)
  73. #define LTC3589_MASK_LDO2       BIT(2)
  74. #define LTC3589_MASK_LDO1       BIT(1)
  75.  
  76. /* REG_CTRL bitfields */
  77. #define LTC3589_REG_CTRL_VDCDC1_EN  BIT(5)
  78. #define LTC3589_REG_CTRL_VDCDC2_EN  BIT(4)
  79. #define LTC3589_REG_CTRL_VDCDC3_EN  BIT(3)
  80. #define LTC3589_REG_CTRL_LDO2_EN    BIT(2)
  81. #define LTC3589_REG_CTRL_LDO1_EN    BIT(1)
  82.  
  83. /* LDO_CTRL bitfields */
  84. #define LTC3589_LDO_CTRL_LDOx_SHIFT(ldo_id) ((ldo_id)*4)
  85. #define LTC3589_LDO_CTRL_LDOx_MASK(ldo_id)  (0xF0 >> ((ldo_id)*4))
  86.  
  87. /* Number of step-down converters available */
  88. #define LTC3589_NUM_DCDC        4
  89. /* Number of LDO voltage regulators  available */
  90. #define LTC3589_NUM_LDO     4
  91. /* Number of total regulators available */
  92. #define LTC3589_NUM_REGULATOR   (LTC3589_NUM_DCDC + LTC3589_NUM_LDO)
  93.  
  94. /* DCDCs */
  95. #define LTC3589_DCDC_1          0
  96. #define LTC3589_DCDC_2          1
  97. #define LTC3589_DCDC_3          2
  98. #define LTC3589_DCDC_4          3
  99. /* LDOs */
  100. #define LTC3589_LDO_1           4
  101. #define LTC3589_LDO_2           5
  102. #define LTC3589_LDO_3           6
  103. #define LTC3589_LDO_4           7
  104. /* Resistorss */
  105. #define LTC3589_LDO2_R1         180
  106. #define LTC3589_LDO2_R2_TO1     232
  107. #define LTC3589_LDO2_R2_TO2     191
  108. #define LTC3589_SW1_R1          100
  109. #define LTC3589_SW1_R2          180
  110. #define LTC3589_SW2_R1          180
  111. #define LTC3589_SW2_R2_TO1      232
  112. #define LTC3589_SW2_R2_TO2      191
  113. #define LTC3589_SW3_R1          270
  114. #define LTC3589_SW3_R2          100
  115.  
  116. #define LTC3589_MAX_REG_ID      LTC3589_LDO_4
  117.  
  118. /* Supported voltage values for regulators */
  119. static const u16 LDO4_VSEL_table[] = {
  120.     2800, 2500, 1800, 3300,
  121. };
  122.  
  123. struct i2c_client *ltc3589_client;
  124.  
  125. /* Regulator specific details */
  126. struct ltc_info {
  127.     const char *name;
  128.     unsigned min_uV;
  129.     unsigned max_uV;
  130.     bool fixed;
  131.     u8 table_len;
  132.     const u16 *table;
  133. };
  134.  
  135. /* PMIC details */
  136. struct ltc_pmic {
  137.     struct regulator_desc desc[LTC3589_NUM_REGULATOR];
  138.     struct i2c_client *client;
  139.     struct regulator_dev *rdev[LTC3589_NUM_REGULATOR];
  140.     const struct ltc_info *info[LTC3589_NUM_REGULATOR];
  141.     struct mutex io_lock;
  142. };
  143.  
  144. static int ltc3589_ldo2_r2;
  145. static int ltc3589_sw2_r2;
  146.  
  147. /*
  148.  * LTC3589 Device IO
  149.  */
  150. static DEFINE_MUTEX(io_mutex);
  151.  
  152. static int ltc_3589_set_bits(struct ltc3589 *ltc, u8 reg, u8 mask)
  153. {
  154.     int err, data;
  155.  
  156.     mutex_lock(&io_mutex);
  157.  
  158.     data = ltc->read_dev(ltc, reg);
  159.     if (data < 0) {
  160.         dev_err(&ltc->i2c_client->dev,
  161.             "Read from reg 0x%x failed\n", reg);
  162.         err = data;
  163.         goto out;
  164.     }
  165.  
  166.     data |= mask;
  167.     err = ltc->write_dev(ltc, reg, data);
  168.     if (err)
  169.         dev_err(&ltc->i2c_client->dev,
  170.             "Write for reg 0x%x failed\n", reg);
  171.  
  172. out:
  173.     mutex_unlock(&io_mutex);
  174.     return err;
  175. }
  176.  
  177. static int ltc_3589_clear_bits(struct ltc3589 *ltc, u8 reg, u8 mask)
  178. {
  179.     int err, data;
  180.  
  181.     mutex_lock(&io_mutex);
  182.  
  183.     data = ltc->read_dev(ltc, reg);
  184.     if (data < 0) {
  185.         dev_err(&ltc->i2c_client->dev,
  186.             "Read from reg 0x%x failed\n", reg);
  187.         err = data;
  188.         goto out;
  189.     }
  190.  
  191.     data &= ~mask;
  192.  
  193.     err = ltc->write_dev(ltc, reg, data);
  194.     if (err)
  195.         dev_err(&ltc->i2c_client->dev,
  196.             "Write for reg 0x%x failed\n", reg);
  197.  
  198. out:
  199.     mutex_unlock(&io_mutex);
  200.     return err;
  201.  
  202. }
  203.  
  204. static int ltc_3589_reg_read(struct ltc3589 *ltc, u8 reg)
  205. {
  206.     int data;
  207.  
  208.     mutex_lock(&io_mutex);
  209.  
  210.     data = ltc->read_dev(ltc, reg);
  211.     if (data < 0)
  212.         dev_err(&ltc->i2c_client->dev,
  213.             "Read from reg 0x%x failed\n", reg);
  214.  
  215.     mutex_unlock(&io_mutex);
  216.     return data;
  217. }
  218.  
  219. static int ltc_3589_reg_write(struct ltc3589 *ltc, u8 reg, u8 val)
  220. {
  221.     int err;
  222.  
  223.     mutex_lock(&io_mutex);
  224.  
  225.     err = ltc->write_dev(ltc, reg, val);
  226.     if (err < 0)
  227.         dev_err(&ltc->i2c_client->dev,
  228.             "Write for reg 0x%x failed\n", reg);
  229.  
  230.     mutex_unlock(&io_mutex);
  231.     return err;
  232. }
  233.  
  234. int ltc3589_set_slew_rate(struct regulator_dev *dev, int rate)
  235. {
  236.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  237.     int data, dcdc = rdev_get_id(dev);
  238.  
  239.     if (dcdc == LTC3589_DCDC_4 || dcdc == LTC3589_LDO_1 ||
  240.         dcdc == LTC3589_LDO_3 || dcdc == LTC3589_LDO_4)
  241.         return 0;
  242.  
  243.     if (rate > 0x3)
  244.         return -EINVAL;
  245.  
  246.     data = ltc_3589_reg_read(ltc, LTC3589_REG_VRRCR);
  247.     if (data < 0)
  248.         return data;
  249.  
  250.     if (dcdc == LTC3589_LDO_2)
  251.         dcdc = 3;
  252.  
  253.     data &= ~(3 << (2 * dcdc));
  254.     data |= (3 << (2 * dcdc));
  255.  
  256.     ltc_3589_reg_write(ltc, LTC3589_REG_VRRCR, data);
  257.  
  258.     return 0;
  259. }
  260.  
  261. static int ltc3589_dcdc_is_enabled(struct regulator_dev *dev)
  262. {
  263.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  264.     int data, dcdc = rdev_get_id(dev);
  265.     u8 shift;
  266.  
  267.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_4)
  268.         return -EINVAL;
  269.  
  270.     shift = dcdc;
  271.     data = ltc_3589_reg_read(ltc, LTC3589_REG_OVEN);
  272.  
  273.     if (data < 0)
  274.         return data;
  275.     else
  276.         return (data & 1<<shift) ? 1 : 0;
  277. }
  278.  
  279. static int ltc3589_ldo_is_enabled(struct regulator_dev *dev)
  280. {
  281.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  282.     int data, ldo = rdev_get_id(dev);
  283.     u8 shift;
  284.  
  285.     if (ldo < LTC3589_LDO_1 || ldo > LTC3589_LDO_4)
  286.         return -EINVAL;
  287.  
  288.     if (ldo == LTC3589_LDO_1)
  289.         return 1;
  290.  
  291.     shift = ldo - 1;
  292.     data = ltc_3589_reg_read(ltc, LTC3589_REG_OVEN);
  293.  
  294.     if (data < 0)
  295.         return data;
  296.     else
  297.         return (data & 1<<shift) ? 1 : 0;
  298. }
  299.  
  300. static int ltc3589_dcdc_enable(struct regulator_dev *dev)
  301. {
  302.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  303.     int dcdc = rdev_get_id(dev);
  304.     u8 shift;
  305.  
  306.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_4)
  307.         return -EINVAL;
  308.  
  309.     shift = dcdc;
  310.     return ltc_3589_set_bits(ltc, LTC3589_REG_OVEN, 1 << shift);
  311. }
  312.  
  313. static int ltc3589_dcdc_disable(struct regulator_dev *dev)
  314. {
  315.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  316.     int dcdc = rdev_get_id(dev);
  317.     u8 shift;
  318.  
  319.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_4)
  320.         return -EINVAL;
  321.  
  322.     shift = dcdc;
  323.     return ltc_3589_clear_bits(ltc, LTC3589_REG_OVEN, 1 << shift);
  324. }
  325.  
  326. static int ltc3589_ldo_enable(struct regulator_dev *dev)
  327. {
  328.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  329.     int ldo = rdev_get_id(dev);
  330.     u8 shift;
  331.  
  332.     if (ldo < LTC3589_LDO_1 || ldo > LTC3589_LDO_4)
  333.         return -EINVAL;
  334.  
  335.     if (ldo == LTC3589_LDO_1) {
  336.         printk(KERN_ERR "LDO1 is always enabled\n");
  337.         return 0;
  338.     }
  339.  
  340.     shift = (ldo - 1);
  341.     return ltc_3589_set_bits(ltc, LTC3589_REG_OVEN, 1 << shift);
  342. }
  343.  
  344. static int ltc3589_ldo_disable(struct regulator_dev *dev)
  345. {
  346.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  347.     int ldo = rdev_get_id(dev);
  348.     u8 shift;
  349.  
  350.     if (ldo < LTC3589_LDO_1 || ldo > LTC3589_LDO_4)
  351.         return -EINVAL;
  352.  
  353.     if (ldo == LTC3589_LDO_1) {
  354.         printk(KERN_ERR "LDO1 can not be disabled\n");
  355.         return 0;
  356.     }
  357.  
  358.     shift = (ldo - 1);
  359.     return ltc_3589_clear_bits(ltc, LTC3589_REG_OVEN, 1 << shift);
  360. }
  361.  
  362. static int ltc3589_dcdc_set_mode(struct regulator_dev *dev,
  363.                        unsigned int mode)
  364. {
  365.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  366.     int dcdc = rdev_get_id(dev);
  367.     u16 val;
  368.     int data;
  369.  
  370.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_4)
  371.         return -EINVAL;
  372.  
  373.     val = 1 << (dcdc - LTC3589_DCDC_1);
  374.     data = ltc_3589_reg_read(ltc, LTC3589_REG_SCR1);
  375.     if (data < 0)
  376.         return data;
  377.  
  378.     data &= ~(3 << (2 * dcdc));
  379.  
  380.     switch (mode) {
  381.     case REGULATOR_MODE_FAST:
  382.         /* burst mode */
  383.         data |= (1 << (2 * dcdc));
  384.         break;
  385.     case REGULATOR_MODE_NORMAL:
  386.         /* active / pulse skipping */
  387.         data |= (0 << (2 * dcdc));
  388.         break;
  389.     case REGULATOR_MODE_IDLE:
  390.     case REGULATOR_MODE_STANDBY:
  391.         /* force continuous mode */
  392.         data |= (2 << (2 * dcdc));
  393.     }
  394.  
  395.     return ltc_3589_reg_write(ltc, LTC3589_REG_SCR1, data);;
  396. }
  397.  
  398. static unsigned int ltc3589_dcdc_get_mode(struct regulator_dev *dev)
  399. {
  400.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  401.     int dcdc = rdev_get_id(dev);
  402.     int data;
  403.  
  404.     data = ltc_3589_reg_read(ltc, LTC3589_REG_VCCR);
  405.     if (data < 0)
  406.         return data;
  407.  
  408.     if (dcdc == LTC3589_DCDC_4) {
  409.         data >>= (2 * dcdc);
  410.         data &= 0x01;
  411.  
  412.         if (data == 1)
  413.             return REGULATOR_MODE_FAST;
  414.         else
  415.             return REGULATOR_MODE_NORMAL;
  416.     } else {
  417.         data >>= (2 * dcdc);
  418.         data &= 0x03;
  419.  
  420.         switch (data) {
  421.         case 0:
  422.             return REGULATOR_MODE_NORMAL;
  423.         case 1:
  424.             return REGULATOR_MODE_FAST;
  425.         case 2:
  426.             return REGULATOR_MODE_IDLE;
  427.         }
  428.     }
  429.  
  430.     return 0;
  431. }
  432.  
  433. static int ltc3589_dcdc_get_voltage(struct regulator_dev *dev)
  434. {
  435.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  436.     int volt_reg, data, dcdc = rdev_get_id(dev);
  437.     int shift, mask, r1, r2;
  438.     int uV;
  439.  
  440.     r1 = 0;
  441.     r2 = 1;
  442.  
  443.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_3)
  444.         return -EINVAL;
  445.  
  446.     data = ltc_3589_reg_read(ltc, LTC3589_REG_VCCR);
  447.     if (data < 0)
  448.         return data;
  449.  
  450.     switch (dcdc) {
  451.     case LTC3589_DCDC_1:
  452.         r1 = LTC3589_SW1_R1;
  453.         r2 = LTC3589_SW1_R2;
  454.         shift = LTC3589_B1DTV2_REG1_REF_INPUT_V2_SHIFT;
  455.         mask = LTC3589_B1DTV2_REG1_REF_INPUT_V2_MASK;
  456.         if (data & LTC3589_VCCR_REG1_REF_SELECT)
  457.             volt_reg = LTC3589_REG_B1DTV2;
  458.         else
  459.             volt_reg = LTC3589_REG_B1DTV1;
  460.         break;
  461.     case LTC3589_DCDC_2:
  462.         r1 = LTC3589_SW2_R1;
  463.         r2 = ltc3589_sw2_r2;
  464.         shift = LTC3589_B2DTV2_REG2_REF_INPUT_V2_SHIFT;
  465.         mask = LTC3589_B2DTV2_REG2_REF_INPUT_V2_MASK;
  466.         if (data & LTC3589_VCCR_REG2_REF_SELECT)
  467.             volt_reg = LTC3589_REG_B2DTV2;
  468.         else
  469.             volt_reg = LTC3589_REG_B2DTV1;
  470.         break;
  471.     case LTC3589_DCDC_3:
  472.         r1 = LTC3589_SW3_R1;
  473.         r2 = LTC3589_SW3_R2;
  474.         shift = LTC3589_B3DTV2_REG3_REF_INPUT_V2_SHIFT;
  475.         mask = LTC3589_B3DTV2_REG3_REF_INPUT_V2_MASK;
  476.         if (data & LTC3589_VCCR_REG3_REF_SELECT)
  477.             volt_reg = LTC3589_REG_B3DTV2;
  478.         else
  479.             volt_reg = LTC3589_REG_B3DTV1;
  480.         break;
  481.     default:
  482.         return -EINVAL;
  483.     }
  484.  
  485.     data = ltc_3589_reg_read(ltc, volt_reg);
  486.     if (data < 0)
  487.         return data;
  488.  
  489.     data >>= shift;
  490.     data &= mask;
  491.     uV = (((r1 + r2) * (362500 + data * 12500)) / r2);
  492.     return uV;
  493. }
  494.  
  495. static int ltc3589_dcdc_set_voltage(struct regulator_dev *dev,
  496.                 int min_uV, int max_uV)
  497. {
  498.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  499.     int dcdc = rdev_get_id(dev);
  500.     int volt_reg1;
  501.     int volt_reg2;
  502.     int shift, mask;
  503.     int r1, r2;
  504.     int dac_vol, data, slew_val;
  505.  
  506.     r1 = 0;
  507.     r2 = 1;
  508.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_3)
  509.         return -EINVAL;
  510.  
  511.     switch (dcdc) {
  512.     case LTC3589_DCDC_1:
  513.         r1 = LTC3589_SW1_R1;
  514.         r2 = LTC3589_SW1_R2;
  515.         volt_reg1 = 0;
  516.         volt_reg2 = LTC3589_REG_B1DTV1;
  517.         slew_val = 1;
  518.         shift = LTC3589_B1DTV2_REG1_REF_INPUT_V2_SHIFT;
  519.         mask = LTC3589_B1DTV2_REG1_REF_INPUT_V2_MASK;
  520.         break;
  521.     case LTC3589_DCDC_2:
  522.         r1 = LTC3589_SW2_R1;
  523.         r2 = ltc3589_sw2_r2;
  524.         volt_reg1 = 0;
  525.         volt_reg2 = LTC3589_REG_B2DTV1;
  526.         slew_val = 1;
  527.         shift = LTC3589_B2DTV2_REG2_REF_INPUT_V2_SHIFT;
  528.         mask = LTC3589_B2DTV2_REG2_REF_INPUT_V2_MASK;
  529.         break;
  530.     case LTC3589_DCDC_3:
  531.         r1 = LTC3589_SW3_R1;
  532.         r2 = LTC3589_SW3_R2;
  533.         volt_reg1 = 0;
  534.         volt_reg2 = LTC3589_REG_B3DTV1;
  535.         slew_val = 1;
  536.         shift = LTC3589_B3DTV2_REG3_REF_INPUT_V2_SHIFT;
  537.         mask = LTC3589_B3DTV2_REG3_REF_INPUT_V2_MASK;
  538.         break;
  539.     default:
  540.         return -EINVAL;
  541.     }
  542.  
  543.     dac_vol = ((min_uV * r2 - 362500 * (r1 + r2)) / (12500 * (r1 + r2)));
  544.     if ((dac_vol > 0x1F) || (dac_vol < 0))
  545.         return -EINVAL;
  546.  
  547.     /* Set voltage */
  548.     if (volt_reg1 != 0) {
  549.         data = ltc_3589_reg_read(ltc, volt_reg1);
  550.         if (data < 0)
  551.             return data;
  552.  
  553.         data >>= shift;
  554.         data &= ~mask;
  555.         data |= dac_vol;
  556.         ltc_3589_reg_write(ltc, volt_reg1, data);
  557.     }
  558.  
  559.     if (volt_reg2 != 0) {
  560.         data = ltc_3589_reg_read(ltc, volt_reg2);
  561.         if (data < 0)
  562.             return data;
  563.  
  564.         data >>= shift;
  565.         data &= ~mask;
  566.         data |= dac_vol;
  567.         ltc_3589_reg_write(ltc, volt_reg2, data);
  568.     }
  569.  
  570.     /* Set slew config */
  571.     data = ltc_3589_reg_read(ltc, LTC3589_REG_VCCR);
  572.     if (data < 0)
  573.         return data;
  574.  
  575.     data &= ~(3 << (2 * dcdc));
  576.     data |= (slew_val << (2 * dcdc));
  577.  
  578.     ltc_3589_reg_write(ltc, LTC3589_REG_VCCR, data);
  579.  
  580.     data = ltc_3589_reg_read(ltc, LTC3589_REG_SCR2);
  581.     if (data < 0)
  582.         return data;
  583.  
  584.     data &= ~(1 << dcdc);
  585.     data |= (1 << dcdc);
  586.  
  587.     ltc_3589_reg_write(ltc, LTC3589_REG_SCR2, data);
  588.  
  589.     data = ltc_3589_reg_read(ltc, LTC3589_REG_OVEN);
  590.     if (data < 0)
  591.         return data;
  592.  
  593.     data &= ~(1 << dcdc);
  594.     data |= (1 << dcdc);
  595.  
  596.     ltc_3589_reg_write(ltc, LTC3589_REG_OVEN, data);
  597.  
  598.     mdelay(10);
  599.  
  600.     return 0;
  601. }
  602.  
  603. static int ltc3589_set_suspend_voltage(struct regulator_dev *dev,
  604.                            int uV)
  605. {
  606.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  607.     int dcdc = rdev_get_id(dev);
  608.     int volt_reg1;
  609.     int shift, mask;
  610.     int r1, r2;
  611.     int dac_vol, data;
  612.  
  613.     r1 = 0;
  614.     r2 = 1;
  615.     if (dcdc < LTC3589_DCDC_1 || dcdc > LTC3589_DCDC_3)
  616.         return -EINVAL;
  617.  
  618.     switch (dcdc) {
  619.     case LTC3589_DCDC_1:
  620.         r1 = LTC3589_SW1_R1;
  621.         r2 = LTC3589_SW1_R2;
  622.         volt_reg1 = LTC3589_REG_B1DTV2;
  623.         shift = LTC3589_B1DTV2_REG1_REF_INPUT_V2_SHIFT;
  624.         mask = LTC3589_B1DTV2_REG1_REF_INPUT_V2_MASK;
  625.         break;
  626.     case LTC3589_DCDC_2:
  627.         r1 = LTC3589_SW2_R1;
  628.         r2 = ltc3589_sw2_r2;
  629.         volt_reg1 = LTC3589_REG_B2DTV2;
  630.         shift = LTC3589_B2DTV2_REG2_REF_INPUT_V2_SHIFT;
  631.         mask = LTC3589_B2DTV2_REG2_REF_INPUT_V2_MASK;
  632.         break;
  633.     default:
  634.         return 0;
  635.     }
  636.  
  637.     dac_vol = ((uV * r2 - 362500 * (r1 + r2)) / (12500 * (r1 + r2)));
  638.     if ((dac_vol > 0x1F) || (dac_vol < 0))
  639.         return -EINVAL;
  640.  
  641.     data = ltc_3589_reg_read(ltc, volt_reg1);
  642.     if (data < 0)
  643.         return data;
  644.  
  645.     data >>= shift;
  646.     data &= ~mask;
  647.     data |= dac_vol;
  648.     ltc_3589_reg_write(ltc, volt_reg1, data);
  649.     return 0;
  650. }
  651.  
  652. static int ltc3589_set_suspend_enable(struct regulator_dev *rdev)
  653. {
  654.     return 0;
  655. }
  656.  
  657. static int ltc3589_set_suspend_disable(struct regulator_dev *rdev)
  658. {
  659.     return 0;
  660. }
  661.  
  662. static int ltc3589_set_suspend_mode(struct regulator_dev *rdev,
  663.     unsigned int mode)
  664. {
  665.     return 0;
  666. }
  667.  
  668. static int ltc3589_ldo_get_voltage(struct regulator_dev *dev)
  669. {
  670.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  671.     int data, ldo = rdev_get_id(dev);
  672.     int uV;
  673.  
  674.     if (ldo < LTC3589_LDO_1 || ldo > LTC3589_LDO_4)
  675.         return -EINVAL;
  676.  
  677.     if (ldo == LTC3589_LDO_1 || ldo == LTC3589_LDO_3)
  678.         return -EINVAL;
  679.  
  680.     if (ldo == LTC3589_LDO_4) {
  681.         data = ltc_3589_reg_read(ltc, LTC3589_REG_L2DTV2);
  682.         if (data < 0)
  683.             return data;
  684.  
  685.         data >>= LTC3589_L2DTV2_LDO4_OUTPUT_VOLTAGE_SHIFT;
  686.         data &= LTC3589_L2DTV2_LDO4_OUTPUT_VOLTAGE_MASK;
  687.         switch (data) {
  688.         case 0:
  689.             return 1800000;
  690.         case 1:
  691.             return 2500000;
  692.         case 2:
  693.             return 3000000;
  694.         case 3:
  695.             return 3300000;
  696.         default:
  697.             return -EINVAL;
  698.         }
  699.     } else {
  700.         data = ltc_3589_reg_read(ltc, LTC3589_REG_VCCR);
  701.         if (data < 0)
  702.             return data;
  703.  
  704.         if (data & LTC3589_VCCR_LDO2_REF_SELECT)
  705.             data = ltc_3589_reg_read(ltc, LTC3589_REG_L2DTV2);
  706.         else
  707.             data = ltc_3589_reg_read(ltc, LTC3589_REG_L2DTV1);
  708.  
  709.         if (data < 0)
  710.             return data;
  711.  
  712.         data >>= LTC3589_L2DTV2_LDO2_REF_INPUT_V2_SHIFT;
  713.         data &= LTC3589_L2DTV2_LDO2_REF_INPUT_V2_MASK;
  714.         uV = (((LTC3589_LDO2_R1 + ltc3589_ldo2_r2)
  715.             * (362500 + data * 12500)) / ltc3589_ldo2_r2);
  716.         return uV;
  717.     }
  718.  
  719.     return -EINVAL;
  720. }
  721.  
  722. static int ltc3589_ldo_set_voltage(struct regulator_dev *dev,
  723.                 int min_uV, int max_uV)
  724. {
  725.     struct ltc3589 *ltc = rdev_get_drvdata(dev);
  726.     int data, vsel, ldo = rdev_get_id(dev);
  727.  
  728.     if (ldo < LTC3589_LDO_1 || ldo > LTC3589_LDO_4)
  729.         return -EINVAL;
  730.  
  731.     if (ldo == LTC3589_LDO_1 || ldo == LTC3589_LDO_3)
  732.         return -EINVAL;
  733.  
  734.     if (ldo == LTC3589_LDO_4) {
  735.         for (vsel = 0; vsel < 4; vsel++) {
  736.             int mV = LDO4_VSEL_table[vsel];
  737.             int uV = mV * 1000;
  738.  
  739.             /* Break at the first in-range value */
  740.             if (min_uV <= uV && uV <= max_uV)
  741.                 break;
  742.         }
  743.  
  744.         if (vsel == 4)
  745.             return -EINVAL;
  746.  
  747.         data = ltc_3589_reg_read(ltc, LTC3589_REG_L2DTV2);
  748.         if (data < 0)
  749.             return data;
  750.  
  751.         data &= ~(0x3 << LTC3589_L2DTV2_LDO4_OUTPUT_VOLTAGE_SHIFT);
  752.         data |= (vsel << LTC3589_L2DTV2_LDO4_OUTPUT_VOLTAGE_SHIFT);
  753.         data &= ~(1 << LTC3589_L2DTV2_LDO4_CONTROL_MODE_SHIFT);
  754.         data |= (1 << LTC3589_L2DTV2_LDO4_CONTROL_MODE_SHIFT);
  755.         ltc_3589_reg_write(ltc, LTC3589_REG_L2DTV2, data);
  756.  
  757.  
  758.         data = ltc_3589_reg_read(ltc, LTC3589_REG_SCR2);
  759.         if (data < 0)
  760.             return data;
  761.  
  762.         data &= ~(1 << LTC3589_SCR2_LDO4_STARTUP_SHIFT);
  763.         data |= (1 << LTC3589_SCR2_LDO4_STARTUP_SHIFT);
  764.  
  765.         ltc_3589_reg_write(ltc, LTC3589_REG_SCR2, data);
  766.  
  767.         data = ltc_3589_reg_read(ltc, LTC3589_REG_OVEN);
  768.         if (data < 0)
  769.             return data;
  770.  
  771.         data &= ~(LTC3589_OVEN_EN_LDO4);
  772.         data |= LTC3589_OVEN_EN_LDO4;
  773.  
  774.         ltc_3589_reg_write(ltc, LTC3589_REG_OVEN, data);
  775.  
  776.         mdelay(10);
  777.     } else {
  778.         int dac_vol;
  779.  
  780.         dac_vol = ((min_uV * ltc3589_ldo2_r2 -
  781.                 362500 * (LTC3589_LDO2_R1 + ltc3589_ldo2_r2))
  782.                 / (12500 * (LTC3589_LDO2_R1 + ltc3589_ldo2_r2)));
  783.         if ((dac_vol > 0x1F) || (dac_vol < 0))
  784.             return -EINVAL;
  785.  
  786.         data = ltc_3589_reg_read(ltc, LTC3589_REG_L2DTV1);
  787.         if (data < 0)
  788.             return data;
  789.  
  790.         data &= ~LTC3589_L2DTV2_LDO2_REF_INPUT_V2_MASK;
  791.         data |= dac_vol;
  792.         ltc_3589_reg_write(ltc, LTC3589_REG_L2DTV1, data);
  793.  
  794.         /* Set slew config */
  795.         data = ltc_3589_reg_read(ltc, LTC3589_REG_VCCR);
  796.         if (data < 0)
  797.             return data;
  798.  
  799.         data &= ~(LTC3589_VCCR_LDO2_SLEW |
  800.               LTC3589_VCCR_LDO2_REF_SELECT);
  801.         data |= LTC3589_VCCR_LDO2_SLEW;
  802.  
  803.         ltc_3589_reg_write(ltc, LTC3589_REG_VCCR, data);
  804.  
  805.         data = ltc_3589_reg_read(ltc, LTC3589_REG_SCR2);
  806.         if (data < 0)
  807.             return data;
  808.  
  809.         data &= ~(1 << LTC3589_SCR2_LDO2_STARTUP_SHIFT);
  810.         data |= (1 << LTC3589_SCR2_LDO2_STARTUP_SHIFT);
  811.  
  812.         ltc_3589_reg_write(ltc, LTC3589_REG_SCR2, data);
  813.  
  814.         data = ltc_3589_reg_read(ltc, LTC3589_REG_OVEN);
  815.         if (data < 0)
  816.             return data;
  817.  
  818.         data &= ~(LTC3589_OVEN_EN_LDO2);
  819.         data |= (LTC3589_OVEN_EN_LDO2);
  820.  
  821.         ltc_3589_reg_write(ltc, LTC3589_REG_OVEN, data);
  822.  
  823.         mdelay(10);
  824.     }
  825.     return 0;
  826. }
  827.  
  828. static int ltc3589_ldo4_list_voltage(struct regulator_dev *dev,
  829.                     unsigned selector)
  830. {
  831.     int ldo = rdev_get_id(dev);
  832.  
  833.     if (ldo != LTC3589_LDO_4)
  834.         return -EINVAL;
  835.  
  836.     if (selector >= 4)
  837.         return -EINVAL;
  838.     else
  839.         return LDO4_VSEL_table[selector] * 1000;
  840. }
  841.  
  842. /* Operations permitted on SWx */
  843. static struct regulator_ops ltc3589_sw_ops = {
  844.     .is_enabled = ltc3589_dcdc_is_enabled,
  845.     .enable = ltc3589_dcdc_enable,
  846.     .disable = ltc3589_dcdc_disable,
  847.     .get_mode = ltc3589_dcdc_get_mode,
  848.     .set_mode = ltc3589_dcdc_set_mode,
  849.     .get_voltage = ltc3589_dcdc_get_voltage,
  850.     .set_voltage = ltc3589_dcdc_set_voltage,
  851.     .set_suspend_voltage = ltc3589_set_suspend_voltage,
  852.     .set_suspend_enable = ltc3589_set_suspend_enable,
  853.     .set_suspend_disable = ltc3589_set_suspend_disable,
  854.     .set_suspend_mode = ltc3589_set_suspend_mode,
  855. };
  856.  
  857. /* Operations permitted on SW4 Buck-Boost */
  858. static struct regulator_ops ltc3589_sw4_ops = {
  859.     .is_enabled = ltc3589_dcdc_is_enabled,
  860.     .enable = ltc3589_dcdc_enable,
  861.     .disable = ltc3589_dcdc_disable,
  862.     .get_mode = ltc3589_dcdc_get_mode,
  863.     .set_mode = ltc3589_dcdc_set_mode,
  864. };
  865.  
  866. /* Operations permitted on LDO1_STBY, LDO3 */
  867. static struct regulator_ops ltc3589_ldo13_ops = {
  868.     .is_enabled = ltc3589_ldo_is_enabled,
  869.     .enable = ltc3589_ldo_enable,
  870.     .disable = ltc3589_ldo_disable,
  871. };
  872.  
  873. /* Operations permitted on LDO2 */
  874. static struct regulator_ops ltc3589_ldo2_ops = {
  875.     .is_enabled = ltc3589_ldo_is_enabled,
  876.     .enable = ltc3589_ldo_enable,
  877.     .disable = ltc3589_ldo_disable,
  878.     .get_voltage = ltc3589_ldo_get_voltage,
  879.     .set_voltage = ltc3589_ldo_set_voltage,
  880. };
  881.  
  882. /* Operations permitted on LDO4 */
  883. static struct regulator_ops ltc3589_ldo4_ops = {
  884.     .is_enabled = ltc3589_ldo_is_enabled,
  885.     .enable = ltc3589_ldo_enable,
  886.     .disable = ltc3589_ldo_disable,
  887.     .get_voltage = ltc3589_ldo_get_voltage,
  888.     .set_voltage = ltc3589_ldo_set_voltage,
  889.     .list_voltage = ltc3589_ldo4_list_voltage,
  890. };
  891.  
  892. static struct regulator_desc ltc3589_reg[] = {
  893.     {
  894.         .name = "SW1",
  895.         .id = LTC3589_SW1,
  896.         .ops = &ltc3589_sw_ops,
  897.         .type = REGULATOR_VOLTAGE,
  898.         .n_voltages = 0x1F + 1,
  899.         .owner = THIS_MODULE,
  900.     },
  901.     {
  902.         .name = "SW2",
  903.         .id = LTC3589_SW2,
  904.         .ops = &ltc3589_sw_ops,
  905.         .type = REGULATOR_VOLTAGE,
  906.         .n_voltages = 0x1F + 1,
  907.         .owner = THIS_MODULE,
  908.     },
  909.     {
  910.         .name = "SW3",
  911.         .id = LTC3589_SW3,
  912.         .ops = &ltc3589_sw_ops,
  913.         .type = REGULATOR_VOLTAGE,
  914.         .n_voltages = 0x1F + 1,
  915.         .owner = THIS_MODULE,
  916.     },
  917.     {
  918.         .name = "SW4",
  919.         .id = LTC3589_SW4,
  920.         .ops = &ltc3589_sw4_ops,
  921.         .type = REGULATOR_VOLTAGE,
  922.         .owner = THIS_MODULE,
  923.     },
  924.     {
  925.         .name = "LDO1_STBY",
  926.         .id = LTC3589_LDO1,
  927.         .ops = &ltc3589_ldo13_ops,
  928.         .type = REGULATOR_VOLTAGE,
  929.         .owner = THIS_MODULE,
  930.     },
  931.     {
  932.         .name = "LDO2",
  933.         .id = LTC3589_LDO2,
  934.         .ops = &ltc3589_ldo2_ops,
  935.         .type = REGULATOR_VOLTAGE,
  936.         .n_voltages = 0x1F + 1,
  937.         .owner = THIS_MODULE,
  938.     },
  939.     {
  940.         .name = "LDO3",
  941.         .id = LTC3589_LDO3,
  942.         .ops = &ltc3589_ldo13_ops,
  943.         .type = REGULATOR_VOLTAGE,
  944.         .owner = THIS_MODULE,
  945.     },
  946.     {
  947.         .name = "LDO4",
  948.         .id = LTC3589_LDO4,
  949.         .ops = &ltc3589_ldo4_ops,
  950.         .type = REGULATOR_VOLTAGE,
  951.         .n_voltages = ARRAY_SIZE(LDO4_VSEL_table),
  952.         .owner = THIS_MODULE,
  953.     },
  954. };
  955.  
  956. static int ltc3589_regulator_probe(struct platform_device *pdev)
  957. {
  958.     struct regulator_dev *rdev;
  959.  
  960.     if (pdev->id < LTC3589_DCDC_1 || pdev->id > LTC3589_LDO4)
  961.         return -ENODEV;
  962.  
  963.     if (cpu_is_mx53_rev(CHIP_REV_2_0) >= 1) {
  964.         ltc3589_ldo2_r2 = LTC3589_LDO2_R2_TO2;
  965.         ltc3589_sw2_r2 = LTC3589_SW2_R2_TO2;
  966.     } else {
  967.         ltc3589_ldo2_r2 = LTC3589_LDO2_R2_TO1;
  968.         ltc3589_sw2_r2 = LTC3589_SW2_R2_TO1;
  969.     }
  970.  
  971.     /* register regulator */
  972.     rdev = regulator_register(&ltc3589_reg[pdev->id], &pdev->dev,
  973.                   pdev->dev.platform_data,
  974.                   dev_get_drvdata(&pdev->dev));
  975.         if (IS_ERR(rdev)) {
  976.             dev_err(&pdev->dev, "failed to register %s\n",
  977.             ltc3589_reg[pdev->id].name);
  978.             return PTR_ERR(rdev);
  979.         }
  980.  
  981.     ltc3589_set_slew_rate(rdev, LTC3589_VRRCR_SLEW_RATE_7P00MV_US);
  982.  
  983.     return 0;
  984. }
  985.  
  986. static int ltc3589_regulator_remove(struct platform_device *pdev)
  987. {
  988.     struct regulator_dev *rdev = platform_get_drvdata(pdev);
  989.  
  990.     regulator_unregister(rdev);
  991.  
  992.     return 0;
  993. }
  994.  
  995. int ltc3589_register_regulator(struct ltc3589 *ltc3589, int reg,
  996.                   struct regulator_init_data *initdata)
  997. {
  998.     struct platform_device *pdev;
  999.     int ret;
  1000.  
  1001.     if (ltc3589->pmic.pdev[reg])
  1002.         return -EBUSY;
  1003.     if (reg < LTC3589_DCDC_1 || reg > LTC3589_LDO_4)
  1004.         return -ENODEV;
  1005.     pdev = platform_device_alloc("ltc3589-regulator", reg);
  1006.     if (!pdev)
  1007.         return -ENOMEM;
  1008.     ltc3589->pmic.pdev[reg] = pdev;
  1009.  
  1010.     initdata->driver_data = ltc3589;
  1011.  
  1012.     pdev->dev.platform_data = initdata;
  1013.     pdev->dev.parent = ltc3589->dev;
  1014.     platform_set_drvdata(pdev, ltc3589);
  1015.  
  1016.     ret = platform_device_add(pdev);
  1017.  
  1018.     if (ret != 0) {
  1019.         dev_err(ltc3589->dev, "Failed to register regulator %d: %d\n",
  1020.             reg, ret);
  1021.         platform_device_del(pdev);
  1022.         ltc3589->pmic.pdev[reg] = NULL;
  1023.     }
  1024.  
  1025.     return ret;
  1026. }
  1027. EXPORT_SYMBOL_GPL(ltc3589_register_regulator);
  1028.  
  1029. static struct platform_driver ltc3589_regulator_driver = {
  1030.     .driver = {
  1031.            .name = "ltc3589-regulator",
  1032.     },
  1033.     .probe = ltc3589_regulator_probe,
  1034.     .remove = ltc3589_regulator_remove,
  1035. };
  1036.  
  1037. static int __init ltc3589_regulator_init(void)
  1038. {
  1039.     return platform_driver_register(&ltc3589_regulator_driver);
  1040.  
  1041. }
  1042. subsys_initcall_sync(ltc3589_regulator_init);
  1043.  
  1044. static void __exit ltc3589_regulator_exit(void)
  1045. {
  1046.     platform_driver_unregister(&ltc3589_regulator_driver);
  1047. }
  1048. module_exit(ltc3589_regulator_exit);
  1049.  
  1050. MODULE_AUTHOR("Freescale Semiconductor, Inc.");
  1051. MODULE_DESCRIPTION("LTC3589 Regulator driver");
  1052. MODULE_LICENSE("GPL");
  1053.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!