1a1a503a8SSean Wang // SPDX-License-Identifier: GPL-2.0 2a1a503a8SSean Wang /* 3a1a503a8SSean Wang * Copyright (C) 2018 MediaTek Inc. 4a1a503a8SSean Wang * 5a1a503a8SSean Wang * Author: Sean Wang <sean.wang@mediatek.com> 6a1a503a8SSean Wang * 7a1a503a8SSean Wang */ 8a1a503a8SSean Wang 9cafe19dbSLight Hsieh #include <dt-bindings/pinctrl/mt65xx.h> 10a1a503a8SSean Wang #include <linux/device.h> 11a1a503a8SSean Wang #include <linux/err.h> 1222d7fe49SLinus Walleij #include <linux/gpio/driver.h> 1389132dd8SSean Wang #include <linux/platform_device.h> 14a1a503a8SSean Wang #include <linux/io.h> 158174a851SLight Hsieh #include <linux/module.h> 1689132dd8SSean Wang #include <linux/of_irq.h> 17a1a503a8SSean Wang 1889132dd8SSean Wang #include "mtk-eint.h" 19a1a503a8SSean Wang #include "pinctrl-mtk-common-v2.h" 20a1a503a8SSean Wang 21c2832197SSean Wang /** 22c2832197SSean Wang * struct mtk_drive_desc - the structure that holds the information 23c2832197SSean Wang * of the driving current 24c2832197SSean Wang * @min: the minimum current of this group 25c2832197SSean Wang * @max: the maximum current of this group 26c2832197SSean Wang * @step: the step current of this group 27c2832197SSean Wang * @scal: the weight factor 28c2832197SSean Wang * 29c2832197SSean Wang * formula: output = ((input) / step - 1) * scal 30c2832197SSean Wang */ 31c2832197SSean Wang struct mtk_drive_desc { 32c2832197SSean Wang u8 min; 33c2832197SSean Wang u8 max; 34c2832197SSean Wang u8 step; 35c2832197SSean Wang u8 scal; 36c2832197SSean Wang }; 37c2832197SSean Wang 38c2832197SSean Wang /* The groups of drive strength */ 3907c6b037SWei Yongjun static const struct mtk_drive_desc mtk_drive[] = { 40c2832197SSean Wang [DRV_GRP0] = { 4, 16, 4, 1 }, 41c2832197SSean Wang [DRV_GRP1] = { 4, 16, 4, 2 }, 42c2832197SSean Wang [DRV_GRP2] = { 2, 8, 2, 1 }, 43c2832197SSean Wang [DRV_GRP3] = { 2, 8, 2, 2 }, 44c2832197SSean Wang [DRV_GRP4] = { 2, 16, 2, 1 }, 45c2832197SSean Wang }; 46c2832197SSean Wang 472bc47dfeSSean Wang static void mtk_w32(struct mtk_pinctrl *pctl, u8 i, u32 reg, u32 val) 48a1a503a8SSean Wang { 492bc47dfeSSean Wang writel_relaxed(val, pctl->base[i] + reg); 50a1a503a8SSean Wang } 51a1a503a8SSean Wang 522bc47dfeSSean Wang static u32 mtk_r32(struct mtk_pinctrl *pctl, u8 i, u32 reg) 53a1a503a8SSean Wang { 542bc47dfeSSean Wang return readl_relaxed(pctl->base[i] + reg); 55a1a503a8SSean Wang } 56a1a503a8SSean Wang 572bc47dfeSSean Wang void mtk_rmw(struct mtk_pinctrl *pctl, u8 i, u32 reg, u32 mask, u32 set) 58a1a503a8SSean Wang { 59a1a503a8SSean Wang u32 val; 60a1a503a8SSean Wang 612bc47dfeSSean Wang val = mtk_r32(pctl, i, reg); 62a1a503a8SSean Wang val &= ~mask; 63a1a503a8SSean Wang val |= set; 642bc47dfeSSean Wang mtk_w32(pctl, i, reg, val); 65a1a503a8SSean Wang } 66a1a503a8SSean Wang 67ea051eb3SSean Wang static int mtk_hw_pin_field_lookup(struct mtk_pinctrl *hw, 68ea051eb3SSean Wang const struct mtk_pin_desc *desc, 699d9b171cSSean Wang int field, struct mtk_pin_field *pfd) 70a1a503a8SSean Wang { 7186ecb7d6SYueHaibing const struct mtk_pin_field_calc *c; 729d9b171cSSean Wang const struct mtk_pin_reg_calc *rc; 733de7deefSLight Hsieh int start = 0, end, check; 743de7deefSLight Hsieh bool found = false; 75a1a503a8SSean Wang u32 bits; 76a1a503a8SSean Wang 779d9b171cSSean Wang if (hw->soc->reg_cal && hw->soc->reg_cal[field].range) { 789d9b171cSSean Wang rc = &hw->soc->reg_cal[field]; 799d9b171cSSean Wang } else { 809d9b171cSSean Wang dev_dbg(hw->dev, 813de7deefSLight Hsieh "Not support field %d for this soc\n", field); 829d9b171cSSean Wang return -ENOTSUPP; 839d9b171cSSean Wang } 849d9b171cSSean Wang 853de7deefSLight Hsieh end = rc->nranges - 1; 86a1a503a8SSean Wang 873de7deefSLight Hsieh while (start <= end) { 883de7deefSLight Hsieh check = (start + end) >> 1; 893de7deefSLight Hsieh if (desc->number >= rc->range[check].s_pin 903de7deefSLight Hsieh && desc->number <= rc->range[check].e_pin) { 913de7deefSLight Hsieh found = true; 92a1a503a8SSean Wang break; 933de7deefSLight Hsieh } else if (start == end) 943de7deefSLight Hsieh break; 953de7deefSLight Hsieh else if (desc->number < rc->range[check].s_pin) 963de7deefSLight Hsieh end = check - 1; 973de7deefSLight Hsieh else 983de7deefSLight Hsieh start = check + 1; 99a1a503a8SSean Wang } 100a1a503a8SSean Wang 1013de7deefSLight Hsieh if (!found) { 1029d9b171cSSean Wang dev_dbg(hw->dev, "Not support field %d for pin = %d (%s)\n", 1039d9b171cSSean Wang field, desc->number, desc->name); 1049d9b171cSSean Wang return -ENOTSUPP; 105a1a503a8SSean Wang } 106a1a503a8SSean Wang 1073de7deefSLight Hsieh c = rc->range + check; 1083de7deefSLight Hsieh 1092bc47dfeSSean Wang if (c->i_base > hw->nbase - 1) { 1109d9b171cSSean Wang dev_err(hw->dev, 1119d9b171cSSean Wang "Invalid base for field %d for pin = %d (%s)\n", 1129d9b171cSSean Wang field, desc->number, desc->name); 1132bc47dfeSSean Wang return -EINVAL; 1142bc47dfeSSean Wang } 1152bc47dfeSSean Wang 116b906faf7SSean Wang /* Calculated bits as the overall offset the pin is located at, 117b906faf7SSean Wang * if c->fixed is held, that determines the all the pins in the 118b906faf7SSean Wang * range use the same field with the s_pin. 119b906faf7SSean Wang */ 120ea051eb3SSean Wang bits = c->fixed ? c->s_bit : c->s_bit + 121ea051eb3SSean Wang (desc->number - c->s_pin) * (c->x_bits); 122a1a503a8SSean Wang 123b906faf7SSean Wang /* Fill pfd from bits. For example 32-bit register applied is assumed 124b906faf7SSean Wang * when c->sz_reg is equal to 32. 125b906faf7SSean Wang */ 1262bc47dfeSSean Wang pfd->index = c->i_base; 127b906faf7SSean Wang pfd->offset = c->s_addr + c->x_addrs * (bits / c->sz_reg); 128b906faf7SSean Wang pfd->bitpos = bits % c->sz_reg; 129a1a503a8SSean Wang pfd->mask = (1 << c->x_bits) - 1; 130a1a503a8SSean Wang 131a1a503a8SSean Wang /* pfd->next is used for indicating that bit wrapping-around happens 132a1a503a8SSean Wang * which requires the manipulation for bit 0 starting in the next 133a1a503a8SSean Wang * register to form the complete field read/write. 134a1a503a8SSean Wang */ 135b906faf7SSean Wang pfd->next = pfd->bitpos + c->x_bits > c->sz_reg ? c->x_addrs : 0; 136a1a503a8SSean Wang 137a1a503a8SSean Wang return 0; 138a1a503a8SSean Wang } 139a1a503a8SSean Wang 140ea051eb3SSean Wang static int mtk_hw_pin_field_get(struct mtk_pinctrl *hw, 141ea051eb3SSean Wang const struct mtk_pin_desc *desc, 142a1a503a8SSean Wang int field, struct mtk_pin_field *pfd) 143a1a503a8SSean Wang { 144a1a503a8SSean Wang if (field < 0 || field >= PINCTRL_PIN_REG_MAX) { 145a1a503a8SSean Wang dev_err(hw->dev, "Invalid Field %d\n", field); 146a1a503a8SSean Wang return -EINVAL; 147a1a503a8SSean Wang } 148a1a503a8SSean Wang 1499d9b171cSSean Wang return mtk_hw_pin_field_lookup(hw, desc, field, pfd); 150a1a503a8SSean Wang } 151a1a503a8SSean Wang 152a1a503a8SSean Wang static void mtk_hw_bits_part(struct mtk_pin_field *pf, int *h, int *l) 153a1a503a8SSean Wang { 154a1a503a8SSean Wang *l = 32 - pf->bitpos; 155a1a503a8SSean Wang *h = get_count_order(pf->mask) - *l; 156a1a503a8SSean Wang } 157a1a503a8SSean Wang 158a1a503a8SSean Wang static void mtk_hw_write_cross_field(struct mtk_pinctrl *hw, 159a1a503a8SSean Wang struct mtk_pin_field *pf, int value) 160a1a503a8SSean Wang { 161a1a503a8SSean Wang int nbits_l, nbits_h; 162a1a503a8SSean Wang 163a1a503a8SSean Wang mtk_hw_bits_part(pf, &nbits_h, &nbits_l); 164a1a503a8SSean Wang 1652bc47dfeSSean Wang mtk_rmw(hw, pf->index, pf->offset, pf->mask << pf->bitpos, 166a1a503a8SSean Wang (value & pf->mask) << pf->bitpos); 167a1a503a8SSean Wang 1682bc47dfeSSean Wang mtk_rmw(hw, pf->index, pf->offset + pf->next, BIT(nbits_h) - 1, 169a1a503a8SSean Wang (value & pf->mask) >> nbits_l); 170a1a503a8SSean Wang } 171a1a503a8SSean Wang 172a1a503a8SSean Wang static void mtk_hw_read_cross_field(struct mtk_pinctrl *hw, 173a1a503a8SSean Wang struct mtk_pin_field *pf, int *value) 174a1a503a8SSean Wang { 175a1a503a8SSean Wang int nbits_l, nbits_h, h, l; 176a1a503a8SSean Wang 177a1a503a8SSean Wang mtk_hw_bits_part(pf, &nbits_h, &nbits_l); 178a1a503a8SSean Wang 1792bc47dfeSSean Wang l = (mtk_r32(hw, pf->index, pf->offset) 1802bc47dfeSSean Wang >> pf->bitpos) & (BIT(nbits_l) - 1); 1812bc47dfeSSean Wang h = (mtk_r32(hw, pf->index, pf->offset + pf->next)) 1822bc47dfeSSean Wang & (BIT(nbits_h) - 1); 183a1a503a8SSean Wang 184a1a503a8SSean Wang *value = (h << nbits_l) | l; 185a1a503a8SSean Wang } 186a1a503a8SSean Wang 187ea051eb3SSean Wang int mtk_hw_set_value(struct mtk_pinctrl *hw, const struct mtk_pin_desc *desc, 188ea051eb3SSean Wang int field, int value) 189a1a503a8SSean Wang { 190a1a503a8SSean Wang struct mtk_pin_field pf; 191a1a503a8SSean Wang int err; 192a1a503a8SSean Wang 193ea051eb3SSean Wang err = mtk_hw_pin_field_get(hw, desc, field, &pf); 194a1a503a8SSean Wang if (err) 195a1a503a8SSean Wang return err; 196a1a503a8SSean Wang 1973de7deefSLight Hsieh if (value < 0 || value > pf.mask) 1983de7deefSLight Hsieh return -EINVAL; 1993de7deefSLight Hsieh 200a1a503a8SSean Wang if (!pf.next) 2012bc47dfeSSean Wang mtk_rmw(hw, pf.index, pf.offset, pf.mask << pf.bitpos, 202a1a503a8SSean Wang (value & pf.mask) << pf.bitpos); 203a1a503a8SSean Wang else 204a1a503a8SSean Wang mtk_hw_write_cross_field(hw, &pf, value); 205a1a503a8SSean Wang 206a1a503a8SSean Wang return 0; 207a1a503a8SSean Wang } 2088174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_hw_set_value); 209a1a503a8SSean Wang 210ea051eb3SSean Wang int mtk_hw_get_value(struct mtk_pinctrl *hw, const struct mtk_pin_desc *desc, 211ea051eb3SSean Wang int field, int *value) 212a1a503a8SSean Wang { 213a1a503a8SSean Wang struct mtk_pin_field pf; 214a1a503a8SSean Wang int err; 215a1a503a8SSean Wang 216ea051eb3SSean Wang err = mtk_hw_pin_field_get(hw, desc, field, &pf); 217a1a503a8SSean Wang if (err) 218a1a503a8SSean Wang return err; 219a1a503a8SSean Wang 220a1a503a8SSean Wang if (!pf.next) 2212bc47dfeSSean Wang *value = (mtk_r32(hw, pf.index, pf.offset) 2222bc47dfeSSean Wang >> pf.bitpos) & pf.mask; 223a1a503a8SSean Wang else 224a1a503a8SSean Wang mtk_hw_read_cross_field(hw, &pf, value); 225a1a503a8SSean Wang 226a1a503a8SSean Wang return 0; 227a1a503a8SSean Wang } 2288174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_hw_get_value); 229c2832197SSean Wang 23089132dd8SSean Wang static int mtk_xt_find_eint_num(struct mtk_pinctrl *hw, unsigned long eint_n) 23189132dd8SSean Wang { 23289132dd8SSean Wang const struct mtk_pin_desc *desc; 23389132dd8SSean Wang int i = 0; 23489132dd8SSean Wang 23589132dd8SSean Wang desc = (const struct mtk_pin_desc *)hw->soc->pins; 23689132dd8SSean Wang 23789132dd8SSean Wang while (i < hw->soc->npins) { 23889132dd8SSean Wang if (desc[i].eint.eint_n == eint_n) 23989132dd8SSean Wang return desc[i].number; 24089132dd8SSean Wang i++; 24189132dd8SSean Wang } 24289132dd8SSean Wang 24389132dd8SSean Wang return EINT_NA; 24489132dd8SSean Wang } 24589132dd8SSean Wang 246edd54646SHanks Chen /* 247edd54646SHanks Chen * Virtual GPIO only used inside SOC and not being exported to outside SOC. 248edd54646SHanks Chen * Some modules use virtual GPIO as eint (e.g. pmif or usb). 249edd54646SHanks Chen * In MTK platform, external interrupt (EINT) and GPIO is 1-1 mapping 250edd54646SHanks Chen * and we can set GPIO as eint. 251edd54646SHanks Chen * But some modules use specific eint which doesn't have real GPIO pin. 252edd54646SHanks Chen * So we use virtual GPIO to map it. 253edd54646SHanks Chen */ 254edd54646SHanks Chen 255edd54646SHanks Chen bool mtk_is_virt_gpio(struct mtk_pinctrl *hw, unsigned int gpio_n) 256edd54646SHanks Chen { 257edd54646SHanks Chen const struct mtk_pin_desc *desc; 258edd54646SHanks Chen bool virt_gpio = false; 259edd54646SHanks Chen 260edd54646SHanks Chen desc = (const struct mtk_pin_desc *)&hw->soc->pins[gpio_n]; 261edd54646SHanks Chen 262edd54646SHanks Chen if (desc->funcs && !desc->funcs[desc->eint.eint_m].name) 263edd54646SHanks Chen virt_gpio = true; 264edd54646SHanks Chen 265edd54646SHanks Chen return virt_gpio; 266edd54646SHanks Chen } 267*047cd9a6SRandy Dunlap EXPORT_SYMBOL_GPL(mtk_is_virt_gpio); 268edd54646SHanks Chen 26989132dd8SSean Wang static int mtk_xt_get_gpio_n(void *data, unsigned long eint_n, 27089132dd8SSean Wang unsigned int *gpio_n, 27189132dd8SSean Wang struct gpio_chip **gpio_chip) 27289132dd8SSean Wang { 27389132dd8SSean Wang struct mtk_pinctrl *hw = (struct mtk_pinctrl *)data; 27489132dd8SSean Wang const struct mtk_pin_desc *desc; 27589132dd8SSean Wang 27689132dd8SSean Wang desc = (const struct mtk_pin_desc *)hw->soc->pins; 27789132dd8SSean Wang *gpio_chip = &hw->chip; 27889132dd8SSean Wang 27989132dd8SSean Wang /* Be greedy to guess first gpio_n is equal to eint_n */ 28089132dd8SSean Wang if (desc[eint_n].eint.eint_n == eint_n) 28189132dd8SSean Wang *gpio_n = eint_n; 28289132dd8SSean Wang else 28389132dd8SSean Wang *gpio_n = mtk_xt_find_eint_num(hw, eint_n); 28489132dd8SSean Wang 28589132dd8SSean Wang return *gpio_n == EINT_NA ? -EINVAL : 0; 28689132dd8SSean Wang } 28789132dd8SSean Wang 28889132dd8SSean Wang static int mtk_xt_get_gpio_state(void *data, unsigned long eint_n) 28989132dd8SSean Wang { 29089132dd8SSean Wang struct mtk_pinctrl *hw = (struct mtk_pinctrl *)data; 29189132dd8SSean Wang const struct mtk_pin_desc *desc; 29289132dd8SSean Wang struct gpio_chip *gpio_chip; 29389132dd8SSean Wang unsigned int gpio_n; 29489132dd8SSean Wang int value, err; 29589132dd8SSean Wang 29689132dd8SSean Wang err = mtk_xt_get_gpio_n(hw, eint_n, &gpio_n, &gpio_chip); 29789132dd8SSean Wang if (err) 29889132dd8SSean Wang return err; 29989132dd8SSean Wang 30089132dd8SSean Wang desc = (const struct mtk_pin_desc *)&hw->soc->pins[gpio_n]; 30189132dd8SSean Wang 30289132dd8SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DI, &value); 30389132dd8SSean Wang if (err) 30489132dd8SSean Wang return err; 30589132dd8SSean Wang 30689132dd8SSean Wang return !!value; 30789132dd8SSean Wang } 30889132dd8SSean Wang 30989132dd8SSean Wang static int mtk_xt_set_gpio_as_eint(void *data, unsigned long eint_n) 31089132dd8SSean Wang { 31189132dd8SSean Wang struct mtk_pinctrl *hw = (struct mtk_pinctrl *)data; 31289132dd8SSean Wang const struct mtk_pin_desc *desc; 31389132dd8SSean Wang struct gpio_chip *gpio_chip; 31489132dd8SSean Wang unsigned int gpio_n; 31589132dd8SSean Wang int err; 31689132dd8SSean Wang 31789132dd8SSean Wang err = mtk_xt_get_gpio_n(hw, eint_n, &gpio_n, &gpio_chip); 31889132dd8SSean Wang if (err) 31989132dd8SSean Wang return err; 32089132dd8SSean Wang 321edd54646SHanks Chen if (mtk_is_virt_gpio(hw, gpio_n)) 322edd54646SHanks Chen return 0; 323edd54646SHanks Chen 32489132dd8SSean Wang desc = (const struct mtk_pin_desc *)&hw->soc->pins[gpio_n]; 32589132dd8SSean Wang 32689132dd8SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_MODE, 32789132dd8SSean Wang desc->eint.eint_m); 32889132dd8SSean Wang if (err) 32989132dd8SSean Wang return err; 33089132dd8SSean Wang 33189132dd8SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DIR, MTK_INPUT); 33289132dd8SSean Wang if (err) 33389132dd8SSean Wang return err; 33489132dd8SSean Wang 33589132dd8SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_SMT, MTK_ENABLE); 3366e737a4eSchuanjia.liu /* SMT is supposed to be supported by every real GPIO and doesn't 3376e737a4eSchuanjia.liu * support virtual GPIOs, so the extra condition err != -ENOTSUPP 3386e737a4eSchuanjia.liu * is just for adding EINT support to these virtual GPIOs. It should 3396e737a4eSchuanjia.liu * add an extra flag in the pin descriptor when more pins with 3406e737a4eSchuanjia.liu * distinctive characteristic come out. 3416e737a4eSchuanjia.liu */ 3426e737a4eSchuanjia.liu if (err && err != -ENOTSUPP) 34389132dd8SSean Wang return err; 34489132dd8SSean Wang 34589132dd8SSean Wang return 0; 34689132dd8SSean Wang } 34789132dd8SSean Wang 34889132dd8SSean Wang static const struct mtk_eint_xt mtk_eint_xt = { 34989132dd8SSean Wang .get_gpio_n = mtk_xt_get_gpio_n, 35089132dd8SSean Wang .get_gpio_state = mtk_xt_get_gpio_state, 35189132dd8SSean Wang .set_gpio_as_eint = mtk_xt_set_gpio_as_eint, 35289132dd8SSean Wang }; 35389132dd8SSean Wang 35489132dd8SSean Wang int mtk_build_eint(struct mtk_pinctrl *hw, struct platform_device *pdev) 35589132dd8SSean Wang { 35689132dd8SSean Wang struct device_node *np = pdev->dev.of_node; 35789132dd8SSean Wang struct resource *res; 35889132dd8SSean Wang 35989132dd8SSean Wang if (!IS_ENABLED(CONFIG_EINT_MTK)) 36089132dd8SSean Wang return 0; 36189132dd8SSean Wang 36289132dd8SSean Wang if (!of_property_read_bool(np, "interrupt-controller")) 36389132dd8SSean Wang return -ENODEV; 36489132dd8SSean Wang 36589132dd8SSean Wang hw->eint = devm_kzalloc(hw->dev, sizeof(*hw->eint), GFP_KERNEL); 36689132dd8SSean Wang if (!hw->eint) 36789132dd8SSean Wang return -ENOMEM; 36889132dd8SSean Wang 36989132dd8SSean Wang res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "eint"); 37089132dd8SSean Wang if (!res) { 37189132dd8SSean Wang dev_err(&pdev->dev, "Unable to get eint resource\n"); 37289132dd8SSean Wang return -ENODEV; 37389132dd8SSean Wang } 37489132dd8SSean Wang 37589132dd8SSean Wang hw->eint->base = devm_ioremap_resource(&pdev->dev, res); 37689132dd8SSean Wang if (IS_ERR(hw->eint->base)) 37789132dd8SSean Wang return PTR_ERR(hw->eint->base); 37889132dd8SSean Wang 37989132dd8SSean Wang hw->eint->irq = irq_of_parse_and_map(np, 0); 38089132dd8SSean Wang if (!hw->eint->irq) 38189132dd8SSean Wang return -EINVAL; 38289132dd8SSean Wang 38389132dd8SSean Wang if (!hw->soc->eint_hw) 38489132dd8SSean Wang return -ENODEV; 38589132dd8SSean Wang 38689132dd8SSean Wang hw->eint->dev = &pdev->dev; 38789132dd8SSean Wang hw->eint->hw = hw->soc->eint_hw; 38889132dd8SSean Wang hw->eint->pctl = hw; 38989132dd8SSean Wang hw->eint->gpio_xlate = &mtk_eint_xt; 39089132dd8SSean Wang 39189132dd8SSean Wang return mtk_eint_do_init(hw->eint); 39289132dd8SSean Wang } 3938174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_build_eint); 39489132dd8SSean Wang 3959afc305bSSean Wang /* Revision 0 */ 39685430152SSean Wang int mtk_pinconf_bias_disable_set(struct mtk_pinctrl *hw, 39785430152SSean Wang const struct mtk_pin_desc *desc) 39885430152SSean Wang { 39985430152SSean Wang int err; 40085430152SSean Wang 401ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PU, 40285430152SSean Wang MTK_DISABLE); 40385430152SSean Wang if (err) 40485430152SSean Wang return err; 40585430152SSean Wang 406ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PD, 40785430152SSean Wang MTK_DISABLE); 40885430152SSean Wang if (err) 40985430152SSean Wang return err; 41085430152SSean Wang 41185430152SSean Wang return 0; 41285430152SSean Wang } 4138174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_disable_set); 41485430152SSean Wang 41585430152SSean Wang int mtk_pinconf_bias_disable_get(struct mtk_pinctrl *hw, 41685430152SSean Wang const struct mtk_pin_desc *desc, int *res) 41785430152SSean Wang { 41885430152SSean Wang int v, v2; 41985430152SSean Wang int err; 42085430152SSean Wang 421ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PU, &v); 42285430152SSean Wang if (err) 42385430152SSean Wang return err; 42485430152SSean Wang 425ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PD, &v2); 42685430152SSean Wang if (err) 42785430152SSean Wang return err; 42885430152SSean Wang 42985430152SSean Wang if (v == MTK_ENABLE || v2 == MTK_ENABLE) 43085430152SSean Wang return -EINVAL; 43185430152SSean Wang 43285430152SSean Wang *res = 1; 43385430152SSean Wang 43485430152SSean Wang return 0; 43585430152SSean Wang } 4368174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_disable_get); 43785430152SSean Wang 43885430152SSean Wang int mtk_pinconf_bias_set(struct mtk_pinctrl *hw, 43985430152SSean Wang const struct mtk_pin_desc *desc, bool pullup) 44085430152SSean Wang { 44185430152SSean Wang int err, arg; 44285430152SSean Wang 44385430152SSean Wang arg = pullup ? 1 : 2; 44485430152SSean Wang 445ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PU, arg & 1); 44685430152SSean Wang if (err) 44785430152SSean Wang return err; 44885430152SSean Wang 449ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PD, 45085430152SSean Wang !!(arg & 2)); 45185430152SSean Wang if (err) 45285430152SSean Wang return err; 45385430152SSean Wang 45485430152SSean Wang return 0; 45585430152SSean Wang } 4568174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_set); 45785430152SSean Wang 45885430152SSean Wang int mtk_pinconf_bias_get(struct mtk_pinctrl *hw, 45985430152SSean Wang const struct mtk_pin_desc *desc, bool pullup, int *res) 46085430152SSean Wang { 46185430152SSean Wang int reg, err, v; 46285430152SSean Wang 46385430152SSean Wang reg = pullup ? PINCTRL_PIN_REG_PU : PINCTRL_PIN_REG_PD; 46485430152SSean Wang 465ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, reg, &v); 46685430152SSean Wang if (err) 46785430152SSean Wang return err; 46885430152SSean Wang 46985430152SSean Wang if (!v) 47085430152SSean Wang return -EINVAL; 47185430152SSean Wang 47285430152SSean Wang *res = 1; 47385430152SSean Wang 47485430152SSean Wang return 0; 47585430152SSean Wang } 4768174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_get); 47785430152SSean Wang 4789afc305bSSean Wang /* Revision 1 */ 4799afc305bSSean Wang int mtk_pinconf_bias_disable_set_rev1(struct mtk_pinctrl *hw, 4809afc305bSSean Wang const struct mtk_pin_desc *desc) 4819afc305bSSean Wang { 4829afc305bSSean Wang int err; 4839afc305bSSean Wang 484ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PULLEN, 4859afc305bSSean Wang MTK_DISABLE); 4869afc305bSSean Wang if (err) 4879afc305bSSean Wang return err; 4889afc305bSSean Wang 4899afc305bSSean Wang return 0; 4909afc305bSSean Wang } 4918174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_disable_set_rev1); 4929afc305bSSean Wang 4939afc305bSSean Wang int mtk_pinconf_bias_disable_get_rev1(struct mtk_pinctrl *hw, 4949afc305bSSean Wang const struct mtk_pin_desc *desc, int *res) 4959afc305bSSean Wang { 4969afc305bSSean Wang int v, err; 4979afc305bSSean Wang 498ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PULLEN, &v); 4999afc305bSSean Wang if (err) 5009afc305bSSean Wang return err; 5019afc305bSSean Wang 5029afc305bSSean Wang if (v == MTK_ENABLE) 5039afc305bSSean Wang return -EINVAL; 5049afc305bSSean Wang 5059afc305bSSean Wang *res = 1; 5069afc305bSSean Wang 5079afc305bSSean Wang return 0; 5089afc305bSSean Wang } 5098174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_disable_get_rev1); 5109afc305bSSean Wang 5119afc305bSSean Wang int mtk_pinconf_bias_set_rev1(struct mtk_pinctrl *hw, 5129afc305bSSean Wang const struct mtk_pin_desc *desc, bool pullup) 5139afc305bSSean Wang { 5149afc305bSSean Wang int err, arg; 5159afc305bSSean Wang 5169afc305bSSean Wang arg = pullup ? MTK_PULLUP : MTK_PULLDOWN; 5179afc305bSSean Wang 518ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PULLEN, 5199afc305bSSean Wang MTK_ENABLE); 5209afc305bSSean Wang if (err) 5219afc305bSSean Wang return err; 5229afc305bSSean Wang 523ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PULLSEL, arg); 5249afc305bSSean Wang if (err) 5259afc305bSSean Wang return err; 5269afc305bSSean Wang 5279afc305bSSean Wang return 0; 5289afc305bSSean Wang } 5298174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_set_rev1); 5309afc305bSSean Wang 5319afc305bSSean Wang int mtk_pinconf_bias_get_rev1(struct mtk_pinctrl *hw, 5329afc305bSSean Wang const struct mtk_pin_desc *desc, bool pullup, 5339afc305bSSean Wang int *res) 5349afc305bSSean Wang { 5359afc305bSSean Wang int err, v; 5369afc305bSSean Wang 537ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PULLEN, &v); 5389afc305bSSean Wang if (err) 5399afc305bSSean Wang return err; 5409afc305bSSean Wang 5419afc305bSSean Wang if (v == MTK_DISABLE) 5429afc305bSSean Wang return -EINVAL; 5439afc305bSSean Wang 544ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PULLSEL, &v); 5459afc305bSSean Wang if (err) 5469afc305bSSean Wang return err; 5479afc305bSSean Wang 5489afc305bSSean Wang if (pullup ^ (v == MTK_PULLUP)) 5499afc305bSSean Wang return -EINVAL; 5509afc305bSSean Wang 5519afc305bSSean Wang *res = 1; 5529afc305bSSean Wang 5539afc305bSSean Wang return 0; 5549afc305bSSean Wang } 5558174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_get_rev1); 5569afc305bSSean Wang 557cafe19dbSLight Hsieh /* Combo for the following pull register type: 558cafe19dbSLight Hsieh * 1. PU + PD 559cafe19dbSLight Hsieh * 2. PULLSEL + PULLEN 560cafe19dbSLight Hsieh * 3. PUPD + R0 + R1 561cafe19dbSLight Hsieh */ 562cafe19dbSLight Hsieh static int mtk_pinconf_bias_set_pu_pd(struct mtk_pinctrl *hw, 563cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 564cafe19dbSLight Hsieh u32 pullup, u32 arg) 565cafe19dbSLight Hsieh { 566cafe19dbSLight Hsieh int err, pu, pd; 567cafe19dbSLight Hsieh 568cafe19dbSLight Hsieh if (arg == MTK_DISABLE) { 569cafe19dbSLight Hsieh pu = 0; 570cafe19dbSLight Hsieh pd = 0; 571cafe19dbSLight Hsieh } else if ((arg == MTK_ENABLE) && pullup) { 572cafe19dbSLight Hsieh pu = 1; 573cafe19dbSLight Hsieh pd = 0; 574cafe19dbSLight Hsieh } else if ((arg == MTK_ENABLE) && !pullup) { 575cafe19dbSLight Hsieh pu = 0; 576cafe19dbSLight Hsieh pd = 1; 577cafe19dbSLight Hsieh } else { 578cafe19dbSLight Hsieh err = -EINVAL; 579cafe19dbSLight Hsieh goto out; 580cafe19dbSLight Hsieh } 581cafe19dbSLight Hsieh 582cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PU, pu); 583cafe19dbSLight Hsieh if (err) 584cafe19dbSLight Hsieh goto out; 585cafe19dbSLight Hsieh 586cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PD, pd); 587cafe19dbSLight Hsieh 588cafe19dbSLight Hsieh out: 589cafe19dbSLight Hsieh return err; 590cafe19dbSLight Hsieh } 591cafe19dbSLight Hsieh 592cafe19dbSLight Hsieh static int mtk_pinconf_bias_set_pullsel_pullen(struct mtk_pinctrl *hw, 593cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 594cafe19dbSLight Hsieh u32 pullup, u32 arg) 595cafe19dbSLight Hsieh { 596cafe19dbSLight Hsieh int err, enable; 597cafe19dbSLight Hsieh 598cafe19dbSLight Hsieh if (arg == MTK_DISABLE) 599cafe19dbSLight Hsieh enable = 0; 600cafe19dbSLight Hsieh else if (arg == MTK_ENABLE) 601cafe19dbSLight Hsieh enable = 1; 602cafe19dbSLight Hsieh else { 603cafe19dbSLight Hsieh err = -EINVAL; 604cafe19dbSLight Hsieh goto out; 605cafe19dbSLight Hsieh } 606cafe19dbSLight Hsieh 607cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PULLEN, enable); 608cafe19dbSLight Hsieh if (err) 609cafe19dbSLight Hsieh goto out; 610cafe19dbSLight Hsieh 611cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PULLSEL, pullup); 612cafe19dbSLight Hsieh 613cafe19dbSLight Hsieh out: 614cafe19dbSLight Hsieh return err; 615cafe19dbSLight Hsieh } 616cafe19dbSLight Hsieh 617cafe19dbSLight Hsieh static int mtk_pinconf_bias_set_pupd_r1_r0(struct mtk_pinctrl *hw, 618cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 619cafe19dbSLight Hsieh u32 pullup, u32 arg) 620cafe19dbSLight Hsieh { 621cafe19dbSLight Hsieh int err, r0, r1; 622cafe19dbSLight Hsieh 623cafe19dbSLight Hsieh if ((arg == MTK_DISABLE) || (arg == MTK_PUPD_SET_R1R0_00)) { 624cafe19dbSLight Hsieh pullup = 0; 625cafe19dbSLight Hsieh r0 = 0; 626cafe19dbSLight Hsieh r1 = 0; 627cafe19dbSLight Hsieh } else if (arg == MTK_PUPD_SET_R1R0_01) { 628cafe19dbSLight Hsieh r0 = 1; 629cafe19dbSLight Hsieh r1 = 0; 630cafe19dbSLight Hsieh } else if (arg == MTK_PUPD_SET_R1R0_10) { 631cafe19dbSLight Hsieh r0 = 0; 632cafe19dbSLight Hsieh r1 = 1; 633cafe19dbSLight Hsieh } else if (arg == MTK_PUPD_SET_R1R0_11) { 634cafe19dbSLight Hsieh r0 = 1; 635cafe19dbSLight Hsieh r1 = 1; 636cafe19dbSLight Hsieh } else { 637cafe19dbSLight Hsieh err = -EINVAL; 638cafe19dbSLight Hsieh goto out; 639cafe19dbSLight Hsieh } 640cafe19dbSLight Hsieh 641cafe19dbSLight Hsieh /* MTK HW PUPD bit: 1 for pull-down, 0 for pull-up */ 642cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PUPD, !pullup); 643cafe19dbSLight Hsieh if (err) 644cafe19dbSLight Hsieh goto out; 645cafe19dbSLight Hsieh 646cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_R0, r0); 647cafe19dbSLight Hsieh if (err) 648cafe19dbSLight Hsieh goto out; 649cafe19dbSLight Hsieh 650cafe19dbSLight Hsieh err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_R1, r1); 651cafe19dbSLight Hsieh 652cafe19dbSLight Hsieh out: 653cafe19dbSLight Hsieh return err; 654cafe19dbSLight Hsieh } 655cafe19dbSLight Hsieh 656cafe19dbSLight Hsieh static int mtk_pinconf_bias_get_pu_pd(struct mtk_pinctrl *hw, 657cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 658cafe19dbSLight Hsieh u32 *pullup, u32 *enable) 659cafe19dbSLight Hsieh { 660cafe19dbSLight Hsieh int err, pu, pd; 661cafe19dbSLight Hsieh 662cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PU, &pu); 663cafe19dbSLight Hsieh if (err) 664cafe19dbSLight Hsieh goto out; 665cafe19dbSLight Hsieh 666cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PD, &pd); 667cafe19dbSLight Hsieh if (err) 668cafe19dbSLight Hsieh goto out; 669cafe19dbSLight Hsieh 670cafe19dbSLight Hsieh if (pu == 0 && pd == 0) { 671cafe19dbSLight Hsieh *pullup = 0; 672cafe19dbSLight Hsieh *enable = MTK_DISABLE; 673cafe19dbSLight Hsieh } else if (pu == 1 && pd == 0) { 674cafe19dbSLight Hsieh *pullup = 1; 675cafe19dbSLight Hsieh *enable = MTK_ENABLE; 676cafe19dbSLight Hsieh } else if (pu == 0 && pd == 1) { 677cafe19dbSLight Hsieh *pullup = 0; 678cafe19dbSLight Hsieh *enable = MTK_ENABLE; 679cafe19dbSLight Hsieh } else 680cafe19dbSLight Hsieh err = -EINVAL; 681cafe19dbSLight Hsieh 682cafe19dbSLight Hsieh out: 683cafe19dbSLight Hsieh return err; 684cafe19dbSLight Hsieh } 685cafe19dbSLight Hsieh 686cafe19dbSLight Hsieh static int mtk_pinconf_bias_get_pullsel_pullen(struct mtk_pinctrl *hw, 687cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 688cafe19dbSLight Hsieh u32 *pullup, u32 *enable) 689cafe19dbSLight Hsieh { 690cafe19dbSLight Hsieh int err; 691cafe19dbSLight Hsieh 692cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PULLSEL, pullup); 693cafe19dbSLight Hsieh if (err) 694cafe19dbSLight Hsieh goto out; 695cafe19dbSLight Hsieh 696cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PULLEN, enable); 697cafe19dbSLight Hsieh 698cafe19dbSLight Hsieh out: 699cafe19dbSLight Hsieh return err; 700cafe19dbSLight Hsieh } 701cafe19dbSLight Hsieh 702cafe19dbSLight Hsieh static int mtk_pinconf_bias_get_pupd_r1_r0(struct mtk_pinctrl *hw, 703cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 704cafe19dbSLight Hsieh u32 *pullup, u32 *enable) 705cafe19dbSLight Hsieh { 706cafe19dbSLight Hsieh int err, r0, r1; 707cafe19dbSLight Hsieh 708cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PUPD, pullup); 709cafe19dbSLight Hsieh if (err) 710cafe19dbSLight Hsieh goto out; 711cafe19dbSLight Hsieh /* MTK HW PUPD bit: 1 for pull-down, 0 for pull-up */ 712cafe19dbSLight Hsieh *pullup = !(*pullup); 713cafe19dbSLight Hsieh 714cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_R0, &r0); 715cafe19dbSLight Hsieh if (err) 716cafe19dbSLight Hsieh goto out; 717cafe19dbSLight Hsieh 718cafe19dbSLight Hsieh err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_R1, &r1); 719cafe19dbSLight Hsieh if (err) 720cafe19dbSLight Hsieh goto out; 721cafe19dbSLight Hsieh 722cafe19dbSLight Hsieh if ((r1 == 0) && (r0 == 0)) 723cafe19dbSLight Hsieh *enable = MTK_PUPD_SET_R1R0_00; 724cafe19dbSLight Hsieh else if ((r1 == 0) && (r0 == 1)) 725cafe19dbSLight Hsieh *enable = MTK_PUPD_SET_R1R0_01; 726cafe19dbSLight Hsieh else if ((r1 == 1) && (r0 == 0)) 727cafe19dbSLight Hsieh *enable = MTK_PUPD_SET_R1R0_10; 728cafe19dbSLight Hsieh else if ((r1 == 1) && (r0 == 1)) 729cafe19dbSLight Hsieh *enable = MTK_PUPD_SET_R1R0_11; 730cafe19dbSLight Hsieh else 731cafe19dbSLight Hsieh err = -EINVAL; 732cafe19dbSLight Hsieh 733cafe19dbSLight Hsieh out: 734cafe19dbSLight Hsieh return err; 735cafe19dbSLight Hsieh } 736cafe19dbSLight Hsieh 737cafe19dbSLight Hsieh int mtk_pinconf_bias_set_combo(struct mtk_pinctrl *hw, 738cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 739cafe19dbSLight Hsieh u32 pullup, u32 arg) 740cafe19dbSLight Hsieh { 741cafe19dbSLight Hsieh int err; 742cafe19dbSLight Hsieh 743cafe19dbSLight Hsieh err = mtk_pinconf_bias_set_pu_pd(hw, desc, pullup, arg); 744cafe19dbSLight Hsieh if (!err) 745cafe19dbSLight Hsieh goto out; 746cafe19dbSLight Hsieh 747cafe19dbSLight Hsieh err = mtk_pinconf_bias_set_pullsel_pullen(hw, desc, pullup, arg); 748cafe19dbSLight Hsieh if (!err) 749cafe19dbSLight Hsieh goto out; 750cafe19dbSLight Hsieh 751cafe19dbSLight Hsieh err = mtk_pinconf_bias_set_pupd_r1_r0(hw, desc, pullup, arg); 752cafe19dbSLight Hsieh 753cafe19dbSLight Hsieh out: 754cafe19dbSLight Hsieh return err; 755cafe19dbSLight Hsieh } 7568174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_set_combo); 757cafe19dbSLight Hsieh 758cafe19dbSLight Hsieh int mtk_pinconf_bias_get_combo(struct mtk_pinctrl *hw, 759cafe19dbSLight Hsieh const struct mtk_pin_desc *desc, 760cafe19dbSLight Hsieh u32 *pullup, u32 *enable) 761cafe19dbSLight Hsieh { 762cafe19dbSLight Hsieh int err; 763cafe19dbSLight Hsieh 764cafe19dbSLight Hsieh err = mtk_pinconf_bias_get_pu_pd(hw, desc, pullup, enable); 765cafe19dbSLight Hsieh if (!err) 766cafe19dbSLight Hsieh goto out; 767cafe19dbSLight Hsieh 768cafe19dbSLight Hsieh err = mtk_pinconf_bias_get_pullsel_pullen(hw, desc, pullup, enable); 769cafe19dbSLight Hsieh if (!err) 770cafe19dbSLight Hsieh goto out; 771cafe19dbSLight Hsieh 772cafe19dbSLight Hsieh err = mtk_pinconf_bias_get_pupd_r1_r0(hw, desc, pullup, enable); 773cafe19dbSLight Hsieh 774cafe19dbSLight Hsieh out: 775cafe19dbSLight Hsieh return err; 776cafe19dbSLight Hsieh } 7778174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_bias_get_combo); 778cafe19dbSLight Hsieh 779c2832197SSean Wang /* Revision 0 */ 780c2832197SSean Wang int mtk_pinconf_drive_set(struct mtk_pinctrl *hw, 781c2832197SSean Wang const struct mtk_pin_desc *desc, u32 arg) 782c2832197SSean Wang { 783c2832197SSean Wang const struct mtk_drive_desc *tb; 784c2832197SSean Wang int err = -ENOTSUPP; 785c2832197SSean Wang 786c2832197SSean Wang tb = &mtk_drive[desc->drv_n]; 787c2832197SSean Wang /* 4mA when (e8, e4) = (0, 0) 788c2832197SSean Wang * 8mA when (e8, e4) = (0, 1) 789c2832197SSean Wang * 12mA when (e8, e4) = (1, 0) 790c2832197SSean Wang * 16mA when (e8, e4) = (1, 1) 791c2832197SSean Wang */ 792c2832197SSean Wang if ((arg >= tb->min && arg <= tb->max) && !(arg % tb->step)) { 793c2832197SSean Wang arg = (arg / tb->step - 1) * tb->scal; 794ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_E4, 795c2832197SSean Wang arg & 0x1); 796c2832197SSean Wang if (err) 797c2832197SSean Wang return err; 798c2832197SSean Wang 799ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_E8, 800c2832197SSean Wang (arg & 0x2) >> 1); 801c2832197SSean Wang if (err) 802c2832197SSean Wang return err; 803c2832197SSean Wang } 804c2832197SSean Wang 805c2832197SSean Wang return err; 806c2832197SSean Wang } 8078174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_set); 808c2832197SSean Wang 809c2832197SSean Wang int mtk_pinconf_drive_get(struct mtk_pinctrl *hw, 810c2832197SSean Wang const struct mtk_pin_desc *desc, int *val) 811c2832197SSean Wang { 812c2832197SSean Wang const struct mtk_drive_desc *tb; 813c2832197SSean Wang int err, val1, val2; 814c2832197SSean Wang 815c2832197SSean Wang tb = &mtk_drive[desc->drv_n]; 816c2832197SSean Wang 817ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_E4, &val1); 818c2832197SSean Wang if (err) 819c2832197SSean Wang return err; 820c2832197SSean Wang 821ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_E8, &val2); 822c2832197SSean Wang if (err) 823c2832197SSean Wang return err; 824c2832197SSean Wang 825c2832197SSean Wang /* 4mA when (e8, e4) = (0, 0); 8mA when (e8, e4) = (0, 1) 826c2832197SSean Wang * 12mA when (e8, e4) = (1, 0); 16mA when (e8, e4) = (1, 1) 827c2832197SSean Wang */ 828c2832197SSean Wang *val = (((val2 << 1) + val1) / tb->scal + 1) * tb->step; 829c2832197SSean Wang 830c2832197SSean Wang return 0; 831c2832197SSean Wang } 8328174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_get); 8333ad38a14SSean Wang 8343ad38a14SSean Wang /* Revision 1 */ 8353ad38a14SSean Wang int mtk_pinconf_drive_set_rev1(struct mtk_pinctrl *hw, 8363ad38a14SSean Wang const struct mtk_pin_desc *desc, u32 arg) 8373ad38a14SSean Wang { 8383ad38a14SSean Wang const struct mtk_drive_desc *tb; 8393ad38a14SSean Wang int err = -ENOTSUPP; 8403ad38a14SSean Wang 8413ad38a14SSean Wang tb = &mtk_drive[desc->drv_n]; 8423ad38a14SSean Wang 8433ad38a14SSean Wang if ((arg >= tb->min && arg <= tb->max) && !(arg % tb->step)) { 8443ad38a14SSean Wang arg = (arg / tb->step - 1) * tb->scal; 8453ad38a14SSean Wang 846ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DRV, 8473ad38a14SSean Wang arg); 8483ad38a14SSean Wang if (err) 8493ad38a14SSean Wang return err; 8503ad38a14SSean Wang } 8513ad38a14SSean Wang 8523ad38a14SSean Wang return err; 8533ad38a14SSean Wang } 8548174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_set_rev1); 8553ad38a14SSean Wang 8563ad38a14SSean Wang int mtk_pinconf_drive_get_rev1(struct mtk_pinctrl *hw, 8573ad38a14SSean Wang const struct mtk_pin_desc *desc, int *val) 8583ad38a14SSean Wang { 8593ad38a14SSean Wang const struct mtk_drive_desc *tb; 8603ad38a14SSean Wang int err, val1; 8613ad38a14SSean Wang 8623ad38a14SSean Wang tb = &mtk_drive[desc->drv_n]; 8633ad38a14SSean Wang 864ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DRV, &val1); 8653ad38a14SSean Wang if (err) 8663ad38a14SSean Wang return err; 8673ad38a14SSean Wang 8683ad38a14SSean Wang *val = ((val1 & 0x7) / tb->scal + 1) * tb->step; 8693ad38a14SSean Wang 8703ad38a14SSean Wang return 0; 8713ad38a14SSean Wang } 8728174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_get_rev1); 8730d7ca772SSean Wang 8745f755e1fSLight Hsieh int mtk_pinconf_drive_set_raw(struct mtk_pinctrl *hw, 8755f755e1fSLight Hsieh const struct mtk_pin_desc *desc, u32 arg) 8765f755e1fSLight Hsieh { 8775f755e1fSLight Hsieh return mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DRV, arg); 8785f755e1fSLight Hsieh } 8798174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_set_raw); 8805f755e1fSLight Hsieh 8815f755e1fSLight Hsieh int mtk_pinconf_drive_get_raw(struct mtk_pinctrl *hw, 8825f755e1fSLight Hsieh const struct mtk_pin_desc *desc, int *val) 8835f755e1fSLight Hsieh { 8845f755e1fSLight Hsieh return mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DRV, val); 8855f755e1fSLight Hsieh } 8868174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_drive_get_raw); 8875f755e1fSLight Hsieh 8880d7ca772SSean Wang int mtk_pinconf_adv_pull_set(struct mtk_pinctrl *hw, 8890d7ca772SSean Wang const struct mtk_pin_desc *desc, bool pullup, 8900d7ca772SSean Wang u32 arg) 8910d7ca772SSean Wang { 8920d7ca772SSean Wang int err; 8930d7ca772SSean Wang 8940d7ca772SSean Wang /* 10K off & 50K (75K) off, when (R0, R1) = (0, 0); 8950d7ca772SSean Wang * 10K off & 50K (75K) on, when (R0, R1) = (0, 1); 8960d7ca772SSean Wang * 10K on & 50K (75K) off, when (R0, R1) = (1, 0); 8970d7ca772SSean Wang * 10K on & 50K (75K) on, when (R0, R1) = (1, 1) 8980d7ca772SSean Wang */ 899ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_R0, arg & 1); 9000d7ca772SSean Wang if (err) 9010d7ca772SSean Wang return 0; 9020d7ca772SSean Wang 903ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_R1, 9040d7ca772SSean Wang !!(arg & 2)); 9050d7ca772SSean Wang if (err) 9060d7ca772SSean Wang return 0; 9070d7ca772SSean Wang 9080d7ca772SSean Wang arg = pullup ? 0 : 1; 9090d7ca772SSean Wang 910ea051eb3SSean Wang err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_PUPD, arg); 9110d7ca772SSean Wang 91279348f6fSSean Wang /* If PUPD register is not supported for that pin, let's fallback to 91379348f6fSSean Wang * general bias control. 91479348f6fSSean Wang */ 91579348f6fSSean Wang if (err == -ENOTSUPP) { 91679348f6fSSean Wang if (hw->soc->bias_set) { 91779348f6fSSean Wang err = hw->soc->bias_set(hw, desc, pullup); 91879348f6fSSean Wang if (err) 91979348f6fSSean Wang return err; 92079348f6fSSean Wang } else { 92179348f6fSSean Wang return -ENOTSUPP; 92279348f6fSSean Wang } 92379348f6fSSean Wang } 92479348f6fSSean Wang 9250d7ca772SSean Wang return err; 9260d7ca772SSean Wang } 9278174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_adv_pull_set); 9280d7ca772SSean Wang 9290d7ca772SSean Wang int mtk_pinconf_adv_pull_get(struct mtk_pinctrl *hw, 9300d7ca772SSean Wang const struct mtk_pin_desc *desc, bool pullup, 9310d7ca772SSean Wang u32 *val) 9320d7ca772SSean Wang { 9330d7ca772SSean Wang u32 t, t2; 9340d7ca772SSean Wang int err; 9350d7ca772SSean Wang 936ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_PUPD, &t); 93779348f6fSSean Wang 93879348f6fSSean Wang /* If PUPD register is not supported for that pin, let's fallback to 93979348f6fSSean Wang * general bias control. 94079348f6fSSean Wang */ 94179348f6fSSean Wang if (err == -ENOTSUPP) { 94279348f6fSSean Wang if (hw->soc->bias_get) { 94379348f6fSSean Wang err = hw->soc->bias_get(hw, desc, pullup, val); 94479348f6fSSean Wang if (err) 94579348f6fSSean Wang return err; 94679348f6fSSean Wang } else { 94779348f6fSSean Wang return -ENOTSUPP; 94879348f6fSSean Wang } 94979348f6fSSean Wang } else { 95079348f6fSSean Wang /* t == 0 supposes PULLUP for the customized PULL setup */ 9510d7ca772SSean Wang if (err) 9520d7ca772SSean Wang return err; 9530d7ca772SSean Wang 9540d7ca772SSean Wang if (pullup ^ !t) 9550d7ca772SSean Wang return -EINVAL; 95679348f6fSSean Wang } 9570d7ca772SSean Wang 958ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_R0, &t); 9590d7ca772SSean Wang if (err) 9600d7ca772SSean Wang return err; 9610d7ca772SSean Wang 962ea051eb3SSean Wang err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_R1, &t2); 9630d7ca772SSean Wang if (err) 9640d7ca772SSean Wang return err; 9650d7ca772SSean Wang 9660d7ca772SSean Wang *val = (t | t2 << 1) & 0x7; 9670d7ca772SSean Wang 9680d7ca772SSean Wang return 0; 9690d7ca772SSean Wang } 9708174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_adv_pull_get); 9715e73de34SZhiyong Tao 9725e73de34SZhiyong Tao int mtk_pinconf_adv_drive_set(struct mtk_pinctrl *hw, 9735e73de34SZhiyong Tao const struct mtk_pin_desc *desc, u32 arg) 9745e73de34SZhiyong Tao { 9755e73de34SZhiyong Tao int err; 9765e73de34SZhiyong Tao int en = arg & 1; 9775e73de34SZhiyong Tao int e0 = !!(arg & 2); 9785e73de34SZhiyong Tao int e1 = !!(arg & 4); 9795e73de34SZhiyong Tao 9805e73de34SZhiyong Tao err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DRV_EN, en); 9815e73de34SZhiyong Tao if (err) 9825e73de34SZhiyong Tao return err; 9835e73de34SZhiyong Tao 9845e73de34SZhiyong Tao if (!en) 9855e73de34SZhiyong Tao return err; 9865e73de34SZhiyong Tao 9875e73de34SZhiyong Tao err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DRV_E0, e0); 9885e73de34SZhiyong Tao if (err) 9895e73de34SZhiyong Tao return err; 9905e73de34SZhiyong Tao 9915e73de34SZhiyong Tao err = mtk_hw_set_value(hw, desc, PINCTRL_PIN_REG_DRV_E1, e1); 9925e73de34SZhiyong Tao if (err) 9935e73de34SZhiyong Tao return err; 9945e73de34SZhiyong Tao 9955e73de34SZhiyong Tao return err; 9965e73de34SZhiyong Tao } 9978174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_adv_drive_set); 9985e73de34SZhiyong Tao 9995e73de34SZhiyong Tao int mtk_pinconf_adv_drive_get(struct mtk_pinctrl *hw, 10005e73de34SZhiyong Tao const struct mtk_pin_desc *desc, u32 *val) 10015e73de34SZhiyong Tao { 10025e73de34SZhiyong Tao u32 en, e0, e1; 10035e73de34SZhiyong Tao int err; 10045e73de34SZhiyong Tao 10055e73de34SZhiyong Tao err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DRV_EN, &en); 10065e73de34SZhiyong Tao if (err) 10075e73de34SZhiyong Tao return err; 10085e73de34SZhiyong Tao 10095e73de34SZhiyong Tao err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DRV_E0, &e0); 10105e73de34SZhiyong Tao if (err) 10115e73de34SZhiyong Tao return err; 10125e73de34SZhiyong Tao 10135e73de34SZhiyong Tao err = mtk_hw_get_value(hw, desc, PINCTRL_PIN_REG_DRV_E1, &e1); 10145e73de34SZhiyong Tao if (err) 10155e73de34SZhiyong Tao return err; 10165e73de34SZhiyong Tao 10175e73de34SZhiyong Tao *val = (en | e0 << 1 | e1 << 2) & 0x7; 10185e73de34SZhiyong Tao 10195e73de34SZhiyong Tao return 0; 10205e73de34SZhiyong Tao } 10218174a851SLight Hsieh EXPORT_SYMBOL_GPL(mtk_pinconf_adv_drive_get); 1022c7acd6feSArnd Bergmann 1023c7acd6feSArnd Bergmann MODULE_LICENSE("GPL v2"); 1024c7acd6feSArnd Bergmann MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 1025c7acd6feSArnd Bergmann MODULE_DESCRIPTION("Pin configuration library module for mediatek SoCs"); 1026