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