Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * TI Bandgap temperature sensor driver for J72XX SoC Family
0004  *
0005  * Copyright (C) 2021 Texas Instruments Incorporated - http://www.ti.com/
0006  */
0007 
0008 #include <linux/math.h>
0009 #include <linux/math64.h>
0010 #include <linux/module.h>
0011 #include <linux/init.h>
0012 #include <linux/kernel.h>
0013 #include <linux/pm_runtime.h>
0014 #include <linux/err.h>
0015 #include <linux/types.h>
0016 #include <linux/of_platform.h>
0017 #include <linux/io.h>
0018 #include <linux/thermal.h>
0019 #include <linux/of.h>
0020 #include <linux/delay.h>
0021 #include <linux/slab.h>
0022 
0023 #define K3_VTM_DEVINFO_PWR0_OFFSET      0x4
0024 #define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK    0xf0
0025 #define K3_VTM_TMPSENS0_CTRL_OFFSET     0x300
0026 #define K3_VTM_MISC_CTRL_OFFSET         0xc
0027 #define K3_VTM_TMPSENS_STAT_OFFSET      0x8
0028 #define K3_VTM_ANYMAXT_OUTRG_ALERT_EN       0x1
0029 #define K3_VTM_MISC_CTRL2_OFFSET        0x10
0030 #define K3_VTM_TS_STAT_DTEMP_MASK       0x3ff
0031 #define K3_VTM_MAX_NUM_TS           8
0032 #define K3_VTM_TMPSENS_CTRL_SOC         BIT(5)
0033 #define K3_VTM_TMPSENS_CTRL_CLRZ        BIT(6)
0034 #define K3_VTM_TMPSENS_CTRL_CLKON_REQ       BIT(7)
0035 #define K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN   BIT(11)
0036 
0037 #define K3_VTM_CORRECTION_TEMP_CNT      3
0038 
0039 #define MINUS40CREF             5
0040 #define PLUS30CREF              253
0041 #define PLUS125CREF             730
0042 #define PLUS150CREF             940
0043 
0044 #define TABLE_SIZE              1024
0045 #define MAX_TEMP                123000
0046 #define COOL_DOWN_TEMP              105000
0047 
0048 #define FACTORS_REDUCTION           13
0049 static int *derived_table;
0050 
0051 static int compute_value(int index, const s64 *factors, int nr_factors,
0052              int reduction)
0053 {
0054     s64 value = 0;
0055     int i;
0056 
0057     for (i = 0; i < nr_factors; i++)
0058         value += factors[i] * int_pow(index, i);
0059 
0060     return (int)div64_s64(value, int_pow(10, reduction));
0061 }
0062 
0063 static void init_table(int factors_size, int *table, const s64 *factors)
0064 {
0065     int i;
0066 
0067     for (i = 0; i < TABLE_SIZE; i++)
0068         table[i] = compute_value(i, factors, factors_size,
0069                      FACTORS_REDUCTION);
0070 }
0071 
0072 /**
0073  * struct err_values - structure containing error/reference values
0074  * @refs: reference error values for -40C, 30C, 125C & 150C
0075  * @errs: Actual error values for -40C, 30C, 125C & 150C read from the efuse
0076  */
0077 struct err_values {
0078     int refs[4];
0079     int errs[4];
0080 };
0081 
0082 static void create_table_segments(struct err_values *err_vals, int seg,
0083                   int *ref_table)
0084 {
0085     int m = 0, c, num, den, i, err, idx1, idx2, err1, err2, ref1, ref2;
0086 
0087     if (seg == 0)
0088         idx1 = 0;
0089     else
0090         idx1 = err_vals->refs[seg];
0091 
0092     idx2 = err_vals->refs[seg + 1];
0093     err1 = err_vals->errs[seg];
0094     err2 = err_vals->errs[seg + 1];
0095     ref1 = err_vals->refs[seg];
0096     ref2 = err_vals->refs[seg + 1];
0097 
0098     /*
0099      * Calculate the slope with adc values read from the register
0100      * as the y-axis param and err in adc value as x-axis param
0101      */
0102     num = ref2 - ref1;
0103     den = err2 - err1;
0104     if (den)
0105         m = num / den;
0106     c = ref2 - m * err2;
0107 
0108     /*
0109      * Take care of divide by zero error if error values are same
0110      * Or when the slope is 0
0111      */
0112     if (den != 0 && m != 0) {
0113         for (i = idx1; i <= idx2; i++) {
0114             err = (i - c) / m;
0115             if (((i + err) < 0) || ((i + err) >= TABLE_SIZE))
0116                 continue;
0117             derived_table[i] = ref_table[i + err];
0118         }
0119     } else { /* Constant error take care of divide by zero */
0120         for (i = idx1; i <= idx2; i++) {
0121             if (((i + err1) < 0) || ((i + err1) >= TABLE_SIZE))
0122                 continue;
0123             derived_table[i] = ref_table[i + err1];
0124         }
0125     }
0126 }
0127 
0128 static int prep_lookup_table(struct err_values *err_vals, int *ref_table)
0129 {
0130     int inc, i, seg;
0131 
0132     /*
0133      * Fill up the lookup table under 3 segments
0134      * region -40C to +30C
0135      * region +30C to +125C
0136      * region +125C to +150C
0137      */
0138     for (seg = 0; seg < 3; seg++)
0139         create_table_segments(err_vals, seg, ref_table);
0140 
0141     /* Get to the first valid temperature */
0142     i = 0;
0143     while (!derived_table[i])
0144         i++;
0145 
0146     /*
0147      * Get to the last zero index and back fill the temperature for
0148      * sake of continuity
0149      */
0150     if (i) {
0151         /* 300 milli celsius steps */
0152         while (i--)
0153             derived_table[i] = derived_table[i + 1] - 300;
0154     }
0155 
0156     /*
0157      * Fill the last trailing 0s which are unfilled with increments of
0158      * 100 milli celsius till 1023 code
0159      */
0160     i = TABLE_SIZE - 1;
0161     while (!derived_table[i])
0162         i--;
0163 
0164     i++;
0165     inc = 1;
0166     while (i < TABLE_SIZE) {
0167         derived_table[i] = derived_table[i - 1] + inc * 100;
0168         i++;
0169     }
0170 
0171     return 0;
0172 }
0173 
0174 struct k3_thermal_data;
0175 
0176 struct k3_j72xx_bandgap {
0177     struct device *dev;
0178     void __iomem *base;
0179     void __iomem *cfg2_base;
0180     void __iomem *fuse_base;
0181     struct k3_thermal_data *ts_data[K3_VTM_MAX_NUM_TS];
0182 };
0183 
0184 /* common data structures */
0185 struct k3_thermal_data {
0186     struct k3_j72xx_bandgap *bgp;
0187     u32 ctrl_offset;
0188     u32 stat_offset;
0189 };
0190 
0191 static int two_cmp(int tmp, int mask)
0192 {
0193     tmp = ~(tmp);
0194     tmp &= mask;
0195     tmp += 1;
0196 
0197     /* Return negative value */
0198     return (0 - tmp);
0199 }
0200 
0201 static unsigned int vtm_get_best_value(unsigned int s0, unsigned int s1,
0202                        unsigned int s2)
0203 {
0204     int d01 = abs(s0 - s1);
0205     int d02 = abs(s0 - s2);
0206     int d12 = abs(s1 - s2);
0207 
0208     if (d01 <= d02 && d01 <= d12)
0209         return (s0 + s1) / 2;
0210 
0211     if (d02 <= d01 && d02 <= d12)
0212         return (s0 + s2) / 2;
0213 
0214     return (s1 + s2) / 2;
0215 }
0216 
0217 static inline int k3_bgp_read_temp(struct k3_thermal_data *devdata,
0218                    int *temp)
0219 {
0220     struct k3_j72xx_bandgap *bgp;
0221     unsigned int dtemp, s0, s1, s2;
0222 
0223     bgp = devdata->bgp;
0224     /*
0225      * Errata is applicable for am654 pg 1.0 silicon/J7ES. There
0226      * is a variation of the order for certain degree centigrade on AM654.
0227      * Work around that by getting the average of two closest
0228      * readings out of three readings everytime we want to
0229      * report temperatures.
0230      *
0231      * Errata workaround.
0232      */
0233     s0 = readl(bgp->base + devdata->stat_offset) &
0234         K3_VTM_TS_STAT_DTEMP_MASK;
0235     s1 = readl(bgp->base + devdata->stat_offset) &
0236         K3_VTM_TS_STAT_DTEMP_MASK;
0237     s2 = readl(bgp->base + devdata->stat_offset) &
0238         K3_VTM_TS_STAT_DTEMP_MASK;
0239     dtemp = vtm_get_best_value(s0, s1, s2);
0240 
0241     if (dtemp < 0 || dtemp >= TABLE_SIZE)
0242         return -EINVAL;
0243 
0244     *temp = derived_table[dtemp];
0245 
0246     return 0;
0247 }
0248 
0249 /* Get temperature callback function for thermal zone */
0250 static int k3_thermal_get_temp(void *devdata, int *temp)
0251 {
0252     struct k3_thermal_data *data = devdata;
0253     int ret = 0;
0254 
0255     ret = k3_bgp_read_temp(data, temp);
0256     if (ret)
0257         return ret;
0258 
0259     return ret;
0260 }
0261 
0262 static const struct thermal_zone_of_device_ops k3_of_thermal_ops = {
0263     .get_temp = k3_thermal_get_temp,
0264 };
0265 
0266 static int k3_j72xx_bandgap_temp_to_adc_code(int temp)
0267 {
0268     int low = 0, high = TABLE_SIZE - 1, mid;
0269 
0270     if (temp > 160000 || temp < -50000)
0271         return -EINVAL;
0272 
0273     /* Binary search to find the adc code */
0274     while (low < (high - 1)) {
0275         mid = (low + high) / 2;
0276         if (temp <= derived_table[mid])
0277             high = mid;
0278         else
0279             low = mid;
0280     }
0281 
0282     return mid;
0283 }
0284 
0285 static void get_efuse_values(int id, struct k3_thermal_data *data, int *err,
0286                  struct k3_j72xx_bandgap *bgp)
0287 {
0288     int i, tmp, pow;
0289     int ct_offsets[5][K3_VTM_CORRECTION_TEMP_CNT] = {
0290         { 0x0, 0x8, 0x4 },
0291         { 0x0, 0x8, 0x4 },
0292         { 0x0, -1,  0x4 },
0293         { 0x0, 0xC, -1 },
0294         { 0x0, 0xc, 0x8 }
0295     };
0296     int ct_bm[5][K3_VTM_CORRECTION_TEMP_CNT] = {
0297         { 0x3f, 0x1fe000, 0x1ff },
0298         { 0xfc0, 0x1fe000, 0x3fe00 },
0299         { 0x3f000, 0x7f800000, 0x7fc0000 },
0300         { 0xfc0000, 0x1fe0, 0x1f800000 },
0301         { 0x3f000000, 0x1fe000, 0x1ff0 }
0302     };
0303 
0304     for (i = 0; i < 3; i++) {
0305         /* Extract the offset value using bit-mask */
0306         if (ct_offsets[id][i] == -1 && i == 1) {
0307             /* 25C offset Case of Sensor 2 split between 2 regs */
0308             tmp = (readl(bgp->fuse_base + 0x8) & 0xE0000000) >> (29);
0309             tmp |= ((readl(bgp->fuse_base + 0xC) & 0x1F) << 3);
0310             pow = tmp & 0x80;
0311         } else if (ct_offsets[id][i] == -1 && i == 2) {
0312             /* 125C Case of Sensor 3 split between 2 regs */
0313             tmp = (readl(bgp->fuse_base + 0x4) & 0xF8000000) >> (27);
0314             tmp |= ((readl(bgp->fuse_base + 0x8) & 0xF) << 5);
0315             pow = tmp & 0x100;
0316         } else {
0317             tmp = readl(bgp->fuse_base + ct_offsets[id][i]);
0318             tmp &= ct_bm[id][i];
0319             tmp = tmp >> __ffs(ct_bm[id][i]);
0320 
0321             /* Obtain the sign bit pow*/
0322             pow = ct_bm[id][i] >> __ffs(ct_bm[id][i]);
0323             pow += 1;
0324             pow /= 2;
0325         }
0326 
0327         /* Check for negative value */
0328         if (tmp & pow) {
0329             /* 2's complement value */
0330             tmp = two_cmp(tmp, ct_bm[id][i] >> __ffs(ct_bm[id][i]));
0331         }
0332         err[i] = tmp;
0333     }
0334 
0335     /* Err value for 150C is set to 0 */
0336     err[i] = 0;
0337 }
0338 
0339 static void print_look_up_table(struct device *dev, int *ref_table)
0340 {
0341     int i;
0342 
0343     dev_dbg(dev, "The contents of derived array\n");
0344     dev_dbg(dev, "Code   Temperature\n");
0345     for (i = 0; i < TABLE_SIZE; i++)
0346         dev_dbg(dev, "%d       %d %d\n", i, derived_table[i], ref_table[i]);
0347 }
0348 
0349 struct k3_j72xx_bandgap_data {
0350     unsigned int has_errata_i2128;
0351 };
0352 
0353 static int k3_j72xx_bandgap_probe(struct platform_device *pdev)
0354 {
0355     int ret = 0, cnt, val, id;
0356     int high_max, low_temp;
0357     struct resource *res;
0358     struct device *dev = &pdev->dev;
0359     struct k3_j72xx_bandgap *bgp;
0360     struct k3_thermal_data *data;
0361     int workaround_needed = 0;
0362     const struct k3_j72xx_bandgap_data *driver_data;
0363     struct thermal_zone_device *ti_thermal;
0364     int *ref_table;
0365     struct err_values err_vals;
0366 
0367     const s64 golden_factors[] = {
0368         -490019999999999936,
0369         3251200000000000,
0370         -1705800000000,
0371         603730000,
0372         -92627,
0373     };
0374 
0375     const s64 pvt_wa_factors[] = {
0376         -415230000000000000,
0377         3126600000000000,
0378         -1157800000000,
0379     };
0380 
0381     bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
0382     if (!bgp)
0383         return -ENOMEM;
0384 
0385     bgp->dev = dev;
0386     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0387     bgp->base = devm_ioremap_resource(dev, res);
0388     if (IS_ERR(bgp->base))
0389         return PTR_ERR(bgp->base);
0390 
0391     res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
0392     bgp->cfg2_base = devm_ioremap_resource(dev, res);
0393     if (IS_ERR(bgp->cfg2_base))
0394         return PTR_ERR(bgp->cfg2_base);
0395 
0396     res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
0397     bgp->fuse_base = devm_ioremap_resource(dev, res);
0398     if (IS_ERR(bgp->fuse_base))
0399         return PTR_ERR(bgp->fuse_base);
0400 
0401     driver_data = of_device_get_match_data(dev);
0402     if (driver_data)
0403         workaround_needed = driver_data->has_errata_i2128;
0404 
0405     pm_runtime_enable(dev);
0406     ret = pm_runtime_get_sync(dev);
0407     if (ret < 0) {
0408         pm_runtime_put_noidle(dev);
0409         pm_runtime_disable(dev);
0410         return ret;
0411     }
0412 
0413     /* Get the sensor count in the VTM */
0414     val = readl(bgp->base + K3_VTM_DEVINFO_PWR0_OFFSET);
0415     cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK;
0416     cnt >>= __ffs(K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK);
0417 
0418     data = devm_kcalloc(bgp->dev, cnt, sizeof(*data), GFP_KERNEL);
0419     if (!data) {
0420         ret = -ENOMEM;
0421         goto err_alloc;
0422     }
0423 
0424     ref_table = kzalloc(sizeof(*ref_table) * TABLE_SIZE, GFP_KERNEL);
0425     if (!ref_table) {
0426         ret = -ENOMEM;
0427         goto err_alloc;
0428     }
0429 
0430     derived_table = devm_kzalloc(bgp->dev, sizeof(*derived_table) * TABLE_SIZE,
0431                      GFP_KERNEL);
0432     if (!derived_table) {
0433         ret = -ENOMEM;
0434         goto err_free_ref_table;
0435     }
0436 
0437     /* Workaround not needed if bit30/bit31 is set even for J721e */
0438     if (workaround_needed && (readl(bgp->fuse_base + 0x0) & 0xc0000000) == 0xc0000000)
0439         workaround_needed = false;
0440 
0441     dev_dbg(bgp->dev, "Work around %sneeded\n",
0442         workaround_needed ? "not " : "");
0443 
0444     if (!workaround_needed)
0445         init_table(5, ref_table, golden_factors);
0446     else
0447         init_table(3, ref_table, pvt_wa_factors);
0448 
0449     /* Register the thermal sensors */
0450     for (id = 0; id < cnt; id++) {
0451         data[id].bgp = bgp;
0452         data[id].ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET + id * 0x20;
0453         data[id].stat_offset = data[id].ctrl_offset +
0454                     K3_VTM_TMPSENS_STAT_OFFSET;
0455 
0456         if (workaround_needed) {
0457             /* ref adc values for -40C, 30C & 125C respectively */
0458             err_vals.refs[0] = MINUS40CREF;
0459             err_vals.refs[1] = PLUS30CREF;
0460             err_vals.refs[2] = PLUS125CREF;
0461             err_vals.refs[3] = PLUS150CREF;
0462             get_efuse_values(id, &data[id], err_vals.errs, bgp);
0463         }
0464 
0465         if (id == 0 && workaround_needed)
0466             prep_lookup_table(&err_vals, ref_table);
0467         else if (id == 0 && !workaround_needed)
0468             memcpy(derived_table, ref_table, TABLE_SIZE * 4);
0469 
0470         val = readl(data[id].bgp->cfg2_base + data[id].ctrl_offset);
0471         val |= (K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN |
0472             K3_VTM_TMPSENS_CTRL_SOC |
0473             K3_VTM_TMPSENS_CTRL_CLRZ | BIT(4));
0474         writel(val, data[id].bgp->cfg2_base + data[id].ctrl_offset);
0475 
0476         bgp->ts_data[id] = &data[id];
0477         ti_thermal =
0478         devm_thermal_zone_of_sensor_register(bgp->dev, id,
0479                              &data[id],
0480                              &k3_of_thermal_ops);
0481         if (IS_ERR(ti_thermal)) {
0482             dev_err(bgp->dev, "thermal zone device is NULL\n");
0483             ret = PTR_ERR(ti_thermal);
0484             goto err_free_ref_table;
0485         }
0486     }
0487 
0488     /*
0489      * Program TSHUT thresholds
0490      * Step 1: set the thresholds to ~123C and 105C WKUP_VTM_MISC_CTRL2
0491      * Step 2: WKUP_VTM_TMPSENS_CTRL_j set the MAXT_OUTRG_EN  bit
0492      *         This is already taken care as per of init
0493      * Step 3: WKUP_VTM_MISC_CTRL set the ANYMAXT_OUTRG_ALERT_EN  bit
0494      */
0495     high_max = k3_j72xx_bandgap_temp_to_adc_code(MAX_TEMP);
0496     low_temp = k3_j72xx_bandgap_temp_to_adc_code(COOL_DOWN_TEMP);
0497 
0498     writel((low_temp << 16) | high_max, data[0].bgp->cfg2_base +
0499            K3_VTM_MISC_CTRL2_OFFSET);
0500     mdelay(100);
0501     writel(K3_VTM_ANYMAXT_OUTRG_ALERT_EN, data[0].bgp->cfg2_base +
0502            K3_VTM_MISC_CTRL_OFFSET);
0503 
0504     platform_set_drvdata(pdev, bgp);
0505 
0506     print_look_up_table(dev, ref_table);
0507     /*
0508      * Now that the derived_table has the appropriate look up values
0509      * Free up the ref_table
0510      */
0511     kfree(ref_table);
0512 
0513     return 0;
0514 
0515 err_free_ref_table:
0516     kfree(ref_table);
0517 
0518 err_alloc:
0519     pm_runtime_put_sync(&pdev->dev);
0520     pm_runtime_disable(&pdev->dev);
0521 
0522     return ret;
0523 }
0524 
0525 static int k3_j72xx_bandgap_remove(struct platform_device *pdev)
0526 {
0527     pm_runtime_put_sync(&pdev->dev);
0528     pm_runtime_disable(&pdev->dev);
0529 
0530     return 0;
0531 }
0532 
0533 static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j721e_data = {
0534     .has_errata_i2128 = 1,
0535 };
0536 
0537 static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j7200_data = {
0538     .has_errata_i2128 = 0,
0539 };
0540 
0541 static const struct of_device_id of_k3_j72xx_bandgap_match[] = {
0542     {
0543         .compatible = "ti,j721e-vtm",
0544         .data = &k3_j72xx_bandgap_j721e_data,
0545     },
0546     {
0547         .compatible = "ti,j7200-vtm",
0548         .data = &k3_j72xx_bandgap_j7200_data,
0549     },
0550     { /* sentinel */ },
0551 };
0552 MODULE_DEVICE_TABLE(of, of_k3_j72xx_bandgap_match);
0553 
0554 static struct platform_driver k3_j72xx_bandgap_sensor_driver = {
0555     .probe = k3_j72xx_bandgap_probe,
0556     .remove = k3_j72xx_bandgap_remove,
0557     .driver = {
0558         .name = "k3-j72xx-soc-thermal",
0559         .of_match_table = of_k3_j72xx_bandgap_match,
0560     },
0561 };
0562 
0563 module_platform_driver(k3_j72xx_bandgap_sensor_driver);
0564 
0565 MODULE_DESCRIPTION("K3 bandgap temperature sensor driver");
0566 MODULE_LICENSE("GPL");
0567 MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!