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 12 /* 13 * Playback Volume 14 * amixer set "DVC Out" 100% 15 * 16 * Capture Volume 17 * amixer set "DVC In" 100% 18 * 19 * Playback Mute 20 * amixer set "DVC Out Mute" on 21 * 22 * Capture Mute 23 * amixer set "DVC In Mute" on 24 * 25 * Volume Ramp 26 * amixer set "DVC Out Ramp Up Rate" "0.125 dB/64 steps" 27 * amixer set "DVC Out Ramp Down Rate" "0.125 dB/512 steps" 28 * amixer set "DVC Out Ramp" on 29 * aplay xxx.wav & 30 * amixer set "DVC Out" 80% // Volume Down 31 * amixer set "DVC Out" 100% // Volume Up 32 */ 33 34 #include "rsnd.h" 35 36 #define RSND_DVC_NAME_SIZE 16 37 38 #define DVC_NAME "dvc" 39 40 struct rsnd_dvc { 41 struct rsnd_mod mod; 42 struct rsnd_kctrl_cfg_m volume; 43 struct rsnd_kctrl_cfg_m mute; 44 struct rsnd_kctrl_cfg_s ren; /* Ramp Enable */ 45 struct rsnd_kctrl_cfg_s rup; /* Ramp Rate Up */ 46 struct rsnd_kctrl_cfg_s rdown; /* Ramp Rate Down */ 47 u32 flags; 48 }; 49 50 #define KCTRL_INITIALIZED (1 << 0) 51 52 #define rsnd_dvc_get(priv, id) ((struct rsnd_dvc *)(priv->dvc) + id) 53 #define rsnd_dvc_nr(priv) ((priv)->dvc_nr) 54 55 #define rsnd_mod_to_dvc(_mod) \ 56 container_of((_mod), struct rsnd_dvc, mod) 57 58 #define for_each_rsnd_dvc(pos, priv, i) \ 59 for ((i) = 0; \ 60 ((i) < rsnd_dvc_nr(priv)) && \ 61 ((pos) = (struct rsnd_dvc *)(priv)->dvc + i); \ 62 i++) 63 64 static void rsnd_dvc_activation(struct rsnd_mod *mod) 65 { 66 rsnd_mod_write(mod, DVC_SWRSR, 0); 67 rsnd_mod_write(mod, DVC_SWRSR, 1); 68 } 69 70 static void rsnd_dvc_halt(struct rsnd_mod *mod) 71 { 72 rsnd_mod_write(mod, DVC_DVUIR, 1); 73 rsnd_mod_write(mod, DVC_SWRSR, 0); 74 } 75 76 #define rsnd_dvc_get_vrpdr(dvc) (rsnd_kctrl_vals(dvc->rup) << 8 | \ 77 rsnd_kctrl_vals(dvc->rdown)) 78 #define rsnd_dvc_get_vrdbr(dvc) (0x3ff - (rsnd_kctrl_valm(dvc->volume, 0) >> 13)) 79 80 static void rsnd_dvc_volume_parameter(struct rsnd_dai_stream *io, 81 struct rsnd_mod *mod) 82 { 83 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 84 u32 val[RSND_MAX_CHANNELS]; 85 int i; 86 87 /* Enable Ramp */ 88 if (rsnd_kctrl_vals(dvc->ren)) 89 for (i = 0; i < RSND_MAX_CHANNELS; i++) 90 val[i] = rsnd_kctrl_max(dvc->volume); 91 else 92 for (i = 0; i < RSND_MAX_CHANNELS; i++) 93 val[i] = rsnd_kctrl_valm(dvc->volume, i); 94 95 /* Enable Digital Volume */ 96 rsnd_mod_write(mod, DVC_VOL0R, val[0]); 97 rsnd_mod_write(mod, DVC_VOL1R, val[1]); 98 rsnd_mod_write(mod, DVC_VOL2R, val[2]); 99 rsnd_mod_write(mod, DVC_VOL3R, val[3]); 100 rsnd_mod_write(mod, DVC_VOL4R, val[4]); 101 rsnd_mod_write(mod, DVC_VOL5R, val[5]); 102 rsnd_mod_write(mod, DVC_VOL6R, val[6]); 103 rsnd_mod_write(mod, DVC_VOL7R, val[7]); 104 } 105 106 static void rsnd_dvc_volume_init(struct rsnd_dai_stream *io, 107 struct rsnd_mod *mod) 108 { 109 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 110 u32 adinr = 0; 111 u32 dvucr = 0; 112 u32 vrctr = 0; 113 u32 vrpdr = 0; 114 u32 vrdbr = 0; 115 116 adinr = rsnd_get_adinr_bit(mod, io) | 117 rsnd_runtime_channel_after_ctu(io); 118 119 /* Enable Digital Volume, Zero Cross Mute Mode */ 120 dvucr |= 0x101; 121 122 /* Enable Ramp */ 123 if (rsnd_kctrl_vals(dvc->ren)) { 124 dvucr |= 0x10; 125 126 /* 127 * FIXME !! 128 * use scale-downed Digital Volume 129 * as Volume Ramp 130 * 7F FFFF -> 3FF 131 */ 132 vrctr = 0xff; 133 vrpdr = rsnd_dvc_get_vrpdr(dvc); 134 vrdbr = rsnd_dvc_get_vrdbr(dvc); 135 } 136 137 /* Initialize operation */ 138 rsnd_mod_write(mod, DVC_DVUIR, 1); 139 140 /* General Information */ 141 rsnd_mod_write(mod, DVC_ADINR, adinr); 142 rsnd_mod_write(mod, DVC_DVUCR, dvucr); 143 144 /* Volume Ramp Parameter */ 145 rsnd_mod_write(mod, DVC_VRCTR, vrctr); 146 rsnd_mod_write(mod, DVC_VRPDR, vrpdr); 147 rsnd_mod_write(mod, DVC_VRDBR, vrdbr); 148 149 /* Digital Volume Function Parameter */ 150 rsnd_dvc_volume_parameter(io, mod); 151 152 /* cancel operation */ 153 rsnd_mod_write(mod, DVC_DVUIR, 0); 154 } 155 156 static void rsnd_dvc_volume_update(struct rsnd_dai_stream *io, 157 struct rsnd_mod *mod) 158 { 159 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 160 u32 zcmcr = 0; 161 u32 vrpdr = 0; 162 u32 vrdbr = 0; 163 int i; 164 165 for (i = 0; i < rsnd_kctrl_size(dvc->mute); i++) 166 zcmcr |= (!!rsnd_kctrl_valm(dvc->mute, i)) << i; 167 168 if (rsnd_kctrl_vals(dvc->ren)) { 169 vrpdr = rsnd_dvc_get_vrpdr(dvc); 170 vrdbr = rsnd_dvc_get_vrdbr(dvc); 171 } 172 173 /* Disable DVC Register access */ 174 rsnd_mod_write(mod, DVC_DVUER, 0); 175 176 /* Zero Cross Mute Function */ 177 rsnd_mod_write(mod, DVC_ZCMCR, zcmcr); 178 179 /* Volume Ramp Function */ 180 rsnd_mod_write(mod, DVC_VRPDR, vrpdr); 181 rsnd_mod_write(mod, DVC_VRDBR, vrdbr); 182 /* add DVC_VRWTR here */ 183 184 /* Digital Volume Function Parameter */ 185 rsnd_dvc_volume_parameter(io, mod); 186 187 /* Enable DVC Register access */ 188 rsnd_mod_write(mod, DVC_DVUER, 1); 189 } 190 191 static int rsnd_dvc_probe_(struct rsnd_mod *mod, 192 struct rsnd_dai_stream *io, 193 struct rsnd_priv *priv) 194 { 195 return rsnd_cmd_attach(io, rsnd_mod_id(mod)); 196 } 197 198 static int rsnd_dvc_init(struct rsnd_mod *mod, 199 struct rsnd_dai_stream *io, 200 struct rsnd_priv *priv) 201 { 202 rsnd_mod_power_on(mod); 203 204 rsnd_dvc_activation(mod); 205 206 rsnd_dvc_volume_init(io, mod); 207 208 rsnd_dvc_volume_update(io, mod); 209 210 return 0; 211 } 212 213 static int rsnd_dvc_quit(struct rsnd_mod *mod, 214 struct rsnd_dai_stream *io, 215 struct rsnd_priv *priv) 216 { 217 rsnd_dvc_halt(mod); 218 219 rsnd_mod_power_off(mod); 220 221 return 0; 222 } 223 224 static int rsnd_dvc_pcm_new(struct rsnd_mod *mod, 225 struct rsnd_dai_stream *io, 226 struct snd_soc_pcm_runtime *rtd) 227 { 228 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod); 229 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 230 int is_play = rsnd_io_is_play(io); 231 int channels = rsnd_rdai_channels_get(rdai); 232 int ret; 233 234 if (rsnd_flags_has(dvc, KCTRL_INITIALIZED)) 235 return 0; 236 237 /* Volume */ 238 ret = rsnd_kctrl_new_m(mod, io, rtd, 239 is_play ? 240 "DVC Out Playback Volume" : "DVC In Capture Volume", 241 rsnd_kctrl_accept_anytime, 242 rsnd_dvc_volume_update, 243 &dvc->volume, channels, 244 0x00800000 - 1); 245 if (ret < 0) 246 return ret; 247 248 /* Mute */ 249 ret = rsnd_kctrl_new_m(mod, io, rtd, 250 is_play ? 251 "DVC Out Mute Switch" : "DVC In Mute Switch", 252 rsnd_kctrl_accept_anytime, 253 rsnd_dvc_volume_update, 254 &dvc->mute, channels, 255 1); 256 if (ret < 0) 257 return ret; 258 259 /* Ramp */ 260 ret = rsnd_kctrl_new_s(mod, io, rtd, 261 is_play ? 262 "DVC Out Ramp Switch" : "DVC In Ramp Switch", 263 rsnd_kctrl_accept_anytime, 264 rsnd_dvc_volume_update, 265 &dvc->ren, 1); 266 if (ret < 0) 267 return ret; 268 269 ret = rsnd_kctrl_new_e(mod, io, rtd, 270 is_play ? 271 "DVC Out Ramp Up Rate" : "DVC In Ramp Up Rate", 272 rsnd_kctrl_accept_anytime, 273 rsnd_dvc_volume_update, 274 &dvc->rup, 275 volume_ramp_rate, 276 VOLUME_RAMP_MAX_DVC); 277 if (ret < 0) 278 return ret; 279 280 ret = rsnd_kctrl_new_e(mod, io, rtd, 281 is_play ? 282 "DVC Out Ramp Down Rate" : "DVC In Ramp Down Rate", 283 rsnd_kctrl_accept_anytime, 284 rsnd_dvc_volume_update, 285 &dvc->rdown, 286 volume_ramp_rate, 287 VOLUME_RAMP_MAX_DVC); 288 289 if (ret < 0) 290 return ret; 291 292 rsnd_flags_set(dvc, KCTRL_INITIALIZED); 293 294 return 0; 295 } 296 297 static struct dma_chan *rsnd_dvc_dma_req(struct rsnd_dai_stream *io, 298 struct rsnd_mod *mod) 299 { 300 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 301 302 return rsnd_dma_request_channel(rsnd_dvc_of_node(priv), 303 mod, "tx"); 304 } 305 306 static struct rsnd_mod_ops rsnd_dvc_ops = { 307 .name = DVC_NAME, 308 .dma_req = rsnd_dvc_dma_req, 309 .probe = rsnd_dvc_probe_, 310 .init = rsnd_dvc_init, 311 .quit = rsnd_dvc_quit, 312 .pcm_new = rsnd_dvc_pcm_new, 313 }; 314 315 struct rsnd_mod *rsnd_dvc_mod_get(struct rsnd_priv *priv, int id) 316 { 317 if (WARN_ON(id < 0 || id >= rsnd_dvc_nr(priv))) 318 id = 0; 319 320 return rsnd_mod_get(rsnd_dvc_get(priv, id)); 321 } 322 323 int rsnd_dvc_probe(struct rsnd_priv *priv) 324 { 325 struct device_node *node; 326 struct device_node *np; 327 struct device *dev = rsnd_priv_to_dev(priv); 328 struct rsnd_dvc *dvc; 329 struct clk *clk; 330 char name[RSND_DVC_NAME_SIZE]; 331 int i, nr, ret; 332 333 /* This driver doesn't support Gen1 at this point */ 334 if (rsnd_is_gen1(priv)) 335 return 0; 336 337 node = rsnd_dvc_of_node(priv); 338 if (!node) 339 return 0; /* not used is not error */ 340 341 nr = of_get_child_count(node); 342 if (!nr) { 343 ret = -EINVAL; 344 goto rsnd_dvc_probe_done; 345 } 346 347 dvc = devm_kcalloc(dev, nr, sizeof(*dvc), GFP_KERNEL); 348 if (!dvc) { 349 ret = -ENOMEM; 350 goto rsnd_dvc_probe_done; 351 } 352 353 priv->dvc_nr = nr; 354 priv->dvc = dvc; 355 356 i = 0; 357 ret = 0; 358 for_each_child_of_node(node, np) { 359 dvc = rsnd_dvc_get(priv, i); 360 361 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d", 362 DVC_NAME, i); 363 364 clk = devm_clk_get(dev, name); 365 if (IS_ERR(clk)) { 366 ret = PTR_ERR(clk); 367 of_node_put(np); 368 goto rsnd_dvc_probe_done; 369 } 370 371 ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops, 372 clk, rsnd_mod_get_status, RSND_MOD_DVC, i); 373 if (ret) { 374 of_node_put(np); 375 goto rsnd_dvc_probe_done; 376 } 377 378 i++; 379 } 380 381 rsnd_dvc_probe_done: 382 of_node_put(node); 383 384 return ret; 385 } 386 387 void rsnd_dvc_remove(struct rsnd_priv *priv) 388 { 389 struct rsnd_dvc *dvc; 390 int i; 391 392 for_each_rsnd_dvc(dvc, priv, i) { 393 rsnd_mod_quit(rsnd_mod_get(dvc)); 394 } 395 } 396