drivers/pwm/pwm-ntxec.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * The Netronix embedded controller is a microcontroller found in some
   4  * e-book readers designed by the original design manufacturer Netronix, Inc.
   5  * It contains RTC, battery monitoring, system power management, and PWM
   6  * functionality.
   7  *
   8  * This driver implements PWM output.
   9  *
  10  * Copyright 2020 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
  11  *
  12  * Limitations:
  13  * - The get_state callback is not implemented, because the current state of
  14  *   the PWM output can't be read back from the hardware.
  15  * - The hardware can only generate normal polarity output.
  16  * - The period and duty cycle can't be changed together in one atomic action.
  17  */
  18
  19 #include <linux/mfd/ntxec.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/pwm.h>
  23 #include <linux/regmap.h>
  24 #include <linux/types.h>
  25
  26 struct ntxec_pwm {
  27         struct ntxec *ec;
  28         struct pwm_chip chip;
  29 };
  30
  31 static struct ntxec_pwm *ntxec_pwm_from_chip(struct pwm_chip *chip)
  32 {
  33         return container_of(chip, struct ntxec_pwm, chip);
  34 }
  35
  36 #define NTXEC_REG_AUTO_OFF_HI   0xa1
  37 #define NTXEC_REG_AUTO_OFF_LO   0xa2
  38 #define NTXEC_REG_ENABLE        0xa3
  39 #define NTXEC_REG_PERIOD_LOW    0xa4
  40 #define NTXEC_REG_PERIOD_HIGH   0xa5
  41 #define NTXEC_REG_DUTY_LOW      0xa6
  42 #define NTXEC_REG_DUTY_HIGH     0xa7
  43
  44 /*
  45  * The time base used in the EC is 8MHz, or 125ns. Period and duty cycle are
  46  * measured in this unit.
  47  */
  48 #define TIME_BASE_NS 125
  49
  50 /*
  51  * The maximum input value (in nanoseconds) is determined by the time base and
  52  * the range of the hardware registers that hold the converted value.
  53  * It fits into 32 bits, so we can do our calculations in 32 bits as well.
  54  */
  55 #define MAX_PERIOD_NS (TIME_BASE_NS * 0xffff)
  56
  57 static int ntxec_pwm_set_raw_period_and_duty_cycle(struct pwm_chip *chip,
  58                                                    int period, int duty)
  59 {
  60         struct ntxec_pwm *priv = ntxec_pwm_from_chip(chip);
  61
  62         /*
  63          * Changes to the period and duty cycle take effect as soon as the
  64          * corresponding low byte is written, so the hardware may be configured
  65          * to an inconsistent state after the period is written and before the
  66          * duty cycle is fully written. If, in such a case, the old duty cycle
  67          * is longer than the new period, the EC may output 100% for a moment.
  68          *
  69          * To minimize the time between the changes to period and duty cycle
  70          * taking effect, the writes are interleaved.
  71          */
  72
  73         struct reg_sequence regs[] = {
  74                 { NTXEC_REG_PERIOD_HIGH, ntxec_reg8(period >> 8) },
  75                 { NTXEC_REG_DUTY_HIGH, ntxec_reg8(duty >> 8) },
  76                 { NTXEC_REG_PERIOD_LOW, ntxec_reg8(period) },
  77                 { NTXEC_REG_DUTY_LOW, ntxec_reg8(duty) },
  78         };
  79
  80         return regmap_multi_reg_write(priv->ec->regmap, regs, ARRAY_SIZE(regs));
  81 }
  82
  83 static int ntxec_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm_dev,
  84                            const struct pwm_state *state)
  85 {
  86         struct ntxec_pwm *priv = ntxec_pwm_from_chip(chip);
  87         unsigned int period, duty;
  88         int res;
  89
  90         if (state->polarity != PWM_POLARITY_NORMAL)
  91                 return -EINVAL;
  92
  93         period = min_t(u64, state->period, MAX_PERIOD_NS);
  94         duty   = min_t(u64, state->duty_cycle, period);
  95
  96         period /= TIME_BASE_NS;
  97         duty   /= TIME_BASE_NS;
  98
  99         /*
 100          * Writing a duty cycle of zero puts the device into a state where
 101          * writing a higher duty cycle doesn't result in the brightness that it
 102          * usually results in. This can be fixed by cycling the ENABLE register.
 103          *
 104          * As a workaround, write ENABLE=0 when the duty cycle is zero.
 105          * The case that something has previously set the duty cycle to zero
 106          * but ENABLE=1, is not handled.
 107          */
 108         if (state->enabled && duty != 0) {
 109                 res = ntxec_pwm_set_raw_period_and_duty_cycle(chip, period, duty);
 110                 if (res)
 111                         return res;
 112
 113                 res = regmap_write(priv->ec->regmap, NTXEC_REG_ENABLE, ntxec_reg8(1));
 114                 if (res)
 115                         return res;
 116
 117                 /* Disable the auto-off timer */
 118                 res = regmap_write(priv->ec->regmap, NTXEC_REG_AUTO_OFF_HI, ntxec_reg8(0xff));
 119                 if (res)
 120                         return res;
 121
 122                 return regmap_write(priv->ec->regmap, NTXEC_REG_AUTO_OFF_LO, ntxec_reg8(0xff));
 123         } else {
 124                 return regmap_write(priv->ec->regmap, NTXEC_REG_ENABLE, ntxec_reg8(0));
 125         }
 126 }
 127
 128 static const struct pwm_ops ntxec_pwm_ops = {
 129         .owner = THIS_MODULE,
 130         .apply = ntxec_pwm_apply,
 131         /*
 132          * No .get_state callback, because the current state cannot be read
 133          * back from the hardware.
 134          */
 135 };
 136
 137 static int ntxec_pwm_probe(struct platform_device *pdev)
 138 {
 139         struct ntxec *ec = dev_get_drvdata(pdev->dev.parent);
 140         struct ntxec_pwm *priv;
 141         struct pwm_chip *chip;
 142
 143         device_set_of_node_from_dev(&pdev->dev, pdev->dev.parent);
 144
 145         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 146         if (!priv)
 147                 return -ENOMEM;
 148
 149         priv->ec = ec;
 150
 151         chip = &priv->chip;
 152         chip->dev = &pdev->dev;
 153         chip->ops = &ntxec_pwm_ops;
 154         chip->npwm = 1;
 155
 156         return devm_pwmchip_add(&pdev->dev, chip);
 157 }
 158
 159 static struct platform_driver ntxec_pwm_driver = {
 160         .driver = {
 161                 .name = "ntxec-pwm",
 162         },
 163         .probe = ntxec_pwm_probe,
 164 };
 165 module_platform_driver(ntxec_pwm_driver);
 166
 167 MODULE_AUTHOR("Jonathan Neuschäfer <j.neuschaefer@gmx.net>");
 168 MODULE_DESCRIPTION("PWM driver for Netronix EC");
 169 MODULE_LICENSE("GPL");
 170 MODULE_ALIAS("platform:ntxec-pwm");