// SPDX-License-Identifier: GPL-2.0-only /* * Copyright ( c ) 2014 - 2016 , Fuzhou Rockchip Electronics Co . , Ltd * Caesar Wang < wxt @ rock - chips . com > #include <linux/clk.h>#include <linux/delay.h>#include <linux/interrupt.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_irq.h>#include <linux/platform_device.h>#include <linux/regmap.h>#include <linux/reset.h>#include <linux/thermal.h>#include <linux/mfd/syscon.h>#include <linux/pinctrl/consumer.h>/* * If the temperature over a period of time High , * the resulting TSHUT gave CRU module , let it reset the entire chip , * or via GPIO give PMIC . enum tshut_mode {0 ,/* * The system Temperature Sensors tshut ( tshut ) polarity * the bit 8 is tshut polarity . * 0 : low active , 1 : high active enum tshut_polarity {0 ,/* * The conversion table has the adc value and temperature . * ADC_DECREMENT : the adc value is of diminishing . ( e . g . rk3288_code_table ) * ADC_INCREMENT : the adc value is incremental . ( e . g . rk3368_code_table ) enum adc_sort_mode {0 ,#include "thermal_hwmon.h" /** * struct chip_tsadc_table - hold information about chip - specific differences * @ id : conversion table * @ length : size of conversion table * @ data_mask : mask to apply on data inputs * @ mode : sort mode of this adc variant ( incrementing or decrementing ) struct chip_tsadc_table {const struct tsadc_table *id;unsigned int length;enum adc_sort_mode mode;/** * struct rockchip_tsadc_chip - hold the private data of tsadc chip * @ chn_offset : the channel offset of the first channel * @ chn_num : the channel number of tsadc chip * @ trim_slope : used to convert the trim code to a temperature in millicelsius * @ tshut_temp : the hardware - controlled shutdown temperature value , with no trim * @ tshut_mode : the hardware - controlled shutdown mode ( 0 : CRU 1 : GPIO ) * @ tshut_polarity : the hardware - controlled active polarity ( 0 : LOW 1 : HIGH ) * @ initialize : SoC special initialize tsadc controller method * @ irq_ack : clear the interrupt * @ control : enable / disable method for the tsadc controller * @ get_temp : get the raw temperature , unadjusted by trim * @ set_alarm_temp : set the high temperature interrupt * @ set_tshut_temp : set the hardware - controlled shutdown temperature * @ set_tshut_mode : set the hardware - controlled shutdown mode * @ get_trim_code : convert a hardware temperature code to one adjusted for by trim * @ table : the chip - specific conversion table struct rockchip_tsadc_chip {/* The sensor id of chip correspond to the ADC channel */ int chn_offset;int chn_num;/* Used to convert trim code to trim temp */ int trim_slope;/* The hardware-controlled tshut property */ int tshut_temp;enum tshut_mode tshut_mode;enum tshut_polarity tshut_polarity;/* Chip-wide methods */ void (*initialize)(struct regmap *grf,void __iomem *reg, enum tshut_polarity p);void (*irq_ack)(void __iomem *reg);void (*control)(void __iomem *reg, bool on);/* Per-sensor methods */ int (*get_temp)(const struct chip_tsadc_table *table,int chn, void __iomem *reg, int *temp);int (*set_alarm_temp)(const struct chip_tsadc_table *table,int chn, void __iomem *reg, int temp);int (*set_tshut_temp)(const struct chip_tsadc_table *table,int chn, void __iomem *reg, int temp);void (*set_tshut_mode)(int chn, void __iomem *reg, enum tshut_mode m);int (*get_trim_code)(const struct chip_tsadc_table *table,int code, int trim_base, int trim_base_frac);/* Per-table methods */ struct chip_tsadc_table table;/** * struct rockchip_thermal_sensor - hold the information of thermal sensor * @ thermal : pointer to the platform / configuration data * @ tzd : pointer to a thermal zone * @ of_node : pointer to the device_node representing this sensor , if any * @ id : identifier of the thermal sensor * @ trim_temp : per - sensor trim temperature value struct rockchip_thermal_sensor {struct rockchip_thermal_data *thermal;struct thermal_zone_device *tzd;struct device_node *of_node;int id;int trim_temp;/** * struct rockchip_thermal_data - hold the private data of thermal driver * @ chip : pointer to the platform / configuration data * @ pdev : platform device of thermal * @ reset : the reset controller of tsadc * @ sensors : array of thermal sensors * @ clk : the controller clock is divided by the exteral 24 MHz * @ pclk : the advanced peripherals bus clock * @ grf : the general register file will be used to do static set by software * @ regs : the base address of tsadc controller * @ trim_base : major component of sensor trim value , in Celsius * @ trim_base_frac : minor component of sensor trim value , in Decicelsius * @ trim : fallback thermal trim value for each channel * @ tshut_temp : the hardware - controlled shutdown temperature value , with no trim * @ trim_temp : the fallback trim temperature for the whole sensor * @ tshut_mode : the hardware - controlled shutdown mode ( 0 : CRU 1 : GPIO ) * @ tshut_polarity : the hardware - controlled active polarity ( 0 : LOW 1 : HIGH ) struct rockchip_thermal_data {const struct rockchip_tsadc_chip *chip;struct platform_device *pdev;struct reset_control *reset;struct rockchip_thermal_sensor *sensors;struct clk *clk;struct clk *pclk;struct regmap *grf;void __iomem *regs;int trim_base;int trim_base_frac;int trim;int tshut_temp;int trim_temp;enum tshut_mode tshut_mode;enum tshut_polarity tshut_polarity;/* * TSADC Sensor Register description : * * TSADCV2_ * are used for RK3288 SoCs , the other chips can reuse it . * TSADCV3_ * are used for newer SoCs than RK3288 . ( e . g : RK3228 , RK3399 ) * #define TSADCV2_USER_CON 0 x00#define TSADCV2_AUTO_CON 0 x04#define TSADCV2_INT_EN 0 x08#define TSADCV2_INT_PD 0 x0c#define TSADCV3_AUTO_SRC_CON 0 x0c#define TSADCV3_HT_INT_EN 0 x14#define TSADCV3_HSHUT_GPIO_INT_EN 0 x18#define TSADCV3_HSHUT_CRU_INT_EN 0 x1c#define TSADCV3_INT_PD 0 x24#define TSADCV3_HSHUT_PD 0 x28#define TSADCV2_DATA(chn) (0 x20 + (chn) * 0 x04)#define TSADCV2_COMP_INT(chn) (0 x30 + (chn) * 0 x04)#define TSADCV2_COMP_SHUT(chn) (0 x40 + (chn) * 0 x04)#define TSADCV3_DATA(chn) (0 x2c + (chn) * 0 x04)#define TSADCV3_COMP_INT(chn) (0 x6c + (chn) * 0 x04)#define TSADCV3_COMP_SHUT(chn) (0 x10c + (chn) * 0 x04)#define TSADCV2_HIGHT_INT_DEBOUNCE 0 x60#define TSADCV2_HIGHT_TSHUT_DEBOUNCE 0 x64#define TSADCV3_HIGHT_INT_DEBOUNCE 0 x14c#define TSADCV3_HIGHT_TSHUT_DEBOUNCE 0 x150#define TSADCV2_AUTO_PERIOD 0 x68#define TSADCV2_AUTO_PERIOD_HT 0 x6c#define TSADCV3_AUTO_PERIOD 0 x154#define TSADCV3_AUTO_PERIOD_HT 0 x158#define TSADCV2_AUTO_EN BIT(0 )#define TSADCV2_AUTO_EN_MASK BIT(16 )#define TSADCV2_AUTO_SRC_EN(chn) BIT(4 + (chn))#define TSADCV3_AUTO_SRC_EN(chn) BIT(chn)#define TSADCV3_AUTO_SRC_EN_MASK(chn) BIT(16 + chn)#define TSADCV2_AUTO_TSHUT_POLARITY_HIGH BIT(8 )#define TSADCV2_AUTO_TSHUT_POLARITY_MASK BIT(24 )#define TSADCV3_AUTO_Q_SEL_EN BIT(1 )#define TSADCV2_INT_SRC_EN(chn) BIT(chn)#define TSADCV2_INT_SRC_EN_MASK(chn) BIT(16 + (chn))#define TSADCV2_SHUT_2GPIO_SRC_EN(chn) BIT(4 + (chn))#define TSADCV2_SHUT_2CRU_SRC_EN(chn) BIT(8 + (chn))#define TSADCV2_INT_PD_CLEAR_MASK ~BIT(8 )#define TSADCV3_INT_PD_CLEAR_MASK ~BIT(16 )#define TSADCV4_INT_PD_CLEAR_MASK 0 xffffffff#define TSADCV2_DATA_MASK 0 xfff#define TSADCV3_DATA_MASK 0 x3ff#define TSADCV4_DATA_MASK 0 x1ff#define TSADCV2_HIGHT_INT_DEBOUNCE_COUNT 4 #define TSADCV2_HIGHT_TSHUT_DEBOUNCE_COUNT 4 #define TSADCV2_AUTO_PERIOD_TIME 250 /* 250ms */ #define TSADCV2_AUTO_PERIOD_HT_TIME 50 /* 50ms */ #define TSADCV3_AUTO_PERIOD_TIME 1875 /* 2.5ms */ #define TSADCV3_AUTO_PERIOD_HT_TIME 1875 /* 2.5ms */ #define TSADCV5_AUTO_PERIOD_TIME 1622 /* 2.5ms */ #define TSADCV5_AUTO_PERIOD_HT_TIME 1622 /* 2.5ms */ #define TSADCV6_AUTO_PERIOD_TIME 5000 /* 2.5ms */ #define TSADCV6_AUTO_PERIOD_HT_TIME 5000 /* 2.5ms */ #define TSADCV2_USER_INTER_PD_SOC 0 x340 /* 13 clocks */ #define TSADCV5_USER_INTER_PD_SOC 0 xfc0 /* 97us, at least 90us */ #define GRF_SARADC_TESTBIT 0 x0e644#define GRF_TSADC_TESTBIT_L 0 x0e648#define GRF_TSADC_TESTBIT_H 0 x0e64c#define PX30_GRF_SOC_CON2 0 x0408#define RK3568_GRF_TSADC_CON 0 x0600#define RK3568_GRF_TSADC_ANA_REG0 (0 x10001 << 0 )#define RK3568_GRF_TSADC_ANA_REG1 (0 x10001 << 1 )#define RK3568_GRF_TSADC_ANA_REG2 (0 x10001 << 2 )#define RK3568_GRF_TSADC_TSEN (0 x10001 << 8 )#define RK3588_GRF0_TSADC_CON 0 x0100#define RK3588_GRF0_TSADC_TRM (0 xff0077 << 0 )#define RK3588_GRF0_TSADC_SHUT_2CRU (0 x30003 << 10 )#define RK3588_GRF0_TSADC_SHUT_2GPIO (0 x70007 << 12 )#define GRF_SARADC_TESTBIT_ON (0 x10001 << 2 )#define GRF_TSADC_TESTBIT_H_ON (0 x10001 << 2 )#define GRF_TSADC_VCM_EN_L (0 x10001 << 7 )#define GRF_TSADC_VCM_EN_H (0 x10001 << 7 )#define GRF_CON_TSADC_CH_INV (0 x10001 << 1 )#define RK_MAX_TEMP (180000 )/** * struct tsadc_table - code to temperature conversion table * @ code : the value of adc channel * @ temp : the temperature * Note : * code to temperature mapping of the temperature sensor is a piece wise linear * curve . Any temperature , code faling between to 2 give temperatures can be * linearly interpolated . * Code to Temperature mapping should be updated based on manufacturer results . struct tsadc_table {int temp;static const struct tsadc_table rv1108_table[] = {0 , -40000 },374 , -40000 },382 , -35000 },389 , -30000 },397 , -25000 },405 , -20000 },413 , -15000 },421 , -10000 },429 , -5000 },436 , 0 },444 , 5000 },452 , 10000 },460 , 15000 },468 , 20000 },476 , 25000 },483 , 30000 },491 , 35000 },499 , 40000 },507 , 45000 },515 , 50000 },523 , 55000 },531 , 60000 },539 , 65000 },547 , 70000 },555 , 75000 },562 , 80000 },570 , 85000 },578 , 90000 },586 , 95000 },594 , 100000 },602 , 105000 },610 , 110000 },618 , 115000 },626 , 120000 },634 , 125000 },125000 },static const struct tsadc_table rk3228_code_table[] = {0 , -40000 },588 , -40000 },593 , -35000 },598 , -30000 },603 , -25000 },608 , -20000 },613 , -15000 },618 , -10000 },623 , -5000 },629 , 0 },634 , 5000 },639 , 10000 },644 , 15000 },649 , 20000 },654 , 25000 },660 , 30000 },665 , 35000 },670 , 40000 },675 , 45000 },681 , 50000 },686 , 55000 },691 , 60000 },696 , 65000 },702 , 70000 },707 , 75000 },712 , 80000 },717 , 85000 },723 , 90000 },728 , 95000 },733 , 100000 },738 , 105000 },744 , 110000 },749 , 115000 },754 , 120000 },760 , 125000 },125000 },static const struct tsadc_table rk3288_code_table[] = {40000 },3800 , -40000 },3792 , -35000 },3783 , -30000 },3774 , -25000 },3765 , -20000 },3756 , -15000 },3747 , -10000 },3737 , -5000 },3728 , 0 },3718 , 5000 },3708 , 10000 },3698 , 15000 },3688 , 20000 },3678 , 25000 },3667 , 30000 },3656 , 35000 },3645 , 40000 },3634 , 45000 },3623 , 50000 },3611 , 55000 },3600 , 60000 },3588 , 65000 },3575 , 70000 },3563 , 75000 },3550 , 80000 },3537 , 85000 },3524 , 90000 },3510 , 95000 },3496 , 100000 },3482 , 105000 },3467 , 110000 },3452 , 115000 },3437 , 120000 },3421 , 125000 },0 , 125000 },static const struct tsadc_table rk3328_code_table[] = {0 , -40000 },296 , -40000 },304 , -35000 },313 , -30000 },322 , -25000 },331 , -20000 },340 , -15000 },349 , -10000 },359 , -5000 },368 , 0 },378 , 5000 },388 , 10000 },398 , 15000 },408 , 20000 },418 , 25000 },429 , 30000 },440 , 35000 },451 , 40000 },462 , 45000 },473 , 50000 },485 , 55000 },496 , 60000 },508 , 65000 },521 , 70000 },533 , 75000 },546 , 80000 },559 , 85000 },572 , 90000 },586 , 95000 },600 , 100000 },614 , 105000 },629 , 110000 },644 , 115000 },659 , 120000 },675 , 125000 },125000 },static const struct tsadc_table rk3368_code_table[] = {0 , -40000 },106 , -40000 },108 , -35000 },110 , -30000 },112 , -25000 },114 , -20000 },116 , -15000 },118 , -10000 },120 , -5000 },122 , 0 },124 , 5000 },126 , 10000 },128 , 15000 },130 , 20000 },132 , 25000 },134 , 30000 },136 , 35000 },138 , 40000 },140 , 45000 },142 , 50000 },144 , 55000 },146 , 60000 },148 , 65000 },150 , 70000 },152 , 75000 },154 , 80000 },156 , 85000 },158 , 90000 },160 , 95000 },162 , 100000 },163 , 105000 },165 , 110000 },167 , 115000 },169 , 120000 },171 , 125000 },125000 },static const struct tsadc_table rk3399_code_table[] = {0 , -40000 },402 , -40000 },410 , -35000 },419 , -30000 },427 , -25000 },436 , -20000 },444 , -15000 },453 , -10000 },461 , -5000 },470 , 0 },478 , 5000 },487 , 10000 },496 , 15000 },504 , 20000 },513 , 25000 },521 , 30000 },530 , 35000 },538 , 40000 },547 , 45000 },555 , 50000 },564 , 55000 },573 , 60000 },581 , 65000 },590 , 70000 },599 , 75000 },607 , 80000 },616 , 85000 },624 , 90000 },633 , 95000 },642 , 100000 },650 , 105000 },659 , 110000 },668 , 115000 },677 , 120000 },685 , 125000 },125000 },static const struct tsadc_table rk3568_code_table[] = {0 , -40000 },1584 , -40000 },1620 , -35000 },1652 , -30000 },1688 , -25000 },1720 , -20000 },1756 , -15000 },1788 , -10000 },1824 , -5000 },1856 , 0 },1892 , 5000 },1924 , 10000 },1956 , 15000 },1992 , 20000 },2024 , 25000 },2060 , 30000 },2092 , 35000 },2128 , 40000 },2160 , 45000 },2196 , 50000 },2228 , 55000 },2264 , 60000 },2300 , 65000 },2332 , 70000 },2368 , 75000 },2400 , 80000 },2436 , 85000 },2468 , 90000 },2500 , 95000 },2536 , 100000 },2572 , 105000 },2604 , 110000 },2636 , 115000 },2672 , 120000 },2704 , 125000 },125000 },static const struct tsadc_table rk3588_code_table[] = {0 , -40000 },215 , -40000 },285 , 25000 },350 , 85000 },395 , 125000 },125000 },static u32 rk_tsadcv2_temp_to_code(const struct chip_tsadc_table *table,int temp)int high, low, mid;unsigned long num;unsigned int denom;0 ;1 ) - 1 ; /* ignore the last check for table */ 2 ;/* Return mask code data when the temp is over table range */ if (temp < table->id[low].temp || temp > table->id[high].temp)goto exit ;while (low <= high) {if (temp == table->id[mid].temp)return table->id[mid].code;else if (temp < table->id[mid].temp)1 ;else 1 ;2 ;/* * The conversion code granularity provided by the table . Let ' s * assume that the relationship between temperature and * analog value between 2 table entries is linear and interpolate * to produce less granular result . 1 ].code - table->id[mid].code);1 ].temp - table->id[mid].temp;switch (table->mode) {case ADC_DECREMENT:return table->id[mid].code - (num / denom);case ADC_INCREMENT:return table->id[mid].code + (num / denom);default :"%s: unknown table mode: %d\n" , __func__, table->mode);return error;exit :"%s: invalid temperature, temp=%d error=%d\n" ,return error;static int rk_tsadcv2_code_to_temp(const struct chip_tsadc_table *table,int *temp)unsigned int low = 1 ;unsigned int high = table->length - 1 ;unsigned int mid = (low + high) / 2 ;unsigned int num;unsigned long denom;2 );switch (table->mode) {case ADC_DECREMENT:if (code <= table->id[high].code)return -EAGAIN; /* Incorrect reading */ while (low <= high) {if (code >= table->id[mid].code &&1 ].code)break ;else if (code < table->id[mid].code)1 ;else 1 ;2 ;break ;case ADC_INCREMENT:if (code < table->id[low].code)return -EAGAIN; /* Incorrect reading */ while (low <= high) {if (code <= table->id[mid].code &&1 ].code)break ;else if (code > table->id[mid].code)1 ;else 1 ;2 ;break ;default :"%s: unknown table mode: %d\n" , __func__, table->mode);return -EINVAL;/* * The 5 C granularity provided by the table is too much . Let ' s * assume that the relationship between sensor readings and * temperature between 2 table entries is linear and interpolate * to produce less granular result . 1 ].temp;1 ].code - code);1 ].code - table->id[mid].code);1 ].temp + (num / denom);return 0 ;/** * rk_tsadcv2_initialize - initialize TASDC Controller . * @ grf : the general register file will be used to do static set by software * @ regs : the base address of tsadc controller * @ tshut_polarity : the hardware - controlled active polarity ( 0 : LOW 1 : HIGH ) * * ( 1 ) Set TSADC_V2_AUTO_PERIOD : * Configure the interleave between every two accessing of * TSADC in normal operation . * * ( 2 ) Set TSADCV2_AUTO_PERIOD_HT : * Configure the interleave between every two accessing of * TSADC after the temperature is higher than COM_SHUT or COM_INT . * * ( 3 ) Set TSADCV2_HIGH_INT_DEBOUNCE and TSADC_HIGHT_TSHUT_DEBOUNCE : * If the temperature is higher than COMP_INT or COMP_SHUT for * " debounce " times , TSADC controller will generate interrupt or TSHUT . static void rk_tsadcv2_initialize(struct regmap *grf, void __iomem *regs,enum tshut_polarity tshut_polarity)if (tshut_polarity == TSHUT_HIGH_ACTIVE)0 U | TSADCV2_AUTO_TSHUT_POLARITY_HIGH,else 0 U & ~TSADCV2_AUTO_TSHUT_POLARITY_HIGH,/** * rk_tsadcv3_initialize - initialize TASDC Controller . * @ grf : the general register file will be used to do static set by software * @ regs : the base address of tsadc controller * @ tshut_polarity : the hardware - controlled active polarity ( 0 : LOW 1 : HIGH ) * * ( 1 ) The tsadc control power sequence . * * ( 2 ) Set TSADC_V2_AUTO_PERIOD : * Configure the interleave between every two accessing of * TSADC in normal operation . * * ( 2 ) Set TSADCV2_AUTO_PERIOD_HT : * Configure the interleave between every two accessing of * TSADC after the temperature is higher than COM_SHUT or COM_INT . * * ( 3 ) Set TSADCV2_HIGH_INT_DEBOUNCE and TSADC_HIGHT_TSHUT_DEBOUNCE : * If the temperature is higher than COMP_INT or COMP_SHUT for * " debounce " times , TSADC controller will generate interrupt or TSHUT . static void rk_tsadcv3_initialize(struct regmap *grf, void __iomem *regs,enum tshut_polarity tshut_polarity)/* The tsadc control power sequence */ if (IS_ERR(grf)) {/* Set interleave value to workround ic time sync issue */ else {/* Enable the voltage common mode feature */ 15 , 100 ); /* The spec note says at least 15 us */ 90 , 200 ); /* The spec note says at least 90 us */ if (tshut_polarity == TSHUT_HIGH_ACTIVE)0 U | TSADCV2_AUTO_TSHUT_POLARITY_HIGH,else 0 U & ~TSADCV2_AUTO_TSHUT_POLARITY_HIGH,static void rk_tsadcv4_initialize(struct regmap *grf, void __iomem *regs,enum tshut_polarity tshut_polarity)static void rk_tsadcv7_initialize(struct regmap *grf, void __iomem *regs,enum tshut_polarity tshut_polarity)if (tshut_polarity == TSHUT_HIGH_ACTIVE)0 U | TSADCV2_AUTO_TSHUT_POLARITY_HIGH,else 0 U & ~TSADCV2_AUTO_TSHUT_POLARITY_HIGH,/* * The general register file will is optional * and might not be available . if (!IS_ERR(grf)) {/* * RK3568 TRM , section 18 . 5 . requires a delay no less * than 10 us between the rising edge of tsadc_tsen_en * and the rising edge of tsadc_ana_reg_0 / 1 / 2 . 15 );/* * RK3568 TRM , section 18 . 5 . requires a delay no less * than 90 us after the rising edge of tsadc_ana_reg_0 / 1 / 2 . 100 , 200 );static void rk_tsadcv8_initialize(struct regmap *grf, void __iomem *regs,enum tshut_polarity tshut_polarity)if (tshut_polarity == TSHUT_HIGH_ACTIVE)else static void rk_tsadcv2_irq_ack(void __iomem *regs)static void rk_tsadcv3_irq_ack(void __iomem *regs)static void rk_tsadcv4_irq_ack(void __iomem *regs)static void rk_tsadcv2_control(void __iomem *regs, bool enable)if (enable)else /** * rk_tsadcv3_control - the tsadc controller is enabled or disabled . * @ regs : the base address of tsadc controller * @ enable : boolean flag to enable the controller * * NOTE : TSADC controller works at auto mode , and some SoCs need set the * tsadc_q_sel bit on TSADCV2_AUTO_CON [ 1 ] . The ( 1024 - tsadc_q ) as output * adc value if setting this bit to enable . static void rk_tsadcv3_control(void __iomem *regs, bool enable)if (enable)else static void rk_tsadcv4_control(void __iomem *regs, bool enable)if (enable)else static int rk_tsadcv2_get_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int *temp)return rk_tsadcv2_code_to_temp(table, val, temp);static int rk_tsadcv4_get_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int *temp)return rk_tsadcv2_code_to_temp(table, val, temp);static int rk_tsadcv2_alarm_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int temp)/* * In some cases , some sensors didn ' t need the trip points , the * set_trips will pass { - INT_MAX , INT_MAX } to trigger tsadc alarm * in the end , ignore this case and disable the high temperature * interrupt . if (temp == INT_MAX) {return 0 ;/* Make sure the value is valid */ if (alarm_value == table->data_mask)return -ERANGE;return 0 ;static int rk_tsadcv3_alarm_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int temp)/* * In some cases , some sensors didn ' t need the trip points , the * set_trips will pass { - INT_MAX , INT_MAX } to trigger tsadc alarm * in the end , ignore this case and disable the high temperature * interrupt . if (temp == INT_MAX) {return 0 ;/* Make sure the value is valid */ if (alarm_value == table->data_mask)return -ERANGE;return 0 ;static int rk_tsadcv2_tshut_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int temp)/* Make sure the value is valid */ if (tshut_value == table->data_mask)return -ERANGE;/* TSHUT will be valid */ return 0 ;static int rk_tsadcv3_tshut_temp(const struct chip_tsadc_table *table,int chn, void __iomem *regs, int temp)/* Make sure the value is valid */ if (tshut_value == table->data_mask)return -ERANGE;/* TSHUT will be valid */ return 0 ;static void rk_tsadcv2_tshut_mode(int chn, void __iomem *regs,enum tshut_mode mode)if (mode == TSHUT_MODE_GPIO) {else {static void rk_tsadcv4_tshut_mode(int chn, void __iomem *regs,enum tshut_mode mode)if (mode == TSHUT_MODE_GPIO) {else {static int rk_tsadcv2_get_trim_code(const struct chip_tsadc_table *table,int code, int trim_base, int trim_base_frac)int temp = trim_base * 1000 + trim_base_frac * 100 ;return code - base_code;static const struct rockchip_tsadc_chip px30_tsadc_data = {/* cpu, gpu */ 0 ,2 , /* 2 channels for tsadc */ /* default TSHUT via CRU */ 95000 ,static const struct rockchip_tsadc_chip rv1108_tsadc_data = {/* cpu */ 0 ,1 , /* one channel for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3228_tsadc_data = {/* cpu */ 0 ,1 , /* one channel for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3288_tsadc_data = {/* cpu, gpu */ 1 ,2 , /* two channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3328_tsadc_data = {/* cpu */ 0 ,1 , /* one channels for tsadc */ /* default TSHUT via CRU */ 95000 ,static const struct rockchip_tsadc_chip rk3366_tsadc_data = {/* cpu, gpu */ 0 ,2 , /* two channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3368_tsadc_data = {/* cpu, gpu */ 0 ,2 , /* two channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3399_tsadc_data = {/* cpu, gpu */ 0 ,2 , /* two channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3568_tsadc_data = {/* cpu, gpu */ 0 ,2 , /* two channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct rockchip_tsadc_chip rk3576_tsadc_data = {/* top, big_core, little_core, ddr, npu, gpu */ 0 ,6 , /* six channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,923 ,static const struct rockchip_tsadc_chip rk3588_tsadc_data = {/* top, big_core0, big_core1, little_core, center, gpu, npu */ 0 ,7 , /* seven channels for tsadc */ /* default TSHUT via GPIO give PMIC */ /* default TSHUT LOW ACTIVE */ 95000 ,static const struct of_device_id of_rockchip_thermal_match[] = {"rockchip,px30-tsadc" ,void *)&px30_tsadc_data,"rockchip,rv1108-tsadc" ,void *)&rv1108_tsadc_data,"rockchip,rk3228-tsadc" ,void *)&rk3228_tsadc_data,"rockchip,rk3288-tsadc" ,void *)&rk3288_tsadc_data,"rockchip,rk3328-tsadc" ,void *)&rk3328_tsadc_data,"rockchip,rk3366-tsadc" ,void *)&rk3366_tsadc_data,"rockchip,rk3368-tsadc" ,void *)&rk3368_tsadc_data,"rockchip,rk3399-tsadc" ,void *)&rk3399_tsadc_data,"rockchip,rk3568-tsadc" ,void *)&rk3568_tsadc_data,"rockchip,rk3576-tsadc" ,void *)&rk3576_tsadc_data,"rockchip,rk3588-tsadc" ,void *)&rk3588_tsadc_data,/* end */ }, static void struct rockchip_thermal_sensor *sensor, bool on)struct thermal_zone_device *tzd = sensor->tzd;if (on)else static irqreturn_t rockchip_thermal_alarm_irq_thread(int irq, void *dev)struct rockchip_thermal_data *thermal = dev;int i;"thermal alarm\n" );for (i = 0 ; i < thermal->chip->chn_num; i++)return IRQ_HANDLED;static int rockchip_thermal_set_trips(struct thermal_zone_device *tz, int low, int high)struct rockchip_thermal_sensor *sensor = thermal_zone_device_priv(tz);struct rockchip_thermal_data *thermal = sensor->thermal;const struct rockchip_tsadc_chip *tsadc = thermal->chip;"%s: sensor %d: low: %d, high %d\n" ,return tsadc->set_alarm_temp(&tsadc->table,static int rockchip_thermal_get_temp(struct thermal_zone_device *tz, int *out_temp)struct rockchip_thermal_sensor *sensor = thermal_zone_device_priv(tz);struct rockchip_thermal_data *thermal = sensor->thermal;const struct rockchip_tsadc_chip *tsadc = sensor->thermal->chip;int retval;return retval;static const struct thermal_zone_device_ops rockchip_of_thermal_ops = {/** * rockchip_get_efuse_value - read an OTP cell from a device node * @ np : pointer to the device node with the nvmem - cells property * @ cell_name : name of cell that should be read * @ value : pointer to where the read value will be placed * * Return : Negative errno on failure , during which * value will not be touched , * or 0 on success . static int rockchip_get_efuse_value(struct device_node *np, const char *cell_name,int *value)struct nvmem_cell *cell;int ret = 0 ;int i;if (IS_ERR(cell))return PTR_ERR(cell);if (IS_ERR(buf))return PTR_ERR(buf);if (len > sizeof (*value)) {goto exit ;/* Copy with implicit endian conversion */ 0 ;for (i = 0 ; i < len; i++)int ) buf[i] << (8 * i);exit :return ret;static int rockchip_get_trim_configuration(struct device *dev, struct device_node *np,struct rockchip_thermal_data *thermal)const struct rockchip_tsadc_chip *tsadc = thermal->chip;int trim_base = 0 , trim_base_frac = 0 , trim = 0 ;int trim_code;int ret;0 ;0 ;0 ;if (!tsadc->get_trim_code)return 0 ;"trim_base" , &trim_base);if (ret < 0 ) {if (ret == -ENOENT) {30 ;"trim_base is absent, defaulting to 30\n" );else {"failed reading nvmem value of trim_base: %pe\n" ,return ret;"trim_base_frac" , &trim_base_frac);if (ret < 0 ) {if (ret == -ENOENT) {"trim_base_frac is absent, defaulting to 0\n" );else {"failed reading nvmem value of trim_base_frac: %pe\n" ,return ret;/* * If the tsadc node contains the trim property , then it is used in the * absence of per - channel trim values if (!rockchip_get_efuse_value(np, "trim" , &trim))if (trim) {return 0 ;static int rockchip_configure_from_dt(struct device *dev,struct device_node *np,struct rockchip_thermal_data *thermal)if (of_property_read_u32(np, "rockchip,hw-tshut-temp" , &shut_temp)) {"Missing tshut temp property, using default %d\n" ,else {if (shut_temp > INT_MAX) {"Invalid tshut temperature specified: %d\n" ,return -ERANGE;if (of_property_read_u32(np, "rockchip,hw-tshut-mode" , &tshut_mode)) {"Missing tshut mode property, using default (%s)\n" ,"gpio" : "cru" );else {if (thermal->tshut_mode > 1 ) {"Invalid tshut mode specified: %d\n" ,return -EINVAL;if (of_property_read_u32(np, "rockchip,hw-tshut-polarity" ,"Missing tshut-polarity property, using default (%s)\n" ,"low" : "high" );else {if (thermal->tshut_polarity > 1 ) {"Invalid tshut-polarity specified: %d\n" ,return -EINVAL;/* The tsadc wont to handle the error in here since some SoCs didn't * need this property . "rockchip,grf" );if (IS_ERR(thermal->grf))"Missing rockchip,grf property\n" );return 0 ;static int struct platform_device *pdev,struct rockchip_thermal_data *thermal,struct rockchip_thermal_sensor *sensor,int id)const struct rockchip_tsadc_chip *tsadc = thermal->chip;struct device *dev = &pdev->dev;int trim = thermal->trim;int trim_code, tshut_temp;int trim_temp = 0 ;int error;if (thermal->trim_temp)if (tsadc->get_trim_code && sensor->of_node) {"trim" , &trim);if (error < 0 && error != -ENOENT) {"failed reading trim of sensor %d: %pe\n" ,return error;if (trim) {"trim of sensor %d is %d\n" , id, sensor->trim_temp);if (error)"%s: invalid tshut=%d, error=%d\n" ,if (IS_ERR(sensor->tzd)) {"failed to register sensor %d: %d\n" ,return error;return 0 ;/** * rockchip_thermal_reset_controller - Reset TSADC Controller , reset all tsadc registers . * @ reset : the reset controller of tsadc static void rockchip_thermal_reset_controller(struct reset_control *reset)10 , 20 );static int rockchip_thermal_probe(struct platform_device *pdev)struct device_node *np = pdev->dev.of_node;struct rockchip_thermal_data *thermal;struct device_node *child;int irq;int i;int error;0 );if (irq < 0 )return -EINVAL;sizeof (struct rockchip_thermal_data),if (!thermal)return -ENOMEM;if (!thermal->chip)return -EINVAL;sizeof (*thermal->sensors), GFP_KERNEL);if (!thermal->sensors)return -ENOMEM;0 , NULL);if (IS_ERR(thermal->regs))return PTR_ERR(thermal->regs);if (IS_ERR(thermal->reset))return dev_err_probe(&pdev->dev, PTR_ERR(thermal->reset),"failed to get tsadc reset.\n" );"tsadc" );if (IS_ERR(thermal->clk))return dev_err_probe(&pdev->dev, PTR_ERR(thermal->clk),"failed to get tsadc clock.\n" );"apb_pclk" );if (IS_ERR(thermal->pclk))return dev_err_probe(&pdev->dev, PTR_ERR(thermal->pclk),"failed to get apb_pclk clock.\n" );if (error)return dev_err_probe(&pdev->dev, error,"failed to parse device tree data\n" );if (!of_property_read_u32(child, "reg" , &chn)) {if (chn < thermal->chip->chn_num)else "sensor address (%d) too large, ignoring its trim\n" ,for (i = 0 ; i < thermal->chip->chn_num; i++) {if (error)return dev_err_probe(&pdev->dev, error,"failed to register sensor[%d].\n" , i);"rockchip_thermal" , thermal);if (error)return dev_err_probe(&pdev->dev, error,"failed to request tsadc irq.\n" );true );for (i = 0 ; i < thermal->chip->chn_num; i++) {true );if (error)"failed to register sensor %d with hwmon: %d\n" ,return 0 ;static void rockchip_thermal_remove(struct platform_device *pdev)struct rockchip_thermal_data *thermal = platform_get_drvdata(pdev);int i;for (i = 0 ; i < thermal->chip->chn_num; i++) {struct rockchip_thermal_sensor *sensor = &thermal->sensors[i];false );false );static int __maybe_unused rockchip_thermal_suspend(struct device *dev)struct rockchip_thermal_data *thermal = dev_get_drvdata(dev);int i;for (i = 0 ; i < thermal->chip->chn_num; i++)false );false );return 0 ;static int __maybe_unused rockchip_thermal_resume(struct device *dev)struct rockchip_thermal_data *thermal = dev_get_drvdata(dev);const struct rockchip_tsadc_chip *tsadc = thermal->chip;struct rockchip_thermal_sensor *sensor;int tshut_temp;int error;int i;if (error)return error;if (error) {return error;for (i = 0 ; i < thermal->chip->chn_num; i++) {if (error)"%s: invalid tshut=%d, error=%d\n" ,true );for (i = 0 ; i < thermal->chip->chn_num; i++)true );return 0 ;static SIMPLE_DEV_PM_OPS(rockchip_thermal_pm_ops,static struct platform_driver rockchip_thermal_driver = {"rockchip-thermal" ,"ROCKCHIP THERMAL Driver" );"Rockchip, Inc." );"GPL v2" );"platform:rockchip-thermal" );
Messung V0.5 in Prozent C=95 H=96 G=95
¤ Dauer der Verarbeitung: 0.51 Sekunden
(vorverarbeitet am 2026-09-29)
¤ *© Formatika GbR, Deutschland
