fan53555.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
  4. //
  5. // Supported Part Numbers:
  6. // FAN53555UC00X/01X/03X/04X/05X
  7. //
  8. // Copyright (c) 2012 Marvell Technology Ltd.
  9. // Yunfan Zhang <yfzhang@marvell.com>
  10. #include <linux/module.h>
  11. #include <linux/param.h>
  12. #include <linux/err.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/regulator/driver.h>
  15. #include <linux/regulator/machine.h>
  16. #include <linux/regulator/of_regulator.h>
  17. #include <linux/of_device.h>
  18. #include <linux/i2c.h>
  19. #include <linux/slab.h>
  20. #include <linux/regmap.h>
  21. #include <linux/regulator/fan53555.h>
  22. /* Voltage setting */
  23. #define FAN53555_VSEL0 0x00
  24. #define FAN53555_VSEL1 0x01
  25. /* Control register */
  26. #define FAN53555_CONTROL 0x02
  27. /* IC Type */
  28. #define FAN53555_ID1 0x03
  29. /* IC mask version */
  30. #define FAN53555_ID2 0x04
  31. /* Monitor register */
  32. #define FAN53555_MONITOR 0x05
  33. /* VSEL bit definitions */
  34. #define VSEL_BUCK_EN (1 << 7)
  35. #define VSEL_MODE (1 << 6)
  36. /* Chip ID and Verison */
  37. #define DIE_ID 0x0F /* ID1 */
  38. #define DIE_REV 0x0F /* ID2 */
  39. /* Control bit definitions */
  40. #define CTL_OUTPUT_DISCHG (1 << 7)
  41. #define CTL_SLEW_MASK (0x7 << 4)
  42. #define CTL_SLEW_SHIFT 4
  43. #define CTL_RESET (1 << 2)
  44. #define CTL_MODE_VSEL0_MODE BIT(0)
  45. #define CTL_MODE_VSEL1_MODE BIT(1)
  46. #define FAN53555_NVOLTAGES 64 /* Numbers of voltages */
  47. #define FAN53526_NVOLTAGES 128
  48. enum fan53555_vendor {
  49. FAN53526_VENDOR_FAIRCHILD = 0,
  50. FAN53555_VENDOR_FAIRCHILD,
  51. FAN53555_VENDOR_SILERGY,
  52. };
  53. enum {
  54. FAN53526_CHIP_ID_01 = 1,
  55. };
  56. enum {
  57. FAN53526_CHIP_REV_08 = 8,
  58. };
  59. /* IC Type */
  60. enum {
  61. FAN53555_CHIP_ID_00 = 0,
  62. FAN53555_CHIP_ID_01,
  63. FAN53555_CHIP_ID_02,
  64. FAN53555_CHIP_ID_03,
  65. FAN53555_CHIP_ID_04,
  66. FAN53555_CHIP_ID_05,
  67. FAN53555_CHIP_ID_08 = 8,
  68. };
  69. /* IC mask revision */
  70. enum {
  71. FAN53555_CHIP_REV_00 = 0x3,
  72. FAN53555_CHIP_REV_13 = 0xf,
  73. };
  74. enum {
  75. SILERGY_SYR82X = 8,
  76. SILERGY_SYR83X = 9,
  77. };
  78. struct fan53555_device_info {
  79. enum fan53555_vendor vendor;
  80. struct device *dev;
  81. struct regulator_desc desc;
  82. struct regulator_init_data *regulator;
  83. /* IC Type and Rev */
  84. int chip_id;
  85. int chip_rev;
  86. /* Voltage setting register */
  87. unsigned int vol_reg;
  88. unsigned int sleep_reg;
  89. /* Voltage range and step(linear) */
  90. unsigned int vsel_min;
  91. unsigned int vsel_step;
  92. unsigned int vsel_count;
  93. /* Mode */
  94. unsigned int mode_reg;
  95. unsigned int mode_mask;
  96. /* Sleep voltage cache */
  97. unsigned int sleep_vol_cache;
  98. };
  99. static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
  100. {
  101. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  102. int ret;
  103. if (di->sleep_vol_cache == uV)
  104. return 0;
  105. ret = regulator_map_voltage_linear(rdev, uV, uV);
  106. if (ret < 0)
  107. return ret;
  108. ret = regmap_update_bits(rdev->regmap, di->sleep_reg,
  109. di->desc.vsel_mask, ret);
  110. if (ret < 0)
  111. return ret;
  112. /* Cache the sleep voltage setting.
  113. * Might not be the real voltage which is rounded */
  114. di->sleep_vol_cache = uV;
  115. return 0;
  116. }
  117. static int fan53555_set_suspend_enable(struct regulator_dev *rdev)
  118. {
  119. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  120. return regmap_update_bits(rdev->regmap, di->sleep_reg,
  121. VSEL_BUCK_EN, VSEL_BUCK_EN);
  122. }
  123. static int fan53555_set_suspend_disable(struct regulator_dev *rdev)
  124. {
  125. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  126. return regmap_update_bits(rdev->regmap, di->sleep_reg,
  127. VSEL_BUCK_EN, 0);
  128. }
  129. static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
  130. {
  131. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  132. switch (mode) {
  133. case REGULATOR_MODE_FAST:
  134. regmap_update_bits(rdev->regmap, di->mode_reg,
  135. di->mode_mask, di->mode_mask);
  136. break;
  137. case REGULATOR_MODE_NORMAL:
  138. regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);
  139. break;
  140. default:
  141. return -EINVAL;
  142. }
  143. return 0;
  144. }
  145. static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
  146. {
  147. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  148. unsigned int val;
  149. int ret = 0;
  150. ret = regmap_read(rdev->regmap, di->mode_reg, &val);
  151. if (ret < 0)
  152. return ret;
  153. if (val & di->mode_mask)
  154. return REGULATOR_MODE_FAST;
  155. else
  156. return REGULATOR_MODE_NORMAL;
  157. }
  158. static const int slew_rates[] = {
  159. 64000,
  160. 32000,
  161. 16000,
  162. 8000,
  163. 4000,
  164. 2000,
  165. 1000,
  166. 500,
  167. };
  168. static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp)
  169. {
  170. struct fan53555_device_info *di = rdev_get_drvdata(rdev);
  171. int regval = -1, i;
  172. for (i = 0; i < ARRAY_SIZE(slew_rates); i++) {
  173. if (ramp <= slew_rates[i])
  174. regval = i;
  175. else
  176. break;
  177. }
  178. if (regval < 0) {
  179. dev_err(di->dev, "unsupported ramp value %d\n", ramp);
  180. return -EINVAL;
  181. }
  182. return regmap_update_bits(rdev->regmap, FAN53555_CONTROL,
  183. CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT);
  184. }
  185. static const struct regulator_ops fan53555_regulator_ops = {
  186. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  187. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  188. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  189. .map_voltage = regulator_map_voltage_linear,
  190. .list_voltage = regulator_list_voltage_linear,
  191. .set_suspend_voltage = fan53555_set_suspend_voltage,
  192. .enable = regulator_enable_regmap,
  193. .disable = regulator_disable_regmap,
  194. .is_enabled = regulator_is_enabled_regmap,
  195. .set_mode = fan53555_set_mode,
  196. .get_mode = fan53555_get_mode,
  197. .set_ramp_delay = fan53555_set_ramp,
  198. .set_suspend_enable = fan53555_set_suspend_enable,
  199. .set_suspend_disable = fan53555_set_suspend_disable,
  200. };
  201. static int fan53526_voltages_setup_fairchild(struct fan53555_device_info *di)
  202. {
  203. /* Init voltage range and step */
  204. switch (di->chip_id) {
  205. case FAN53526_CHIP_ID_01:
  206. switch (di->chip_rev) {
  207. case FAN53526_CHIP_REV_08:
  208. di->vsel_min = 600000;
  209. di->vsel_step = 6250;
  210. break;
  211. default:
  212. dev_err(di->dev,
  213. "Chip ID %d with rev %d not supported!\n",
  214. di->chip_id, di->chip_rev);
  215. return -EINVAL;
  216. }
  217. break;
  218. default:
  219. dev_err(di->dev,
  220. "Chip ID %d not supported!\n", di->chip_id);
  221. return -EINVAL;
  222. }
  223. di->vsel_count = FAN53526_NVOLTAGES;
  224. return 0;
  225. }
  226. static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
  227. {
  228. /* Init voltage range and step */
  229. switch (di->chip_id) {
  230. case FAN53555_CHIP_ID_00:
  231. switch (di->chip_rev) {
  232. case FAN53555_CHIP_REV_00:
  233. di->vsel_min = 600000;
  234. di->vsel_step = 10000;
  235. break;
  236. case FAN53555_CHIP_REV_13:
  237. di->vsel_min = 800000;
  238. di->vsel_step = 10000;
  239. break;
  240. default:
  241. dev_err(di->dev,
  242. "Chip ID %d with rev %d not supported!\n",
  243. di->chip_id, di->chip_rev);
  244. return -EINVAL;
  245. }
  246. break;
  247. case FAN53555_CHIP_ID_01:
  248. case FAN53555_CHIP_ID_03:
  249. case FAN53555_CHIP_ID_05:
  250. case FAN53555_CHIP_ID_08:
  251. di->vsel_min = 600000;
  252. di->vsel_step = 10000;
  253. break;
  254. case FAN53555_CHIP_ID_04:
  255. di->vsel_min = 603000;
  256. di->vsel_step = 12826;
  257. break;
  258. default:
  259. dev_err(di->dev,
  260. "Chip ID %d not supported!\n", di->chip_id);
  261. return -EINVAL;
  262. }
  263. di->vsel_count = FAN53555_NVOLTAGES;
  264. return 0;
  265. }
  266. static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)
  267. {
  268. /* Init voltage range and step */
  269. switch (di->chip_id) {
  270. case SILERGY_SYR82X:
  271. case SILERGY_SYR83X:
  272. di->vsel_min = 712500;
  273. di->vsel_step = 12500;
  274. break;
  275. default:
  276. dev_err(di->dev,
  277. "Chip ID %d not supported!\n", di->chip_id);
  278. return -EINVAL;
  279. }
  280. di->vsel_count = FAN53555_NVOLTAGES;
  281. return 0;
  282. }
  283. /* For 00,01,03,05 options:
  284. * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
  285. * For 04 option:
  286. * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
  287. * */
  288. static int fan53555_device_setup(struct fan53555_device_info *di,
  289. struct fan53555_platform_data *pdata)
  290. {
  291. int ret = 0;
  292. /* Setup voltage control register */
  293. switch (pdata->sleep_vsel_id) {
  294. case FAN53555_VSEL_ID_0:
  295. di->sleep_reg = FAN53555_VSEL0;
  296. di->vol_reg = FAN53555_VSEL1;
  297. break;
  298. case FAN53555_VSEL_ID_1:
  299. di->sleep_reg = FAN53555_VSEL1;
  300. di->vol_reg = FAN53555_VSEL0;
  301. break;
  302. default:
  303. dev_err(di->dev, "Invalid VSEL ID!\n");
  304. return -EINVAL;
  305. }
  306. /* Setup mode control register */
  307. switch (di->vendor) {
  308. case FAN53526_VENDOR_FAIRCHILD:
  309. di->mode_reg = FAN53555_CONTROL;
  310. switch (pdata->sleep_vsel_id) {
  311. case FAN53555_VSEL_ID_0:
  312. di->mode_mask = CTL_MODE_VSEL1_MODE;
  313. break;
  314. case FAN53555_VSEL_ID_1:
  315. di->mode_mask = CTL_MODE_VSEL0_MODE;
  316. break;
  317. }
  318. break;
  319. case FAN53555_VENDOR_FAIRCHILD:
  320. case FAN53555_VENDOR_SILERGY:
  321. di->mode_reg = di->vol_reg;
  322. di->mode_mask = VSEL_MODE;
  323. break;
  324. default:
  325. dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
  326. return -EINVAL;
  327. }
  328. /* Setup voltage range */
  329. switch (di->vendor) {
  330. case FAN53526_VENDOR_FAIRCHILD:
  331. ret = fan53526_voltages_setup_fairchild(di);
  332. break;
  333. case FAN53555_VENDOR_FAIRCHILD:
  334. ret = fan53555_voltages_setup_fairchild(di);
  335. break;
  336. case FAN53555_VENDOR_SILERGY:
  337. ret = fan53555_voltages_setup_silergy(di);
  338. break;
  339. default:
  340. dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
  341. return -EINVAL;
  342. }
  343. return ret;
  344. }
  345. static int fan53555_regulator_register(struct fan53555_device_info *di,
  346. struct regulator_config *config)
  347. {
  348. struct regulator_desc *rdesc = &di->desc;
  349. struct regulator_dev *rdev;
  350. rdesc->name = "fan53555-reg";
  351. rdesc->supply_name = "vin";
  352. rdesc->ops = &fan53555_regulator_ops;
  353. rdesc->type = REGULATOR_VOLTAGE;
  354. rdesc->n_voltages = di->vsel_count;
  355. rdesc->enable_reg = di->vol_reg;
  356. rdesc->enable_mask = VSEL_BUCK_EN;
  357. rdesc->min_uV = di->vsel_min;
  358. rdesc->uV_step = di->vsel_step;
  359. rdesc->vsel_reg = di->vol_reg;
  360. rdesc->vsel_mask = di->vsel_count - 1;
  361. rdesc->owner = THIS_MODULE;
  362. rdev = devm_regulator_register(di->dev, &di->desc, config);
  363. return PTR_ERR_OR_ZERO(rdev);
  364. }
  365. static const struct regmap_config fan53555_regmap_config = {
  366. .reg_bits = 8,
  367. .val_bits = 8,
  368. };
  369. static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
  370. struct device_node *np,
  371. const struct regulator_desc *desc)
  372. {
  373. struct fan53555_platform_data *pdata;
  374. int ret;
  375. u32 tmp;
  376. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  377. if (!pdata)
  378. return NULL;
  379. pdata->regulator = of_get_regulator_init_data(dev, np, desc);
  380. ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
  381. &tmp);
  382. if (!ret)
  383. pdata->sleep_vsel_id = tmp;
  384. return pdata;
  385. }
  386. static const struct of_device_id __maybe_unused fan53555_dt_ids[] = {
  387. {
  388. .compatible = "fcs,fan53526",
  389. .data = (void *)FAN53526_VENDOR_FAIRCHILD,
  390. }, {
  391. .compatible = "fcs,fan53555",
  392. .data = (void *)FAN53555_VENDOR_FAIRCHILD
  393. }, {
  394. .compatible = "silergy,syr827",
  395. .data = (void *)FAN53555_VENDOR_SILERGY,
  396. }, {
  397. .compatible = "silergy,syr828",
  398. .data = (void *)FAN53555_VENDOR_SILERGY,
  399. },
  400. { }
  401. };
  402. MODULE_DEVICE_TABLE(of, fan53555_dt_ids);
  403. static int fan53555_regulator_probe(struct i2c_client *client,
  404. const struct i2c_device_id *id)
  405. {
  406. struct device_node *np = client->dev.of_node;
  407. struct fan53555_device_info *di;
  408. struct fan53555_platform_data *pdata;
  409. struct regulator_config config = { };
  410. struct regmap *regmap;
  411. unsigned int val;
  412. int ret;
  413. di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
  414. GFP_KERNEL);
  415. if (!di)
  416. return -ENOMEM;
  417. pdata = dev_get_platdata(&client->dev);
  418. if (!pdata)
  419. pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
  420. if (!pdata || !pdata->regulator) {
  421. dev_err(&client->dev, "Platform data not found!\n");
  422. return -ENODEV;
  423. }
  424. di->regulator = pdata->regulator;
  425. if (client->dev.of_node) {
  426. di->vendor =
  427. (unsigned long)of_device_get_match_data(&client->dev);
  428. } else {
  429. /* if no ramp constraint set, get the pdata ramp_delay */
  430. if (!di->regulator->constraints.ramp_delay) {
  431. if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) {
  432. dev_err(&client->dev, "Invalid slew_rate\n");
  433. return -EINVAL;
  434. }
  435. di->regulator->constraints.ramp_delay
  436. = slew_rates[pdata->slew_rate];
  437. }
  438. di->vendor = id->driver_data;
  439. }
  440. regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
  441. if (IS_ERR(regmap)) {
  442. dev_err(&client->dev, "Failed to allocate regmap!\n");
  443. return PTR_ERR(regmap);
  444. }
  445. di->dev = &client->dev;
  446. i2c_set_clientdata(client, di);
  447. /* Get chip ID */
  448. ret = regmap_read(regmap, FAN53555_ID1, &val);
  449. if (ret < 0) {
  450. dev_err(&client->dev, "Failed to get chip ID!\n");
  451. return ret;
  452. }
  453. di->chip_id = val & DIE_ID;
  454. /* Get chip revision */
  455. ret = regmap_read(regmap, FAN53555_ID2, &val);
  456. if (ret < 0) {
  457. dev_err(&client->dev, "Failed to get chip Rev!\n");
  458. return ret;
  459. }
  460. di->chip_rev = val & DIE_REV;
  461. dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
  462. di->chip_id, di->chip_rev);
  463. /* Device init */
  464. ret = fan53555_device_setup(di, pdata);
  465. if (ret < 0) {
  466. dev_err(&client->dev, "Failed to setup device!\n");
  467. return ret;
  468. }
  469. /* Register regulator */
  470. config.dev = di->dev;
  471. config.init_data = di->regulator;
  472. config.regmap = regmap;
  473. config.driver_data = di;
  474. config.of_node = np;
  475. ret = fan53555_regulator_register(di, &config);
  476. if (ret < 0)
  477. dev_err(&client->dev, "Failed to register regulator!\n");
  478. return ret;
  479. }
  480. static const struct i2c_device_id fan53555_id[] = {
  481. {
  482. .name = "fan53526",
  483. .driver_data = FAN53526_VENDOR_FAIRCHILD
  484. }, {
  485. .name = "fan53555",
  486. .driver_data = FAN53555_VENDOR_FAIRCHILD
  487. }, {
  488. .name = "syr827",
  489. .driver_data = FAN53555_VENDOR_SILERGY
  490. }, {
  491. .name = "syr828",
  492. .driver_data = FAN53555_VENDOR_SILERGY
  493. },
  494. { },
  495. };
  496. MODULE_DEVICE_TABLE(i2c, fan53555_id);
  497. static struct i2c_driver fan53555_regulator_driver = {
  498. .driver = {
  499. .name = "fan53555-regulator",
  500. .of_match_table = of_match_ptr(fan53555_dt_ids),
  501. },
  502. .probe = fan53555_regulator_probe,
  503. .id_table = fan53555_id,
  504. };
  505. module_i2c_driver(fan53555_regulator_driver);
  506. MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
  507. MODULE_DESCRIPTION("FAN53555 regulator driver");
  508. MODULE_LICENSE("GPL v2");