1 // SPDX-License-Identifier: GPL-2.0
3 * Driver for Gateworks System Controller Hardware Monitor module
5 * Copyright (C) 2020 Gateworks Corporation
7 #include <linux/hwmon.h>
8 #include <linux/hwmon-sysfs.h>
9 #include <linux/mfd/gsc.h>
10 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/regmap.h>
14 #include <linux/slab.h>
16 #include <linux/platform_data/gsc_hwmon.h>
18 #define GSC_HWMON_MAX_TEMP_CH 16
19 #define GSC_HWMON_MAX_IN_CH 16
21 #define GSC_HWMON_RESOLUTION 12
22 #define GSC_HWMON_VREF 2500
24 struct gsc_hwmon_data
{
26 struct gsc_hwmon_platform_data
*pdata
;
27 struct regmap
*regmap
;
28 const struct gsc_hwmon_channel
*temp_ch
[GSC_HWMON_MAX_TEMP_CH
];
29 const struct gsc_hwmon_channel
*in_ch
[GSC_HWMON_MAX_IN_CH
];
30 u32 temp_config
[GSC_HWMON_MAX_TEMP_CH
+ 1];
31 u32 in_config
[GSC_HWMON_MAX_IN_CH
+ 1];
32 struct hwmon_channel_info temp_info
;
33 struct hwmon_channel_info in_info
;
34 const struct hwmon_channel_info
*info
[3];
35 struct hwmon_chip_info chip
;
38 static struct regmap_bus gsc_hwmon_regmap_bus
= {
40 .reg_write
= gsc_write
,
43 static const struct regmap_config gsc_hwmon_regmap_config
= {
46 .cache_type
= REGCACHE_NONE
,
49 static ssize_t
pwm_auto_point_temp_show(struct device
*dev
,
50 struct device_attribute
*devattr
,
53 struct gsc_hwmon_data
*hwmon
= dev_get_drvdata(dev
);
54 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
55 u8 reg
= hwmon
->pdata
->fan_base
+ (2 * attr
->index
);
59 ret
= regmap_bulk_read(hwmon
->regmap
, reg
, regs
, 2);
63 ret
= regs
[0] | regs
[1] << 8;
64 return sprintf(buf
, "%d\n", ret
* 10);
67 static ssize_t
pwm_auto_point_temp_store(struct device
*dev
,
68 struct device_attribute
*devattr
,
69 const char *buf
, size_t count
)
71 struct gsc_hwmon_data
*hwmon
= dev_get_drvdata(dev
);
72 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
73 u8 reg
= hwmon
->pdata
->fan_base
+ (2 * attr
->index
);
78 if (kstrtol(buf
, 10, &temp
))
81 temp
= clamp_val(temp
, 0, 10000);
82 temp
= DIV_ROUND_CLOSEST(temp
, 10);
84 regs
[0] = temp
& 0xff;
85 regs
[1] = (temp
>> 8) & 0xff;
86 err
= regmap_bulk_write(hwmon
->regmap
, reg
, regs
, 2);
93 static ssize_t
pwm_auto_point_pwm_show(struct device
*dev
,
94 struct device_attribute
*devattr
,
97 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
99 return sprintf(buf
, "%d\n", 255 * (50 + (attr
->index
* 10)) / 100);
102 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm
, pwm_auto_point_pwm
, 0);
103 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp
, pwm_auto_point_temp
, 0);
105 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_pwm
, pwm_auto_point_pwm
, 1);
106 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_temp
, pwm_auto_point_temp
, 1);
108 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm
, pwm_auto_point_pwm
, 2);
109 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_temp
, pwm_auto_point_temp
, 2);
111 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point4_pwm
, pwm_auto_point_pwm
, 3);
112 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_temp
, pwm_auto_point_temp
, 3);
114 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm
, pwm_auto_point_pwm
, 4);
115 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point5_temp
, pwm_auto_point_temp
, 4);
117 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point6_pwm
, pwm_auto_point_pwm
, 5);
118 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point6_temp
, pwm_auto_point_temp
, 5);
120 static struct attribute
*gsc_hwmon_attributes
[] = {
121 &sensor_dev_attr_pwm1_auto_point1_pwm
.dev_attr
.attr
,
122 &sensor_dev_attr_pwm1_auto_point1_temp
.dev_attr
.attr
,
123 &sensor_dev_attr_pwm1_auto_point2_pwm
.dev_attr
.attr
,
124 &sensor_dev_attr_pwm1_auto_point2_temp
.dev_attr
.attr
,
125 &sensor_dev_attr_pwm1_auto_point3_pwm
.dev_attr
.attr
,
126 &sensor_dev_attr_pwm1_auto_point3_temp
.dev_attr
.attr
,
127 &sensor_dev_attr_pwm1_auto_point4_pwm
.dev_attr
.attr
,
128 &sensor_dev_attr_pwm1_auto_point4_temp
.dev_attr
.attr
,
129 &sensor_dev_attr_pwm1_auto_point5_pwm
.dev_attr
.attr
,
130 &sensor_dev_attr_pwm1_auto_point5_temp
.dev_attr
.attr
,
131 &sensor_dev_attr_pwm1_auto_point6_pwm
.dev_attr
.attr
,
132 &sensor_dev_attr_pwm1_auto_point6_temp
.dev_attr
.attr
,
136 static const struct attribute_group gsc_hwmon_group
= {
137 .attrs
= gsc_hwmon_attributes
,
139 __ATTRIBUTE_GROUPS(gsc_hwmon
);
142 gsc_hwmon_read(struct device
*dev
, enum hwmon_sensor_types type
, u32 attr
,
143 int channel
, long *val
)
145 struct gsc_hwmon_data
*hwmon
= dev_get_drvdata(dev
);
146 const struct gsc_hwmon_channel
*ch
;
153 ch
= hwmon
->in_ch
[channel
];
156 ch
= hwmon
->temp_ch
[channel
];
162 sz
= (ch
->mode
== mode_voltage
) ? 3 : 2;
163 ret
= regmap_bulk_read(hwmon
->regmap
, ch
->reg
, buf
, sz
);
169 tmp
|= (buf
[sz
] << (8 * sz
));
172 case mode_temperature
:
176 case mode_voltage_raw
:
177 tmp
= clamp_val(tmp
, 0, BIT(GSC_HWMON_RESOLUTION
));
178 /* scale based on ref voltage and ADC resolution */
179 tmp
*= GSC_HWMON_VREF
;
180 tmp
>>= GSC_HWMON_RESOLUTION
;
181 /* scale based on optional voltage divider */
182 if (ch
->vdiv
[0] && ch
->vdiv
[1]) {
183 tmp
*= (ch
->vdiv
[0] + ch
->vdiv
[1]);
186 /* adjust by uV offset */
190 /* no adjustment needed */
200 gsc_hwmon_read_string(struct device
*dev
, enum hwmon_sensor_types type
,
201 u32 attr
, int channel
, const char **buf
)
203 struct gsc_hwmon_data
*hwmon
= dev_get_drvdata(dev
);
207 *buf
= hwmon
->in_ch
[channel
]->name
;
210 *buf
= hwmon
->temp_ch
[channel
]->name
;
220 gsc_hwmon_is_visible(const void *_data
, enum hwmon_sensor_types type
, u32 attr
,
226 static const struct hwmon_ops gsc_hwmon_ops
= {
227 .is_visible
= gsc_hwmon_is_visible
,
228 .read
= gsc_hwmon_read
,
229 .read_string
= gsc_hwmon_read_string
,
232 static struct gsc_hwmon_platform_data
*
233 gsc_hwmon_get_devtree_pdata(struct device
*dev
)
235 struct gsc_hwmon_platform_data
*pdata
;
236 struct gsc_hwmon_channel
*ch
;
237 struct fwnode_handle
*child
;
238 struct device_node
*fan
;
241 nchannels
= device_get_child_node_count(dev
);
243 return ERR_PTR(-ENODEV
);
245 pdata
= devm_kzalloc(dev
,
246 sizeof(*pdata
) + nchannels
* sizeof(*ch
),
249 return ERR_PTR(-ENOMEM
);
250 ch
= (struct gsc_hwmon_channel
*)(pdata
+ 1);
251 pdata
->channels
= ch
;
252 pdata
->nchannels
= nchannels
;
254 /* fan controller base address */
255 fan
= of_find_compatible_node(dev
->parent
->of_node
, NULL
, "gw,gsc-fan");
256 if (fan
&& of_property_read_u32(fan
, "reg", &pdata
->fan_base
)) {
257 dev_err(dev
, "fan node without base\n");
258 return ERR_PTR(-EINVAL
);
261 /* allocate structures for channels and count instances of each type */
262 device_for_each_child_node(dev
, child
) {
263 if (fwnode_property_read_string(child
, "label", &ch
->name
)) {
264 dev_err(dev
, "channel without label\n");
265 fwnode_handle_put(child
);
266 return ERR_PTR(-EINVAL
);
268 if (fwnode_property_read_u32(child
, "reg", &ch
->reg
)) {
269 dev_err(dev
, "channel without reg\n");
270 fwnode_handle_put(child
);
271 return ERR_PTR(-EINVAL
);
273 if (fwnode_property_read_u32(child
, "gw,mode", &ch
->mode
)) {
274 dev_err(dev
, "channel without mode\n");
275 fwnode_handle_put(child
);
276 return ERR_PTR(-EINVAL
);
278 if (ch
->mode
> mode_max
) {
279 dev_err(dev
, "invalid channel mode\n");
280 fwnode_handle_put(child
);
281 return ERR_PTR(-EINVAL
);
284 if (!fwnode_property_read_u32(child
,
285 "gw,voltage-offset-microvolt",
287 ch
->mvoffset
/= 1000;
288 fwnode_property_read_u32_array(child
,
289 "gw,voltage-divider-ohms",
290 ch
->vdiv
, ARRAY_SIZE(ch
->vdiv
));
297 static int gsc_hwmon_probe(struct platform_device
*pdev
)
299 struct gsc_dev
*gsc
= dev_get_drvdata(pdev
->dev
.parent
);
300 struct device
*dev
= &pdev
->dev
;
301 struct device
*hwmon_dev
;
302 struct gsc_hwmon_platform_data
*pdata
= dev_get_platdata(dev
);
303 struct gsc_hwmon_data
*hwmon
;
304 const struct attribute_group
**groups
;
308 pdata
= gsc_hwmon_get_devtree_pdata(dev
);
310 return PTR_ERR(pdata
);
313 hwmon
= devm_kzalloc(dev
, sizeof(*hwmon
), GFP_KERNEL
);
317 hwmon
->pdata
= pdata
;
319 hwmon
->regmap
= devm_regmap_init(dev
, &gsc_hwmon_regmap_bus
,
321 &gsc_hwmon_regmap_config
);
322 if (IS_ERR(hwmon
->regmap
))
323 return PTR_ERR(hwmon
->regmap
);
325 for (i
= 0, i_in
= 0, i_temp
= 0; i
< hwmon
->pdata
->nchannels
; i
++) {
326 const struct gsc_hwmon_channel
*ch
= &pdata
->channels
[i
];
329 case mode_temperature
:
330 if (i_temp
== GSC_HWMON_MAX_TEMP_CH
) {
331 dev_err(gsc
->dev
, "too many temp channels\n");
334 hwmon
->temp_ch
[i_temp
] = ch
;
335 hwmon
->temp_config
[i_temp
] = HWMON_T_INPUT
|
340 case mode_voltage_raw
:
341 if (i_in
== GSC_HWMON_MAX_IN_CH
) {
342 dev_err(gsc
->dev
, "too many input channels\n");
345 hwmon
->in_ch
[i_in
] = ch
;
346 hwmon
->in_config
[i_in
] =
347 HWMON_I_INPUT
| HWMON_I_LABEL
;
351 dev_err(gsc
->dev
, "invalid mode: %d\n", ch
->mode
);
356 /* setup config structures */
357 hwmon
->chip
.ops
= &gsc_hwmon_ops
;
358 hwmon
->chip
.info
= hwmon
->info
;
359 hwmon
->info
[0] = &hwmon
->temp_info
;
360 hwmon
->info
[1] = &hwmon
->in_info
;
361 hwmon
->temp_info
.type
= hwmon_temp
;
362 hwmon
->temp_info
.config
= hwmon
->temp_config
;
363 hwmon
->in_info
.type
= hwmon_in
;
364 hwmon
->in_info
.config
= hwmon
->in_config
;
366 groups
= pdata
->fan_base
? gsc_hwmon_groups
: NULL
;
367 hwmon_dev
= devm_hwmon_device_register_with_info(dev
,
368 KBUILD_MODNAME
, hwmon
,
369 &hwmon
->chip
, groups
);
370 return PTR_ERR_OR_ZERO(hwmon_dev
);
373 static const struct of_device_id gsc_hwmon_of_match
[] = {
374 { .compatible
= "gw,gsc-adc", },
378 static struct platform_driver gsc_hwmon_driver
= {
381 .of_match_table
= gsc_hwmon_of_match
,
383 .probe
= gsc_hwmon_probe
,
386 module_platform_driver(gsc_hwmon_driver
);
388 MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");
389 MODULE_DESCRIPTION("GSC hardware monitor driver");
390 MODULE_LICENSE("GPL v2");