clk-cs2000-cp.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * CS2000 -- CIRRUS LOGIC Fractional-N Clock Synthesizer & Clock Multiplier
  4. *
  5. * Copyright (C) 2015 Renesas Electronics Corporation
  6. * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  7. */
  8. #include <linux/clk-provider.h>
  9. #include <linux/delay.h>
  10. #include <linux/clk.h>
  11. #include <linux/i2c.h>
  12. #include <linux/of_device.h>
  13. #include <linux/module.h>
  14. #define CH_MAX 4
  15. #define RATIO_REG_SIZE 4
  16. #define DEVICE_ID 0x1
  17. #define DEVICE_CTRL 0x2
  18. #define DEVICE_CFG1 0x3
  19. #define DEVICE_CFG2 0x4
  20. #define GLOBAL_CFG 0x5
  21. #define Ratio_Add(x, nth) (6 + (x * 4) + (nth))
  22. #define Ratio_Val(x, nth) ((x >> (24 - (8 * nth))) & 0xFF)
  23. #define Val_Ratio(x, nth) ((x & 0xFF) << (24 - (8 * nth)))
  24. #define FUNC_CFG1 0x16
  25. #define FUNC_CFG2 0x17
  26. /* DEVICE_ID */
  27. #define REVISION_MASK (0x7)
  28. #define REVISION_B2_B3 (0x4)
  29. #define REVISION_C1 (0x6)
  30. /* DEVICE_CTRL */
  31. #define PLL_UNLOCK (1 << 7)
  32. #define AUXOUTDIS (1 << 1)
  33. #define CLKOUTDIS (1 << 0)
  34. /* DEVICE_CFG1 */
  35. #define RSEL(x) (((x) & 0x3) << 3)
  36. #define RSEL_MASK RSEL(0x3)
  37. #define ENDEV1 (0x1)
  38. /* DEVICE_CFG2 */
  39. #define AUTORMOD (1 << 3)
  40. #define LOCKCLK(x) (((x) & 0x3) << 1)
  41. #define LOCKCLK_MASK LOCKCLK(0x3)
  42. #define FRACNSRC_MASK (1 << 0)
  43. #define FRACNSRC_STATIC (0 << 0)
  44. #define FRACNSRC_DYNAMIC (1 << 1)
  45. /* GLOBAL_CFG */
  46. #define ENDEV2 (0x1)
  47. /* FUNC_CFG1 */
  48. #define CLKSKIPEN (1 << 7)
  49. #define REFCLKDIV(x) (((x) & 0x3) << 3)
  50. #define REFCLKDIV_MASK REFCLKDIV(0x3)
  51. /* FUNC_CFG2 */
  52. #define LFRATIO_MASK (1 << 3)
  53. #define LFRATIO_20_12 (0 << 3)
  54. #define LFRATIO_12_20 (1 << 3)
  55. #define CH_SIZE_ERR(ch) ((ch < 0) || (ch >= CH_MAX))
  56. #define hw_to_priv(_hw) container_of(_hw, struct cs2000_priv, hw)
  57. #define priv_to_client(priv) (priv->client)
  58. #define priv_to_dev(priv) (&(priv_to_client(priv)->dev))
  59. #define CLK_IN 0
  60. #define REF_CLK 1
  61. #define CLK_MAX 2
  62. struct cs2000_priv {
  63. struct clk_hw hw;
  64. struct i2c_client *client;
  65. struct clk *clk_in;
  66. struct clk *ref_clk;
  67. /* suspend/resume */
  68. unsigned long saved_rate;
  69. unsigned long saved_parent_rate;
  70. };
  71. static const struct of_device_id cs2000_of_match[] = {
  72. { .compatible = "cirrus,cs2000-cp", },
  73. {},
  74. };
  75. MODULE_DEVICE_TABLE(of, cs2000_of_match);
  76. static const struct i2c_device_id cs2000_id[] = {
  77. { "cs2000-cp", },
  78. {}
  79. };
  80. MODULE_DEVICE_TABLE(i2c, cs2000_id);
  81. #define cs2000_read(priv, addr) \
  82. i2c_smbus_read_byte_data(priv_to_client(priv), addr)
  83. #define cs2000_write(priv, addr, val) \
  84. i2c_smbus_write_byte_data(priv_to_client(priv), addr, val)
  85. static int cs2000_bset(struct cs2000_priv *priv, u8 addr, u8 mask, u8 val)
  86. {
  87. s32 data;
  88. data = cs2000_read(priv, addr);
  89. if (data < 0)
  90. return data;
  91. data &= ~mask;
  92. data |= (val & mask);
  93. return cs2000_write(priv, addr, data);
  94. }
  95. static int cs2000_enable_dev_config(struct cs2000_priv *priv, bool enable)
  96. {
  97. int ret;
  98. ret = cs2000_bset(priv, DEVICE_CFG1, ENDEV1,
  99. enable ? ENDEV1 : 0);
  100. if (ret < 0)
  101. return ret;
  102. ret = cs2000_bset(priv, GLOBAL_CFG, ENDEV2,
  103. enable ? ENDEV2 : 0);
  104. if (ret < 0)
  105. return ret;
  106. ret = cs2000_bset(priv, FUNC_CFG1, CLKSKIPEN,
  107. enable ? CLKSKIPEN : 0);
  108. if (ret < 0)
  109. return ret;
  110. /* FIXME: for Static ratio mode */
  111. ret = cs2000_bset(priv, FUNC_CFG2, LFRATIO_MASK,
  112. LFRATIO_12_20);
  113. if (ret < 0)
  114. return ret;
  115. return 0;
  116. }
  117. static int cs2000_clk_in_bound_rate(struct cs2000_priv *priv,
  118. u32 rate_in)
  119. {
  120. u32 val;
  121. if (rate_in >= 32000000 && rate_in < 56000000)
  122. val = 0x0;
  123. else if (rate_in >= 16000000 && rate_in < 28000000)
  124. val = 0x1;
  125. else if (rate_in >= 8000000 && rate_in < 14000000)
  126. val = 0x2;
  127. else
  128. return -EINVAL;
  129. return cs2000_bset(priv, FUNC_CFG1,
  130. REFCLKDIV_MASK,
  131. REFCLKDIV(val));
  132. }
  133. static int cs2000_wait_pll_lock(struct cs2000_priv *priv)
  134. {
  135. struct device *dev = priv_to_dev(priv);
  136. s32 val;
  137. unsigned int i;
  138. for (i = 0; i < 256; i++) {
  139. val = cs2000_read(priv, DEVICE_CTRL);
  140. if (val < 0)
  141. return val;
  142. if (!(val & PLL_UNLOCK))
  143. return 0;
  144. udelay(1);
  145. }
  146. dev_err(dev, "pll lock failed\n");
  147. return -ETIMEDOUT;
  148. }
  149. static int cs2000_clk_out_enable(struct cs2000_priv *priv, bool enable)
  150. {
  151. /* enable both AUX_OUT, CLK_OUT */
  152. return cs2000_bset(priv, DEVICE_CTRL,
  153. (AUXOUTDIS | CLKOUTDIS),
  154. enable ? 0 :
  155. (AUXOUTDIS | CLKOUTDIS));
  156. }
  157. static u32 cs2000_rate_to_ratio(u32 rate_in, u32 rate_out)
  158. {
  159. u64 ratio;
  160. /*
  161. * ratio = rate_out / rate_in * 2^20
  162. *
  163. * To avoid over flow, rate_out is u64.
  164. * The result should be u32.
  165. */
  166. ratio = (u64)rate_out << 20;
  167. do_div(ratio, rate_in);
  168. return ratio;
  169. }
  170. static unsigned long cs2000_ratio_to_rate(u32 ratio, u32 rate_in)
  171. {
  172. u64 rate_out;
  173. /*
  174. * ratio = rate_out / rate_in * 2^20
  175. *
  176. * To avoid over flow, rate_out is u64.
  177. * The result should be u32 or unsigned long.
  178. */
  179. rate_out = (u64)ratio * rate_in;
  180. return rate_out >> 20;
  181. }
  182. static int cs2000_ratio_set(struct cs2000_priv *priv,
  183. int ch, u32 rate_in, u32 rate_out)
  184. {
  185. u32 val;
  186. unsigned int i;
  187. int ret;
  188. if (CH_SIZE_ERR(ch))
  189. return -EINVAL;
  190. val = cs2000_rate_to_ratio(rate_in, rate_out);
  191. for (i = 0; i < RATIO_REG_SIZE; i++) {
  192. ret = cs2000_write(priv,
  193. Ratio_Add(ch, i),
  194. Ratio_Val(val, i));
  195. if (ret < 0)
  196. return ret;
  197. }
  198. return 0;
  199. }
  200. static u32 cs2000_ratio_get(struct cs2000_priv *priv, int ch)
  201. {
  202. s32 tmp;
  203. u32 val;
  204. unsigned int i;
  205. val = 0;
  206. for (i = 0; i < RATIO_REG_SIZE; i++) {
  207. tmp = cs2000_read(priv, Ratio_Add(ch, i));
  208. if (tmp < 0)
  209. return 0;
  210. val |= Val_Ratio(tmp, i);
  211. }
  212. return val;
  213. }
  214. static int cs2000_ratio_select(struct cs2000_priv *priv, int ch)
  215. {
  216. int ret;
  217. if (CH_SIZE_ERR(ch))
  218. return -EINVAL;
  219. /*
  220. * FIXME
  221. *
  222. * this driver supports static ratio mode only at this point.
  223. */
  224. ret = cs2000_bset(priv, DEVICE_CFG1, RSEL_MASK, RSEL(ch));
  225. if (ret < 0)
  226. return ret;
  227. ret = cs2000_bset(priv, DEVICE_CFG2,
  228. (AUTORMOD | LOCKCLK_MASK | FRACNSRC_MASK),
  229. (LOCKCLK(ch) | FRACNSRC_STATIC));
  230. if (ret < 0)
  231. return ret;
  232. return 0;
  233. }
  234. static unsigned long cs2000_recalc_rate(struct clk_hw *hw,
  235. unsigned long parent_rate)
  236. {
  237. struct cs2000_priv *priv = hw_to_priv(hw);
  238. int ch = 0; /* it uses ch0 only at this point */
  239. u32 ratio;
  240. ratio = cs2000_ratio_get(priv, ch);
  241. return cs2000_ratio_to_rate(ratio, parent_rate);
  242. }
  243. static long cs2000_round_rate(struct clk_hw *hw, unsigned long rate,
  244. unsigned long *parent_rate)
  245. {
  246. u32 ratio;
  247. ratio = cs2000_rate_to_ratio(*parent_rate, rate);
  248. return cs2000_ratio_to_rate(ratio, *parent_rate);
  249. }
  250. static int __cs2000_set_rate(struct cs2000_priv *priv, int ch,
  251. unsigned long rate, unsigned long parent_rate)
  252. {
  253. int ret;
  254. ret = cs2000_clk_in_bound_rate(priv, parent_rate);
  255. if (ret < 0)
  256. return ret;
  257. ret = cs2000_ratio_set(priv, ch, parent_rate, rate);
  258. if (ret < 0)
  259. return ret;
  260. ret = cs2000_ratio_select(priv, ch);
  261. if (ret < 0)
  262. return ret;
  263. priv->saved_rate = rate;
  264. priv->saved_parent_rate = parent_rate;
  265. return 0;
  266. }
  267. static int cs2000_set_rate(struct clk_hw *hw,
  268. unsigned long rate, unsigned long parent_rate)
  269. {
  270. struct cs2000_priv *priv = hw_to_priv(hw);
  271. int ch = 0; /* it uses ch0 only at this point */
  272. return __cs2000_set_rate(priv, ch, rate, parent_rate);
  273. }
  274. static int cs2000_set_saved_rate(struct cs2000_priv *priv)
  275. {
  276. int ch = 0; /* it uses ch0 only at this point */
  277. return __cs2000_set_rate(priv, ch,
  278. priv->saved_rate,
  279. priv->saved_parent_rate);
  280. }
  281. static int cs2000_enable(struct clk_hw *hw)
  282. {
  283. struct cs2000_priv *priv = hw_to_priv(hw);
  284. int ret;
  285. ret = cs2000_enable_dev_config(priv, true);
  286. if (ret < 0)
  287. return ret;
  288. ret = cs2000_clk_out_enable(priv, true);
  289. if (ret < 0)
  290. return ret;
  291. ret = cs2000_wait_pll_lock(priv);
  292. if (ret < 0)
  293. return ret;
  294. return ret;
  295. }
  296. static void cs2000_disable(struct clk_hw *hw)
  297. {
  298. struct cs2000_priv *priv = hw_to_priv(hw);
  299. cs2000_enable_dev_config(priv, false);
  300. cs2000_clk_out_enable(priv, false);
  301. }
  302. static u8 cs2000_get_parent(struct clk_hw *hw)
  303. {
  304. /* always return REF_CLK */
  305. return REF_CLK;
  306. }
  307. static const struct clk_ops cs2000_ops = {
  308. .get_parent = cs2000_get_parent,
  309. .recalc_rate = cs2000_recalc_rate,
  310. .round_rate = cs2000_round_rate,
  311. .set_rate = cs2000_set_rate,
  312. .prepare = cs2000_enable,
  313. .unprepare = cs2000_disable,
  314. };
  315. static int cs2000_clk_get(struct cs2000_priv *priv)
  316. {
  317. struct device *dev = priv_to_dev(priv);
  318. struct clk *clk_in, *ref_clk;
  319. clk_in = devm_clk_get(dev, "clk_in");
  320. /* not yet provided */
  321. if (IS_ERR(clk_in))
  322. return -EPROBE_DEFER;
  323. ref_clk = devm_clk_get(dev, "ref_clk");
  324. /* not yet provided */
  325. if (IS_ERR(ref_clk))
  326. return -EPROBE_DEFER;
  327. priv->clk_in = clk_in;
  328. priv->ref_clk = ref_clk;
  329. return 0;
  330. }
  331. static int cs2000_clk_register(struct cs2000_priv *priv)
  332. {
  333. struct device *dev = priv_to_dev(priv);
  334. struct device_node *np = dev->of_node;
  335. struct clk_init_data init;
  336. const char *name = np->name;
  337. static const char *parent_names[CLK_MAX];
  338. int ch = 0; /* it uses ch0 only at this point */
  339. int rate;
  340. int ret;
  341. of_property_read_string(np, "clock-output-names", &name);
  342. /*
  343. * set default rate as 1/1.
  344. * otherwise .set_rate which setup ratio
  345. * is never called if user requests 1/1 rate
  346. */
  347. rate = clk_get_rate(priv->ref_clk);
  348. ret = __cs2000_set_rate(priv, ch, rate, rate);
  349. if (ret < 0)
  350. return ret;
  351. parent_names[CLK_IN] = __clk_get_name(priv->clk_in);
  352. parent_names[REF_CLK] = __clk_get_name(priv->ref_clk);
  353. init.name = name;
  354. init.ops = &cs2000_ops;
  355. init.flags = CLK_SET_RATE_GATE;
  356. init.parent_names = parent_names;
  357. init.num_parents = ARRAY_SIZE(parent_names);
  358. priv->hw.init = &init;
  359. ret = clk_hw_register(dev, &priv->hw);
  360. if (ret)
  361. return ret;
  362. ret = of_clk_add_hw_provider(np, of_clk_hw_simple_get, &priv->hw);
  363. if (ret < 0) {
  364. clk_hw_unregister(&priv->hw);
  365. return ret;
  366. }
  367. return 0;
  368. }
  369. static int cs2000_version_print(struct cs2000_priv *priv)
  370. {
  371. struct device *dev = priv_to_dev(priv);
  372. s32 val;
  373. const char *revision;
  374. val = cs2000_read(priv, DEVICE_ID);
  375. if (val < 0)
  376. return val;
  377. /* CS2000 should be 0x0 */
  378. if (val >> 3)
  379. return -EIO;
  380. switch (val & REVISION_MASK) {
  381. case REVISION_B2_B3:
  382. revision = "B2 / B3";
  383. break;
  384. case REVISION_C1:
  385. revision = "C1";
  386. break;
  387. default:
  388. return -EIO;
  389. }
  390. dev_info(dev, "revision - %s\n", revision);
  391. return 0;
  392. }
  393. static int cs2000_remove(struct i2c_client *client)
  394. {
  395. struct cs2000_priv *priv = i2c_get_clientdata(client);
  396. struct device *dev = priv_to_dev(priv);
  397. struct device_node *np = dev->of_node;
  398. of_clk_del_provider(np);
  399. clk_hw_unregister(&priv->hw);
  400. return 0;
  401. }
  402. static int cs2000_probe(struct i2c_client *client,
  403. const struct i2c_device_id *id)
  404. {
  405. struct cs2000_priv *priv;
  406. struct device *dev = &client->dev;
  407. int ret;
  408. priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
  409. if (!priv)
  410. return -ENOMEM;
  411. priv->client = client;
  412. i2c_set_clientdata(client, priv);
  413. ret = cs2000_clk_get(priv);
  414. if (ret < 0)
  415. return ret;
  416. ret = cs2000_clk_register(priv);
  417. if (ret < 0)
  418. return ret;
  419. ret = cs2000_version_print(priv);
  420. if (ret < 0)
  421. goto probe_err;
  422. return 0;
  423. probe_err:
  424. cs2000_remove(client);
  425. return ret;
  426. }
  427. static int __maybe_unused cs2000_resume(struct device *dev)
  428. {
  429. struct cs2000_priv *priv = dev_get_drvdata(dev);
  430. return cs2000_set_saved_rate(priv);
  431. }
  432. static const struct dev_pm_ops cs2000_pm_ops = {
  433. SET_LATE_SYSTEM_SLEEP_PM_OPS(NULL, cs2000_resume)
  434. };
  435. static struct i2c_driver cs2000_driver = {
  436. .driver = {
  437. .name = "cs2000-cp",
  438. .pm = &cs2000_pm_ops,
  439. .of_match_table = cs2000_of_match,
  440. },
  441. .probe = cs2000_probe,
  442. .remove = cs2000_remove,
  443. .id_table = cs2000_id,
  444. };
  445. module_i2c_driver(cs2000_driver);
  446. MODULE_DESCRIPTION("CS2000-CP driver");
  447. MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
  448. MODULE_LICENSE("GPL v2");