clk-si514.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Driver for Silicon Labs Si514 Programmable Oscillator
  4. *
  5. * Copyright (C) 2015 Topic Embedded Products
  6. *
  7. * Author: Mike Looijmans <mike.looijmans@topic.nl>
  8. */
  9. #include <linux/clk-provider.h>
  10. #include <linux/delay.h>
  11. #include <linux/module.h>
  12. #include <linux/i2c.h>
  13. #include <linux/regmap.h>
  14. #include <linux/slab.h>
  15. /* I2C registers */
  16. #define SI514_REG_LP 0
  17. #define SI514_REG_M_FRAC1 5
  18. #define SI514_REG_M_FRAC2 6
  19. #define SI514_REG_M_FRAC3 7
  20. #define SI514_REG_M_INT_FRAC 8
  21. #define SI514_REG_M_INT 9
  22. #define SI514_REG_HS_DIV 10
  23. #define SI514_REG_LS_HS_DIV 11
  24. #define SI514_REG_OE_STATE 14
  25. #define SI514_REG_RESET 128
  26. #define SI514_REG_CONTROL 132
  27. /* Register values */
  28. #define SI514_RESET_RST BIT(7)
  29. #define SI514_CONTROL_FCAL BIT(0)
  30. #define SI514_CONTROL_OE BIT(2)
  31. #define SI514_MIN_FREQ 100000U
  32. #define SI514_MAX_FREQ 250000000U
  33. #define FXO 31980000U
  34. #define FVCO_MIN 2080000000U
  35. #define FVCO_MAX 2500000000U
  36. #define HS_DIV_MAX 1022
  37. struct clk_si514 {
  38. struct clk_hw hw;
  39. struct regmap *regmap;
  40. struct i2c_client *i2c_client;
  41. };
  42. #define to_clk_si514(_hw) container_of(_hw, struct clk_si514, hw)
  43. /* Multiplier/divider settings */
  44. struct clk_si514_muldiv {
  45. u32 m_frac; /* 29-bit Fractional part of multiplier M */
  46. u8 m_int; /* Integer part of multiplier M, 65..78 */
  47. u8 ls_div_bits; /* 2nd divider, as 2^x */
  48. u16 hs_div; /* 1st divider, must be even and 10<=x<=1022 */
  49. };
  50. /* Enables or disables the output driver */
  51. static int si514_enable_output(struct clk_si514 *data, bool enable)
  52. {
  53. return regmap_update_bits(data->regmap, SI514_REG_CONTROL,
  54. SI514_CONTROL_OE, enable ? SI514_CONTROL_OE : 0);
  55. }
  56. static int si514_prepare(struct clk_hw *hw)
  57. {
  58. struct clk_si514 *data = to_clk_si514(hw);
  59. return si514_enable_output(data, true);
  60. }
  61. static void si514_unprepare(struct clk_hw *hw)
  62. {
  63. struct clk_si514 *data = to_clk_si514(hw);
  64. si514_enable_output(data, false);
  65. }
  66. static int si514_is_prepared(struct clk_hw *hw)
  67. {
  68. struct clk_si514 *data = to_clk_si514(hw);
  69. unsigned int val;
  70. int err;
  71. err = regmap_read(data->regmap, SI514_REG_CONTROL, &val);
  72. if (err < 0)
  73. return err;
  74. return !!(val & SI514_CONTROL_OE);
  75. }
  76. /* Retrieve clock multiplier and dividers from hardware */
  77. static int si514_get_muldiv(struct clk_si514 *data,
  78. struct clk_si514_muldiv *settings)
  79. {
  80. int err;
  81. u8 reg[7];
  82. err = regmap_bulk_read(data->regmap, SI514_REG_M_FRAC1,
  83. reg, ARRAY_SIZE(reg));
  84. if (err)
  85. return err;
  86. settings->m_frac = reg[0] | reg[1] << 8 | reg[2] << 16 |
  87. (reg[3] & 0x1F) << 24;
  88. settings->m_int = (reg[4] & 0x3f) << 3 | reg[3] >> 5;
  89. settings->ls_div_bits = (reg[6] >> 4) & 0x07;
  90. settings->hs_div = (reg[6] & 0x03) << 8 | reg[5];
  91. return 0;
  92. }
  93. static int si514_set_muldiv(struct clk_si514 *data,
  94. struct clk_si514_muldiv *settings)
  95. {
  96. u8 lp;
  97. u8 reg[7];
  98. int err;
  99. /* Calculate LP1/LP2 according to table 13 in the datasheet */
  100. /* 65.259980246 */
  101. if (settings->m_int < 65 ||
  102. (settings->m_int == 65 && settings->m_frac <= 139575831))
  103. lp = 0x22;
  104. /* 67.859763463 */
  105. else if (settings->m_int < 67 ||
  106. (settings->m_int == 67 && settings->m_frac <= 461581994))
  107. lp = 0x23;
  108. /* 72.937624981 */
  109. else if (settings->m_int < 72 ||
  110. (settings->m_int == 72 && settings->m_frac <= 503383578))
  111. lp = 0x33;
  112. /* 75.843265046 */
  113. else if (settings->m_int < 75 ||
  114. (settings->m_int == 75 && settings->m_frac <= 452724474))
  115. lp = 0x34;
  116. else
  117. lp = 0x44;
  118. err = regmap_write(data->regmap, SI514_REG_LP, lp);
  119. if (err < 0)
  120. return err;
  121. reg[0] = settings->m_frac;
  122. reg[1] = settings->m_frac >> 8;
  123. reg[2] = settings->m_frac >> 16;
  124. reg[3] = settings->m_frac >> 24 | settings->m_int << 5;
  125. reg[4] = settings->m_int >> 3;
  126. reg[5] = settings->hs_div;
  127. reg[6] = (settings->hs_div >> 8) | (settings->ls_div_bits << 4);
  128. err = regmap_bulk_write(data->regmap, SI514_REG_HS_DIV, reg + 5, 2);
  129. if (err < 0)
  130. return err;
  131. /*
  132. * Writing to SI514_REG_M_INT_FRAC triggers the clock change, so that
  133. * must be written last
  134. */
  135. return regmap_bulk_write(data->regmap, SI514_REG_M_FRAC1, reg, 5);
  136. }
  137. /* Calculate divider settings for a given frequency */
  138. static int si514_calc_muldiv(struct clk_si514_muldiv *settings,
  139. unsigned long frequency)
  140. {
  141. u64 m;
  142. u32 ls_freq;
  143. u32 tmp;
  144. u8 res;
  145. if ((frequency < SI514_MIN_FREQ) || (frequency > SI514_MAX_FREQ))
  146. return -EINVAL;
  147. /* Determine the minimum value of LS_DIV and resulting target freq. */
  148. ls_freq = frequency;
  149. if (frequency >= (FVCO_MIN / HS_DIV_MAX))
  150. settings->ls_div_bits = 0;
  151. else {
  152. res = 1;
  153. tmp = 2 * HS_DIV_MAX;
  154. while (tmp <= (HS_DIV_MAX * 32)) {
  155. if ((frequency * tmp) >= FVCO_MIN)
  156. break;
  157. ++res;
  158. tmp <<= 1;
  159. }
  160. settings->ls_div_bits = res;
  161. ls_freq = frequency << res;
  162. }
  163. /* Determine minimum HS_DIV, round up to even number */
  164. settings->hs_div = DIV_ROUND_UP(FVCO_MIN >> 1, ls_freq) << 1;
  165. /* M = LS_DIV x HS_DIV x frequency / F_XO (in fixed-point) */
  166. m = ((u64)(ls_freq * settings->hs_div) << 29) + (FXO / 2);
  167. do_div(m, FXO);
  168. settings->m_frac = (u32)m & (BIT(29) - 1);
  169. settings->m_int = (u32)(m >> 29);
  170. return 0;
  171. }
  172. /* Calculate resulting frequency given the register settings */
  173. static unsigned long si514_calc_rate(struct clk_si514_muldiv *settings)
  174. {
  175. u64 m = settings->m_frac | ((u64)settings->m_int << 29);
  176. u32 d = settings->hs_div * BIT(settings->ls_div_bits);
  177. return ((u32)(((m * FXO) + (FXO / 2)) >> 29)) / d;
  178. }
  179. static unsigned long si514_recalc_rate(struct clk_hw *hw,
  180. unsigned long parent_rate)
  181. {
  182. struct clk_si514 *data = to_clk_si514(hw);
  183. struct clk_si514_muldiv settings;
  184. int err;
  185. err = si514_get_muldiv(data, &settings);
  186. if (err) {
  187. dev_err(&data->i2c_client->dev, "unable to retrieve settings\n");
  188. return 0;
  189. }
  190. return si514_calc_rate(&settings);
  191. }
  192. static long si514_round_rate(struct clk_hw *hw, unsigned long rate,
  193. unsigned long *parent_rate)
  194. {
  195. struct clk_si514_muldiv settings;
  196. int err;
  197. if (!rate)
  198. return 0;
  199. err = si514_calc_muldiv(&settings, rate);
  200. if (err)
  201. return err;
  202. return si514_calc_rate(&settings);
  203. }
  204. /*
  205. * Update output frequency for big frequency changes (> 1000 ppm).
  206. * The chip supports <1000ppm changes "on the fly", we haven't implemented
  207. * that here.
  208. */
  209. static int si514_set_rate(struct clk_hw *hw, unsigned long rate,
  210. unsigned long parent_rate)
  211. {
  212. struct clk_si514 *data = to_clk_si514(hw);
  213. struct clk_si514_muldiv settings;
  214. unsigned int old_oe_state;
  215. int err;
  216. err = si514_calc_muldiv(&settings, rate);
  217. if (err)
  218. return err;
  219. err = regmap_read(data->regmap, SI514_REG_CONTROL, &old_oe_state);
  220. if (err)
  221. return err;
  222. si514_enable_output(data, false);
  223. err = si514_set_muldiv(data, &settings);
  224. if (err < 0)
  225. return err; /* Undefined state now, best to leave disabled */
  226. /* Trigger calibration */
  227. err = regmap_write(data->regmap, SI514_REG_CONTROL, SI514_CONTROL_FCAL);
  228. if (err < 0)
  229. return err;
  230. /* Applying a new frequency can take up to 10ms */
  231. usleep_range(10000, 12000);
  232. if (old_oe_state & SI514_CONTROL_OE)
  233. si514_enable_output(data, true);
  234. return err;
  235. }
  236. static const struct clk_ops si514_clk_ops = {
  237. .prepare = si514_prepare,
  238. .unprepare = si514_unprepare,
  239. .is_prepared = si514_is_prepared,
  240. .recalc_rate = si514_recalc_rate,
  241. .round_rate = si514_round_rate,
  242. .set_rate = si514_set_rate,
  243. };
  244. static bool si514_regmap_is_volatile(struct device *dev, unsigned int reg)
  245. {
  246. switch (reg) {
  247. case SI514_REG_CONTROL:
  248. case SI514_REG_RESET:
  249. return true;
  250. default:
  251. return false;
  252. }
  253. }
  254. static bool si514_regmap_is_writeable(struct device *dev, unsigned int reg)
  255. {
  256. switch (reg) {
  257. case SI514_REG_LP:
  258. case SI514_REG_M_FRAC1 ... SI514_REG_LS_HS_DIV:
  259. case SI514_REG_OE_STATE:
  260. case SI514_REG_RESET:
  261. case SI514_REG_CONTROL:
  262. return true;
  263. default:
  264. return false;
  265. }
  266. }
  267. static const struct regmap_config si514_regmap_config = {
  268. .reg_bits = 8,
  269. .val_bits = 8,
  270. .cache_type = REGCACHE_RBTREE,
  271. .max_register = SI514_REG_CONTROL,
  272. .writeable_reg = si514_regmap_is_writeable,
  273. .volatile_reg = si514_regmap_is_volatile,
  274. };
  275. static int si514_probe(struct i2c_client *client,
  276. const struct i2c_device_id *id)
  277. {
  278. struct clk_si514 *data;
  279. struct clk_init_data init;
  280. int err;
  281. data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
  282. if (!data)
  283. return -ENOMEM;
  284. init.ops = &si514_clk_ops;
  285. init.flags = 0;
  286. init.num_parents = 0;
  287. data->hw.init = &init;
  288. data->i2c_client = client;
  289. if (of_property_read_string(client->dev.of_node, "clock-output-names",
  290. &init.name))
  291. init.name = client->dev.of_node->name;
  292. data->regmap = devm_regmap_init_i2c(client, &si514_regmap_config);
  293. if (IS_ERR(data->regmap)) {
  294. dev_err(&client->dev, "failed to allocate register map\n");
  295. return PTR_ERR(data->regmap);
  296. }
  297. i2c_set_clientdata(client, data);
  298. err = devm_clk_hw_register(&client->dev, &data->hw);
  299. if (err) {
  300. dev_err(&client->dev, "clock registration failed\n");
  301. return err;
  302. }
  303. err = of_clk_add_hw_provider(client->dev.of_node, of_clk_hw_simple_get,
  304. &data->hw);
  305. if (err) {
  306. dev_err(&client->dev, "unable to add clk provider\n");
  307. return err;
  308. }
  309. return 0;
  310. }
  311. static int si514_remove(struct i2c_client *client)
  312. {
  313. of_clk_del_provider(client->dev.of_node);
  314. return 0;
  315. }
  316. static const struct i2c_device_id si514_id[] = {
  317. { "si514", 0 },
  318. { }
  319. };
  320. MODULE_DEVICE_TABLE(i2c, si514_id);
  321. static const struct of_device_id clk_si514_of_match[] = {
  322. { .compatible = "silabs,si514" },
  323. { },
  324. };
  325. MODULE_DEVICE_TABLE(of, clk_si514_of_match);
  326. static struct i2c_driver si514_driver = {
  327. .driver = {
  328. .name = "si514",
  329. .of_match_table = clk_si514_of_match,
  330. },
  331. .probe = si514_probe,
  332. .remove = si514_remove,
  333. .id_table = si514_id,
  334. };
  335. module_i2c_driver(si514_driver);
  336. MODULE_AUTHOR("Mike Looijmans <mike.looijmans@topic.nl>");
  337. MODULE_DESCRIPTION("Si514 driver");
  338. MODULE_LICENSE("GPL");