1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright(C) 2020 Linaro Limited. All rights reserved.
4 * Author: Mike Leach <mike.leach@linaro.org>
5 */
6
7 #include <linux/sysfs.h>
8 #include "coresight-config.h"
9 #include "coresight-priv.h"
10
11 /*
12 * This provides a set of generic functions that operate on configurations
13 * and features to manage the handling of parameters, the programming and
14 * saving of registers used by features on devices.
15 */
16
17 /*
18 * Write the value held in the register structure into the driver internal memory
19 * location.
20 */
cscfg_set_reg(struct cscfg_regval_csdev * reg_csdev)21 static void cscfg_set_reg(struct cscfg_regval_csdev *reg_csdev)
22 {
23 u32 *p_val32 = (u32 *)reg_csdev->driver_regval;
24 u32 tmp32 = reg_csdev->reg_desc.val32;
25
26 if (reg_csdev->reg_desc.type & CS_CFG_REG_TYPE_VAL_64BIT) {
27 *((u64 *)reg_csdev->driver_regval) = reg_csdev->reg_desc.val64;
28 return;
29 }
30
31 if (reg_csdev->reg_desc.type & CS_CFG_REG_TYPE_VAL_MASK) {
32 tmp32 = *p_val32;
33 tmp32 &= ~reg_csdev->reg_desc.mask32;
34 tmp32 |= reg_csdev->reg_desc.val32 & reg_csdev->reg_desc.mask32;
35 }
36 *p_val32 = tmp32;
37 }
38
39 /*
40 * Read the driver value into the reg if this is marked as one we want to save.
41 */
cscfg_save_reg(struct cscfg_regval_csdev * reg_csdev)42 static void cscfg_save_reg(struct cscfg_regval_csdev *reg_csdev)
43 {
44 if (!(reg_csdev->reg_desc.type & CS_CFG_REG_TYPE_VAL_SAVE))
45 return;
46 if (reg_csdev->reg_desc.type & CS_CFG_REG_TYPE_VAL_64BIT)
47 reg_csdev->reg_desc.val64 = *(u64 *)(reg_csdev->driver_regval);
48 else
49 reg_csdev->reg_desc.val32 = *(u32 *)(reg_csdev->driver_regval);
50 }
51
52 /*
53 * Some register values are set from parameters. Initialise these registers
54 * from the current parameter values.
55 */
cscfg_init_reg_param(struct cscfg_feature_csdev * feat_csdev,struct cscfg_regval_desc * reg_desc,struct cscfg_regval_csdev * reg_csdev)56 static void cscfg_init_reg_param(struct cscfg_feature_csdev *feat_csdev,
57 struct cscfg_regval_desc *reg_desc,
58 struct cscfg_regval_csdev *reg_csdev)
59 {
60 struct cscfg_parameter_csdev *param_csdev;
61
62 /* for param, load routines have validated the index */
63 param_csdev = &feat_csdev->params_csdev[reg_desc->param_idx];
64 param_csdev->reg_csdev = reg_csdev;
65 param_csdev->val64 = reg_csdev->reg_desc.type & CS_CFG_REG_TYPE_VAL_64BIT;
66
67 if (param_csdev->val64)
68 reg_csdev->reg_desc.val64 = param_csdev->current_value;
69 else
70 reg_csdev->reg_desc.val32 = (u32)param_csdev->current_value;
71 }
72
73 /* set values into the driver locations referenced in cscfg_reg_csdev */
cscfg_set_on_enable(struct cscfg_feature_csdev * feat_csdev)74 static int cscfg_set_on_enable(struct cscfg_feature_csdev *feat_csdev)
75 {
76 unsigned long flags;
77 int i;
78
79 spin_lock_irqsave(feat_csdev->drv_spinlock, flags);
80 for (i = 0; i < feat_csdev->nr_regs; i++)
81 cscfg_set_reg(&feat_csdev->regs_csdev[i]);
82 spin_unlock_irqrestore(feat_csdev->drv_spinlock, flags);
83 dev_dbg(&feat_csdev->csdev->dev, "Feature %s: %s",
84 feat_csdev->feat_desc->name, "set on enable");
85 return 0;
86 }
87
88 /* copy back values from the driver locations referenced in cscfg_reg_csdev */
cscfg_save_on_disable(struct cscfg_feature_csdev * feat_csdev)89 static void cscfg_save_on_disable(struct cscfg_feature_csdev *feat_csdev)
90 {
91 unsigned long flags;
92 int i;
93
94 spin_lock_irqsave(feat_csdev->drv_spinlock, flags);
95 for (i = 0; i < feat_csdev->nr_regs; i++)
96 cscfg_save_reg(&feat_csdev->regs_csdev[i]);
97 spin_unlock_irqrestore(feat_csdev->drv_spinlock, flags);
98 dev_dbg(&feat_csdev->csdev->dev, "Feature %s: %s",
99 feat_csdev->feat_desc->name, "save on disable");
100 }
101
102 /* default reset - restore default values */
cscfg_reset_feat(struct cscfg_feature_csdev * feat_csdev)103 void cscfg_reset_feat(struct cscfg_feature_csdev *feat_csdev)
104 {
105 struct cscfg_regval_desc *reg_desc;
106 struct cscfg_regval_csdev *reg_csdev;
107 int i;
108
109 /*
110 * set the default values for all parameters and regs from the
111 * relevant static descriptors.
112 */
113 for (i = 0; i < feat_csdev->nr_params; i++)
114 feat_csdev->params_csdev[i].current_value =
115 feat_csdev->feat_desc->params_desc[i].value;
116
117 for (i = 0; i < feat_csdev->nr_regs; i++) {
118 reg_desc = &feat_csdev->feat_desc->regs_desc[i];
119 reg_csdev = &feat_csdev->regs_csdev[i];
120 reg_csdev->reg_desc.type = reg_desc->type;
121
122 /* check if reg set from a parameter otherwise desc default */
123 if (reg_desc->type & CS_CFG_REG_TYPE_VAL_PARAM)
124 cscfg_init_reg_param(feat_csdev, reg_desc, reg_csdev);
125 else
126 /*
127 * for normal values the union between val64 & val32 + mask32
128 * allows us to init using the 64 bit value
129 */
130 reg_csdev->reg_desc.val64 = reg_desc->val64;
131 }
132 }
133
134 /*
135 * For the selected presets, we set the register associated with the parameter, to
136 * the value of the preset index associated with the parameter.
137 */
cscfg_update_presets(struct cscfg_config_csdev * config_csdev,int preset)138 static int cscfg_update_presets(struct cscfg_config_csdev *config_csdev, int preset)
139 {
140 int i, j, val_idx = 0, nr_cfg_params;
141 struct cscfg_parameter_csdev *param_csdev;
142 struct cscfg_feature_csdev *feat_csdev;
143 const struct cscfg_config_desc *config_desc = config_csdev->config_desc;
144 const char *name;
145 const u64 *preset_base;
146 u64 val;
147
148 /* preset in range 1 to nr_presets */
149 if (preset < 1 || preset > config_desc->nr_presets)
150 return -EINVAL;
151 /*
152 * Go through the array of features, assigning preset values to
153 * feature parameters in the order they appear.
154 * There should be precisely the same number of preset values as the
155 * sum of number of parameters over all the features - but we will
156 * ensure there is no overrun.
157 */
158 nr_cfg_params = config_desc->nr_total_params;
159 preset_base = &config_desc->presets[(preset - 1) * nr_cfg_params];
160 for (i = 0; i < config_csdev->nr_feat; i++) {
161 feat_csdev = config_csdev->feats_csdev[i];
162 if (!feat_csdev->nr_params)
163 continue;
164
165 for (j = 0; j < feat_csdev->nr_params; j++) {
166 param_csdev = &feat_csdev->params_csdev[j];
167 name = feat_csdev->feat_desc->params_desc[j].name;
168 val = preset_base[val_idx++];
169 if (param_csdev->val64) {
170 dev_dbg(&config_csdev->csdev->dev,
171 "set param %s (%lld)", name, val);
172 param_csdev->reg_csdev->reg_desc.val64 = val;
173 } else {
174 param_csdev->reg_csdev->reg_desc.val32 = (u32)val;
175 dev_dbg(&config_csdev->csdev->dev,
176 "set param %s (%d)", name, (u32)val);
177 }
178 }
179
180 /* exit early if all params filled */
181 if (val_idx >= nr_cfg_params)
182 break;
183 }
184 return 0;
185 }
186
187 /*
188 * if we are not using a preset, then need to update the feature params
189 * with current values. This sets the register associated with the parameter
190 * with the current value of that parameter.
191 */
cscfg_update_curr_params(struct cscfg_config_csdev * config_csdev)192 static int cscfg_update_curr_params(struct cscfg_config_csdev *config_csdev)
193 {
194 int i, j;
195 struct cscfg_feature_csdev *feat_csdev;
196 struct cscfg_parameter_csdev *param_csdev;
197 const char *name;
198 u64 val;
199
200 for (i = 0; i < config_csdev->nr_feat; i++) {
201 feat_csdev = config_csdev->feats_csdev[i];
202 if (!feat_csdev->nr_params)
203 continue;
204 for (j = 0; j < feat_csdev->nr_params; j++) {
205 param_csdev = &feat_csdev->params_csdev[j];
206 name = feat_csdev->feat_desc->params_desc[j].name;
207 val = param_csdev->current_value;
208 if (param_csdev->val64) {
209 dev_dbg(&config_csdev->csdev->dev,
210 "set param %s (%lld)", name, val);
211 param_csdev->reg_csdev->reg_desc.val64 = val;
212 } else {
213 param_csdev->reg_csdev->reg_desc.val32 = (u32)val;
214 dev_dbg(&config_csdev->csdev->dev,
215 "set param %s (%d)", name, (u32)val);
216 }
217 }
218 }
219 return 0;
220 }
221
222 /*
223 * Configuration values will be programmed into the driver locations if enabling, or read
224 * from relevant locations on disable.
225 */
cscfg_prog_config(struct cscfg_config_csdev * config_csdev,bool enable)226 static int cscfg_prog_config(struct cscfg_config_csdev *config_csdev, bool enable)
227 {
228 int i, err = 0;
229 struct cscfg_feature_csdev *feat_csdev;
230 struct coresight_device *csdev;
231
232 for (i = 0; i < config_csdev->nr_feat; i++) {
233 feat_csdev = config_csdev->feats_csdev[i];
234 csdev = feat_csdev->csdev;
235 dev_dbg(&csdev->dev, "cfg %s; %s feature:%s", config_csdev->config_desc->name,
236 enable ? "enable" : "disable", feat_csdev->feat_desc->name);
237
238 if (enable)
239 err = cscfg_set_on_enable(feat_csdev);
240 else
241 cscfg_save_on_disable(feat_csdev);
242
243 if (err)
244 break;
245 }
246 return err;
247 }
248
249 /*
250 * Enable configuration for the device. Will result in the internal driver data
251 * being updated ready for programming into the device.
252 *
253 * @config_csdev: config_csdev to set.
254 * @preset: preset values to use - 0 for default.
255 */
cscfg_csdev_enable_config(struct cscfg_config_csdev * config_csdev,int preset)256 int cscfg_csdev_enable_config(struct cscfg_config_csdev *config_csdev, int preset)
257 {
258 int err = 0;
259
260 if (preset)
261 err = cscfg_update_presets(config_csdev, preset);
262 else
263 err = cscfg_update_curr_params(config_csdev);
264 if (!err)
265 err = cscfg_prog_config(config_csdev, true);
266 return err;
267 }
268
cscfg_csdev_disable_config(struct cscfg_config_csdev * config_csdev)269 void cscfg_csdev_disable_config(struct cscfg_config_csdev *config_csdev)
270 {
271 cscfg_prog_config(config_csdev, false);
272 }
273