1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2020 Intel Corporation. 4 * 5 * Limitations: 6 * - The hardware supports fixed period & configures only 2-wire mode. 7 * - Supports normal polarity. Does not support changing polarity. 8 * - When PWM is disabled, output of PWM will become 0(inactive). It doesn't 9 * keep track of running period. 10 * - When duty cycle is changed, PWM output may be a mix of previous setting 11 * and new setting for the first period. From second period, the output is 12 * based on new setting. 13 * - It is a dedicated PWM fan controller. There are no other consumers for 14 * this PWM controller. 15 */ 16 #include <linux/bitfield.h> 17 #include <linux/clk.h> 18 #include <linux/module.h> 19 #include <linux/platform_device.h> 20 #include <linux/mod_devicetable.h> 21 #include <linux/pwm.h> 22 #include <linux/regmap.h> 23 #include <linux/reset.h> 24 25 #define LGM_PWM_FAN_CON0 0x0 26 #define LGM_PWM_FAN_EN_EN BIT(0) 27 #define LGM_PWM_FAN_EN_DIS 0x0 28 #define LGM_PWM_FAN_EN_MSK BIT(0) 29 #define LGM_PWM_FAN_MODE_2WIRE 0x0 30 #define LGM_PWM_FAN_MODE_MSK BIT(1) 31 #define LGM_PWM_FAN_DC_MSK GENMASK(23, 16) 32 33 #define LGM_PWM_FAN_CON1 0x4 34 #define LGM_PWM_FAN_MAX_RPM_MSK GENMASK(15, 0) 35 36 #define LGM_PWM_MAX_RPM (BIT(16) - 1) 37 #define LGM_PWM_DEFAULT_RPM 4000 38 #define LGM_PWM_MAX_DUTY_CYCLE (BIT(8) - 1) 39 40 #define LGM_PWM_DC_BITS 8 41 42 #define LGM_PWM_PERIOD_2WIRE_NS (40 * NSEC_PER_MSEC) 43 44 struct lgm_pwm_chip { 45 struct pwm_chip chip; 46 struct regmap *regmap; 47 u32 period; 48 }; 49 50 static inline struct lgm_pwm_chip *to_lgm_pwm_chip(struct pwm_chip *chip) 51 { 52 return container_of(chip, struct lgm_pwm_chip, chip); 53 } 54 55 static int lgm_pwm_enable(struct pwm_chip *chip, bool enable) 56 { 57 struct lgm_pwm_chip *pc = to_lgm_pwm_chip(chip); 58 struct regmap *regmap = pc->regmap; 59 60 return regmap_update_bits(regmap, LGM_PWM_FAN_CON0, LGM_PWM_FAN_EN_MSK, 61 enable ? LGM_PWM_FAN_EN_EN : LGM_PWM_FAN_EN_DIS); 62 } 63 64 static int lgm_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, 65 const struct pwm_state *state) 66 { 67 struct lgm_pwm_chip *pc = to_lgm_pwm_chip(chip); 68 u32 duty_cycle, val; 69 int ret; 70 71 /* The hardware only supports normal polarity and fixed period. */ 72 if (state->polarity != PWM_POLARITY_NORMAL || state->period < pc->period) 73 return -EINVAL; 74 75 if (!state->enabled) 76 return lgm_pwm_enable(chip, 0); 77 78 duty_cycle = min_t(u64, state->duty_cycle, pc->period); 79 val = duty_cycle * LGM_PWM_MAX_DUTY_CYCLE / pc->period; 80 81 ret = regmap_update_bits(pc->regmap, LGM_PWM_FAN_CON0, LGM_PWM_FAN_DC_MSK, 82 FIELD_PREP(LGM_PWM_FAN_DC_MSK, val)); 83 if (ret) 84 return ret; 85 86 return lgm_pwm_enable(chip, 1); 87 } 88 89 static int lgm_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm, 90 struct pwm_state *state) 91 { 92 struct lgm_pwm_chip *pc = to_lgm_pwm_chip(chip); 93 u32 duty, val; 94 95 state->enabled = regmap_test_bits(pc->regmap, LGM_PWM_FAN_CON0, 96 LGM_PWM_FAN_EN_EN); 97 state->polarity = PWM_POLARITY_NORMAL; 98 state->period = pc->period; /* fixed period */ 99 100 regmap_read(pc->regmap, LGM_PWM_FAN_CON0, &val); 101 duty = FIELD_GET(LGM_PWM_FAN_DC_MSK, val); 102 state->duty_cycle = DIV_ROUND_UP(duty * pc->period, LGM_PWM_MAX_DUTY_CYCLE); 103 104 return 0; 105 } 106 107 static const struct pwm_ops lgm_pwm_ops = { 108 .get_state = lgm_pwm_get_state, 109 .apply = lgm_pwm_apply, 110 .owner = THIS_MODULE, 111 }; 112 113 static void lgm_pwm_init(struct lgm_pwm_chip *pc) 114 { 115 struct regmap *regmap = pc->regmap; 116 u32 con0_val; 117 118 con0_val = FIELD_PREP(LGM_PWM_FAN_MODE_MSK, LGM_PWM_FAN_MODE_2WIRE); 119 pc->period = LGM_PWM_PERIOD_2WIRE_NS; 120 regmap_update_bits(regmap, LGM_PWM_FAN_CON1, LGM_PWM_FAN_MAX_RPM_MSK, 121 LGM_PWM_DEFAULT_RPM); 122 regmap_update_bits(regmap, LGM_PWM_FAN_CON0, LGM_PWM_FAN_MODE_MSK, 123 con0_val); 124 } 125 126 static const struct regmap_config lgm_pwm_regmap_config = { 127 .reg_bits = 32, 128 .reg_stride = 4, 129 .val_bits = 32, 130 }; 131 132 static void lgm_clk_release(void *data) 133 { 134 struct clk *clk = data; 135 136 clk_disable_unprepare(clk); 137 } 138 139 static int lgm_clk_enable(struct device *dev, struct clk *clk) 140 { 141 int ret; 142 143 ret = clk_prepare_enable(clk); 144 if (ret) 145 return ret; 146 147 return devm_add_action_or_reset(dev, lgm_clk_release, clk); 148 } 149 150 static void lgm_reset_control_release(void *data) 151 { 152 struct reset_control *rst = data; 153 154 reset_control_assert(rst); 155 } 156 157 static int lgm_reset_control_deassert(struct device *dev, struct reset_control *rst) 158 { 159 int ret; 160 161 ret = reset_control_deassert(rst); 162 if (ret) 163 return ret; 164 165 return devm_add_action_or_reset(dev, lgm_reset_control_release, rst); 166 } 167 168 static int lgm_pwm_probe(struct platform_device *pdev) 169 { 170 struct device *dev = &pdev->dev; 171 struct reset_control *rst; 172 struct lgm_pwm_chip *pc; 173 void __iomem *io_base; 174 struct clk *clk; 175 int ret; 176 177 pc = devm_kzalloc(dev, sizeof(*pc), GFP_KERNEL); 178 if (!pc) 179 return -ENOMEM; 180 181 io_base = devm_platform_ioremap_resource(pdev, 0); 182 if (IS_ERR(io_base)) 183 return PTR_ERR(io_base); 184 185 pc->regmap = devm_regmap_init_mmio(dev, io_base, &lgm_pwm_regmap_config); 186 if (IS_ERR(pc->regmap)) 187 return dev_err_probe(dev, PTR_ERR(pc->regmap), 188 "failed to init register map\n"); 189 190 clk = devm_clk_get(dev, NULL); 191 if (IS_ERR(clk)) 192 return dev_err_probe(dev, PTR_ERR(clk), "failed to get clock\n"); 193 194 ret = lgm_clk_enable(dev, clk); 195 if (ret) 196 return dev_err_probe(dev, ret, "failed to enable clock\n"); 197 198 rst = devm_reset_control_get_exclusive(dev, NULL); 199 if (IS_ERR(rst)) 200 return dev_err_probe(dev, PTR_ERR(rst), 201 "failed to get reset control\n"); 202 203 ret = lgm_reset_control_deassert(dev, rst); 204 if (ret) 205 return dev_err_probe(dev, ret, "cannot deassert reset control\n"); 206 207 pc->chip.dev = dev; 208 pc->chip.ops = &lgm_pwm_ops; 209 pc->chip.npwm = 1; 210 211 lgm_pwm_init(pc); 212 213 ret = devm_pwmchip_add(dev, &pc->chip); 214 if (ret < 0) 215 return dev_err_probe(dev, ret, "failed to add PWM chip\n"); 216 217 return 0; 218 } 219 220 static const struct of_device_id lgm_pwm_of_match[] = { 221 { .compatible = "intel,lgm-pwm" }, 222 { } 223 }; 224 MODULE_DEVICE_TABLE(of, lgm_pwm_of_match); 225 226 static struct platform_driver lgm_pwm_driver = { 227 .driver = { 228 .name = "intel-pwm", 229 .of_match_table = lgm_pwm_of_match, 230 }, 231 .probe = lgm_pwm_probe, 232 }; 233 module_platform_driver(lgm_pwm_driver); 234 235 MODULE_LICENSE("GPL v2"); 236