* [lee-mfd:ib-mfd-clk-gpio-regulator-rtc-5.13 12/16] drivers/regulator/bd71828-regulator.c:191:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast
@ 2021-04-14 12:50 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2021-04-14 12:50 UTC (permalink / raw)
To: kbuild-all
[-- Attachment #1: Type: text/plain, Size: 30270 bytes --]
tree: https://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git ib-mfd-clk-gpio-regulator-rtc-5.13
head: 5a8a64d9a38b9d3794f9f5e153fc0358b858cc24
commit: 18f3c62586f7b4e1f038f570acda61a25c97c4ee [12/16] regulator: bd718x7, bd71828: Use ramp-delay helper
config: i386-randconfig-s001-20210414 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce:
# apt-get install sparse
# sparse version: v0.6.3-280-g2cd6d34e-dirty
# https://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git/commit/?id=18f3c62586f7b4e1f038f570acda61a25c97c4ee
git remote add lee-mfd https://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git
git fetch --no-tags lee-mfd ib-mfd-clk-gpio-regulator-rtc-5.13
git checkout 18f3c62586f7b4e1f038f570acda61a25c97c4ee
# save the attached .config to linux build tree
make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' W=1 ARCH=i386
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All warnings (new ones prefixed by >>):
drivers/regulator/bd71828-regulator.c:157:20: error: 'regulator_set_ramp_delay_regmap' undeclared here (not in a function); did you mean 'regulator_set_pull_down_regmap'?
157 | .set_ramp_delay = regulator_set_ramp_delay_regmap,
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
| regulator_set_pull_down_regmap
drivers/regulator/bd71828-regulator.c:191:5: error: 'struct regulator_desc' has no member named 'ramp_delay_table'; did you mean 'ramp_delay'?
191 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~
| ramp_delay
>> drivers/regulator/bd71828-regulator.c:191:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast [-Wint-conversion]
191 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:191:24: note: (near initialization for 'bd71828_rdata[0].desc.vsel_step')
drivers/regulator/bd71828-regulator.c:192:5: error: 'struct regulator_desc' has no member named 'n_ramp_values'
192 | .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
| ^~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:193:5: error: 'struct regulator_desc' has no member named 'ramp_reg'; did you mean 'ramp_delay'?
193 | .ramp_reg = BD71828_REG_BUCK1_MODE,
| ^~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:194:5: error: 'struct regulator_desc' has no member named 'ramp_mask'
194 | .ramp_mask = BD71828_MASK_RAMP_DELAY,
| ^~~~~~~~~
drivers/regulator/bd71828-regulator.c:237:5: error: 'struct regulator_desc' has no member named 'ramp_delay_table'; did you mean 'ramp_delay'?
237 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:237:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast [-Wint-conversion]
237 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:237:24: note: (near initialization for 'bd71828_rdata[1].desc.vsel_step')
drivers/regulator/bd71828-regulator.c:238:5: error: 'struct regulator_desc' has no member named 'n_ramp_values'
238 | .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
| ^~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:239:5: error: 'struct regulator_desc' has no member named 'ramp_reg'; did you mean 'ramp_delay'?
239 | .ramp_reg = BD71828_REG_BUCK2_MODE,
| ^~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:240:5: error: 'struct regulator_desc' has no member named 'ramp_mask'
240 | .ramp_mask = BD71828_MASK_RAMP_DELAY,
| ^~~~~~~~~
drivers/regulator/bd71828-regulator.c:401:5: error: 'struct regulator_desc' has no member named 'ramp_delay_table'; did you mean 'ramp_delay'?
401 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:401:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast [-Wint-conversion]
401 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:401:24: note: (near initialization for 'bd71828_rdata[5].desc.vsel_step')
drivers/regulator/bd71828-regulator.c:402:5: error: 'struct regulator_desc' has no member named 'n_ramp_values'
402 | .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
| ^~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:403:5: error: 'struct regulator_desc' has no member named 'ramp_reg'; did you mean 'ramp_delay'?
403 | .ramp_reg = BD71828_REG_BUCK6_MODE,
| ^~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:404:5: error: 'struct regulator_desc' has no member named 'ramp_mask'
404 | .ramp_mask = BD71828_MASK_RAMP_DELAY,
| ^~~~~~~~~
drivers/regulator/bd71828-regulator.c:442:5: error: 'struct regulator_desc' has no member named 'ramp_delay_table'; did you mean 'ramp_delay'?
442 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:442:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast [-Wint-conversion]
442 | .ramp_delay_table = bd71828_ramp_delay,
| ^~~~~~~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:442:24: note: (near initialization for 'bd71828_rdata[6].desc.vsel_step')
drivers/regulator/bd71828-regulator.c:443:5: error: 'struct regulator_desc' has no member named 'n_ramp_values'
443 | .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
| ^~~~~~~~~~~~~
drivers/regulator/bd71828-regulator.c:444:5: error: 'struct regulator_desc' has no member named 'ramp_reg'; did you mean 'ramp_delay'?
444 | .ramp_reg = BD71828_REG_BUCK7_MODE,
| ^~~~~~~~
| ramp_delay
drivers/regulator/bd71828-regulator.c:445:5: error: 'struct regulator_desc' has no member named 'ramp_mask'
445 | .ramp_mask = BD71828_MASK_RAMP_DELAY,
| ^~~~~~~~~
vim +191 drivers/regulator/bd71828-regulator.c
174
175 static const struct bd71828_regulator_data bd71828_rdata[] = {
176 {
177 .desc = {
178 .name = "buck1",
179 .of_match = of_match_ptr("BUCK1"),
180 .regulators_node = of_match_ptr("regulators"),
181 .id = BD71828_BUCK1,
182 .ops = &bd71828_dvs_buck_ops,
183 .type = REGULATOR_VOLTAGE,
184 .linear_ranges = bd71828_buck1267_volts,
185 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
186 .n_voltages = BD71828_BUCK1267_VOLTS,
187 .enable_reg = BD71828_REG_BUCK1_EN,
188 .enable_mask = BD71828_MASK_RUN_EN,
189 .vsel_reg = BD71828_REG_BUCK1_VOLT,
190 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
> 191 .ramp_delay_table = bd71828_ramp_delay,
192 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
193 .ramp_reg = BD71828_REG_BUCK1_MODE,
194 .ramp_mask = BD71828_MASK_RAMP_DELAY,
195 .owner = THIS_MODULE,
196 .of_parse_cb = buck_set_hw_dvs_levels,
197 },
198 .dvs = {
199 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
200 ROHM_DVS_LEVEL_SUSPEND |
201 ROHM_DVS_LEVEL_LPSR,
202 .run_reg = BD71828_REG_BUCK1_VOLT,
203 .run_mask = BD71828_MASK_BUCK1267_VOLT,
204 .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT,
205 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
206 .idle_on_mask = BD71828_MASK_IDLE_EN,
207 .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT,
208 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
209 .suspend_on_mask = BD71828_MASK_SUSP_EN,
210 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
211 /*
212 * LPSR voltage is same as SUSPEND voltage. Allow
213 * setting it so that regulator can be set enabled at
214 * LPSR state
215 */
216 .lpsr_reg = BD71828_REG_BUCK1_SUSP_VOLT,
217 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
218 },
219 .reg_inits = buck1_inits,
220 .reg_init_amnt = ARRAY_SIZE(buck1_inits),
221 },
222 {
223 .desc = {
224 .name = "buck2",
225 .of_match = of_match_ptr("BUCK2"),
226 .regulators_node = of_match_ptr("regulators"),
227 .id = BD71828_BUCK2,
228 .ops = &bd71828_dvs_buck_ops,
229 .type = REGULATOR_VOLTAGE,
230 .linear_ranges = bd71828_buck1267_volts,
231 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
232 .n_voltages = BD71828_BUCK1267_VOLTS,
233 .enable_reg = BD71828_REG_BUCK2_EN,
234 .enable_mask = BD71828_MASK_RUN_EN,
235 .vsel_reg = BD71828_REG_BUCK2_VOLT,
236 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
237 .ramp_delay_table = bd71828_ramp_delay,
238 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
239 .ramp_reg = BD71828_REG_BUCK2_MODE,
240 .ramp_mask = BD71828_MASK_RAMP_DELAY,
241 .owner = THIS_MODULE,
242 .of_parse_cb = buck_set_hw_dvs_levels,
243 },
244 .dvs = {
245 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
246 ROHM_DVS_LEVEL_SUSPEND |
247 ROHM_DVS_LEVEL_LPSR,
248 .run_reg = BD71828_REG_BUCK2_VOLT,
249 .run_mask = BD71828_MASK_BUCK1267_VOLT,
250 .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
251 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
252 .idle_on_mask = BD71828_MASK_IDLE_EN,
253 .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
254 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
255 .suspend_on_mask = BD71828_MASK_SUSP_EN,
256 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
257 .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
258 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
259 },
260 .reg_inits = buck2_inits,
261 .reg_init_amnt = ARRAY_SIZE(buck2_inits),
262 },
263 {
264 .desc = {
265 .name = "buck3",
266 .of_match = of_match_ptr("BUCK3"),
267 .regulators_node = of_match_ptr("regulators"),
268 .id = BD71828_BUCK3,
269 .ops = &bd71828_buck_ops,
270 .type = REGULATOR_VOLTAGE,
271 .linear_ranges = bd71828_buck3_volts,
272 .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
273 .n_voltages = BD71828_BUCK3_VOLTS,
274 .enable_reg = BD71828_REG_BUCK3_EN,
275 .enable_mask = BD71828_MASK_RUN_EN,
276 .vsel_reg = BD71828_REG_BUCK3_VOLT,
277 .vsel_mask = BD71828_MASK_BUCK3_VOLT,
278 .owner = THIS_MODULE,
279 .of_parse_cb = buck_set_hw_dvs_levels,
280 },
281 .dvs = {
282 /*
283 * BUCK3 only supports single voltage for all states.
284 * voltage can be individually enabled for each state
285 * though => allow setting all states to support
286 * enabling power rail on different states.
287 */
288 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
289 ROHM_DVS_LEVEL_SUSPEND |
290 ROHM_DVS_LEVEL_LPSR,
291 .run_reg = BD71828_REG_BUCK3_VOLT,
292 .idle_reg = BD71828_REG_BUCK3_VOLT,
293 .suspend_reg = BD71828_REG_BUCK3_VOLT,
294 .lpsr_reg = BD71828_REG_BUCK3_VOLT,
295 .run_mask = BD71828_MASK_BUCK3_VOLT,
296 .idle_mask = BD71828_MASK_BUCK3_VOLT,
297 .suspend_mask = BD71828_MASK_BUCK3_VOLT,
298 .lpsr_mask = BD71828_MASK_BUCK3_VOLT,
299 .idle_on_mask = BD71828_MASK_IDLE_EN,
300 .suspend_on_mask = BD71828_MASK_SUSP_EN,
301 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
302 },
303 },
304 {
305 .desc = {
306 .name = "buck4",
307 .of_match = of_match_ptr("BUCK4"),
308 .regulators_node = of_match_ptr("regulators"),
309 .id = BD71828_BUCK4,
310 .ops = &bd71828_buck_ops,
311 .type = REGULATOR_VOLTAGE,
312 .linear_ranges = bd71828_buck4_volts,
313 .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
314 .n_voltages = BD71828_BUCK4_VOLTS,
315 .enable_reg = BD71828_REG_BUCK4_EN,
316 .enable_mask = BD71828_MASK_RUN_EN,
317 .vsel_reg = BD71828_REG_BUCK4_VOLT,
318 .vsel_mask = BD71828_MASK_BUCK4_VOLT,
319 .owner = THIS_MODULE,
320 .of_parse_cb = buck_set_hw_dvs_levels,
321 },
322 .dvs = {
323 /*
324 * BUCK4 only supports single voltage for all states.
325 * voltage can be individually enabled for each state
326 * though => allow setting all states to support
327 * enabling power rail on different states.
328 */
329 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
330 ROHM_DVS_LEVEL_SUSPEND |
331 ROHM_DVS_LEVEL_LPSR,
332 .run_reg = BD71828_REG_BUCK4_VOLT,
333 .idle_reg = BD71828_REG_BUCK4_VOLT,
334 .suspend_reg = BD71828_REG_BUCK4_VOLT,
335 .lpsr_reg = BD71828_REG_BUCK4_VOLT,
336 .run_mask = BD71828_MASK_BUCK4_VOLT,
337 .idle_mask = BD71828_MASK_BUCK4_VOLT,
338 .suspend_mask = BD71828_MASK_BUCK4_VOLT,
339 .lpsr_mask = BD71828_MASK_BUCK4_VOLT,
340 .idle_on_mask = BD71828_MASK_IDLE_EN,
341 .suspend_on_mask = BD71828_MASK_SUSP_EN,
342 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
343 },
344 },
345 {
346 .desc = {
347 .name = "buck5",
348 .of_match = of_match_ptr("BUCK5"),
349 .regulators_node = of_match_ptr("regulators"),
350 .id = BD71828_BUCK5,
351 .ops = &bd71828_buck_ops,
352 .type = REGULATOR_VOLTAGE,
353 .linear_ranges = bd71828_buck5_volts,
354 .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
355 .n_voltages = BD71828_BUCK5_VOLTS,
356 .enable_reg = BD71828_REG_BUCK5_EN,
357 .enable_mask = BD71828_MASK_RUN_EN,
358 .vsel_reg = BD71828_REG_BUCK5_VOLT,
359 .vsel_mask = BD71828_MASK_BUCK5_VOLT,
360 .owner = THIS_MODULE,
361 .of_parse_cb = buck_set_hw_dvs_levels,
362 },
363 .dvs = {
364 /*
365 * BUCK5 only supports single voltage for all states.
366 * voltage can be individually enabled for each state
367 * though => allow setting all states to support
368 * enabling power rail on different states.
369 */
370 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
371 ROHM_DVS_LEVEL_SUSPEND |
372 ROHM_DVS_LEVEL_LPSR,
373 .run_reg = BD71828_REG_BUCK5_VOLT,
374 .idle_reg = BD71828_REG_BUCK5_VOLT,
375 .suspend_reg = BD71828_REG_BUCK5_VOLT,
376 .lpsr_reg = BD71828_REG_BUCK5_VOLT,
377 .run_mask = BD71828_MASK_BUCK5_VOLT,
378 .idle_mask = BD71828_MASK_BUCK5_VOLT,
379 .suspend_mask = BD71828_MASK_BUCK5_VOLT,
380 .lpsr_mask = BD71828_MASK_BUCK5_VOLT,
381 .idle_on_mask = BD71828_MASK_IDLE_EN,
382 .suspend_on_mask = BD71828_MASK_SUSP_EN,
383 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
384 },
385 },
386 {
387 .desc = {
388 .name = "buck6",
389 .of_match = of_match_ptr("BUCK6"),
390 .regulators_node = of_match_ptr("regulators"),
391 .id = BD71828_BUCK6,
392 .ops = &bd71828_dvs_buck_ops,
393 .type = REGULATOR_VOLTAGE,
394 .linear_ranges = bd71828_buck1267_volts,
395 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
396 .n_voltages = BD71828_BUCK1267_VOLTS,
397 .enable_reg = BD71828_REG_BUCK6_EN,
398 .enable_mask = BD71828_MASK_RUN_EN,
399 .vsel_reg = BD71828_REG_BUCK6_VOLT,
400 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
401 .ramp_delay_table = bd71828_ramp_delay,
402 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
403 .ramp_reg = BD71828_REG_BUCK6_MODE,
404 .ramp_mask = BD71828_MASK_RAMP_DELAY,
405 .owner = THIS_MODULE,
406 .of_parse_cb = buck_set_hw_dvs_levels,
407 },
408 .dvs = {
409 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
410 ROHM_DVS_LEVEL_SUSPEND |
411 ROHM_DVS_LEVEL_LPSR,
412 .run_reg = BD71828_REG_BUCK6_VOLT,
413 .run_mask = BD71828_MASK_BUCK1267_VOLT,
414 .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
415 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
416 .idle_on_mask = BD71828_MASK_IDLE_EN,
417 .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
418 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
419 .suspend_on_mask = BD71828_MASK_SUSP_EN,
420 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
421 .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
422 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
423 },
424 .reg_inits = buck6_inits,
425 .reg_init_amnt = ARRAY_SIZE(buck6_inits),
426 },
427 {
428 .desc = {
429 .name = "buck7",
430 .of_match = of_match_ptr("BUCK7"),
431 .regulators_node = of_match_ptr("regulators"),
432 .id = BD71828_BUCK7,
433 .ops = &bd71828_dvs_buck_ops,
434 .type = REGULATOR_VOLTAGE,
435 .linear_ranges = bd71828_buck1267_volts,
436 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
437 .n_voltages = BD71828_BUCK1267_VOLTS,
438 .enable_reg = BD71828_REG_BUCK7_EN,
439 .enable_mask = BD71828_MASK_RUN_EN,
440 .vsel_reg = BD71828_REG_BUCK7_VOLT,
441 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
442 .ramp_delay_table = bd71828_ramp_delay,
443 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
444 .ramp_reg = BD71828_REG_BUCK7_MODE,
445 .ramp_mask = BD71828_MASK_RAMP_DELAY,
446 .owner = THIS_MODULE,
447 .of_parse_cb = buck_set_hw_dvs_levels,
448 },
449 .dvs = {
450 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
451 ROHM_DVS_LEVEL_SUSPEND |
452 ROHM_DVS_LEVEL_LPSR,
453 .run_reg = BD71828_REG_BUCK7_VOLT,
454 .run_mask = BD71828_MASK_BUCK1267_VOLT,
455 .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
456 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
457 .idle_on_mask = BD71828_MASK_IDLE_EN,
458 .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT,
459 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
460 .suspend_on_mask = BD71828_MASK_SUSP_EN,
461 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
462 .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT,
463 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
464 },
465 .reg_inits = buck7_inits,
466 .reg_init_amnt = ARRAY_SIZE(buck7_inits),
467 },
468 {
469 .desc = {
470 .name = "ldo1",
471 .of_match = of_match_ptr("LDO1"),
472 .regulators_node = of_match_ptr("regulators"),
473 .id = BD71828_LDO1,
474 .ops = &bd71828_ldo_ops,
475 .type = REGULATOR_VOLTAGE,
476 .linear_ranges = bd71828_ldo_volts,
477 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
478 .n_voltages = BD71828_LDO_VOLTS,
479 .enable_reg = BD71828_REG_LDO1_EN,
480 .enable_mask = BD71828_MASK_RUN_EN,
481 .vsel_reg = BD71828_REG_LDO1_VOLT,
482 .vsel_mask = BD71828_MASK_LDO_VOLT,
483 .owner = THIS_MODULE,
484 .of_parse_cb = buck_set_hw_dvs_levels,
485 },
486 .dvs = {
487 /*
488 * LDO1 only supports single voltage for all states.
489 * voltage can be individually enabled for each state
490 * though => allow setting all states to support
491 * enabling power rail on different states.
492 */
493 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
494 ROHM_DVS_LEVEL_SUSPEND |
495 ROHM_DVS_LEVEL_LPSR,
496 .run_reg = BD71828_REG_LDO1_VOLT,
497 .idle_reg = BD71828_REG_LDO1_VOLT,
498 .suspend_reg = BD71828_REG_LDO1_VOLT,
499 .lpsr_reg = BD71828_REG_LDO1_VOLT,
500 .run_mask = BD71828_MASK_LDO_VOLT,
501 .idle_mask = BD71828_MASK_LDO_VOLT,
502 .suspend_mask = BD71828_MASK_LDO_VOLT,
503 .lpsr_mask = BD71828_MASK_LDO_VOLT,
504 .idle_on_mask = BD71828_MASK_IDLE_EN,
505 .suspend_on_mask = BD71828_MASK_SUSP_EN,
506 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
507 },
508 }, {
509 .desc = {
510 .name = "ldo2",
511 .of_match = of_match_ptr("LDO2"),
512 .regulators_node = of_match_ptr("regulators"),
513 .id = BD71828_LDO2,
514 .ops = &bd71828_ldo_ops,
515 .type = REGULATOR_VOLTAGE,
516 .linear_ranges = bd71828_ldo_volts,
517 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
518 .n_voltages = BD71828_LDO_VOLTS,
519 .enable_reg = BD71828_REG_LDO2_EN,
520 .enable_mask = BD71828_MASK_RUN_EN,
521 .vsel_reg = BD71828_REG_LDO2_VOLT,
522 .vsel_mask = BD71828_MASK_LDO_VOLT,
523 .owner = THIS_MODULE,
524 .of_parse_cb = buck_set_hw_dvs_levels,
525 },
526 .dvs = {
527 /*
528 * LDO2 only supports single voltage for all states.
529 * voltage can be individually enabled for each state
530 * though => allow setting all states to support
531 * enabling power rail on different states.
532 */
533 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
534 ROHM_DVS_LEVEL_SUSPEND |
535 ROHM_DVS_LEVEL_LPSR,
536 .run_reg = BD71828_REG_LDO2_VOLT,
537 .idle_reg = BD71828_REG_LDO2_VOLT,
538 .suspend_reg = BD71828_REG_LDO2_VOLT,
539 .lpsr_reg = BD71828_REG_LDO2_VOLT,
540 .run_mask = BD71828_MASK_LDO_VOLT,
541 .idle_mask = BD71828_MASK_LDO_VOLT,
542 .suspend_mask = BD71828_MASK_LDO_VOLT,
543 .lpsr_mask = BD71828_MASK_LDO_VOLT,
544 .idle_on_mask = BD71828_MASK_IDLE_EN,
545 .suspend_on_mask = BD71828_MASK_SUSP_EN,
546 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
547 },
548 }, {
549 .desc = {
550 .name = "ldo3",
551 .of_match = of_match_ptr("LDO3"),
552 .regulators_node = of_match_ptr("regulators"),
553 .id = BD71828_LDO3,
554 .ops = &bd71828_ldo_ops,
555 .type = REGULATOR_VOLTAGE,
556 .linear_ranges = bd71828_ldo_volts,
557 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
558 .n_voltages = BD71828_LDO_VOLTS,
559 .enable_reg = BD71828_REG_LDO3_EN,
560 .enable_mask = BD71828_MASK_RUN_EN,
561 .vsel_reg = BD71828_REG_LDO3_VOLT,
562 .vsel_mask = BD71828_MASK_LDO_VOLT,
563 .owner = THIS_MODULE,
564 .of_parse_cb = buck_set_hw_dvs_levels,
565 },
566 .dvs = {
567 /*
568 * LDO3 only supports single voltage for all states.
569 * voltage can be individually enabled for each state
570 * though => allow setting all states to support
571 * enabling power rail on different states.
572 */
573 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
574 ROHM_DVS_LEVEL_SUSPEND |
575 ROHM_DVS_LEVEL_LPSR,
576 .run_reg = BD71828_REG_LDO3_VOLT,
577 .idle_reg = BD71828_REG_LDO3_VOLT,
578 .suspend_reg = BD71828_REG_LDO3_VOLT,
579 .lpsr_reg = BD71828_REG_LDO3_VOLT,
580 .run_mask = BD71828_MASK_LDO_VOLT,
581 .idle_mask = BD71828_MASK_LDO_VOLT,
582 .suspend_mask = BD71828_MASK_LDO_VOLT,
583 .lpsr_mask = BD71828_MASK_LDO_VOLT,
584 .idle_on_mask = BD71828_MASK_IDLE_EN,
585 .suspend_on_mask = BD71828_MASK_SUSP_EN,
586 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
587 },
588
589 }, {
590 .desc = {
591 .name = "ldo4",
592 .of_match = of_match_ptr("LDO4"),
593 .regulators_node = of_match_ptr("regulators"),
594 .id = BD71828_LDO4,
595 .ops = &bd71828_ldo_ops,
596 .type = REGULATOR_VOLTAGE,
597 .linear_ranges = bd71828_ldo_volts,
598 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
599 .n_voltages = BD71828_LDO_VOLTS,
600 .enable_reg = BD71828_REG_LDO4_EN,
601 .enable_mask = BD71828_MASK_RUN_EN,
602 .vsel_reg = BD71828_REG_LDO4_VOLT,
603 .vsel_mask = BD71828_MASK_LDO_VOLT,
604 .owner = THIS_MODULE,
605 .of_parse_cb = buck_set_hw_dvs_levels,
606 },
607 .dvs = {
608 /*
609 * LDO1 only supports single voltage for all states.
610 * voltage can be individually enabled for each state
611 * though => allow setting all states to support
612 * enabling power rail on different states.
613 */
614 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
615 ROHM_DVS_LEVEL_SUSPEND |
616 ROHM_DVS_LEVEL_LPSR,
617 .run_reg = BD71828_REG_LDO4_VOLT,
618 .idle_reg = BD71828_REG_LDO4_VOLT,
619 .suspend_reg = BD71828_REG_LDO4_VOLT,
620 .lpsr_reg = BD71828_REG_LDO4_VOLT,
621 .run_mask = BD71828_MASK_LDO_VOLT,
622 .idle_mask = BD71828_MASK_LDO_VOLT,
623 .suspend_mask = BD71828_MASK_LDO_VOLT,
624 .lpsr_mask = BD71828_MASK_LDO_VOLT,
625 .idle_on_mask = BD71828_MASK_IDLE_EN,
626 .suspend_on_mask = BD71828_MASK_SUSP_EN,
627 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
628 },
629 }, {
630 .desc = {
631 .name = "ldo5",
632 .of_match = of_match_ptr("LDO5"),
633 .regulators_node = of_match_ptr("regulators"),
634 .id = BD71828_LDO5,
635 .ops = &bd71828_ldo_ops,
636 .type = REGULATOR_VOLTAGE,
637 .linear_ranges = bd71828_ldo_volts,
638 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
639 .n_voltages = BD71828_LDO_VOLTS,
640 .enable_reg = BD71828_REG_LDO5_EN,
641 .enable_mask = BD71828_MASK_RUN_EN,
642 .vsel_reg = BD71828_REG_LDO5_VOLT,
643 .vsel_mask = BD71828_MASK_LDO_VOLT,
644 .of_parse_cb = buck_set_hw_dvs_levels,
645 .owner = THIS_MODULE,
646 },
647 /*
648 * LDO5 is special. It can choose vsel settings to be configured
649 * from 2 different registers (by GPIO).
650 *
651 * This driver supports only configuration where
652 * BD71828_REG_LDO5_VOLT_L is used.
653 */
654 .dvs = {
655 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
656 ROHM_DVS_LEVEL_SUSPEND |
657 ROHM_DVS_LEVEL_LPSR,
658 .run_reg = BD71828_REG_LDO5_VOLT,
659 .idle_reg = BD71828_REG_LDO5_VOLT,
660 .suspend_reg = BD71828_REG_LDO5_VOLT,
661 .lpsr_reg = BD71828_REG_LDO5_VOLT,
662 .run_mask = BD71828_MASK_LDO_VOLT,
663 .idle_mask = BD71828_MASK_LDO_VOLT,
664 .suspend_mask = BD71828_MASK_LDO_VOLT,
665 .lpsr_mask = BD71828_MASK_LDO_VOLT,
666 .idle_on_mask = BD71828_MASK_IDLE_EN,
667 .suspend_on_mask = BD71828_MASK_SUSP_EN,
668 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
669 },
670
671 }, {
672 .desc = {
673 .name = "ldo6",
674 .of_match = of_match_ptr("LDO6"),
675 .regulators_node = of_match_ptr("regulators"),
676 .id = BD71828_LDO6,
677 .ops = &bd71828_ldo6_ops,
678 .type = REGULATOR_VOLTAGE,
679 .fixed_uV = BD71828_LDO_6_VOLTAGE,
680 .n_voltages = 1,
681 .enable_reg = BD71828_REG_LDO6_EN,
682 .enable_mask = BD71828_MASK_RUN_EN,
683 .owner = THIS_MODULE,
684 /*
685 * LDO6 only supports enable/disable for all states.
686 * Voltage for LDO6 is fixed.
687 */
688 .of_parse_cb = ldo6_parse_dt,
689 },
690 }, {
691 .desc = {
692 /* SNVS LDO in data-sheet */
693 .name = "ldo7",
694 .of_match = of_match_ptr("LDO7"),
695 .regulators_node = of_match_ptr("regulators"),
696 .id = BD71828_LDO_SNVS,
697 .ops = &bd71828_ldo_ops,
698 .type = REGULATOR_VOLTAGE,
699 .linear_ranges = bd71828_ldo_volts,
700 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
701 .n_voltages = BD71828_LDO_VOLTS,
702 .enable_reg = BD71828_REG_LDO7_EN,
703 .enable_mask = BD71828_MASK_RUN_EN,
704 .vsel_reg = BD71828_REG_LDO7_VOLT,
705 .vsel_mask = BD71828_MASK_LDO_VOLT,
706 .owner = THIS_MODULE,
707 .of_parse_cb = buck_set_hw_dvs_levels,
708 },
709 .dvs = {
710 /*
711 * LDO7 only supports single voltage for all states.
712 * voltage can be individually enabled for each state
713 * though => allow setting all states to support
714 * enabling power rail on different states.
715 */
716 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
717 ROHM_DVS_LEVEL_SUSPEND |
718 ROHM_DVS_LEVEL_LPSR,
719 .run_reg = BD71828_REG_LDO7_VOLT,
720 .idle_reg = BD71828_REG_LDO7_VOLT,
721 .suspend_reg = BD71828_REG_LDO7_VOLT,
722 .lpsr_reg = BD71828_REG_LDO7_VOLT,
723 .run_mask = BD71828_MASK_LDO_VOLT,
724 .idle_mask = BD71828_MASK_LDO_VOLT,
725 .suspend_mask = BD71828_MASK_LDO_VOLT,
726 .lpsr_mask = BD71828_MASK_LDO_VOLT,
727 .idle_on_mask = BD71828_MASK_IDLE_EN,
728 .suspend_on_mask = BD71828_MASK_SUSP_EN,
729 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
730 },
731
732 },
733 };
734
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 32622 bytes --]
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2021-04-14 12:50 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2021-04-14 12:50 [lee-mfd:ib-mfd-clk-gpio-regulator-rtc-5.13 12/16] drivers/regulator/bd71828-regulator.c:191:24: warning: initialization of 'unsigned int' from 'const unsigned int *' makes integer from pointer without a cast kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.