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 (!bgp || IS_ERR(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)
609 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
610 RMW_BITS(bgp, id, bgap_mode_ctrl, mode_ctrl_mask, 0);
613 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 1);
616 tsr = bgp->conf->sensors[id].registers;
619 if (ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
625 RMW_BITS(bgp, id, temp_sensor_ctrl, bgap_soc_mask, 0);
630 if (!(ti_bandgap_readl(bgp, tsr->temp_sensor_ctrl) &
640 * @bgp: pointer to struct ti_bandgap
649 static int ti_bandgap_set_continuous_mode(struct ti_bandgap *bgp)
653 for (i = 0; i < bgp->conf->sensor_count; i++) {
655 ti_bandgap_force_single_read(bgp, i);
656 RMW_BITS(bgp, i, bgap_mode_ctrl, mode_ctrl_mask, 1);
664 * @bgp: pointer to struct ti_bandgap
677 int ti_bandgap_get_trend(struct ti_bandgap *bgp, int id, int *trend)
683 ret = ti_bandgap_validate(bgp, id);
687 if (!TI_BANDGAP_HAS(bgp, HISTORY_BUFFER) ||
688 !TI_BANDGAP_HAS(bgp, FREEZE_BIT)) {
693 spin_lock(&bgp->lock);
695 tsr = bgp->conf->sensors[id].registers;
698 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 1);
703 temp1 = ti_bandgap_readl(bgp, reg1);
706 temp2 = ti_bandgap_readl(bgp, reg2);
710 ret = ti_bandgap_adc_to_mcelsius(bgp, temp1, &t1);
714 ret = ti_bandgap_adc_to_mcelsius(bgp, temp2, &t2);
719 ret = ti_bandgap_read_update_interval(bgp, id, &interval);
729 dev_dbg(bgp->dev, "The temperatures are t1 = %d and t2 = %d and trend =%d\n",
733 RMW_BITS(bgp, id, bgap_mask_ctrl, mask_freeze_mask, 0);
734 spin_unlock(&bgp->lock);
741 * @bgp: pointer to struct ti_bandgap
753 static int ti_bandgap_tshut_init(struct ti_bandgap *bgp,
758 status = request_irq(gpiod_to_irq(bgp->tshut_gpiod),
762 dev_err(bgp->dev, "request irq failed for TSHUT");
769 * @bgp: pointer to struct ti_bandgap
780 static int ti_bandgap_talert_init(struct ti_bandgap *bgp,
785 bgp->irq = platform_get_irq(pdev, 0);
786 if (bgp->irq < 0)
787 return bgp->irq;
789 ret = request_threaded_irq(bgp->irq, NULL,
792 "talert", bgp);
817 struct ti_bandgap *bgp;
827 bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
828 if (!bgp)
833 bgp->conf = of_id->data;
836 bgp->regval = devm_kcalloc(&pdev->dev, bgp->conf->sensor_count,
837 sizeof(*bgp->regval), GFP_KERNEL);
838 if (!bgp->regval)
850 bgp->base = chunk;
857 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
858 bgp->tshut_gpiod = devm_gpiod_get(&pdev->dev, NULL, GPIOD_IN);
859 if (IS_ERR(bgp->tshut_gpiod)) {
861 return ERR_CAST(bgp->tshut_gpiod);
865 return bgp;
884 struct ti_bandgap *bgp;
887 bgp = ti_bandgap_build(pdev);
888 if (IS_ERR(bgp)) {
890 return PTR_ERR(bgp);
892 bgp->dev = &pdev->dev;
894 if (TI_BANDGAP_HAS(bgp, UNRELIABLE))
898 if (TI_BANDGAP_HAS(bgp, TSHUT)) {
899 ret = ti_bandgap_tshut_init(bgp, pdev);
907 bgp->fclock = clk_get(NULL, bgp->conf->fclock_name);
908 if (IS_ERR(bgp->fclock)) {
910 ret = PTR_ERR(bgp->fclock);
914 bgp->div_clk = clk_get(NULL, bgp->conf->div_ck_name);
915 if (IS_ERR(bgp->div_clk)) {
917 ret = PTR_ERR(bgp->div_clk);
921 for (i = 0; i < bgp->conf->sensor_count; i++) {
925 tsr = bgp->conf->sensors[i].registers;
931 val = ti_bandgap_readl(bgp, tsr->bgap_efuse);
937 clk_rate = clk_round_rate(bgp->div_clk,
938 bgp->conf->sensors[0].ts_data->max_freq);
939 if (clk_rate < bgp->conf->sensors[0].ts_data->min_freq ||
946 ret = clk_set_rate(bgp->div_clk, clk_rate);
950 bgp->clk_rate = clk_rate;
951 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
952 clk_prepare_enable(bgp->fclock);
955 spin_lock_init(&bgp->lock);
956 bgp->dev = &pdev->dev;
957 platform_set_drvdata(pdev, bgp);
959 ti_bandgap_power(bgp, true);
962 if (TI_BANDGAP_HAS(bgp, COUNTER))
963 for (i = 0; i < bgp->conf->sensor_count; i++)
964 RMW_BITS(bgp, i, bgap_counter, counter_mask, 1);
967 for (i = 0; i < bgp->conf->sensor_count; i++) {
970 ts_data = bgp->conf->sensors[i].ts_data;
972 if (TI_BANDGAP_HAS(bgp, TALERT)) {
974 RMW_BITS(bgp, i, bgap_threshold,
976 RMW_BITS(bgp, i, bgap_threshold,
979 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_hot_mask, 1);
980 RMW_BITS(bgp, i, bgap_mask_ctrl, mask_cold_mask, 1);
983 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG)) {
985 RMW_BITS(bgp, i, tshut_threshold,
987 RMW_BITS(bgp, i, tshut_threshold,
992 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
993 ti_bandgap_set_continuous_mode(bgp);
996 if (TI_BANDGAP_HAS(bgp, COUNTER))
997 for (i = 0; i < bgp->conf->sensor_count; i++)
998 RMW_BITS(bgp, i, bgap_counter, counter_mask,
999 bgp->clk_rate / 4);
1002 for (i = 0; i < bgp->conf->sensor_count; i++) {
1005 if (bgp->conf->sensors[i].register_cooling) {
1006 ret = bgp->conf->sensors[i].register_cooling(bgp, i);
1011 if (bgp->conf->expose_sensor) {
1012 domain = bgp->conf->sensors[i].domain;
1013 ret = bgp->conf->expose_sensor(bgp, i, domain);
1024 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1025 ret = ti_bandgap_talert_init(bgp, pdev);
1028 i = bgp->conf->sensor_count;
1034 bgp->nb.notifier_call = bandgap_omap_cpu_notifier;
1036 cpu_pm_register_notifier(&bgp->nb);
1042 if (bgp->conf->sensors[i].unregister_cooling)
1043 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1046 if (bgp->conf->sensors[i].unregister_cooling)
1047 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1048 if (bgp->conf->remove_sensor)
1049 bgp->conf->remove_sensor(bgp, i);
1051 ti_bandgap_power(bgp, false);
1053 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1054 clk_disable_unprepare(bgp->fclock);
1056 clk_put(bgp->div_clk);
1058 clk_put(bgp->fclock);
1060 if (TI_BANDGAP_HAS(bgp, TSHUT))
1061 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1069 struct ti_bandgap *bgp = platform_get_drvdata(pdev);
1073 cpu_pm_unregister_notifier(&bgp->nb);
1076 for (i = 0; i < bgp->conf->sensor_count; i++) {
1077 if (bgp->conf->sensors[i].unregister_cooling)
1078 bgp->conf->sensors[i].unregister_cooling(bgp, i);
1080 if (bgp->conf->remove_sensor)
1081 bgp->conf->remove_sensor(bgp, i);
1084 ti_bandgap_power(bgp, false);
1086 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1087 clk_disable_unprepare(bgp->fclock);
1088 clk_put(bgp->fclock);
1089 clk_put(bgp->div_clk);
1091 if (TI_BANDGAP_HAS(bgp, TALERT))
1092 free_irq(bgp->irq, bgp);
1094 if (TI_BANDGAP_HAS(bgp, TSHUT))
1095 free_irq(gpiod_to_irq(bgp->tshut_gpiod), NULL);
1101 static int ti_bandgap_save_ctxt(struct ti_bandgap *bgp)
1105 for (i = 0; i < bgp->conf->sensor_count; i++) {
1109 rval = &bgp->regval[i];
1110 tsr = bgp->conf->sensors[i].registers;
1112 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1113 rval->bg_mode_ctrl = ti_bandgap_readl(bgp,
1115 if (TI_BANDGAP_HAS(bgp, COUNTER))
1116 rval->bg_counter = ti_bandgap_readl(bgp,
1118 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1119 rval->bg_threshold = ti_bandgap_readl(bgp,
1121 rval->bg_ctrl = ti_bandgap_readl(bgp,
1125 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1126 rval->tshut_threshold = ti_bandgap_readl(bgp,
1133 static int ti_bandgap_restore_ctxt(struct ti_bandgap *bgp)
1137 for (i = 0; i < bgp->conf->sensor_count; i++) {
1142 rval = &bgp->regval[i];
1143 tsr = bgp->conf->sensors[i].registers;
1145 if (TI_BANDGAP_HAS(bgp, COUNTER))
1146 val = ti_bandgap_readl(bgp, tsr->bgap_counter);
1148 if (TI_BANDGAP_HAS(bgp, TSHUT_CONFIG))
1149 ti_bandgap_writel(bgp, rval->tshut_threshold,
1154 ti_bandgap_force_single_read(bgp, i);
1156 if (TI_BANDGAP_HAS(bgp, COUNTER))
1157 ti_bandgap_writel(bgp, rval->bg_counter,
1159 if (TI_BANDGAP_HAS(bgp, MODE_CONFIG))
1160 ti_bandgap_writel(bgp, rval->bg_mode_ctrl,
1162 if (TI_BANDGAP_HAS(bgp, TALERT)) {
1163 ti_bandgap_writel(bgp, rval->bg_threshold,
1165 ti_bandgap_writel(bgp, rval->bg_ctrl,
1175 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1178 err = ti_bandgap_save_ctxt(bgp);
1179 ti_bandgap_power(bgp, false);
1181 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1182 clk_disable_unprepare(bgp->fclock);
1184 bgp->is_suspended = true;
1192 struct ti_bandgap *bgp;
1194 bgp = container_of(nb, struct ti_bandgap, nb);
1196 spin_lock(&bgp->lock);
1199 if (bgp->is_suspended)
1201 ti_bandgap_save_ctxt(bgp);
1202 ti_bandgap_power(bgp, false);
1203 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1204 clk_disable(bgp->fclock);
1208 if (bgp->is_suspended)
1210 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1211 clk_enable(bgp->fclock);
1212 ti_bandgap_power(bgp, true);
1213 ti_bandgap_restore_ctxt(bgp);
1216 spin_unlock(&bgp->lock);
1223 struct ti_bandgap *bgp = dev_get_drvdata(dev);
1225 if (TI_BANDGAP_HAS(bgp, CLK_CTRL))
1226 clk_prepare_enable(bgp->fclock);
1228 ti_bandgap_power(bgp, true);
1229 bgp->is_suspended = false;
1231 return ti_bandgap_restore_ctxt(bgp);