Confira !!
Assunto : [PATCH 2/4] Thermal: k3: adicione suporte para sensores de bandgap
From : Keerthy <j-keerthy @ xxxxxx>
Data : quinta-feira, 13 de fevereiro de 2020 15:54:38 +0530
Em resposta a : < 20200213102440.20539-1-j-keerthy@ti.com >
O bandgap fornece referência de corrente e tensão para seus
circuitos e outros blocos IP analógicos. O analógico para digital
conversor (ADC) produz um valor de saída proporcional
à temperatura do silício.
Atualmente, as temperaturas de leitura e a computação de tendências são suportadas
pois não há agente de resfriamento ativo / passivo suportado.
Assinado por: Keerthy <j-keerthy @ xxxxxx>
---
drivers / térmica / Kconfig | 12 ++
drivers / térmica / Makefile | 1 +
drivers / térmica / k3_bandgap.c | 342 ++++++++++++++++++++++++++++++++++++
3 arquivos alterados, 355 inserções (+)
modo de criação 100644 drivers / Thermal / k3_bandgap.c
diff --git a / drivers / Thermal / Kconfig b / drivers / Thermal / Kconfig
índice 5a05db5438d6..fa598eddc7ac 100644
--- a / drivers / Thermal / Kconfig
+++ b / drivers / térmica / Kconfig
@@ -251,6 +251,18 @@ config IMX_THERMAL
O cpufreq é usado como dispositivo de resfriamento para acelerar as CPUs quando o
viagem passiva é cruzada.
+ configuração K3_THERMAL
+ suporte "Suporte térmico Texas Instruments K3"
+ depende de THERMAL
+ depende de ARCH_K3 || COMPILE_TEST
+ ajuda
+ Se você disser sim, aqui você obtém suporte térmico para o Texas Instruments
Família SoC + K3. O chip atual suportado é:
+ - AM654
+
+ Inclui funcionalidade de leitura de temperatura e também tendência
+ computação.
+
config MAX77620_THERMAL
tristate "Driver do sensor de temperatura para Maxim MAX77620 PMIC"
depende do MFD_MAX77620
diff --git a / drivers / térmico / Makefile b / drivers / térmico / Makefile
índice 9fb88e26fb10..5ad6535139ae 100644
--- a / drivers / térmica / Makefile
+++ b / drivers / térmica / Makefile
@@ -28,6 +28,7 @@ Thermal_sys - $ (CONFIG_CLOCK_THERMAL) + = clock_cooling.o
# devfreq cooling
Thermal_sys - $ (CONFIG_DEVFREQ_THERMAL) + = devfreq_cooling.o
+ obj - $ (CONFIG_K3_THERMAL) + = k3_bandgap.o
# drivers térmicos da plataforma
obj-y + = broadcom /
obj - $ (CONFIG_THERMAL_MMIO) + = Thermal_mmio.o
diff --git a / drivers / Thermal / k3_bandgap.cb / drivers / Thermal / k3_bandgap.c
novo modo de arquivo 100644
índice 000000000000..00184d2d6ba6
--- / dev / null
+++ b / drivers / Thermal / k3_bandgap.c
@@ -0,0 +1,342 @@
+ // Identificador de licença SPDX: GPL-2.0
+ / *
+ * Driver do sensor de temperatura Bandgap da TI para a família K3 SoC
+ *
+ * Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
+ * /
+
+ # include <linux / module.h>
+ # inclui <linux / init.h>
+ # include <linux / kernel.h>
+ # include <linux / pm_runtime.h>
+ # inclui <linux / err.h>
+ # include <linux / types.h>
+ # include <linux / spinlock.h>
+ # include <linux / of_platform.h>
+ # include <linux / io.h>
+ # include <linux / workqueue.h>
+ # include <linux / Thermal.h>
+ # inclui <linux / of.h>
+
+ # define K3_VTM_DEVINFO_PWR0_OFFSET 0x4
+ # define K3_VTM_DEVINFO_PWR0_CVD_CT_MASK 0xf
+ # define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK 0xf0
+ # define K3_VTM_TMPSENS0_CTRL_OFFSET 0x80
+ # define K3_VTM_REGS_PER_TS 0x10
+ # define K3_VTM_TS_STAT_DTEMP_MASK 0x3ff
+ # define K3_VTM_MAX_NUM_TS 8
+ # define K3_VTM_TMPSENS_CTRL_CBIASSEL BIT (0)
+ # define K3_VTM_TMPSENS_CTRL_SOC BIT (5)
+ # define K3_VTM_TMPSENS_CTRL_CLRZ BIT (6)
+ # define K3_VTM_TMPSENS_CTRL_CLKON_REQ BIT (7)
+
+ # define K3_VTM_ADC_BEGIN_VAL 540
+ # define K3_VTM_ADC_END_VAL 944
+
+ const const estático k3_adc_to_temp [K3_VTM_ADC_END_VAL - K3_VTM_ADC_BEGIN_VAL
+ + 1] = {
+ -40000, -40000, -40000, -40000, -39800, -39400, -39000, -38600, -38200,
+ -37800, -37400, -37000, -36600, -36200, -35800, -35300, -34700, -34200,
+ -33800, -33400, -33000, -32600, -32200, -31800, -31400, -31000, -30600,
+ -30200, -29800, -29400, -29000, -28600, -28200, -27700, -27100, -26600,
+ -26200, -25800, -25400, -25000, -24600, -24200, -23800, -23400, -23000,
+ -22600, -22200, -21800, -21400, -21000, -20500, -19900, -19400, -19000,
+ -18600, -18200, -17800, -17400, -17000, -16600, -16200, -15800, -15400,
+ -15000, -14600, -14200, -13800, -13400, -13000, -12500, -11900, -11400,
+ -11000, -10600, -10200, -9800, -9400, -9000, -8600, -8200, -7800, -7400,
+ -7000, -6600, -6200, -5800, -5400, -5000, -4500, -3900, -3400, -3000,
+ -2600, -2200, -1800, -1400, -1000, -600, -200, 200, 600, 1000, 1400,
+ 1800, 2200, 2600, 3000, 3400, 3900, 4500, 5000, 5400, 5800, 6200, 6600,
+ 7000, 7400, 7800, 8200, 8600, 9000, 9400, 9800, 10200, 10600, 11000,
+ 11400, 11800, 12200, 12700, 13300, 13800, 14200, 14600, 15000, 15400,
+ 15800, 16200, 16600, 17000, 17400, 17800, 18200, 18600, 19000, 19400,
+ 19800, 20200, 20600, 21000, 21400, 21900, 22500, 23000, 23400, 23800,
+ 24200, 24600, 25000, 25400, 25800, 26200, 26600, 27000, 27400, 27800,
+ 28200, 28600, 29000, 29400, 29800, 30200, 30600, 31000, 31400, 31900,
+ 32500, 33000, 33400, 33800, 34200, 34600, 35000, 35400, 35800, 36200,
+ 36600, 37000, 37400, 37800, 38200, 38600, 39000, 39400, 39800, 40200,
+ 40600, 41000, 41400, 41800, 42200, 42600, 43100, 43700, 44200, 44600,
+ 45000, 45400, 45800, 46200, 46600, 47000, 47400, 47800, 48200, 48600,
+ 49000, 49400, 49800, 50200, 50600, 51000, 51400, 51800, 52200, 52600,
+ 53000, 53400, 53800, 54200, 54600, 55000, 55400, 55900, 56500, 57000,
+ 57400, 57800, 58200, 58600, 59000, 59400, 59800, 60200, 60600, 61000,
+ 61400, 61800, 62200, 62600, 63000, 63400, 63800, 64200, 64600, 65000,
+ 65400, 65800, 66200, 66600, 67000, 67400, 67800, 68200, 68600, 69000,
+ 69400, 69800, 70200, 70600, 71000, 71500, 72100, 72600, 73000, 73400,
+ 73800, 74200, 74600, 75000, 75400, 75800, 76200, 76600, 77000, 77400,
+ 77800, 78200, 78600, 79000, 79400, 79800, 80200, 80600, 81000, 81400,
+ 81800, 82200, 82600, 83000, 83400, 83800, 84200, 84600, 85000, 85400,
+ 85800, 86200, 86600, 87000, 87400, 87800, 88200, 88600, 89000, 89400,
+ 89800, 90200, 90600, 91000, 91400, 91800, 92200, 92600, 93000, 93400,
+ 93800, 94200, 94600, 95000, 95400, 95800, 96200, 96600, 97000, 97500,
+ 98100, 98600, 99000, 99400, 99800, 100200, 100600, 101000, 101400,
+ 101800, 102200, 102600, 103000, 103400, 103800, 104200, 104600, 105000,
+ 105400, 105800, 106200, 106600, 107000, 107400, 107800, 108200, 108600,
+ 109000, 109400, 109800, 110200, 110600, 111000, 111400, 111800, 112200,
+ 112600, 113000, 113400, 113800, 114200, 114600, 115000, 115400, 115800,
+ 116200, 116600, 117000, 117400, 117800, 118200, 118600, 119000, 119400,
+ 119800, 120200, 120600, 121000, 121400, 121800, 122200, 122600, 123000,
+ 123400, 123800, 124200, 124600, 124900, 125000,
+};
+
+ struct k3_thermal_data;
+
+ struct k3_bandgap {
+ dispositivo de estrutura * dev;
+ void __iomem * base;
+ const struct k3_bandgap_data * conf;
+ bloqueio spinlock_t; / * protege essa estrutura * /
+ int ts_cnt;
+ 32 erratas;
+ struct k3_thermal_data * ts_data [K3_VTM_MAX_NUM_TS];
+};
+
+ struct k3_vtm_driver_data {
+ 32 erratas;
+};
+
+ / * estruturas de dados comuns * /
+ struct k3_thermal_data {
+ struct Thermal_zone_device * ti_thermal;
+ struct Thermal_cooling_device * cool_dev;
+ struct k3_bandgap * bgp;
+ modo enum Thermal_device_mode;
+ struct work_struct Thermal_wq;
+ int sensor_id;
+ u32 ctrl_offset;
+ u32 stat_offset;
+ int prev_temp;
+};
+
+ estático não assinado int vtm_get_best_value (não assinado int s0, não assinado int s1,
+ não assinado int s2)
+ {
+ int d01 = abs (s0 - s1);
+ int d02 = abs (s0 - s2);
+ int d12 = abs (s1 - s2);
+
+ if (d01 <= d02 && d01 <= d12)
+ retorno (s0 + s1) / 2;
+
+ if (d02 <= d01 && d02 <= d12)
+ retorno (s0 + s2) / 2;
+
+ retorno (s1 + s2) / 2;
+}
+
+ static int k3_bgp_read_temp (struct k3_thermal_data * devdata,
+ int * temp)
+ {
+ struct k3_bandgap * bgp;
+ não assinado int dtemp, s0, s1, s2;
+
+ bgp = devdata-> bgp;
+ / **
+ * Errata é aplicável ao silício am654 pg 1.0. Lá
+ * é uma variação da ordem de 8 a 10 graus centígrados.
+ * Para solucionar isso, obtenha a média dos dois mais próximos
+ * leituras de três leituras sempre que queremos
+ * relatório de temperaturas.
+ *
+ * Errata solução alternativa.
+ * /
+
+ se (bgp-> errata) {
+ s0 = readl (bgp-> base + devdata-> stat_offset) &
+ K3_VTM_TS_STAT_DTEMP_MASK;
+ s1 = readl (bgp-> base + devdata-> stat_offset) &
+ K3_VTM_TS_STAT_DTEMP_MASK;
+ s2 = readl (bgp-> base + devdata-> stat_offset) &
+ K3_VTM_TS_STAT_DTEMP_MASK;
+ dtemp = vtm_get_best_value (s0, s1, s2);
+} else {
+ dtemp = readl (bgp-> base + devdata-> stat_offset) &
+ K3_VTM_TS_STAT_DTEMP_MASK;
+}
+
+ if (dtemp <K3_VTM_ADC_BEGIN_VAL || dtemp> K3_VTM_ADC_END_VAL)
+ retornar -EINVAL;
+
+ * temp = k3_adc_to_temp [dtemp - K3_VTM_ADC_BEGIN_VAL];
+
+ retornar 0;
+}
+
+ / * ops da zona térmica * /
+ / * Obter função de retorno de temperatura para zona térmica * /
+ estático int k3_thermal_get_temp (void * devdata, int * temp)
+ {
+ struct k3_thermal_data * data = devdata;
+ int ret = 0;
+
+ ret = k3_bgp_read_temp (dados, temperatura);
+ se (ret)
+ retorno ret;
+
+ data-> prev_temp = * temp;
+
+ retorno ret;
+}
+
+ static int k3_thermal_get_trend (void * p, int trip, enum Thermal_trend * trend)
+ {
+ struct k3_thermal_data * data = p;
+ struct k3_bandgap * bgp;
+ int ret = 0, temp = 0;
+
+ bgp = dados-> bgp;
+
+ ret = k3_bgp_read_temp (dados e temperatura);
+ se (ret)
+ retorno ret;
+
+ if (temp> dados-> previsão_temp)
+ * tendência = THERMAL_TREND_RAISING;
+ else if (temp <data-> prev_temp)
+ * tendência = THERMAL_TREND_DROPPING;
+ else
+ * tendência = THERMAL_TREND_STABLE;
+
+ retornar 0;
+}
+
+ estrutura const estática Thermal_zone_of_device_ops k3_of_thermal_ops = {
+ .get_temp = k3_thermal_get_temp,
+ .get_trend = k3_thermal_get_trend,
+};
+
+ vazio estático k3_thermal_work (struct work_struct * work)
+ {
+ struct k3_thermal_data * data = container_of (trabalho,
+ struct k3_thermal_data, Thermal_wq);
+
+ Thermal_zone_device_update (data-> ti_thermal, THERMAL_EVENT_UNSPECIFIED);
+
+ dev_dbg (& data-> ti_thermal-> device, "zona térmica atualizada% s \ n",
+ data-> ti_thermal-> tipo);
+}
+
+ estrutura const estática do dispositivo_de_k3_bandgap_match [];
+
+ static int k3_bandgap_probe (struct platform_device * pdev)
+ {
+ int ret = 0, cnt, val, id, reg_cnt = 0;
+ estrutura resource * res;
+ dispositivo de estrutura * dev = & pdev-> dev;
+ struct k3_bandgap * bgp;
+ struct k3_thermal_data * dados;
+ const struct k3_vtm_driver_data * drv_data;
+
+ bgp = devm_kzalloc (& pdev-> dev, sizeof (* bgp), GFP_KERNEL);
+ se (! bgp)
+ retornar -ENOMEM;
+
+ drv_data = of_device_get_match_data (& pdev-> dev);
+ se (drv_data)
+ bgp-> errata = drv_data-> errata;
+
+ bgp-> dev = dev;
+ res = platform_get_resource (pdev, IORESOURCE_MEM, 0);
+ bgp-> base = devm_ioremap_resource (dev, res);
+ if (IS_ERR (bgp-> base))
+ retornar PTR_ERR (bgp-> base);
+
+ pm_runtime_enable (dev);
+ ret = pm_runtime_get_sync (dev);
+ se (ret <0) {
+ pm_runtime_put_noidle (dev);
+ pm_runtime_disable (dev);
+ retorno ret;
+}
+
+ / * Obtenha a contagem de sensores no VTM * /
+ val = readl (bgp-> base + K3_VTM_DEVINFO_PWR0_OFFSET);
+ cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK;
+ cnt >> = __ffs (K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK);
+ bgp-> ts_cnt = cnt;
+
+ data = devm_kcalloc (bgp-> dev, cnt, sizeof (* data), GFP_KERNEL);
+ se (! dados) {
+ ret = -ENOMEM;
+ ir para err_alloc;
+}
+
+ / * Registre os sensores térmicos * /
+ para (id = 0; id <cnt; id ++) {
+ data [id] .sensor_id = id;
+ dados [id] .bgp = bgp;
+ data [id] .ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET
+ id * K3_VTM_REGS_PER_TS;
+ data [id] .stat_offset = dados [id] .ctrl_offset + 0x8;
+ INIT_WORK (& data [id] .thermal_wq, k3_thermal_work);
+
+ val = readl (dados [id] .bgp-> base + dados [id] .ctrl_offset);
+ val | = (K3_VTM_TMPSENS_CTRL_SOC |
+ K3_VTM_TMPSENS_CTRL_CLRZ
+ K3_VTM_TMPSENS_CTRL_CLKON_REQ);
+ val & = ~ K3_VTM_TMPSENS_CTRL_CBIASSEL;
+ writel (val, dados [id] .bgp-> base + dados [id] .ctrl_offset);
+
+ bgp-> ts_data [id] = & dados [id];
+ data [id] .ti_thermal =
+ devm_thermal_zone_of_sensor_register (bgp-> dev, id,
+ & dados [id],
+ & k3_of_thermal_ops);
+ if (IS_ERR (dados [id] .ti_thermal)) {
+ dev_err (bgp-> dev, "o dispositivo da zona térmica é NULL \ n");
+ ret = PTR_ERR (dados [id] .ti_thermal);
+ ir para err_alloc;
+}
+
+ reg_cnt ++;
+
+ / * Inicializar temperatura anterior * /
+ k3_thermal_get_temp (& data [id], & data [id] .prev_temp);
+}
+
+ platform_set_drvdata (pdev, bgp);
+
+ retornar 0;
+
+ err_alloc:
+ pm_runtime_put_sync (& pdev-> dev);
+ pm_runtime_disable (& pdev-> dev);
+
+ retorno ret;
+}
+
+ static int k3_bandgap_remove (struct platform_device * pdev)
+ {
+ pm_runtime_put_sync (& pdev-> dev);
+ pm_runtime_disable (& pdev-> dev);
+
+ retornar 0;
+}
+
+ estrutura const estática k3_vtm_driver_data am654_data = {
+ .errata = 1,
+};
+
+ estrutura estática da const_dispositivo_id de_k3_bandgap_match [] = {
+ {
+ .compatible = "ti, am654-vtm",
+ .data = & am654_data,
+},
+ {/ * sentinela * /},
+};
+ MODULE_DEVICE_TABLE (de, of_k3_bandgap_match);
+
+ estrutura estática platform_driver k3_bandgap_sensor_driver = {
+ .probe = k3_bandgap_probe,
+ .remove = k3_bandgap_remove,
+ .driver = {
+ .name = "k3-soc-térmico",
+ .of_match_table = of_k3_bandgap_match,
+},
+};
+
+ módulo_plataforma_driver (k3_bandgap_sensor_driver);
+
+ MODULE_DESCRIPTION ("driver do sensor de temperatura com band Kap");
+ MODULE_LICENSE ("GPL v2");
+ MODULE_AUTHOR ("J Keerthy <j-keerthy @ xxxxxx>");
-
2.17.1
_______________________________________________
lista de discussão linux-arm-kernel
linux-arm-kernel @ xxxxxxxxxxxxxxxxxxx
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Referências :
[PATCH 0/4] Thermal: k3: adicione suporte para sensores de bandgap
De: Keerthy
Anterior à data: [PATCH 4/4] arm64: dts: ti: am6: Adicionar nó VTM
Next by Date: Re: [PATCH] ARM: adicione suporte para DEBUG_STACKOVERFLOW
Previous by thread: [PATCH 4/4] arm64: dts: ti: am6: adicione o nó VTM
Índice (es)
Date
Thread
Fonte
Até a próxima !!
Nenhum comentário:
Postar um comentário