1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204 |
- // SPDX-License-Identifier: GPL-2.0-only
- /*
- * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC
- *
- * Authors:
- * Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>
- * Serge Semin <Sergey.Semin@baikalelectronics.ru>
- *
- * 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/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[] = {
- PVT_SENSOR_INFO(0, "CPU Core Temperature", hwmon_temp, TEMP, TTHRES),
- PVT_SENSOR_INFO(0, "CPU Core Voltage", hwmon_in, VOLT, VTHRES),
- PVT_SENSOR_INFO(1, "CPU Core Low-Vt", hwmon_in, LVT, LTHRES),
- PVT_SENSOR_INFO(2, "CPU Core High-Vt", hwmon_in, HVT, HTHRES),
- PVT_SENSOR_INFO(3, "CPU Core Standard-Vt", hwmon_in, SVT, STHRES),
- };
- /*
- * 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 pvt_poly __maybe_unused poly_temp_to_N = {
- .total_divider = 10000,
- .terms = {
- {4, 18322, 10000, 10000},
- {3, 2343, 10000, 10},
- {2, 87018, 10000, 10},
- {1, 39269, 1000, 1},
- {0, 1720400, 1, 1}
- }
- };
- static const struct pvt_poly poly_N_to_temp = {
- .total_divider = 1,
- .terms = {
- {4, -16743, 1000, 1},
- {3, 81542, 1000, 1},
- {2, -182010, 1000, 1},
- {1, 310200, 1000, 1},
- {0, -48380, 1, 1}
- }
- };
- /*
- * 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 pvt_poly __maybe_unused poly_volt_to_N = {
- .total_divider = 10,
- .terms = {
- {1, 18658, 1000, 1},
- {0, -11572, 1, 1}
- }
- };
- static const struct pvt_poly poly_N_to_volt = {
- .total_divider = 10,
- .terms = {
- {1, 100000, 18658, 1},
- {0, 115720000, 1, 18658}
- }
- };
- /*
- * Here is the polynomial calculation function, which performs the
- * redistributed terms calculations. It's pretty straightforward. We walk
- * over each degree term up to the free one, and perform the redistributed
- * multiplication of the term coefficient, its divider (as for the rationale
- * fraction representation), data power and the rational fraction divider
- * leftover. Then all of this is collected in a total sum variable, which
- * value is normalized by the total divider before being returned.
- */
- static long pvt_calc_poly(const struct pvt_poly *poly, long data)
- {
- const struct pvt_poly_term *term = poly->terms;
- long tmp, ret = 0;
- int deg;
- do {
- tmp = term->coef;
- for (deg = 0; deg < term->deg; ++deg)
- tmp = mult_frac(tmp, data, term->divider);
- ret += tmp / term->divider_leftover;
- } while ((term++)->deg);
- return ret / poly->total_divider;
- }
- static inline u32 pvt_update(void __iomem *reg, u32 mask, u32 data)
- {
- u32 old;
- old = readl_relaxed(reg);
- writel((old & ~mask) | (data & mask), reg);
- return old & mask;
- }
- /*
- * 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)
- {
- u32 old;
- mode = FIELD_PREP(PVT_CTRL_MODE_MASK, mode);
- old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_MODE_MASK | PVT_CTRL_EN,
- mode | old);
- }
- static inline u32 pvt_calc_trim(long temp)
- {
- temp = clamp_val(temp, 0, PVT_TRIM_TEMP);
- return DIV_ROUND_UP(temp, PVT_TRIM_STEP);
- }
- static inline void pvt_set_trim(struct pvt_hwmon *pvt, u32 trim)
- {
- u32 old;
- trim = FIELD_PREP(PVT_CTRL_TRIM_MASK, trim);
- old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_TRIM_MASK | PVT_CTRL_EN,
- trim | old);
- }
- static inline void pvt_set_tout(struct pvt_hwmon *pvt, u32 tout)
- {
- u32 old;
- old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- writel(tout, pvt->regs + PVT_TTIMEOUT);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, old);
- }
- /*
- * 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 NULL
- static irqreturn_t pvt_soft_isr(int irq, void *data)
- {
- const struct pvt_sensor_info *info;
- struct pvt_hwmon *pvt = data;
- struct pvt_cache *cache;
- u32 val, thres_sts, old;
- /*
- * DVALID bit will be cleared by reading the data. We need to save the
- * status before the next conversion happens. Threshold events will be
- * handled a bit later.
- */
- thres_sts = readl(pvt->regs + PVT_RAW_INTR_STAT);
- /*
- * Then lets recharge the PVT interface with the next sampling mode.
- * Lock the interface mutex to serialize trim, timeouts and alarm
- * thresholds settings.
- */
- cache = &pvt->cache[pvt->sensor];
- info = &pvt_info[pvt->sensor];
- pvt->sensor = (pvt->sensor == PVT_SENSOR_LAST) ?
- PVT_SENSOR_FIRST : (pvt->sensor + 1);
- /*
- * For some reason we have to mask the interrupt before changing the
- * mode, otherwise sometimes the temperature mode doesn't get
- * activated even though the actual mode in the ctrl register
- * corresponds to one. Then we read the data. By doing so we also
- * recharge the data conversion. After this the mode corresponding
- * to the next sensor in the row is set. Finally we enable the
- * interrupts back.
- */
- mutex_lock(&pvt->iface_mtx);
- old = pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
- PVT_INTR_DVALID);
- val = readl(pvt->regs + PVT_DATA);
- pvt_set_mode(pvt, pvt_info[pvt->sensor].mode);
- pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, old);
- mutex_unlock(&pvt->iface_mtx);
- /*
- * We can now update the data cache with data just retrieved from the
- * sensor. Lock write-seqlock to make sure the reader has a coherent
- * data.
- */
- write_seqlock(&cache->data_seqlock);
- cache->data = FIELD_GET(PVT_DATA_DATA_MASK, val);
- write_sequnlock(&cache->data_seqlock);
- /*
- * While PVT core is doing the next mode data conversion, we'll check
- * whether the alarms were triggered for the current sensor. Note that
- * according to the documentation only one threshold IRQ status can be
- * set at a time, that's why if-else statement is utilized.
- */
- if ((thres_sts & info->thres_sts_lo) ^ cache->thres_sts_lo) {
- WRITE_ONCE(cache->thres_sts_lo, thres_sts & info->thres_sts_lo);
- hwmon_notify_event(pvt->hwmon, info->type, info->attr_min_alarm,
- info->channel);
- } else if ((thres_sts & info->thres_sts_hi) ^ cache->thres_sts_hi) {
- WRITE_ONCE(cache->thres_sts_hi, thres_sts & info->thres_sts_hi);
- hwmon_notify_event(pvt->hwmon, info->type, info->attr_max_alarm,
- info->channel);
- }
- return IRQ_HANDLED;
- }
- static inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type)
- {
- return 0644;
- }
- static inline umode_t pvt_alarm_is_visible(enum pvt_sensor_type type)
- {
- return 0444;
- }
- static int pvt_read_data(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
- long *val)
- {
- struct pvt_cache *cache = &pvt->cache[type];
- unsigned int seq;
- u32 data;
- do {
- seq = read_seqbegin(&cache->data_seqlock);
- data = cache->data;
- } while (read_seqretry(&cache->data_seqlock, seq));
- if (type == PVT_TEMP)
- *val = pvt_calc_poly(&poly_N_to_temp, data);
- else
- *val = pvt_calc_poly(&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)
- {
- u32 data;
- /* No need in serialization, since it is just read from MMIO. */
- data = readl(pvt->regs + pvt_info[type].thres_base);
- if (is_low)
- data = FIELD_GET(PVT_THRES_LO_MASK, data);
- else
- data = FIELD_GET(PVT_THRES_HI_MASK, data);
- if (type == PVT_TEMP)
- *val = pvt_calc_poly(&poly_N_to_temp, data);
- else
- *val = pvt_calc_poly(&poly_N_to_volt, data);
- return 0;
- }
- static int pvt_write_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
- bool is_low, long val)
- {
- u32 data, limit, mask;
- int ret;
- if (type == PVT_TEMP) {
- val = clamp(val, PVT_TEMP_MIN, PVT_TEMP_MAX);
- data = pvt_calc_poly(&poly_temp_to_N, val);
- } else {
- val = clamp(val, PVT_VOLT_MIN, PVT_VOLT_MAX);
- data = pvt_calc_poly(&poly_volt_to_N, val);
- }
- /* Serialize limit update, since a part of the register is changed. */
- ret = mutex_lock_interruptible(&pvt->iface_mtx);
- if (ret)
- return ret;
- /* Make sure the upper and lower ranges don't intersect. */
- limit = readl(pvt->regs + pvt_info[type].thres_base);
- if (is_low) {
- limit = FIELD_GET(PVT_THRES_HI_MASK, limit);
- data = clamp_val(data, PVT_DATA_MIN, limit);
- data = FIELD_PREP(PVT_THRES_LO_MASK, data);
- mask = PVT_THRES_LO_MASK;
- } else {
- limit = FIELD_GET(PVT_THRES_LO_MASK, limit);
- data = clamp_val(data, limit, PVT_DATA_MAX);
- data = FIELD_PREP(PVT_THRES_HI_MASK, data);
- mask = PVT_THRES_HI_MASK;
- }
- pvt_update(pvt->regs + pvt_info[type].thres_base, mask, data);
- mutex_unlock(&pvt->iface_mtx);
- return 0;
- }
- static int pvt_read_alarm(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
- bool is_low, long *val)
- {
- if (is_low)
- *val = !!READ_ONCE(pvt->cache[type].thres_sts_lo);
- else
- *val = !!READ_ONCE(pvt->cache[type].thres_sts_hi);
- return 0;
- }
- static const struct hwmon_channel_info *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_MIN | HWMON_T_MIN_ALARM |
- HWMON_T_MAX | HWMON_T_MAX_ALARM |
- HWMON_T_OFFSET),
- HWMON_CHANNEL_INFO(in,
- HWMON_I_INPUT | HWMON_I_LABEL |
- HWMON_I_MIN | HWMON_I_MIN_ALARM |
- HWMON_I_MAX | HWMON_I_MAX_ALARM,
- HWMON_I_INPUT | HWMON_I_LABEL |
- HWMON_I_MIN | HWMON_I_MIN_ALARM |
- HWMON_I_MAX | HWMON_I_MAX_ALARM,
- HWMON_I_INPUT | HWMON_I_LABEL |
- HWMON_I_MIN | HWMON_I_MIN_ALARM |
- HWMON_I_MAX | HWMON_I_MAX_ALARM,
- HWMON_I_INPUT | HWMON_I_LABEL |
- HWMON_I_MIN | HWMON_I_MIN_ALARM |
- HWMON_I_MAX | HWMON_I_MAX_ALARM),
- NULL
- };
- #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 NULL
- 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 = pvt_calc_poly(&poly_N_to_temp, data);
- else
- *val = pvt_calc_poly(&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 *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)
- {
- switch (type) {
- case hwmon_temp:
- if (ch < 0 || ch >= PVT_TEMP_CHS)
- return false;
- break;
- case hwmon_in:
- if (ch < 0 || ch >= PVT_VOLT_CHS)
- return false;
- break;
- default:
- break;
- }
- /* The rest of the types are independent from the channel number. */
- return true;
- }
- static umode_t pvt_hwmon_is_visible(const void *data,
- enum hwmon_sensor_types type,
- u32 attr, int ch)
- {
- if (!pvt_hwmon_channel_is_valid(type, ch))
- return 0;
- switch (type) {
- case hwmon_chip:
- switch (attr) {
- case hwmon_chip_update_interval:
- return 0644;
- }
- break;
- case hwmon_temp:
- switch (attr) {
- case hwmon_temp_input:
- case hwmon_temp_type:
- case hwmon_temp_label:
- return 0444;
- case hwmon_temp_min:
- case hwmon_temp_max:
- return pvt_limit_is_visible(ch);
- case hwmon_temp_min_alarm:
- case hwmon_temp_max_alarm:
- return pvt_alarm_is_visible(ch);
- case hwmon_temp_offset:
- return 0644;
- }
- break;
- case hwmon_in:
- switch (attr) {
- case hwmon_in_input:
- case hwmon_in_label:
- return 0444;
- case hwmon_in_min:
- case hwmon_in_max:
- return pvt_limit_is_visible(PVT_VOLT + ch);
- case hwmon_in_min_alarm:
- case hwmon_in_max_alarm:
- return pvt_alarm_is_visible(PVT_VOLT + ch);
- }
- break;
- default:
- break;
- }
- return 0;
- }
- static int pvt_read_trim(struct pvt_hwmon *pvt, long *val)
- {
- u32 data;
- data = readl(pvt->regs + PVT_CTRL);
- *val = FIELD_GET(PVT_CTRL_TRIM_MASK, data) * PVT_TRIM_STEP;
- return 0;
- }
- static int pvt_write_trim(struct pvt_hwmon *pvt, long val)
- {
- u32 trim;
- int ret;
- /*
- * Serialize trim update, since a part of the register is changed and
- * the controller is supposed to be disabled during this operation.
- */
- ret = mutex_lock_interruptible(&pvt->iface_mtx);
- if (ret)
- return ret;
- trim = pvt_calc_trim(val);
- pvt_set_trim(pvt, trim);
- mutex_unlock(&pvt->iface_mtx);
- return 0;
- }
- static int pvt_read_timeout(struct pvt_hwmon *pvt, long *val)
- {
- int ret;
- ret = mutex_lock_interruptible(&pvt->iface_mtx);
- if (ret)
- return ret;
- /* Return the result in msec as hwmon sysfs interface requires. */
- *val = ktime_to_ms(pvt->timeout);
- mutex_unlock(&pvt->iface_mtx);
- return 0;
- }
- static int pvt_write_timeout(struct pvt_hwmon *pvt, long val)
- {
- unsigned long rate;
- ktime_t kt, cache;
- u32 data;
- int ret;
- rate = clk_get_rate(pvt->clks[PVT_CLOCK_REF].clk);
- if (!rate)
- return -ENODEV;
- /*
- * If alarms are enabled, the requested timeout must be divided
- * between all available sensors to have the requested delay
- * applicable to each individual sensor.
- */
- cache = kt = ms_to_ktime(val);
- #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- kt = ktime_divns(kt, PVT_SENSORS_NUM);
- #endif
- /*
- * Subtract a constant lag, which always persists due to the limited
- * PVT sampling rate. Make sure the timeout is not negative.
- */
- kt = ktime_sub_ns(kt, PVT_TOUT_MIN);
- if (ktime_to_ns(kt) < 0)
- kt = ktime_set(0, 0);
- /*
- * Finally recalculate the timeout in terms of the reference clock
- * period.
- */
- data = ktime_divns(kt * rate, NSEC_PER_SEC);
- /*
- * Update the measurements delay, but lock the interface first, since
- * we have to disable PVT in order to have the new delay actually
- * updated.
- */
- ret = mutex_lock_interruptible(&pvt->iface_mtx);
- if (ret)
- return ret;
- pvt_set_tout(pvt, data);
- pvt->timeout = cache;
- mutex_unlock(&pvt->iface_mtx);
- return 0;
- }
- static int pvt_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
- u32 attr, int ch, long *val)
- {
- struct pvt_hwmon *pvt = dev_get_drvdata(dev);
- if (!pvt_hwmon_channel_is_valid(type, ch))
- return -EINVAL;
- switch (type) {
- case hwmon_chip:
- switch (attr) {
- case hwmon_chip_update_interval:
- return pvt_read_timeout(pvt, val);
- }
- break;
- case hwmon_temp:
- switch (attr) {
- case hwmon_temp_input:
- return pvt_read_data(pvt, ch, val);
- case hwmon_temp_type:
- *val = 1;
- return 0;
- case hwmon_temp_min:
- return pvt_read_limit(pvt, ch, true, val);
- case hwmon_temp_max:
- return pvt_read_limit(pvt, ch, false, val);
- case hwmon_temp_min_alarm:
- return pvt_read_alarm(pvt, ch, true, val);
- case hwmon_temp_max_alarm:
- return pvt_read_alarm(pvt, ch, false, val);
- case hwmon_temp_offset:
- return pvt_read_trim(pvt, val);
- }
- break;
- case hwmon_in:
- switch (attr) {
- case hwmon_in_input:
- return pvt_read_data(pvt, PVT_VOLT + ch, val);
- case hwmon_in_min:
- return pvt_read_limit(pvt, PVT_VOLT + ch, true, val);
- case hwmon_in_max:
- return pvt_read_limit(pvt, PVT_VOLT + ch, false, val);
- case hwmon_in_min_alarm:
- return pvt_read_alarm(pvt, PVT_VOLT + ch, true, val);
- case hwmon_in_max_alarm:
- return pvt_read_alarm(pvt, PVT_VOLT + ch, false, val);
- }
- break;
- default:
- break;
- }
- return -EOPNOTSUPP;
- }
- static int pvt_hwmon_read_string(struct device *dev,
- enum hwmon_sensor_types type,
- u32 attr, int ch, const char **str)
- {
- if (!pvt_hwmon_channel_is_valid(type, ch))
- return -EINVAL;
- switch (type) {
- case hwmon_temp:
- switch (attr) {
- case hwmon_temp_label:
- *str = pvt_info[ch].label;
- return 0;
- }
- break;
- case hwmon_in:
- switch (attr) {
- case hwmon_in_label:
- *str = pvt_info[PVT_VOLT + ch].label;
- return 0;
- }
- break;
- default:
- break;
- }
- return -EOPNOTSUPP;
- }
- static int pvt_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
- u32 attr, int ch, long val)
- {
- struct pvt_hwmon *pvt = dev_get_drvdata(dev);
- if (!pvt_hwmon_channel_is_valid(type, ch))
- return -EINVAL;
- switch (type) {
- case hwmon_chip:
- switch (attr) {
- case hwmon_chip_update_interval:
- return pvt_write_timeout(pvt, val);
- }
- break;
- case hwmon_temp:
- switch (attr) {
- case hwmon_temp_min:
- return pvt_write_limit(pvt, ch, true, val);
- case hwmon_temp_max:
- return pvt_write_limit(pvt, ch, false, val);
- case hwmon_temp_offset:
- return pvt_write_trim(pvt, val);
- }
- break;
- case hwmon_in:
- switch (attr) {
- case hwmon_in_min:
- return pvt_write_limit(pvt, PVT_VOLT + ch, true, val);
- case hwmon_in_max:
- return pvt_write_limit(pvt, PVT_VOLT + ch, false, val);
- }
- break;
- default:
- break;
- }
- return -EOPNOTSUPP;
- }
- static const struct hwmon_ops pvt_hwmon_ops = {
- .is_visible = pvt_hwmon_is_visible,
- .read = pvt_hwmon_read,
- .read_string = pvt_hwmon_read_string,
- .write = pvt_hwmon_write
- };
- static const struct hwmon_chip_info pvt_hwmon_info = {
- .ops = &pvt_hwmon_ops,
- .info = pvt_channel_info
- };
- static void pvt_clear_data(void *data)
- {
- struct pvt_hwmon *pvt = data;
- #if !defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- int idx;
- for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
- complete_all(&pvt->cache[idx].conversion);
- #endif
- mutex_destroy(&pvt->iface_mtx);
- }
- static struct pvt_hwmon *pvt_create_data(struct platform_device *pdev)
- {
- struct device *dev = &pdev->dev;
- struct pvt_hwmon *pvt;
- int ret, idx;
- pvt = devm_kzalloc(dev, sizeof(*pvt), GFP_KERNEL);
- if (!pvt)
- return ERR_PTR(-ENOMEM);
- ret = devm_add_action(dev, pvt_clear_data, pvt);
- if (ret) {
- dev_err(dev, "Can't add PVT data clear action\n");
- return ERR_PTR(ret);
- }
- pvt->dev = dev;
- pvt->sensor = PVT_SENSOR_FIRST;
- mutex_init(&pvt->iface_mtx);
- #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
- seqlock_init(&pvt->cache[idx].data_seqlock);
- #else
- for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
- init_completion(&pvt->cache[idx].conversion);
- #endif
- return pvt;
- }
- static int pvt_request_regs(struct pvt_hwmon *pvt)
- {
- struct platform_device *pdev = to_platform_device(pvt->dev);
- struct resource *res;
- res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!res) {
- dev_err(pvt->dev, "Couldn't find PVT memresource\n");
- return -EINVAL;
- }
- pvt->regs = devm_ioremap_resource(pvt->dev, res);
- if (IS_ERR(pvt->regs)) {
- dev_err(pvt->dev, "Couldn't map PVT registers\n");
- return PTR_ERR(pvt->regs);
- }
- return 0;
- }
- static void pvt_disable_clks(void *data)
- {
- struct pvt_hwmon *pvt = data;
- clk_bulk_disable_unprepare(PVT_CLOCK_NUM, pvt->clks);
- }
- static int pvt_request_clks(struct pvt_hwmon *pvt)
- {
- int ret;
- pvt->clks[PVT_CLOCK_APB].id = "pclk";
- pvt->clks[PVT_CLOCK_REF].id = "ref";
- ret = devm_clk_bulk_get(pvt->dev, PVT_CLOCK_NUM, pvt->clks);
- if (ret) {
- dev_err(pvt->dev, "Couldn't get PVT clocks descriptors\n");
- return ret;
- }
- ret = clk_bulk_prepare_enable(PVT_CLOCK_NUM, pvt->clks);
- if (ret) {
- dev_err(pvt->dev, "Couldn't enable the PVT clocks\n");
- return ret;
- }
- ret = devm_add_action_or_reset(pvt->dev, pvt_disable_clks, pvt);
- if (ret) {
- dev_err(pvt->dev, "Can't add PVT clocks disable action\n");
- return ret;
- }
- return 0;
- }
- static int pvt_check_pwr(struct pvt_hwmon *pvt)
- {
- unsigned long tout;
- int ret = 0;
- u32 data;
- /*
- * Test out the sensor conversion functionality. If it is not done on
- * time then the domain must have been unpowered and we won't be able
- * to use the device later in this driver.
- * Note If the power source is lost during the normal driver work the
- * data read procedure will either return -ETIMEDOUT (for the
- * alarm-less driver configuration) or just stop the repeated
- * conversion. In the later case alas we won't be able to detect the
- * problem.
- */
- pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_ALL, PVT_INTR_ALL);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN);
- pvt_set_tout(pvt, 0);
- readl(pvt->regs + PVT_DATA);
- tout = PVT_TOUT_MIN / NSEC_PER_USEC;
- usleep_range(tout, 2 * tout);
- data = readl(pvt->regs + PVT_DATA);
- if (!(data & PVT_DATA_VALID)) {
- ret = -ENODEV;
- dev_err(pvt->dev, "Sensor is powered down\n");
- }
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- return ret;
- }
- static int pvt_init_iface(struct pvt_hwmon *pvt)
- {
- unsigned long rate;
- u32 trim, temp;
- rate = clk_get_rate(pvt->clks[PVT_CLOCK_REF].clk);
- if (!rate) {
- dev_err(pvt->dev, "Invalid reference clock rate\n");
- return -ENODEV;
- }
- /*
- * Make sure all interrupts and controller are disabled so not to
- * accidentally have ISR executed before the driver data is fully
- * initialized. Clear the IRQ status as well.
- */
- pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_ALL, PVT_INTR_ALL);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- readl(pvt->regs + PVT_CLR_INTR);
- readl(pvt->regs + PVT_DATA);
- /* Setup default sensor mode, timeout and temperature trim. */
- pvt_set_mode(pvt, pvt_info[pvt->sensor].mode);
- pvt_set_tout(pvt, PVT_TOUT_DEF);
- /*
- * Preserve the current ref-clock based delay (Ttotal) between the
- * sensors data samples in the driver data so not to recalculate it
- * each time on the data requests and timeout reads. It consists of the
- * delay introduced by the internal ref-clock timer (N / Fclk) and the
- * constant timeout caused by each conversion latency (Tmin):
- * Ttotal = N / Fclk + Tmin
- * If alarms are enabled the sensors are polled one after another and
- * in order to get the next measurement of a particular sensor the
- * caller will have to wait for at most until all the others are
- * polled. In that case the formulae will look a bit different:
- * Ttotal = 5 * (N / Fclk + Tmin)
- */
- #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- pvt->timeout = ktime_set(PVT_SENSORS_NUM * PVT_TOUT_DEF, 0);
- pvt->timeout = ktime_divns(pvt->timeout, rate);
- pvt->timeout = ktime_add_ns(pvt->timeout, PVT_SENSORS_NUM * PVT_TOUT_MIN);
- #else
- pvt->timeout = ktime_set(PVT_TOUT_DEF, 0);
- pvt->timeout = ktime_divns(pvt->timeout, rate);
- pvt->timeout = ktime_add_ns(pvt->timeout, PVT_TOUT_MIN);
- #endif
- trim = PVT_TRIM_DEF;
- if (!of_property_read_u32(pvt->dev->of_node,
- "baikal,pvt-temp-offset-millicelsius", &temp))
- trim = pvt_calc_trim(temp);
- pvt_set_trim(pvt, trim);
- return 0;
- }
- static int pvt_request_irq(struct pvt_hwmon *pvt)
- {
- struct platform_device *pdev = to_platform_device(pvt->dev);
- int ret;
- pvt->irq = platform_get_irq(pdev, 0);
- if (pvt->irq < 0)
- return pvt->irq;
- ret = devm_request_threaded_irq(pvt->dev, pvt->irq,
- pvt_hard_isr, pvt_soft_isr,
- #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- IRQF_SHARED | IRQF_TRIGGER_HIGH |
- IRQF_ONESHOT,
- #else
- IRQF_SHARED | IRQF_TRIGGER_HIGH,
- #endif
- "pvt", pvt);
- if (ret) {
- dev_err(pvt->dev, "Couldn't request PVT IRQ\n");
- return ret;
- }
- return 0;
- }
- static int pvt_create_hwmon(struct pvt_hwmon *pvt)
- {
- pvt->hwmon = devm_hwmon_device_register_with_info(pvt->dev, "pvt", pvt,
- &pvt_hwmon_info, NULL);
- if (IS_ERR(pvt->hwmon)) {
- dev_err(pvt->dev, "Couldn't create hwmon device\n");
- return PTR_ERR(pvt->hwmon);
- }
- return 0;
- }
- #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
- static void pvt_disable_iface(void *data)
- {
- struct pvt_hwmon *pvt = data;
- mutex_lock(&pvt->iface_mtx);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
- pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
- PVT_INTR_DVALID);
- mutex_unlock(&pvt->iface_mtx);
- }
- static int pvt_enable_iface(struct pvt_hwmon *pvt)
- {
- int ret;
- ret = devm_add_action(pvt->dev, pvt_disable_iface, pvt);
- if (ret) {
- dev_err(pvt->dev, "Can't add PVT disable interface action\n");
- return ret;
- }
- /*
- * Enable sensors data conversion and IRQ. We need to lock the
- * interface mutex since hwmon has just been created and the
- * corresponding sysfs files are accessible from user-space,
- * which theoretically may cause races.
- */
- mutex_lock(&pvt->iface_mtx);
- pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, 0);
- pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN);
- mutex_unlock(&pvt->iface_mtx);
- return 0;
- }
- #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)
- {
- struct pvt_hwmon *pvt;
- int ret;
- pvt = pvt_create_data(pdev);
- if (IS_ERR(pvt))
- return PTR_ERR(pvt);
- ret = pvt_request_regs(pvt);
- if (ret)
- return ret;
- ret = pvt_request_clks(pvt);
- if (ret)
- return ret;
- ret = pvt_check_pwr(pvt);
- if (ret)
- return ret;
- ret = pvt_init_iface(pvt);
- if (ret)
- return ret;
- ret = pvt_request_irq(pvt);
- if (ret)
- return ret;
- ret = pvt_create_hwmon(pvt);
- if (ret)
- return ret;
- ret = pvt_enable_iface(pvt);
- if (ret)
- return ret;
- return 0;
- }
- static const struct of_device_id pvt_of_match[] = {
- { .compatible = "baikal,bt1-pvt" },
- { }
- };
- MODULE_DEVICE_TABLE(of, pvt_of_match);
- static struct platform_driver pvt_driver = {
- .probe = pvt_probe,
- .driver = {
- .name = "bt1-pvt",
- .of_match_table = pvt_of_match
- }
- };
- module_platform_driver(pvt_driver);
- MODULE_AUTHOR("Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>");
- MODULE_DESCRIPTION("Baikal-T1 PVT driver");
- MODULE_LICENSE("GPL v2");
|