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

This page was automatically generated by LXR 0.3.1.  •  Linux is a registered trademark of Linus Torvalds