PageRenderTime 65ms CodeModel.GetById 20ms app.highlight 39ms RepoModel.GetById 1ms app.codeStats 0ms

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

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