316ca15d6802c4bbfb26752f62e4fe9e79c0015f
[linux-2.6.git] / 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.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
129 struct 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
147 static int  eeprom_open(struct inode * inode, struct file * file);
148 static loff_t  eeprom_lseek(struct file * file, loff_t offset, int orig);
149 static ssize_t  eeprom_read(struct file * file, char * buf, size_t count,
150                             loff_t *off);
151 static ssize_t  eeprom_write(struct file * file, const char * buf, size_t count,
152                              loff_t *off);
153 static int eeprom_close(struct inode * inode, struct file * file);
154
155 static int  eeprom_address(unsigned long addr);
156 static int  read_from_eeprom(char * buf, int count);
157 static int eeprom_write_buf(loff_t addr, const char * buf, int count);
158 static int eeprom_read_buf(loff_t addr, char * buf, int count);
159
160 static void eeprom_disable_write_protect(void);
161
162
163 static const char eeprom_name[] = "eeprom";
164
165 /* chip description */
166 static struct eeprom_type eeprom;
167
168 /* This is the exported file-operations structure for this device. */
169 struct 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
180 int __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
444 static 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
464 static 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
505 static 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
517 static 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
584 static 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
596 static 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
756 static 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
764 static 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
823 static 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
877 static 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
945 module_init(eeprom_init);