1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
39
40
41#define EEPROM_MAJOR_NR 122
42#define EEPROM_MINOR_NR 0
43
44
45
46
47#define INITIAL_WRITEDELAY_US 4000
48#define MAX_WRITEDELAY_US 10000
49
50
51#define EEPROM_RETRIES 10
52
53#define EEPROM_2KB (2 * 1024)
54
55#define EEPROM_8KB (8 * 1024 - 1 )
56#define EEPROM_16KB (16 * 1024)
57
58#define i2c_delay(x) udelay(x)
59
60
61
62
63
64
65struct eeprom_type
66{
67 unsigned long size;
68 unsigned long sequential_write_pagesize;
69 unsigned char select_cmd;
70 unsigned long usec_delay_writecycles;
71
72 unsigned long usec_delay_step;
73 int adapt_state;
74
75
76 wait_queue_head_t wait_q;
77 volatile int busy;
78 int retry_cnt_addr;
79
80 int retry_cnt_read;
81};
82
83static int eeprom_open(struct inode * inode, struct file * file);
84static loff_t eeprom_lseek(struct file * file, loff_t offset, int orig);
85static ssize_t eeprom_read(struct file * file, char * buf, size_t count,
86 loff_t *off);
87static ssize_t eeprom_write(struct file * file, const char * buf, size_t count,
88 loff_t *off);
89static int eeprom_close(struct inode * inode, struct file * file);
90
91static int eeprom_address(unsigned long addr);
92static int read_from_eeprom(char * buf, int count);
93static int eeprom_write_buf(loff_t addr, const char * buf, int count);
94static int eeprom_read_buf(loff_t addr, char * buf, int count);
95
96static void eeprom_disable_write_protect(void);
97
98
99static const char eeprom_name[] = "eeprom";
100
101
102static struct eeprom_type eeprom;
103
104
105const 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
115
116int __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
137
138
139
140
141
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
155 int success = 0;
156 unsigned char buf_2k_start[16];
157
158
159
160
161
162
163
164
165
166
167
168
169#define LOC1 8
170#define LOC2 (0x1fb)
171
172
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
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
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
211
212 loc1[0] = ~loc1[0];
213 if (eeprom_write_buf(LOC1, loc1, 1) == 1)
214 {
215
216
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
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
267
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
289
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 }
306 }
307 if (!success)
308 {
309 printk(KERN_INFO "%s: Probing failed!, using 2KB!\n", eeprom_name);
310 eeprom.size = EEPROM_2KB;
311 }
312 }
313 }
314 }
315 else
316 {
317 i2c_outbyte(0x00);
318 if(!i2c_getack())
319 {
320
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
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
379static 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
390 return 0;
391 }
392
393
394 return -EFAULT;
395}
396
397
398
399static loff_t eeprom_lseek(struct file * file, loff_t offset, int orig)
400{
401
402
403
404
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
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
439
440static 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
451
452static 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)
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
479 eeprom.busy--;
480 wake_up_interruptible(&eeprom.wait_q);
481 return -EFAULT;
482 }
483
484 if( (p + count) > eeprom.size)
485 {
486
487 count = eeprom.size - p;
488 }
489
490
491 i2c_start();
492
493
494 if(eeprom.size < EEPROM_16KB)
495 {
496 i2c_outbyte( eeprom.select_cmd | 1 | (page << 1) );
497 }
498
499
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
513
514static 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
525
526static 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
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
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
559 eeprom.busy--;
560 wake_up_interruptible(&eeprom.wait_q);
561 return -EFAULT;
562 }
563#ifdef EEPROM_ADAPTIVE_TIMING
564
565 if (eeprom.retry_cnt_addr > 0)
566 {
567
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
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
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
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
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
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
646 D(printk("#Restart\n"));
647 eeprom.usec_delay_step++;
648 }
649 }
650#endif
651
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
667 i2c_stop();
668 i2c_delay(eeprom.usec_delay_writecycles);
669 }
670 }
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
682
683static int eeprom_close(struct inode * inode, struct file * file)
684{
685
686 return 0;
687}
688
689
690
691static 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
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
717 i2c_stop();
718
719 i2c_delay(MAX_WRITEDELAY_US / EEPROM_RETRIES * i);
720
721
722 }
723 else
724 {
725 i2c_outbyte(offset);
726
727 if(!i2c_getack())
728 {
729
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
743 return 0;
744 }
745 return 1;
746}
747
748
749
750static 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
786
787
788 if(read < count)
789 {
790 i2c_sendack();
791 }
792 }
793
794
795 i2c_stop();
796
797 return read;
798}
799
800
801
802#define DBP_SAVE(x)
803#define ax_printf printk
804static void eeprom_disable_write_protect(void)
805{
806
807 if (eeprom.size == EEPROM_8KB)
808 {
809
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
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
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
869 }
870}
871
872module_init(eeprom_init);
873