![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to programming.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / utils / devbios|
Return to programming.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / utils / devbios |
1.1 root 1: /*
2: * OpenBIOS - free your system!
3: * ( firmware/flash device driver for Linux )
4: *
5: * programming.c - flash device programming and probing algorithms.
6: *
7: * This program is part of a free implementation of the IEEE 1275-1994
8: * Standard for Boot (Initialization Configuration) Firmware.
9: *
10: * Copyright (C) 1998-2004 Stefan Reinauer, <[email protected]>
11: *
12: * This program is free software; you can redistribute it and/or modify
13: * it under the terms of the GNU General Public License as published by
14: * the Free Software Foundation; version 2 of the License.
15: *
16: * This program is distributed in the hope that it will be useful,
17: * but WITHOUT ANY WARRANTY; without even the implied warranty of
18: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19: * GNU General Public License for more details.
20: *
21: * You should have received a copy of the GNU General Public License
22: * along with this program; if not, write to the Free Software
23: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
24: *
25: */
26:
27: // <-- C++ style comments are for experimental comments only.
28: // They will disappear as soon as I fixed all the stuff.
29:
30: /* #define DEBUG_PROBING */
31:
32: #include <linux/config.h>
33: #include <linux/version.h>
34: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) && defined(MODVERSIONS)
35: #include <linux/modversions.h>
36: #endif
37:
38: #include <linux/pci.h>
39: #include <linux/errno.h>
40: #include <linux/types.h>
41: #include <linux/vmalloc.h>
42: #include <linux/delay.h>
43: #include <linux/spinlock.h>
44: #include <asm/io.h>
45: #include <asm/delay.h>
46: #include <asm/uaccess.h>
47:
48: #include "bios.h"
49: #include "pcisets.h"
50: #include "flashchips.h"
51: #include "programming.h"
52:
53: struct flashdevice flashdevices[BIOS_MAXDEV];
54: int flashcount;
55:
56: /*
57: * ******************************************
58: *
59: * flashchip handling
60: *
61: * ******************************************
62: */
63:
64:
65: void flash_command (unsigned char *addr, unsigned char command)
66: #if 1
67: {
68: flash_writeb(addr, 0x5555, 0xaa);
69: flash_writeb(addr, 0x2AAA, 0x55);
70: flash_writeb(addr, 0x5555, command);
71: }
72: void fwh_flash_command(unsigned char *addr, unsigned char command)
73: #endif
74: {
75: flash_writeb(addr, 0x75555, 0xaa);
76: flash_writeb(addr, 0x72aaa, 0x55);
77: flash_writeb(addr, 0x75555, command);
78: }
79:
80: #define CFLASH flashdevices[flashcount]
81: int flash_probe_address(void *address)
82: {
83: int flashnum=0, manufnum=0, sectors=0;
84: unsigned short flash_id, testflash;
85: unsigned long flags;
86: #ifdef DEBUG_PROBING
87: printk( KERN_DEBUG "BIOS: Probing for flash chip @0x%08lx\n", (unsigned long) address);
88: #endif
89:
90: #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
91: save_flags(flags);
92: #endif
93: spin_lock_irqsave(&bios_lock, flags);
94:
95: testflash= (flash_readb(address, 0))+(flash_readb(address, 1)<<8);
96:
97: /* 1st method: Intel, Atmel listen to this.. */
98:
99: flash_command(address, 0x90);
100: udelay(20);
101:
102: flash_id = (flash_readb(address, 0))+(flash_readb(address, 1)<<8);
103:
104: #ifdef DEBUG_PROBING
105: printk (KERN_DEBUG "BIOS: testflash[%04x] flash_id[%04x]\n",
106: testflash, flash_id);
107: #endif
108:
109: /* 2nd method: Winbond (I think this is Jedec standard) */
110:
111: if (flash_id==testflash) {
112: #ifdef DEBUG_PROBING
113: printk (KERN_DEBUG "BIOS: Trying 2nd ID method.\n");
114: #endif
115: flash_command(address, 0xf0); /* Reset */
116: udelay(20);
117:
118: flash_command(address, 0x80);
119: flash_command(address, 0x60);
120: udelay(20);
121:
122: flash_id = (flash_readb(address, 0))+(flash_readb(address, 1)<<8);
123: #ifdef DEBUG_PROBING
124: printk (KERN_DEBUG "BIOS: testflash[%04x] flash_id[%04x]\n",
125: testflash, flash_id);
126: #endif
127: }
128:
129: /* 3rd Method: Some Winbonds seem to want this */
130:
131: if (flash_id==testflash) {
132: #ifdef DEBUG_PROBING
133: printk (KERN_DEBUG "BIOS: Trying 3rd ID method.\n");
134: #endif
135: flash_command(address, 0xf0); /* Reset again */
136: udelay(20);
137:
138: flash_command(address, 0x80);
139: flash_command(address, 0x20);
140: udelay(20);
141:
142: flash_id = (flash_readb(address, 0))+(flash_readb(address, 1)<<8);
143: #ifdef DEBUG_PROBING
144: printk (KERN_DEBUG "BIOS: testflash[%04x] flash_id[%04x]\n",
145: testflash, flash_id);
146: #endif
147: }
148:
149: if (flash_id==0x7f7f && flash_readb(address, 0x100)==0x1c) {
150: /* We have an Eon flashchip. They keep their
151: * device id at 0x101 instead of 0x1
152: */
153: printk(KERN_INFO "BIOS: Eon flash device detected\n");
154: flash_id=(flash_readb(address, 0x1))+(flash_readb(address, 0x101)<<8);
155: }
156:
157: flash_command(address, 0xf0);
158: udelay(20);
159:
160: spin_unlock_irqrestore(&bios_lock, flags);
161:
162: if (flash_id==testflash) return 0; /* Nothing found :-( */
163:
164: while (flashchips[flashnum].id!=0) {
165: if (flash_id==flashchips[flashnum].id)
166: break;
167: flashnum++;
168: }
169:
170: while (manufacturers[manufnum].id!=0) {
171: if ((flash_id&0xff)==manufacturers[manufnum].id)
172: break;
173: manufnum++;
174: }
175:
176: if (flashchips[flashnum].id) {
177: while (flashchips[flashnum].sectors[sectors]<flashchips[flashnum].size)
178: sectors++;
179: }
180:
181: if (flashcount >= BIOS_MAXDEV) {
182: printk(KERN_DEBUG "BIOS: Too many flash devices found.\n");
183: return -1;
184: }
185:
186: CFLASH.flashnum = flashnum;
187: CFLASH.manufnum = manufnum;
188: CFLASH.id = flash_id;
189: CFLASH.size = (flashchips[flashnum].size<<10);
190: CFLASH.sectors = sectors;
191: CFLASH.open_mode= 0;
192: CFLASH.open_cnt = 0;
193:
194: return 1;
195: }
196:
197: void flash_probe_area(unsigned long romaddr, unsigned long romsize,
198: int map_always)
199: {
200: unsigned long probeaddr;
201: unsigned char *mapped;
202:
203: mapped=ioremap(romaddr, romsize);
204:
205: devices[flashdevices[currflash].idx].activate();
206:
207: probeaddr=(unsigned long)mapped;
208:
209: while ( probeaddr < (unsigned long)mapped + romsize - 0x5555 ) {
210: if ( flash_probe_address ((void *)probeaddr) != 1) {
211: probeaddr += 4*1024;
212: continue;
213: }
214:
215: CFLASH.offset = probeaddr-(unsigned long)mapped;
216: CFLASH.mapped = (unsigned long)mapped;
217: CFLASH.physical = romaddr+CFLASH.offset;
218:
219: printk( KERN_INFO "BIOS: flash device with size "
220: "%dk (ID 0x%04x) found.\n",
221: CFLASH.size >> 10, CFLASH.id);
222:
223: printk( KERN_INFO "BIOS: physical address "
224: "0x%08lx (va=0x%08lx+0x%lx).\n",
225: CFLASH.physical, (unsigned long)CFLASH.mapped,
226: CFLASH.offset);
227:
228: if (flashchips[CFLASH.flashnum].flags&f_fwh_compl) {
229: unsigned long t_lk;
230: unsigned int i=7;
231: printk(KERN_INFO "BIOS: FWH compliant "
232: "chip detected.\n");
233: for (t_lk=0xffb80002; t_lk<=0xffbf0002; t_lk+=0x10000)
234: {
235: printk(KERN_INFO "Lock register %d "
236: "(0x%08lx): 0x%x\n",
237: i, t_lk, (unsigned int)
238: (readb(phys_to_virt(t_lk))));
239: i--;
240: }
241: }
242: flashcount++;
243: currflash++;
244: #ifdef MULTIPLE_FLASH
245: probeaddr += flashdevices[flashcount-1].size;
246: flashdevices[flashcount].mapped=flashdevices[flashcount-1].mapped;
247: flashdevices[flashcount].data=flashdevices[flashcount-1].data;
248: continue;
249: #else
250: break;
251: #endif
252: }
253:
254: /* We might want to always map the memory
255: * region in certain cases
256: */
257:
258: if (map_always) {
259: CFLASH.flashnum = 0;
260: CFLASH.manufnum = 0;
261: CFLASH.id = 0;
262: CFLASH.size = romsize;
263: CFLASH.sectors = 0;
264: CFLASH.open_mode= 0;
265: CFLASH.open_cnt = 0;
266: CFLASH.offset = 0;
267: CFLASH.mapped = (unsigned long)mapped;
268: CFLASH.physical = romaddr;
269: printk( KERN_INFO "BIOS: rom device with size "
270: "%dk registered.\n", CFLASH.size >> 10);
271: flashcount++; currflash++;
272: return;
273: }
274:
275: /* We found nothing in this area, so let's unmap it again */
276:
277: if (flashcount && flashdevices[flashcount-1].mapped != (unsigned long)mapped)
278: iounmap(mapped);
279:
280: devices[flashdevices[currflash].idx].deactivate();
281: }
282:
283: #undef CFLASH
284:
285: void flash_program (unsigned char *addr)
286: {
287: flash_command(addr, 0xa0);
288: }
289:
290: void flash_program_atmel (unsigned char *addr)
291: {
292: flash_command(addr, 0x80);
293: flash_command(addr, 0x20);
294: }
295:
296: int flash_erase (unsigned char *addr, unsigned int flashnum)
297: {
298: flash_command(addr, 0x80);
299: flash_command(addr, 0x10);
300: udelay(80);
301: return flash_ready_toggle(addr, 0);
302: }
303:
304: int flash_erase_sectors (unsigned char *addr, unsigned int flashnum, unsigned int startsec, unsigned int endsec)
305: {
306: unsigned int sector;
307:
308: if (!(flashchips[flashnum].flags & f_slow_sector_erase)) {
309: flash_command(addr, 0x80);
310:
311: if (flashchips[flashnum].flags&f_fwh_compl) {
312: flash_writeb(addr, 0x75555,0xaa);
313: flash_writeb(addr, 0x72aaa,0x55);
314: } else {
315: flash_writeb(addr, 0x5555,0xaa);
316: flash_writeb(addr, 0x2aaa,0x55);
317: }
318:
319: for (sector=startsec; sector <= endsec; sector++) {
320: flash_writeb (addr, flashchips[flashnum].sectors[sector]*1024, 0x30);
321: }
322:
323: udelay(150); // 80 max normally, wait 150usec to be sure
324: #if 0
325: if (flashchips[flashnum].flags&f_fwh_compl)
326: #endif
327: return flash_ready_toggle(addr, flashchips[flashnum].sectors[sector-1]*1024);
328: #if 0
329: else
330: return flash_ready_poll(addr, flashchips[flashnum].sectors[sector-1]*1024, 0xff);
331: #endif
332: }
333:
334: /* sectors must be sent the sector erase command for every sector */
335: for (sector=startsec; sector <= endsec; sector++) {
336: flash_command(addr, 0x80);
337: if (flashchips[flashnum].flags&f_fwh_compl) {
338: flash_writeb(addr, 0x75555,0xaa);
339: flash_writeb(addr, 0x72aaa,0x55);
340: } else {
341: flash_writeb(addr, 0x5555,0xaa);
342: flash_writeb(addr, 0x2aaa,0x55);
343: }
344:
345: flash_writeb(addr, flashchips[flashnum].sectors[sector]*1024, 0x30);
346: udelay(150);
347: #if 0
348: if (flashchips[flashnum].flags&f_fwh_compl)
349: #endif
350: flash_ready_toggle(addr, flashchips[flashnum].sectors[sector] *1024);
351: #if 0
352: else
353: flash_ready_poll(addr, flashchips[flashnum].sectors[sector]*1024, 0xff);
354: #endif
355: }
356:
357: return 0;
358:
359: }
360:
361: /* waiting for the end of programming/erasure by using the toggle method.
362: * As long as there is a programming procedure going on, bit 6 of the last
363: * written byte is toggling it's state with each consecutive read.
364: * The toggling stops as soon as the procedure is completed.
365: * This function returns 0 if everything is ok, 1 if an error occured
366: * while programming was in progress.
367: */
368:
369: int flash_ready_toggle (unsigned char *addr, unsigned int offset)
370: {
371: unsigned long int timeout=0;
372: unsigned char oldflag, flag;
373: int loop=1;
374:
375: oldflag=flash_readb(addr, offset) & 0x40;
376:
377: while (loop && (timeout<0x7fffffff)) {
378: flag=flash_readb(addr, offset) & 0x40;
379:
380: if (flag == oldflag)
381: loop=0;
382:
383: oldflag=flag;
384: timeout++;
385: }
386:
387: if (loop) {
388: printk(KERN_DEBUG "BIOS: operation timed out (Toggle)\n");
389: return 1;
390: }
391:
392: return 0;
393: }
394:
395: /* This functions is similar to the above one. While a programming
396: * procedure is going on, bit 7 of the last written data byte is
397: * inverted. When the procedure is completed, bit 7 contains the
398: * correct data value
399: */
400:
401: int flash_ready_poll (unsigned char *addr, unsigned int offset, unsigned char data)
402: {
403: unsigned long int timeout=0;
404: unsigned char flag;
405:
406: flag=flash_readb(addr, offset);
407:
408: while ( ( flag & 0x80) != ( data & 0x80)) {
409: if ( ( flag & 0x80 ) == ( data & 0x80 ) ) {
410: #ifdef DBGTIMEOUT
411: printk(KERN_DEBUG "BIOS: Timeout value (EOT Polling) %ld\n",timeout);
412: #endif
413: return 0;
414: }
415: flag=flash_readb(addr, offset);
416: if (timeout++>12800) { // 10 times more than usual.
417: printk(KERN_ERR "BIOS: EOT Polling timed out at 0x%08x."
418: " Try again or increase max. timeout.\n",offset);
419: return 1;
420: }
421: if ((flag & 0x80) == ( data & 0x80)) {
422: flag=flash_readb(addr, offset);
423: }
424: }
425: #ifdef DBGTIMEOUT
426: printk(KERN_DEBUG "BIOS: Timeout value (EOT Polling) %ld\n",timeout);
427: #endif
428:
429: flag=flash_readb(addr, offset);
430: if ( ( flag & 0x80 ) == ( data & 0x80 ) ) return 0; else return 1;
431: }
432:
433:
434:
435: void iflash_program_byte (unsigned char *addr, unsigned int offset, unsigned char data)
436: {
437: unsigned long int timeout=0;
438: unsigned char flag;
439:
440: flash_writeb (addr, offset, 0x40);
441: flash_writeb (addr, offset, data);
442:
443: flash_writeb (addr, offset, 0x70); /* Read Status */
444: do {
445: flag=flash_readb (addr, offset);
446: if (timeout++>100) { // usually 2 or 3 :-)
447: printk(KERN_ERR "BIOS: Intel programming timed out at"
448: "0x%08x. Try again or increase max. timeout.\n",offset);
449: return;
450: }
451: } while ((flag&0x80) != 0x80);
452:
453: #ifdef DBGTIMEOUT
454: printk (KERN_DEBUG"BIOS: Timeout value (Intel byte program) %ld\n",timeout);
455: #endif
456:
457: if (flag&0x18) {
458: flash_writeb (addr, offset, 0x50); /* Reset Status Register */
459: printk (KERN_ERR "BIOS: Error occured, please repeat write operation. (intel)\n");
460: }
461:
462: flash_writeb (addr, offset, 0xff);
463: }
464:
465:
466:
467: int iflash_erase_sectors (unsigned char *addr, unsigned int flashnum, unsigned int startsec, unsigned int endsec)
468: {
469: unsigned long int timeout;
470: unsigned int sector, offset=0;
471: unsigned char flag;
472:
473: for (sector=startsec; sector<=endsec; sector++) {
474: offset=(flashchips[flashnum].sectors[sector]*1024);
475: flash_writeb (addr, offset, 0x20);
476: flash_writeb (addr, offset, 0xd0);
477:
478: flash_writeb (addr, offset, 0x70); /* Read Status */
479: timeout=0;
480: do {
481: flag=flash_readb (addr, offset);
482: if (timeout++>1440000) { // usually 144000
483: printk(KERN_ERR "BIOS: Intel sector erase timed out at 0x%08x. Try again or increase max. timeout.\n",offset);
484: return 1;
485: }
486: } while ((flag&0x80) != 0x80);
487:
488: #ifdef DBGTIMEOUT
489: printk (KERN_DEBUG "BIOS: Timeout value (Intel sector erase) %ld\n",timeout);
490: #endif
491:
492: if (flag&0x28) {
493: flash_writeb (addr, offset, 0x50);
494: flash_writeb (addr, offset, 0xff);
495: return 1; /* Error! */
496: }
497: }
498:
499: flash_writeb (addr, offset, 0xff);
500: return 0;
501: }
502:
503:
504:
505: unsigned char flash_readb(unsigned char *addr, unsigned int offset)
506: {
507: #if defined(__alpha__)
508: if (flashdevices[currflash].data==(void *)0xfff80000) {
509: if (offset<0x80000)
510: outb(0x00,0x800);
511: else {
512: outb(0x01, 0x800);
513: offset-=0x80000;
514: }
515: }
516: #endif
517: return readb(addr+offset);
518: }
519:
520:
521:
522: void flash_writeb(unsigned char *addr, unsigned int offset, unsigned char data)
523: {
524: #if defined(__alpha__)
525: if (flashdevices[currflash].data==(void *)0xfff80000) {
526: if (offset<0x80000)
527: outb(0x00,0x800);
528: else {
529: outb(0x01, 0x800);
530: offset-=0x80000;
531: }
532: }
533: #endif
534: /*
535: printk(KERN_DEBUG "BIOS: writing 0x%02x to 0x%lx+0x%x\n",
536: data,bios,offset);
537: */
538: writeb(data,addr+offset);
539: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.