1 /* 2 * Renesas R-Car DVC support 3 * 4 * Copyright (C) 2014 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include "rsnd.h" 12 13 #define RSND_DVC_NAME_SIZE 16 14 15 #define DVC_NAME "dvc" 16 17 struct rsnd_dvc { 18 struct rsnd_dvc_platform_info *info; /* rcar_snd.h */ 19 struct rsnd_mod mod; 20 struct rsnd_kctrl_cfg_m volume; 21 struct rsnd_kctrl_cfg_m mute; 22 struct rsnd_kctrl_cfg_s ren; /* Ramp Enable */ 23 struct rsnd_kctrl_cfg_s rup; /* Ramp Rate Up */ 24 struct rsnd_kctrl_cfg_s rdown; /* Ramp Rate Down */ 25 }; 26 27 #define rsnd_mod_to_dvc(_mod) \ 28 container_of((_mod), struct rsnd_dvc, mod) 29 30 #define for_each_rsnd_dvc(pos, priv, i) \ 31 for ((i) = 0; \ 32 ((i) < rsnd_dvc_nr(priv)) && \ 33 ((pos) = (struct rsnd_dvc *)(priv)->dvc + i); \ 34 i++) 35 36 static const char const *dvc_ramp_rate[] = { 37 "128 dB/1 step", /* 00000 */ 38 "64 dB/1 step", /* 00001 */ 39 "32 dB/1 step", /* 00010 */ 40 "16 dB/1 step", /* 00011 */ 41 "8 dB/1 step", /* 00100 */ 42 "4 dB/1 step", /* 00101 */ 43 "2 dB/1 step", /* 00110 */ 44 "1 dB/1 step", /* 00111 */ 45 "0.5 dB/1 step", /* 01000 */ 46 "0.25 dB/1 step", /* 01001 */ 47 "0.125 dB/1 step", /* 01010 */ 48 "0.125 dB/2 steps", /* 01011 */ 49 "0.125 dB/4 steps", /* 01100 */ 50 "0.125 dB/8 steps", /* 01101 */ 51 "0.125 dB/16 steps", /* 01110 */ 52 "0.125 dB/32 steps", /* 01111 */ 53 "0.125 dB/64 steps", /* 10000 */ 54 "0.125 dB/128 steps", /* 10001 */ 55 "0.125 dB/256 steps", /* 10010 */ 56 "0.125 dB/512 steps", /* 10011 */ 57 "0.125 dB/1024 steps", /* 10100 */ 58 "0.125 dB/2048 steps", /* 10101 */ 59 "0.125 dB/4096 steps", /* 10110 */ 60 "0.125 dB/8192 steps", /* 10111 */ 61 }; 62 63 static void rsnd_dvc_volume_update(struct rsnd_mod *mod) 64 { 65 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 66 u32 val[RSND_DVC_CHANNELS]; 67 u32 dvucr = 0; 68 u32 mute = 0; 69 int i; 70 71 for (i = 0; i < dvc->mute.cfg.size; i++) 72 mute |= (!!dvc->mute.cfg.val[i]) << i; 73 74 /* Disable DVC Register access */ 75 rsnd_mod_write(mod, DVC_DVUER, 0); 76 77 /* Enable Ramp */ 78 if (dvc->ren.val) { 79 dvucr |= 0x10; 80 81 /* Digital Volume Max */ 82 for (i = 0; i < RSND_DVC_CHANNELS; i++) 83 val[i] = dvc->volume.cfg.max; 84 85 rsnd_mod_write(mod, DVC_VRCTR, 0xff); 86 rsnd_mod_write(mod, DVC_VRPDR, dvc->rup.val << 8 | 87 dvc->rdown.val); 88 /* 89 * FIXME !! 90 * use scale-downed Digital Volume 91 * as Volume Ramp 92 * 7F FFFF -> 3FF 93 */ 94 rsnd_mod_write(mod, DVC_VRDBR, 95 0x3ff - (dvc->volume.val[0] >> 13)); 96 97 } else { 98 for (i = 0; i < RSND_DVC_CHANNELS; i++) 99 val[i] = dvc->volume.val[i]; 100 } 101 102 /* Enable Digital Volume */ 103 dvucr |= 0x100; 104 rsnd_mod_write(mod, DVC_VOL0R, val[0]); 105 rsnd_mod_write(mod, DVC_VOL1R, val[1]); 106 107 /* Enable Mute */ 108 if (mute) { 109 dvucr |= 0x1; 110 rsnd_mod_write(mod, DVC_ZCMCR, mute); 111 } 112 113 rsnd_mod_write(mod, DVC_DVUCR, dvucr); 114 115 /* Enable DVC Register access */ 116 rsnd_mod_write(mod, DVC_DVUER, 1); 117 } 118 119 static int rsnd_dvc_probe_gen2(struct rsnd_mod *mod, 120 struct rsnd_priv *priv) 121 { 122 struct device *dev = rsnd_priv_to_dev(priv); 123 124 dev_dbg(dev, "%s[%d] (Gen2) is probed\n", 125 rsnd_mod_name(mod), rsnd_mod_id(mod)); 126 127 return 0; 128 } 129 130 static int rsnd_dvc_remove_gen2(struct rsnd_mod *mod, 131 struct rsnd_priv *priv) 132 { 133 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 134 135 rsnd_kctrl_remove(dvc->volume); 136 rsnd_kctrl_remove(dvc->mute); 137 rsnd_kctrl_remove(dvc->ren); 138 rsnd_kctrl_remove(dvc->rup); 139 rsnd_kctrl_remove(dvc->rdown); 140 141 return 0; 142 } 143 144 static int rsnd_dvc_init(struct rsnd_mod *dvc_mod, 145 struct rsnd_priv *priv) 146 { 147 struct rsnd_dai_stream *io = rsnd_mod_to_io(dvc_mod); 148 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); 149 struct device *dev = rsnd_priv_to_dev(priv); 150 int dvc_id = rsnd_mod_id(dvc_mod); 151 int src_id = rsnd_mod_id(src_mod); 152 u32 route[] = { 153 [0] = 0x30000, 154 [1] = 0x30001, 155 [2] = 0x40000, 156 [3] = 0x10000, 157 [4] = 0x20000, 158 [5] = 0x40100 159 }; 160 161 if (src_id >= ARRAY_SIZE(route)) { 162 dev_err(dev, "DVC%d isn't connected to SRC%d\n", dvc_id, src_id); 163 return -EINVAL; 164 } 165 166 rsnd_mod_hw_start(dvc_mod); 167 168 /* 169 * fixme 170 * it doesn't support CTU/MIX 171 */ 172 rsnd_mod_write(dvc_mod, CMD_ROUTE_SLCT, route[src_id]); 173 174 rsnd_mod_write(dvc_mod, DVC_SWRSR, 0); 175 rsnd_mod_write(dvc_mod, DVC_SWRSR, 1); 176 177 rsnd_mod_write(dvc_mod, DVC_DVUIR, 1); 178 179 rsnd_mod_write(dvc_mod, DVC_ADINR, rsnd_get_adinr(dvc_mod)); 180 181 /* ch0/ch1 Volume */ 182 rsnd_dvc_volume_update(dvc_mod); 183 184 rsnd_mod_write(dvc_mod, DVC_DVUIR, 0); 185 186 rsnd_adg_set_cmd_timsel_gen2(dvc_mod, io); 187 188 return 0; 189 } 190 191 static int rsnd_dvc_quit(struct rsnd_mod *mod, 192 struct rsnd_priv *priv) 193 { 194 rsnd_mod_hw_stop(mod); 195 196 return 0; 197 } 198 199 static int rsnd_dvc_start(struct rsnd_mod *mod, 200 struct rsnd_priv *priv) 201 { 202 rsnd_mod_write(mod, CMD_CTRL, 0x10); 203 204 return 0; 205 } 206 207 static int rsnd_dvc_stop(struct rsnd_mod *mod, 208 struct rsnd_priv *priv) 209 { 210 rsnd_mod_write(mod, CMD_CTRL, 0); 211 212 return 0; 213 } 214 215 static int rsnd_dvc_pcm_new(struct rsnd_mod *mod, 216 struct snd_soc_pcm_runtime *rtd) 217 { 218 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 219 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 220 int is_play = rsnd_io_is_play(io); 221 int ret; 222 223 /* Volume */ 224 ret = rsnd_kctrl_new_m(mod, rtd, 225 is_play ? 226 "DVC Out Playback Volume" : "DVC In Capture Volume", 227 rsnd_dvc_volume_update, 228 &dvc->volume, 0x00800000 - 1); 229 if (ret < 0) 230 return ret; 231 232 /* Mute */ 233 ret = rsnd_kctrl_new_m(mod, rtd, 234 is_play ? 235 "DVC Out Mute Switch" : "DVC In Mute Switch", 236 rsnd_dvc_volume_update, 237 &dvc->mute, 1); 238 if (ret < 0) 239 return ret; 240 241 /* Ramp */ 242 ret = rsnd_kctrl_new_s(mod, rtd, 243 is_play ? 244 "DVC Out Ramp Switch" : "DVC In Ramp Switch", 245 rsnd_dvc_volume_update, 246 &dvc->ren, 1); 247 if (ret < 0) 248 return ret; 249 250 ret = rsnd_kctrl_new_e(mod, rtd, 251 is_play ? 252 "DVC Out Ramp Up Rate" : "DVC In Ramp Up Rate", 253 &dvc->rup, 254 rsnd_dvc_volume_update, 255 dvc_ramp_rate, ARRAY_SIZE(dvc_ramp_rate)); 256 if (ret < 0) 257 return ret; 258 259 ret = rsnd_kctrl_new_e(mod, rtd, 260 is_play ? 261 "DVC Out Ramp Down Rate" : "DVC In Ramp Down Rate", 262 &dvc->rdown, 263 rsnd_dvc_volume_update, 264 dvc_ramp_rate, ARRAY_SIZE(dvc_ramp_rate)); 265 266 if (ret < 0) 267 return ret; 268 269 return 0; 270 } 271 272 static struct rsnd_mod_ops rsnd_dvc_ops = { 273 .name = DVC_NAME, 274 .probe = rsnd_dvc_probe_gen2, 275 .remove = rsnd_dvc_remove_gen2, 276 .init = rsnd_dvc_init, 277 .quit = rsnd_dvc_quit, 278 .start = rsnd_dvc_start, 279 .stop = rsnd_dvc_stop, 280 .pcm_new = rsnd_dvc_pcm_new, 281 }; 282 283 struct rsnd_mod *rsnd_dvc_mod_get(struct rsnd_priv *priv, int id) 284 { 285 if (WARN_ON(id < 0 || id >= rsnd_dvc_nr(priv))) 286 id = 0; 287 288 return &((struct rsnd_dvc *)(priv->dvc) + id)->mod; 289 } 290 291 static void rsnd_of_parse_dvc(struct platform_device *pdev, 292 const struct rsnd_of_data *of_data, 293 struct rsnd_priv *priv) 294 { 295 struct device_node *node; 296 struct rsnd_dvc_platform_info *dvc_info; 297 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 298 struct device *dev = &pdev->dev; 299 int nr; 300 301 if (!of_data) 302 return; 303 304 node = of_get_child_by_name(dev->of_node, "rcar_sound,dvc"); 305 if (!node) 306 return; 307 308 nr = of_get_child_count(node); 309 if (!nr) 310 goto rsnd_of_parse_dvc_end; 311 312 dvc_info = devm_kzalloc(dev, 313 sizeof(struct rsnd_dvc_platform_info) * nr, 314 GFP_KERNEL); 315 if (!dvc_info) { 316 dev_err(dev, "dvc info allocation error\n"); 317 goto rsnd_of_parse_dvc_end; 318 } 319 320 info->dvc_info = dvc_info; 321 info->dvc_info_nr = nr; 322 323 rsnd_of_parse_dvc_end: 324 of_node_put(node); 325 } 326 327 int rsnd_dvc_probe(struct platform_device *pdev, 328 const struct rsnd_of_data *of_data, 329 struct rsnd_priv *priv) 330 { 331 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 332 struct device *dev = rsnd_priv_to_dev(priv); 333 struct rsnd_dvc *dvc; 334 struct clk *clk; 335 char name[RSND_DVC_NAME_SIZE]; 336 int i, nr; 337 338 rsnd_of_parse_dvc(pdev, of_data, priv); 339 340 nr = info->dvc_info_nr; 341 if (!nr) 342 return 0; 343 344 /* This driver doesn't support Gen1 at this point */ 345 if (rsnd_is_gen1(priv)) { 346 dev_warn(dev, "CMD is not supported on Gen1\n"); 347 return -EINVAL; 348 } 349 350 dvc = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL); 351 if (!dvc) { 352 dev_err(dev, "CMD allocate failed\n"); 353 return -ENOMEM; 354 } 355 356 priv->dvc_nr = nr; 357 priv->dvc = dvc; 358 359 for_each_rsnd_dvc(dvc, priv, i) { 360 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d", 361 DVC_NAME, i); 362 363 clk = devm_clk_get(dev, name); 364 if (IS_ERR(clk)) 365 return PTR_ERR(clk); 366 367 dvc->info = &info->dvc_info[i]; 368 369 rsnd_mod_init(&dvc->mod, &rsnd_dvc_ops, 370 clk, RSND_MOD_DVC, i); 371 372 dev_dbg(dev, "CMD%d probed\n", i); 373 } 374 375 return 0; 376 } 377