1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (C) 2022 Hewlett-Packard Enterprise Development Company, L.P. */ 3 4 #include <linux/bits.h> 5 #include <linux/err.h> 6 #include <linux/hwmon.h> 7 #include <linux/io.h> 8 #include <linux/module.h> 9 #include <linux/of_device.h> 10 #include <linux/platform_device.h> 11 12 #define OFS_FAN_INST 0 /* Is 0 because plreg base will be set at INST */ 13 #define OFS_FAN_FAIL 2 /* Is 2 bytes after base */ 14 #define OFS_SEVSTAT 0 /* Is 0 because fn2 base will be set at SEVSTAT */ 15 #define POWER_BIT 24 16 17 struct gxp_fan_ctrl_drvdata { 18 void __iomem *base; 19 void __iomem *plreg; 20 void __iomem *fn2; 21 }; 22 23 static bool fan_installed(struct device *dev, int fan) 24 { 25 struct gxp_fan_ctrl_drvdata *drvdata = dev_get_drvdata(dev); 26 u8 val; 27 28 val = readb(drvdata->plreg + OFS_FAN_INST); 29 30 return !!(val & BIT(fan)); 31 } 32 33 static long fan_failed(struct device *dev, int fan) 34 { 35 struct gxp_fan_ctrl_drvdata *drvdata = dev_get_drvdata(dev); 36 u8 val; 37 38 val = readb(drvdata->plreg + OFS_FAN_FAIL); 39 40 return !!(val & BIT(fan)); 41 } 42 43 static long fan_enabled(struct device *dev, int fan) 44 { 45 struct gxp_fan_ctrl_drvdata *drvdata = dev_get_drvdata(dev); 46 u32 val; 47 48 /* 49 * Check the power status as if the platform is off the value 50 * reported for the PWM will be incorrect. Report fan as 51 * disabled. 52 */ 53 val = readl(drvdata->fn2 + OFS_SEVSTAT); 54 55 return !!((val & BIT(POWER_BIT)) && fan_installed(dev, fan)); 56 } 57 58 static int gxp_pwm_write(struct device *dev, u32 attr, int channel, long val) 59 { 60 struct gxp_fan_ctrl_drvdata *drvdata = dev_get_drvdata(dev); 61 62 switch (attr) { 63 case hwmon_pwm_input: 64 if (val > 255 || val < 0) 65 return -EINVAL; 66 writeb(val, drvdata->base + channel); 67 return 0; 68 default: 69 return -EOPNOTSUPP; 70 } 71 } 72 73 static int gxp_fan_ctrl_write(struct device *dev, enum hwmon_sensor_types type, 74 u32 attr, int channel, long val) 75 { 76 switch (type) { 77 case hwmon_pwm: 78 return gxp_pwm_write(dev, attr, channel, val); 79 default: 80 return -EOPNOTSUPP; 81 } 82 } 83 84 static int gxp_fan_read(struct device *dev, u32 attr, int channel, long *val) 85 { 86 switch (attr) { 87 case hwmon_fan_enable: 88 *val = fan_enabled(dev, channel); 89 return 0; 90 case hwmon_fan_fault: 91 *val = fan_failed(dev, channel); 92 return 0; 93 default: 94 return -EOPNOTSUPP; 95 } 96 } 97 98 static int gxp_pwm_read(struct device *dev, u32 attr, int channel, long *val) 99 { 100 struct gxp_fan_ctrl_drvdata *drvdata = dev_get_drvdata(dev); 101 u32 reg; 102 103 /* 104 * Check the power status of the platform. If the platform is off 105 * the value reported for the PWM will be incorrect. In this case 106 * report a PWM of zero. 107 */ 108 109 reg = readl(drvdata->fn2 + OFS_SEVSTAT); 110 111 if (reg & BIT(POWER_BIT)) 112 *val = fan_installed(dev, channel) ? readb(drvdata->base + channel) : 0; 113 else 114 *val = 0; 115 116 return 0; 117 } 118 119 static int gxp_fan_ctrl_read(struct device *dev, enum hwmon_sensor_types type, 120 u32 attr, int channel, long *val) 121 { 122 switch (type) { 123 case hwmon_fan: 124 return gxp_fan_read(dev, attr, channel, val); 125 case hwmon_pwm: 126 return gxp_pwm_read(dev, attr, channel, val); 127 default: 128 return -EOPNOTSUPP; 129 } 130 } 131 132 static umode_t gxp_fan_ctrl_is_visible(const void *_data, 133 enum hwmon_sensor_types type, 134 u32 attr, int channel) 135 { 136 umode_t mode = 0; 137 138 switch (type) { 139 case hwmon_fan: 140 switch (attr) { 141 case hwmon_fan_enable: 142 case hwmon_fan_fault: 143 mode = 0444; 144 break; 145 default: 146 break; 147 } 148 break; 149 case hwmon_pwm: 150 switch (attr) { 151 case hwmon_pwm_input: 152 mode = 0644; 153 break; 154 default: 155 break; 156 } 157 break; 158 default: 159 break; 160 } 161 162 return mode; 163 } 164 165 static const struct hwmon_ops gxp_fan_ctrl_ops = { 166 .is_visible = gxp_fan_ctrl_is_visible, 167 .read = gxp_fan_ctrl_read, 168 .write = gxp_fan_ctrl_write, 169 }; 170 171 static const struct hwmon_channel_info * const gxp_fan_ctrl_info[] = { 172 HWMON_CHANNEL_INFO(fan, 173 HWMON_F_FAULT | HWMON_F_ENABLE, 174 HWMON_F_FAULT | HWMON_F_ENABLE, 175 HWMON_F_FAULT | HWMON_F_ENABLE, 176 HWMON_F_FAULT | HWMON_F_ENABLE, 177 HWMON_F_FAULT | HWMON_F_ENABLE, 178 HWMON_F_FAULT | HWMON_F_ENABLE, 179 HWMON_F_FAULT | HWMON_F_ENABLE, 180 HWMON_F_FAULT | HWMON_F_ENABLE), 181 HWMON_CHANNEL_INFO(pwm, 182 HWMON_PWM_INPUT, 183 HWMON_PWM_INPUT, 184 HWMON_PWM_INPUT, 185 HWMON_PWM_INPUT, 186 HWMON_PWM_INPUT, 187 HWMON_PWM_INPUT, 188 HWMON_PWM_INPUT, 189 HWMON_PWM_INPUT), 190 NULL 191 }; 192 193 static const struct hwmon_chip_info gxp_fan_ctrl_chip_info = { 194 .ops = &gxp_fan_ctrl_ops, 195 .info = gxp_fan_ctrl_info, 196 197 }; 198 199 static int gxp_fan_ctrl_probe(struct platform_device *pdev) 200 { 201 struct gxp_fan_ctrl_drvdata *drvdata; 202 struct device *dev = &pdev->dev; 203 struct device *hwmon_dev; 204 205 drvdata = devm_kzalloc(dev, sizeof(struct gxp_fan_ctrl_drvdata), 206 GFP_KERNEL); 207 if (!drvdata) 208 return -ENOMEM; 209 210 drvdata->base = devm_platform_get_and_ioremap_resource(pdev, 0, NULL); 211 if (IS_ERR(drvdata->base)) 212 return dev_err_probe(dev, PTR_ERR(drvdata->base), 213 "failed to map base\n"); 214 215 drvdata->plreg = devm_platform_ioremap_resource_byname(pdev, 216 "pl"); 217 if (IS_ERR(drvdata->plreg)) 218 return dev_err_probe(dev, PTR_ERR(drvdata->plreg), 219 "failed to map plreg\n"); 220 221 drvdata->fn2 = devm_platform_ioremap_resource_byname(pdev, 222 "fn2"); 223 if (IS_ERR(drvdata->fn2)) 224 return dev_err_probe(dev, PTR_ERR(drvdata->fn2), 225 "failed to map fn2\n"); 226 227 hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev, 228 "hpe_gxp_fan_ctrl", 229 drvdata, 230 &gxp_fan_ctrl_chip_info, 231 NULL); 232 233 return PTR_ERR_OR_ZERO(hwmon_dev); 234 } 235 236 static const struct of_device_id gxp_fan_ctrl_of_match[] = { 237 { .compatible = "hpe,gxp-fan-ctrl", }, 238 {}, 239 }; 240 MODULE_DEVICE_TABLE(of, gxp_fan_ctrl_of_match); 241 242 static struct platform_driver gxp_fan_ctrl_driver = { 243 .probe = gxp_fan_ctrl_probe, 244 .driver = { 245 .name = "gxp-fan-ctrl", 246 .of_match_table = gxp_fan_ctrl_of_match, 247 }, 248 }; 249 module_platform_driver(gxp_fan_ctrl_driver); 250 251 MODULE_AUTHOR("Nick Hawkins <nick.hawkins@hpe.com>"); 252 MODULE_DESCRIPTION("HPE GXP fan controller"); 253 MODULE_LICENSE("GPL"); 254