Initial revision
authorwdenk <wdenk>
Sat, 26 Oct 2002 15:22:42 +0000 (15:22 +0000)
committerwdenk <wdenk>
Sat, 26 Oct 2002 15:22:42 +0000 (15:22 +0000)
common/cmd_i2c.c [new file with mode: 0644]
include/configs/smdk2410.h [new file with mode: 0644]

diff --git a/common/cmd_i2c.c b/common/cmd_i2c.c
new file mode 100644 (file)
index 0000000..fe5841e
--- /dev/null
@@ -0,0 +1,868 @@
+/*
+ * (C) Copyright 2001
+ * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+/*
+ * I2C Functions similar to the standard memory functions.
+ *
+ * There are several parameters in many of the commands that bear further
+ * explanations:
+ *
+ * Two of the commands (imm and imw) take a byte/word/long modifier
+ * (e.g. imm.w specifies the word-length modifier).  This was done to
+ * allow manipulating word-length registers.  It was not done on any other
+ * commands because it was not deemed useful.
+ *
+ * {i2c_chip} is the I2C chip address (the first byte sent on the bus).
+ *   Each I2C chip on the bus has a unique address.  On the I2C data bus,
+ *   the address is the upper seven bits and the LSB is the "read/write"
+ *   bit.  Note that the {i2c_chip} address specified on the command
+ *   line is not shifted up: e.g. a typical EEPROM memory chip may have
+ *   an I2C address of 0x50, but the data put on the bus will be 0xA0
+ *   for write and 0xA1 for read.  This "non shifted" address notation
+ *   matches at least half of the data sheets :-/.
+ *
+ * {addr} is the address (or offset) within the chip.  Small memory
+ *   chips have 8 bit addresses.  Large memory chips have 16 bit
+ *   addresses.  Other memory chips have 9, 10, or 11 bit addresses.
+ *   Many non-memory chips have multiple registers and {addr} is used
+ *   as the register index.  Some non-memory chips have only one register
+ *   and therefore don't need any {addr} parameter.
+ *
+ *   The default {addr} parameter is one byte (.1) which works well for
+ *   memories and registers with 8 bits of address space.
+ *
+ *   You can specify the length of the {addr} field with the optional .0,
+ *   .1, or .2 modifier (similar to the .b, .w, .l modifier).  If you are
+ *   manipulating a single register device which doesn't use an address
+ *   field, use "0.0" for the address and the ".0" length field will
+ *   suppress the address in the I2C data stream.  This also works for
+ *   successive reads using the I2C auto-incrementing memory pointer.
+ *
+ *   If you are manipulating a large memory with 2-byte addresses, use
+ *   the .2 address modifier, e.g. 210.2 addresses location 528 (decimal).
+ *
+ *   Then there are the unfortunate memory chips that spill the most
+ *   significant 1, 2, or 3 bits of address into the chip address byte.
+ *   This effectively makes one chip (logically) look like 2, 4, or
+ *   8 chips.  This is handled (awkwardly) by #defining
+ *   CFG_I2C_EEPROM_ADDR_OVERFLOW and using the .1 modifier on the
+ *   {addr} field (since .1 is the default, it doesn't actually have to
+ *   be specified).  Examples: given a memory chip at I2C chip address
+ *   0x50, the following would happen...
+ *     imd 50 0 10      display 16 bytes starting at 0x000
+ *                      On the bus: <S> A0 00 <E> <S> A1 <rd> ... <rd>
+ *     imd 50 100 10    display 16 bytes starting at 0x100
+ *                      On the bus: <S> A2 00 <E> <S> A3 <rd> ... <rd>
+ *     imd 50 210 10    display 16 bytes starting at 0x210
+ *                      On the bus: <S> A4 10 <E> <S> A5 <rd> ... <rd>
+ *   This is awfully ugly.  It would be nice if someone would think up
+ *   a better way of handling this.
+ *
+ * Adapted from cmd_mem.c which is copyright Wolfgang Denk (wd@denx.de).
+ */
+
+#include <common.h>
+#include <command.h>
+#include <cmd_i2c.h>
+#include <i2c.h>
+#include <asm/byteorder.h>
+
+#if (CONFIG_COMMANDS & CFG_CMD_I2C)
+
+
+/* Display values from last command.
+ * Memory modify remembered values are different from display memory.
+ */
+static uchar   i2c_dp_last_chip;
+static uint    i2c_dp_last_addr;
+static uint    i2c_dp_last_alen;
+static uint    i2c_dp_last_length = 0x10;
+
+static uchar   i2c_mm_last_chip;
+static uint    i2c_mm_last_addr;
+static uint    i2c_mm_last_alen;
+
+#if defined(CFG_I2C_NOPROBES)
+static uchar i2c_no_probes[] = CFG_I2C_NOPROBES;
+#endif
+
+static int
+mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char *argv[]);
+extern int cmd_get_data_size(char* arg, int default_size);
+
+/*
+ * Syntax:
+ *     imd {i2c_chip} {addr}{.0, .1, .2} {len}
+ */
+#define DISP_LINE_LEN  16
+
+int do_i2c_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       u_char  chip;
+       uint    addr, alen, length;
+       int     j, nbytes, linebytes;
+
+       /* We use the last specified parameters, unless new ones are
+        * entered.
+        */
+       chip   = i2c_dp_last_chip;
+       addr   = i2c_dp_last_addr;
+       alen   = i2c_dp_last_alen;
+       length = i2c_dp_last_length;
+
+       if (argc < 3) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+
+       if ((flag & CMD_FLAG_REPEAT) == 0) {
+               /*
+                * New command specified.
+                */
+               alen = 1;
+
+               /*
+                * I2C chip address
+                */
+               chip = simple_strtoul(argv[1], NULL, 16);
+
+               /*
+                * I2C data address within the chip.  This can be 1 or
+                * 2 bytes long.  Some day it might be 3 bytes long :-).
+                */
+               addr = simple_strtoul(argv[2], NULL, 16);
+               alen = 1;
+               for(j = 0; j < 8; j++) {
+                       if (argv[2][j] == '.') {
+                               alen = argv[2][j+1] - '0';
+                               if (alen > 4) {
+                                       printf ("Usage:\n%s\n", cmdtp->usage);
+                                       return 1;
+                               }
+                               break;
+                       } else if (argv[2][j] == '\0') {
+                               break;
+                       }
+               }
+
+               /*
+                * If another parameter, it is the length to display.
+                * Length is the number of objects, not number of bytes.
+                */
+               if (argc > 3)
+                       length = simple_strtoul(argv[3], NULL, 16);
+       }
+
+       /*
+        * Print the lines.
+        *
+        * We buffer all read data, so we can make sure data is read only
+        * once.
+        */
+       nbytes = length;
+       do {
+               unsigned char   linebuf[DISP_LINE_LEN];
+               unsigned char   *cp;
+
+               linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
+
+               if(i2c_read(chip, addr, alen, linebuf, linebytes) != 0) {
+                       printf("Error reading the chip.\n");
+               } else {
+                       printf("%04x:", addr);
+                       cp = linebuf;
+                       for (j=0; j<linebytes; j++) {
+                               printf(" %02x", *cp++);
+                               addr++;
+                       }
+                       printf("    ");
+                       cp = linebuf;
+                       for (j=0; j<linebytes; j++) {
+                               if ((*cp < 0x20) || (*cp > 0x7e))
+                                       printf(".");
+                               else
+                                       printf("%c", *cp);
+                               cp++;
+                       }
+                       printf("\n");
+               }
+               nbytes -= linebytes;
+       } while (nbytes > 0);
+
+       i2c_dp_last_chip   = chip;
+       i2c_dp_last_addr   = addr;
+       i2c_dp_last_alen   = alen;
+       i2c_dp_last_length = length;
+
+       return 0;
+}
+
+int do_i2c_mm ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
+}
+
+
+int do_i2c_nm ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
+}
+
+/* Write (fill) memory
+ *
+ * Syntax:
+ *     imw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
+ */
+int do_i2c_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       uchar   chip;
+       ulong   addr;
+       uint    alen;
+       uchar   byte;
+       int     count;
+       int     j;
+
+       if ((argc < 4) || (argc > 5)) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+
+       /*
+        * Chip is always specified.
+        */
+       chip = simple_strtoul(argv[1], NULL, 16);
+
+       /*
+        * Address is always specified.
+        */
+       addr = simple_strtoul(argv[2], NULL, 16);
+       alen = 1;
+       for(j = 0; j < 8; j++) {
+               if (argv[2][j] == '.') {
+                       alen = argv[2][j+1] - '0';
+                       if(alen > 4) {
+                               printf ("Usage:\n%s\n", cmdtp->usage);
+                               return 1;
+                       }
+                       break;
+               } else if (argv[2][j] == '\0') {
+                       break;
+               }
+       }
+
+       /*
+        * Value to write is always specified.
+        */
+       byte = simple_strtoul(argv[3], NULL, 16);
+
+       /*
+        * Optional count
+        */
+       if(argc == 5) {
+               count = simple_strtoul(argv[4], NULL, 16);
+       } else {
+               count = 1;
+       }
+
+       while (count-- > 0) {
+               if(i2c_write(chip, addr++, alen, &byte, 1) != 0) {
+                       printf("Error writing the chip.\n");
+               }
+               /*
+                * Wait for the write to complete.  The write can take
+                * up to 10mSec (we allow a little more time).
+                *
+                * On some chips, while the write is in progress, the
+                * chip doesn't respond.  This apparently isn't a
+                * universal feature so we don't take advantage of it.
+                */
+               udelay(11000);
+#if 0
+               for(timeout = 0; timeout < 10; timeout++) {
+                       udelay(2000);
+                       if(i2c_probe(chip) == 0)
+                               break;
+               }
+#endif
+       }
+
+       return (0);
+}
+
+
+/* Calculate a CRC on memory
+ *
+ * Syntax:
+ *     icrc32 {i2c_chip} {addr}{.0, .1, .2} {count}
+ */
+int do_i2c_crc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       uchar   chip;
+       ulong   addr;
+       uint    alen;
+       int     count;
+       uchar   byte;
+       ulong   crc;
+       ulong   err;
+       int     j;
+
+       if (argc < 4) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+
+       /*
+        * Chip is always specified.
+        */
+       chip = simple_strtoul(argv[1], NULL, 16);
+
+       /*
+        * Address is always specified.
+        */
+       addr = simple_strtoul(argv[2], NULL, 16);
+       alen = 1;
+       for(j = 0; j < 8; j++) {
+               if (argv[2][j] == '.') {
+                       alen = argv[2][j+1] - '0';
+                       if(alen > 4) {
+                               printf ("Usage:\n%s\n", cmdtp->usage);
+                               return 1;
+                       }
+                       break;
+               } else if (argv[2][j] == '\0') {
+                       break;
+               }
+       }
+
+       /*
+        * Count is always specified
+        */
+       count = simple_strtoul(argv[3], NULL, 16);
+
+       printf ("CRC32 for %08lx ... %08lx ==> ", addr, addr + count - 1);
+       /*
+        * CRC a byte at a time.  This is going to be slooow, but hey, the
+        * memories are small and slow too so hopefully nobody notices.
+        */
+       crc = 0;
+       err = 0;
+       while(count-- > 0) {
+               if(i2c_read(chip, addr, alen, &byte, 1) != 0) {
+                       err++;
+               }
+               crc = crc32 (crc, &byte, 1);
+               addr++;
+       }
+       if(err > 0)
+       {
+               printf("Error reading the chip,\n");
+       } else {
+               printf ("%08lx\n", crc);
+       }
+
+       return 0;
+}
+
+
+/* Modify memory.
+ *
+ * Syntax:
+ *     imm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
+ *     inm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
+ */
+
+static int
+mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char *argv[])
+{
+       uchar   chip;
+       ulong   addr;
+       uint    alen;
+       ulong   data;
+       int     size = 1;
+       int     nbytes;
+       int     j;
+       extern char console_buffer[];
+
+       if (argc != 3) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+
+#ifdef CONFIG_BOOT_RETRY_TIME
+       reset_cmd_timeout();    /* got a good command to get here */
+#endif
+       /*
+        * We use the last specified parameters, unless new ones are
+        * entered.
+        */
+       chip = i2c_mm_last_chip;
+       addr = i2c_mm_last_addr;
+       alen = i2c_mm_last_alen;
+
+       if ((flag & CMD_FLAG_REPEAT) == 0) {
+               /*
+                * New command specified.  Check for a size specification.
+                * Defaults to byte if no or incorrect specification.
+                */
+               size = cmd_get_data_size(argv[0], 1);
+
+               /*
+                * Chip is always specified.
+                */
+               chip = simple_strtoul(argv[1], NULL, 16);
+
+               /*
+                * Address is always specified.
+                */
+               addr = simple_strtoul(argv[2], NULL, 16);
+               alen = 1;
+               for(j = 0; j < 8; j++) {
+                       if (argv[2][j] == '.') {
+                               alen = argv[2][j+1] - '0';
+                               if(alen > 4) {
+                                       printf ("Usage:\n%s\n", cmdtp->usage);
+                                       return 1;
+                               }
+                               break;
+                       } else if (argv[2][j] == '\0') {
+                               break;
+                       }
+               }
+       }
+
+       /*
+        * Print the address, followed by value.  Then accept input for
+        * the next value.  A non-converted value exits.
+        */
+       do {
+               printf("%08lx:", addr);
+               if(i2c_read(chip, addr, alen, (char *)&data, size) != 0) {
+                       printf("\nError reading the chip,\n");
+               } else {
+                       data = cpu_to_be32(data);
+                       if(size == 1) {
+                               printf(" %02lx", (data >> 24) & 0x000000FF);
+                       } else if(size == 2) {
+                               printf(" %04lx", (data >> 16) & 0x0000FFFF);
+                       } else {
+                               printf(" %08lx", data);
+                       }
+               }
+
+               nbytes = readline (" ? ");
+               if (nbytes == 0) {
+                       /*
+                        * <CR> pressed as only input, don't modify current
+                        * location and move to next.
+                        */
+                       if (incrflag)
+                               addr += size;
+                       nbytes = size;
+#ifdef CONFIG_BOOT_RETRY_TIME
+                       reset_cmd_timeout(); /* good enough to not time out */
+#endif
+               }
+#ifdef CONFIG_BOOT_RETRY_TIME
+               else if (nbytes == -2) {
+                       break;  /* timed out, exit the command  */
+               }
+#endif
+               else {
+                       char *endp;
+
+                       data = simple_strtoul(console_buffer, &endp, 16);
+                       if(size == 1) {
+                               data = data << 24;
+                       } else if(size == 2) {
+                               data = data << 16;
+                       }
+                       data = be32_to_cpu(data);
+                       nbytes = endp - console_buffer;
+                       if (nbytes) {
+#ifdef CONFIG_BOOT_RETRY_TIME
+                               /*
+                                * good enough to not time out
+                                */
+                               reset_cmd_timeout();
+#endif
+                               if(i2c_write(chip, addr, alen, (char *)&data, size) != 0) {
+                                       printf("Error writing the chip.\n");
+                               }
+                               if (incrflag)
+                                       addr += size;
+                       }
+               }
+       } while (nbytes);
+
+       chip = i2c_mm_last_chip;
+       addr = i2c_mm_last_addr;
+       alen = i2c_mm_last_alen;
+
+       return 0;
+}
+
+/*
+ * Syntax:
+ *     iprobe {addr}{.0, .1, .2}
+ */
+int do_i2c_probe (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       int j;
+#if defined(CFG_I2C_NOPROBES)
+       int k, skip;
+#endif
+
+       printf("Valid chip addresses:");
+       for(j = 0; j < 128; j++) {
+#if defined(CFG_I2C_NOPROBES)
+               skip = 0;
+               for (k = 0; k < sizeof(i2c_no_probes); k++){
+                       if (j == i2c_no_probes[k]){
+                               skip = 1;
+                               break;
+                       }
+               }
+               if (skip)
+                       continue;
+#endif
+               if(i2c_probe(j) == 0) {
+                       printf(" %02X", j);
+               }
+       }
+       printf("\n");
+
+#if defined(CFG_I2C_NOPROBES)
+       puts ("Excluded chip addresses:");
+       for( k = 0; k < sizeof(i2c_no_probes); k++ )
+               printf(" %02X", i2c_no_probes[k] );
+       puts ("\n");
+#endif
+
+       return 0;
+}
+
+
+/*
+ * Syntax:
+ *     iloop {i2c_chip} {addr}{.0, .1, .2} [{length}] [{delay}]
+ *     {length} - Number of bytes to read
+ *     {delay}  - A DECIMAL number and defaults to 1000 uSec
+ */
+int do_i2c_loop(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       u_char  chip;
+       ulong   alen;
+       uint    addr;
+       uint    length;
+       u_char  bytes[16];
+       int     delay;
+       int     j;
+
+       if (argc < 3) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+
+       /*
+        * Chip is always specified.
+        */
+       chip = simple_strtoul(argv[1], NULL, 16);
+
+       /*
+        * Address is always specified.
+        */
+       addr = simple_strtoul(argv[2], NULL, 16);
+       alen = 1;
+       for(j = 0; j < 8; j++) {
+               if (argv[2][j] == '.') {
+                       alen = argv[2][j+1] - '0';
+                       if (alen > 4) {
+                               printf ("Usage:\n%s\n", cmdtp->usage);
+                               return 1;
+                       }
+                       break;
+               } else if (argv[2][j] == '\0') {
+                       break;
+               }
+       }
+
+       /*
+        * Length is the number of objects, not number of bytes.
+        */
+       length = 1;
+       length = simple_strtoul(argv[3], NULL, 16);
+       if(length > sizeof(bytes)) {
+               length = sizeof(bytes);
+       }
+
+       /*
+        * The delay time (uSec) is optional.
+        */
+       delay = 1000;
+       if (argc > 3) {
+               delay = simple_strtoul(argv[4], NULL, 10);
+       }
+       /*
+        * Run the loop...
+        */
+       while(1) {
+               if(i2c_read(chip, addr, alen, bytes, length) != 0) {
+                       printf("Error reading the chip.\n");
+               }
+               udelay(delay);
+       }
+
+       /* NOTREACHED */
+       return 0;
+}
+
+
+/*
+ * The SDRAM command is separately configured because many
+ * (most?) embedded boards don't use SDRAM DIMMs.
+ */
+#if (CONFIG_COMMANDS & CFG_CMD_SDRAM)
+
+/*
+ * Syntax:
+ *     sdram {i2c_chip}
+ */
+int do_sdram  ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+       u_char  chip;
+       u_char  data[128];
+       u_char  cksum;
+       int     j;
+
+       if (argc < 2) {
+               printf ("Usage:\n%s\n", cmdtp->usage);
+               return 1;
+       }
+       /*
+        * Chip is always specified.
+        */
+       chip = simple_strtoul(argv[1], NULL, 16);
+
+       if(i2c_read(chip, 0, 1, data, sizeof(data)) != 0) {
+               printf("No SDRAM Serial Presence Detect found.\n");
+               return 1;
+       }
+
+       cksum = 0;
+       for (j = 0; j < 63; j++) {
+               cksum += data[j];
+       }
+       if(cksum != data[63]) {
+               printf ("WARNING: Configuration data checksum failure:\n"
+                       "  is 0x%02x, calculated 0x%02x\n",
+                       data[63], cksum);
+       }
+       printf("SPD data revision            %d.%d\n",
+               (data[62] >> 4) & 0x0F, data[62] & 0x0F);
+       printf("Bytes used                   0x%02X\n", data[0]);
+       printf("Serial memory size           0x%02X\n", 1 << data[1]);
+       printf("Memory type                  ");
+       switch(data[2]) {
+               case 2:  printf("EDO\n");       break;
+               case 4:  printf("SDRAM\n");     break;
+               default: printf("unknown\n");   break;
+       }
+       printf("Row address bits             ");
+       if((data[3] & 0x00F0) == 0) {
+               printf("%d\n", data[3] & 0x0F);
+       } else {
+               printf("%d/%d\n", data[3] & 0x0F, (data[3] >> 4) & 0x0F);
+       }
+       printf("Column address bits          ");
+       if((data[4] & 0x00F0) == 0) {
+               printf("%d\n", data[4] & 0x0F);
+       } else {
+               printf("%d/%d\n", data[4] & 0x0F, (data[4] >> 4) & 0x0F);
+       }
+       printf("Module rows                  %d\n", data[5]);
+       printf("Module data width            %d bits\n", (data[7] << 8) | data[6]);
+       printf("Interface signal levels      ");
+       switch(data[8]) {
+               case 0:  printf("5.0v/TTL\n");  break;
+               case 1:  printf("LVTTL\n");     break;
+               case 2:  printf("HSTL 1.5\n");  break;
+               case 3:  printf("SSTL 3.3\n");  break;
+               case 4:  printf("SSTL 2.5\n");  break;
+               default: printf("unknown\n");   break;
+       }
+       printf("SDRAM cycle time             %d.%d nS\n",
+               (data[9] >> 4) & 0x0F, data[9] & 0x0F);
+       printf("SDRAM access time            %d.%d nS\n",
+               (data[10] >> 4) & 0x0F, data[10] & 0x0F);
+       printf("EDC configuration            ");
+       switch(data[11]) {
+               case 0:  printf("None\n");      break;
+               case 1:  printf("Parity\n");    break;
+               case 2:  printf("ECC\n");       break;
+               default: printf("unknown\n");   break;
+       }
+       if((data[12] & 0x80) == 0) {
+               printf("No self refresh, rate        ");
+       } else {
+               printf("Self refresh, rate           ");
+       }
+       switch(data[12] & 0x7F) {
+               case 0:  printf("15.625uS\n");  break;
+               case 1:  printf("3.9uS\n");     break;
+               case 2:  printf("7.8uS\n");     break;
+               case 3:  printf("31.3uS\n");    break;
+               case 4:  printf("62.5uS\n");    break;
+               case 5:  printf("125uS\n");     break;
+               default: printf("unknown\n");   break;
+       }
+       printf("SDRAM width (primary)        %d\n", data[13] & 0x7F);
+       if((data[13] & 0x80) != 0) {
+               printf("  (second bank)              %d\n",
+                       2 * (data[13] & 0x7F));
+       }
+       if(data[14] != 0) {
+               printf("EDC width                    %d\n",
+                       data[14] & 0x7F);
+               if((data[14] & 0x80) != 0) {
+                       printf("  (second bank)              %d\n",
+                               2 * (data[14] & 0x7F));
+               }
+       }
+       printf("Min clock delay, back-to-back random column addresses %d\n",
+               data[15]);
+       printf("Burst length(s)             ");
+       if(data[16] & 0x80) printf(" Page");
+       if(data[16] & 0x08) printf(" 8");
+       if(data[16] & 0x04) printf(" 4");
+       if(data[16] & 0x02) printf(" 2");
+       if(data[16] & 0x01) printf(" 1");
+       printf("\n");
+       printf("Number of banks              %d\n", data[17]);
+       printf("CAS latency(s)              ");
+       if(data[18] & 0x80) printf(" TBD");
+       if(data[18] & 0x40) printf(" 7");
+       if(data[18] & 0x20) printf(" 6");
+       if(data[18] & 0x10) printf(" 5");
+       if(data[18] & 0x08) printf(" 4");
+       if(data[18] & 0x04) printf(" 3");
+       if(data[18] & 0x02) printf(" 2");
+       if(data[18] & 0x01) printf(" 1");
+       printf("\n");
+       printf("CS latency(s)               ");
+       if(data[19] & 0x80) printf(" TBD");
+       if(data[19] & 0x40) printf(" 6");
+       if(data[19] & 0x20) printf(" 5");
+       if(data[19] & 0x10) printf(" 4");
+       if(data[19] & 0x08) printf(" 3");
+       if(data[19] & 0x04) printf(" 2");
+       if(data[19] & 0x02) printf(" 1");
+       if(data[19] & 0x01) printf(" 0");
+       printf("\n");
+       printf("WE latency(s)               ");
+       if(data[20] & 0x80) printf(" TBD");
+       if(data[20] & 0x40) printf(" 6");
+       if(data[20] & 0x20) printf(" 5");
+       if(data[20] & 0x10) printf(" 4");
+       if(data[20] & 0x08) printf(" 3");
+       if(data[20] & 0x04) printf(" 2");
+       if(data[20] & 0x02) printf(" 1");
+       if(data[20] & 0x01) printf(" 0");
+       printf("\n");
+       printf("Module attributes:\n");
+       if(!data[21])       printf("  (none)\n");
+       if(data[21] & 0x80) printf("  TBD (bit 7)\n");
+       if(data[21] & 0x40) printf("  Redundant row address\n");
+       if(data[21] & 0x20) printf("  Differential clock input\n");
+       if(data[21] & 0x10) printf("  Registerd DQMB inputs\n");
+       if(data[21] & 0x08) printf("  Buffered DQMB inputs\n");
+       if(data[21] & 0x04) printf("  On-card PLL\n");
+       if(data[21] & 0x02) printf("  Registered address/control lines\n");
+       if(data[21] & 0x01) printf("  Buffered address/control lines\n");
+       printf("Device attributes:\n");
+       if(data[22] & 0x80) printf("  TBD (bit 7)\n");
+       if(data[22] & 0x40) printf("  TBD (bit 6)\n");
+       if(data[22] & 0x20) printf("  Upper Vcc tolerance 5%%\n");
+       else                printf("  Upper Vcc tolerance 10%%\n");
+       if(data[22] & 0x10) printf("  Lower Vcc tolerance 5%%\n");
+       else                printf("  Lower Vcc tolerance 10%%\n");
+       if(data[22] & 0x08) printf("  Supports write1/read burst\n");
+       if(data[22] & 0x04) printf("  Supports precharge all\n");
+       if(data[22] & 0x02) printf("  Supports auto precharge\n");
+       if(data[22] & 0x01) printf("  Supports early RAS# precharge\n");
+       printf("SDRAM cycle time (2nd highest CAS latency)        %d.%d nS\n",
+               (data[23] >> 4) & 0x0F, data[23] & 0x0F);
+       printf("SDRAM access from clock (2nd highest CAS latency) %d.%d nS\n",
+               (data[24] >> 4) & 0x0F, data[24] & 0x0F);
+       printf("SDRAM cycle time (3rd highest CAS latency)        %d.%d nS\n",
+               (data[25] >> 4) & 0x0F, data[25] & 0x0F);
+       printf("SDRAM access from clock (3rd highest CAS latency) %d.%d nS\n",
+               (data[26] >> 4) & 0x0F, data[26] & 0x0F);
+       printf("Minimum row precharge        %d nS\n", data[27]);
+       printf("Row active to row active min %d nS\n", data[28]);
+       printf("RAS to CAS delay min         %d nS\n", data[29]);
+       printf("Minimum RAS pulse width      %d nS\n", data[30]);
+       printf("Density of each row         ");
+       if(data[31] & 0x80) printf(" 512MByte");
+       if(data[31] & 0x40) printf(" 256MByte");
+       if(data[31] & 0x20) printf(" 128MByte");
+       if(data[31] & 0x10) printf(" 64MByte");
+       if(data[31] & 0x08) printf(" 32MByte");
+       if(data[31] & 0x04) printf(" 16MByte");
+       if(data[31] & 0x02) printf(" 8MByte");
+       if(data[31] & 0x01) printf(" 4MByte");
+       printf("\n");
+       printf("Command and Address setup    %c%d.%d nS\n",
+               (data[32] & 0x80) ? '-' : '+',
+               (data[32] >> 4) & 0x07, data[32] & 0x0F);
+       printf("Command and Address hold     %c%d.%d nS\n",
+               (data[33] & 0x80) ? '-' : '+',
+               (data[33] >> 4) & 0x07, data[33] & 0x0F);
+       printf("Data signal input setup      %c%d.%d nS\n",
+               (data[34] & 0x80) ? '-' : '+',
+               (data[34] >> 4) & 0x07, data[34] & 0x0F);
+       printf("Data signal input hold       %c%d.%d nS\n",
+               (data[35] & 0x80) ? '-' : '+',
+               (data[35] >> 4) & 0x07, data[35] & 0x0F);
+       printf("Manufacturer's JEDEC ID      ");
+       for(j = 64; j <= 71; j++)
+               printf("%02X ", data[j]);
+       printf("\n");
+       printf("Manufacturing Location       %02X\n", data[72]);
+       printf("Manufacturer's Part Number   ");
+       for(j = 73; j <= 90; j++)
+               printf("%02X ", data[j]);
+       printf("\n");
+       printf("Revision Code                %02X %02X\n", data[91], data[92]);
+       printf("Manufacturing Date           %02X %02X\n", data[93], data[94]);
+       printf("Assembly Serial Number       ");
+       for(j = 95; j <= 98; j++)
+               printf("%02X ", data[j]);
+       printf("\n");
+       printf("Speed rating                 PC%d\n",
+               data[126] == 0x66 ? 66 : data[126]);
+
+       return 0;
+}
+#endif /* CFG_CMD_SDRAM */
+
+#endif /* CFG_CMD_I2C */
diff --git a/include/configs/smdk2410.h b/include/configs/smdk2410.h
new file mode 100644 (file)
index 0000000..8cebbec
--- /dev/null
@@ -0,0 +1,173 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Marius Groeger <mgroeger@sysgo.de>
+ * Gary Jennejohn <gj@denx.de>
+ * David Mueller <d.mueller@elsoft.ch>
+ *
+ * Configuation settings for the SAMSUNG SMDK2410 board.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+/*
+ * If we are developing, we might want to start armboot from ram
+ * so we MUST NOT initialize critical regs like mem-timing ...
+ */
+#define CONFIG_INIT_CRITICAL           /* undef for developing */
+
+/*
+ * High Level Configuration Options
+ * (easy to change)
+ */
+#define CONFIG_ARM920T         1       /* This is an ARM920T Core      */
+#define        CONFIG_S3C2410          1       /* in a SAMSUNG S3C2410 SoC     */
+#define CONFIG_SMDK2410                1       /* on a SAMSUNG SMDK2410 Board  */
+
+/* input clock of PLL */
+#define CONFIG_PLL_INPUT_FREQ  12000000/* the SMDK2410 has 12MHz input clock */
+
+
+#define USE_920T_MMU           1
+#undef CONFIG_USE_IRQ                  /* we don't need IRQ/FIQ stuff */
+
+/*
+ * Size of malloc() pool
+ */
+#define CONFIG_MALLOC_SIZE     (CFG_ENV_SIZE + 128*1024)
+
+/*
+ * Hardware drivers
+ */
+#define CONFIG_DRIVER_CS8900   1       /* we have a CS8900 on-board */
+#define CS8900_BASE            0x19000300
+#define CS8900_BUS16           1 /* the Linux driver does accesses as shorts */
+
+/*
+ * select serial console configuration
+ */
+#define CONFIG_SERIAL1          1      /* we use SERIAL 1 on SMDK2410 */
+
+/* allow to overwrite serial and ethaddr */
+#define CONFIG_ENV_OVERWRITE
+
+#define CONFIG_BAUDRATE                115200
+
+#ifndef USE_920T_MMU
+#define CONFIG_COMMANDS                (CONFIG_CMD_DFL & ~CFG_CMD_CACHE)
+#else
+#define CONFIG_COMMANDS                (CONFIG_CMD_DFL)
+#endif
+
+/* this must be included AFTER the definition of CONFIG_COMMANDS (if any) */
+#include <cmd_confdefs.h>
+
+#define CONFIG_BOOTDELAY       3
+/*#define CONFIG_BOOTARGS      "root=ramfs devfs=mount console=ttySA0,9600" */
+/*#define CONFIG_ETHADDR       08:00:3e:26:0a:5b */
+#define CONFIG_NETMASK          255.255.255.0
+#define CONFIG_IPADDR          10.0.0.110
+#define CONFIG_SERVERIP                10.0.0.1
+/*#define CONFIG_BOOTFILE      "elinos-lart" */
+/*#define CONFIG_BOOTCOMMAND   "tftp; bootm" */
+
+#if (CONFIG_COMMANDS & CFG_CMD_KGDB)
+#define CONFIG_KGDB_BAUDRATE   115200          /* speed to run kgdb serial port */
+/* what's this ? it's not used anywhere */
+#define CONFIG_KGDB_SER_INDEX  1               /* which serial port to use */
+#endif
+
+/*
+ * Miscellaneous configurable options
+ */
+#define        CFG_LONGHELP                            /* undef to save memory         */
+#define        CFG_PROMPT              "SMDK2410 # "   /* Monitor Command Prompt       */
+#define        CFG_CBSIZE              256             /* Console I/O Buffer Size      */
+#define        CFG_PBSIZE (CFG_CBSIZE+sizeof(CFG_PROMPT)+16) /* Print Buffer Size */
+#define        CFG_MAXARGS             16              /* max number of command args   */
+#define CFG_BARGSIZE           CFG_CBSIZE      /* Boot Argument Buffer Size    */
+
+#define CFG_MEMTEST_START      0x30000000      /* memtest works on     */
+#define CFG_MEMTEST_END                0x33F00000      /* 63 MB in DRAM        */
+
+#undef  CFG_CLKS_IN_HZ         /* everything, incl board info, in Hz */
+
+#define        CFG_LOAD_ADDR           0x33000000      /* default load address */
+
+/* the PWM TImer 4 uses a counter of 15625 for 10 ms, so we need */
+/* it to wrap 100 times (total 1562500) to get 1 sec. */
+#define        CFG_HZ                  1562500
+
+/* valid baudrates */
+#define CFG_BAUDRATE_TABLE     { 9600, 19200, 38400, 57600, 115200 }
+
+/*-----------------------------------------------------------------------
+ * Stack sizes
+ *
+ * The stack sizes are set up in start.S using the settings below
+ */
+#define CONFIG_STACKSIZE       (128*1024)      /* regular stack */
+#ifdef CONFIG_USE_IRQ
+#define CONFIG_STACKSIZE_IRQ   (4*1024)        /* IRQ stack */
+#define CONFIG_STACKSIZE_FIQ   (4*1024)        /* FIQ stack */
+#endif
+
+/*-----------------------------------------------------------------------
+ * Physical Memory Map
+ */
+#define CONFIG_NR_DRAM_BANKS   1          /* we have 1 bank of DRAM */
+#define PHYS_SDRAM_1           0x30000000 /* SDRAM Bank #1 */
+#define PHYS_SDRAM_1_SIZE      0x04000000 /* 64 MB */
+
+#define PHYS_FLASH_1           0x00000000 /* Flash Bank #1 */
+
+#define CFG_FLASH_BASE         PHYS_FLASH_1
+
+/*-----------------------------------------------------------------------
+ * FLASH and environment organization
+ */
+
+#define CONFIG_AMD_LV400       1       /* uncomment this if you have a LV400 flash */
+#if 0
+#define CONFIG_AMD_LV800       1       /* uncomment this if you have a LV800 flash */
+#endif
+
+#define CFG_MAX_FLASH_BANKS    1       /* max number of memory banks */
+#ifdef CONFIG_AMD_LV800
+#define PHYS_FLASH_SIZE                0x00100000 /* 1MB */
+#define CFG_MAX_FLASH_SECT     (19)    /* max number of sectors on one chip */
+#define CFG_ENV_ADDR           (CFG_FLASH_BASE + 0x0F0000) /* addr of environment */
+#endif
+#ifdef CONFIG_AMD_LV400
+#define PHYS_FLASH_SIZE                0x00080000 /* 512KB */
+#define CFG_MAX_FLASH_SECT     (11)    /* max number of sectors on one chip */
+#define CFG_ENV_ADDR           (CFG_FLASH_BASE + 0x070000) /* addr of environment */
+#endif
+
+/* timeout values are in ticks */
+#define CFG_FLASH_ERASE_TOUT   (5*CFG_HZ) /* Timeout for Flash Erase */
+#define CFG_FLASH_WRITE_TOUT   (5*CFG_HZ) /* Timeout for Flash Write */
+
+#define        CFG_ENV_IS_IN_FLASH     1
+#define CFG_ENV_SIZE           0x10000 /* Total Size of Environment Sector */
+
+#endif /* __CONFIG_H */