drivers/ram/stm32mp1/stm32mp1_ddr.c

   1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2018, STMicroelectronics - All Rights Reserved
   4  */
   5
   6 #include <common.h>
   7 #include <clk.h>
   8 #include <log.h>
   9 #include <ram.h>
  10 #include <reset.h>
  11 #include <timer.h>
  12 #include <asm/io.h>
  13 #include <asm/arch/ddr.h>
  14 #include <linux/delay.h>
  15 #include <linux/iopoll.h>
  16 #include "stm32mp1_ddr.h"
  17 #include "stm32mp1_ddr_regs.h"
  18
  19 #define RCC_DDRITFCR            0xD8
  20
  21 #define RCC_DDRITFCR_DDRCAPBRST         (BIT(14))
  22 #define RCC_DDRITFCR_DDRCAXIRST         (BIT(15))
  23 #define RCC_DDRITFCR_DDRCORERST         (BIT(16))
  24 #define RCC_DDRITFCR_DPHYAPBRST         (BIT(17))
  25 #define RCC_DDRITFCR_DPHYRST            (BIT(18))
  26 #define RCC_DDRITFCR_DPHYCTLRST         (BIT(19))
  27
  28 struct reg_desc {
  29         const char *name;
  30         u16 offset;     /* offset for base address */
  31         u8 par_offset;  /* offset for parameter array */
  32 };
  33
  34 #define INVALID_OFFSET  0xFF
  35
  36 #define DDRCTL_REG(x, y) \
  37         {#x,\
  38          offsetof(struct stm32mp1_ddrctl, x),\
  39          offsetof(struct y, x)}
  40
  41 #define DDRPHY_REG(x, y) \
  42         {#x,\
  43          offsetof(struct stm32mp1_ddrphy, x),\
  44          offsetof(struct y, x)}
  45
  46 #define DDR_REG_DYN(x) \
  47         {#x,\
  48          offsetof(struct stm32mp1_ddrctl, x),\
  49          INVALID_OFFSET}
  50
  51 #define DDRPHY_REG_DYN(x) \
  52         {#x,\
  53          offsetof(struct stm32mp1_ddrphy, x),\
  54          INVALID_OFFSET}
  55
  56 /***********************************************************
  57  * PARAMETERS: value get from device tree :
  58  *             size / order need to be aligned with binding
  59  *             modification NOT ALLOWED !!!
  60  ***********************************************************/
  61 #define DDRCTL_REG_REG_SIZE     25      /* st,ctl-reg */
  62 #define DDRCTL_REG_TIMING_SIZE  12      /* st,ctl-timing */
  63 #define DDRCTL_REG_MAP_SIZE     9       /* st,ctl-map */
  64 #define DDRCTL_REG_PERF_SIZE    17      /* st,ctl-perf */
  65
  66 #define DDRPHY_REG_REG_SIZE     11      /* st,phy-reg */
  67 #define DDRPHY_REG_TIMING_SIZE  10      /* st,phy-timing */
  68 #define DDRPHY_REG_CAL_SIZE     12      /* st,phy-cal */
  69
  70 #define DDRCTL_REG_REG(x)       DDRCTL_REG(x, stm32mp1_ddrctrl_reg)
  71 static const struct reg_desc ddr_reg[DDRCTL_REG_REG_SIZE] = {
  72         DDRCTL_REG_REG(mstr),
  73         DDRCTL_REG_REG(mrctrl0),
  74         DDRCTL_REG_REG(mrctrl1),
  75         DDRCTL_REG_REG(derateen),
  76         DDRCTL_REG_REG(derateint),
  77         DDRCTL_REG_REG(pwrctl),
  78         DDRCTL_REG_REG(pwrtmg),
  79         DDRCTL_REG_REG(hwlpctl),
  80         DDRCTL_REG_REG(rfshctl0),
  81         DDRCTL_REG_REG(rfshctl3),
  82         DDRCTL_REG_REG(crcparctl0),
  83         DDRCTL_REG_REG(zqctl0),
  84         DDRCTL_REG_REG(dfitmg0),
  85         DDRCTL_REG_REG(dfitmg1),
  86         DDRCTL_REG_REG(dfilpcfg0),
  87         DDRCTL_REG_REG(dfiupd0),
  88         DDRCTL_REG_REG(dfiupd1),
  89         DDRCTL_REG_REG(dfiupd2),
  90         DDRCTL_REG_REG(dfiphymstr),
  91         DDRCTL_REG_REG(odtmap),
  92         DDRCTL_REG_REG(dbg0),
  93         DDRCTL_REG_REG(dbg1),
  94         DDRCTL_REG_REG(dbgcmd),
  95         DDRCTL_REG_REG(poisoncfg),
  96         DDRCTL_REG_REG(pccfg),
  97 };
  98
  99 #define DDRCTL_REG_TIMING(x)    DDRCTL_REG(x, stm32mp1_ddrctrl_timing)
 100 static const struct reg_desc ddr_timing[DDRCTL_REG_TIMING_SIZE] = {
 101         DDRCTL_REG_TIMING(rfshtmg),
 102         DDRCTL_REG_TIMING(dramtmg0),
 103         DDRCTL_REG_TIMING(dramtmg1),
 104         DDRCTL_REG_TIMING(dramtmg2),
 105         DDRCTL_REG_TIMING(dramtmg3),
 106         DDRCTL_REG_TIMING(dramtmg4),
 107         DDRCTL_REG_TIMING(dramtmg5),
 108         DDRCTL_REG_TIMING(dramtmg6),
 109         DDRCTL_REG_TIMING(dramtmg7),
 110         DDRCTL_REG_TIMING(dramtmg8),
 111         DDRCTL_REG_TIMING(dramtmg14),
 112         DDRCTL_REG_TIMING(odtcfg),
 113 };
 114
 115 #define DDRCTL_REG_MAP(x)       DDRCTL_REG(x, stm32mp1_ddrctrl_map)
 116 static const struct reg_desc ddr_map[DDRCTL_REG_MAP_SIZE] = {
 117         DDRCTL_REG_MAP(addrmap1),
 118         DDRCTL_REG_MAP(addrmap2),
 119         DDRCTL_REG_MAP(addrmap3),
 120         DDRCTL_REG_MAP(addrmap4),
 121         DDRCTL_REG_MAP(addrmap5),
 122         DDRCTL_REG_MAP(addrmap6),
 123         DDRCTL_REG_MAP(addrmap9),
 124         DDRCTL_REG_MAP(addrmap10),
 125         DDRCTL_REG_MAP(addrmap11),
 126 };
 127
 128 #define DDRCTL_REG_PERF(x)      DDRCTL_REG(x, stm32mp1_ddrctrl_perf)
 129 static const struct reg_desc ddr_perf[DDRCTL_REG_PERF_SIZE] = {
 130         DDRCTL_REG_PERF(sched),
 131         DDRCTL_REG_PERF(sched1),
 132         DDRCTL_REG_PERF(perfhpr1),
 133         DDRCTL_REG_PERF(perflpr1),
 134         DDRCTL_REG_PERF(perfwr1),
 135         DDRCTL_REG_PERF(pcfgr_0),
 136         DDRCTL_REG_PERF(pcfgw_0),
 137         DDRCTL_REG_PERF(pcfgqos0_0),
 138         DDRCTL_REG_PERF(pcfgqos1_0),
 139         DDRCTL_REG_PERF(pcfgwqos0_0),
 140         DDRCTL_REG_PERF(pcfgwqos1_0),
 141         DDRCTL_REG_PERF(pcfgr_1),
 142         DDRCTL_REG_PERF(pcfgw_1),
 143         DDRCTL_REG_PERF(pcfgqos0_1),
 144         DDRCTL_REG_PERF(pcfgqos1_1),
 145         DDRCTL_REG_PERF(pcfgwqos0_1),
 146         DDRCTL_REG_PERF(pcfgwqos1_1),
 147 };
 148
 149 #define DDRPHY_REG_REG(x)       DDRPHY_REG(x, stm32mp1_ddrphy_reg)
 150 static const struct reg_desc ddrphy_reg[DDRPHY_REG_REG_SIZE] = {
 151         DDRPHY_REG_REG(pgcr),
 152         DDRPHY_REG_REG(aciocr),
 153         DDRPHY_REG_REG(dxccr),
 154         DDRPHY_REG_REG(dsgcr),
 155         DDRPHY_REG_REG(dcr),
 156         DDRPHY_REG_REG(odtcr),
 157         DDRPHY_REG_REG(zq0cr1),
 158         DDRPHY_REG_REG(dx0gcr),
 159         DDRPHY_REG_REG(dx1gcr),
 160         DDRPHY_REG_REG(dx2gcr),
 161         DDRPHY_REG_REG(dx3gcr),
 162 };
 163
 164 #define DDRPHY_REG_TIMING(x)    DDRPHY_REG(x, stm32mp1_ddrphy_timing)
 165 static const struct reg_desc ddrphy_timing[DDRPHY_REG_TIMING_SIZE] = {
 166         DDRPHY_REG_TIMING(ptr0),
 167         DDRPHY_REG_TIMING(ptr1),
 168         DDRPHY_REG_TIMING(ptr2),
 169         DDRPHY_REG_TIMING(dtpr0),
 170         DDRPHY_REG_TIMING(dtpr1),
 171         DDRPHY_REG_TIMING(dtpr2),
 172         DDRPHY_REG_TIMING(mr0),
 173         DDRPHY_REG_TIMING(mr1),
 174         DDRPHY_REG_TIMING(mr2),
 175         DDRPHY_REG_TIMING(mr3),
 176 };
 177
 178 #define DDRPHY_REG_CAL(x)       DDRPHY_REG(x, stm32mp1_ddrphy_cal)
 179 static const struct reg_desc ddrphy_cal[DDRPHY_REG_CAL_SIZE] = {
 180         DDRPHY_REG_CAL(dx0dllcr),
 181         DDRPHY_REG_CAL(dx0dqtr),
 182         DDRPHY_REG_CAL(dx0dqstr),
 183         DDRPHY_REG_CAL(dx1dllcr),
 184         DDRPHY_REG_CAL(dx1dqtr),
 185         DDRPHY_REG_CAL(dx1dqstr),
 186         DDRPHY_REG_CAL(dx2dllcr),
 187         DDRPHY_REG_CAL(dx2dqtr),
 188         DDRPHY_REG_CAL(dx2dqstr),
 189         DDRPHY_REG_CAL(dx3dllcr),
 190         DDRPHY_REG_CAL(dx3dqtr),
 191         DDRPHY_REG_CAL(dx3dqstr),
 192 };
 193
 194 /**************************************************************
 195  * DYNAMIC REGISTERS: only used for debug purpose (read/modify)
 196  **************************************************************/
 197 #ifdef CONFIG_STM32MP1_DDR_INTERACTIVE
 198 static const struct reg_desc ddr_dyn[] = {
 199         DDR_REG_DYN(stat),
 200         DDR_REG_DYN(init0),
 201         DDR_REG_DYN(dfimisc),
 202         DDR_REG_DYN(dfistat),
 203         DDR_REG_DYN(swctl),
 204         DDR_REG_DYN(swstat),
 205         DDR_REG_DYN(pctrl_0),
 206         DDR_REG_DYN(pctrl_1),
 207 };
 208
 209 #define DDR_REG_DYN_SIZE        ARRAY_SIZE(ddr_dyn)
 210
 211 static const struct reg_desc ddrphy_dyn[] = {
 212         DDRPHY_REG_DYN(pir),
 213         DDRPHY_REG_DYN(pgsr),
 214         DDRPHY_REG_DYN(zq0sr0),
 215         DDRPHY_REG_DYN(zq0sr1),
 216         DDRPHY_REG_DYN(dx0gsr0),
 217         DDRPHY_REG_DYN(dx0gsr1),
 218         DDRPHY_REG_DYN(dx1gsr0),
 219         DDRPHY_REG_DYN(dx1gsr1),
 220         DDRPHY_REG_DYN(dx2gsr0),
 221         DDRPHY_REG_DYN(dx2gsr1),
 222         DDRPHY_REG_DYN(dx3gsr0),
 223         DDRPHY_REG_DYN(dx3gsr1),
 224 };
 225
 226 #define DDRPHY_REG_DYN_SIZE     ARRAY_SIZE(ddrphy_dyn)
 227
 228 #endif
 229
 230 /*****************************************************************
 231  * REGISTERS ARRAY: used to parse device tree and interactive mode
 232  *****************************************************************/
 233 enum reg_type {
 234         REG_REG,
 235         REG_TIMING,
 236         REG_PERF,
 237         REG_MAP,
 238         REGPHY_REG,
 239         REGPHY_TIMING,
 240         REGPHY_CAL,
 241 #ifdef CONFIG_STM32MP1_DDR_INTERACTIVE
 242 /* dynamic registers => managed in driver or not changed,
 243  * can be dumped in interactive mode
 244  */
 245         REG_DYN,
 246         REGPHY_DYN,
 247 #endif
 248         REG_TYPE_NB
 249 };
 250
 251 enum base_type {
 252         DDR_BASE,
 253         DDRPHY_BASE,
 254         NONE_BASE
 255 };
 256
 257 struct ddr_reg_info {
 258         const char *name;
 259         const struct reg_desc *desc;
 260         u8 size;
 261         enum base_type base;
 262 };
 263
 264 #define DDRPHY_REG_CAL(x)       DDRPHY_REG(x, stm32mp1_ddrphy_cal)
 265
 266 const struct ddr_reg_info ddr_registers[REG_TYPE_NB] = {
 267 [REG_REG] = {
 268         "static", ddr_reg, DDRCTL_REG_REG_SIZE, DDR_BASE},
 269 [REG_TIMING] = {
 270         "timing", ddr_timing, DDRCTL_REG_TIMING_SIZE, DDR_BASE},
 271 [REG_PERF] = {
 272         "perf", ddr_perf, DDRCTL_REG_PERF_SIZE, DDR_BASE},
 273 [REG_MAP] = {
 274         "map", ddr_map, DDRCTL_REG_MAP_SIZE, DDR_BASE},
 275 [REGPHY_REG] = {
 276         "static", ddrphy_reg, DDRPHY_REG_REG_SIZE, DDRPHY_BASE},
 277 [REGPHY_TIMING] = {
 278         "timing", ddrphy_timing, DDRPHY_REG_TIMING_SIZE, DDRPHY_BASE},
 279 [REGPHY_CAL] = {
 280         "cal", ddrphy_cal, DDRPHY_REG_CAL_SIZE, DDRPHY_BASE},
 281 #ifdef CONFIG_STM32MP1_DDR_INTERACTIVE
 282 [REG_DYN] = {
 283         "dyn", ddr_dyn, DDR_REG_DYN_SIZE, DDR_BASE},
 284 [REGPHY_DYN] = {
 285         "dyn", ddrphy_dyn, DDRPHY_REG_DYN_SIZE, DDRPHY_BASE},
 286 #endif
 287
 288 };
 289
 290 const char *base_name[] = {
 291         [DDR_BASE] = "ctl",
 292         [DDRPHY_BASE] = "phy",
 293 };
 294
 295 static u32 get_base_addr(const struct ddr_info *priv, enum base_type base)
 296 {
 297         if (base == DDRPHY_BASE)
 298                 return (u32)priv->phy;
 299         else
 300                 return (u32)priv->ctl;
 301 }
 302
 303 static void set_reg(const struct ddr_info *priv,
 304                     enum reg_type type,
 305                     const void *param)
 306 {
 307         unsigned int i;
 308         unsigned int *ptr, value;
 309         enum base_type base = ddr_registers[type].base;
 310         u32 base_addr = get_base_addr(priv, base);
 311         const struct reg_desc *desc = ddr_registers[type].desc;
 312
 313         debug("init %s\n", ddr_registers[type].name);
 314         for (i = 0; i < ddr_registers[type].size; i++) {
 315                 ptr = (unsigned int *)(base_addr + desc[i].offset);
 316                 if (desc[i].par_offset == INVALID_OFFSET) {
 317                         pr_err("invalid parameter offset for %s", desc[i].name);
 318                 } else {
 319                         value = *((u32 *)((u32)param +
 320                                                desc[i].par_offset));
 321                         writel(value, ptr);
 322                         debug("[0x%x] %s= 0x%08x\n",
 323                               (u32)ptr, desc[i].name, value);
 324                 }
 325         }
 326 }
 327
 328 #ifdef CONFIG_STM32MP1_DDR_INTERACTIVE
 329 static void stm32mp1_dump_reg_desc(u32 base_addr, const struct reg_desc *desc)
 330 {
 331         unsigned int *ptr;
 332
 333         ptr = (unsigned int *)(base_addr + desc->offset);
 334         printf("%s= 0x%08x\n", desc->name, readl(ptr));
 335 }
 336
 337 static void stm32mp1_dump_param_desc(u32 par_addr, const struct reg_desc *desc)
 338 {
 339         unsigned int *ptr;
 340
 341         ptr = (unsigned int *)(par_addr + desc->par_offset);
 342         printf("%s= 0x%08x\n", desc->name, readl(ptr));
 343 }
 344
 345 static const struct reg_desc *found_reg(const char *name, enum reg_type *type)
 346 {
 347         unsigned int i, j;
 348         const struct reg_desc *desc;
 349
 350         for (i = 0; i < ARRAY_SIZE(ddr_registers); i++) {
 351                 desc = ddr_registers[i].desc;
 352                 for (j = 0; j < ddr_registers[i].size; j++) {
 353                         if (strcmp(name, desc[j].name) == 0) {
 354                                 *type = i;
 355                                 return &desc[j];
 356                         }
 357                 }
 358         }
 359         *type = REG_TYPE_NB;
 360         return NULL;
 361 }
 362
 363 int stm32mp1_dump_reg(const struct ddr_info *priv,
 364                       const char *name)
 365 {
 366         unsigned int i, j;
 367         const struct reg_desc *desc;
 368         u32 base_addr;
 369         enum base_type p_base;
 370         enum reg_type type;
 371         const char *p_name;
 372         enum base_type filter = NONE_BASE;
 373         int result = -1;
 374
 375         if (name) {
 376                 if (strcmp(name, base_name[DDR_BASE]) == 0)
 377                         filter = DDR_BASE;
 378                 else if (strcmp(name, base_name[DDRPHY_BASE]) == 0)
 379                         filter = DDRPHY_BASE;
 380         }
 381
 382         for (i = 0; i < ARRAY_SIZE(ddr_registers); i++) {
 383                 p_base = ddr_registers[i].base;
 384                 p_name = ddr_registers[i].name;
 385                 if (!name || (filter == p_base || !strcmp(name, p_name))) {
 386                         result = 0;
 387                         desc = ddr_registers[i].desc;
 388                         base_addr = get_base_addr(priv, p_base);
 389                         printf("==%s.%s==\n", base_name[p_base], p_name);
 390                         for (j = 0; j < ddr_registers[i].size; j++)
 391                                 stm32mp1_dump_reg_desc(base_addr, &desc[j]);
 392                 }
 393         }
 394         if (result) {
 395                 desc = found_reg(name, &type);
 396                 if (desc) {
 397                         p_base = ddr_registers[type].base;
 398                         base_addr = get_base_addr(priv, p_base);
 399                         stm32mp1_dump_reg_desc(base_addr, desc);
 400                         result = 0;
 401                 }
 402         }
 403         return result;
 404 }
 405
 406 void stm32mp1_edit_reg(const struct ddr_info *priv,
 407                        char *name, char *string)
 408 {
 409         unsigned long *ptr, value;
 410         enum reg_type type;
 411         enum base_type base;
 412         const struct reg_desc *desc;
 413         u32 base_addr;
 414
 415         desc = found_reg(name, &type);
 416
 417         if (!desc) {
 418                 printf("%s not found\n", name);
 419                 return;
 420         }
 421         if (strict_strtoul(string, 16, &value) < 0) {
 422                 printf("invalid value %s\n", string);
 423                 return;
 424         }
 425         base = ddr_registers[type].base;
 426         base_addr = get_base_addr(priv, base);
 427         ptr = (unsigned long *)(base_addr + desc->offset);
 428         writel(value, ptr);
 429         printf("%s= 0x%08x\n", desc->name, readl(ptr));
 430 }
 431
 432 static u32 get_par_addr(const struct stm32mp1_ddr_config *config,
 433                         enum reg_type type)
 434 {
 435         u32 par_addr = 0x0;
 436
 437         switch (type) {
 438         case REG_REG:
 439                 par_addr = (u32)&config->c_reg;
 440                 break;
 441         case REG_TIMING:
 442                 par_addr = (u32)&config->c_timing;
 443                 break;
 444         case REG_PERF:
 445                 par_addr = (u32)&config->c_perf;
 446                 break;
 447         case REG_MAP:
 448                 par_addr = (u32)&config->c_map;
 449                 break;
 450         case REGPHY_REG:
 451                 par_addr = (u32)&config->p_reg;
 452                 break;
 453         case REGPHY_TIMING:
 454                 par_addr = (u32)&config->p_timing;
 455                 break;
 456         case REGPHY_CAL:
 457                 par_addr = (u32)&config->p_cal;
 458                 break;
 459         case REG_DYN:
 460         case REGPHY_DYN:
 461         case REG_TYPE_NB:
 462                 par_addr = (u32)NULL;
 463                 break;
 464         }
 465
 466         return par_addr;
 467 }
 468
 469 int stm32mp1_dump_param(const struct stm32mp1_ddr_config *config,
 470                         const char *name)
 471 {
 472         unsigned int i, j;
 473         const struct reg_desc *desc;
 474         u32 par_addr;
 475         enum base_type p_base;
 476         enum reg_type type;
 477         const char *p_name;
 478         enum base_type filter = NONE_BASE;
 479         int result = -EINVAL;
 480
 481         if (name) {
 482                 if (strcmp(name, base_name[DDR_BASE]) == 0)
 483                         filter = DDR_BASE;
 484                 else if (strcmp(name, base_name[DDRPHY_BASE]) == 0)
 485                         filter = DDRPHY_BASE;
 486         }
 487
 488         for (i = 0; i < ARRAY_SIZE(ddr_registers); i++) {
 489                 par_addr = get_par_addr(config, i);
 490                 if (!par_addr)
 491                         continue;
 492                 p_base = ddr_registers[i].base;
 493                 p_name = ddr_registers[i].name;
 494                 if (!name || (filter == p_base || !strcmp(name, p_name))) {
 495                         result = 0;
 496                         desc = ddr_registers[i].desc;
 497                         printf("==%s.%s==\n", base_name[p_base], p_name);
 498                         for (j = 0; j < ddr_registers[i].size; j++)
 499                                 stm32mp1_dump_param_desc(par_addr, &desc[j]);
 500                 }
 501         }
 502         if (result) {
 503                 desc = found_reg(name, &type);
 504                 if (desc) {
 505                         par_addr = get_par_addr(config, type);
 506                         if (par_addr) {
 507                                 stm32mp1_dump_param_desc(par_addr, desc);
 508                                 result = 0;
 509                         }
 510                 }
 511         }
 512         return result;
 513 }
 514
 515 void stm32mp1_edit_param(const struct stm32mp1_ddr_config *config,
 516                          char *name, char *string)
 517 {
 518         unsigned long *ptr, value;
 519         enum reg_type type;
 520         const struct reg_desc *desc;
 521         u32 par_addr;
 522
 523         desc = found_reg(name, &type);
 524         if (!desc) {
 525                 printf("%s not found\n", name);
 526                 return;
 527         }
 528         if (strict_strtoul(string, 16, &value) < 0) {
 529                 printf("invalid value %s\n", string);
 530                 return;
 531         }
 532         par_addr = get_par_addr(config, type);
 533         if (!par_addr) {
 534                 printf("no parameter %s\n", name);
 535                 return;
 536         }
 537         ptr = (unsigned long *)(par_addr + desc->par_offset);
 538         writel(value, ptr);
 539         printf("%s= 0x%08x\n", desc->name, readl(ptr));
 540 }
 541 #endif
 542
 543 __weak bool stm32mp1_ddr_interactive(void *priv,
 544                                      enum stm32mp1_ddr_interact_step step,
 545                                      const struct stm32mp1_ddr_config *config)
 546 {
 547         return false;
 548 }
 549
 550 #define INTERACTIVE(step)\
 551         stm32mp1_ddr_interactive(priv, step, config)
 552
 553 static void ddrphy_idone_wait(struct stm32mp1_ddrphy *phy)
 554 {
 555         u32 pgsr;
 556         int ret;
 557
 558         ret = readl_poll_timeout(&phy->pgsr, pgsr,
 559                                  pgsr & (DDRPHYC_PGSR_IDONE |
 560                                          DDRPHYC_PGSR_DTERR |
 561                                          DDRPHYC_PGSR_DTIERR |
 562                                          DDRPHYC_PGSR_DFTERR |
 563                                          DDRPHYC_PGSR_RVERR |
 564                                          DDRPHYC_PGSR_RVEIRR),
 565                                 1000000);
 566         debug("\n[0x%08x] pgsr = 0x%08x ret=%d\n",
 567               (u32)&phy->pgsr, pgsr, ret);
 568 }
 569
 570 void stm32mp1_ddrphy_init(struct stm32mp1_ddrphy *phy, u32 pir)
 571 {
 572         pir |= DDRPHYC_PIR_INIT;
 573         writel(pir, &phy->pir);
 574         debug("[0x%08x] pir = 0x%08x -> 0x%08x\n",
 575               (u32)&phy->pir, pir, readl(&phy->pir));
 576
 577         /* need to wait 10 configuration clock before start polling */
 578         udelay(10);
 579
 580         /* Wait DRAM initialization and Gate Training Evaluation complete */
 581         ddrphy_idone_wait(phy);
 582 }
 583
 584 /* start quasi dynamic register update */
 585 static void start_sw_done(struct stm32mp1_ddrctl *ctl)
 586 {
 587         clrbits_le32(&ctl->swctl, DDRCTRL_SWCTL_SW_DONE);
 588 }
 589
 590 /* wait quasi dynamic register update */
 591 static void wait_sw_done_ack(struct stm32mp1_ddrctl *ctl)
 592 {
 593         int ret;
 594         u32 swstat;
 595
 596         setbits_le32(&ctl->swctl, DDRCTRL_SWCTL_SW_DONE);
 597
 598         ret = readl_poll_timeout(&ctl->swstat, swstat,
 599                                  swstat & DDRCTRL_SWSTAT_SW_DONE_ACK,
 600                                  1000000);
 601         if (ret)
 602                 panic("Timeout initialising DRAM : DDR->swstat = %x\n",
 603                       swstat);
 604
 605         debug("[0x%08x] swstat = 0x%08x\n", (u32)&ctl->swstat, swstat);
 606 }
 607
 608 /* wait quasi dynamic register update */
 609 static void wait_operating_mode(struct ddr_info *priv, int mode)
 610 {
 611         u32 stat, val, mask, val2 = 0, mask2 = 0;
 612         int ret;
 613
 614         mask = DDRCTRL_STAT_OPERATING_MODE_MASK;
 615         val = mode;
 616         /* self-refresh due to software => check also STAT.selfref_type */
 617         if (mode == DDRCTRL_STAT_OPERATING_MODE_SR) {
 618                 mask |= DDRCTRL_STAT_SELFREF_TYPE_MASK;
 619                 val |= DDRCTRL_STAT_SELFREF_TYPE_SR;
 620         } else if (mode == DDRCTRL_STAT_OPERATING_MODE_NORMAL) {
 621                 /* normal mode: handle also automatic self refresh */
 622                 mask2 = DDRCTRL_STAT_OPERATING_MODE_MASK |
 623                         DDRCTRL_STAT_SELFREF_TYPE_MASK;
 624                 val2 = DDRCTRL_STAT_OPERATING_MODE_SR |
 625                        DDRCTRL_STAT_SELFREF_TYPE_ASR;
 626         }
 627
 628         ret = readl_poll_timeout(&priv->ctl->stat, stat,
 629                                  ((stat & mask) == val) ||
 630                                  (mask2 && ((stat & mask2) == val2)),
 631                                  1000000);
 632
 633         if (ret)
 634                 panic("Timeout DRAM : DDR->stat = %x\n", stat);
 635
 636         debug("[0x%08x] stat = 0x%08x\n", (u32)&priv->ctl->stat, stat);
 637 }
 638
 639 void stm32mp1_refresh_disable(struct stm32mp1_ddrctl *ctl)
 640 {
 641         start_sw_done(ctl);
 642         /* quasi-dynamic register update*/
 643         setbits_le32(&ctl->rfshctl3, DDRCTRL_RFSHCTL3_DIS_AUTO_REFRESH);
 644         clrbits_le32(&ctl->pwrctl, DDRCTRL_PWRCTL_POWERDOWN_EN |
 645                                    DDRCTRL_PWRCTL_SELFREF_EN);
 646         clrbits_le32(&ctl->dfimisc, DDRCTRL_DFIMISC_DFI_INIT_COMPLETE_EN);
 647         wait_sw_done_ack(ctl);
 648 }
 649
 650 void stm32mp1_refresh_restore(struct stm32mp1_ddrctl *ctl,
 651                               u32 rfshctl3, u32 pwrctl)
 652 {
 653         start_sw_done(ctl);
 654         if (!(rfshctl3 & DDRCTRL_RFSHCTL3_DIS_AUTO_REFRESH))
 655                 clrbits_le32(&ctl->rfshctl3, DDRCTRL_RFSHCTL3_DIS_AUTO_REFRESH);
 656         if (pwrctl & DDRCTRL_PWRCTL_POWERDOWN_EN)
 657                 setbits_le32(&ctl->pwrctl, DDRCTRL_PWRCTL_POWERDOWN_EN);
 658         if ((pwrctl & DDRCTRL_PWRCTL_SELFREF_EN))
 659                 setbits_le32(&ctl->pwrctl, DDRCTRL_PWRCTL_SELFREF_EN);
 660         setbits_le32(&ctl->dfimisc, DDRCTRL_DFIMISC_DFI_INIT_COMPLETE_EN);
 661         wait_sw_done_ack(ctl);
 662 }
 663
 664 /* board-specific DDR power initializations. */
 665 __weak int board_ddr_power_init(enum ddr_type ddr_type)
 666 {
 667         return 0;
 668 }
 669
 670 __maybe_unused
 671 void stm32mp1_ddr_init(struct ddr_info *priv,
 672                        const struct stm32mp1_ddr_config *config)
 673 {
 674         u32 pir;
 675         int ret = -EINVAL;
 676         char bus_width;
 677
 678         switch (config->c_reg.mstr & DDRCTRL_MSTR_DATA_BUS_WIDTH_MASK) {
 679         case DDRCTRL_MSTR_DATA_BUS_WIDTH_QUARTER:
 680                 bus_width = 8;
 681                 break;
 682         case DDRCTRL_MSTR_DATA_BUS_WIDTH_HALF:
 683                 bus_width = 16;
 684                 break;
 685         default:
 686                 bus_width = 32;
 687                 break;
 688         }
 689
 690
 691         if (config->c_reg.mstr & DDRCTRL_MSTR_DDR3)
 692                 ret = board_ddr_power_init(STM32MP_DDR3);
 693         else if (config->c_reg.mstr & DDRCTRL_MSTR_LPDDR2) {
 694                 if (bus_width == 32)
 695                         ret = board_ddr_power_init(STM32MP_LPDDR2_32);
 696                 else
 697                         ret = board_ddr_power_init(STM32MP_LPDDR2_16);
 698         } else if (config->c_reg.mstr & DDRCTRL_MSTR_LPDDR3) {
 699                 if (bus_width == 32)
 700                         ret = board_ddr_power_init(STM32MP_LPDDR3_32);
 701                 else
 702                         ret = board_ddr_power_init(STM32MP_LPDDR3_16);
 703         }
 704         if (ret)
 705                 panic("ddr power init failed\n");
 706
 707 start:
 708         debug("name = %s\n", config->info.name);
 709         debug("speed = %d kHz\n", config->info.speed);
 710         debug("size  = 0x%x\n", config->info.size);
 711 /*
 712  * 1. Program the DWC_ddr_umctl2 registers
 713  * 1.1 RESETS: presetn, core_ddrc_rstn, aresetn
 714  */
 715         /* Assert All DDR part */
 716         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCAPBRST);
 717         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCAXIRST);
 718         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCORERST);
 719         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYAPBRST);
 720         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYRST);
 721         setbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYCTLRST);
 722
 723 /* 1.2. start CLOCK */
 724         if (stm32mp1_ddr_clk_enable(priv, config->info.speed))
 725                 panic("invalid DRAM clock : %d kHz\n",
 726                       config->info.speed);
 727
 728 /* 1.3. deassert reset */
 729         /* de-assert PHY rstn and ctl_rstn via DPHYRST and DPHYCTLRST */
 730         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYRST);
 731         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYCTLRST);
 732         /* De-assert presetn once the clocks are active
 733          * and stable via DDRCAPBRST bit
 734          */
 735         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCAPBRST);
 736
 737 /* 1.4. wait 128 cycles to permit initialization of end logic */
 738         udelay(2);
 739         /* for PCLK = 133MHz => 1 us is enough, 2 to allow lower frequency */
 740
 741         if (INTERACTIVE(STEP_DDR_RESET))
 742                 goto start;
 743
 744 /* 1.5. initialize registers ddr_umctl2 */
 745         /* Stop uMCTL2 before PHY is ready */
 746         clrbits_le32(&priv->ctl->dfimisc, DDRCTRL_DFIMISC_DFI_INIT_COMPLETE_EN);
 747         debug("[0x%08x] dfimisc = 0x%08x\n",
 748               (u32)&priv->ctl->dfimisc, readl(&priv->ctl->dfimisc));
 749
 750         set_reg(priv, REG_REG, &config->c_reg);
 751         set_reg(priv, REG_TIMING, &config->c_timing);
 752         set_reg(priv, REG_MAP, &config->c_map);
 753
 754         /* skip CTRL init, SDRAM init is done by PHY PUBL */
 755         clrsetbits_le32(&priv->ctl->init0,
 756                         DDRCTRL_INIT0_SKIP_DRAM_INIT_MASK,
 757                         DDRCTRL_INIT0_SKIP_DRAM_INIT_NORMAL);
 758
 759         set_reg(priv, REG_PERF, &config->c_perf);
 760
 761         if (INTERACTIVE(STEP_CTL_INIT))
 762                 goto start;
 763
 764 /*  2. deassert reset signal core_ddrc_rstn, aresetn and presetn */
 765         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCORERST);
 766         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DDRCAXIRST);
 767         clrbits_le32(priv->rcc + RCC_DDRITFCR, RCC_DDRITFCR_DPHYAPBRST);
 768
 769 /*  3. start PHY init by accessing relevant PUBL registers
 770  *    (DXGCR, DCR, PTR*, MR*, DTPR*)
 771  */
 772         set_reg(priv, REGPHY_REG, &config->p_reg);
 773         set_reg(priv, REGPHY_TIMING, &config->p_timing);
 774         if (config->p_cal_present)
 775                 set_reg(priv, REGPHY_CAL, &config->p_cal);
 776
 777         if (INTERACTIVE(STEP_PHY_INIT))
 778                 goto start;
 779
 780 /*  4. Monitor PHY init status by polling PUBL register PGSR.IDONE
 781  *     Perform DDR PHY DRAM initialization and Gate Training Evaluation
 782  */
 783         ddrphy_idone_wait(priv->phy);
 784
 785 /*  5. Indicate to PUBL that controller performs SDRAM initialization
 786  *     by setting PIR.INIT and PIR CTLDINIT and pool PGSR.IDONE
 787  *     DRAM init is done by PHY, init0.skip_dram.init = 1
 788  */
 789         pir = DDRPHYC_PIR_DLLSRST | DDRPHYC_PIR_DLLLOCK | DDRPHYC_PIR_ZCAL |
 790               DDRPHYC_PIR_ITMSRST | DDRPHYC_PIR_DRAMINIT | DDRPHYC_PIR_ICPC;
 791
 792         if (config->c_reg.mstr & DDRCTRL_MSTR_DDR3)
 793                 pir |= DDRPHYC_PIR_DRAMRST; /* only for DDR3 */
 794
 795         stm32mp1_ddrphy_init(priv->phy, pir);
 796
 797 /*  6. SET DFIMISC.dfi_init_complete_en to 1 */
 798         /* Enable quasi-dynamic register programming*/
 799         start_sw_done(priv->ctl);
 800         setbits_le32(&priv->ctl->dfimisc, DDRCTRL_DFIMISC_DFI_INIT_COMPLETE_EN);
 801         wait_sw_done_ack(priv->ctl);
 802
 803 /*  7. Wait for DWC_ddr_umctl2 to move to normal operation mode
 804  *     by monitoring STAT.operating_mode signal
 805  */
 806         /* wait uMCTL2 ready */
 807
 808         wait_operating_mode(priv, DDRCTRL_STAT_OPERATING_MODE_NORMAL);
 809
 810         if (config->p_cal_present) {
 811                 debug("DDR DQS training skipped.\n");
 812         } else {
 813                 debug("DDR DQS training : ");
 814 /*  8. Disable Auto refresh and power down by setting
 815  *    - RFSHCTL3.dis_au_refresh = 1
 816  *    - PWRCTL.powerdown_en = 0
 817  *    - DFIMISC.dfiinit_complete_en = 0
 818  */
 819                 stm32mp1_refresh_disable(priv->ctl);
 820
 821 /*  9. Program PUBL PGCR to enable refresh during training and rank to train
 822  *     not done => keep the programed value in PGCR
 823  */
 824
 825 /* 10. configure PUBL PIR register to specify which training step to run */
 826         /* warning : RVTRN  is not supported by this PUBL */
 827                 stm32mp1_ddrphy_init(priv->phy, DDRPHYC_PIR_QSTRN);
 828
 829 /* 11. monitor PUB PGSR.IDONE to poll cpmpletion of training sequence */
 830                 ddrphy_idone_wait(priv->phy);
 831
 832 /* 12. set back registers in step 8 to the orginal values if desidered */
 833                 stm32mp1_refresh_restore(priv->ctl, config->c_reg.rfshctl3,
 834                                          config->c_reg.pwrctl);
 835         } /* if (config->p_cal_present) */
 836
 837         /* enable uMCTL2 AXI port 0 and 1 */
 838         setbits_le32(&priv->ctl->pctrl_0, DDRCTRL_PCTRL_N_PORT_EN);
 839         setbits_le32(&priv->ctl->pctrl_1, DDRCTRL_PCTRL_N_PORT_EN);
 840
 841         if (INTERACTIVE(STEP_DDR_READY))
 842                 goto start;
 843 }