Merge branch 'fixes' into cleanups
[platform/kernel/u-boot.git] / board / sacsng / sacsng.c
1 /*
2  * (C) Copyright 2002
3  * Custom IDEAS, Inc. <www.cideas.com>
4  * Gerald Van Baren <vanbaren@cideas.com>
5  *
6  * See file CREDITS for list of people who contributed to this
7  * project.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License as
11  * published by the Free Software Foundation; either version 2 of
12  * the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
22  * MA 02111-1307 USA
23  */
24
25 #include <common.h>
26 #include <asm/u-boot.h>
27 #include <ioports.h>
28 #include <mpc8260.h>
29 #include <i2c.h>
30 #include <spi.h>
31 #include <command.h>
32
33 #ifdef CONFIG_SHOW_BOOT_PROGRESS
34 #include <status_led.h>
35 #endif
36
37 #ifdef CONFIG_ETHER_LOOPBACK_TEST
38 extern void eth_loopback_test(void);
39 #endif /* CONFIG_ETHER_LOOPBACK_TEST */
40
41 extern int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
42
43 #include "clkinit.h"
44 #include "ioconfig.h" /* I/O configuration table */
45
46 /*
47  * PBI Page Based Interleaving
48  *   PSDMR_PBI page based interleaving
49  *   0         bank based interleaving
50  * External Address Multiplexing (EAMUX) adds a clock to address cycles
51  *   (this can help with marginal board layouts)
52  *   PSDMR_EAMUX  adds a clock
53  *   0            no extra clock
54  * Buffer Command (BUFCMD) adds a clock to command cycles.
55  *   PSDMR_BUFCMD adds a clock
56  *   0            no extra clock
57  */
58 #define CONFIG_PBI              PSDMR_PBI
59 #define PESSIMISTIC_SDRAM       0
60 #define EAMUX                   0       /* EST requires EAMUX */
61 #define BUFCMD                  0
62
63 /*
64  * ADC/DAC Defines:
65  */
66 #define INITIAL_SAMPLE_RATE 10016     /* Initial Daq sample rate */
67 #define INITIAL_RIGHT_JUST  0         /* Initial DAC right justification */
68 #define INITIAL_MCLK_DIVIDE 0         /* Initial MCLK Divide */
69 #define INITIAL_SAMPLE_64X  1         /* Initial  64x clocking mode */
70 #define INITIAL_SAMPLE_128X 0         /* Initial 128x clocking mode */
71
72 /*
73  * ADC Defines:
74  */
75 #define I2C_ADC_1_ADDR 0x0E           /* I2C Address of the ADC #1 */
76 #define I2C_ADC_2_ADDR 0x0F           /* I2C Address of the ADC #2 */
77
78 #define ADC_SDATA1_MASK 0x00020000    /* PA14 - CH12SDATA_PU   */
79 #define ADC_SDATA2_MASK 0x00010000    /* PA15 - CH34SDATA_PU   */
80
81 #define ADC_VREF_CAP   100            /* VREF capacitor in uF */
82 #define ADC_INITIAL_DELAY (10 * ADC_VREF_CAP) /* 10 usec per uF, in usec */
83 #define ADC_SDATA_DELAY    100        /* ADC SDATA release delay in usec */
84 #define ADC_CAL_DELAY (1000000 / INITIAL_SAMPLE_RATE * 4500)
85                                       /* Wait at least 4100 LRCLK's */
86
87 #define ADC_REG1_FRAME_START    0x80  /* Frame start */
88 #define ADC_REG1_GROUND_CAL     0x40  /* Ground calibration enable */
89 #define ADC_REG1_ANA_MOD_PDOWN  0x20  /* Analog modulator section in power down */
90 #define ADC_REG1_DIG_MOD_PDOWN  0x10  /* Digital modulator section in power down */
91
92 #define ADC_REG2_128x           0x80  /* Oversample at 128x */
93 #define ADC_REG2_CAL            0x40  /* System calibration enable */
94 #define ADC_REG2_CHANGE_SIGN    0x20  /* Change sign enable */
95 #define ADC_REG2_LR_DISABLE     0x10  /* Left/Right output disable */
96 #define ADC_REG2_HIGH_PASS_DIS  0x08  /* High pass filter disable */
97 #define ADC_REG2_SLAVE_MODE     0x04  /* Slave mode */
98 #define ADC_REG2_DFS            0x02  /* Digital format select */
99 #define ADC_REG2_MUTE           0x01  /* Mute */
100
101 #define ADC_REG7_ADDR_ENABLE    0x80  /* Address enable */
102 #define ADC_REG7_PEAK_ENABLE    0x40  /* Peak enable */
103 #define ADC_REG7_PEAK_UPDATE    0x20  /* Peak update */
104 #define ADC_REG7_PEAK_FORMAT    0x10  /* Peak display format */
105 #define ADC_REG7_DIG_FILT_PDOWN 0x04  /* Digital filter power down enable */
106 #define ADC_REG7_FIR2_IN_EN     0x02  /* External FIR2 input enable */
107 #define ADC_REG7_PSYCHO_EN      0x01  /* External pyscho filter input enable */
108
109 /*
110  * DAC Defines:
111  */
112
113 #define I2C_DAC_ADDR 0x11             /* I2C Address of the DAC */
114
115 #define DAC_RST_MASK 0x00008000       /* PA16 - DAC_RST*  */
116 #define DAC_RESET_DELAY    100        /* DAC reset delay in usec */
117 #define DAC_INITIAL_DELAY 5000        /* DAC initialization delay in usec */
118
119 #define DAC_REG1_AMUTE   0x80         /* Auto-mute */
120
121 #define DAC_REG1_LEFT_JUST_24_BIT (0 << 4) /* Fmt 0: Left justified 24 bit  */
122 #define DAC_REG1_I2S_24_BIT       (1 << 4) /* Fmt 1: I2S up to 24 bit       */
123 #define DAC_REG1_RIGHT_JUST_16BIT (2 << 4) /* Fmt 2: Right justified 16 bit */
124 #define DAC_REG1_RIGHT_JUST_24BIT (3 << 4) /* Fmt 3: Right justified 24 bit */
125 #define DAC_REG1_RIGHT_JUST_20BIT (4 << 4) /* Fmt 4: Right justified 20 bit */
126 #define DAC_REG1_RIGHT_JUST_18BIT (5 << 4) /* Fmt 5: Right justified 18 bit */
127
128 #define DAC_REG1_DEM_NO           (0 << 2) /* No      De-emphasis  */
129 #define DAC_REG1_DEM_44KHZ        (1 << 2) /* 44.1KHz De-emphasis  */
130 #define DAC_REG1_DEM_48KHZ        (2 << 2) /* 48KHz   De-emphasis  */
131 #define DAC_REG1_DEM_32KHZ        (3 << 2) /* 32KHz   De-emphasis  */
132
133 #define DAC_REG1_SINGLE 0             /*   4- 50KHz sample rate  */
134 #define DAC_REG1_DOUBLE 1             /*  50-100KHz sample rate  */
135 #define DAC_REG1_QUAD   2             /* 100-200KHz sample rate  */
136 #define DAC_REG1_DSD    3             /* Direct Stream Data, DSD */
137
138 #define DAC_REG5_INVERT_A   0x80      /* Invert channel A */
139 #define DAC_REG5_INVERT_B   0x40      /* Invert channel B */
140 #define DAC_REG5_I2C_MODE   0x20      /* Control port (I2C) mode */
141 #define DAC_REG5_POWER_DOWN 0x10      /* Power down mode */
142 #define DAC_REG5_MUTEC_A_B  0x08      /* Mutec A=B */
143 #define DAC_REG5_FREEZE     0x04      /* Freeze */
144 #define DAC_REG5_MCLK_DIV   0x02      /* MCLK divide by 2 */
145 #define DAC_REG5_RESERVED   0x01      /* Reserved */
146
147 /* ------------------------------------------------------------------------- */
148
149 /*
150  * Check Board Identity:
151  */
152
153 int checkboard(void)
154 {
155     printf ("SACSng\n");
156
157     return 0;
158 }
159
160 /* ------------------------------------------------------------------------- */
161
162 phys_size_t initdram(int board_type)
163 {
164     volatile immap_t *immap  = (immap_t *)CONFIG_SYS_IMMR;
165     volatile memctl8260_t *memctl = &immap->im_memctl;
166     volatile uchar c = 0;
167     volatile uchar *ramaddr = (uchar *)(CONFIG_SYS_SDRAM_BASE + 0x8);
168     uint  psdmr = CONFIG_SYS_PSDMR;
169     int   i;
170     uint   psrt = 14;                                   /* for no SPD */
171     uint   chipselects = 1;                             /* for no SPD */
172     uint   sdram_size = CONFIG_SYS_SDRAM0_SIZE * 1024 * 1024;   /* for no SPD */
173     uint   or = CONFIG_SYS_OR2_PRELIM;                          /* for no SPD */
174 #ifdef SDRAM_SPD_ADDR
175     uint   data_width;
176     uint   rows;
177     uint   banks;
178     uint   cols;
179     uint   caslatency;
180     uint   width;
181     uint   rowst;
182     uint   sdam;
183     uint   bsma;
184     uint   sda10;
185     u_char spd_size;
186     u_char data;
187     u_char cksum;
188     int    j;
189 #endif
190
191 #ifdef SDRAM_SPD_ADDR
192     /* Keep the compiler from complaining about potentially uninitialized vars */
193     data_width = chipselects = rows = banks = cols = caslatency = psrt = 0;
194
195     /*
196      * Read the SDRAM SPD EEPROM via I2C.
197      */
198     i2c_read(SDRAM_SPD_ADDR, 0, 1, &data, 1);
199     spd_size = data;
200     cksum    = data;
201     for(j = 1; j < 64; j++) {   /* read only the checksummed bytes */
202         /* note: the I2C address autoincrements when alen == 0 */
203         i2c_read(SDRAM_SPD_ADDR, 0, 0, &data, 1);
204              if(j ==  5) chipselects = data & 0x0F;
205         else if(j ==  6) data_width  = data;
206         else if(j ==  7) data_width |= data << 8;
207         else if(j ==  3) rows        = data & 0x0F;
208         else if(j ==  4) cols        = data & 0x0F;
209         else if(j == 12) {
210             /*
211              * Refresh rate: this assumes the prescaler is set to
212              * approximately 1uSec per tick.
213              */
214             switch(data & 0x7F) {
215                 default:
216                 case 0:  psrt =  14 ; /*  15.625uS */  break;
217                 case 1:  psrt =   2;  /*   3.9uS   */  break;
218                 case 2:  psrt =   6;  /*   7.8uS   */  break;
219                 case 3:  psrt =  29;  /*  31.3uS   */  break;
220                 case 4:  psrt =  60;  /*  62.5uS   */  break;
221                 case 5:  psrt = 120;  /* 125uS     */  break;
222             }
223         }
224         else if(j == 17) banks       = data;
225         else if(j == 18) {
226             caslatency = 3; /* default CL */
227 #if(PESSIMISTIC_SDRAM)
228                  if((data & 0x04) != 0) caslatency = 3;
229             else if((data & 0x02) != 0) caslatency = 2;
230             else if((data & 0x01) != 0) caslatency = 1;
231 #else
232                  if((data & 0x01) != 0) caslatency = 1;
233             else if((data & 0x02) != 0) caslatency = 2;
234             else if((data & 0x04) != 0) caslatency = 3;
235 #endif
236             else {
237                 printf ("WARNING: Unknown CAS latency 0x%02X, using 3\n",
238                         data);
239             }
240         }
241         else if(j == 63) {
242             if(data != cksum) {
243                 printf ("WARNING: Configuration data checksum failure:"
244                         " is 0x%02x, calculated 0x%02x\n",
245                         data, cksum);
246             }
247         }
248         cksum += data;
249     }
250
251     /* We don't trust CL less than 2 (only saw it on an old 16MByte DIMM) */
252     if(caslatency < 2) {
253         printf("WARNING: CL was %d, forcing to 2\n", caslatency);
254         caslatency = 2;
255     }
256     if(rows > 14) {
257         printf("WARNING: This doesn't look good, rows = %d, should be <= 14\n", rows);
258         rows = 14;
259     }
260     if(cols > 11) {
261         printf("WARNING: This doesn't look good, columns = %d, should be <= 11\n", cols);
262         cols = 11;
263     }
264
265     if((data_width != 64) && (data_width != 72))
266     {
267         printf("WARNING: SDRAM width unsupported, is %d, expected 64 or 72.\n",
268             data_width);
269     }
270     width = 3;          /* 2^3 = 8 bytes = 64 bits wide */
271     /*
272      * Convert banks into log2(banks)
273      */
274     if     (banks == 2) banks = 1;
275     else if(banks == 4) banks = 2;
276     else if(banks == 8) banks = 3;
277
278     sdram_size = 1 << (rows + cols + banks + width);
279
280 #if(CONFIG_PBI == 0)    /* bank-based interleaving */
281     rowst = ((32 - 6) - (rows + cols + width)) * 2;
282 #else
283     rowst = 32 - (rows + banks + cols + width);
284 #endif
285
286     or = ~(sdram_size - 1)    | /* SDAM address mask    */
287           ((banks-1) << 13)   | /* banks per device     */
288           (rowst << 9)        | /* rowst                */
289           ((rows - 9) << 6);    /* numr                 */
290
291     memctl->memc_or2 = or;
292
293     /*
294      * SDAM specifies the number of columns that are multiplexed
295      * (reference AN2165/D), defined to be (columns - 6) for page
296      * interleave, (columns - 8) for bank interleave.
297      *
298      * BSMA is 14 - max(rows, cols).  The bank select lines come
299      * into play above the highest "address" line going into the
300      * the SDRAM.
301      */
302 #if(CONFIG_PBI == 0)    /* bank-based interleaving */
303     sdam = cols - 8;
304     bsma = ((31 - width) - 14) - ((rows > cols) ? rows : cols);
305     sda10 = sdam + 2;
306 #else
307     sdam = cols - 6;
308     bsma = ((31 - width) - 14) - ((rows > cols) ? rows : cols);
309     sda10 = sdam;
310 #endif
311 #if(PESSIMISTIC_SDRAM)
312     psdmr = (CONFIG_PBI              |\
313              PSDMR_RFEN              |\
314              PSDMR_RFRC_16_CLK       |\
315              PSDMR_PRETOACT_8W       |\
316              PSDMR_ACTTORW_8W        |\
317              PSDMR_WRC_4C            |\
318              PSDMR_EAMUX             |\
319              PSDMR_BUFCMD)           |\
320              caslatency              |\
321              ((caslatency - 1) << 6) |  /* LDOTOPRE is CL - 1 */ \
322              (sdam << 24)            |\
323              (bsma << 21)            |\
324              (sda10 << 18);
325 #else
326     psdmr = (CONFIG_PBI              |\
327              PSDMR_RFEN              |\
328              PSDMR_RFRC_7_CLK        |\
329              PSDMR_PRETOACT_3W       |  /* 1 for 7E parts (fast PC-133) */ \
330              PSDMR_ACTTORW_2W        |  /* 1 for 7E parts (fast PC-133) */ \
331              PSDMR_WRC_1C            |  /* 1 clock + 7nSec */
332              EAMUX                   |\
333              BUFCMD)                 |\
334              caslatency              |\
335              ((caslatency - 1) << 6) |  /* LDOTOPRE is CL - 1 */ \
336              (sdam << 24)            |\
337              (bsma << 21)            |\
338              (sda10 << 18);
339 #endif
340 #endif
341
342     /*
343      * Quote from 8260 UM (10.4.2 SDRAM Power-On Initialization, 10-35):
344      *
345      * "At system reset, initialization software must set up the
346      *  programmable parameters in the memory controller banks registers
347      *  (ORx, BRx, P/LSDMR). After all memory parameters are configured,
348      *  system software should execute the following initialization sequence
349      *  for each SDRAM device.
350      *
351      *  1. Issue a PRECHARGE-ALL-BANKS command
352      *  2. Issue eight CBR REFRESH commands
353      *  3. Issue a MODE-SET command to initialize the mode register
354      *
355      * Quote from Micron MT48LC8M16A2 data sheet:
356      *
357      *  "...the SDRAM requires a 100uS delay prior to issuing any
358      *  command other than a COMMAND INHIBIT or NOP.  Starting at some
359      *  point during this 100uS period and continuing at least through
360      *  the end of this period, COMMAND INHIBIT or NOP commands should
361      *  be applied."
362      *
363      *  "Once the 100uS delay has been satisfied with at least one COMMAND
364      *  INHIBIT or NOP command having been applied, a /PRECHARGE command/
365      *  should be applied.  All banks must then be precharged, thereby
366      *  placing the device in the all banks idle state."
367      *
368      *  "Once in the idle state, /two/ AUTO REFRESH cycles must be
369      *  performed.  After the AUTO REFRESH cycles are complete, the
370      *  SDRAM is ready for mode register programming."
371      *
372      *  (/emphasis/ mine, gvb)
373      *
374      *  The way I interpret this, Micron start up sequence is:
375      *  1. Issue a PRECHARGE-BANK command (initial precharge)
376      *  2. Issue a PRECHARGE-ALL-BANKS command ("all banks ... precharged")
377      *  3. Issue two (presumably, doing eight is OK) CBR REFRESH commands
378      *  4. Issue a MODE-SET command to initialize the mode register
379      *
380      *  --------
381      *
382      *  The initial commands are executed by setting P/LSDMR[OP] and
383      *  accessing the SDRAM with a single-byte transaction."
384      *
385      * The appropriate BRx/ORx registers have already been set when we
386      * get here. The SDRAM can be accessed at the address CONFIG_SYS_SDRAM_BASE.
387      */
388
389     memctl->memc_mptpr = CONFIG_SYS_MPTPR;
390     memctl->memc_psrt  = psrt;
391
392     memctl->memc_psdmr = psdmr | PSDMR_OP_PREA;
393     *ramaddr = c;
394
395     memctl->memc_psdmr = psdmr | PSDMR_OP_CBRR;
396     for (i = 0; i < 8; i++)
397         *ramaddr = c;
398
399     memctl->memc_psdmr = psdmr | PSDMR_OP_MRW;
400     *ramaddr = c;
401
402     memctl->memc_psdmr = psdmr | PSDMR_OP_NORM | PSDMR_RFEN;
403     *ramaddr = c;
404
405     /*
406      * Do it a second time for the second set of chips if the DIMM has
407      * two chip selects (double sided).
408      */
409     if(chipselects > 1) {
410         ramaddr += sdram_size;
411
412         memctl->memc_br3 = CONFIG_SYS_BR3_PRELIM + sdram_size;
413         memctl->memc_or3 = or;
414
415         memctl->memc_psdmr = psdmr | PSDMR_OP_PREA;
416         *ramaddr = c;
417
418         memctl->memc_psdmr = psdmr | PSDMR_OP_CBRR;
419         for (i = 0; i < 8; i++)
420             *ramaddr = c;
421
422         memctl->memc_psdmr = psdmr | PSDMR_OP_MRW;
423         *ramaddr = c;
424
425         memctl->memc_psdmr = psdmr | PSDMR_OP_NORM | PSDMR_RFEN;
426         *ramaddr = c;
427     }
428
429     /* return total ram size */
430     return (sdram_size * chipselects);
431 }
432
433 /*-----------------------------------------------------------------------
434  * Board Control Functions
435  */
436 void board_poweroff (void)
437 {
438     while (1);          /* hang forever */
439 }
440
441
442 #ifdef CONFIG_MISC_INIT_R
443 /* ------------------------------------------------------------------------- */
444 int misc_init_r(void)
445 {
446     /*
447      * Note: iop is used by the I2C macros, and iopa by the ADC/DAC initialization.
448      */
449     volatile ioport_t *iopa = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 0 /* port A */);
450     volatile ioport_t *iop  = ioport_addr((immap_t *)CONFIG_SYS_IMMR, I2C_PORT);
451
452     int  reg;          /* I2C register value */
453     char *ep;          /* Environment pointer */
454     char str_buf[12] ; /* sprintf output buffer */
455     int  sample_rate;  /* ADC/DAC sample rate */
456     int  sample_64x;   /* Use  64/4 clocking for the ADC/DAC */
457     int  sample_128x;  /* Use 128/4 clocking for the ADC/DAC */
458     int  right_just;   /* Is the data to the DAC right justified? */
459     int  mclk_divide;  /* MCLK Divide */
460     int  quiet;        /* Quiet or minimal output mode */
461
462     quiet = 0;
463     if ((ep = getenv("quiet")) != NULL) {
464         quiet = simple_strtol(ep, NULL, 10);
465     }
466     else {
467         setenv("quiet", "0");
468     }
469
470     /*
471      * SACSng custom initialization:
472      *    Start the ADC and DAC clocks, since the Crystal parts do not
473      *    work on the I2C bus until the clocks are running.
474      */
475
476     sample_rate = INITIAL_SAMPLE_RATE;
477     if ((ep = getenv("DaqSampleRate")) != NULL) {
478         sample_rate = simple_strtol(ep, NULL, 10);
479     }
480
481     sample_64x  = INITIAL_SAMPLE_64X;
482     sample_128x = INITIAL_SAMPLE_128X;
483     if ((ep = getenv("Daq64xSampling")) != NULL) {
484         sample_64x = simple_strtol(ep, NULL, 10);
485         if (sample_64x) {
486             sample_128x = 0;
487         }
488         else {
489             sample_128x = 1;
490         }
491     }
492     else {
493         if ((ep = getenv("Daq128xSampling")) != NULL) {
494             sample_128x = simple_strtol(ep, NULL, 10);
495             if (sample_128x) {
496                 sample_64x = 0;
497             }
498             else {
499                 sample_64x = 1;
500             }
501         }
502     }
503
504     /*
505      * Stop the clocks and wait for at least 1 LRCLK period
506      * to make sure the clocking has really stopped.
507      */
508     Daq_Stop_Clocks();
509     udelay((1000000 / sample_rate) * NUM_LRCLKS_TO_STABILIZE);
510
511     /*
512      * Initialize the clocks with the new rates
513      */
514     Daq_Init_Clocks(sample_rate, sample_64x);
515     sample_rate = Daq_Get_SampleRate();
516
517     /*
518      * Start the clocks and wait for at least 1 LRCLK period
519      * to make sure the clocking has become stable.
520      */
521     Daq_Start_Clocks(sample_rate);
522     udelay((1000000 / sample_rate) * NUM_LRCLKS_TO_STABILIZE);
523
524     sprintf(str_buf, "%d", sample_rate);
525     setenv("DaqSampleRate", str_buf);
526
527     if (sample_64x) {
528         setenv("Daq64xSampling",  "1");
529         setenv("Daq128xSampling", NULL);
530     }
531     else {
532         setenv("Daq64xSampling",  NULL);
533         setenv("Daq128xSampling", "1");
534     }
535
536     /*
537      * Display the ADC/DAC clocking information
538      */
539     if (!quiet) {
540         Daq_Display_Clocks();
541     }
542
543     /*
544      * Determine the DAC data justification
545      */
546
547     right_just = INITIAL_RIGHT_JUST;
548     if ((ep = getenv("DaqDACRightJustified")) != NULL) {
549         right_just = simple_strtol(ep, NULL, 10);
550     }
551
552     sprintf(str_buf, "%d", right_just);
553     setenv("DaqDACRightJustified", str_buf);
554
555     /*
556      * Determine the DAC MCLK Divide
557      */
558
559     mclk_divide = INITIAL_MCLK_DIVIDE;
560     if ((ep = getenv("DaqDACMClockDivide")) != NULL) {
561         mclk_divide = simple_strtol(ep, NULL, 10);
562     }
563
564     sprintf(str_buf, "%d", mclk_divide);
565     setenv("DaqDACMClockDivide", str_buf);
566
567     /*
568      * Initializing the I2C address in the Crystal A/Ds:
569      *
570      * 1) Wait for VREF cap to settle (10uSec per uF)
571      * 2) Release pullup on SDATA
572      * 3) Write the I2C address to register 6
573      * 4) Enable address matching by setting the MSB in register 7
574      */
575
576     if (!quiet) {
577         printf("Initializing the ADC...\n");
578     }
579     udelay(ADC_INITIAL_DELAY);          /* 10uSec per uF of VREF cap */
580
581     iopa->pdat &= ~ADC_SDATA1_MASK;     /* release SDATA1 */
582     udelay(ADC_SDATA_DELAY);            /* arbitrary settling time */
583
584     i2c_reg_write(0x00, 0x06, I2C_ADC_1_ADDR);  /* set address */
585     i2c_reg_write(I2C_ADC_1_ADDR, 0x07,         /* turn on ADDREN */
586                   ADC_REG7_ADDR_ENABLE);
587
588     i2c_reg_write(I2C_ADC_1_ADDR, 0x02, /* 128x, slave mode, !HPEN */
589                   (sample_64x ? 0 : ADC_REG2_128x) |
590                   ADC_REG2_HIGH_PASS_DIS |
591                   ADC_REG2_SLAVE_MODE);
592
593     reg = i2c_reg_read(I2C_ADC_1_ADDR, 0x06) & 0x7F;
594     if(reg != I2C_ADC_1_ADDR)
595         printf("Init of ADC U10 failed: address is 0x%02X should be 0x%02X\n",
596                reg, I2C_ADC_1_ADDR);
597
598     iopa->pdat &= ~ADC_SDATA2_MASK;     /* release SDATA2 */
599     udelay(ADC_SDATA_DELAY);            /* arbitrary settling time */
600
601     i2c_reg_write(0x00, 0x06, I2C_ADC_2_ADDR);  /* set address (do not set ADDREN yet) */
602
603     i2c_reg_write(I2C_ADC_2_ADDR, 0x02, /* 64x, slave mode, !HPEN */
604                   (sample_64x ? 0 : ADC_REG2_128x) |
605                   ADC_REG2_HIGH_PASS_DIS |
606                   ADC_REG2_SLAVE_MODE);
607
608     reg = i2c_reg_read(I2C_ADC_2_ADDR, 0x06) & 0x7F;
609     if(reg != I2C_ADC_2_ADDR)
610         printf("Init of ADC U15 failed: address is 0x%02X should be 0x%02X\n",
611                reg, I2C_ADC_2_ADDR);
612
613     i2c_reg_write(I2C_ADC_1_ADDR, 0x01, /* set FSTART and GNDCAL */
614                   ADC_REG1_FRAME_START |
615                   ADC_REG1_GROUND_CAL);
616
617     i2c_reg_write(I2C_ADC_1_ADDR, 0x02, /* Start calibration */
618                   (sample_64x ? 0 : ADC_REG2_128x) |
619                   ADC_REG2_CAL |
620                   ADC_REG2_HIGH_PASS_DIS |
621                   ADC_REG2_SLAVE_MODE);
622
623     udelay(ADC_CAL_DELAY);              /* a minimum of 4100 LRCLKs */
624     i2c_reg_write(I2C_ADC_1_ADDR, 0x01, 0x00);  /* remove GNDCAL */
625
626     /*
627      * Now that we have synchronized the ADC's, enable address
628      * selection on the second ADC as well as the first.
629      */
630     i2c_reg_write(I2C_ADC_2_ADDR, 0x07, ADC_REG7_ADDR_ENABLE);
631
632     /*
633      * Initialize the Crystal DAC
634      *
635      * Two of the config lines are used for I2C so we have to set them
636      * to the proper initialization state without inadvertantly
637      * sending an I2C "start" sequence.  When we bring the I2C back to
638      * the normal state, we send an I2C "stop" sequence.
639      */
640     if (!quiet) {
641         printf("Initializing the DAC...\n");
642     }
643
644     /*
645      * Bring the I2C clock and data lines low for initialization
646      */
647     I2C_SCL(0);
648     I2C_DELAY;
649     I2C_SDA(0);
650     I2C_ACTIVE;
651     I2C_DELAY;
652
653     /* Reset the DAC */
654     iopa->pdat &= ~DAC_RST_MASK;
655     udelay(DAC_RESET_DELAY);
656
657     /* Release the DAC reset */
658     iopa->pdat |=  DAC_RST_MASK;
659     udelay(DAC_INITIAL_DELAY);
660
661     /*
662      * Cause the DAC to:
663      *     Enable control port (I2C mode)
664      *     Going into power down
665      */
666     i2c_reg_write(I2C_DAC_ADDR, 0x05,
667                   DAC_REG5_I2C_MODE |
668                   DAC_REG5_POWER_DOWN);
669
670     /*
671      * Cause the DAC to:
672      *     Enable control port (I2C mode)
673      *     Going into power down
674      *         . MCLK divide by 1
675      *         . MCLK divide by 2
676      */
677     i2c_reg_write(I2C_DAC_ADDR, 0x05,
678                   DAC_REG5_I2C_MODE |
679                   DAC_REG5_POWER_DOWN |
680                   (mclk_divide ? DAC_REG5_MCLK_DIV : 0));
681
682     /*
683      * Cause the DAC to:
684      *     Auto-mute disabled
685      *         . Format 0, left  justified 24 bits
686      *         . Format 3, right justified 24 bits
687      *     No de-emphasis
688      *         . Single speed mode
689      *         . Double speed mode
690      */
691     i2c_reg_write(I2C_DAC_ADDR, 0x01,
692                   (right_just ? DAC_REG1_RIGHT_JUST_24BIT :
693                                 DAC_REG1_LEFT_JUST_24_BIT) |
694                   DAC_REG1_DEM_NO |
695                   (sample_rate >= 50000 ? DAC_REG1_DOUBLE : DAC_REG1_SINGLE));
696
697     sprintf(str_buf, "%d",
698             sample_rate >= 50000 ? DAC_REG1_DOUBLE : DAC_REG1_SINGLE);
699     setenv("DaqDACFunctionalMode", str_buf);
700
701     /*
702      * Cause the DAC to:
703      *     Enable control port (I2C mode)
704      *     Remove power down
705      *         . MCLK divide by 1
706      *         . MCLK divide by 2
707      */
708     i2c_reg_write(I2C_DAC_ADDR, 0x05,
709                   DAC_REG5_I2C_MODE |
710                   (mclk_divide ? DAC_REG5_MCLK_DIV : 0));
711
712     /*
713      * Create a I2C stop condition:
714      *     low->high on data while clock is high.
715      */
716     I2C_SCL(1);
717     I2C_DELAY;
718     I2C_SDA(1);
719     I2C_DELAY;
720     I2C_TRISTATE;
721
722     if (!quiet) {
723         printf("\n");
724     }
725
726 #ifdef CONFIG_ETHER_LOOPBACK_TEST
727     /*
728      * Run the Ethernet loopback test
729      */
730     eth_loopback_test ();
731 #endif /* CONFIG_ETHER_LOOPBACK_TEST */
732
733 #ifdef CONFIG_SHOW_BOOT_PROGRESS
734     /*
735      * Turn off the RED fail LED now that we are up and running.
736      */
737     status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
738 #endif
739
740     return 0;
741 }
742
743 #ifdef CONFIG_SHOW_BOOT_PROGRESS
744 /*
745  * Show boot status: flash the LED if something goes wrong, indicating
746  * that last thing that worked and thus, by implication, what is broken.
747  *
748  * This stores the last OK value in RAM so this will not work properly
749  * before RAM is initialized.  Since it is being used for indicating
750  * boot status (i.e. after RAM is initialized), that is OK.
751  */
752 static void flash_code(uchar number, uchar modulo, uchar digits)
753 {
754     int   j;
755
756     /*
757      * Recursively do upper digits.
758      */
759     if(digits > 1) {
760         flash_code(number / modulo, modulo, digits - 1);
761     }
762
763     number = number % modulo;
764
765     /*
766      * Zero is indicated by one long flash (dash).
767      */
768     if(number == 0) {
769         status_led_set(STATUS_LED_BOOT, STATUS_LED_ON);
770         udelay(1000000);
771         status_led_set(STATUS_LED_BOOT, STATUS_LED_OFF);
772         udelay(200000);
773     } else {
774         /*
775          * Non-zero is indicated by short flashes, one per count.
776          */
777         for(j = 0; j < number; j++) {
778             status_led_set(STATUS_LED_BOOT, STATUS_LED_ON);
779             udelay(100000);
780             status_led_set(STATUS_LED_BOOT, STATUS_LED_OFF);
781             udelay(200000);
782         }
783     }
784     /*
785      * Inter-digit pause: we've already waited 200 mSec, wait 1 sec total
786      */
787     udelay(700000);
788 }
789
790 static int last_boot_progress;
791
792 void show_boot_progress (int status)
793 {
794     int i,j;
795     if(status > 0) {
796         last_boot_progress = status;
797     } else {
798         /*
799          * If a specific failure code is given, flash this code
800          * else just use the last success code we've seen
801          */
802         if(status < -1)
803             last_boot_progress = -status;
804
805         /*
806          * Flash this code 5 times
807          */
808         for(j=0; j<5; j++) {
809             /*
810              * Houston, we have a problem.
811              * Blink the last OK status which indicates where things failed.
812              */
813             status_led_set(STATUS_LED_RED, STATUS_LED_ON);
814             flash_code(last_boot_progress, 5, 3);
815
816             /*
817              * Delay 5 seconds between repetitions,
818              * with the fault LED blinking
819              */
820             for(i=0; i<5; i++) {
821                 status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
822                 udelay(500000);
823                 status_led_set(STATUS_LED_RED, STATUS_LED_ON);
824                 udelay(500000);
825             }
826         }
827
828         /*
829          * Reset the board to retry initialization.
830          */
831         do_reset (NULL, 0, 0, NULL);
832     }
833 }
834 #endif /* CONFIG_SHOW_BOOT_PROGRESS */
835
836
837 /*
838  * The following are used to control the SPI chip selects for the SPI command.
839  */
840 #if defined(CONFIG_CMD_SPI)
841
842 #define SPI_ADC_CS_MASK 0x00000800
843 #define SPI_DAC_CS_MASK 0x00001000
844
845 static const u32 cs_mask[] = {
846     SPI_ADC_CS_MASK,
847     SPI_DAC_CS_MASK,
848 };
849
850 int spi_cs_is_valid(unsigned int bus, unsigned int cs)
851 {
852     return bus == 0 && cs < sizeof(cs_mask) / sizeof(cs_mask[0]);
853 }
854
855 void spi_cs_activate(struct spi_slave *slave)
856 {
857     volatile ioport_t *iopd = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 3 /* port D */);
858
859     iopd->pdat &= ~cs_mask[slave->cs];
860 }
861
862 void spi_cs_deactivate(struct spi_slave *slave)
863 {
864     volatile ioport_t *iopd = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 3 /* port D */);
865
866     iopd->pdat |= cs_mask[slave->cs];
867 }
868
869 #endif
870
871 #endif /* CONFIG_MISC_INIT_R */
872
873 #ifdef CONFIG_POST
874 /*
875  * Returns 1 if keys pressed to start the power-on long-running tests
876  * Called from board_init_f().
877  */
878 int post_hotkeys_pressed(void)
879 {
880         return 0;       /* No hotkeys supported */
881 }
882
883 #endif