Lines Matching defs:bgp
38 static int ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id);
48 * @bgp: pointer to ti_bandgap structure
54 static u32 ti_bandgap_readl(struct ti_bandgap *bgp, u32 reg)
56 return readl(bgp->base + reg);
61 * @bgp: pointer to ti_bandgap structure
67 static void ti_bandgap_writel(struct ti_bandgap *bgp, u32 val, u32 reg)
69 writel(val, bgp->base + reg);
78 #define RMW_BITS(bgp, id, reg, mask, val) \
83 t = bgp->conf->sensors[(id)].registers; \
84 r = ti_bandgap_readl(bgp, t->reg); \
87 ti_bandgap_writel(bgp, r, t->reg); \
94 * @bgp: pointer to ti_bandgap structure
102 static int ti_bandgap_power(struct ti_bandgap *bgp, bool on)
106 if (!TI_BANDGAP_HAS(bgp, POWER_SWITCH))
109 for (i = 0; i < bgp->conf->sensor_count; i++)
111 RMW_BITS(bgp, i, temp_sensor_ctrl, bgap_tempsoff_mask, !on);
117 * @bgp: pointer to ti_bandgap structure
131 static u32 ti_errata814_bandgap_read_temp(struct ti_bandgap *bgp, u32 reg)
135 val1 = ti_bandgap_readl(bgp, reg);
136 val2 = ti_bandgap_readl(bgp, reg);
143 return ti_bandgap_readl(bgp, reg);
148 * @bgp: pointer to ti_bandgap structure
158 static u32 ti_bandgap_read_temp(struct ti_bandgap *bgp, int id)
163 tsr = bgp->conf->sensors[id].registers;
166 if (TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
167 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
176 if (TI_BANDGAP_HAS(bgp, ERRATA_814))
177 temp = ti_errata814_bandgap_read_temp(bgp, reg);
179 temp = ti_bandgap_readl(bgp, reg);
183 if (TI_BANDGAP_HAS(bgp, FREEZE_BIT))
184 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
206 struct ti_bandgap *bgp = data;
211 spin_lock(&bgp->lock);
212 for (i = 0; i < bgp->conf->sensor_count; i++) {
213 tsr = bgp->conf->sensors[i].registers;
214 ctrl = ti_bandgap_readl(bgp, tsr->bgap_status);
225 ctrl = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
239 ti_bandgap_writel(bgp, ctrl, tsr->bgap_mask_ctrl);
241 dev_dbg(bgp->dev,
243 __func__, bgp->conf->sensors[i].domain,
247 if (bgp->conf->report_temperature)
248 bgp->conf->report_temperature(bgp, i);
250 spin_unlock(&bgp->lock);
280 * @bgp: struct ti_bandgap pointer
292 int ti_bandgap_adc_to_mcelsius(struct ti_bandgap *bgp, int adc_val, int *t)
294 const struct ti_bandgap_data *conf = bgp->conf;
300 *t = bgp->conf->conv_table[adc_val - conf->adc_start_val];
306 * @bgp: struct ti_bandgap pointer
312 * Return: 0 if no errors, -EINVAL for invalid @bgp pointer or -ERANGE if
313 * @id cannot index @bgp sensors.
315 static inline int ti_bandgap_validate(struct ti_bandgap *bgp, int id)
317 if (IS_ERR_OR_NULL(bgp)) {
322 if ((id < 0) || (id >= bgp->conf->sensor_count)) {
323 dev_err(bgp->dev, "%s: sensor id out of range (%d)\n",
333 * @bgp: pointer to bandgap instance
337 static void ti_bandgap_read_counter(struct ti_bandgap *bgp, int id,
343 tsr = bgp->conf->sensors[id].registers;
344 time = ti_bandgap_readl(bgp, tsr->bgap_counter);
347 time = time * 1000 / bgp->clk_rate;
353 * @bgp: pointer to bandgap instance
357 static void ti_bandgap_read_counter_delay(struct ti_bandgap *bgp, int id,
363 tsr = bgp->conf->sensors[id].registers;
365 reg_val = ti_bandgap_readl(bgp, tsr->bgap_mask_ctrl);
388 dev_warn(bgp->dev, "Wrong counter delay value read from register %X",
395 * @bgp: pointer to bandgap instance
401 int ti_bandgap_read_update_interval(struct ti_bandgap *bgp, int id,
406 ret = ti_bandgap_validate(bgp, id);
410 if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
411 !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
416 if (TI_BANDGAP_HAS(bgp, COUNTER)) {
417 ti_bandgap_read_counter(bgp, id, interval);
421 ti_bandgap_read_counter_delay(bgp, id, interval);
428 * @bgp: pointer to bandgap instance
434 static int ti_bandgap_write_counter_delay(struct ti_bandgap *bgp, int id,
459 dev_warn(bgp->dev, "Delay %d ms is not supported\n", interval);
463 spin_lock(&bgp->lock);
464 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_counter_delay_mask, rval);
465 spin_unlock(&bgp->lock);
472 * @bgp: pointer to bandgap instance
476 static void ti_bandgap_write_counter(struct ti_bandgap *bgp, int id,
479 interval = interval * bgp->clk_rate / 1000;
480 spin_lock(&bgp->lock);
481 RMW_BITS(bgp, id, bgap_counter, counter_mask, interval);
482 spin_unlock(&bgp->lock);
487 * @bgp: pointer to bandgap instance
493 int ti_bandgap_write_update_interval(struct ti_bandgap *bgp,
496 int ret = ti_bandgap_validate(bgp, id);
500 if (!TI_BANDGAP_HAS(bgp, COUNTER) &&
501 !TI_BANDGAP_HAS(bgp, COUNTER_DELAY)) {
506 if (TI_BANDGAP_HAS(bgp, COUNTER)) {
507 ti_bandgap_write_counter(bgp, id, interval);
511 ret = ti_bandgap_write_counter_delay(bgp, id, interval);
518 * @bgp: pointer to bandgap instance
524 int ti_bandgap_read_temperature(struct ti_bandgap *bgp, int id,
530 ret = ti_bandgap_validate(bgp, id);
534 if (!TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
535 ret = ti_bandgap_force_single_read(bgp, id);
540 spin_lock(&bgp->lock);
541 temp = ti_bandgap_read_temp(bgp, id);
542 spin_unlock(&bgp->lock);
544 ret = ti_bandgap_adc_to_mcelsius(bgp, temp, &temp);
556 * @bgp: pointer to bandgap instance
562 int ti_bandgap_set_sensor_data(struct ti_bandgap *bgp, int id, void *data)
564 int ret = ti_bandgap_validate(bgp, id);
568 bgp->regval[id].data = data;
576 * @bgp: pointer to bandgap instance
581 void *ti_bandgap_get_sensor_data(struct ti_bandgap *bgp, int id)
583 int ret = ti_bandgap_validate(bgp, id);
587 return bgp->regval[id].data;
594 * @bgp: pointer to struct ti_bandgap
603 ti_bandgap_force_single_read(struct ti_bandgap *bgp, int id)
605 struct temp_sensor_registers *tsr = bgp->conf->sensors[id].registers;
606 void __iomem *temp_sensor_ctrl = bgp->base + tsr->temp_sensor_ctrl;
611 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG)) {
612 if (TI_BANDGAP_HAS(bgp, CONT_MODE_ONLY))
613 RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 1);
615 RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
620 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 1);
627 dev_warn(bgp->dev, "eocz timed out waiting high\n");
630 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 0);
638 dev_warn(bgp->dev, "eocz timed out waiting low\n");
645 * @bgp: pointer to struct ti_bandgap
654 static int ti_bandgap_set_continuous_mode(struct ti_bandgap *bgp)
658 for (i = 0; i < bgp->conf->sensor_count; i++) {
660 ti_bandgap_force_single_read(bgp, i);
661 RMW_BITS(bgp, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
669 * @bgp: pointer to struct ti_bandgap
682 int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend)
688 ret = ti_bandgap_validate(bgp, id);
692 if (!TI_BANDGAP_HAS(bgp, HISTORY_BUFFER) ||
693 !TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
698 spin_lock(&bgp->lock);
700 tsr = bgp->conf->sensors[id].registers;
703 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
708 temp1 = ti_bandgap_readl(bgp, reg1);
711 temp2 = ti_bandgap_readl(bgp, reg2);
715 ret = ti_bandgap_adc_to_mcelsius(bgp, temp1, &t1);
719 ret = ti_bandgap_adc_to_mcelsius(bgp, temp2, &t2);
724 ret = ti_bandgap_read_update_interval(bgp, id, &interval);
734 dev_dbg(bgp->dev, "The temperatures are t1 = %d and t2 = %d and trend =%d\n",
738 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
739 spin_unlock(&bgp->lock);
746 * @bgp: pointer to struct ti_bandgap
758 static int ti_bandgap_tshut_init(struct ti_bandgap *bgp,
763 status = request_irq(gpiod_to_irq(bgp->tshut_gpiod),
767 dev_err(bgp->dev, "request irq failed for TSHUT");
774 * @bgp: pointer to struct ti_bandgap
785 static int ti_bandgap_talert_init(struct ti_bandgap *bgp,
790 bgp->irq = platform_get_irq(pdev, 0);
791 if (bgp->irq < 0)
792 return bgp->irq;
794 ret = request_threaded_irq(bgp->irq, NULL,
797 "talert", bgp);
822 struct ti_bandgap *bgp;
832 bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
833 if (!bgp)
838 bgp->conf = of_id->data;
841 bgp->regval = devm_kcalloc(&pdev->dev, bgp->conf->sensor_count,
842 sizeof(*bgp->regval), GFP_KERNEL);
843 if (!bgp->regval)
855 bgp->base = chunk;
862 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
863 bgp->tshut_gpiod = devm_gpiod_get(&pdev->dev, NULL, GPIOD_IN);
864 if (IS_ERR(bgp->tshut_gpiod)) {
866 return ERR_CAST(bgp->tshut_gpiod);
870 return bgp;
889 struct ti_bandgap *bgp;
892 bgp = ti_bandgap_build(pdev);
893 if (IS_ERR(bgp)) {
895 return PTR_ERR(bgp);
897 bgp->dev = &pdev->dev;
899 if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
903 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
904 ret = ti_bandgap_tshut_init(bgp, pdev);
912 bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
913 if (IS_ERR(bgp->fclock)) {
915 ret = PTR_ERR(bgp->fclock);
919 bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
920 if (IS_ERR(bgp->div_clk)) {
922 ret = PTR_ERR(bgp->div_clk);
926 for (i = 0; i < bgp->conf->sensor_count; i++) {
930 tsr = bgp->conf->sensors[i].registers;
936 val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
942 clk_rate = clk_round_rate(bgp->div_clk,
943 bgp->conf->sensors[0].ts_data->max_freq);
944 if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
951 ret = clk_set_rate(bgp->div_clk, clk_rate);
955 bgp->clk_rate = clk_rate;
956 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
957 clk_prepare_enable(bgp->fclock);
960 spin_lock_init(&bgp->lock);
961 bgp->dev = &pdev->dev;
962 platform_set_drvdata(pdev, bgp);
964 ti_bandgap_power(bgp, true);
967 if (TI_BANDGAP_HAS(bgp, COUNTER))
968 for (i = 0; i < bgp->conf->sensor_count; i++)
969 RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
972 for (i = 0; i < bgp->conf->sensor_count; i++) {
975 ts_data = bgp->conf->sensors[i].ts_data;
977 if (TI_BANDGAP_HAS(bgp, TALERT)) {
979 RMW_BITS(bgp, i, bgap_threshold,
981 RMW_BITS(bgp, i, bgap_threshold,
984 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
985 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
988 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
990 RMW_BITS(bgp, i, tshut_threshold,
992 RMW_BITS(bgp, i, tshut_threshold,
997 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
998 ti_bandgap_set_continuous_mode(bgp);
1001 if (TI_BANDGAP_HAS(bgp, COUNTER))
1002 for (i = 0; i < bgp->conf->sensor_count; i++)
1003 RMW_BITS(bgp, i, bgap_counter, counter_mask,
1004 bgp->clk_rate / 4);
1007 for (i = 0; i < bgp->conf->sensor_count; i++) {
1010 if (bgp->conf->sensors[i].register_cooling) {
1011 ret = bgp->conf->sensors[i].register_cooling(bgp, i);
1016 if (bgp->conf->expose_sensor) {
1017 domain = bgp->conf->sensors[i].domain;
1018 ret = bgp->conf->expose_sensor(bgp, i, domain);
1029 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1030 ret = ti_bandgap_talert_init(bgp, pdev);
1033 i = bgp->conf->sensor_count;
1039 bgp->nb.notifier_call = bandgap_omap_cpu_notifier;
1041 cpu_pm_register_notifier(&bgp->nb);
1047 if (bgp->conf->sensors[i].unregister_cooling)
1048 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1051 if (bgp->conf->sensors[i].unregister_cooling)
1052 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1053 if (bgp->conf->remove_sensor)
1054 bgp->conf->remove_sensor(bgp, i);
1056 ti_bandgap_power(bgp, false);
1058 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1059 clk_disable_unprepare(bgp->fclock);
1061 clk_put(bgp->div_clk);
1063 clk_put(bgp->fclock);
1065 if (TI_BANDGAP_HAS(bgp, TSHUT))
1066 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1074 struct ti_bandgap *bgp = platform_get_drvdata(pdev);
1078 cpu_pm_unregister_notifier(&bgp->nb);
1081 for (i = 0; i < bgp->conf->sensor_count; i++) {
1082 if (bgp->conf->sensors[i].unregister_cooling)
1083 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1085 if (bgp->conf->remove_sensor)
1086 bgp->conf->remove_sensor(bgp, i);
1089 ti_bandgap_power(bgp, false);
1091 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1092 clk_disable_unprepare(bgp->fclock);
1093 clk_put(bgp->fclock);
1094 clk_put(bgp->div_clk);
1096 if (TI_BANDGAP_HAS(bgp, TALERT))
1097 free_irq(bgp->irq, bgp);
1099 if (TI_BANDGAP_HAS(bgp, TSHUT))
1100 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1106 static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
1110 for (i = 0; i < bgp->conf->sensor_count; i++) {
1114 rval = &bgp->regval[i];
1115 tsr = bgp->conf->sensors[i].registers;
1117 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1118 rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
1120 if (TI_BANDGAP_HAS(bgp, COUNTER))
1121 rval->bg_counter = ti_bandgap_readl(bgp,
1123 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1124 rval->bg_threshold = ti_bandgap_readl(bgp,
1126 rval->bg_ctrl = ti_bandgap_readl(bgp,
1130 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1131 rval->tshut_threshold = ti_bandgap_readl(bgp,
1138 static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
1142 for (i = 0; i < bgp->conf->sensor_count; i++) {
1146 rval = &bgp->regval[i];
1147 tsr = bgp->conf->sensors[i].registers;
1149 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1150 ti_bandgap_writel(bgp, rval->tshut_threshold,
1155 ti_bandgap_force_single_read(bgp, i);
1157 if (TI_BANDGAP_HAS(bgp, COUNTER))
1158 ti_bandgap_writel(bgp, rval->bg_counter,
1160 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1161 ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
1163 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1164 ti_bandgap_writel(bgp, rval->bg_threshold,
1166 ti_bandgap_writel(bgp, rval->bg_ctrl,
1176 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1179 err = ti_bandgap_save_ctxt(bgp);
1180 ti_bandgap_power(bgp, false);
1182 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1183 clk_disable_unprepare(bgp->fclock);
1185 bgp->is_suspended = true;
1193 struct ti_bandgap *bgp;
1195 bgp = container_of(nb, struct ti_bandgap, nb);
1197 spin_lock(&bgp->lock);
1200 if (bgp->is_suspended)
1202 ti_bandgap_save_ctxt(bgp);
1203 ti_bandgap_power(bgp, false);
1204 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1205 clk_disable(bgp->fclock);
1209 if (bgp->is_suspended)
1211 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1212 clk_enable(bgp->fclock);
1213 ti_bandgap_power(bgp, true);
1214 ti_bandgap_restore_ctxt(bgp);
1217 spin_unlock(&bgp->lock);
1224 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1226 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1227 clk_prepare_enable(bgp->fclock);
1229 ti_bandgap_power(bgp, true);
1230 bgp->is_suspended = false;
1232 return ti_bandgap_restore_ctxt(bgp);