src/cpu/amd/sc520/raminit.c

   1 /* this setupcpu function comes from: */
   2 /*==============================================================================*/
   3 /* FILE   :  start16.asm*/
   4 /**/
   5 /* DESC   : A  16 bit mode assembly language startup program, intended for*/
   6 /*          use with on Aspen SC520 platforms.*/
   7 /**/
   8 /* 11/16/2000 Added support for the NetSC520*/
   9 /* 12/28/2000 Modified to boot linux image*/
  10 /**/
  11 /* =============================================================================*/
  12 /*                                                                             */
  13 /*  Copyright 2000 Advanced Micro Devices, Inc.                                */
  14 /*                                                                             */
  15 /* This software is the property of Advanced Micro Devices, Inc  (AMD)  which */
  16 /* specifically grants the user the right to modify, use and distribute this */
  17 /* software provided this COPYRIGHT NOTICE is not removed or altered.  All */
  18 /* other rights are reserved by AMD.                                                       */
  19 /*                                                                            */
  20 /* THE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY */
  21 /* OF ANY KIND INCLUDING WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT OF */
  22 /* THIRD-PARTY INTELLECTUAL PROPERTY, OR FITNESS FOR ANY PARTICULAR PURPOSE.*/
  23 /* IN NO EVENT SHALL AMD OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER*/
  24 /* (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, BUSINESS*/
  25 /* INTERRUPTION, LOSS OF INFORMATION) ARISING OUT OF THE USE OF OR INABILITY*/
  26 /* TO USE THE MATERIALS, EVEN IF AMD HAS BEEN ADVISED OF THE POSSIBILITY OF*/
  27 /* SUCH DAMAGES.  BECAUSE SOME JURSIDICTIONS PROHIBIT THE EXCLUSION OR*/
  28 /* LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE*/
  29 /* LIMITATION MAY NOT APPLY TO YOU.*/
  30 /**/
  31 /* AMD does not assume any responsibility for any errors that may appear in*/
  32 /* the Materials nor any responsibility to support or update the Materials.*/
  33 /* AMD retains the right to make changes to its test specifications at any*/
  34 /* time, without notice.*/
  35 /**/
  36 /* So that all may benefit from your experience, please report  any  problems */
  37 /* or suggestions about this software back to AMD.  Please include your name, */
  38 /* company,  telephone number,  AMD product requiring support and question or */
  39 /* problem encountered.                                                       */
  40 /*                                                                            */
  41 /* Advanced Micro Devices, Inc.         Worldwide support and contact           */
  42 /* Embedded Processor Division            information available at:               */
  43 /* Systems Engineering                       epd.support@amd.com*/
  44 /* 5204 E. Ben White Blvd.                          -or-*/
  45 /* Austin, TX 78741                http://www.amd.com/html/support/techsup.html*/
  46 /* ============================================================================*/
  47
  48
  49 #define OUTC(addr, val) *(unsigned char *)(addr) = (val)
  50
  51 /* sadly, romcc can't quite handle what we want, so we do this ugly thing */
  52 #define drcctl   (( volatile unsigned char *)0xfffef010)
  53 #define drcmctl   (( volatile unsigned char *)0xfffef012)
  54 #define drccfg   (( volatile unsigned char *)0xfffef014)
  55
  56 #define drcbendadr   (( volatile unsigned long *)0xfffef018)
  57 #define eccctl   (( volatile unsigned char *)0xfffef020)
  58 #define dbctl   (( volatile unsigned char *)0xfffef040)
  59
  60 void setupsc520(void)
  61 {
  62         volatile unsigned char *cp;
  63         volatile unsigned short *sp;
  64         volatile unsigned long *edi;
  65
  66         /* do this to see if MMCR will start acting right. we suspect
  67          * you have to do SOMETHING to get things going. I'm really
  68          * starting to hate this processor.
  69          */
  70
  71         /* no, that did not help. I wonder what will?
  72          * outl(0x800df0cb, 0xfffc);
  73          */
  74
  75         /* well, this is special! You have to do SHORT writes to the
  76          * locations, even though they are CHAR in size and CHAR aligned
  77          * and technically, a SHORT write will result in -- yoo ha! --
  78          * over writing the next location! Thanks to the u-boot guys
  79          * for a reference code I can use. with these short pointers,
  80          * it now reliably comes up after power cycle with printk. Ah yi
  81          * yi.
  82          */
  83
  84         /* turn off the write buffer*/
  85         /* per the note above, make this a short? Let's try it. */
  86         sp = (unsigned short *)0xfffef040;
  87         *sp = 0;
  88
  89         /* as per the book: */
  90         /* PAR register setup */
  91         /* set up the PAR registers as they are on the MSM586SEG */
  92         /*    moved to romstage.c by Stepan, Ron says: */
  93         /* NOTE: move this to mainboard.c ASAP */
  94         setup_pars();
  95
  96         /* CPCSF register */
  97         sp =  (unsigned short *)0xfffefc24;
  98         *sp = 0xfe;
  99
 100         /* ADDDECTL */
 101         sp =  (unsigned short *)0xfffefc80;
 102         *sp = 0x10;
 103
 104         /* byte writes in AMD assembly */
 105         /* we do short anyway, since u-boot does ... */
 106         /*set the GP CS offset*/
 107         sp =  (unsigned short *)0xfffefc08;
 108         *sp = 0x00001;
 109         /*set the GP CS width*/
 110         sp =  (unsigned short *)0xfffefc09;
 111         *sp = 0x00003;
 112
 113         /* short writes in AMD assembly */
 114         /*set the GP CS width*/
 115         sp =  (unsigned short *)0xfffefc0a;
 116         *sp = 0x00001;
 117         /*set the RD pulse width*/
 118         sp =  (unsigned short *)0xfffefc0b;
 119         *sp = 0x00003;
 120         /*set the GP RD offset */
 121         sp =  (unsigned short *)0xfffefc0c;
 122         *sp = 0x00001;
 123         /*set the GP WR pulse width*/
 124         sp =  (unsigned short *)0xfffefc0d;
 125         *sp = 0x00003;
 126         /*set the GP WR offset*/
 127         sp =  (unsigned short *)0xfffefc0e;
 128         *sp = 0x00001;
 129
 130
 131         /* set up the GP IO pins*/
 132         /*set the GPIO directionreg*/
 133         sp =  (unsigned short *)0xfffefc2c;
 134         *sp = 0x00000;
 135         /*set the GPIO directionreg*/
 136         sp =  (unsigned short *)0xfffefc2a;
 137         *sp = 0x00000;
 138         /*set the GPIO pin function 31-16 reg*/
 139         sp =  (unsigned short *)0xfffefc22;
 140         *sp = 0x0FFFF;
 141         /*set the GPIO pin function 15-0 reg*/
 142         sp =  (unsigned short *)0xfffefc20;
 143         *sp = 0x0FFFF;
 144
 145
 146         /* the 0x80 led should now be working*/
 147         outb(0xaa, 0x80);
 148 #if 0
 149         /* wtf are 680 leds ... */
 150         par = (unsigned long *) 0xfffef0c4;
 151         *par = 0x28000680;
 152         /* well? */
 153         outb(0x55, 0x80);
 154 #endif
 155
 156         /* set the uart baud rate clocks to the normal 1.8432 MHz.*/
 157         /* enable interrupts here? Why not? */
 158         cp = (unsigned char *)0xfffefcc0;
 159         *cp = 4 | 3;                    /* uart 1 clock source */
 160         cp = (unsigned char *)0xfffefcc4;
 161         *cp = 4;                        /* uart 2 clock source */
 162
 163 #if 0
 164 /*; set the interrupt mapping registers.*/
 165         cp = (unsigned char *)0x0fffefd20;
 166         *cp = 0x01;
 167
 168         cp = (unsigned char *)0x0fffefd28;
 169         *cp = 0x0c;
 170
 171         cp = (unsigned char *)0x0fffefd29;
 172         *cp = 0x0b;
 173
 174         cp = (unsigned char *)0x0fffefd30;
 175         *cp = 0x07;
 176
 177         cp = (unsigned char *)0x0fffefd43;
 178         *cp = 0x03;
 179
 180         cp = (unsigned char *)0x0fffefd51;
 181         *cp = 0x02;
 182 #endif
 183
 184 /* Stepan says: This needs to go to the msm586seg code */
 185 /* "enumerate" the PCI. Mainly set the interrupt bits on the PCnetFast. */
 186         outl(0x08000683c, 0xcf8);
 187         outl(0xc, 0xcfc); /* set the interrupt line */
 188
 189
 190         /* Set the SC520 PCI host bridge to target mode to
 191          * allow external bus mastering events
 192          */
 193         /* index the status command register on device 0*/
 194         outl(0x080000004, 0x0cf8);
 195         outl(0x2, 0xcfc);               /*set the memory access enable bit*/
 196         OUTC(0x0fffef072, 1);           /* enable req bits in SYSARBMENB */
 197 }
 198
 199
 200 /*
 201  *
 202  *
 203  */
 204
 205
 206
 207 #define CACHELINESZ   0x00000010  /*  size of our cache line (read buffer)*/
 208
 209 #define COL11_ADR  *(unsigned int *)0x0e001e00 /* 11 col addrs*/
 210 #define COL10_ADR  *(unsigned int *)0x0e000e00 /* 10 col addrs*/
 211 #define COL09_ADR  *(unsigned int *)0x0e000600 /*  9 col addrs*/
 212 #define COL08_ADR  *(unsigned int *)0x0e000200 /*  8 col addrs*/
 213
 214 #define ROW14_ADR  *(unsigned int *)0x0f000000 /* 14 row addrs*/
 215 #define ROW13_ADR  *(unsigned int *)0x07000000 /* 13 row addrs*/
 216 #define ROW12_ADR  *(unsigned int *)0x03000000 /* 12 row addrs*/
 217 #define ROW11_ADR  *(unsigned int *)0x01000000 /* 11 row addrs/also bank switch*/
 218 #define ROW10_ADR  *(unsigned int *)0x00000000 /* 10 row addrs/also bank switch*/
 219
 220 #define COL11_DATA 0x0b0b0b0b   /*  11 col addrs*/
 221 #define COL10_DATA 0x0a0a0a0a   /*  10 col data*/
 222 #define COL09_DATA 0x09090909   /*   9 col data*/
 223 #define COL08_DATA 0x08080808   /*   8 col data*/
 224
 225 #define ROW14_DATA 0x3f3f3f3f   /*  14 row data (MASK)*/
 226 #define ROW13_DATA 0x1f1f1f1f   /*  13 row data (MASK)*/
 227 #define ROW12_DATA 0x0f0f0f0f   /*  12 row data (MASK)*/
 228 #define ROW11_DATA 0x07070707   /*  11 row data/also bank switch (MASK)*/
 229 #define ROW10_DATA 0xaaaaaaaa   /*  10 row data/also bank switch (MASK)*/
 230
 231 void
 232 dummy_write(void){
 233   volatile unsigned short *ptr = (volatile unsigned short *)CACHELINESZ;
 234   *ptr = 0;
 235 }
 236
 237 #include "pc80/udelay_io.c"
 238
 239 static void dumpram(void){
 240   print_err("ctl "); print_err_hex8(*drcctl); print_err("\n");
 241   print_err("mctl "); print_err_hex8(*drcmctl); print_err("\n");
 242   print_err("cfg "); print_err_hex8(*drccfg); print_err("\n");
 243
 244   print_err("bendadr0 "); print_err_hex8(*drcbendadr); print_err("\n");
 245   print_err("bendadr1 "); print_err_hex8(*drcbendadr); print_err("\n");
 246   print_err("bendadr2 "); print_err_hex8(*drcbendadr); print_err("\n");
 247   print_err("bendadr3"); print_err_hex8(*drcbendadr); print_err("\n");
 248 }
 249
 250 /* there is a lot of silliness in the amd code, and it is
 251  * causing romcc real headaches, so we're going to be be a little
 252  * less silly.
 253  * so, the order of ops is:
 254  * for i in 3 to 0
 255  * see if bank is there.
 256  * if we can write a word, and read it back, to hell with paranoia
 257  * the bank is there. So write the magic byte, read it back, and
 258  * use that to get size, etc. Try to keep things very simple,
 259  * so people can actually follow the damned code.
 260  */
 261
 262 /* cache is assumed to be disabled */
 263 int sizemem(void)
 264 {
 265
 266         int rows,banks, cols, i, bank;
 267         unsigned char al;
 268         volatile unsigned long *lp = (volatile unsigned long *) CACHELINESZ;
 269         unsigned long l;
 270         /* initialize dram controller registers */
 271         /* disable write buffer/read-ahead buffer */
 272         *dbctl = 0;
 273         /* no ecc interrupts of any kind. */
 274         *eccctl = 0;
 275         /* Set SDRAM timing for slowest speed. */
 276         *drcmctl = 0x1e;
 277
 278         /* setup dram register for all banks
 279          * with max cols and max banks
 280          * this is the oldest trick in the book. You are going to set up for max rows
 281          * and cols, then do a write, then see if the data is wrapped to low memory.
 282          * you can actually tell by which data gets to which low memory,
 283          * exactly how many rows and cols you have.
 284          */
 285         *drccfg=0xbbbb;
 286
 287         /* setup loop to do 4 external banks starting with bank 3 */
 288         *drcbendadr=0x0ff000000;
 289         /* for now, set it up for one loop of bank 0. Just to get it to go at all. */
 290         *drcbendadr=0x0ff;
 291
 292         /* issue a NOP to all DRAMs */
 293         /* Setup DRAM control register with Disable refresh,
 294          * disable write buffer Test Mode and NOP command select
 295          */
 296         *drcctl=0x01;
 297
 298         /* dummy write for NOP to take effect */
 299         dummy_write();
 300         print_err("NOP\n");
 301         /* 100? 200? */
 302         udelay(100);
 303         print_err("after udelay\n");
 304
 305         /* issue all banks precharge */
 306         *drcctl=0x02;
 307         print_err("set *drcctl to 2 \n");
 308         dummy_write();
 309         print_err("PRE\n");
 310
 311         /* issue 2 auto refreshes to all banks */
 312         *drcctl=0x04;
 313         dummy_write();
 314         print_err("AUTO1\n");
 315         dummy_write();
 316         print_err("AUTO2\n");
 317
 318         /* issue LOAD MODE REGISTER command */
 319         *drcctl=0x03;
 320         dummy_write();
 321         print_err("LOAD MODE REG\n");
 322
 323         *drcctl=0x04;
 324         for (i=0; i<8; i++) /* refresh 8 times */{
 325                 dummy_write();
 326                 print_err("dummy write\n");
 327         }
 328         print_err("8 dummy writes\n");
 329
 330         /* set control register to NORMAL mode */
 331         *drcctl=0x00;
 332         print_err("normal\n");
 333
 334         print_err("HI done normal\n");
 335
 336         print_err("sizemem\n");
 337         for(bank = 3; bank >= 0; bank--) {
 338           print_err("Try to assign to l\n");
 339           *lp = 0xdeadbeef;
 340           print_err("assigned l ... \n");
 341           if (*lp != 0xdeadbeef) {
 342             print_err(" no memory at bank ");
 343             // print_err_hex8(bank);
 344             //   print_err(" value "); print_err_hex32(*lp);
 345             print_err("\n");
 346             //      continue;
 347           }
 348           *drcctl = 2;
 349           dummy_write();
 350           *drccfg = *drccfg >> 4;
 351           l = *drcbendadr;
 352           l >>= 8;
 353           *drcbendadr = l;
 354           print_err("loop around\n");
 355           *drcctl = 0;
 356           dummy_write();
 357         }
 358 #if 0
 359         /* enable last bank and setup ending address
 360          * register for max ram in last bank
 361          */
 362         *drcbendadr=0x0ff000000;
 363
 364
 365 //      dumpram();
 366
 367         /* issue a NOP to all DRAMs */
 368         /* Setup DRAM control register with Disable refresh,
 369          * disable write buffer Test Mode and NOP command select
 370          */
 371         *drcctl=0x01;
 372
 373         /* dummy write for NOP to take effect */
 374         dummy_write();
 375         print_err("NOP\n");
 376         /* 100? 200? */
 377         //udelay(100);
 378         print_err("after udelay\n");
 379
 380         /* issue all banks precharge */
 381         *drcctl=0x02;
 382         print_err("set *drcctl to 2 \n");
 383         dummy_write();
 384         print_err("PRE\n");
 385
 386         /* issue 2 auto refreshes to all banks */
 387         *drcctl=0x04;
 388         dummy_write();
 389         print_err("AUTO1\n");
 390         dummy_write();
 391         print_err("AUTO2\n");
 392
 393         /* issue LOAD MODE REGISTER command */
 394         *drcctl=0x03;
 395         dummy_write();
 396         print_err("LOAD MODE REG\n");
 397
 398         *drcctl=0x04;
 399         for (i=0; i<8; i++) /* refresh 8 times */{
 400                 dummy_write();
 401                 print_err("dummy write\n");
 402         }
 403         print_err("8 dummy writes\n");
 404
 405         /* set control register to NORMAL mode */
 406         *drcctl=0x00;
 407         print_err("normal\n");
 408
 409         print_err("HI done normal\n");
 410         bank = 3;
 411
 412
 413         /* this is really ugly, it is right from assembly code.
 414          * we need to clean it up later
 415          */
 416
 417 start:
 418         /* write col 11 wrap adr */
 419         COL11_ADR=COL11_DATA;
 420         if(COL11_ADR!=COL11_DATA)
 421                 goto bad_ram;
 422
 423 print_err("11\n");
 424         /* write col 10 wrap adr */
 425         COL10_ADR=COL10_DATA;
 426         if(COL10_ADR!=COL10_DATA)
 427                 goto bad_ram;
 428 print_err("10\n");
 429
 430         /* write col 9 wrap adr */
 431         COL09_ADR=COL09_DATA;
 432         if(COL09_ADR!=COL09_DATA)
 433                 goto bad_ram;
 434 print_err("9\n");
 435
 436         /* write col 8 wrap adr */
 437         COL08_ADR=COL08_DATA;
 438         if(COL08_ADR!=COL08_DATA)
 439                 goto bad_ram;
 440 print_err("8\n");
 441
 442         /* write row 14 wrap adr */
 443         ROW14_ADR=ROW14_DATA;
 444         if(ROW14_ADR!=ROW14_DATA)
 445                 goto bad_ram;
 446 print_err("14\n");
 447
 448         /* write row 13 wrap adr */
 449         ROW13_ADR=ROW13_DATA;
 450         if(ROW13_ADR!=ROW13_DATA)
 451                 goto bad_ram;
 452 print_err("13\n");
 453
 454         /* write row 12 wrap adr */
 455         ROW12_ADR=ROW12_DATA;
 456         if(ROW12_ADR!=ROW12_DATA)
 457                 goto bad_ram;
 458 print_err("12\n");
 459
 460         /* write row 11 wrap adr */
 461         ROW11_ADR=ROW11_DATA;
 462         if(ROW11_ADR!=ROW11_DATA)
 463                 goto bad_ram;
 464 print_err("11\n");
 465
 466         /* write row 10 wrap adr */
 467         ROW10_ADR=ROW10_DATA;
 468         if(ROW10_ADR!=ROW10_DATA)
 469                 goto bad_ram;
 470 print_err("10\n");
 471
 472 /*
 473  * read data @ row 12 wrap adr to determine # banks,
 474  *  and read data @ row 14 wrap adr to determine # rows.
 475  *  if data @ row 12 wrap adr is not AA, 11 or 12 we have bad RAM.
 476  * if data @ row 12 wrap == AA, we only have 2 banks, NOT 4
 477  * if data @ row 12 wrap == 11 or 12, we have 4 banks
 478  */
 479
 480         banks=2;
 481         if (ROW12_ADR != ROW10_DATA) {
 482                 banks=4;
 483 print_err("4b\n");
 484                 if(ROW12_ADR != ROW11_DATA) {
 485                         if(ROW12_ADR != ROW12_DATA)
 486                                 goto bad_ram;
 487                 }
 488         }
 489
 490         /* validate row mask */
 491         rows=ROW14_ADR;
 492         if (rows<ROW11_DATA)
 493                 goto bad_ram;
 494         if (rows>ROW14_DATA)
 495                 goto bad_ram;
 496         /* verify all 4 bytes of dword same */
 497 /*
 498         if(rows&0xffff!=(rows>>16)&0xffff)
 499                 goto bad_ram;
 500         if(rows&0xff!=(rows>>8)&0xff)
 501                 goto bad_ram;
 502 */
 503         /* now just get one of them */
 504         rows &= 0xff;
 505         print_err("rows"); print_err_hex32(rows); print_err("\n");
 506         /* validate column data */
 507         cols=COL11_ADR;
 508         if(cols<COL08_DATA)
 509                 goto bad_ram;
 510         if (cols>COL11_DATA)
 511                 goto bad_ram;
 512         /* verify all 4 bytes of dword same */
 513 /*
 514         if(cols&0xffff!=(cols>>16)&0xffff)
 515                 goto bad_ram;
 516         if(cols&0xff!=(cols>>8)&0xff)
 517                 goto bad_ram;
 518 */
 519         print_err("cols"); print_err_hex32(cols); print_err("\n");
 520         cols -= COL08_DATA;
 521
 522         /* cols now is in the range of 0 1 2 3 ...
 523          */
 524         i = cols&3;
 525         //      i = cols + rows;
 526
 527         /* wacky end addr calculation */
 528 /*
 529         al = 3;
 530         al -= (i & 0xff);k
 531  */
 532
 533         /* what a fookin' mess this is */
 534         if(banks==4)
 535                 i+=8; /* <-- i holds merged value */
 536         /* i now has the col width in bits 0-1 and the bank count (2 or 4)
 537          * in bit 3.
 538          * this is the format for the drccfg register
 539          */
 540
 541         /* fix ending addr mask*/
 542         /*FIXME*/
 543         /* let's just go with this to start ... see if we can get ANYWHERE */
 544         /* need to get end addr. Need to do it with the bank in mind. */
 545 /*
 546         al = 3;
 547         al -= i&3;
 548         *drcbendaddr = rows >> al;
 549         print_err("computed ending_adr = "); print_err_hex8(ending_adr);
 550         print_err("\n");
 551
 552 */
 553 bad_reinit:
 554         /* issue all banks recharge */
 555         *drcctl=0x02;
 556         dummy_write();
 557
 558         /* update ending address register */
 559 //      *drcbendadr = ending_adr;
 560
 561         /* update config register */
 562         *drccfg &= ~(0xff << bank*4);
 563         if (ending_adr)
 564           *drccfg = ((banks == 4 ? 8 : 0) | cols & 3)<< (bank*4);
 565 //      dumpram();
 566         /* skip the rest for now */
 567         //      bank = 0;
 568         //      *drccfg=*drccfg&YYY|ZZZZ;
 569
 570         if(bank!=0) {
 571                 bank--;
 572 //              drcbendaddr--;
 573                 *drcbendaddr = 0xff000000;
 574                 //*(&*drcbendadr+XXYYXX)=0xff;
 575                 goto start;
 576         }
 577
 578         /* set control register to NORMAL mode */
 579         *drcctl=0x18;
 580         dummy_write();
 581         return bank;
 582
 583 bad_ram:
 584         print_info("bad ram!\n");
 585         /* you are here because the read-after-write failed,
 586          * in most cases because: no ram in that bank!
 587          * set badbank to 1 and go to reinit
 588          */
 589         ending_adr = 0;
 590         goto bad_reinit;
 591         while(1)
 592         print_err("DONE NEXTBANK\n");
 593 #endif
 594 }
 595
 596 /* note: based on AMD code*/
 597 /* This code is known to work on the digital logic board and on the technologic
 598  * systems ts5300
 599  */
 600 int staticmem(void)
 601 {
 602         volatile unsigned long *zero = (unsigned long *) CACHELINESZ;
 603
 604         /* set up 0x18 .. **/
 605         *drcbendadr = 0x88;
 606         *drcmctl = 0x1e;
 607         *drccfg = 0x9;
 608         /* nop mode */
 609         *drcctl = 0x1;
 610         /* do the dummy write */
 611         *zero = 0;
 612
 613         /* precharge */
 614         *drcctl = 2;
 615         *zero = 0;
 616
 617         /* two autorefreshes */
 618         *drcctl = 4;
 619         *zero = 0;
 620         print_debug("one zero out on refresh\n");
 621         *zero = 0;
 622         print_debug("two zero out on refresh\n");
 623
 624         /* load mode register */
 625         *drcctl = 3;
 626         *zero = 0;
 627         print_debug("DONE the load mode reg\n");
 628
 629         /* normal mode */
 630         *drcctl = 0x0;
 631         *zero = 0;
 632         print_debug("DONE one last write and then turn on refresh etc\n");
 633         *drcctl = 0x18;
 634         *zero = 0;
 635         print_debug("DONE the normal\n");
 636         *zero = 0xdeadbeef;
 637         if (*zero != 0xdeadbeef)
 638           print_debug("NO LUCK\n");
 639         else
 640           print_debug("did a store and load ...\n");
 641         //print_err_hex32(*zero);
 642         //      print_err(" zero is now "); print_err_hex32(*zero); print_err("\n");
 643 }