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

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