arch/cris/arch-v10/drivers/eeprom.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*!*****************************************************************************
   3 *!
   4 *!  Implements an interface for i2c compatible eeproms to run under Linux.
   5 *!  Supports 2k, 8k(?) and 16k. Uses adaptive timing adjustments by
   6 *!  Johan.Adolfsson@axis.com
   7 *!
   8 *!  Probing results:
   9 *!    8k or not is detected (the assumes 2k or 16k)
  10 *!    2k or 16k detected using test reads and writes.
  11 *!
  12 *!------------------------------------------------------------------------
  13 *!  HISTORY
  14 *!
  15 *!  DATE          NAME              CHANGES
  16 *!  ----          ----              -------
  17 *!  Aug  28 1999  Edgar Iglesias    Initial Version
  18 *!  Aug  31 1999  Edgar Iglesias    Allow simultaneous users.
  19 *!  Sep  03 1999  Edgar Iglesias    Updated probe.
  20 *!  Sep  03 1999  Edgar Iglesias    Added bail-out stuff if we get interrupted
  21 *!                                  in the spin-lock.
  22 *!
  23 *!        (c) 1999 Axis Communications AB, Lund, Sweden
  24 *!*****************************************************************************/
  25
  26 #include <linux/kernel.h>
  27 #include <linux/sched.h>
  28 #include <linux/fs.h>
  29 #include <linux/init.h>
  30 #include <linux/delay.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/wait.h>
  33 #include <linux/uaccess.h>
  34 #include "i2c.h"
  35
  36 #define D(x)
  37
  38 /* If we should use adaptive timing or not: */
  39 /* #define EEPROM_ADAPTIVE_TIMING */
  40
  41 #define EEPROM_MAJOR_NR 122  /* use a LOCAL/EXPERIMENTAL major for now */
  42 #define EEPROM_MINOR_NR 0
  43
  44 /* Empirical sane initial value of the delay, the value will be adapted to
  45  * what the chip needs when using EEPROM_ADAPTIVE_TIMING.
  46  */
  47 #define INITIAL_WRITEDELAY_US 4000
  48 #define MAX_WRITEDELAY_US 10000 /* 10 ms according to spec for 2KB EEPROM */
  49
  50 /* This one defines how many times to try when eeprom fails. */
  51 #define EEPROM_RETRIES 10
  52
  53 #define EEPROM_2KB (2 * 1024)
  54 /*#define EEPROM_4KB (4 * 1024)*/ /* Exists but not used in Axis products */
  55 #define EEPROM_8KB (8 * 1024 - 1 ) /* Last byte has write protection bit */
  56 #define EEPROM_16KB (16 * 1024)
  57
  58 #define i2c_delay(x) udelay(x)
  59
  60 /*
  61  *  This structure describes the attached eeprom chip.
  62  *  The values are probed for.
  63  */
  64
  65 struct eeprom_type
  66 {
  67   unsigned long size;
  68   unsigned long sequential_write_pagesize;
  69   unsigned char select_cmd;
  70   unsigned long usec_delay_writecycles; /* Min time between write cycles
  71                                            (up to 10ms for some models) */
  72   unsigned long usec_delay_step; /* For adaptive algorithm */
  73   int adapt_state; /* 1 = To high , 0 = Even, -1 = To low */
  74
  75   /* this one is to keep the read/write operations atomic */
  76   struct mutex lock;
  77   int retry_cnt_addr; /* Used to keep track of number of retries for
  78                          adaptive timing adjustments */
  79   int retry_cnt_read;
  80 };
  81
  82 static int  eeprom_open(struct inode * inode, struct file * file);
  83 static loff_t  eeprom_lseek(struct file * file, loff_t offset, int orig);
  84 static ssize_t  eeprom_read(struct file * file, char * buf, size_t count,
  85                             loff_t *off);
  86 static ssize_t  eeprom_write(struct file * file, const char * buf, size_t count,
  87                              loff_t *off);
  88 static int eeprom_close(struct inode * inode, struct file * file);
  89
  90 static int  eeprom_address(unsigned long addr);
  91 static int  read_from_eeprom(char * buf, int count);
  92 static int eeprom_write_buf(loff_t addr, const char * buf, int count);
  93 static int eeprom_read_buf(loff_t addr, char * buf, int count);
  94
  95 static void eeprom_disable_write_protect(void);
  96
  97
  98 static const char eeprom_name[] = "eeprom";
  99
 100 /* chip description */
 101 static struct eeprom_type eeprom;
 102
 103 /* This is the exported file-operations structure for this device. */
 104 const struct file_operations eeprom_fops =
 105 {
 106   .llseek  = eeprom_lseek,
 107   .read    = eeprom_read,
 108   .write   = eeprom_write,
 109   .open    = eeprom_open,
 110   .release = eeprom_close
 111 };
 112
 113 /* eeprom init call. Probes for different eeprom models. */
 114
 115 int __init eeprom_init(void)
 116 {
 117   mutex_init(&eeprom.lock);
 118
 119 #ifdef CONFIG_ETRAX_I2C_EEPROM_PROBE
 120 #define EETEXT "Found"
 121 #else
 122 #define EETEXT "Assuming"
 123 #endif
 124   if (register_chrdev(EEPROM_MAJOR_NR, eeprom_name, &eeprom_fops))
 125   {
 126     printk(KERN_INFO "%s: unable to get major %d for eeprom device\n",
 127            eeprom_name, EEPROM_MAJOR_NR);
 128     return -1;
 129   }
 130
 131   printk("EEPROM char device v0.3, (c) 2000 Axis Communications AB\n");
 132
 133   /*
 134    *  Note: Most of this probing method was taken from the printserver (5470e)
 135    *        codebase. It did not contain a way of finding the 16kB chips
 136    *        (M24128 or variants). The method used here might not work
 137    *        for all models. If you encounter problems the easiest way
 138    *        is probably to define your model within #ifdef's, and hard-
 139    *        code it.
 140    */
 141
 142   eeprom.size = 0;
 143   eeprom.usec_delay_writecycles = INITIAL_WRITEDELAY_US;
 144   eeprom.usec_delay_step = 128;
 145   eeprom.adapt_state = 0;
 146
 147 #ifdef CONFIG_ETRAX_I2C_EEPROM_PROBE
 148   i2c_start();
 149   i2c_outbyte(0x80);
 150   if(!i2c_getack())
 151   {
 152     /* It's not 8k.. */
 153     int success = 0;
 154     unsigned char buf_2k_start[16];
 155
 156     /* Im not sure this will work... :) */
 157     /* assume 2kB, if failure go for 16kB */
 158     /* Test with 16kB settings.. */
 159     /* If it's a 2kB EEPROM and we address it outside it's range
 160      * it will mirror the address space:
 161      * 1. We read two locations (that are mirrored),
 162      *    if the content differs * it's a 16kB EEPROM.
 163      * 2. if it doesn't differ - write different value to one of the locations,
 164      *    check the other - if content still is the same it's a 2k EEPROM,
 165      *    restore original data.
 166      */
 167 #define LOC1 8
 168 #define LOC2 (0x1fb) /*1fb, 3ed, 5df, 7d1 */
 169
 170    /* 2k settings */
 171     i2c_stop();
 172     eeprom.size = EEPROM_2KB;
 173     eeprom.select_cmd = 0xA0;
 174     eeprom.sequential_write_pagesize = 16;
 175     if( eeprom_read_buf( 0, buf_2k_start, 16 ) == 16 )
 176     {
 177       D(printk("2k start: '%16.16s'\n", buf_2k_start));
 178     }
 179     else
 180     {
 181       printk(KERN_INFO "%s: Failed to read in 2k mode!\n", eeprom_name);
 182     }
 183
 184     /* 16k settings */
 185     eeprom.size = EEPROM_16KB;
 186     eeprom.select_cmd = 0xA0;
 187     eeprom.sequential_write_pagesize = 64;
 188
 189     {
 190       unsigned char loc1[4], loc2[4], tmp[4];
 191       if( eeprom_read_buf(LOC2, loc2, 4) == 4)
 192       {
 193         if( eeprom_read_buf(LOC1, loc1, 4) == 4)
 194         {
 195           D(printk("0 loc1: (%i) '%4.4s' loc2 (%i) '%4.4s'\n",
 196                    LOC1, loc1, LOC2, loc2));
 197 #if 0
 198           if (memcmp(loc1, loc2, 4) != 0 )
 199           {
 200             /* It's 16k */
 201             printk(KERN_INFO "%s: 16k detected in step 1\n", eeprom_name);
 202             eeprom.size = EEPROM_16KB;
 203             success = 1;
 204           }
 205           else
 206 #endif
 207           {
 208             /* Do step 2 check */
 209             /* Invert value */
 210             loc1[0] = ~loc1[0];
 211             if (eeprom_write_buf(LOC1, loc1, 1) == 1)
 212             {
 213               /* If 2k EEPROM this write will actually write 10 bytes
 214                * from pos 0
 215                */
 216               D(printk("1 loc1: (%i) '%4.4s' loc2 (%i) '%4.4s'\n",
 217                        LOC1, loc1, LOC2, loc2));
 218               if( eeprom_read_buf(LOC1, tmp, 4) == 4)
 219               {
 220                 D(printk("2 loc1: (%i) '%4.4s' tmp '%4.4s'\n",
 221                          LOC1, loc1, tmp));
 222                 if (memcmp(loc1, tmp, 4) != 0 )
 223                 {
 224                   printk(KERN_INFO "%s: read and write differs! Not 16kB\n",
 225                          eeprom_name);
 226                   loc1[0] = ~loc1[0];
 227
 228                   if (eeprom_write_buf(LOC1, loc1, 1) == 1)
 229                   {
 230                     success = 1;
 231                   }
 232                   else
 233                   {
 234                     printk(KERN_INFO "%s: Restore 2k failed during probe,"
 235                            " EEPROM might be corrupt!\n", eeprom_name);
 236
 237                   }
 238                   i2c_stop();
 239                   /* Go to 2k mode and write original data */
 240                   eeprom.size = EEPROM_2KB;
 241                   eeprom.select_cmd = 0xA0;
 242                   eeprom.sequential_write_pagesize = 16;
 243                   if( eeprom_write_buf(0, buf_2k_start, 16) == 16)
 244                   {
 245                   }
 246                   else
 247                   {
 248                     printk(KERN_INFO "%s: Failed to write back 2k start!\n",
 249                            eeprom_name);
 250                   }
 251
 252                   eeprom.size = EEPROM_2KB;
 253                 }
 254               }
 255
 256               if(!success)
 257               {
 258                 if( eeprom_read_buf(LOC2, loc2, 1) == 1)
 259                 {
 260                   D(printk("0 loc1: (%i) '%4.4s' loc2 (%i) '%4.4s'\n",
 261                            LOC1, loc1, LOC2, loc2));
 262                   if (memcmp(loc1, loc2, 4) == 0 )
 263                   {
 264                     /* Data the same, must be mirrored -> 2k */
 265                     /* Restore data */
 266                     printk(KERN_INFO "%s: 2k detected in step 2\n", eeprom_name);
 267                     loc1[0] = ~loc1[0];
 268                     if (eeprom_write_buf(LOC1, loc1, 1) == 1)
 269                     {
 270                       success = 1;
 271                     }
 272                     else
 273                     {
 274                       printk(KERN_INFO "%s: Restore 2k failed during probe,"
 275                              " EEPROM might be corrupt!\n", eeprom_name);
 276
 277                     }
 278
 279                     eeprom.size = EEPROM_2KB;
 280                   }
 281                   else
 282                   {
 283                     printk(KERN_INFO "%s: 16k detected in step 2\n",
 284                            eeprom_name);
 285                     loc1[0] = ~loc1[0];
 286                     /* Data differs, assume 16k */
 287                     /* Restore data */
 288                     if (eeprom_write_buf(LOC1, loc1, 1) == 1)
 289                     {
 290                       success = 1;
 291                     }
 292                     else
 293                     {
 294                       printk(KERN_INFO "%s: Restore 16k failed during probe,"
 295                              " EEPROM might be corrupt!\n", eeprom_name);
 296                     }
 297
 298                     eeprom.size = EEPROM_16KB;
 299                   }
 300                 }
 301               }
 302             }
 303           } /* read LOC1 */
 304         } /* address LOC1 */
 305         if (!success)
 306         {
 307           printk(KERN_INFO "%s: Probing failed!, using 2KB!\n", eeprom_name);
 308           eeprom.size = EEPROM_2KB;
 309         }
 310       } /* read */
 311     }
 312   }
 313   else
 314   {
 315     i2c_outbyte(0x00);
 316     if(!i2c_getack())
 317     {
 318       /* No 8k */
 319       eeprom.size = EEPROM_2KB;
 320     }
 321     else
 322     {
 323       i2c_start();
 324       i2c_outbyte(0x81);
 325       if (!i2c_getack())
 326       {
 327         eeprom.size = EEPROM_2KB;
 328       }
 329       else
 330       {
 331         /* It's a 8kB */
 332         i2c_inbyte();
 333         eeprom.size = EEPROM_8KB;
 334       }
 335     }
 336   }
 337   i2c_stop();
 338 #elif defined(CONFIG_ETRAX_I2C_EEPROM_16KB)
 339   eeprom.size = EEPROM_16KB;
 340 #elif defined(CONFIG_ETRAX_I2C_EEPROM_8KB)
 341   eeprom.size = EEPROM_8KB;
 342 #elif defined(CONFIG_ETRAX_I2C_EEPROM_2KB)
 343   eeprom.size = EEPROM_2KB;
 344 #endif
 345
 346   switch(eeprom.size)
 347   {
 348    case (EEPROM_2KB):
 349      printk("%s: " EETEXT " i2c compatible 2kB eeprom.\n", eeprom_name);
 350      eeprom.sequential_write_pagesize = 16;
 351      eeprom.select_cmd = 0xA0;
 352      break;
 353    case (EEPROM_8KB):
 354      printk("%s: " EETEXT " i2c compatible 8kB eeprom.\n", eeprom_name);
 355      eeprom.sequential_write_pagesize = 16;
 356      eeprom.select_cmd = 0x80;
 357      break;
 358    case (EEPROM_16KB):
 359      printk("%s: " EETEXT " i2c compatible 16kB eeprom.\n", eeprom_name);
 360      eeprom.sequential_write_pagesize = 64;
 361      eeprom.select_cmd = 0xA0;
 362      break;
 363    default:
 364      eeprom.size = 0;
 365      printk("%s: Did not find a supported eeprom\n", eeprom_name);
 366      break;
 367   }
 368
 369
 370
 371   eeprom_disable_write_protect();
 372
 373   return 0;
 374 }
 375
 376 /* Opens the device. */
 377 static int eeprom_open(struct inode * inode, struct file * file)
 378 {
 379   if(iminor(inode) != EEPROM_MINOR_NR)
 380      return -ENXIO;
 381   if(imajor(inode) != EEPROM_MAJOR_NR)
 382      return -ENXIO;
 383
 384   if( eeprom.size > 0 )
 385   {
 386     /* OK */
 387     return 0;
 388   }
 389
 390   /* No EEprom found */
 391   return -EFAULT;
 392 }
 393
 394 /* Changes the current file position. */
 395
 396 static loff_t eeprom_lseek(struct file * file, loff_t offset, int orig)
 397 {
 398 /*
 399  *  orig 0: position from beginning of eeprom
 400  *  orig 1: relative from current position
 401  *  orig 2: position from last eeprom address
 402  */
 403
 404   switch (orig)
 405   {
 406    case 0:
 407      file->f_pos = offset;
 408      break;
 409    case 1:
 410      file->f_pos += offset;
 411      break;
 412    case 2:
 413      file->f_pos = eeprom.size - offset;
 414      break;
 415    default:
 416      return -EINVAL;
 417   }
 418
 419   /* truncate position */
 420   if (file->f_pos < 0)
 421   {
 422     file->f_pos = 0;
 423     return(-EOVERFLOW);
 424   }
 425
 426   if (file->f_pos >= eeprom.size)
 427   {
 428     file->f_pos = eeprom.size - 1;
 429     return(-EOVERFLOW);
 430   }
 431
 432   return ( file->f_pos );
 433 }
 434
 435 /* Reads data from eeprom. */
 436
 437 static int eeprom_read_buf(loff_t addr, char * buf, int count)
 438 {
 439   return eeprom_read(NULL, buf, count, &addr);
 440 }
 441
 442
 443
 444 /* Reads data from eeprom. */
 445
 446 static ssize_t eeprom_read(struct file * file, char * buf, size_t count, loff_t *off)
 447 {
 448   int read=0;
 449   unsigned long p = *off;
 450
 451   unsigned char page;
 452
 453   if(p >= eeprom.size)  /* Address i 0 - (size-1) */
 454   {
 455     return -EFAULT;
 456   }
 457
 458   if (mutex_lock_interruptible(&eeprom.lock))
 459     return -EINTR;
 460
 461   page = (unsigned char) (p >> 8);
 462
 463   if(!eeprom_address(p))
 464   {
 465     printk(KERN_INFO "%s: Read failed to address the eeprom: "
 466            "0x%08X (%i) page: %i\n", eeprom_name, (int)p, (int)p, page);
 467     i2c_stop();
 468
 469     /* don't forget to wake them up */
 470     mutex_unlock(&eeprom.lock);
 471     return -EFAULT;
 472   }
 473
 474   if( (p + count) > eeprom.size)
 475   {
 476     /* truncate count */
 477     count = eeprom.size - p;
 478   }
 479
 480   /* stop dummy write op and initiate the read op */
 481   i2c_start();
 482
 483   /* special case for small eeproms */
 484   if(eeprom.size < EEPROM_16KB)
 485   {
 486     i2c_outbyte( eeprom.select_cmd | 1 | (page << 1) );
 487   }
 488
 489   /* go on with the actual read */
 490   read = read_from_eeprom( buf, count);
 491
 492   if(read > 0)
 493   {
 494     *off += read;
 495   }
 496
 497   mutex_unlock(&eeprom.lock);
 498   return read;
 499 }
 500
 501 /* Writes data to eeprom. */
 502
 503 static int eeprom_write_buf(loff_t addr, const char * buf, int count)
 504 {
 505   return eeprom_write(NULL, buf, count, &addr);
 506 }
 507
 508
 509 /* Writes data to eeprom. */
 510
 511 static ssize_t eeprom_write(struct file * file, const char * buf, size_t count,
 512                             loff_t *off)
 513 {
 514   int i, written, restart=1;
 515   unsigned long p;
 516
 517   if (!access_ok(VERIFY_READ, buf, count))
 518   {
 519     return -EFAULT;
 520   }
 521
 522   /* bail out if we get interrupted */
 523   if (mutex_lock_interruptible(&eeprom.lock))
 524     return -EINTR;
 525   for(i = 0; (i < EEPROM_RETRIES) && (restart > 0); i++)
 526   {
 527     restart = 0;
 528     written = 0;
 529     p = *off;
 530
 531
 532     while( (written < count) && (p < eeprom.size))
 533     {
 534       /* address the eeprom */
 535       if(!eeprom_address(p))
 536       {
 537         printk(KERN_INFO "%s: Write failed to address the eeprom: "
 538                "0x%08X (%i) \n", eeprom_name, (int)p, (int)p);
 539         i2c_stop();
 540
 541         /* don't forget to wake them up */
 542         mutex_unlock(&eeprom.lock);
 543         return -EFAULT;
 544       }
 545 #ifdef EEPROM_ADAPTIVE_TIMING
 546       /* Adaptive algorithm to adjust timing */
 547       if (eeprom.retry_cnt_addr > 0)
 548       {
 549         /* To Low now */
 550         D(printk(">D=%i d=%i\n",
 551                eeprom.usec_delay_writecycles, eeprom.usec_delay_step));
 552
 553         if (eeprom.usec_delay_step < 4)
 554         {
 555           eeprom.usec_delay_step++;
 556           eeprom.usec_delay_writecycles += eeprom.usec_delay_step;
 557         }
 558         else
 559         {
 560
 561           if (eeprom.adapt_state > 0)
 562           {
 563             /* To Low before */
 564             eeprom.usec_delay_step *= 2;
 565             if (eeprom.usec_delay_step > 2)
 566             {
 567               eeprom.usec_delay_step--;
 568             }
 569             eeprom.usec_delay_writecycles += eeprom.usec_delay_step;
 570           }
 571           else if (eeprom.adapt_state < 0)
 572           {
 573             /* To High before (toggle dir) */
 574             eeprom.usec_delay_writecycles += eeprom.usec_delay_step;
 575             if (eeprom.usec_delay_step > 1)
 576             {
 577               eeprom.usec_delay_step /= 2;
 578               eeprom.usec_delay_step--;
 579             }
 580           }
 581         }
 582
 583         eeprom.adapt_state = 1;
 584       }
 585       else
 586       {
 587         /* To High (or good) now */
 588         D(printk("<D=%i d=%i\n",
 589                eeprom.usec_delay_writecycles, eeprom.usec_delay_step));
 590
 591         if (eeprom.adapt_state < 0)
 592         {
 593           /* To High before */
 594           if (eeprom.usec_delay_step > 1)
 595           {
 596             eeprom.usec_delay_step *= 2;
 597             eeprom.usec_delay_step--;
 598
 599             if (eeprom.usec_delay_writecycles > eeprom.usec_delay_step)
 600             {
 601               eeprom.usec_delay_writecycles -= eeprom.usec_delay_step;
 602             }
 603           }
 604         }
 605         else if (eeprom.adapt_state > 0)
 606         {
 607           /* To Low before (toggle dir) */
 608           if (eeprom.usec_delay_writecycles > eeprom.usec_delay_step)
 609           {
 610             eeprom.usec_delay_writecycles -= eeprom.usec_delay_step;
 611           }
 612           if (eeprom.usec_delay_step > 1)
 613           {
 614             eeprom.usec_delay_step /= 2;
 615             eeprom.usec_delay_step--;
 616           }
 617
 618           eeprom.adapt_state = -1;
 619         }
 620
 621         if (eeprom.adapt_state > -100)
 622         {
 623           eeprom.adapt_state--;
 624         }
 625         else
 626         {
 627           /* Restart adaption */
 628           D(printk("#Restart\n"));
 629           eeprom.usec_delay_step++;
 630         }
 631       }
 632 #endif /* EEPROM_ADAPTIVE_TIMING */
 633       /* write until we hit a page boundary or count */
 634       do
 635       {
 636         i2c_outbyte(buf[written]);
 637         if(!i2c_getack())
 638         {
 639           restart=1;
 640           printk(KERN_INFO "%s: write error, retrying. %d\n", eeprom_name, i);
 641           i2c_stop();
 642           break;
 643         }
 644         written++;
 645         p++;
 646       } while( written < count && ( p % eeprom.sequential_write_pagesize ));
 647
 648       /* end write cycle */
 649       i2c_stop();
 650       i2c_delay(eeprom.usec_delay_writecycles);
 651     } /* while */
 652   } /* for  */
 653
 654   mutex_unlock(&eeprom.lock);
 655   if (written == 0 && p >= eeprom.size){
 656     return -ENOSPC;
 657   }
 658   *off = p;
 659   return written;
 660 }
 661
 662 /* Closes the device. */
 663
 664 static int eeprom_close(struct inode * inode, struct file * file)
 665 {
 666   /* do nothing for now */
 667   return 0;
 668 }
 669
 670 /* Sets the current address of the eeprom. */
 671
 672 static int eeprom_address(unsigned long addr)
 673 {
 674   int i;
 675   unsigned char page, offset;
 676
 677   page   = (unsigned char) (addr >> 8);
 678   offset = (unsigned char)  addr;
 679
 680   for(i = 0; i < EEPROM_RETRIES; i++)
 681   {
 682     /* start a dummy write for addressing */
 683     i2c_start();
 684
 685     if(eeprom.size == EEPROM_16KB)
 686     {
 687       i2c_outbyte( eeprom.select_cmd );
 688       i2c_getack();
 689       i2c_outbyte(page);
 690     }
 691     else
 692     {
 693       i2c_outbyte( eeprom.select_cmd | (page << 1) );
 694     }
 695     if(!i2c_getack())
 696     {
 697       /* retry */
 698       i2c_stop();
 699       /* Must have a delay here.. 500 works, >50, 100->works 5th time*/
 700       i2c_delay(MAX_WRITEDELAY_US / EEPROM_RETRIES * i);
 701       /* The chip needs up to 10 ms from write stop to next start */
 702
 703     }
 704     else
 705     {
 706       i2c_outbyte(offset);
 707
 708       if(!i2c_getack())
 709       {
 710         /* retry */
 711         i2c_stop();
 712       }
 713       else
 714         break;
 715     }
 716   }
 717
 718
 719   eeprom.retry_cnt_addr = i;
 720   D(printk("%i\n", eeprom.retry_cnt_addr));
 721   if(eeprom.retry_cnt_addr == EEPROM_RETRIES)
 722   {
 723     /* failed */
 724     return 0;
 725   }
 726   return 1;
 727 }
 728
 729 /* Reads from current address. */
 730
 731 static int read_from_eeprom(char * buf, int count)
 732 {
 733   int i, read=0;
 734
 735   for(i = 0; i < EEPROM_RETRIES; i++)
 736   {
 737     if(eeprom.size == EEPROM_16KB)
 738     {
 739       i2c_outbyte( eeprom.select_cmd | 1 );
 740     }
 741
 742     if(i2c_getack())
 743     {
 744       break;
 745     }
 746   }
 747
 748   if(i == EEPROM_RETRIES)
 749   {
 750     printk(KERN_INFO "%s: failed to read from eeprom\n", eeprom_name);
 751     i2c_stop();
 752
 753     return -EFAULT;
 754   }
 755
 756   while( (read < count))
 757   {
 758     if (put_user(i2c_inbyte(), &buf[read++]))
 759     {
 760       i2c_stop();
 761
 762       return -EFAULT;
 763     }
 764
 765     /*
 766      *  make sure we don't ack last byte or you will get very strange
 767      *  results!
 768      */
 769     if(read < count)
 770     {
 771       i2c_sendack();
 772     }
 773   }
 774
 775   /* stop the operation */
 776   i2c_stop();
 777
 778   return read;
 779 }
 780
 781 /* Disables write protection if applicable. */
 782
 783 #define DBP_SAVE(x)
 784 #define ax_printf printk
 785 static void eeprom_disable_write_protect(void)
 786 {
 787   /* Disable write protect */
 788   if (eeprom.size == EEPROM_8KB)
 789   {
 790     /* Step 1 Set WEL = 1 (write 00000010 to address 1FFFh */
 791     i2c_start();
 792     i2c_outbyte(0xbe);
 793     if(!i2c_getack())
 794     {
 795       DBP_SAVE(ax_printf("Get ack returns false\n"));
 796     }
 797     i2c_outbyte(0xFF);
 798     if(!i2c_getack())
 799     {
 800       DBP_SAVE(ax_printf("Get ack returns false 2\n"));
 801     }
 802     i2c_outbyte(0x02);
 803     if(!i2c_getack())
 804     {
 805       DBP_SAVE(ax_printf("Get ack returns false 3\n"));
 806     }
 807     i2c_stop();
 808
 809     i2c_delay(1000);
 810
 811     /* Step 2 Set RWEL = 1 (write 00000110 to address 1FFFh */
 812     i2c_start();
 813     i2c_outbyte(0xbe);
 814     if(!i2c_getack())
 815     {
 816       DBP_SAVE(ax_printf("Get ack returns false 55\n"));
 817     }
 818     i2c_outbyte(0xFF);
 819     if(!i2c_getack())
 820     {
 821       DBP_SAVE(ax_printf("Get ack returns false 52\n"));
 822     }
 823     i2c_outbyte(0x06);
 824     if(!i2c_getack())
 825     {
 826       DBP_SAVE(ax_printf("Get ack returns false 53\n"));
 827     }
 828     i2c_stop();
 829
 830     /* Step 3 Set BP1, BP0, and/or WPEN bits (write 00000110 to address 1FFFh */
 831     i2c_start();
 832     i2c_outbyte(0xbe);
 833     if(!i2c_getack())
 834     {
 835       DBP_SAVE(ax_printf("Get ack returns false 56\n"));
 836     }
 837     i2c_outbyte(0xFF);
 838     if(!i2c_getack())
 839     {
 840       DBP_SAVE(ax_printf("Get ack returns false 57\n"));
 841     }
 842     i2c_outbyte(0x06);
 843     if(!i2c_getack())
 844     {
 845       DBP_SAVE(ax_printf("Get ack returns false 58\n"));
 846     }
 847     i2c_stop();
 848
 849     /* Write protect disabled */
 850   }
 851 }
 852 device_initcall(eeprom_init);