// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC * * Authors: * Maxim Kaurkin <[email protected]> * Serge Semin <[email protected]> * * Baikal-T1 Process, Voltage, Temperature sensor driver */ #include <linux/bitfield.h> #include <linux/bitops.h> #include <linux/clk.h> #include <linux/completion.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/hwmon-sysfs.h> #include <linux/hwmon.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/kernel.h> #include <linux/ktime.h> #include <linux/limits.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/polynomial.h> #include <linux/seqlock.h> #include <linux/sysfs.h> #include <linux/types.h> #include "bt1-pvt.h" /* * For the sake of the code simplification we created the sensors info table * with the sensor names, activation modes, threshold registers base address * and the thresholds bit fields. */ static const struct pvt_sensor_info pvt_info[] = …; /* * The original translation formulae of the temperature (in degrees of Celsius) * to PVT data and vice-versa are following: * N = 1.8322e-8*(T^4) + 2.343e-5*(T^3) + 8.7018e-3*(T^2) + 3.9269*(T^1) + * 1.7204e2, * T = -1.6743e-11*(N^4) + 8.1542e-8*(N^3) + -1.8201e-4*(N^2) + * 3.1020e-1*(N^1) - 4.838e1, * where T = [-48.380, 147.438]C and N = [0, 1023]. * They must be accordingly altered to be suitable for the integer arithmetics. * The technique is called 'factor redistribution', which just makes sure the * multiplications and divisions are made so to have a result of the operations * within the integer numbers limit. In addition we need to translate the * formulae to accept millidegrees of Celsius. Here what they look like after * the alterations: * N = (18322e-20*(T^4) + 2343e-13*(T^3) + 87018e-9*(T^2) + 39269e-3*T + * 17204e2) / 1e4, * T = -16743e-12*(D^4) + 81542e-9*(D^3) - 182010e-6*(D^2) + 310200e-3*D - * 48380, * where T = [-48380, 147438] mC and N = [0, 1023]. */ static const struct polynomial __maybe_unused poly_temp_to_N = …; static const struct polynomial poly_N_to_temp = …; /* * Similar alterations are performed for the voltage conversion equations. * The original formulae are: * N = 1.8658e3*V - 1.1572e3, * V = (N + 1.1572e3) / 1.8658e3, * where V = [0.620, 1.168] V and N = [0, 1023]. * After the optimization they looks as follows: * N = (18658e-3*V - 11572) / 10, * V = N * 10^5 / 18658 + 11572 * 10^4 / 18658. */ static const struct polynomial __maybe_unused poly_volt_to_N = …; static const struct polynomial poly_N_to_volt = …; static inline u32 pvt_update(void __iomem *reg, u32 mask, u32 data) { … } /* * Baikal-T1 PVT mode can be updated only when the controller is disabled. * So first we disable it, then set the new mode together with the controller * getting back enabled. The same concerns the temperature trim and * measurements timeout. If it is necessary the interface mutex is supposed * to be locked at the time the operations are performed. */ static inline void pvt_set_mode(struct pvt_hwmon *pvt, u32 mode) { … } static inline u32 pvt_calc_trim(long temp) { … } static inline void pvt_set_trim(struct pvt_hwmon *pvt, u32 trim) { … } static inline void pvt_set_tout(struct pvt_hwmon *pvt, u32 tout) { … } /* * This driver can optionally provide the hwmon alarms for each sensor the PVT * controller supports. The alarms functionality is made compile-time * configurable due to the hardware interface implementation peculiarity * described further in this comment. So in case if alarms are unnecessary in * your system design it's recommended to have them disabled to prevent the PVT * IRQs being periodically raised to get the data cache/alarms status up to * date. * * Baikal-T1 PVT embedded controller is based on the Analog Bits PVT sensor, * but is equipped with a dedicated control wrapper. It exposes the PVT * sub-block registers space via the APB3 bus. In addition the wrapper provides * a common interrupt vector of the sensors conversion completion events and * threshold value alarms. Alas the wrapper interface hasn't been fully thought * through. There is only one sensor can be activated at a time, for which the * thresholds comparator is enabled right after the data conversion is * completed. Due to this if alarms need to be implemented for all available * sensors we can't just set the thresholds and enable the interrupts. We need * to enable the sensors one after another and let the controller to detect * the alarms by itself at each conversion. This also makes pointless to handle * the alarms interrupts, since in occasion they happen synchronously with * data conversion completion. The best driver design would be to have the * completion interrupts enabled only and keep the converted value in the * driver data cache. This solution is implemented if hwmon alarms are enabled * in this driver. In case if the alarms are disabled, the conversion is * performed on demand at the time a sensors input file is read. */ #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS) #define pvt_hard_isr … static irqreturn_t pvt_soft_isr(int irq, void *data) { … } static inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type) { … } static inline umode_t pvt_alarm_is_visible(enum pvt_sensor_type type) { … } static int pvt_read_data(struct pvt_hwmon *pvt, enum pvt_sensor_type type, long *val) { … } static int pvt_read_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long *val) { … } static int pvt_write_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long val) { … } static int pvt_read_alarm(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long *val) { … } static const struct hwmon_channel_info * const pvt_channel_info[] = …; #else /* !CONFIG_SENSORS_BT1_PVT_ALARMS */ static irqreturn_t pvt_hard_isr(int irq, void *data) { struct pvt_hwmon *pvt = data; struct pvt_cache *cache; u32 val; /* * Mask the DVALID interrupt so after exiting from the handler a * repeated conversion wouldn't happen. */ pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, PVT_INTR_DVALID); /* * Nothing special for alarm-less driver. Just read the data, update * the cache and notify a waiter of this event. */ val = readl(pvt->regs + PVT_DATA); if (!(val & PVT_DATA_VALID)) { dev_err(pvt->dev, "Got IRQ when data isn't valid\n"); return IRQ_HANDLED; } cache = &pvt->cache[pvt->sensor]; WRITE_ONCE(cache->data, FIELD_GET(PVT_DATA_DATA_MASK, val)); complete(&cache->conversion); return IRQ_HANDLED; } #define pvt_soft_isr … static inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type) { return 0; } static inline umode_t pvt_alarm_is_visible(enum pvt_sensor_type type) { return 0; } static int pvt_read_data(struct pvt_hwmon *pvt, enum pvt_sensor_type type, long *val) { struct pvt_cache *cache = &pvt->cache[type]; unsigned long timeout; u32 data; int ret; /* * Lock PVT conversion interface until data cache is updated. The * data read procedure is following: set the requested PVT sensor * mode, enable IRQ and conversion, wait until conversion is finished, * then disable conversion and IRQ, and read the cached data. */ ret = mutex_lock_interruptible(&pvt->iface_mtx); if (ret) return ret; pvt->sensor = type; pvt_set_mode(pvt, pvt_info[type].mode); /* * Unmask the DVALID interrupt and enable the sensors conversions. * Do the reverse procedure when conversion is done. */ pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, 0); pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN); /* * Wait with timeout since in case if the sensor is suddenly powered * down the request won't be completed and the caller will hang up on * this procedure until the power is back up again. Multiply the * timeout by the factor of two to prevent a false timeout. */ timeout = 2 * usecs_to_jiffies(ktime_to_us(pvt->timeout)); ret = wait_for_completion_timeout(&cache->conversion, timeout); pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0); pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, PVT_INTR_DVALID); data = READ_ONCE(cache->data); mutex_unlock(&pvt->iface_mtx); if (!ret) return -ETIMEDOUT; if (type == PVT_TEMP) *val = polynomial_calc(&poly_N_to_temp, data); else *val = polynomial_calc(&poly_N_to_volt, data); return 0; } static int pvt_read_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long *val) { return -EOPNOTSUPP; } static int pvt_write_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long val) { return -EOPNOTSUPP; } static int pvt_read_alarm(struct pvt_hwmon *pvt, enum pvt_sensor_type type, bool is_low, long *val) { return -EOPNOTSUPP; } static const struct hwmon_channel_info * const pvt_channel_info[] = { HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL), HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_TYPE | HWMON_T_LABEL | HWMON_T_OFFSET), HWMON_CHANNEL_INFO(in, HWMON_I_INPUT | HWMON_I_LABEL, HWMON_I_INPUT | HWMON_I_LABEL, HWMON_I_INPUT | HWMON_I_LABEL, HWMON_I_INPUT | HWMON_I_LABEL), NULL }; #endif /* !CONFIG_SENSORS_BT1_PVT_ALARMS */ static inline bool pvt_hwmon_channel_is_valid(enum hwmon_sensor_types type, int ch) { … } static umode_t pvt_hwmon_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int ch) { … } static int pvt_read_trim(struct pvt_hwmon *pvt, long *val) { … } static int pvt_write_trim(struct pvt_hwmon *pvt, long val) { … } static int pvt_read_timeout(struct pvt_hwmon *pvt, long *val) { … } static int pvt_write_timeout(struct pvt_hwmon *pvt, long val) { … } static int pvt_hwmon_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int ch, long *val) { … } static int pvt_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, int ch, const char **str) { … } static int pvt_hwmon_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int ch, long val) { … } static const struct hwmon_ops pvt_hwmon_ops = …; static const struct hwmon_chip_info pvt_hwmon_info = …; static void pvt_clear_data(void *data) { … } static struct pvt_hwmon *pvt_create_data(struct platform_device *pdev) { … } static int pvt_request_regs(struct pvt_hwmon *pvt) { … } static void pvt_disable_clks(void *data) { … } static int pvt_request_clks(struct pvt_hwmon *pvt) { … } static int pvt_check_pwr(struct pvt_hwmon *pvt) { … } static int pvt_init_iface(struct pvt_hwmon *pvt) { … } static int pvt_request_irq(struct pvt_hwmon *pvt) { … } static int pvt_create_hwmon(struct pvt_hwmon *pvt) { … } #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS) static void pvt_disable_iface(void *data) { … } static int pvt_enable_iface(struct pvt_hwmon *pvt) { … } #else /* !CONFIG_SENSORS_BT1_PVT_ALARMS */ static int pvt_enable_iface(struct pvt_hwmon *pvt) { return 0; } #endif /* !CONFIG_SENSORS_BT1_PVT_ALARMS */ static int pvt_probe(struct platform_device *pdev) { … } static const struct of_device_id pvt_of_match[] = …; MODULE_DEVICE_TABLE(of, pvt_of_match); static struct platform_driver pvt_driver = …; module_platform_driver(…) …; MODULE_AUTHOR(…) …; MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …;
Codebase Browser
linux