Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Helper routines for R-Car sound ADG. |
| 3 | * |
| 4 | * Copyright (C) 2013 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> |
| 5 | * |
| 6 | * This file is subject to the terms and conditions of the GNU General Public |
| 7 | * License. See the file "COPYING" in the main directory of this archive |
| 8 | * for more details. |
| 9 | */ |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 10 | #include <linux/clk-provider.h> |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 11 | #include "rsnd.h" |
| 12 | |
| 13 | #define CLKA 0 |
| 14 | #define CLKB 1 |
| 15 | #define CLKC 2 |
| 16 | #define CLKI 3 |
| 17 | #define CLKMAX 4 |
| 18 | |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 19 | #define CLKOUT 0 |
| 20 | #define CLKOUT1 1 |
| 21 | #define CLKOUT2 2 |
| 22 | #define CLKOUT3 3 |
| 23 | #define CLKOUTMAX 4 |
| 24 | |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 25 | #define BRRx_MASK(x) (0x3FF & x) |
| 26 | |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 27 | static struct rsnd_mod_ops adg_ops = { |
| 28 | .name = "adg", |
| 29 | }; |
| 30 | |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 31 | struct rsnd_adg { |
| 32 | struct clk *clk[CLKMAX]; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 33 | struct clk *clkout[CLKOUTMAX]; |
| 34 | struct clk_onecell_data onecell; |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 35 | struct rsnd_mod mod; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 36 | |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 37 | int rbga_rate_for_441khz; /* RBGA */ |
| 38 | int rbgb_rate_for_48khz; /* RBGB */ |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 39 | }; |
| 40 | |
| 41 | #define for_each_rsnd_clk(pos, adg, i) \ |
Kuninori Morimoto | 00463c11 | 2014-02-11 17:15:51 -0800 | [diff] [blame] | 42 | for (i = 0; \ |
| 43 | (i < CLKMAX) && \ |
| 44 | ((pos) = adg->clk[i]); \ |
| 45 | i++) |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 46 | #define for_each_rsnd_clkout(pos, adg, i) \ |
| 47 | for (i = 0; \ |
| 48 | (i < CLKOUTMAX) && \ |
| 49 | ((pos) = adg->clkout[i]); \ |
| 50 | i++) |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 51 | #define rsnd_priv_to_adg(priv) ((struct rsnd_adg *)(priv)->adg) |
| 52 | |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 53 | static u32 rsnd_adg_calculate_rbgx(unsigned long div) |
| 54 | { |
| 55 | int i, ratio; |
| 56 | |
| 57 | if (!div) |
| 58 | return 0; |
| 59 | |
| 60 | for (i = 3; i >= 0; i--) { |
| 61 | ratio = 2 << (i * 2); |
| 62 | if (0 == (div % ratio)) |
| 63 | return (u32)((i << 8) | ((div / ratio) - 1)); |
| 64 | } |
| 65 | |
| 66 | return ~0; |
| 67 | } |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 68 | |
Kuninori Morimoto | 8467ded | 2014-03-02 23:43:33 -0800 | [diff] [blame] | 69 | static u32 rsnd_adg_ssi_ws_timing_gen2(struct rsnd_dai_stream *io) |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 70 | { |
Kuninori Morimoto | 8467ded | 2014-03-02 23:43:33 -0800 | [diff] [blame] | 71 | struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 72 | int id = rsnd_mod_id(mod); |
| 73 | int ws = id; |
| 74 | |
Kuninori Morimoto | b415b4d | 2015-10-22 03:15:46 +0000 | [diff] [blame] | 75 | if (rsnd_ssi_is_pin_sharing(io)) { |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 76 | switch (id) { |
| 77 | case 1: |
| 78 | case 2: |
| 79 | ws = 0; |
| 80 | break; |
| 81 | case 4: |
| 82 | ws = 3; |
| 83 | break; |
| 84 | case 8: |
| 85 | ws = 7; |
| 86 | break; |
| 87 | } |
| 88 | } |
| 89 | |
| 90 | return (0x6 + ws) << 8; |
| 91 | } |
| 92 | |
Kuninori Morimoto | f708d94 | 2015-01-15 08:07:19 +0000 | [diff] [blame] | 93 | int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_mod *mod, |
Kuninori Morimoto | bff58ea | 2014-05-08 17:44:49 -0700 | [diff] [blame] | 94 | struct rsnd_dai_stream *io) |
| 95 | { |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 96 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| 97 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
| 98 | struct rsnd_mod *adg_mod = rsnd_mod_get(adg); |
Kuninori Morimoto | bff58ea | 2014-05-08 17:44:49 -0700 | [diff] [blame] | 99 | int id = rsnd_mod_id(mod); |
| 100 | int shift = (id % 2) ? 16 : 0; |
| 101 | u32 mask, val; |
| 102 | |
| 103 | val = rsnd_adg_ssi_ws_timing_gen2(io); |
| 104 | |
| 105 | val = val << shift; |
| 106 | mask = 0xffff << shift; |
| 107 | |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 108 | rsnd_mod_bset(adg_mod, CMDOUT_TIMSEL, mask, val); |
Kuninori Morimoto | bff58ea | 2014-05-08 17:44:49 -0700 | [diff] [blame] | 109 | |
| 110 | return 0; |
| 111 | } |
| 112 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 113 | static int rsnd_adg_set_src_timsel_gen2(struct rsnd_mod *src_mod, |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 114 | struct rsnd_dai_stream *io, |
| 115 | u32 timsel) |
| 116 | { |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 117 | struct rsnd_priv *priv = rsnd_mod_to_priv(src_mod); |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 118 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
| 119 | struct rsnd_mod *adg_mod = rsnd_mod_get(adg); |
Kuninori Morimoto | 985a4f6 | 2015-01-15 08:06:49 +0000 | [diff] [blame] | 120 | int is_play = rsnd_io_is_play(io); |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 121 | int id = rsnd_mod_id(src_mod); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 122 | int shift = (id % 2) ? 16 : 0; |
| 123 | u32 mask, ws; |
| 124 | u32 in, out; |
| 125 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 126 | rsnd_mod_confirm_src(src_mod); |
| 127 | |
Kuninori Morimoto | 8467ded | 2014-03-02 23:43:33 -0800 | [diff] [blame] | 128 | ws = rsnd_adg_ssi_ws_timing_gen2(io); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 129 | |
| 130 | in = (is_play) ? timsel : ws; |
| 131 | out = (is_play) ? ws : timsel; |
| 132 | |
| 133 | in = in << shift; |
| 134 | out = out << shift; |
| 135 | mask = 0xffff << shift; |
| 136 | |
| 137 | switch (id / 2) { |
| 138 | case 0: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 139 | rsnd_mod_bset(adg_mod, SRCIN_TIMSEL0, mask, in); |
| 140 | rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL0, mask, out); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 141 | break; |
| 142 | case 1: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 143 | rsnd_mod_bset(adg_mod, SRCIN_TIMSEL1, mask, in); |
| 144 | rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL1, mask, out); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 145 | break; |
| 146 | case 2: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 147 | rsnd_mod_bset(adg_mod, SRCIN_TIMSEL2, mask, in); |
| 148 | rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL2, mask, out); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 149 | break; |
| 150 | case 3: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 151 | rsnd_mod_bset(adg_mod, SRCIN_TIMSEL3, mask, in); |
| 152 | rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL3, mask, out); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 153 | break; |
| 154 | case 4: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 155 | rsnd_mod_bset(adg_mod, SRCIN_TIMSEL4, mask, in); |
| 156 | rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL4, mask, out); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 157 | break; |
| 158 | } |
| 159 | |
| 160 | return 0; |
| 161 | } |
| 162 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 163 | int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *src_mod, |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 164 | struct rsnd_dai_stream *io, |
| 165 | unsigned int src_rate, |
| 166 | unsigned int dst_rate) |
| 167 | { |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 168 | struct rsnd_priv *priv = rsnd_mod_to_priv(src_mod); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 169 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 170 | struct rsnd_mod *adg_mod = rsnd_mod_get(adg); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 171 | struct device *dev = rsnd_priv_to_dev(priv); |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 172 | int idx, sel, div, step, ret; |
| 173 | u32 val, en; |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 174 | unsigned int min, diff; |
| 175 | unsigned int sel_rate [] = { |
| 176 | clk_get_rate(adg->clk[CLKA]), /* 0000: CLKA */ |
| 177 | clk_get_rate(adg->clk[CLKB]), /* 0001: CLKB */ |
| 178 | clk_get_rate(adg->clk[CLKC]), /* 0010: CLKC */ |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 179 | adg->rbga_rate_for_441khz, /* 0011: RBGA */ |
| 180 | adg->rbgb_rate_for_48khz, /* 0100: RBGB */ |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 181 | }; |
| 182 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 183 | rsnd_mod_confirm_src(src_mod); |
| 184 | |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 185 | min = ~0; |
| 186 | val = 0; |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 187 | en = 0; |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 188 | for (sel = 0; sel < ARRAY_SIZE(sel_rate); sel++) { |
| 189 | idx = 0; |
| 190 | step = 2; |
| 191 | |
| 192 | if (!sel_rate[sel]) |
| 193 | continue; |
| 194 | |
| 195 | for (div = 2; div <= 98304; div += step) { |
| 196 | diff = abs(src_rate - sel_rate[sel] / div); |
| 197 | if (min > diff) { |
| 198 | val = (sel << 8) | idx; |
| 199 | min = diff; |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 200 | en = 1 << (sel + 1); /* fixme */ |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | /* |
| 204 | * step of 0_0000 / 0_0001 / 0_1101 |
| 205 | * are out of order |
| 206 | */ |
| 207 | if ((idx > 2) && (idx % 2)) |
| 208 | step *= 2; |
| 209 | if (idx == 0x1c) { |
| 210 | div += step; |
| 211 | step *= 2; |
| 212 | } |
| 213 | idx++; |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | if (min == ~0) { |
| 218 | dev_err(dev, "no Input clock\n"); |
| 219 | return -EIO; |
| 220 | } |
| 221 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 222 | ret = rsnd_adg_set_src_timsel_gen2(src_mod, io, val); |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 223 | if (ret < 0) { |
| 224 | dev_err(dev, "timsel error\n"); |
| 225 | return ret; |
| 226 | } |
| 227 | |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 228 | rsnd_mod_bset(adg_mod, DIV_EN, en, en); |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 229 | |
Kuninori Morimoto | d2c4b80 | 2015-03-19 04:14:45 +0000 | [diff] [blame] | 230 | dev_dbg(dev, "convert rate %d <-> %d\n", src_rate, dst_rate); |
| 231 | |
Kuninori Morimoto | ee2c828 | 2014-02-11 21:04:12 -0800 | [diff] [blame] | 232 | return 0; |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 233 | } |
| 234 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 235 | int rsnd_adg_set_convert_timing_gen2(struct rsnd_mod *src_mod, |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 236 | struct rsnd_dai_stream *io) |
| 237 | { |
Kuninori Morimoto | 8467ded | 2014-03-02 23:43:33 -0800 | [diff] [blame] | 238 | u32 val = rsnd_adg_ssi_ws_timing_gen2(io); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 239 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 240 | rsnd_mod_confirm_src(src_mod); |
| 241 | |
| 242 | return rsnd_adg_set_src_timsel_gen2(src_mod, io, val); |
Kuninori Morimoto | 629509c | 2014-01-23 18:42:00 -0800 | [diff] [blame] | 243 | } |
| 244 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 245 | static void rsnd_adg_set_ssi_clk(struct rsnd_mod *ssi_mod, u32 val) |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 246 | { |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 247 | struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 248 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
| 249 | struct rsnd_mod *adg_mod = rsnd_mod_get(adg); |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 250 | int id = rsnd_mod_id(ssi_mod); |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 251 | int shift = (id % 4) * 8; |
| 252 | u32 mask = 0xFF << shift; |
| 253 | |
Kuninori Morimoto | f1df122 | 2015-09-10 07:03:08 +0000 | [diff] [blame] | 254 | rsnd_mod_confirm_ssi(ssi_mod); |
| 255 | |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 256 | val = val << shift; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 257 | |
| 258 | /* |
| 259 | * SSI 8 is not connected to ADG. |
| 260 | * it works with SSI 7 |
| 261 | */ |
| 262 | if (id == 8) |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 263 | return; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 264 | |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 265 | switch (id / 4) { |
| 266 | case 0: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 267 | rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL0, mask, val); |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 268 | break; |
| 269 | case 1: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 270 | rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL1, mask, val); |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 271 | break; |
| 272 | case 2: |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 273 | rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL2, mask, val); |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 274 | break; |
| 275 | } |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | int rsnd_adg_ssi_clk_stop(struct rsnd_mod *mod) |
| 279 | { |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 280 | /* |
| 281 | * "mod" = "ssi" here. |
| 282 | * we can get "ssi id" from mod |
| 283 | */ |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 284 | rsnd_adg_set_ssi_clk(mod, 0); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 285 | |
| 286 | return 0; |
| 287 | } |
| 288 | |
| 289 | int rsnd_adg_ssi_clk_try_start(struct rsnd_mod *mod, unsigned int rate) |
| 290 | { |
| 291 | struct rsnd_priv *priv = rsnd_mod_to_priv(mod); |
| 292 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
| 293 | struct device *dev = rsnd_priv_to_dev(priv); |
| 294 | struct clk *clk; |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 295 | int i; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 296 | u32 data; |
| 297 | int sel_table[] = { |
| 298 | [CLKA] = 0x1, |
| 299 | [CLKB] = 0x2, |
| 300 | [CLKC] = 0x3, |
| 301 | [CLKI] = 0x0, |
| 302 | }; |
| 303 | |
| 304 | dev_dbg(dev, "request clock = %d\n", rate); |
| 305 | |
| 306 | /* |
| 307 | * find suitable clock from |
| 308 | * AUDIO_CLKA/AUDIO_CLKB/AUDIO_CLKC/AUDIO_CLKI. |
| 309 | */ |
| 310 | data = 0; |
| 311 | for_each_rsnd_clk(clk, adg, i) { |
| 312 | if (rate == clk_get_rate(clk)) { |
| 313 | data = sel_table[i]; |
| 314 | goto found_clock; |
| 315 | } |
| 316 | } |
| 317 | |
| 318 | /* |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 319 | * find divided clock from BRGA/BRGB |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 320 | */ |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 321 | if (rate == adg->rbga_rate_for_441khz) { |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 322 | data = 0x10; |
| 323 | goto found_clock; |
| 324 | } |
| 325 | |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 326 | if (rate == adg->rbgb_rate_for_48khz) { |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 327 | data = 0x20; |
| 328 | goto found_clock; |
| 329 | } |
| 330 | |
| 331 | return -EIO; |
| 332 | |
| 333 | found_clock: |
| 334 | |
| 335 | /* |
| 336 | * This "mod" = "ssi" here. |
| 337 | * we can get "ssi id" from mod |
| 338 | */ |
Kuninori Morimoto | e337853 | 2013-12-19 19:26:31 -0800 | [diff] [blame] | 339 | rsnd_adg_set_ssi_clk(mod, data); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 340 | |
Kuninori Morimoto | 3af6c3a | 2015-09-10 07:04:06 +0000 | [diff] [blame] | 341 | dev_dbg(dev, "ADG: %s[%d] selects 0x%x for %d\n", |
| 342 | rsnd_mod_name(mod), rsnd_mod_id(mod), |
| 343 | data, rate); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 344 | |
| 345 | return 0; |
| 346 | } |
| 347 | |
Kuninori Morimoto | 248e88c | 2015-09-10 07:04:24 +0000 | [diff] [blame] | 348 | static void rsnd_adg_get_clkin(struct rsnd_priv *priv, |
| 349 | struct rsnd_adg *adg) |
| 350 | { |
| 351 | struct device *dev = rsnd_priv_to_dev(priv); |
| 352 | struct clk *clk; |
| 353 | static const char * const clk_name[] = { |
| 354 | [CLKA] = "clk_a", |
| 355 | [CLKB] = "clk_b", |
| 356 | [CLKC] = "clk_c", |
| 357 | [CLKI] = "clk_i", |
| 358 | }; |
Kuninori Morimoto | 68a5502 | 2015-11-05 08:51:15 +0000 | [diff] [blame] | 359 | int i, ret; |
Kuninori Morimoto | 248e88c | 2015-09-10 07:04:24 +0000 | [diff] [blame] | 360 | |
| 361 | for (i = 0; i < CLKMAX; i++) { |
| 362 | clk = devm_clk_get(dev, clk_name[i]); |
| 363 | adg->clk[i] = IS_ERR(clk) ? NULL : clk; |
| 364 | } |
| 365 | |
Kuninori Morimoto | 68a5502 | 2015-11-05 08:51:15 +0000 | [diff] [blame] | 366 | for_each_rsnd_clk(clk, adg, i) { |
| 367 | ret = clk_prepare_enable(clk); |
| 368 | if (ret < 0) |
| 369 | dev_warn(dev, "can't use clk %d\n", i); |
| 370 | |
Kuninori Morimoto | 248e88c | 2015-09-10 07:04:24 +0000 | [diff] [blame] | 371 | dev_dbg(dev, "clk %d : %p : %ld\n", i, clk, clk_get_rate(clk)); |
Kuninori Morimoto | 68a5502 | 2015-11-05 08:51:15 +0000 | [diff] [blame] | 372 | } |
Kuninori Morimoto | 248e88c | 2015-09-10 07:04:24 +0000 | [diff] [blame] | 373 | } |
| 374 | |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 375 | static void rsnd_adg_get_clkout(struct rsnd_priv *priv, |
| 376 | struct rsnd_adg *adg) |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 377 | { |
| 378 | struct clk *clk; |
Kuninori Morimoto | 5c6901d | 2015-09-10 07:03:25 +0000 | [diff] [blame] | 379 | struct rsnd_mod *adg_mod = rsnd_mod_get(adg); |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 380 | struct device *dev = rsnd_priv_to_dev(priv); |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 381 | struct device_node *np = dev->of_node; |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 382 | u32 ckr, rbgx, rbga, rbgb; |
Geert Uytterhoeven | 8b27418 | 2015-10-28 16:03:48 +0100 | [diff] [blame] | 383 | u32 rate, req_rate = 0, div; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 384 | uint32_t count = 0; |
| 385 | unsigned long req_48kHz_rate, req_441kHz_rate; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 386 | int i; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 387 | const char *parent_clk_name = NULL; |
| 388 | static const char * const clkout_name[] = { |
| 389 | [CLKOUT] = "audio_clkout", |
| 390 | [CLKOUT1] = "audio_clkout1", |
| 391 | [CLKOUT2] = "audio_clkout2", |
| 392 | [CLKOUT3] = "audio_clkout3", |
| 393 | }; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 394 | int brg_table[] = { |
| 395 | [CLKA] = 0x0, |
| 396 | [CLKB] = 0x1, |
| 397 | [CLKC] = 0x4, |
| 398 | [CLKI] = 0x2, |
| 399 | }; |
| 400 | |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 401 | of_property_read_u32(np, "#clock-cells", &count); |
| 402 | |
| 403 | /* |
| 404 | * ADG supports BRRA/BRRB output only |
| 405 | * this means all clkout0/1/2/3 will be same rate |
| 406 | */ |
| 407 | of_property_read_u32(np, "clock-frequency", &req_rate); |
| 408 | req_48kHz_rate = 0; |
| 409 | req_441kHz_rate = 0; |
| 410 | if (0 == (req_rate % 44100)) |
| 411 | req_441kHz_rate = req_rate; |
| 412 | if (0 == (req_rate % 48000)) |
| 413 | req_48kHz_rate = req_rate; |
| 414 | |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 415 | /* |
| 416 | * This driver is assuming that AUDIO_CLKA/AUDIO_CLKB/AUDIO_CLKC |
| 417 | * have 44.1kHz or 48kHz base clocks for now. |
| 418 | * |
| 419 | * SSI itself can divide parent clock by 1/1 - 1/16 |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 420 | * see |
| 421 | * rsnd_adg_ssi_clk_try_start() |
Kuninori Morimoto | 5c6901d | 2015-09-10 07:03:25 +0000 | [diff] [blame] | 422 | * rsnd_ssi_master_clk_start() |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 423 | */ |
| 424 | ckr = 0; |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 425 | rbga = 2; /* default 1/6 */ |
| 426 | rbgb = 2; /* default 1/6 */ |
| 427 | adg->rbga_rate_for_441khz = 0; |
| 428 | adg->rbgb_rate_for_48khz = 0; |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 429 | for_each_rsnd_clk(clk, adg, i) { |
| 430 | rate = clk_get_rate(clk); |
| 431 | |
| 432 | if (0 == rate) /* not used */ |
| 433 | continue; |
| 434 | |
| 435 | /* RBGA */ |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 436 | if (!adg->rbga_rate_for_441khz && (0 == rate % 44100)) { |
| 437 | div = 6; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 438 | if (req_441kHz_rate) |
| 439 | div = rate / req_441kHz_rate; |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 440 | rbgx = rsnd_adg_calculate_rbgx(div); |
| 441 | if (BRRx_MASK(rbgx) == rbgx) { |
| 442 | rbga = rbgx; |
| 443 | adg->rbga_rate_for_441khz = rate / div; |
| 444 | ckr |= brg_table[i] << 20; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 445 | if (req_441kHz_rate) |
| 446 | parent_clk_name = __clk_get_name(clk); |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 447 | } |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 448 | } |
| 449 | |
| 450 | /* RBGB */ |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 451 | if (!adg->rbgb_rate_for_48khz && (0 == rate % 48000)) { |
| 452 | div = 6; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 453 | if (req_48kHz_rate) |
| 454 | div = rate / req_48kHz_rate; |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 455 | rbgx = rsnd_adg_calculate_rbgx(div); |
| 456 | if (BRRx_MASK(rbgx) == rbgx) { |
| 457 | rbgb = rbgx; |
| 458 | adg->rbgb_rate_for_48khz = rate / div; |
| 459 | ckr |= brg_table[i] << 16; |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 460 | if (req_48kHz_rate) { |
| 461 | parent_clk_name = __clk_get_name(clk); |
| 462 | ckr |= 0x80000000; |
| 463 | } |
| 464 | } |
| 465 | } |
| 466 | } |
| 467 | |
| 468 | /* |
| 469 | * ADG supports BRRA/BRRB output only. |
| 470 | * this means all clkout0/1/2/3 will be * same rate |
| 471 | */ |
| 472 | |
| 473 | /* |
| 474 | * for clkout |
| 475 | */ |
| 476 | if (!count) { |
Kuninori Morimoto | 462c30b | 2015-09-15 02:44:37 +0000 | [diff] [blame] | 477 | clk = clk_register_fixed_rate(dev, clkout_name[CLKOUT], |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 478 | parent_clk_name, |
| 479 | (parent_clk_name) ? |
| 480 | 0 : CLK_IS_ROOT, req_rate); |
| 481 | if (!IS_ERR(clk)) { |
| 482 | adg->clkout[CLKOUT] = clk; |
| 483 | of_clk_add_provider(np, of_clk_src_simple_get, clk); |
| 484 | } |
| 485 | } |
| 486 | /* |
| 487 | * for clkout0/1/2/3 |
| 488 | */ |
| 489 | else { |
| 490 | for (i = 0; i < CLKOUTMAX; i++) { |
| 491 | clk = clk_register_fixed_rate(dev, clkout_name[i], |
| 492 | parent_clk_name, |
| 493 | (parent_clk_name) ? |
| 494 | 0 : CLK_IS_ROOT, |
| 495 | req_rate); |
| 496 | if (!IS_ERR(clk)) { |
| 497 | adg->onecell.clks = adg->clkout; |
| 498 | adg->onecell.clk_num = CLKOUTMAX; |
| 499 | |
| 500 | adg->clkout[i] = clk; |
| 501 | |
| 502 | of_clk_add_provider(np, of_clk_src_onecell_get, |
| 503 | &adg->onecell); |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 504 | } |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 505 | } |
| 506 | } |
| 507 | |
Kuninori Morimoto | 5c6901d | 2015-09-10 07:03:25 +0000 | [diff] [blame] | 508 | rsnd_mod_bset(adg_mod, SSICKR, 0x00FF0000, ckr); |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 509 | rsnd_mod_write(adg_mod, BRRA, rbga); |
| 510 | rsnd_mod_write(adg_mod, BRRB, rbgb); |
| 511 | |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 512 | for_each_rsnd_clkout(clk, adg, i) |
| 513 | dev_dbg(dev, "clkout %d : %p : %ld\n", i, clk, clk_get_rate(clk)); |
Kuninori Morimoto | eae6fff | 2015-09-10 07:03:48 +0000 | [diff] [blame] | 514 | dev_dbg(dev, "SSICKR = 0x%08x, BRRA/BRRB = 0x%x/0x%x\n", |
| 515 | ckr, rbga, rbgb); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 516 | } |
| 517 | |
| 518 | int rsnd_adg_probe(struct platform_device *pdev, |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 519 | struct rsnd_priv *priv) |
| 520 | { |
| 521 | struct rsnd_adg *adg; |
| 522 | struct device *dev = rsnd_priv_to_dev(priv); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 523 | |
| 524 | adg = devm_kzalloc(dev, sizeof(*adg), GFP_KERNEL); |
| 525 | if (!adg) { |
| 526 | dev_err(dev, "ADG allocate failed\n"); |
| 527 | return -ENOMEM; |
| 528 | } |
| 529 | |
Kuninori Morimoto | 1665a9e | 2015-09-10 07:02:39 +0000 | [diff] [blame] | 530 | /* |
| 531 | * ADG is special module. |
| 532 | * Use ADG mod without rsnd_mod_init() to make debug easy |
| 533 | * for rsnd_write/rsnd_read |
| 534 | */ |
| 535 | adg->mod.ops = &adg_ops; |
| 536 | adg->mod.priv = priv; |
| 537 | |
Kuninori Morimoto | 248e88c | 2015-09-10 07:04:24 +0000 | [diff] [blame] | 538 | rsnd_adg_get_clkin(priv, adg); |
Kuninori Morimoto | 2a46db4 | 2015-09-10 07:04:45 +0000 | [diff] [blame] | 539 | rsnd_adg_get_clkout(priv, adg); |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 540 | |
| 541 | priv->adg = adg; |
| 542 | |
Kuninori Morimoto | dfc9403 | 2013-07-21 21:36:46 -0700 | [diff] [blame] | 543 | return 0; |
| 544 | } |
Kuninori Morimoto | 68a5502 | 2015-11-05 08:51:15 +0000 | [diff] [blame] | 545 | |
| 546 | void rsnd_adg_remove(struct platform_device *pdev, |
| 547 | struct rsnd_priv *priv) |
| 548 | { |
| 549 | struct rsnd_adg *adg = rsnd_priv_to_adg(priv); |
| 550 | struct clk *clk; |
| 551 | int i; |
| 552 | |
| 553 | for_each_rsnd_clk(clk, adg, i) { |
| 554 | clk_disable_unprepare(clk); |
| 555 | } |
| 556 | } |