palmas-regulator.c 44 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Driver for Regulator part of Palmas PMIC Chips
  4. *
  5. * Copyright 2011-2013 Texas Instruments Inc.
  6. *
  7. * Author: Graeme Gregory <gg@slimlogic.co.uk>
  8. * Author: Ian Lartey <ian@slimlogic.co.uk>
  9. */
  10. #include <linux/kernel.h>
  11. #include <linux/module.h>
  12. #include <linux/init.h>
  13. #include <linux/err.h>
  14. #include <linux/platform_device.h>
  15. #include <linux/regulator/driver.h>
  16. #include <linux/regulator/machine.h>
  17. #include <linux/slab.h>
  18. #include <linux/regmap.h>
  19. #include <linux/mfd/palmas.h>
  20. #include <linux/of.h>
  21. #include <linux/of_platform.h>
  22. #include <linux/regulator/of_regulator.h>
  23. static const struct linear_range smps_low_ranges[] = {
  24. REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
  25. REGULATOR_LINEAR_RANGE(500000, 0x1, 0x6, 0),
  26. REGULATOR_LINEAR_RANGE(510000, 0x7, 0x79, 10000),
  27. REGULATOR_LINEAR_RANGE(1650000, 0x7A, 0x7f, 0),
  28. };
  29. static const struct linear_range smps_high_ranges[] = {
  30. REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
  31. REGULATOR_LINEAR_RANGE(1000000, 0x1, 0x6, 0),
  32. REGULATOR_LINEAR_RANGE(1020000, 0x7, 0x79, 20000),
  33. REGULATOR_LINEAR_RANGE(3300000, 0x7A, 0x7f, 0),
  34. };
  35. static struct palmas_regs_info palmas_generic_regs_info[] = {
  36. {
  37. .name = "SMPS12",
  38. .sname = "smps1-in",
  39. .vsel_addr = PALMAS_SMPS12_VOLTAGE,
  40. .ctrl_addr = PALMAS_SMPS12_CTRL,
  41. .tstep_addr = PALMAS_SMPS12_TSTEP,
  42. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
  43. },
  44. {
  45. .name = "SMPS123",
  46. .sname = "smps1-in",
  47. .vsel_addr = PALMAS_SMPS12_VOLTAGE,
  48. .ctrl_addr = PALMAS_SMPS12_CTRL,
  49. .tstep_addr = PALMAS_SMPS12_TSTEP,
  50. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
  51. },
  52. {
  53. .name = "SMPS3",
  54. .sname = "smps3-in",
  55. .vsel_addr = PALMAS_SMPS3_VOLTAGE,
  56. .ctrl_addr = PALMAS_SMPS3_CTRL,
  57. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS3,
  58. },
  59. {
  60. .name = "SMPS45",
  61. .sname = "smps4-in",
  62. .vsel_addr = PALMAS_SMPS45_VOLTAGE,
  63. .ctrl_addr = PALMAS_SMPS45_CTRL,
  64. .tstep_addr = PALMAS_SMPS45_TSTEP,
  65. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
  66. },
  67. {
  68. .name = "SMPS457",
  69. .sname = "smps4-in",
  70. .vsel_addr = PALMAS_SMPS45_VOLTAGE,
  71. .ctrl_addr = PALMAS_SMPS45_CTRL,
  72. .tstep_addr = PALMAS_SMPS45_TSTEP,
  73. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
  74. },
  75. {
  76. .name = "SMPS6",
  77. .sname = "smps6-in",
  78. .vsel_addr = PALMAS_SMPS6_VOLTAGE,
  79. .ctrl_addr = PALMAS_SMPS6_CTRL,
  80. .tstep_addr = PALMAS_SMPS6_TSTEP,
  81. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS6,
  82. },
  83. {
  84. .name = "SMPS7",
  85. .sname = "smps7-in",
  86. .vsel_addr = PALMAS_SMPS7_VOLTAGE,
  87. .ctrl_addr = PALMAS_SMPS7_CTRL,
  88. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS7,
  89. },
  90. {
  91. .name = "SMPS8",
  92. .sname = "smps8-in",
  93. .vsel_addr = PALMAS_SMPS8_VOLTAGE,
  94. .ctrl_addr = PALMAS_SMPS8_CTRL,
  95. .tstep_addr = PALMAS_SMPS8_TSTEP,
  96. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS8,
  97. },
  98. {
  99. .name = "SMPS9",
  100. .sname = "smps9-in",
  101. .vsel_addr = PALMAS_SMPS9_VOLTAGE,
  102. .ctrl_addr = PALMAS_SMPS9_CTRL,
  103. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS9,
  104. },
  105. {
  106. .name = "SMPS10_OUT2",
  107. .sname = "smps10-in",
  108. .ctrl_addr = PALMAS_SMPS10_CTRL,
  109. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
  110. },
  111. {
  112. .name = "SMPS10_OUT1",
  113. .sname = "smps10-out2",
  114. .ctrl_addr = PALMAS_SMPS10_CTRL,
  115. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
  116. },
  117. {
  118. .name = "LDO1",
  119. .sname = "ldo1-in",
  120. .vsel_addr = PALMAS_LDO1_VOLTAGE,
  121. .ctrl_addr = PALMAS_LDO1_CTRL,
  122. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO1,
  123. },
  124. {
  125. .name = "LDO2",
  126. .sname = "ldo2-in",
  127. .vsel_addr = PALMAS_LDO2_VOLTAGE,
  128. .ctrl_addr = PALMAS_LDO2_CTRL,
  129. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO2,
  130. },
  131. {
  132. .name = "LDO3",
  133. .sname = "ldo3-in",
  134. .vsel_addr = PALMAS_LDO3_VOLTAGE,
  135. .ctrl_addr = PALMAS_LDO3_CTRL,
  136. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO3,
  137. },
  138. {
  139. .name = "LDO4",
  140. .sname = "ldo4-in",
  141. .vsel_addr = PALMAS_LDO4_VOLTAGE,
  142. .ctrl_addr = PALMAS_LDO4_CTRL,
  143. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO4,
  144. },
  145. {
  146. .name = "LDO5",
  147. .sname = "ldo5-in",
  148. .vsel_addr = PALMAS_LDO5_VOLTAGE,
  149. .ctrl_addr = PALMAS_LDO5_CTRL,
  150. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO5,
  151. },
  152. {
  153. .name = "LDO6",
  154. .sname = "ldo6-in",
  155. .vsel_addr = PALMAS_LDO6_VOLTAGE,
  156. .ctrl_addr = PALMAS_LDO6_CTRL,
  157. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO6,
  158. },
  159. {
  160. .name = "LDO7",
  161. .sname = "ldo7-in",
  162. .vsel_addr = PALMAS_LDO7_VOLTAGE,
  163. .ctrl_addr = PALMAS_LDO7_CTRL,
  164. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO7,
  165. },
  166. {
  167. .name = "LDO8",
  168. .sname = "ldo8-in",
  169. .vsel_addr = PALMAS_LDO8_VOLTAGE,
  170. .ctrl_addr = PALMAS_LDO8_CTRL,
  171. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO8,
  172. },
  173. {
  174. .name = "LDO9",
  175. .sname = "ldo9-in",
  176. .vsel_addr = PALMAS_LDO9_VOLTAGE,
  177. .ctrl_addr = PALMAS_LDO9_CTRL,
  178. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDO9,
  179. },
  180. {
  181. .name = "LDOLN",
  182. .sname = "ldoln-in",
  183. .vsel_addr = PALMAS_LDOLN_VOLTAGE,
  184. .ctrl_addr = PALMAS_LDOLN_CTRL,
  185. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDOLN,
  186. },
  187. {
  188. .name = "LDOUSB",
  189. .sname = "ldousb-in",
  190. .vsel_addr = PALMAS_LDOUSB_VOLTAGE,
  191. .ctrl_addr = PALMAS_LDOUSB_CTRL,
  192. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_LDOUSB,
  193. },
  194. {
  195. .name = "REGEN1",
  196. .ctrl_addr = PALMAS_REGEN1_CTRL,
  197. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN1,
  198. },
  199. {
  200. .name = "REGEN2",
  201. .ctrl_addr = PALMAS_REGEN2_CTRL,
  202. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN2,
  203. },
  204. {
  205. .name = "REGEN3",
  206. .ctrl_addr = PALMAS_REGEN3_CTRL,
  207. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_REGEN3,
  208. },
  209. {
  210. .name = "SYSEN1",
  211. .ctrl_addr = PALMAS_SYSEN1_CTRL,
  212. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SYSEN1,
  213. },
  214. {
  215. .name = "SYSEN2",
  216. .ctrl_addr = PALMAS_SYSEN2_CTRL,
  217. .sleep_id = PALMAS_EXTERNAL_REQSTR_ID_SYSEN2,
  218. },
  219. };
  220. static struct palmas_regs_info tps65917_regs_info[] = {
  221. {
  222. .name = "SMPS1",
  223. .sname = "smps1-in",
  224. .vsel_addr = TPS65917_SMPS1_VOLTAGE,
  225. .ctrl_addr = TPS65917_SMPS1_CTRL,
  226. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS1,
  227. },
  228. {
  229. .name = "SMPS2",
  230. .sname = "smps2-in",
  231. .vsel_addr = TPS65917_SMPS2_VOLTAGE,
  232. .ctrl_addr = TPS65917_SMPS2_CTRL,
  233. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS2,
  234. },
  235. {
  236. .name = "SMPS3",
  237. .sname = "smps3-in",
  238. .vsel_addr = TPS65917_SMPS3_VOLTAGE,
  239. .ctrl_addr = TPS65917_SMPS3_CTRL,
  240. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS3,
  241. },
  242. {
  243. .name = "SMPS4",
  244. .sname = "smps4-in",
  245. .vsel_addr = TPS65917_SMPS4_VOLTAGE,
  246. .ctrl_addr = TPS65917_SMPS4_CTRL,
  247. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS4,
  248. },
  249. {
  250. .name = "SMPS5",
  251. .sname = "smps5-in",
  252. .vsel_addr = TPS65917_SMPS5_VOLTAGE,
  253. .ctrl_addr = TPS65917_SMPS5_CTRL,
  254. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS5,
  255. },
  256. {
  257. .name = "SMPS12",
  258. .sname = "smps1-in",
  259. .vsel_addr = TPS65917_SMPS1_VOLTAGE,
  260. .ctrl_addr = TPS65917_SMPS1_CTRL,
  261. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_SMPS12,
  262. },
  263. {
  264. .name = "LDO1",
  265. .sname = "ldo1-in",
  266. .vsel_addr = TPS65917_LDO1_VOLTAGE,
  267. .ctrl_addr = TPS65917_LDO1_CTRL,
  268. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_LDO1,
  269. },
  270. {
  271. .name = "LDO2",
  272. .sname = "ldo2-in",
  273. .vsel_addr = TPS65917_LDO2_VOLTAGE,
  274. .ctrl_addr = TPS65917_LDO2_CTRL,
  275. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_LDO2,
  276. },
  277. {
  278. .name = "LDO3",
  279. .sname = "ldo3-in",
  280. .vsel_addr = TPS65917_LDO3_VOLTAGE,
  281. .ctrl_addr = TPS65917_LDO3_CTRL,
  282. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_LDO3,
  283. },
  284. {
  285. .name = "LDO4",
  286. .sname = "ldo4-in",
  287. .vsel_addr = TPS65917_LDO4_VOLTAGE,
  288. .ctrl_addr = TPS65917_LDO4_CTRL,
  289. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_LDO4,
  290. },
  291. {
  292. .name = "LDO5",
  293. .sname = "ldo5-in",
  294. .vsel_addr = TPS65917_LDO5_VOLTAGE,
  295. .ctrl_addr = TPS65917_LDO5_CTRL,
  296. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_LDO5,
  297. },
  298. {
  299. .name = "REGEN1",
  300. .ctrl_addr = TPS65917_REGEN1_CTRL,
  301. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_REGEN1,
  302. },
  303. {
  304. .name = "REGEN2",
  305. .ctrl_addr = TPS65917_REGEN2_CTRL,
  306. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_REGEN2,
  307. },
  308. {
  309. .name = "REGEN3",
  310. .ctrl_addr = TPS65917_REGEN3_CTRL,
  311. .sleep_id = TPS65917_EXTERNAL_REQSTR_ID_REGEN3,
  312. },
  313. };
  314. #define EXTERNAL_REQUESTOR(_id, _offset, _pos) \
  315. [PALMAS_EXTERNAL_REQSTR_ID_##_id] = { \
  316. .id = PALMAS_EXTERNAL_REQSTR_ID_##_id, \
  317. .reg_offset = _offset, \
  318. .bit_pos = _pos, \
  319. }
  320. static struct palmas_sleep_requestor_info palma_sleep_req_info[] = {
  321. EXTERNAL_REQUESTOR(REGEN1, 0, 0),
  322. EXTERNAL_REQUESTOR(REGEN2, 0, 1),
  323. EXTERNAL_REQUESTOR(SYSEN1, 0, 2),
  324. EXTERNAL_REQUESTOR(SYSEN2, 0, 3),
  325. EXTERNAL_REQUESTOR(CLK32KG, 0, 4),
  326. EXTERNAL_REQUESTOR(CLK32KGAUDIO, 0, 5),
  327. EXTERNAL_REQUESTOR(REGEN3, 0, 6),
  328. EXTERNAL_REQUESTOR(SMPS12, 1, 0),
  329. EXTERNAL_REQUESTOR(SMPS3, 1, 1),
  330. EXTERNAL_REQUESTOR(SMPS45, 1, 2),
  331. EXTERNAL_REQUESTOR(SMPS6, 1, 3),
  332. EXTERNAL_REQUESTOR(SMPS7, 1, 4),
  333. EXTERNAL_REQUESTOR(SMPS8, 1, 5),
  334. EXTERNAL_REQUESTOR(SMPS9, 1, 6),
  335. EXTERNAL_REQUESTOR(SMPS10, 1, 7),
  336. EXTERNAL_REQUESTOR(LDO1, 2, 0),
  337. EXTERNAL_REQUESTOR(LDO2, 2, 1),
  338. EXTERNAL_REQUESTOR(LDO3, 2, 2),
  339. EXTERNAL_REQUESTOR(LDO4, 2, 3),
  340. EXTERNAL_REQUESTOR(LDO5, 2, 4),
  341. EXTERNAL_REQUESTOR(LDO6, 2, 5),
  342. EXTERNAL_REQUESTOR(LDO7, 2, 6),
  343. EXTERNAL_REQUESTOR(LDO8, 2, 7),
  344. EXTERNAL_REQUESTOR(LDO9, 3, 0),
  345. EXTERNAL_REQUESTOR(LDOLN, 3, 1),
  346. EXTERNAL_REQUESTOR(LDOUSB, 3, 2),
  347. };
  348. #define EXTERNAL_REQUESTOR_TPS65917(_id, _offset, _pos) \
  349. [TPS65917_EXTERNAL_REQSTR_ID_##_id] = { \
  350. .id = TPS65917_EXTERNAL_REQSTR_ID_##_id, \
  351. .reg_offset = _offset, \
  352. .bit_pos = _pos, \
  353. }
  354. static struct palmas_sleep_requestor_info tps65917_sleep_req_info[] = {
  355. EXTERNAL_REQUESTOR_TPS65917(REGEN1, 0, 0),
  356. EXTERNAL_REQUESTOR_TPS65917(REGEN2, 0, 1),
  357. EXTERNAL_REQUESTOR_TPS65917(REGEN3, 0, 6),
  358. EXTERNAL_REQUESTOR_TPS65917(SMPS1, 1, 0),
  359. EXTERNAL_REQUESTOR_TPS65917(SMPS2, 1, 1),
  360. EXTERNAL_REQUESTOR_TPS65917(SMPS3, 1, 2),
  361. EXTERNAL_REQUESTOR_TPS65917(SMPS4, 1, 3),
  362. EXTERNAL_REQUESTOR_TPS65917(SMPS5, 1, 4),
  363. EXTERNAL_REQUESTOR_TPS65917(SMPS12, 1, 5),
  364. EXTERNAL_REQUESTOR_TPS65917(LDO1, 2, 0),
  365. EXTERNAL_REQUESTOR_TPS65917(LDO2, 2, 1),
  366. EXTERNAL_REQUESTOR_TPS65917(LDO3, 2, 2),
  367. EXTERNAL_REQUESTOR_TPS65917(LDO4, 2, 3),
  368. EXTERNAL_REQUESTOR_TPS65917(LDO5, 2, 4),
  369. };
  370. static const unsigned int palmas_smps_ramp_delay[4] = {0, 10000, 5000, 2500};
  371. #define SMPS_CTRL_MODE_OFF 0x00
  372. #define SMPS_CTRL_MODE_ON 0x01
  373. #define SMPS_CTRL_MODE_ECO 0x02
  374. #define SMPS_CTRL_MODE_PWM 0x03
  375. #define PALMAS_SMPS_NUM_VOLTAGES 122
  376. #define PALMAS_SMPS10_NUM_VOLTAGES 2
  377. #define PALMAS_LDO_NUM_VOLTAGES 50
  378. #define SMPS10_VSEL (1<<3)
  379. #define SMPS10_BOOST_EN (1<<2)
  380. #define SMPS10_BYPASS_EN (1<<1)
  381. #define SMPS10_SWITCH_EN (1<<0)
  382. #define REGULATOR_SLAVE 0
  383. static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
  384. unsigned int *dest)
  385. {
  386. unsigned int addr;
  387. addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
  388. return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
  389. }
  390. static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
  391. unsigned int value)
  392. {
  393. unsigned int addr;
  394. addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
  395. return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
  396. }
  397. static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
  398. unsigned int *dest)
  399. {
  400. unsigned int addr;
  401. addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
  402. return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
  403. }
  404. static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
  405. unsigned int value)
  406. {
  407. unsigned int addr;
  408. addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
  409. return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
  410. }
  411. static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
  412. {
  413. int id = rdev_get_id(dev);
  414. int ret;
  415. struct palmas_pmic *pmic = rdev_get_drvdata(dev);
  416. struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
  417. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  418. unsigned int reg;
  419. bool rail_enable = true;
  420. ret = palmas_smps_read(pmic->palmas, rinfo->ctrl_addr, &reg);
  421. if (ret)
  422. return ret;
  423. reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  424. if (reg == SMPS_CTRL_MODE_OFF)
  425. rail_enable = false;
  426. switch (mode) {
  427. case REGULATOR_MODE_NORMAL:
  428. reg |= SMPS_CTRL_MODE_ON;
  429. break;
  430. case REGULATOR_MODE_IDLE:
  431. reg |= SMPS_CTRL_MODE_ECO;
  432. break;
  433. case REGULATOR_MODE_FAST:
  434. reg |= SMPS_CTRL_MODE_PWM;
  435. break;
  436. default:
  437. return -EINVAL;
  438. }
  439. pmic->current_reg_mode[id] = reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  440. if (rail_enable)
  441. palmas_smps_write(pmic->palmas, rinfo->ctrl_addr, reg);
  442. /* Switch the enable value to ensure this is used for enable */
  443. pmic->desc[id].enable_val = pmic->current_reg_mode[id];
  444. return 0;
  445. }
  446. static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
  447. {
  448. struct palmas_pmic *pmic = rdev_get_drvdata(dev);
  449. int id = rdev_get_id(dev);
  450. unsigned int reg;
  451. reg = pmic->current_reg_mode[id] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  452. switch (reg) {
  453. case SMPS_CTRL_MODE_ON:
  454. return REGULATOR_MODE_NORMAL;
  455. case SMPS_CTRL_MODE_ECO:
  456. return REGULATOR_MODE_IDLE;
  457. case SMPS_CTRL_MODE_PWM:
  458. return REGULATOR_MODE_FAST;
  459. }
  460. return 0;
  461. }
  462. static int palmas_smps_set_ramp_delay(struct regulator_dev *rdev,
  463. int ramp_delay)
  464. {
  465. int id = rdev_get_id(rdev);
  466. struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
  467. struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
  468. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  469. unsigned int reg = 0;
  470. int ret;
  471. /* SMPS3 and SMPS7 do not have tstep_addr setting */
  472. switch (id) {
  473. case PALMAS_REG_SMPS3:
  474. case PALMAS_REG_SMPS7:
  475. return 0;
  476. }
  477. if (ramp_delay <= 0)
  478. reg = 0;
  479. else if (ramp_delay <= 2500)
  480. reg = 3;
  481. else if (ramp_delay <= 5000)
  482. reg = 2;
  483. else
  484. reg = 1;
  485. ret = palmas_smps_write(pmic->palmas, rinfo->tstep_addr, reg);
  486. if (ret < 0) {
  487. dev_err(pmic->palmas->dev, "TSTEP write failed: %d\n", ret);
  488. return ret;
  489. }
  490. pmic->ramp_delay[id] = palmas_smps_ramp_delay[reg];
  491. return ret;
  492. }
  493. static const struct regulator_ops palmas_ops_smps = {
  494. .is_enabled = regulator_is_enabled_regmap,
  495. .enable = regulator_enable_regmap,
  496. .disable = regulator_disable_regmap,
  497. .set_mode = palmas_set_mode_smps,
  498. .get_mode = palmas_get_mode_smps,
  499. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  500. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  501. .list_voltage = regulator_list_voltage_linear_range,
  502. .map_voltage = regulator_map_voltage_linear_range,
  503. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  504. .set_ramp_delay = palmas_smps_set_ramp_delay,
  505. };
  506. static const struct regulator_ops palmas_ops_ext_control_smps = {
  507. .set_mode = palmas_set_mode_smps,
  508. .get_mode = palmas_get_mode_smps,
  509. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  510. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  511. .list_voltage = regulator_list_voltage_linear_range,
  512. .map_voltage = regulator_map_voltage_linear_range,
  513. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  514. .set_ramp_delay = palmas_smps_set_ramp_delay,
  515. };
  516. static const struct regulator_ops palmas_ops_smps10 = {
  517. .is_enabled = regulator_is_enabled_regmap,
  518. .enable = regulator_enable_regmap,
  519. .disable = regulator_disable_regmap,
  520. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  521. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  522. .list_voltage = regulator_list_voltage_linear,
  523. .map_voltage = regulator_map_voltage_linear,
  524. .set_bypass = regulator_set_bypass_regmap,
  525. .get_bypass = regulator_get_bypass_regmap,
  526. };
  527. static const struct regulator_ops tps65917_ops_smps = {
  528. .is_enabled = regulator_is_enabled_regmap,
  529. .enable = regulator_enable_regmap,
  530. .disable = regulator_disable_regmap,
  531. .set_mode = palmas_set_mode_smps,
  532. .get_mode = palmas_get_mode_smps,
  533. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  534. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  535. .list_voltage = regulator_list_voltage_linear_range,
  536. .map_voltage = regulator_map_voltage_linear_range,
  537. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  538. };
  539. static const struct regulator_ops tps65917_ops_ext_control_smps = {
  540. .set_mode = palmas_set_mode_smps,
  541. .get_mode = palmas_get_mode_smps,
  542. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  543. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  544. .list_voltage = regulator_list_voltage_linear_range,
  545. .map_voltage = regulator_map_voltage_linear_range,
  546. };
  547. static int palmas_is_enabled_ldo(struct regulator_dev *dev)
  548. {
  549. int id = rdev_get_id(dev);
  550. struct palmas_pmic *pmic = rdev_get_drvdata(dev);
  551. struct palmas_pmic_driver_data *ddata = pmic->palmas->pmic_ddata;
  552. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  553. unsigned int reg;
  554. palmas_ldo_read(pmic->palmas, rinfo->ctrl_addr, &reg);
  555. reg &= PALMAS_LDO1_CTRL_STATUS;
  556. return !!(reg);
  557. }
  558. static const struct regulator_ops palmas_ops_ldo = {
  559. .is_enabled = palmas_is_enabled_ldo,
  560. .enable = regulator_enable_regmap,
  561. .disable = regulator_disable_regmap,
  562. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  563. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  564. .list_voltage = regulator_list_voltage_linear,
  565. .map_voltage = regulator_map_voltage_linear,
  566. };
  567. static const struct regulator_ops palmas_ops_ldo9 = {
  568. .is_enabled = palmas_is_enabled_ldo,
  569. .enable = regulator_enable_regmap,
  570. .disable = regulator_disable_regmap,
  571. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  572. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  573. .list_voltage = regulator_list_voltage_linear,
  574. .map_voltage = regulator_map_voltage_linear,
  575. .set_bypass = regulator_set_bypass_regmap,
  576. .get_bypass = regulator_get_bypass_regmap,
  577. };
  578. static const struct regulator_ops palmas_ops_ext_control_ldo = {
  579. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  580. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  581. .list_voltage = regulator_list_voltage_linear,
  582. .map_voltage = regulator_map_voltage_linear,
  583. };
  584. static const struct regulator_ops palmas_ops_extreg = {
  585. .is_enabled = regulator_is_enabled_regmap,
  586. .enable = regulator_enable_regmap,
  587. .disable = regulator_disable_regmap,
  588. };
  589. static const struct regulator_ops palmas_ops_ext_control_extreg = {
  590. };
  591. static const struct regulator_ops tps65917_ops_ldo = {
  592. .is_enabled = palmas_is_enabled_ldo,
  593. .enable = regulator_enable_regmap,
  594. .disable = regulator_disable_regmap,
  595. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  596. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  597. .list_voltage = regulator_list_voltage_linear,
  598. .map_voltage = regulator_map_voltage_linear,
  599. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  600. };
  601. static const struct regulator_ops tps65917_ops_ldo_1_2 = {
  602. .is_enabled = palmas_is_enabled_ldo,
  603. .enable = regulator_enable_regmap,
  604. .disable = regulator_disable_regmap,
  605. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  606. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  607. .list_voltage = regulator_list_voltage_linear,
  608. .map_voltage = regulator_map_voltage_linear,
  609. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  610. .set_bypass = regulator_set_bypass_regmap,
  611. .get_bypass = regulator_get_bypass_regmap,
  612. };
  613. static int palmas_regulator_config_external(struct palmas *palmas, int id,
  614. struct palmas_reg_init *reg_init)
  615. {
  616. struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
  617. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  618. int ret;
  619. ret = palmas_ext_control_req_config(palmas, rinfo->sleep_id,
  620. reg_init->roof_floor, true);
  621. if (ret < 0)
  622. dev_err(palmas->dev,
  623. "Ext control config for regulator %d failed %d\n",
  624. id, ret);
  625. return ret;
  626. }
  627. /*
  628. * setup the hardware based sleep configuration of the SMPS/LDO regulators
  629. * from the platform data. This is different to the software based control
  630. * supported by the regulator framework as it is controlled by toggling
  631. * pins on the PMIC such as PREQ, SYSEN, ...
  632. */
  633. static int palmas_smps_init(struct palmas *palmas, int id,
  634. struct palmas_reg_init *reg_init)
  635. {
  636. unsigned int reg;
  637. int ret;
  638. struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
  639. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  640. unsigned int addr = rinfo->ctrl_addr;
  641. ret = palmas_smps_read(palmas, addr, &reg);
  642. if (ret)
  643. return ret;
  644. switch (id) {
  645. case PALMAS_REG_SMPS10_OUT1:
  646. case PALMAS_REG_SMPS10_OUT2:
  647. reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
  648. if (reg_init->mode_sleep)
  649. reg |= reg_init->mode_sleep <<
  650. PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
  651. break;
  652. default:
  653. if (reg_init->warm_reset)
  654. reg |= PALMAS_SMPS12_CTRL_WR_S;
  655. else
  656. reg &= ~PALMAS_SMPS12_CTRL_WR_S;
  657. if (reg_init->roof_floor)
  658. reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
  659. else
  660. reg &= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
  661. reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
  662. if (reg_init->mode_sleep)
  663. reg |= reg_init->mode_sleep <<
  664. PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
  665. }
  666. ret = palmas_smps_write(palmas, addr, reg);
  667. if (ret)
  668. return ret;
  669. if (rinfo->vsel_addr && reg_init->vsel) {
  670. reg = reg_init->vsel;
  671. ret = palmas_smps_write(palmas, rinfo->vsel_addr, reg);
  672. if (ret)
  673. return ret;
  674. }
  675. if (reg_init->roof_floor && (id != PALMAS_REG_SMPS10_OUT1) &&
  676. (id != PALMAS_REG_SMPS10_OUT2)) {
  677. /* Enable externally controlled regulator */
  678. ret = palmas_smps_read(palmas, addr, &reg);
  679. if (ret < 0)
  680. return ret;
  681. if (!(reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK)) {
  682. reg |= SMPS_CTRL_MODE_ON;
  683. ret = palmas_smps_write(palmas, addr, reg);
  684. if (ret < 0)
  685. return ret;
  686. }
  687. return palmas_regulator_config_external(palmas, id, reg_init);
  688. }
  689. return 0;
  690. }
  691. static int palmas_ldo_init(struct palmas *palmas, int id,
  692. struct palmas_reg_init *reg_init)
  693. {
  694. unsigned int reg;
  695. unsigned int addr;
  696. int ret;
  697. struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
  698. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  699. addr = rinfo->ctrl_addr;
  700. ret = palmas_ldo_read(palmas, addr, &reg);
  701. if (ret)
  702. return ret;
  703. if (reg_init->warm_reset)
  704. reg |= PALMAS_LDO1_CTRL_WR_S;
  705. else
  706. reg &= ~PALMAS_LDO1_CTRL_WR_S;
  707. if (reg_init->mode_sleep)
  708. reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
  709. else
  710. reg &= ~PALMAS_LDO1_CTRL_MODE_SLEEP;
  711. ret = palmas_ldo_write(palmas, addr, reg);
  712. if (ret)
  713. return ret;
  714. if (reg_init->roof_floor) {
  715. /* Enable externally controlled regulator */
  716. ret = palmas_update_bits(palmas, PALMAS_LDO_BASE,
  717. addr, PALMAS_LDO1_CTRL_MODE_ACTIVE,
  718. PALMAS_LDO1_CTRL_MODE_ACTIVE);
  719. if (ret < 0) {
  720. dev_err(palmas->dev,
  721. "LDO Register 0x%02x update failed %d\n",
  722. addr, ret);
  723. return ret;
  724. }
  725. return palmas_regulator_config_external(palmas, id, reg_init);
  726. }
  727. return 0;
  728. }
  729. static int palmas_extreg_init(struct palmas *palmas, int id,
  730. struct palmas_reg_init *reg_init)
  731. {
  732. unsigned int addr;
  733. int ret;
  734. unsigned int val = 0;
  735. struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
  736. struct palmas_regs_info *rinfo = &ddata->palmas_regs_info[id];
  737. addr = rinfo->ctrl_addr;
  738. if (reg_init->mode_sleep)
  739. val = PALMAS_REGEN1_CTRL_MODE_SLEEP;
  740. ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
  741. addr, PALMAS_REGEN1_CTRL_MODE_SLEEP, val);
  742. if (ret < 0) {
  743. dev_err(palmas->dev, "Resource reg 0x%02x update failed %d\n",
  744. addr, ret);
  745. return ret;
  746. }
  747. if (reg_init->roof_floor) {
  748. /* Enable externally controlled regulator */
  749. ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
  750. addr, PALMAS_REGEN1_CTRL_MODE_ACTIVE,
  751. PALMAS_REGEN1_CTRL_MODE_ACTIVE);
  752. if (ret < 0) {
  753. dev_err(palmas->dev,
  754. "Resource Register 0x%02x update failed %d\n",
  755. addr, ret);
  756. return ret;
  757. }
  758. return palmas_regulator_config_external(palmas, id, reg_init);
  759. }
  760. return 0;
  761. }
  762. static void palmas_enable_ldo8_track(struct palmas *palmas)
  763. {
  764. unsigned int reg;
  765. unsigned int addr;
  766. int ret;
  767. struct palmas_pmic_driver_data *ddata = palmas->pmic_ddata;
  768. struct palmas_regs_info *rinfo;
  769. rinfo = &ddata->palmas_regs_info[PALMAS_REG_LDO8];
  770. addr = rinfo->ctrl_addr;
  771. ret = palmas_ldo_read(palmas, addr, &reg);
  772. if (ret) {
  773. dev_err(palmas->dev, "Error in reading ldo8 control reg\n");
  774. return;
  775. }
  776. reg |= PALMAS_LDO8_CTRL_LDO_TRACKING_EN;
  777. ret = palmas_ldo_write(palmas, addr, reg);
  778. if (ret < 0) {
  779. dev_err(palmas->dev, "Error in enabling tracking mode\n");
  780. return;
  781. }
  782. /*
  783. * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
  784. * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
  785. * and can be set from 0.45 to 1.65 V.
  786. */
  787. addr = rinfo->vsel_addr;
  788. ret = palmas_ldo_read(palmas, addr, &reg);
  789. if (ret) {
  790. dev_err(palmas->dev, "Error in reading ldo8 voltage reg\n");
  791. return;
  792. }
  793. reg = (reg << 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK;
  794. ret = palmas_ldo_write(palmas, addr, reg);
  795. if (ret < 0)
  796. dev_err(palmas->dev, "Error in setting ldo8 voltage reg\n");
  797. return;
  798. }
  799. static int palmas_ldo_registration(struct palmas_pmic *pmic,
  800. struct palmas_pmic_driver_data *ddata,
  801. struct palmas_pmic_platform_data *pdata,
  802. const char *pdev_name,
  803. struct regulator_config config)
  804. {
  805. int id, ret;
  806. struct regulator_dev *rdev;
  807. struct palmas_reg_init *reg_init;
  808. struct palmas_regs_info *rinfo;
  809. struct regulator_desc *desc;
  810. for (id = ddata->ldo_begin; id < ddata->max_reg; id++) {
  811. if (pdata && pdata->reg_init[id])
  812. reg_init = pdata->reg_init[id];
  813. else
  814. reg_init = NULL;
  815. rinfo = &ddata->palmas_regs_info[id];
  816. /* Miss out regulators which are not available due
  817. * to alternate functions.
  818. */
  819. /* Register the regulators */
  820. desc = &pmic->desc[id];
  821. desc->name = rinfo->name;
  822. desc->id = id;
  823. desc->type = REGULATOR_VOLTAGE;
  824. desc->owner = THIS_MODULE;
  825. if (id < PALMAS_REG_REGEN1) {
  826. desc->n_voltages = PALMAS_LDO_NUM_VOLTAGES;
  827. if (reg_init && reg_init->roof_floor)
  828. desc->ops = &palmas_ops_ext_control_ldo;
  829. else
  830. desc->ops = &palmas_ops_ldo;
  831. desc->min_uV = 900000;
  832. desc->uV_step = 50000;
  833. desc->linear_min_sel = 1;
  834. desc->enable_time = 500;
  835. desc->vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
  836. rinfo->vsel_addr);
  837. desc->vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK;
  838. desc->enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
  839. rinfo->ctrl_addr);
  840. desc->enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE;
  841. /* Check if LDO8 is in tracking mode or not */
  842. if (pdata && (id == PALMAS_REG_LDO8) &&
  843. pdata->enable_ldo8_tracking) {
  844. palmas_enable_ldo8_track(pmic->palmas);
  845. desc->min_uV = 450000;
  846. desc->uV_step = 25000;
  847. }
  848. /* LOD6 in vibrator mode will have enable time 2000us */
  849. if (pdata && pdata->ldo6_vibrator &&
  850. (id == PALMAS_REG_LDO6))
  851. desc->enable_time = 2000;
  852. if (id == PALMAS_REG_LDO9) {
  853. desc->ops = &palmas_ops_ldo9;
  854. desc->bypass_reg = desc->enable_reg;
  855. desc->bypass_val_on =
  856. PALMAS_LDO9_CTRL_LDO_BYPASS_EN;
  857. desc->bypass_mask =
  858. PALMAS_LDO9_CTRL_LDO_BYPASS_EN;
  859. }
  860. } else {
  861. if (!ddata->has_regen3 && id == PALMAS_REG_REGEN3)
  862. continue;
  863. desc->n_voltages = 1;
  864. if (reg_init && reg_init->roof_floor)
  865. desc->ops = &palmas_ops_ext_control_extreg;
  866. else
  867. desc->ops = &palmas_ops_extreg;
  868. desc->enable_reg =
  869. PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE,
  870. rinfo->ctrl_addr);
  871. desc->enable_mask = PALMAS_REGEN1_CTRL_MODE_ACTIVE;
  872. }
  873. if (pdata)
  874. config.init_data = pdata->reg_data[id];
  875. else
  876. config.init_data = NULL;
  877. desc->supply_name = rinfo->sname;
  878. config.of_node = ddata->palmas_matches[id].of_node;
  879. rdev = devm_regulator_register(pmic->dev, desc, &config);
  880. if (IS_ERR(rdev)) {
  881. dev_err(pmic->dev,
  882. "failed to register %s regulator\n",
  883. pdev_name);
  884. return PTR_ERR(rdev);
  885. }
  886. /* Initialise sleep/init values from platform data */
  887. if (pdata) {
  888. reg_init = pdata->reg_init[id];
  889. if (reg_init) {
  890. if (id <= ddata->ldo_end)
  891. ret = palmas_ldo_init(pmic->palmas, id,
  892. reg_init);
  893. else
  894. ret = palmas_extreg_init(pmic->palmas,
  895. id, reg_init);
  896. if (ret)
  897. return ret;
  898. }
  899. }
  900. }
  901. return 0;
  902. }
  903. static int tps65917_ldo_registration(struct palmas_pmic *pmic,
  904. struct palmas_pmic_driver_data *ddata,
  905. struct palmas_pmic_platform_data *pdata,
  906. const char *pdev_name,
  907. struct regulator_config config)
  908. {
  909. int id, ret;
  910. struct regulator_dev *rdev;
  911. struct palmas_reg_init *reg_init;
  912. struct palmas_regs_info *rinfo;
  913. struct regulator_desc *desc;
  914. for (id = ddata->ldo_begin; id < ddata->max_reg; id++) {
  915. if (pdata && pdata->reg_init[id])
  916. reg_init = pdata->reg_init[id];
  917. else
  918. reg_init = NULL;
  919. /* Miss out regulators which are not available due
  920. * to alternate functions.
  921. */
  922. rinfo = &ddata->palmas_regs_info[id];
  923. /* Register the regulators */
  924. desc = &pmic->desc[id];
  925. desc->name = rinfo->name;
  926. desc->id = id;
  927. desc->type = REGULATOR_VOLTAGE;
  928. desc->owner = THIS_MODULE;
  929. if (id < TPS65917_REG_REGEN1) {
  930. desc->n_voltages = PALMAS_LDO_NUM_VOLTAGES;
  931. if (reg_init && reg_init->roof_floor)
  932. desc->ops = &palmas_ops_ext_control_ldo;
  933. else
  934. desc->ops = &tps65917_ops_ldo;
  935. desc->min_uV = 900000;
  936. desc->uV_step = 50000;
  937. desc->linear_min_sel = 1;
  938. desc->enable_time = 500;
  939. desc->vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
  940. rinfo->vsel_addr);
  941. desc->vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK;
  942. desc->enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
  943. rinfo->ctrl_addr);
  944. desc->enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE;
  945. /*
  946. * To be confirmed. Discussion on going with PMIC Team.
  947. * It is of the order of ~60mV/uS.
  948. */
  949. desc->ramp_delay = 2500;
  950. if (id == TPS65917_REG_LDO1 ||
  951. id == TPS65917_REG_LDO2) {
  952. desc->ops = &tps65917_ops_ldo_1_2;
  953. desc->bypass_reg = desc->enable_reg;
  954. desc->bypass_val_on =
  955. TPS65917_LDO1_CTRL_BYPASS_EN;
  956. desc->bypass_mask =
  957. TPS65917_LDO1_CTRL_BYPASS_EN;
  958. }
  959. } else {
  960. desc->n_voltages = 1;
  961. if (reg_init && reg_init->roof_floor)
  962. desc->ops = &palmas_ops_ext_control_extreg;
  963. else
  964. desc->ops = &palmas_ops_extreg;
  965. desc->enable_reg =
  966. PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE,
  967. rinfo->ctrl_addr);
  968. desc->enable_mask = PALMAS_REGEN1_CTRL_MODE_ACTIVE;
  969. }
  970. if (pdata)
  971. config.init_data = pdata->reg_data[id];
  972. else
  973. config.init_data = NULL;
  974. desc->supply_name = rinfo->sname;
  975. config.of_node = ddata->palmas_matches[id].of_node;
  976. rdev = devm_regulator_register(pmic->dev, desc, &config);
  977. if (IS_ERR(rdev)) {
  978. dev_err(pmic->dev,
  979. "failed to register %s regulator\n",
  980. pdev_name);
  981. return PTR_ERR(rdev);
  982. }
  983. /* Initialise sleep/init values from platform data */
  984. if (pdata) {
  985. reg_init = pdata->reg_init[id];
  986. if (reg_init) {
  987. if (id < TPS65917_REG_REGEN1)
  988. ret = palmas_ldo_init(pmic->palmas,
  989. id, reg_init);
  990. else
  991. ret = palmas_extreg_init(pmic->palmas,
  992. id, reg_init);
  993. if (ret)
  994. return ret;
  995. }
  996. }
  997. }
  998. return 0;
  999. }
  1000. static int palmas_smps_registration(struct palmas_pmic *pmic,
  1001. struct palmas_pmic_driver_data *ddata,
  1002. struct palmas_pmic_platform_data *pdata,
  1003. const char *pdev_name,
  1004. struct regulator_config config)
  1005. {
  1006. int id, ret;
  1007. unsigned int addr, reg;
  1008. struct regulator_dev *rdev;
  1009. struct palmas_reg_init *reg_init;
  1010. struct palmas_regs_info *rinfo;
  1011. struct regulator_desc *desc;
  1012. for (id = ddata->smps_start; id <= ddata->smps_end; id++) {
  1013. bool ramp_delay_support = false;
  1014. /*
  1015. * Miss out regulators which are not available due
  1016. * to slaving configurations.
  1017. */
  1018. switch (id) {
  1019. case PALMAS_REG_SMPS12:
  1020. case PALMAS_REG_SMPS3:
  1021. if (pmic->smps123)
  1022. continue;
  1023. if (id == PALMAS_REG_SMPS12)
  1024. ramp_delay_support = true;
  1025. break;
  1026. case PALMAS_REG_SMPS123:
  1027. if (!pmic->smps123)
  1028. continue;
  1029. ramp_delay_support = true;
  1030. break;
  1031. case PALMAS_REG_SMPS45:
  1032. case PALMAS_REG_SMPS7:
  1033. if (pmic->smps457)
  1034. continue;
  1035. if (id == PALMAS_REG_SMPS45)
  1036. ramp_delay_support = true;
  1037. break;
  1038. case PALMAS_REG_SMPS457:
  1039. if (!pmic->smps457)
  1040. continue;
  1041. ramp_delay_support = true;
  1042. break;
  1043. case PALMAS_REG_SMPS10_OUT1:
  1044. case PALMAS_REG_SMPS10_OUT2:
  1045. if (!PALMAS_PMIC_HAS(pmic->palmas, SMPS10_BOOST))
  1046. continue;
  1047. }
  1048. rinfo = &ddata->palmas_regs_info[id];
  1049. desc = &pmic->desc[id];
  1050. if ((id == PALMAS_REG_SMPS6) || (id == PALMAS_REG_SMPS8))
  1051. ramp_delay_support = true;
  1052. if (ramp_delay_support) {
  1053. addr = rinfo->tstep_addr;
  1054. ret = palmas_smps_read(pmic->palmas, addr, &reg);
  1055. if (ret < 0) {
  1056. dev_err(pmic->dev,
  1057. "reading TSTEP reg failed: %d\n", ret);
  1058. return ret;
  1059. }
  1060. desc->ramp_delay = palmas_smps_ramp_delay[reg & 0x3];
  1061. pmic->ramp_delay[id] = desc->ramp_delay;
  1062. }
  1063. /* Initialise sleep/init values from platform data */
  1064. if (pdata && pdata->reg_init[id]) {
  1065. reg_init = pdata->reg_init[id];
  1066. ret = palmas_smps_init(pmic->palmas, id, reg_init);
  1067. if (ret)
  1068. return ret;
  1069. } else {
  1070. reg_init = NULL;
  1071. }
  1072. /* Register the regulators */
  1073. desc->name = rinfo->name;
  1074. desc->id = id;
  1075. switch (id) {
  1076. case PALMAS_REG_SMPS10_OUT1:
  1077. case PALMAS_REG_SMPS10_OUT2:
  1078. desc->n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
  1079. desc->ops = &palmas_ops_smps10;
  1080. desc->vsel_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1081. PALMAS_SMPS10_CTRL);
  1082. desc->vsel_mask = SMPS10_VSEL;
  1083. desc->enable_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1084. PALMAS_SMPS10_CTRL);
  1085. if (id == PALMAS_REG_SMPS10_OUT1)
  1086. desc->enable_mask = SMPS10_SWITCH_EN;
  1087. else
  1088. desc->enable_mask = SMPS10_BOOST_EN;
  1089. desc->bypass_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1090. PALMAS_SMPS10_CTRL);
  1091. desc->bypass_val_on = SMPS10_BYPASS_EN;
  1092. desc->bypass_mask = SMPS10_BYPASS_EN;
  1093. desc->min_uV = 3750000;
  1094. desc->uV_step = 1250000;
  1095. break;
  1096. default:
  1097. /*
  1098. * Read and store the RANGE bit for later use
  1099. * This must be done before regulator is probed,
  1100. * otherwise we error in probe with unsupportable
  1101. * ranges. Read the current smps mode for later use.
  1102. */
  1103. addr = rinfo->vsel_addr;
  1104. desc->n_linear_ranges = 3;
  1105. ret = palmas_smps_read(pmic->palmas, addr, &reg);
  1106. if (ret)
  1107. return ret;
  1108. if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
  1109. pmic->range[id] = 1;
  1110. if (pmic->range[id])
  1111. desc->linear_ranges = smps_high_ranges;
  1112. else
  1113. desc->linear_ranges = smps_low_ranges;
  1114. if (reg_init && reg_init->roof_floor)
  1115. desc->ops = &palmas_ops_ext_control_smps;
  1116. else
  1117. desc->ops = &palmas_ops_smps;
  1118. desc->n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
  1119. desc->vsel_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1120. rinfo->vsel_addr);
  1121. desc->vsel_mask = PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
  1122. /* Read the smps mode for later use. */
  1123. addr = rinfo->ctrl_addr;
  1124. ret = palmas_smps_read(pmic->palmas, addr, &reg);
  1125. if (ret)
  1126. return ret;
  1127. pmic->current_reg_mode[id] = reg &
  1128. PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  1129. desc->enable_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1130. rinfo->ctrl_addr);
  1131. desc->enable_mask = PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  1132. /* set_mode overrides this value */
  1133. desc->enable_val = SMPS_CTRL_MODE_ON;
  1134. }
  1135. desc->type = REGULATOR_VOLTAGE;
  1136. desc->owner = THIS_MODULE;
  1137. if (pdata)
  1138. config.init_data = pdata->reg_data[id];
  1139. else
  1140. config.init_data = NULL;
  1141. desc->supply_name = rinfo->sname;
  1142. config.of_node = ddata->palmas_matches[id].of_node;
  1143. rdev = devm_regulator_register(pmic->dev, desc, &config);
  1144. if (IS_ERR(rdev)) {
  1145. dev_err(pmic->dev,
  1146. "failed to register %s regulator\n",
  1147. pdev_name);
  1148. return PTR_ERR(rdev);
  1149. }
  1150. }
  1151. return 0;
  1152. }
  1153. static int tps65917_smps_registration(struct palmas_pmic *pmic,
  1154. struct palmas_pmic_driver_data *ddata,
  1155. struct palmas_pmic_platform_data *pdata,
  1156. const char *pdev_name,
  1157. struct regulator_config config)
  1158. {
  1159. int id, ret;
  1160. unsigned int addr, reg;
  1161. struct regulator_dev *rdev;
  1162. struct palmas_reg_init *reg_init;
  1163. struct palmas_regs_info *rinfo;
  1164. struct regulator_desc *desc;
  1165. for (id = ddata->smps_start; id <= ddata->smps_end; id++) {
  1166. /*
  1167. * Miss out regulators which are not available due
  1168. * to slaving configurations.
  1169. */
  1170. desc = &pmic->desc[id];
  1171. desc->n_linear_ranges = 3;
  1172. if ((id == TPS65917_REG_SMPS2 || id == TPS65917_REG_SMPS1) &&
  1173. pmic->smps12)
  1174. continue;
  1175. /* Initialise sleep/init values from platform data */
  1176. if (pdata && pdata->reg_init[id]) {
  1177. reg_init = pdata->reg_init[id];
  1178. ret = palmas_smps_init(pmic->palmas, id, reg_init);
  1179. if (ret)
  1180. return ret;
  1181. } else {
  1182. reg_init = NULL;
  1183. }
  1184. rinfo = &ddata->palmas_regs_info[id];
  1185. /* Register the regulators */
  1186. desc->name = rinfo->name;
  1187. desc->id = id;
  1188. /*
  1189. * Read and store the RANGE bit for later use
  1190. * This must be done before regulator is probed,
  1191. * otherwise we error in probe with unsupportable
  1192. * ranges. Read the current smps mode for later use.
  1193. */
  1194. addr = rinfo->vsel_addr;
  1195. ret = palmas_smps_read(pmic->palmas, addr, &reg);
  1196. if (ret)
  1197. return ret;
  1198. if (reg & TPS65917_SMPS1_VOLTAGE_RANGE)
  1199. pmic->range[id] = 1;
  1200. if (pmic->range[id])
  1201. desc->linear_ranges = smps_high_ranges;
  1202. else
  1203. desc->linear_ranges = smps_low_ranges;
  1204. if (reg_init && reg_init->roof_floor)
  1205. desc->ops = &tps65917_ops_ext_control_smps;
  1206. else
  1207. desc->ops = &tps65917_ops_smps;
  1208. desc->n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
  1209. desc->vsel_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1210. rinfo->vsel_addr);
  1211. desc->vsel_mask = PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
  1212. desc->ramp_delay = 2500;
  1213. /* Read the smps mode for later use. */
  1214. addr = rinfo->ctrl_addr;
  1215. ret = palmas_smps_read(pmic->palmas, addr, &reg);
  1216. if (ret)
  1217. return ret;
  1218. pmic->current_reg_mode[id] = reg &
  1219. PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  1220. desc->enable_reg = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
  1221. rinfo->ctrl_addr);
  1222. desc->enable_mask = PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
  1223. /* set_mode overrides this value */
  1224. desc->enable_val = SMPS_CTRL_MODE_ON;
  1225. desc->type = REGULATOR_VOLTAGE;
  1226. desc->owner = THIS_MODULE;
  1227. if (pdata)
  1228. config.init_data = pdata->reg_data[id];
  1229. else
  1230. config.init_data = NULL;
  1231. desc->supply_name = rinfo->sname;
  1232. config.of_node = ddata->palmas_matches[id].of_node;
  1233. rdev = devm_regulator_register(pmic->dev, desc, &config);
  1234. if (IS_ERR(rdev)) {
  1235. dev_err(pmic->dev,
  1236. "failed to register %s regulator\n",
  1237. pdev_name);
  1238. return PTR_ERR(rdev);
  1239. }
  1240. }
  1241. return 0;
  1242. }
  1243. static struct of_regulator_match palmas_matches[] = {
  1244. { .name = "smps12", },
  1245. { .name = "smps123", },
  1246. { .name = "smps3", },
  1247. { .name = "smps45", },
  1248. { .name = "smps457", },
  1249. { .name = "smps6", },
  1250. { .name = "smps7", },
  1251. { .name = "smps8", },
  1252. { .name = "smps9", },
  1253. { .name = "smps10_out2", },
  1254. { .name = "smps10_out1", },
  1255. { .name = "ldo1", },
  1256. { .name = "ldo2", },
  1257. { .name = "ldo3", },
  1258. { .name = "ldo4", },
  1259. { .name = "ldo5", },
  1260. { .name = "ldo6", },
  1261. { .name = "ldo7", },
  1262. { .name = "ldo8", },
  1263. { .name = "ldo9", },
  1264. { .name = "ldoln", },
  1265. { .name = "ldousb", },
  1266. { .name = "regen1", },
  1267. { .name = "regen2", },
  1268. { .name = "regen3", },
  1269. { .name = "sysen1", },
  1270. { .name = "sysen2", },
  1271. };
  1272. static struct of_regulator_match tps65917_matches[] = {
  1273. { .name = "smps1", },
  1274. { .name = "smps2", },
  1275. { .name = "smps3", },
  1276. { .name = "smps4", },
  1277. { .name = "smps5", },
  1278. { .name = "smps12",},
  1279. { .name = "ldo1", },
  1280. { .name = "ldo2", },
  1281. { .name = "ldo3", },
  1282. { .name = "ldo4", },
  1283. { .name = "ldo5", },
  1284. { .name = "regen1", },
  1285. { .name = "regen2", },
  1286. { .name = "regen3", },
  1287. { .name = "sysen1", },
  1288. { .name = "sysen2", },
  1289. };
  1290. static struct palmas_pmic_driver_data palmas_ddata = {
  1291. .smps_start = PALMAS_REG_SMPS12,
  1292. .smps_end = PALMAS_REG_SMPS10_OUT1,
  1293. .ldo_begin = PALMAS_REG_LDO1,
  1294. .ldo_end = PALMAS_REG_LDOUSB,
  1295. .max_reg = PALMAS_NUM_REGS,
  1296. .has_regen3 = true,
  1297. .palmas_regs_info = palmas_generic_regs_info,
  1298. .palmas_matches = palmas_matches,
  1299. .sleep_req_info = palma_sleep_req_info,
  1300. .smps_register = palmas_smps_registration,
  1301. .ldo_register = palmas_ldo_registration,
  1302. };
  1303. static struct palmas_pmic_driver_data tps65917_ddata = {
  1304. .smps_start = TPS65917_REG_SMPS1,
  1305. .smps_end = TPS65917_REG_SMPS12,
  1306. .ldo_begin = TPS65917_REG_LDO1,
  1307. .ldo_end = TPS65917_REG_LDO5,
  1308. .max_reg = TPS65917_NUM_REGS,
  1309. .has_regen3 = true,
  1310. .palmas_regs_info = tps65917_regs_info,
  1311. .palmas_matches = tps65917_matches,
  1312. .sleep_req_info = tps65917_sleep_req_info,
  1313. .smps_register = tps65917_smps_registration,
  1314. .ldo_register = tps65917_ldo_registration,
  1315. };
  1316. static int palmas_dt_to_pdata(struct device *dev,
  1317. struct device_node *node,
  1318. struct palmas_pmic_platform_data *pdata,
  1319. struct palmas_pmic_driver_data *ddata)
  1320. {
  1321. struct device_node *regulators;
  1322. u32 prop;
  1323. int idx, ret;
  1324. regulators = of_get_child_by_name(node, "regulators");
  1325. if (!regulators) {
  1326. dev_info(dev, "regulator node not found\n");
  1327. return 0;
  1328. }
  1329. ret = of_regulator_match(dev, regulators, ddata->palmas_matches,
  1330. ddata->max_reg);
  1331. of_node_put(regulators);
  1332. if (ret < 0) {
  1333. dev_err(dev, "Error parsing regulator init data: %d\n", ret);
  1334. return 0;
  1335. }
  1336. for (idx = 0; idx < ddata->max_reg; idx++) {
  1337. struct of_regulator_match *match;
  1338. struct palmas_reg_init *rinit;
  1339. struct device_node *np;
  1340. match = &ddata->palmas_matches[idx];
  1341. np = match->of_node;
  1342. if (!match->init_data || !np)
  1343. continue;
  1344. rinit = devm_kzalloc(dev, sizeof(*rinit), GFP_KERNEL);
  1345. if (!rinit)
  1346. return -ENOMEM;
  1347. pdata->reg_data[idx] = match->init_data;
  1348. pdata->reg_init[idx] = rinit;
  1349. rinit->warm_reset = of_property_read_bool(np, "ti,warm-reset");
  1350. ret = of_property_read_u32(np, "ti,roof-floor", &prop);
  1351. /* EINVAL: Property not found */
  1352. if (ret != -EINVAL) {
  1353. int econtrol;
  1354. /* use default value, when no value is specified */
  1355. econtrol = PALMAS_EXT_CONTROL_NSLEEP;
  1356. if (!ret) {
  1357. switch (prop) {
  1358. case 1:
  1359. econtrol = PALMAS_EXT_CONTROL_ENABLE1;
  1360. break;
  1361. case 2:
  1362. econtrol = PALMAS_EXT_CONTROL_ENABLE2;
  1363. break;
  1364. case 3:
  1365. econtrol = PALMAS_EXT_CONTROL_NSLEEP;
  1366. break;
  1367. default:
  1368. WARN_ON(1);
  1369. dev_warn(dev,
  1370. "%s: Invalid roof-floor option: %u\n",
  1371. match->name, prop);
  1372. break;
  1373. }
  1374. }
  1375. rinit->roof_floor = econtrol;
  1376. }
  1377. ret = of_property_read_u32(np, "ti,mode-sleep", &prop);
  1378. if (!ret)
  1379. rinit->mode_sleep = prop;
  1380. ret = of_property_read_bool(np, "ti,smps-range");
  1381. if (ret)
  1382. rinit->vsel = PALMAS_SMPS12_VOLTAGE_RANGE;
  1383. if (idx == PALMAS_REG_LDO8)
  1384. pdata->enable_ldo8_tracking = of_property_read_bool(
  1385. np, "ti,enable-ldo8-tracking");
  1386. }
  1387. pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
  1388. return 0;
  1389. }
  1390. static const struct of_device_id of_palmas_match_tbl[] = {
  1391. {
  1392. .compatible = "ti,palmas-pmic",
  1393. .data = &palmas_ddata,
  1394. },
  1395. {
  1396. .compatible = "ti,twl6035-pmic",
  1397. .data = &palmas_ddata,
  1398. },
  1399. {
  1400. .compatible = "ti,twl6036-pmic",
  1401. .data = &palmas_ddata,
  1402. },
  1403. {
  1404. .compatible = "ti,twl6037-pmic",
  1405. .data = &palmas_ddata,
  1406. },
  1407. {
  1408. .compatible = "ti,tps65913-pmic",
  1409. .data = &palmas_ddata,
  1410. },
  1411. {
  1412. .compatible = "ti,tps65914-pmic",
  1413. .data = &palmas_ddata,
  1414. },
  1415. {
  1416. .compatible = "ti,tps80036-pmic",
  1417. .data = &palmas_ddata,
  1418. },
  1419. {
  1420. .compatible = "ti,tps659038-pmic",
  1421. .data = &palmas_ddata,
  1422. },
  1423. {
  1424. .compatible = "ti,tps65917-pmic",
  1425. .data = &tps65917_ddata,
  1426. },
  1427. { /* end */ }
  1428. };
  1429. static int palmas_regulators_probe(struct platform_device *pdev)
  1430. {
  1431. struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
  1432. struct palmas_pmic_platform_data *pdata = dev_get_platdata(&pdev->dev);
  1433. struct device_node *node = pdev->dev.of_node;
  1434. struct palmas_pmic_driver_data *driver_data;
  1435. struct regulator_config config = { };
  1436. struct palmas_pmic *pmic;
  1437. const char *pdev_name;
  1438. const struct of_device_id *match;
  1439. int ret = 0;
  1440. unsigned int reg;
  1441. match = of_match_device(of_match_ptr(of_palmas_match_tbl), &pdev->dev);
  1442. if (!match)
  1443. return -ENODATA;
  1444. driver_data = (struct palmas_pmic_driver_data *)match->data;
  1445. pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  1446. if (!pdata)
  1447. return -ENOMEM;
  1448. pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
  1449. if (!pmic)
  1450. return -ENOMEM;
  1451. if (of_device_is_compatible(node, "ti,tps659038-pmic")) {
  1452. palmas_generic_regs_info[PALMAS_REG_REGEN2].ctrl_addr =
  1453. TPS659038_REGEN2_CTRL;
  1454. palmas_ddata.has_regen3 = false;
  1455. }
  1456. pmic->dev = &pdev->dev;
  1457. pmic->palmas = palmas;
  1458. palmas->pmic = pmic;
  1459. platform_set_drvdata(pdev, pmic);
  1460. pmic->palmas->pmic_ddata = driver_data;
  1461. ret = palmas_dt_to_pdata(&pdev->dev, node, pdata, driver_data);
  1462. if (ret)
  1463. return ret;
  1464. ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
  1465. if (ret)
  1466. return ret;
  1467. if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN) {
  1468. pmic->smps123 = 1;
  1469. pmic->smps12 = 1;
  1470. }
  1471. if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
  1472. pmic->smps457 = 1;
  1473. config.regmap = palmas->regmap[REGULATOR_SLAVE];
  1474. config.dev = &pdev->dev;
  1475. config.driver_data = pmic;
  1476. pdev_name = pdev->name;
  1477. ret = driver_data->smps_register(pmic, driver_data, pdata, pdev_name,
  1478. config);
  1479. if (ret)
  1480. return ret;
  1481. ret = driver_data->ldo_register(pmic, driver_data, pdata, pdev_name,
  1482. config);
  1483. return ret;
  1484. }
  1485. static struct platform_driver palmas_driver = {
  1486. .driver = {
  1487. .name = "palmas-pmic",
  1488. .of_match_table = of_palmas_match_tbl,
  1489. },
  1490. .probe = palmas_regulators_probe,
  1491. };
  1492. static int __init palmas_init(void)
  1493. {
  1494. return platform_driver_register(&palmas_driver);
  1495. }
  1496. subsys_initcall(palmas_init);
  1497. static void __exit palmas_exit(void)
  1498. {
  1499. platform_driver_unregister(&palmas_driver);
  1500. }
  1501. module_exit(palmas_exit);
  1502. MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
  1503. MODULE_DESCRIPTION("Palmas voltage regulator driver");
  1504. MODULE_LICENSE("GPL");
  1505. MODULE_ALIAS("platform:palmas-pmic");
  1506. MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);