git.sur5r.net Git - u-boot/blob - board/xilinx/xilinx_iic/iic_adapter.c

   1 /******************************************************************************
   2 *
   3 *     Author: Xilinx, Inc.
   4 *
   5 *
   6 *     This program is free software; you can redistribute it and/or modify it
   7 *     under the terms of the GNU General Public License as published by the
   8 *     Free Software Foundation; either version 2 of the License, or (at your
   9 *     option) any later version.
  10 *
  11 *
  12 *     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
  13 *     COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
  14 *     ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD,
  15 *     XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE
  16 *     FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING
  17 *     ANY THIRD PARTY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
  18 *     XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
  19 *     THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY
  20 *     WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM
  21 *     CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND
  22 *     FITNESS FOR A PARTICULAR PURPOSE.
  23 *
  24 *
  25 *     Xilinx hardware products are not intended for use in life support
  26 *     appliances, devices, or systems. Use in such applications is
  27 *     expressly prohibited.
  28 *
  29 *
  30 *     (c) Copyright 2002-2004 Xilinx Inc.
  31 *     All rights reserved.
  32 *
  33 *
  34 *     You should have received a copy of the GNU General Public License along
  35 *     with this program; if not, write to the Free Software Foundation, Inc.,
  36 *     675 Mass Ave, Cambridge, MA 02139, USA.
  37 *
  38 ******************************************************************************/
  39
  40 #include <common.h>
  41 #include <environment.h>
  42 #include <net.h>
  43 #include "xparameters.h"
  44
  45 #ifdef CFG_ENV_IS_IN_EEPROM
  46 #include <i2c.h>
  47 #include "xiic_l.h"
  48
  49 #define IIC_DELAY     5000
  50
  51 static u8 envStep = 0;          /* 0 means crc has not been read */
  52 const u8 hex[] = "0123456789ABCDEF"; /* lookup table for ML300 CRC */
  53
  54 /************************************************************************
  55  * Use Xilinx provided driver to send data to EEPROM using iic bus.
  56  */
  57 static void
  58 send(u32 adr, u8 * data, u32 len)
  59 {
  60         u8 sendBuf[34];         /* first 2-bit is address and others are data */
  61         u32 pos, wlen;
  62         u32 ret;
  63
  64         wlen = 32;
  65         for (pos = 0; pos < len; pos += 32) {
  66                 if ((len - pos) < 32)
  67                         wlen = len - pos;
  68
  69                 /* Put address and data bits together */
  70                 sendBuf[0] = (u8) ((adr + pos) >> 8);
  71                 sendBuf[1] = (u8) (adr + pos);
  72                 memcpy(&sendBuf[2], &data[pos], wlen);
  73
  74                 /* Send to EEPROM through iic bus */
  75                 ret = XIic_Send(XPAR_IIC_0_BASEADDR, CFG_I2C_EEPROM_ADDR >> 1,
  76                                 sendBuf, wlen + 2);
  77
  78                 udelay(IIC_DELAY);
  79         }
  80 }
  81
  82 /************************************************************************
  83  * Use Xilinx provided driver to read data from EEPROM using the iic bus.
  84  */
  85 static void
  86 receive(u32 adr, u8 * data, u32 len)
  87 {
  88         u8 address[2];
  89         u32 ret;
  90
  91         address[0] = (u8) (adr >> 8);
  92         address[1] = (u8) adr;
  93
  94         /* Provide EEPROM address */
  95         ret =
  96             XIic_Send(XPAR_IIC_0_BASEADDR, CFG_I2C_EEPROM_ADDR >> 1, address,
  97                       2);
  98         /* Receive data from EEPROM */
  99         ret =
 100             XIic_Recv(XPAR_IIC_0_BASEADDR, CFG_I2C_EEPROM_ADDR >> 1, data, len);
 101 }
 102
 103 /************************************************************************
 104  * Convert a hexadecimal string to its equivalent integer value.
 105  */
 106 static u8
 107 axtoi(u8 * hexStg)
 108 {
 109         u8 n;                   /* position in string */
 110         u8 m;                   /* position in digit[] to shift */
 111         u8 count;               /* loop index */
 112         u8 intValue;            /* integer value of hex string */
 113         u8 digit[2];            /* hold values to convert */
 114
 115         for (n = 0; n < 2; n++) {
 116                 if (hexStg[n] == '\0')
 117                         break;
 118                 if (hexStg[n] > 0x29 && hexStg[n] < 0x40)
 119                         digit[n] = hexStg[n] & 0x0f;
 120                 else if (hexStg[n] >= 'a' && hexStg[n] <= 'f')
 121                         digit[n] = (hexStg[n] & 0x0f) + 9;
 122                 else if (hexStg[n] >= 'A' && hexStg[n] <= 'F')
 123                         digit[n] = (hexStg[n] & 0x0f) + 9;
 124                 else
 125                         break;
 126         }
 127
 128         intValue = 0;
 129         count = n;
 130         m = n - 1;
 131         n = 0;
 132         while (n < count) {
 133                 intValue = intValue | (digit[n] << (m << 2));
 134                 m--;            /* adjust the position to set */
 135                 n++;            /* next digit to process */
 136         }
 137
 138         return (intValue);
 139 }
 140
 141 /************************************************************************
 142  * Convert an integer string to its equivalent value.
 143  */
 144 static u8
 145 atoi(uchar * string)
 146 {
 147         u8 res = 0;
 148         while (*string >= '0' && *string <= '9') {
 149                 res *= 10;
 150                 res += *string - '0';
 151                 string++;
 152         }
 153
 154         return res;
 155 }
 156
 157 /************************************************************************
 158  * Key-value pairs are separated by "=" sign.
 159  */
 160 static void
 161 findKey(uchar * buffer, int *loc, u8 len)
 162 {
 163         u32 i;
 164
 165         for (i = 0; i < len; i++)
 166                 if (buffer[i] == '=') {
 167                         *loc = i;
 168                         return;
 169                 }
 170
 171         /* return -1 is no "=" sign found */
 172         *loc = -1;
 173 }
 174
 175 /************************************************************************
 176  * Compute a new ML300 CRC when user calls the saveenv command.
 177  * Also update EEPROM with new CRC value.
 178  */
 179 static u8
 180 update_crc(u32 len, uchar * data)
 181 {
 182         uchar temp[6] = { 'C', '=', 0x00, 0x00, 0x00, 0x00 };
 183         u32 crc;                /* new crc value */
 184         u32 i;
 185
 186         crc = 0;
 187
 188         /* calculate new CRC */
 189         for (i = 0; i < len; i++)
 190                 crc += data[i];
 191
 192         /* CRC includes key for check sum */
 193         crc += 'C' + '=';
 194
 195         /* compose new CRC to be updated */
 196         temp[2] = hex[(crc >> 4) & 0xf];
 197         temp[3] = hex[crc & 0xf];
 198
 199         /* check to see if env size exceeded */
 200         if (len + 6 > ENV_SIZE) {
 201                 printf("ERROR: not enough space to store CRC on EEPROM");
 202                 return 1;
 203         }
 204
 205         memcpy(data + len, temp, 6);
 206         return 0;
 207 }
 208
 209 /************************************************************************
 210  * Read out ML300 CRC and compare it with a runtime calculated ML300 CRC.
 211  * If equal, then pass back a u-boot CRC value, otherwise pass back
 212  * junk to indicate CRC error.
 213 */
 214 static void
 215 read_crc(uchar * buffer, int len)
 216 {
 217         u32 addr, n;
 218         u32 crc;                /* runtime crc */
 219         u8 old[2] = { 0xff, 0xff };     /* current CRC in EEPROM */
 220         u8 stop;                /* indication of end of env data */
 221         u8 pre;                 /* previous EEPROM data bit */
 222         int i, loc;
 223
 224         addr = CFG_ENV_OFFSET;  /* start from first env address */
 225         n = 0;
 226         pre = 1;
 227         stop = 1;
 228         crc = 0;
 229
 230         /* calculate runtime CRC according to ML300 and read back
 231            old CRC stored in the EEPROM */
 232         while (n < CFG_ENV_SIZE) {
 233                 receive(addr, buffer, len);
 234
 235                 /* found two null chars, end of env */
 236                 if ((pre || buffer[0]) == 0)
 237                         break;
 238
 239                 findKey(buffer, &loc, len);
 240
 241                 /* found old check sum, read and store old CRC */
 242                 if ((loc == 0 && pre == 'C')
 243                     || (loc > 0 && buffer[loc - 1] == 'C'))
 244                         receive(addr + loc + 1, old, 2);
 245
 246                 pre = buffer[len - 1];
 247
 248                 /* calculate runtime ML300 CRC */
 249                 crc += buffer[0];
 250                 i = 1;
 251                 do {
 252                         crc += buffer[i];
 253                         stop = buffer[i] || buffer[i - 1];
 254                         i++;
 255                 } while (stop && (i < len));
 256
 257                 if (stop == 0)
 258                         break;
 259
 260                 n += len;
 261                 addr += len;
 262         }
 263
 264         /* exclude old CRC from runtime calculation */
 265         crc -= (old[0] + old[1]);
 266
 267         /* match CRC values, send back u-boot CRC */
 268         if ((old[0] == hex[(crc >> 4) & 0xf])
 269             && (old[1] == hex[crc & 0xf])) {
 270                 crc = 0;
 271                 n = 0;
 272                 addr =
 273                     CFG_ENV_OFFSET - offsetof(env_t, crc) + offsetof(env_t,
 274                                                                      data);
 275                 /* calculate u-boot crc */
 276                 while (n < ENV_SIZE) {
 277                         receive(addr, buffer, len);
 278                         crc = crc32(crc, buffer, len);
 279                         n += len;
 280                         addr += len;
 281                 }
 282
 283                 memcpy(buffer, &crc, 4);
 284         }
 285 }
 286
 287 /************************************************************************
 288  * Convert IP address to hexadecimals.
 289  */
 290 static void
 291 ip_ml300(uchar * s, uchar * res)
 292 {
 293         char temp[2];
 294         u8 i;
 295
 296         res[0] = 0x00;
 297
 298         for (i = 0; i < 4; i++) {
 299                 sprintf(temp, "%02x", atoi(s));
 300                 s = (uchar *)strchr((char *)s, '.') + 1;
 301                 strcat((char *)res, temp);
 302         }
 303 }
 304
 305 /************************************************************************
 306  * Change 0xff (255), a dummy null char to 0x00.
 307  */
 308 static void
 309 change_null(uchar * s)
 310 {
 311         if (s != NULL) {
 312                 change_null((uchar *)strchr((char *)s + 1, 255));
 313                 *(strchr((char *)s, 255)) = '\0';
 314         }
 315 }
 316
 317 /************************************************************************
 318  * Update environment variable name and values to u-boot standard.
 319  */
 320 void
 321 convert_env(void)
 322 {
 323         char *s;                /* pointer to env value */
 324         char temp[20];          /* temp storage for addresses */
 325
 326         /* E -> ethaddr */
 327         s = getenv("E");
 328         if (s != NULL) {
 329                 sprintf(temp, "%c%c.%c%c.%c%c.%c%c.%c%c.%c%c",
 330                         s[0], s[1],  s[ 2], s[ 3],
 331                         s[4], s[5],  s[ 6], s[ 7],
 332                         s[8], s[9],  s[10], s[11] );
 333                 setenv("ethaddr", temp);
 334                 setenv("E", NULL);
 335         }
 336
 337         /* L -> serial# */
 338         s = getenv("L");
 339         if (s != NULL) {
 340                 setenv("serial#", s);
 341                 setenv("L", NULL);
 342         }
 343
 344         /* I -> ipaddr */
 345         s = getenv("I");
 346         if (s != NULL) {
 347                 sprintf(temp, "%d.%d.%d.%d", axtoi((u8 *)s), axtoi((u8 *)(s + 2)),
 348                         axtoi((u8 *)(s + 4)), axtoi((u8 *)(s + 6)));
 349                 setenv("ipaddr", temp);
 350                 setenv("I", NULL);
 351         }
 352
 353         /* S -> serverip */
 354         s = getenv("S");
 355         if (s != NULL) {
 356                 sprintf(temp, "%d.%d.%d.%d", axtoi((u8 *)s), axtoi((u8 *)(s + 2)),
 357                         axtoi((u8 *)(s + 4)), axtoi((u8 *)(s + 6)));
 358                 setenv("serverip", temp);
 359                 setenv("S", NULL);
 360         }
 361
 362         /* A -> bootargs */
 363         s = getenv("A");
 364         if (s != NULL) {
 365                 setenv("bootargs", s);
 366                 setenv("A", NULL);
 367         }
 368
 369         /* F -> bootfile */
 370         s = getenv("F");
 371         if (s != NULL) {
 372                 setenv("bootfile", s);
 373                 setenv("F", NULL);
 374         }
 375
 376         /* M -> bootcmd */
 377         s = getenv("M");
 378         if (s != NULL) {
 379                 setenv("bootcmd", s);
 380                 setenv("M", NULL);
 381         }
 382
 383         /* Don't include C (CRC) */
 384         setenv("C", NULL);
 385 }
 386
 387 /************************************************************************
 388  * Save user modified environment values back to EEPROM.
 389  */
 390 static void
 391 save_env(void)
 392 {
 393         char eprom[ENV_SIZE];   /* buffer to be written back to EEPROM */
 394         char *s, temp[20];
 395         char ff[] = { 0xff, 0x00 };     /* dummy null value */
 396         u32 len;                /* length of env to be written to EEPROM */
 397
 398         eprom[0] = 0x00;
 399
 400         /* ethaddr -> E */
 401         s = getenv("ethaddr");
 402         if (s != NULL) {
 403                 strcat(eprom, "E=");
 404                 sprintf(temp, "%c%c%c%c%c%c%c%c%c%c%c%c",
 405                         *s, *(s + 1), *(s + 3), *(s + 4), *(s + 6), *(s + 7),
 406                         *(s + 9), *(s + 10), *(s + 12), *(s + 13), *(s + 15),
 407                         *(s + 16));
 408                 strcat(eprom, temp);
 409                 strcat(eprom, ff);
 410         }
 411
 412         /* serial# -> L */
 413         s = getenv("serial#");
 414         if (s != NULL) {
 415                 strcat(eprom, "L=");
 416                 strcat(eprom, s);
 417                 strcat(eprom, ff);
 418         }
 419
 420         /* ipaddr -> I */
 421         s = getenv("ipaddr");
 422         if (s != NULL) {
 423                 strcat(eprom, "I=");
 424                 ip_ml300((uchar *)s, (uchar *)temp);
 425                 strcat(eprom, temp);
 426                 strcat(eprom, ff);
 427         }
 428
 429         /* serverip -> S */
 430         s = getenv("serverip");
 431         if (s != NULL) {
 432                 strcat(eprom, "S=");
 433                 ip_ml300((uchar *)s, (uchar *)temp);
 434                 strcat(eprom, temp);
 435                 strcat(eprom, ff);
 436         }
 437
 438         /* bootargs -> A */
 439         s = getenv("bootargs");
 440         if (s != NULL) {
 441                 strcat(eprom, "A=");
 442                 strcat(eprom, s);
 443                 strcat(eprom, ff);
 444         }
 445
 446         /* bootfile -> F */
 447         s = getenv("bootfile");
 448         if (s != NULL) {
 449                 strcat(eprom, "F=");
 450                 strcat(eprom, s);
 451                 strcat(eprom, ff);
 452         }
 453
 454         /* bootcmd -> M */
 455         s = getenv("bootcmd");
 456         if (s != NULL) {
 457                 strcat(eprom, "M=");
 458                 strcat(eprom, s);
 459                 strcat(eprom, ff);
 460         }
 461
 462         len = strlen(eprom);    /* find env length without crc */
 463         change_null((uchar *)eprom);    /* change 0xff to 0x00 */
 464
 465         /* update EEPROM env values if there is enough space */
 466         if (update_crc(len, (uchar *)eprom) == 0)
 467                 send(CFG_ENV_OFFSET, (uchar *)eprom, len + 6);
 468 }
 469
 470 /************************************************************************
 471  * U-boot call for EEPROM read associated activities.
 472  */
 473 int
 474 i2c_read(uchar chip, uint addr, int alen, uchar * buffer, int len)
 475 {
 476
 477         if (envStep == 0) {
 478                 /* first read call is for crc */
 479                 read_crc(buffer, len);
 480                 ++envStep;
 481                 return 0;
 482         } else if (envStep == 1) {
 483                 /* then read out EEPROM content for runtime u-boot CRC calculation */
 484                 receive(addr, buffer, len);
 485
 486                 if (addr + len - CFG_ENV_OFFSET == CFG_ENV_SIZE)
 487                         /* end of runtime crc read */
 488                         ++envStep;
 489                 return 0;
 490         }
 491
 492         if (len < 2) {
 493                 /* when call getenv_r */
 494                 receive(addr, buffer, len);
 495         } else if (addr + len < CFG_ENV_OFFSET + CFG_ENV_SIZE) {
 496                 /* calling env_relocate(), but don't read out
 497                    crc value from EEPROM */
 498                 receive(addr, buffer + 4, len);
 499         } else {
 500                 receive(addr, buffer + 4, len - 4);
 501         }
 502
 503         return 0;
 504
 505 }
 506
 507 /************************************************************************
 508  * U-boot call for EEPROM write acativities.
 509  */
 510 int
 511 i2c_write(uchar chip, uint addr, int alen, uchar * buffer, int len)
 512 {
 513         /* save env on last page write called by u-boot */
 514         if (addr + len >= CFG_ENV_OFFSET + CFG_ENV_SIZE)
 515                 save_env();
 516
 517         return 0;
 518 }
 519
 520 /************************************************************************
 521  * Dummy function.
 522  */
 523 int
 524 i2c_probe(uchar chip)
 525 {
 526         return 1;
 527 }
 528
 529 #endif