drivers/ram/mpc83xx_sdram.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2018
   4  * Mario Six, Guntermann & Drunck GmbH, mario.six@gdsys.cc
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <init.h>
  10 #include <log.h>
  11 #include <ram.h>
  12 #include <dt-bindings/memory/mpc83xx-sdram.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /* Masks for the CS config register */
  17 static const u32 CSCONFIG_ENABLE = 0x80000000;
  18
  19 static const u32 BANK_BITS_2;
  20 static const u32 BANK_BITS_3 = 0x00004000;
  21
  22 static const u32 ROW_BITS_12;
  23 static const u32 ROW_BITS_13 = 0x00000100;
  24 static const u32 ROW_BITS_14 = 0x00000200;
  25
  26 static const u32 COL_BITS_8;
  27 static const u32 COL_BITS_9  = 0x00000001;
  28 static const u32 COL_BITS_10 = 0x00000002;
  29 static const u32 COL_BITS_11 = 0x00000003;
  30
  31 /* Shifts for the DDR SDRAM Timing Configuration 3 register */
  32 static const uint TIMING_CFG3_EXT_REFREC_SHIFT = (31 - 15);
  33
  34 /* Shifts for the DDR SDRAM Timing Configuration 0 register */
  35 static const uint TIMING_CFG0_RWT_SHIFT         = (31 - 1);
  36 static const uint TIMING_CFG0_WRT_SHIFT         = (31 - 3);
  37 static const uint TIMING_CFG0_RRT_SHIFT         = (31 - 5);
  38 static const uint TIMING_CFG0_WWT_SHIFT         = (31 - 7);
  39 static const uint TIMING_CFG0_ACT_PD_EXIT_SHIFT = (31 - 11);
  40 static const uint TIMING_CFG0_PRE_PD_EXIT_SHIFT = (31 - 15);
  41 static const uint TIMING_CFG0_ODT_PD_EXIT_SHIFT = (31 - 23);
  42 static const uint TIMING_CFG0_MRS_CYC_SHIFT     = (31 - 31);
  43
  44 /* Shifts for the DDR SDRAM Timing Configuration 1 register */
  45 static const uint TIMING_CFG1_PRETOACT_SHIFT = (31 - 3);
  46 static const uint TIMING_CFG1_ACTTOPRE_SHIFT = (31 - 7);
  47 static const uint TIMING_CFG1_ACTTORW_SHIFT  = (31 - 11);
  48 static const uint TIMING_CFG1_CASLAT_SHIFT   = (31 - 15);
  49 static const uint TIMING_CFG1_REFREC_SHIFT   = (31 - 19);
  50 static const uint TIMING_CFG1_WRREC_SHIFT    = (31 - 23);
  51 static const uint TIMING_CFG1_ACTTOACT_SHIFT = (31 - 27);
  52 static const uint TIMING_CFG1_WRTORD_SHIFT   = (31 - 31);
  53
  54 /* Shifts for the DDR SDRAM Timing Configuration 2 register */
  55 static const uint TIMING_CFG2_CPO_SHIFT           = (31 - 8);
  56 static const uint TIMING_CFG2_WR_DATA_DELAY_SHIFT = (31 - 21);
  57 static const uint TIMING_CFG2_ADD_LAT_SHIFT       = (31 - 3);
  58 static const uint TIMING_CFG2_WR_LAT_DELAY_SHIFT  = (31 - 12);
  59 static const uint TIMING_CFG2_RD_TO_PRE_SHIFT     = (31 - 18);
  60 static const uint TIMING_CFG2_CKE_PLS_SHIFT       = (31 - 25);
  61 static const uint TIMING_CFG2_FOUR_ACT_SHIFT;
  62
  63 /* Shifts for the DDR SDRAM Control Configuration register */
  64 static const uint SDRAM_CFG_SREN_SHIFT         = (31 - 1);
  65 static const uint SDRAM_CFG_ECC_EN_SHIFT       = (31 - 2);
  66 static const uint SDRAM_CFG_RD_EN_SHIFT        = (31 - 3);
  67 static const uint SDRAM_CFG_SDRAM_TYPE_SHIFT   = (31 - 7);
  68 static const uint SDRAM_CFG_DYN_PWR_SHIFT      = (31 - 10);
  69 static const uint SDRAM_CFG_DBW_SHIFT          = (31 - 12);
  70 static const uint SDRAM_CFG_NCAP_SHIFT         = (31 - 14);
  71 static const uint SDRAM_CFG_2T_EN_SHIFT        = (31 - 16);
  72 static const uint SDRAM_CFG_BA_INTLV_CTL_SHIFT = (31 - 23);
  73 static const uint SDRAM_CFG_PCHB8_SHIFT        = (31 - 27);
  74 static const uint SDRAM_CFG_HSE_SHIFT          = (31 - 28);
  75 static const uint SDRAM_CFG_BI_SHIFT           = (31 - 31);
  76
  77 /* Shifts for the DDR SDRAM Control Configuration 2 register */
  78 static const uint SDRAM_CFG2_FRC_SR_SHIFT = (31 - 0);
  79 static const uint SDRAM_CFG2_DLL_RST_DIS  = (31 - 2);
  80 static const uint SDRAM_CFG2_DQS_CFG      = (31 - 5);
  81 static const uint SDRAM_CFG2_ODT_CFG      = (31 - 10);
  82 static const uint SDRAM_CFG2_NUM_PR       = (31 - 19);
  83
  84 /* Shifts for the DDR SDRAM Mode register */
  85 static const uint SDRAM_MODE_ESD_SHIFT = (31 - 15);
  86 static const uint SDRAM_MODE_SD_SHIFT  = (31 - 31);
  87
  88 /* Shifts for the DDR SDRAM Mode 2 register */
  89 static const uint SDRAM_MODE2_ESD2_SHIFT = (31 - 15);
  90 static const uint SDRAM_MODE2_ESD3_SHIFT = (31 - 31);
  91
  92 /* Shifts for the DDR SDRAM Interval Configuration register */
  93 static const uint SDRAM_INTERVAL_REFINT_SHIFT  = (31 - 15);
  94 static const uint SDRAM_INTERVAL_BSTOPRE_SHIFT = (31 - 31);
  95
  96 /* Mask for the DDR SDRAM Mode Control register */
  97 static const u32 SDRAM_CFG_MEM_EN = 0x80000000;
  98
  99 int dram_init(void)
 100 {
 101         struct udevice *ram_ctrl;
 102         int ret;
 103
 104         /* Current assumption: There is only one RAM controller */
 105         ret = uclass_first_device_err(UCLASS_RAM, &ram_ctrl);
 106         if (ret) {
 107                 debug("%s: uclass_first_device_err failed: %d\n",
 108                       __func__, ret);
 109                 return ret;
 110         }
 111
 112         /* FIXME(mario.six@gdsys.cc): Set gd->ram_size? */
 113
 114         return 0;
 115 }
 116
 117 phys_size_t get_effective_memsize(void)
 118 {
 119         if (!IS_ENABLED(CONFIG_VERY_BIG_RAM))
 120                 return gd->ram_size;
 121
 122         /* Limit stack to what we can reasonable map */
 123         return ((gd->ram_size > CONFIG_MAX_MEM_MAPPED) ?
 124                 CONFIG_MAX_MEM_MAPPED : gd->ram_size);
 125 }
 126
 127 /**
 128  * struct mpc83xx_sdram_priv - Private data for MPC83xx RAM controllers
 129  * @total_size: The total size of all RAM modules associated with this RAM
 130  *              controller in bytes
 131  */
 132 struct mpc83xx_sdram_priv {
 133         ulong total_size;
 134 };
 135
 136 /**
 137  * mpc83xx_sdram_static_init() - Statically initialize a RAM module.
 138  * @node:    Device tree node associated with ths module in question
 139  * @cs:      The chip select to use for this RAM module
 140  * @mapaddr: The address where the RAM module should be mapped
 141  * @size:    The size of the RAM module to be mapped in bytes
 142  *
 143  * Return: 0 if OK, -ve on error
 144  */
 145 static int mpc83xx_sdram_static_init(ofnode node, u32 cs, u32 mapaddr, u32 size)
 146 {
 147         immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 148         u32 msize = size;
 149         u32 msize_log2 = __ilog2(msize);
 150         u32 auto_precharge, odt_rd_cfg, odt_wr_cfg, bank_bits, row_bits,
 151             col_bits;
 152         u32 bank_bits_mask, row_bits_mask, col_bits_mask;
 153
 154         /* Configure the DDR local access window */
 155         out_be32(&im->sysconf.ddrlaw[cs].bar, mapaddr & 0xfffff000);
 156         out_be32(&im->sysconf.ddrlaw[cs].ar, LBLAWAR_EN | (msize_log2 - 1));
 157
 158         out_be32(&im->ddr.csbnds[cs].csbnds, (msize - 1) >> 24);
 159
 160         auto_precharge = ofnode_read_u32_default(node, "auto_precharge", 0);
 161         switch (auto_precharge) {
 162         case AUTO_PRECHARGE_ENABLE:
 163         case AUTO_PRECHARGE_DISABLE:
 164                 break;
 165         default:
 166                 debug("%s: auto_precharge value %d invalid.\n",
 167                       ofnode_get_name(node), auto_precharge);
 168                 return -EINVAL;
 169         }
 170
 171         odt_rd_cfg = ofnode_read_u32_default(node, "odt_rd_cfg", 0);
 172         switch (odt_rd_cfg) {
 173         case ODT_RD_ONLY_OTHER_DIMM:
 174                 if (!IS_ENABLED(CONFIG_ARCH_MPC8360) &&
 175                     !IS_ENABLED(CONFIG_ARCH_MPC837X)) {
 176                         debug("%s: odt_rd_cfg value %d invalid.\n",
 177                               ofnode_get_name(node), odt_rd_cfg);
 178                         return -EINVAL;
 179                 }
 180                 /* fall through */
 181         case ODT_RD_NEVER:
 182         case ODT_RD_ONLY_CURRENT:
 183         case ODT_RD_ONLY_OTHER_CS:
 184                 if (!IS_ENABLED(CONFIG_ARCH_MPC830X) &&
 185                     !IS_ENABLED(CONFIG_ARCH_MPC831X) &&
 186                     !IS_ENABLED(CONFIG_ARCH_MPC8360) &&
 187                     !IS_ENABLED(CONFIG_ARCH_MPC837X)) {
 188                         debug("%s: odt_rd_cfg value %d invalid.\n",
 189                               ofnode_get_name(node), odt_rd_cfg);
 190                         return -EINVAL;
 191                 }
 192                 /* fall through */
 193         /* Only MPC832x knows this value */
 194         case ODT_RD_ALL:
 195                 break;
 196         default:
 197                 debug("%s: odt_rd_cfg value %d invalid.\n",
 198                       ofnode_get_name(node), odt_rd_cfg);
 199                 return -EINVAL;
 200         }
 201
 202         odt_wr_cfg = ofnode_read_u32_default(node, "odt_wr_cfg", 0);
 203         switch (odt_wr_cfg) {
 204         case ODT_WR_ONLY_OTHER_DIMM:
 205                 if (!IS_ENABLED(CONFIG_ARCH_MPC8360) &&
 206                     !IS_ENABLED(CONFIG_ARCH_MPC837X)) {
 207                         debug("%s: odt_wr_cfg value %d invalid.\n",
 208                               ofnode_get_name(node), odt_wr_cfg);
 209                         return -EINVAL;
 210                 }
 211                 /* fall through */
 212         case ODT_WR_NEVER:
 213         case ODT_WR_ONLY_CURRENT:
 214         case ODT_WR_ONLY_OTHER_CS:
 215                 if (!IS_ENABLED(CONFIG_ARCH_MPC830X) &&
 216                     !IS_ENABLED(CONFIG_ARCH_MPC831X) &&
 217                     !IS_ENABLED(CONFIG_ARCH_MPC8360) &&
 218                     !IS_ENABLED(CONFIG_ARCH_MPC837X)) {
 219                         debug("%s: odt_wr_cfg value %d invalid.\n",
 220                               ofnode_get_name(node), odt_wr_cfg);
 221                         return -EINVAL;
 222                 }
 223                 /* fall through */
 224         /* MPC832x only knows this value */
 225         case ODT_WR_ALL:
 226                 break;
 227         default:
 228                 debug("%s: odt_wr_cfg value %d invalid.\n",
 229                       ofnode_get_name(node), odt_wr_cfg);
 230                 return -EINVAL;
 231         }
 232
 233         bank_bits = ofnode_read_u32_default(node, "bank_bits", 0);
 234         switch (bank_bits) {
 235         case 2:
 236                 bank_bits_mask = BANK_BITS_2;
 237                 break;
 238         case 3:
 239                 bank_bits_mask = BANK_BITS_3;
 240                 break;
 241         default:
 242                 debug("%s: bank_bits value %d invalid.\n",
 243                       ofnode_get_name(node), bank_bits);
 244                 return -EINVAL;
 245         }
 246
 247         row_bits = ofnode_read_u32_default(node, "row_bits", 0);
 248         switch (row_bits) {
 249         case 12:
 250                 row_bits_mask = ROW_BITS_12;
 251                 break;
 252         case 13:
 253                 row_bits_mask = ROW_BITS_13;
 254                 break;
 255         case 14:
 256                 row_bits_mask = ROW_BITS_14;
 257                 break;
 258         default:
 259                 debug("%s: row_bits value %d invalid.\n",
 260                       ofnode_get_name(node), row_bits);
 261                 return -EINVAL;
 262         }
 263
 264         col_bits = ofnode_read_u32_default(node, "col_bits", 0);
 265         switch (col_bits) {
 266         case 8:
 267                 col_bits_mask = COL_BITS_8;
 268                 break;
 269         case 9:
 270                 col_bits_mask = COL_BITS_9;
 271                 break;
 272         case 10:
 273                 col_bits_mask = COL_BITS_10;
 274                 break;
 275         case 11:
 276                 col_bits_mask = COL_BITS_11;
 277                 break;
 278         default:
 279                 debug("%s: col_bits value %d invalid.\n",
 280                       ofnode_get_name(node), col_bits);
 281                 return -EINVAL;
 282         }
 283
 284         /* Write CS config value */
 285         out_be32(&im->ddr.cs_config[cs], CSCONFIG_ENABLE | auto_precharge |
 286                                          odt_rd_cfg | odt_wr_cfg |
 287                                          bank_bits_mask | row_bits_mask |
 288                                          col_bits_mask);
 289         return 0;
 290 }
 291
 292 /**
 293  * mpc83xx_sdram_spd_init() - Initialize a RAM module using a SPD flash.
 294  * @node:    Device tree node associated with ths module in question
 295  * @cs:      The chip select to use for this RAM module
 296  * @mapaddr: The address where the RAM module should be mapped
 297  * @size:    The size of the RAM module to be mapped in bytes
 298  *
 299  * Return: 0 if OK, -ve on error
 300  */
 301 static int mpc83xx_sdram_spd_init(ofnode node, u32 cs, u32 mapaddr, u32 size)
 302 {
 303         /* TODO(mario.six@gdsys.cc): Implement */
 304         return 0;
 305 }
 306
 307 static int mpc83xx_sdram_ofdata_to_platdata(struct udevice *dev)
 308 {
 309         return 0;
 310 }
 311
 312 static int mpc83xx_sdram_probe(struct udevice *dev)
 313 {
 314         struct mpc83xx_sdram_priv *priv = dev_get_priv(dev);
 315         immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
 316         int ret = 0;
 317         ofnode subnode;
 318         /* DDR control driver register values */
 319         u32 dso, pz_override, nz_override, odt_term, ddr_type, mvref_sel, m_odr;
 320         u32 ddrcdr;
 321         /* DDR SDRAM Clock Control register values */
 322         u32 clock_adjust;
 323         /* DDR SDRAM Timing Configuration 3 register values */
 324         u32 ext_refresh_rec, ext_refresh_rec_mask;
 325         /* DDR SDRAM Timing Configuration 0 register values */
 326         u32 read_to_write, write_to_read, read_to_read, write_to_write,
 327             active_powerdown_exit, precharge_powerdown_exit,
 328             odt_powerdown_exit, mode_reg_set_cycle;
 329         u32 timing_cfg_0;
 330         /* DDR SDRAM Timing Configuration 1 register values */
 331         u32 precharge_to_activate, activate_to_precharge,
 332             activate_to_readwrite, mcas_latency, refresh_recovery,
 333             last_data_to_precharge, activate_to_activate,
 334             last_write_data_to_read;
 335         u32 timing_cfg_1;
 336         /* DDR SDRAM Timing Configuration 2 register values */
 337         u32 additive_latency, mcas_to_preamble_override, write_latency,
 338             read_to_precharge, write_cmd_to_write_data,
 339             minimum_cke_pulse_width, four_activates_window;
 340         u32 timing_cfg_2;
 341         /* DDR SDRAM Control Configuration register values */
 342         u32 self_refresh, ecc, registered_dram, sdram_type,
 343             dynamic_power_management, databus_width, nc_auto_precharge,
 344             timing_2t, bank_interleaving_ctrl, precharge_bit_8, half_strength,
 345             bypass_initialization;
 346         u32 sdram_cfg;
 347         /* DDR SDRAM Control Configuration 2 register values */
 348         u32 force_self_refresh, dll_reset, dqs_config, odt_config,
 349             posted_refreshes;
 350         u32 sdram_cfg2;
 351         /* DDR SDRAM Mode Configuration register values */
 352         u32 sdmode, esdmode;
 353         u32 sdram_mode;
 354         /* DDR SDRAM Mode Configuration 2 register values */
 355         u32 esdmode2, esdmode3;
 356         u32 sdram_mode2;
 357         /* DDR SDRAM Interval Configuration register values */
 358         u32 refresh_interval, precharge_interval;
 359         u32 sdram_interval;
 360
 361         priv->total_size = 0;
 362
 363         /* Disable both banks initially (might be re-enabled in loop below) */
 364         out_be32(&im->ddr.cs_config[0], 0);
 365         out_be32(&im->ddr.cs_config[1], 0);
 366
 367         dso = dev_read_u32_default(dev, "driver_software_override", 0);
 368         if (dso > 1) {
 369                 debug("%s: driver_software_override value %d invalid.\n",
 370                       dev->name, dso);
 371                 return -EINVAL;
 372         }
 373
 374         pz_override = dev_read_u32_default(dev, "p_impedance_override", 0);
 375
 376         switch (pz_override) {
 377         case DSO_P_IMPEDANCE_HIGHEST_Z:
 378         case DSO_P_IMPEDANCE_MUCH_HIGHER_Z:
 379         case DSO_P_IMPEDANCE_HIGHER_Z:
 380         case DSO_P_IMPEDANCE_NOMINAL:
 381         case DSO_P_IMPEDANCE_LOWER_Z:
 382                 break;
 383         default:
 384                 debug("%s: p_impedance_override value %d invalid.\n",
 385                       dev->name, pz_override);
 386                 return -EINVAL;
 387         }
 388
 389         nz_override = dev_read_u32_default(dev, "n_impedance_override", 0);
 390
 391         switch (nz_override) {
 392         case DSO_N_IMPEDANCE_HIGHEST_Z:
 393         case DSO_N_IMPEDANCE_MUCH_HIGHER_Z:
 394         case DSO_N_IMPEDANCE_HIGHER_Z:
 395         case DSO_N_IMPEDANCE_NOMINAL:
 396         case DSO_N_IMPEDANCE_LOWER_Z:
 397                 break;
 398         default:
 399                 debug("%s: n_impedance_override value %d invalid.\n",
 400                       dev->name, nz_override);
 401                 return -EINVAL;
 402         }
 403
 404         odt_term = dev_read_u32_default(dev, "odt_termination_value", 0);
 405         if (odt_term > 1) {
 406                 debug("%s: odt_termination_value value %d invalid.\n",
 407                       dev->name, odt_term);
 408                 return -EINVAL;
 409         }
 410
 411         ddr_type = dev_read_u32_default(dev, "ddr_type", 0);
 412         if (ddr_type > 1) {
 413                 debug("%s: ddr_type value %d invalid.\n",
 414                       dev->name, ddr_type);
 415                 return -EINVAL;
 416         }
 417
 418         mvref_sel = dev_read_u32_default(dev, "mvref_sel", 0);
 419         if (mvref_sel > 1) {
 420                 debug("%s: mvref_sel value %d invalid.\n",
 421                       dev->name, mvref_sel);
 422                 return -EINVAL;
 423         }
 424
 425         m_odr = dev_read_u32_default(dev, "m_odr", 0);
 426         if (mvref_sel > 1) {
 427                 debug("%s: m_odr value %d invalid.\n",
 428                       dev->name, m_odr);
 429                 return -EINVAL;
 430         }
 431
 432         ddrcdr = dso << (31 - 1) |
 433                  pz_override << (31 - 5) |
 434                  nz_override << (31 - 9) |
 435                  odt_term << (31 - 12) |
 436                  ddr_type << (31 - 13) |
 437                  mvref_sel << (31 - 29) |
 438                  m_odr << (31 - 30) | 1;
 439
 440         /* Configure the DDR control driver register */
 441         out_be32(&im->sysconf.ddrcdr, ddrcdr);
 442
 443         dev_for_each_subnode(subnode, dev) {
 444                 u32 val[3];
 445                 u32 cs, addr, size;
 446
 447                 /* CS, map address, size -> three values */
 448                 ofnode_read_u32_array(subnode, "reg", val, 3);
 449
 450                 cs = val[0];
 451                 addr = val[1];
 452                 size = val[2];
 453
 454                 if (cs > 1) {
 455                         debug("%s: chip select value %d invalid.\n",
 456                               dev->name, cs);
 457                         return -EINVAL;
 458                 }
 459
 460                 /* TODO(mario.six@gdsys.cc): Sanity check for size. */
 461
 462                 if (ofnode_read_bool(subnode, "read-spd"))
 463                         ret = mpc83xx_sdram_spd_init(subnode, cs, addr, size);
 464                 else
 465                         ret = mpc83xx_sdram_static_init(subnode, cs, addr,
 466                                                         size);
 467                 if (ret) {
 468                         debug("%s: RAM init failed.\n", dev->name);
 469                         return ret;
 470                 }
 471         };
 472
 473         /*
 474          * TODO(mario.six@gdsys.cc): This should only occur for static
 475          *                           configuration
 476          */
 477
 478         clock_adjust = dev_read_u32_default(dev, "clock_adjust", 0);
 479         switch (clock_adjust) {
 480         case CLOCK_ADJUST_025:
 481         case CLOCK_ADJUST_05:
 482         case CLOCK_ADJUST_075:
 483         case CLOCK_ADJUST_1:
 484                 break;
 485         default:
 486                 debug("%s: clock_adjust value %d invalid.\n",
 487                       dev->name, clock_adjust);
 488                 return -EINVAL;
 489         }
 490
 491         /* Configure the DDR SDRAM Clock Control register */
 492         out_be32(&im->ddr.sdram_clk_cntl, clock_adjust);
 493
 494         ext_refresh_rec = dev_read_u32_default(dev, "ext_refresh_rec", 0);
 495         switch (ext_refresh_rec) {
 496         case 0:
 497                 ext_refresh_rec_mask = 0 << TIMING_CFG3_EXT_REFREC_SHIFT;
 498                 break;
 499         case 16:
 500                 ext_refresh_rec_mask = 1 << TIMING_CFG3_EXT_REFREC_SHIFT;
 501                 break;
 502         case 32:
 503                 ext_refresh_rec_mask = 2 << TIMING_CFG3_EXT_REFREC_SHIFT;
 504                 break;
 505         case 48:
 506                 ext_refresh_rec_mask = 3 << TIMING_CFG3_EXT_REFREC_SHIFT;
 507                 break;
 508         case 64:
 509                 ext_refresh_rec_mask = 4 << TIMING_CFG3_EXT_REFREC_SHIFT;
 510                 break;
 511         case 80:
 512                 ext_refresh_rec_mask = 5 << TIMING_CFG3_EXT_REFREC_SHIFT;
 513                 break;
 514         case 96:
 515                 ext_refresh_rec_mask = 6 << TIMING_CFG3_EXT_REFREC_SHIFT;
 516                 break;
 517         case 112:
 518                 ext_refresh_rec_mask = 7 << TIMING_CFG3_EXT_REFREC_SHIFT;
 519                 break;
 520         default:
 521                 debug("%s: ext_refresh_rec value %d invalid.\n",
 522                       dev->name, ext_refresh_rec);
 523                 return -EINVAL;
 524         }
 525
 526         /* Configure the DDR SDRAM Timing Configuration 3 register */
 527         out_be32(&im->ddr.timing_cfg_3, ext_refresh_rec_mask);
 528
 529         read_to_write = dev_read_u32_default(dev, "read_to_write", 0);
 530         if (read_to_write > 3) {
 531                 debug("%s: read_to_write value %d invalid.\n",
 532                       dev->name, read_to_write);
 533                 return -EINVAL;
 534         }
 535
 536         write_to_read = dev_read_u32_default(dev, "write_to_read", 0);
 537         if (write_to_read > 3) {
 538                 debug("%s: write_to_read value %d invalid.\n",
 539                       dev->name, write_to_read);
 540                 return -EINVAL;
 541         }
 542
 543         read_to_read = dev_read_u32_default(dev, "read_to_read", 0);
 544         if (read_to_read > 3) {
 545                 debug("%s: read_to_read value %d invalid.\n",
 546                       dev->name, read_to_read);
 547                 return -EINVAL;
 548         }
 549
 550         write_to_write = dev_read_u32_default(dev, "write_to_write", 0);
 551         if (write_to_write > 3) {
 552                 debug("%s: write_to_write value %d invalid.\n",
 553                       dev->name, write_to_write);
 554                 return -EINVAL;
 555         }
 556
 557         active_powerdown_exit =
 558                 dev_read_u32_default(dev, "active_powerdown_exit", 0);
 559         if (active_powerdown_exit > 7) {
 560                 debug("%s: active_powerdown_exit value %d invalid.\n",
 561                       dev->name, active_powerdown_exit);
 562                 return -EINVAL;
 563         }
 564
 565         precharge_powerdown_exit =
 566                 dev_read_u32_default(dev, "precharge_powerdown_exit", 0);
 567         if (precharge_powerdown_exit > 7) {
 568                 debug("%s: precharge_powerdown_exit value %d invalid.\n",
 569                       dev->name, precharge_powerdown_exit);
 570                 return -EINVAL;
 571         }
 572
 573         odt_powerdown_exit = dev_read_u32_default(dev, "odt_powerdown_exit", 0);
 574         if (odt_powerdown_exit > 15) {
 575                 debug("%s: odt_powerdown_exit value %d invalid.\n",
 576                       dev->name, odt_powerdown_exit);
 577                 return -EINVAL;
 578         }
 579
 580         mode_reg_set_cycle = dev_read_u32_default(dev, "mode_reg_set_cycle", 0);
 581         if (mode_reg_set_cycle > 15) {
 582                 debug("%s: mode_reg_set_cycle value %d invalid.\n",
 583                       dev->name, mode_reg_set_cycle);
 584                 return -EINVAL;
 585         }
 586
 587         timing_cfg_0 = read_to_write << TIMING_CFG0_RWT_SHIFT |
 588                        write_to_read << TIMING_CFG0_WRT_SHIFT |
 589                        read_to_read << TIMING_CFG0_RRT_SHIFT |
 590                        write_to_write << TIMING_CFG0_WWT_SHIFT |
 591                        active_powerdown_exit << TIMING_CFG0_ACT_PD_EXIT_SHIFT |
 592                        precharge_powerdown_exit << TIMING_CFG0_PRE_PD_EXIT_SHIFT |
 593                        odt_powerdown_exit << TIMING_CFG0_ODT_PD_EXIT_SHIFT |
 594                        mode_reg_set_cycle << TIMING_CFG0_MRS_CYC_SHIFT;
 595
 596         out_be32(&im->ddr.timing_cfg_0, timing_cfg_0);
 597
 598         precharge_to_activate =
 599                 dev_read_u32_default(dev, "precharge_to_activate", 0);
 600         if (precharge_to_activate > 7 || precharge_to_activate == 0) {
 601                 debug("%s: precharge_to_activate value %d invalid.\n",
 602                       dev->name, precharge_to_activate);
 603                 return -EINVAL;
 604         }
 605
 606         activate_to_precharge =
 607                 dev_read_u32_default(dev, "activate_to_precharge", 0);
 608         if (activate_to_precharge > 19) {
 609                 debug("%s: activate_to_precharge value %d invalid.\n",
 610                       dev->name, activate_to_precharge);
 611                 return -EINVAL;
 612         }
 613
 614         activate_to_readwrite =
 615                 dev_read_u32_default(dev, "activate_to_readwrite", 0);
 616         if (activate_to_readwrite > 7 || activate_to_readwrite == 0) {
 617                 debug("%s: activate_to_readwrite value %d invalid.\n",
 618                       dev->name, activate_to_readwrite);
 619                 return -EINVAL;
 620         }
 621
 622         mcas_latency = dev_read_u32_default(dev, "mcas_latency", 0);
 623         switch (mcas_latency) {
 624         case CASLAT_20:
 625         case CASLAT_25:
 626                 if (!IS_ENABLED(CONFIG_ARCH_MPC8308)) {
 627                         debug("%s: MCAS latency < 3.0 unsupported on MPC8308\n",
 628                               dev->name);
 629                         return -EINVAL;
 630                 }
 631                 /* fall through */
 632         case CASLAT_30:
 633         case CASLAT_35:
 634         case CASLAT_40:
 635         case CASLAT_45:
 636         case CASLAT_50:
 637         case CASLAT_55:
 638         case CASLAT_60:
 639         case CASLAT_65:
 640         case CASLAT_70:
 641         case CASLAT_75:
 642         case CASLAT_80:
 643                 break;
 644         default:
 645                 debug("%s: mcas_latency value %d invalid.\n",
 646                       dev->name, mcas_latency);
 647                 return -EINVAL;
 648         }
 649
 650         refresh_recovery = dev_read_u32_default(dev, "refresh_recovery", 0);
 651         if (refresh_recovery > 23 || refresh_recovery < 8) {
 652                 debug("%s: refresh_recovery value %d invalid.\n",
 653                       dev->name, refresh_recovery);
 654                 return -EINVAL;
 655         }
 656
 657         last_data_to_precharge =
 658                 dev_read_u32_default(dev, "last_data_to_precharge", 0);
 659         if (last_data_to_precharge > 7 || last_data_to_precharge == 0) {
 660                 debug("%s: last_data_to_precharge value %d invalid.\n",
 661                       dev->name, last_data_to_precharge);
 662                 return -EINVAL;
 663         }
 664
 665         activate_to_activate =
 666                 dev_read_u32_default(dev, "activate_to_activate", 0);
 667         if (activate_to_activate > 7 || activate_to_activate == 0) {
 668                 debug("%s: activate_to_activate value %d invalid.\n",
 669                       dev->name, activate_to_activate);
 670                 return -EINVAL;
 671         }
 672
 673         last_write_data_to_read =
 674                 dev_read_u32_default(dev, "last_write_data_to_read", 0);
 675         if (last_write_data_to_read > 7 || last_write_data_to_read == 0) {
 676                 debug("%s: last_write_data_to_read value %d invalid.\n",
 677                       dev->name, last_write_data_to_read);
 678                 return -EINVAL;
 679         }
 680
 681         timing_cfg_1 = precharge_to_activate << TIMING_CFG1_PRETOACT_SHIFT |
 682                        (activate_to_precharge > 15 ?
 683                         activate_to_precharge - 16 :
 684                         activate_to_precharge) << TIMING_CFG1_ACTTOPRE_SHIFT |
 685                        activate_to_readwrite << TIMING_CFG1_ACTTORW_SHIFT |
 686                        mcas_latency << TIMING_CFG1_CASLAT_SHIFT |
 687                        (refresh_recovery - 8) << TIMING_CFG1_REFREC_SHIFT |
 688                        last_data_to_precharge << TIMING_CFG1_WRREC_SHIFT |
 689                        activate_to_activate << TIMING_CFG1_ACTTOACT_SHIFT |
 690                        last_write_data_to_read << TIMING_CFG1_WRTORD_SHIFT;
 691
 692         /* Configure the DDR SDRAM Timing Configuration 1 register */
 693         out_be32(&im->ddr.timing_cfg_1, timing_cfg_1);
 694
 695         additive_latency = dev_read_u32_default(dev, "additive_latency", 0);
 696         if (additive_latency > 5) {
 697                 debug("%s: additive_latency value %d invalid.\n",
 698                       dev->name, additive_latency);
 699                 return -EINVAL;
 700         }
 701
 702         mcas_to_preamble_override =
 703                 dev_read_u32_default(dev, "mcas_to_preamble_override", 0);
 704         switch (mcas_to_preamble_override) {
 705         case READ_LAT_PLUS_1:
 706         case READ_LAT:
 707         case READ_LAT_PLUS_1_4:
 708         case READ_LAT_PLUS_1_2:
 709         case READ_LAT_PLUS_3_4:
 710         case READ_LAT_PLUS_5_4:
 711         case READ_LAT_PLUS_3_2:
 712         case READ_LAT_PLUS_7_4:
 713         case READ_LAT_PLUS_2:
 714         case READ_LAT_PLUS_9_4:
 715         case READ_LAT_PLUS_5_2:
 716         case READ_LAT_PLUS_11_4:
 717         case READ_LAT_PLUS_3:
 718         case READ_LAT_PLUS_13_4:
 719         case READ_LAT_PLUS_7_2:
 720         case READ_LAT_PLUS_15_4:
 721         case READ_LAT_PLUS_4:
 722         case READ_LAT_PLUS_17_4:
 723         case READ_LAT_PLUS_9_2:
 724         case READ_LAT_PLUS_19_4:
 725                 break;
 726         default:
 727                 debug("%s: mcas_to_preamble_override value %d invalid.\n",
 728                       dev->name, mcas_to_preamble_override);
 729                 return -EINVAL;
 730         }
 731
 732         write_latency = dev_read_u32_default(dev, "write_latency", 0);
 733         if (write_latency > 7 || write_latency == 0) {
 734                 debug("%s: write_latency value %d invalid.\n",
 735                       dev->name, write_latency);
 736                 return -EINVAL;
 737         }
 738
 739         read_to_precharge = dev_read_u32_default(dev, "read_to_precharge", 0);
 740         if (read_to_precharge > 4 || read_to_precharge == 0) {
 741                 debug("%s: read_to_precharge value %d invalid.\n",
 742                       dev->name, read_to_precharge);
 743                 return -EINVAL;
 744         }
 745
 746         write_cmd_to_write_data =
 747                 dev_read_u32_default(dev, "write_cmd_to_write_data", 0);
 748         switch (write_cmd_to_write_data) {
 749         case CLOCK_DELAY_0:
 750         case CLOCK_DELAY_1_4:
 751         case CLOCK_DELAY_1_2:
 752         case CLOCK_DELAY_3_4:
 753         case CLOCK_DELAY_1:
 754         case CLOCK_DELAY_5_4:
 755         case CLOCK_DELAY_3_2:
 756                 break;
 757         default:
 758                 debug("%s: write_cmd_to_write_data value %d invalid.\n",
 759                       dev->name, write_cmd_to_write_data);
 760                 return -EINVAL;
 761         }
 762
 763         minimum_cke_pulse_width =
 764                 dev_read_u32_default(dev, "minimum_cke_pulse_width", 0);
 765         if (minimum_cke_pulse_width > 4 || minimum_cke_pulse_width == 0) {
 766                 debug("%s: minimum_cke_pulse_width value %d invalid.\n",
 767                       dev->name, minimum_cke_pulse_width);
 768                 return -EINVAL;
 769         }
 770
 771         four_activates_window =
 772                 dev_read_u32_default(dev, "four_activates_window", 0);
 773         if (four_activates_window > 20 || four_activates_window == 0) {
 774                 debug("%s: four_activates_window value %d invalid.\n",
 775                       dev->name, four_activates_window);
 776                 return -EINVAL;
 777         }
 778
 779         timing_cfg_2 = additive_latency << TIMING_CFG2_ADD_LAT_SHIFT |
 780                        mcas_to_preamble_override << TIMING_CFG2_CPO_SHIFT |
 781                        write_latency << TIMING_CFG2_WR_LAT_DELAY_SHIFT |
 782                        read_to_precharge << TIMING_CFG2_RD_TO_PRE_SHIFT |
 783                        write_cmd_to_write_data << TIMING_CFG2_WR_DATA_DELAY_SHIFT |
 784                        minimum_cke_pulse_width << TIMING_CFG2_CKE_PLS_SHIFT |
 785                        four_activates_window << TIMING_CFG2_FOUR_ACT_SHIFT;
 786
 787         out_be32(&im->ddr.timing_cfg_2, timing_cfg_2);
 788
 789         self_refresh = dev_read_u32_default(dev, "self_refresh", 0);
 790         switch (self_refresh) {
 791         case SREN_DISABLE:
 792         case SREN_ENABLE:
 793                 break;
 794         default:
 795                 debug("%s: self_refresh value %d invalid.\n",
 796                       dev->name, self_refresh);
 797                 return -EINVAL;
 798         }
 799
 800         ecc = dev_read_u32_default(dev, "ecc", 0);
 801         switch (ecc) {
 802         case ECC_DISABLE:
 803         case ECC_ENABLE:
 804                 break;
 805         default:
 806                 debug("%s: ecc value %d invalid.\n", dev->name, ecc);
 807                 return -EINVAL;
 808         }
 809
 810         registered_dram = dev_read_u32_default(dev, "registered_dram", 0);
 811         switch (registered_dram) {
 812         case RD_DISABLE:
 813         case RD_ENABLE:
 814                 break;
 815         default:
 816                 debug("%s: registered_dram value %d invalid.\n",
 817                       dev->name, registered_dram);
 818                 return -EINVAL;
 819         }
 820
 821         sdram_type = dev_read_u32_default(dev, "sdram_type", 0);
 822         switch (sdram_type) {
 823         case TYPE_DDR1:
 824         case TYPE_DDR2:
 825                 break;
 826         default:
 827                 debug("%s: sdram_type value %d invalid.\n",
 828                       dev->name, sdram_type);
 829                 return -EINVAL;
 830         }
 831
 832         dynamic_power_management =
 833                 dev_read_u32_default(dev, "dynamic_power_management", 0);
 834         switch (dynamic_power_management) {
 835         case DYN_PWR_DISABLE:
 836         case DYN_PWR_ENABLE:
 837                 break;
 838         default:
 839                 debug("%s: dynamic_power_management value %d invalid.\n",
 840                       dev->name, dynamic_power_management);
 841                 return -EINVAL;
 842         }
 843
 844         databus_width = dev_read_u32_default(dev, "databus_width", 0);
 845         switch (databus_width) {
 846         case DATA_BUS_WIDTH_16:
 847         case DATA_BUS_WIDTH_32:
 848                 break;
 849         default:
 850                 debug("%s: databus_width value %d invalid.\n",
 851                       dev->name, databus_width);
 852                 return -EINVAL;
 853         }
 854
 855         nc_auto_precharge = dev_read_u32_default(dev, "nc_auto_precharge", 0);
 856         switch (nc_auto_precharge) {
 857         case NCAP_DISABLE:
 858         case NCAP_ENABLE:
 859                 break;
 860         default:
 861                 debug("%s: nc_auto_precharge value %d invalid.\n",
 862                       dev->name, nc_auto_precharge);
 863                 return -EINVAL;
 864         }
 865
 866         timing_2t = dev_read_u32_default(dev, "timing_2t", 0);
 867         switch (timing_2t) {
 868         case TIMING_1T:
 869         case TIMING_2T:
 870                 break;
 871         default:
 872                 debug("%s: timing_2t value %d invalid.\n",
 873                       dev->name, timing_2t);
 874                 return -EINVAL;
 875         }
 876
 877         bank_interleaving_ctrl =
 878                 dev_read_u32_default(dev, "bank_interleaving_ctrl", 0);
 879         switch (bank_interleaving_ctrl) {
 880         case INTERLEAVE_NONE:
 881         case INTERLEAVE_1_AND_2:
 882                 break;
 883         default:
 884                 debug("%s: bank_interleaving_ctrl value %d invalid.\n",
 885                       dev->name, bank_interleaving_ctrl);
 886                 return -EINVAL;
 887         }
 888
 889         precharge_bit_8 = dev_read_u32_default(dev, "precharge_bit_8", 0);
 890         switch (precharge_bit_8) {
 891         case PRECHARGE_MA_10:
 892         case PRECHARGE_MA_8:
 893                 break;
 894         default:
 895                 debug("%s: precharge_bit_8 value %d invalid.\n",
 896                       dev->name, precharge_bit_8);
 897                 return -EINVAL;
 898         }
 899
 900         half_strength = dev_read_u32_default(dev, "half_strength", 0);
 901         switch (half_strength) {
 902         case STRENGTH_FULL:
 903         case STRENGTH_HALF:
 904                 break;
 905         default:
 906                 debug("%s: half_strength value %d invalid.\n",
 907                       dev->name, half_strength);
 908                 return -EINVAL;
 909         }
 910
 911         bypass_initialization =
 912                 dev_read_u32_default(dev, "bypass_initialization", 0);
 913         switch (bypass_initialization) {
 914         case INITIALIZATION_DONT_BYPASS:
 915         case INITIALIZATION_BYPASS:
 916                 break;
 917         default:
 918                 debug("%s: bypass_initialization value %d invalid.\n",
 919                       dev->name, bypass_initialization);
 920                 return -EINVAL;
 921         }
 922
 923         sdram_cfg = self_refresh << SDRAM_CFG_SREN_SHIFT |
 924                     ecc << SDRAM_CFG_ECC_EN_SHIFT |
 925                     registered_dram << SDRAM_CFG_RD_EN_SHIFT |
 926                     sdram_type << SDRAM_CFG_SDRAM_TYPE_SHIFT |
 927                     dynamic_power_management << SDRAM_CFG_DYN_PWR_SHIFT |
 928                     databus_width << SDRAM_CFG_DBW_SHIFT |
 929                     nc_auto_precharge << SDRAM_CFG_NCAP_SHIFT |
 930                     timing_2t << SDRAM_CFG_2T_EN_SHIFT |
 931                     bank_interleaving_ctrl << SDRAM_CFG_BA_INTLV_CTL_SHIFT |
 932                     precharge_bit_8 << SDRAM_CFG_PCHB8_SHIFT |
 933                     half_strength << SDRAM_CFG_HSE_SHIFT |
 934                     bypass_initialization << SDRAM_CFG_BI_SHIFT;
 935
 936         out_be32(&im->ddr.sdram_cfg, sdram_cfg);
 937
 938         force_self_refresh = dev_read_u32_default(dev, "force_self_refresh", 0);
 939         switch (force_self_refresh) {
 940         case MODE_NORMAL:
 941         case MODE_REFRESH:
 942                 break;
 943         default:
 944                 debug("%s: force_self_refresh value %d invalid.\n",
 945                       dev->name, force_self_refresh);
 946                 return -EINVAL;
 947         }
 948
 949         dll_reset = dev_read_u32_default(dev, "dll_reset", 0);
 950         switch (dll_reset) {
 951         case DLL_RESET_ENABLE:
 952         case DLL_RESET_DISABLE:
 953                 break;
 954         default:
 955                 debug("%s: dll_reset value %d invalid.\n",
 956                       dev->name, dll_reset);
 957                 return -EINVAL;
 958         }
 959
 960         dqs_config = dev_read_u32_default(dev, "dqs_config", 0);
 961         switch (dqs_config) {
 962         case DQS_TRUE:
 963                 break;
 964         default:
 965                 debug("%s: dqs_config value %d invalid.\n",
 966                       dev->name, dqs_config);
 967                 return -EINVAL;
 968         }
 969
 970         odt_config = dev_read_u32_default(dev, "odt_config", 0);
 971         switch (odt_config) {
 972         case ODT_ASSERT_NEVER:
 973         case ODT_ASSERT_WRITES:
 974         case ODT_ASSERT_READS:
 975         case ODT_ASSERT_ALWAYS:
 976                 break;
 977         default:
 978                 debug("%s: odt_config value %d invalid.\n",
 979                       dev->name, odt_config);
 980                 return -EINVAL;
 981         }
 982
 983         posted_refreshes = dev_read_u32_default(dev, "posted_refreshes", 0);
 984         if (posted_refreshes > 8 || posted_refreshes == 0) {
 985                 debug("%s: posted_refreshes value %d invalid.\n",
 986                       dev->name, posted_refreshes);
 987                 return -EINVAL;
 988         }
 989
 990         sdram_cfg2 = force_self_refresh << SDRAM_CFG2_FRC_SR_SHIFT |
 991                      dll_reset << SDRAM_CFG2_DLL_RST_DIS |
 992                      dqs_config << SDRAM_CFG2_DQS_CFG |
 993                      odt_config << SDRAM_CFG2_ODT_CFG |
 994                      posted_refreshes << SDRAM_CFG2_NUM_PR;
 995
 996         out_be32(&im->ddr.sdram_cfg2, sdram_cfg2);
 997
 998         sdmode = dev_read_u32_default(dev, "sdmode", 0);
 999         if (sdmode > 0xFFFF) {
1000                 debug("%s: sdmode value %d invalid.\n",
1001                       dev->name, sdmode);
1002                 return -EINVAL;
1003         }
1004
1005         esdmode = dev_read_u32_default(dev, "esdmode", 0);
1006         if (esdmode > 0xFFFF) {
1007                 debug("%s: esdmode value %d invalid.\n", dev->name, esdmode);
1008                 return -EINVAL;
1009         }
1010
1011         sdram_mode = sdmode << SDRAM_MODE_SD_SHIFT |
1012                      esdmode << SDRAM_MODE_ESD_SHIFT;
1013
1014         out_be32(&im->ddr.sdram_mode, sdram_mode);
1015
1016         esdmode2 = dev_read_u32_default(dev, "esdmode2", 0);
1017         if (esdmode2 > 0xFFFF) {
1018                 debug("%s: esdmode2 value %d invalid.\n", dev->name, esdmode2);
1019                 return -EINVAL;
1020         }
1021
1022         esdmode3 = dev_read_u32_default(dev, "esdmode3", 0);
1023         if (esdmode3 > 0xFFFF) {
1024                 debug("%s: esdmode3 value %d invalid.\n", dev->name, esdmode3);
1025                 return -EINVAL;
1026         }
1027
1028         sdram_mode2 = esdmode2 << SDRAM_MODE2_ESD2_SHIFT |
1029                       esdmode3 << SDRAM_MODE2_ESD3_SHIFT;
1030
1031         out_be32(&im->ddr.sdram_mode2, sdram_mode2);
1032
1033         refresh_interval = dev_read_u32_default(dev, "refresh_interval", 0);
1034         if (refresh_interval > 0xFFFF) {
1035                 debug("%s: refresh_interval value %d invalid.\n",
1036                       dev->name, refresh_interval);
1037                 return -EINVAL;
1038         }
1039
1040         precharge_interval = dev_read_u32_default(dev, "precharge_interval", 0);
1041         if (precharge_interval > 0x3FFF) {
1042                 debug("%s: precharge_interval value %d invalid.\n",
1043                       dev->name, precharge_interval);
1044                 return -EINVAL;
1045         }
1046
1047         sdram_interval = refresh_interval << SDRAM_INTERVAL_REFINT_SHIFT |
1048                          precharge_interval << SDRAM_INTERVAL_BSTOPRE_SHIFT;
1049
1050         out_be32(&im->ddr.sdram_interval, sdram_interval);
1051         sync();
1052
1053         /* Enable DDR controller */
1054         setbits_be32(&im->ddr.sdram_cfg, SDRAM_CFG_MEM_EN);
1055         sync();
1056
1057         dev_for_each_subnode(subnode, dev) {
1058                 u32 val[3];
1059                 u32 addr, size;
1060
1061                 /* CS, map address, size -> three values */
1062                 ofnode_read_u32_array(subnode, "reg", val, 3);
1063
1064                 addr = val[1];
1065                 size = val[2];
1066
1067                 priv->total_size += get_ram_size((long int *)addr, size);
1068         };
1069
1070         gd->ram_size = priv->total_size;
1071
1072         return 0;
1073 }
1074
1075 static int mpc83xx_sdram_get_info(struct udevice *dev, struct ram_info *info)
1076 {
1077         /* TODO(mario.six@gdsys.cc): Implement */
1078         return 0;
1079 }
1080
1081 static struct ram_ops mpc83xx_sdram_ops = {
1082         .get_info = mpc83xx_sdram_get_info,
1083 };
1084
1085 static const struct udevice_id mpc83xx_sdram_ids[] = {
1086         { .compatible = "fsl,mpc83xx-mem-controller" },
1087         { /* sentinel */ }
1088 };
1089
1090 U_BOOT_DRIVER(mpc83xx_sdram) = {
1091         .name = "mpc83xx_sdram",
1092         .id = UCLASS_RAM,
1093         .of_match = mpc83xx_sdram_ids,
1094         .ops = &mpc83xx_sdram_ops,
1095         .ofdata_to_platdata = mpc83xx_sdram_ofdata_to_platdata,
1096         .probe = mpc83xx_sdram_probe,
1097         .priv_auto_alloc_size = sizeof(struct mpc83xx_sdram_priv),
1098 };