// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2015, The Linux Foundation. All rights reserved. * Copyright (c) 2019, 2020, Linaro Ltd. */ #include <linux/debugfs.h> #include <linux/err.h> #include <linux/io.h> #include <linux/module.h> #include <linux/nvmem-consumer.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/of_platform.h> #include <linux/mfd/syscon.h> #include <linux/platform_device.h> #include <linux/pm.h> #include <linux/regmap.h> #include <linux/slab.h> #include <linux/suspend.h> #include <linux/thermal.h> #include "../thermal_hwmon.h" #include "tsens.h" /** * struct tsens_irq_data - IRQ status and temperature violations * @up_viol: upper threshold violated * @up_thresh: upper threshold temperature value * @up_irq_mask: mask register for upper threshold irqs * @up_irq_clear: clear register for uppper threshold irqs * @low_viol: lower threshold violated * @low_thresh: lower threshold temperature value * @low_irq_mask: mask register for lower threshold irqs * @low_irq_clear: clear register for lower threshold irqs * @crit_viol: critical threshold violated * @crit_thresh: critical threshold temperature value * @crit_irq_mask: mask register for critical threshold irqs * @crit_irq_clear: clear register for critical threshold irqs * * Structure containing data about temperature threshold settings and * irq status if they were violated. */ struct tsens_irq_data { … }; char *qfprom_read(struct device *dev, const char *cname) { … } int tsens_read_calibration(struct tsens_priv *priv, int shift, u32 *p1, u32 *p2, bool backup) { … } int tsens_calibrate_nvmem(struct tsens_priv *priv, int shift) { … } int tsens_calibrate_common(struct tsens_priv *priv) { … } static u32 tsens_read_cell(const struct tsens_single_value *cell, u8 len, u32 *data0, u32 *data1) { … } int tsens_read_calibration_legacy(struct tsens_priv *priv, const struct tsens_legacy_calibration_format *format, u32 *p1, u32 *p2, u32 *cdata0, u32 *cdata1) { … } /* * Use this function on devices where slope and offset calculations * depend on calibration data read from qfprom. On others the slope * and offset values are derived from tz->tzp->slope and tz->tzp->offset * resp. */ void compute_intercept_slope(struct tsens_priv *priv, u32 *p1, u32 *p2, u32 mode) { … } static inline u32 degc_to_code(int degc, const struct tsens_sensor *s) { … } static inline int code_to_degc(u32 adc_code, const struct tsens_sensor *s) { … } /** * tsens_hw_to_mC - Return sign-extended temperature in mCelsius. * @s: Pointer to sensor struct * @field: Index into regmap_field array pointing to temperature data * * This function handles temperature returned in ADC code or deciCelsius * depending on IP version. * * Return: Temperature in milliCelsius on success, a negative errno will * be returned in error cases */ static int tsens_hw_to_mC(const struct tsens_sensor *s, int field) { … } /** * tsens_mC_to_hw - Convert temperature to hardware register value * @s: Pointer to sensor struct * @temp: temperature in milliCelsius to be programmed to hardware * * This function outputs the value to be written to hardware in ADC code * or deciCelsius depending on IP version. * * Return: ADC code or temperature in deciCelsius. */ static int tsens_mC_to_hw(const struct tsens_sensor *s, int temp) { … } static inline enum tsens_ver tsens_version(struct tsens_priv *priv) { … } static void tsens_set_interrupt_v1(struct tsens_priv *priv, u32 hw_id, enum tsens_irq_type irq_type, bool enable) { … } static void tsens_set_interrupt_v2(struct tsens_priv *priv, u32 hw_id, enum tsens_irq_type irq_type, bool enable) { … } /** * tsens_set_interrupt - Set state of an interrupt * @priv: Pointer to tsens controller private data * @hw_id: Hardware ID aka. sensor number * @irq_type: irq_type from enum tsens_irq_type * @enable: false = disable, true = enable * * Call IP-specific function to set state of an interrupt * * Return: void */ static void tsens_set_interrupt(struct tsens_priv *priv, u32 hw_id, enum tsens_irq_type irq_type, bool enable) { … } /** * tsens_threshold_violated - Check if a sensor temperature violated a preset threshold * @priv: Pointer to tsens controller private data * @hw_id: Hardware ID aka. sensor number * @d: Pointer to irq state data * * Return: 0 if threshold was not violated, 1 if it was violated and negative * errno in case of errors */ static int tsens_threshold_violated(struct tsens_priv *priv, u32 hw_id, struct tsens_irq_data *d) { … } static int tsens_read_irq_state(struct tsens_priv *priv, u32 hw_id, const struct tsens_sensor *s, struct tsens_irq_data *d) { … } static inline u32 masked_irq(u32 hw_id, u32 mask, enum tsens_ver ver) { … } /** * tsens_critical_irq_thread() - Threaded handler for critical interrupts * @irq: irq number * @data: tsens controller private data * * Check FSM watchdog bark status and clear if needed. * Check all sensors to find ones that violated their critical threshold limits. * Clear and then re-enable the interrupt. * * The level-triggered interrupt might deassert if the temperature returned to * within the threshold limits by the time the handler got scheduled. We * consider the irq to have been handled in that case. * * Return: IRQ_HANDLED */ static irqreturn_t tsens_critical_irq_thread(int irq, void *data) { … } /** * tsens_irq_thread - Threaded interrupt handler for uplow interrupts * @irq: irq number * @data: tsens controller private data * * Check all sensors to find ones that violated their threshold limits. If the * temperature is still outside the limits, call thermal_zone_device_update() to * update the thresholds, else re-enable the interrupts. * * The level-triggered interrupt might deassert if the temperature returned to * within the threshold limits by the time the handler got scheduled. We * consider the irq to have been handled in that case. * * Return: IRQ_HANDLED */ static irqreturn_t tsens_irq_thread(int irq, void *data) { … } /** * tsens_combined_irq_thread() - Threaded interrupt handler for combined interrupts * @irq: irq number * @data: tsens controller private data * * Handle the combined interrupt as if it were 2 separate interrupts, so call the * critical handler first and then the up/low one. * * Return: IRQ_HANDLED */ static irqreturn_t tsens_combined_irq_thread(int irq, void *data) { … } static int tsens_set_trips(struct thermal_zone_device *tz, int low, int high) { … } static int tsens_enable_irq(struct tsens_priv *priv) { … } static void tsens_disable_irq(struct tsens_priv *priv) { … } int get_temp_tsens_valid(const struct tsens_sensor *s, int *temp) { … } int get_temp_common(const struct tsens_sensor *s, int *temp) { … } #ifdef CONFIG_DEBUG_FS static int dbg_sensors_show(struct seq_file *s, void *data) { … } static int dbg_version_show(struct seq_file *s, void *data) { … } DEFINE_SHOW_ATTRIBUTE(…); DEFINE_SHOW_ATTRIBUTE(…); static void tsens_debug_init(struct platform_device *pdev) { … } #else static inline void tsens_debug_init(struct platform_device *pdev) {} #endif static const struct regmap_config tsens_config = …; static const struct regmap_config tsens_srot_config = …; int __init init_common(struct tsens_priv *priv) { … } static int tsens_get_temp(struct thermal_zone_device *tz, int *temp) { … } static int __maybe_unused tsens_suspend(struct device *dev) { … } static int __maybe_unused tsens_resume(struct device *dev) { … } static SIMPLE_DEV_PM_OPS(tsens_pm_ops, tsens_suspend, tsens_resume); static const struct of_device_id tsens_table[] = …; MODULE_DEVICE_TABLE(of, tsens_table); static const struct thermal_zone_device_ops tsens_of_ops = …; static int tsens_register_irq(struct tsens_priv *priv, char *irqname, irq_handler_t thread_fn) { … } #ifdef CONFIG_SUSPEND static int tsens_reinit(struct tsens_priv *priv) { … } int tsens_resume_common(struct tsens_priv *priv) { … } #endif /* !CONFIG_SUSPEND */ static int tsens_register(struct tsens_priv *priv) { … } static int tsens_probe(struct platform_device *pdev) { … } static void tsens_remove(struct platform_device *pdev) { … } static struct platform_driver tsens_driver = …; module_platform_driver(…) …; MODULE_LICENSE(…) …; MODULE_DESCRIPTION(…) …; MODULE_ALIAS(…) …;
Codebase Browser
linux