diff options
Diffstat (limited to 'util/flashrom')
31 files changed, 2965 insertions, 0 deletions
diff --git a/util/flashrom/82802ab.c b/util/flashrom/82802ab.c new file mode 100644 index 0000000000..80945ad832 --- /dev/null +++ b/util/flashrom/82802ab.c @@ -0,0 +1,201 @@ +/* + * 82802ab.c: driver for programming JEDEC standard flash parts + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: http://www.intel.com/design/chipsets/datashts/290658.htm + * + * $Id$ + */ + +#include <errno.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <sys/io.h> +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> + +#include "flash.h" +#include "82802ab.h" + +// I need that Berkeley bit-map printer +void print_82802ab_status(unsigned char status) +{ + printf("%s", status & 0x80 ? "Ready:" : "Busy:"); + printf("%s", status & 0x40 ? "BE SUSPEND:" : "BE RUN/FINISH:"); + printf("%s", status & 0x20 ? "BE ERROR:" : "BE OK:"); + printf("%s", status & 0x10 ? "PROG ERR:" : "PROG OK:"); + printf("%s", status & 0x8 ? "VP ERR:" : "VPP OK:"); + printf("%s", status & 0x4 ? "PROG SUSPEND:" : "PROG RUN/FINISH:"); + printf("%s", status & 0x2 ? "WP|TBL#|WP#,ABORT:" : "UNLOCK:"); +} + +int probe_82802ab(struct flashchip *flash) +{ + volatile unsigned char *bios = flash->virt_addr; + unsigned char id1, id2; + +#if 0 + *(volatile unsigned char *) (bios + 0x5555) = 0xAA; + *(volatile unsigned char *) (bios + 0x2AAA) = 0x55; + *(volatile unsigned char *) (bios + 0x5555) = 0x90; +#endif + + *bios = 0xff; + myusec_delay(10); + *bios = 0x90; + myusec_delay(10); + + id1 = *(volatile unsigned char *) bios; + id2 = *(volatile unsigned char *) (bios + 0x01); + +#if 1 + *(volatile unsigned char *) (bios + 0x5555) = 0xAA; + *(volatile unsigned char *) (bios + 0x2AAA) = 0x55; + *(volatile unsigned char *) (bios + 0x5555) = 0xF0; + +#endif + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + + if (id1 == flash->manufacture_id && id2 == flash->model_id) { + size_t size = flash->total_size * 1024; + // we need to mmap the write-protect space. + bios = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED, + flash->fd_mem, (off_t) (0 - 0x400000 - size)); + if (bios == MAP_FAILED) { + // it's this part but we can't map it ... + perror("Error MMAP /dev/mem"); + exit(1); + } + + flash->virt_addr_2 = bios; + return 1; + } + + return 0; +} + +unsigned char wait_82802ab(volatile unsigned char *bios) +{ + + unsigned char status; + unsigned char id1, id2; + + *bios = 0x70; + if ((*bios & 0x80) == 0) { // it's busy + while ((*bios & 0x80) == 0); + } + + status = *bios; + + // put another command to get out of status register mode + + *bios = 0x90; + myusec_delay(10); + + id1 = *(volatile unsigned char *) bios; + id2 = *(volatile unsigned char *) (bios + 0x01); + + // this is needed to jam it out of "read id" mode + *(volatile unsigned char *) (bios + 0x5555) = 0xAA; + *(volatile unsigned char *) (bios + 0x2AAA) = 0x55; + *(volatile unsigned char *) (bios + 0x5555) = 0xF0; + return status; + +} +int erase_82802ab_block(struct flashchip *flash, int offset) +{ + volatile unsigned char *bios = flash->virt_addr + offset; + volatile unsigned char *wrprotect = + flash->virt_addr_2 + offset + 2; + unsigned char status; + + // clear status register + *bios = 0x50; + //printf("Erase at %p\n", bios); + // clear write protect + //printf("write protect is at %p\n", (wrprotect)); + //printf("write protect is 0x%x\n", *(wrprotect)); + *(wrprotect) = 0; + //printf("write protect is 0x%x\n", *(wrprotect)); + + // now start it + *(volatile unsigned char *) (bios) = 0x20; + *(volatile unsigned char *) (bios) = 0xd0; + myusec_delay(10); + // now let's see what the register is + status = wait_82802ab(flash->virt_addr); + //print_82802ab_status(status); + printf("DONE BLOCK 0x%x\n", offset); + return (0); +} +int erase_82802ab(struct flashchip *flash) +{ + int i; + unsigned int total_size = flash->total_size * 1024; + + printf("total_size is %d; flash->page_size is %d\n", + total_size, flash->page_size); + for (i = 0; i < total_size; i += flash->page_size) + erase_82802ab_block(flash, i); + printf("DONE ERASE\n"); + return (0); +} + +void write_page_82802ab(volatile char *bios, char *src, volatile char *dst, + int page_size) +{ + int i; + + for (i = 0; i < page_size; i++) { + /* transfer data from source to destination */ + *dst = 0x40; + *dst++ = *src++; + wait_82802ab(bios); + } + +} + +int write_82802ab(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile unsigned char *bios = flash->virt_addr; + + erase_82802ab(flash); + if (*bios != 0xff) { + printf("ERASE FAILED\n"); + return -1; + } + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + printf("%04d at address: 0x%08x", i, i * page_size); + write_page_82802ab(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf + ("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + protect_82802ab(bios); + return (0); +} diff --git a/util/flashrom/82802ab.h b/util/flashrom/82802ab.h new file mode 100644 index 0000000000..05420685d6 --- /dev/null +++ b/util/flashrom/82802ab.h @@ -0,0 +1,48 @@ +#ifndef __82802AB_H__ +#define __82802AB_H__ 1 + +extern int probe_82802ab(struct flashchip *flash); +extern int erase_82802ab(struct flashchip *flash); +extern int write_82802ab(struct flashchip *flash, unsigned char *buf); + +extern __inline__ void toggle_ready_82802ab(volatile char *dst) +{ + unsigned int i = 0; + char tmp1, tmp2; + + tmp1 = *dst & 0x40; + + while (i++ < 0xFFFFFF) { + tmp2 = *dst & 0x40; + if (tmp1 == tmp2) { + break; + } + tmp1 = tmp2; + } +} + +extern __inline__ void data_polling_82802ab(volatile char *dst, char data) +{ + unsigned int i = 0; + char tmp; + + data &= 0x80; + + while (i++ < 0xFFFFFF) { + tmp = *dst & 0x80; + if (tmp == data) { + break; + } + } +} + +extern __inline__ void protect_82802ab(volatile char *bios) +{ + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0xA0; + + usleep(200); +} + +#endif /* !__82802AB_H__ */ diff --git a/util/flashrom/Makefile b/util/flashrom/Makefile new file mode 100644 index 0000000000..9d4124f31f --- /dev/null +++ b/util/flashrom/Makefile @@ -0,0 +1,33 @@ +OBJS = flash_enable.o udelay.o jedec.o sst28sf040.o am29f040b.o mx29f002.c sst39sf020.o \ + m29f400bt.o w49f002u.o 82802ab.o msys_doc.o pm49fl004.o sst49lf040.o sst_fwhub.o +CC = gcc -O2 -g -Wall -Werror + +all: flash_rom flash_on + +flash_rom: flash_rom.o ${OBJS} + ${CC} -o flash_rom flash_rom.c ${OBJS} -lpci + +flash_on: flash_on.c + ${CC} -o flash_on flash_on.c + +clean: + rm -f flash_rom flash_on *.o *~ + +flash_rom.o: flash_rom.c flash.h jedec.h \ + 82802ab.h am29f040b.h m29f400bt.h msys_doc.h mx29f002.h sst28sf040.h \ + sst39sf020.h w49f002u.h sst49lf040.h +flash_on.o: flash_on.c + +82802ab.o: 82802ab.c 82802ab.h flash.h +am29f040b.o: am29f040b.c am29f040b.h jedec.h flash.h +m29f400bt.o: m29f400bt.c m29f400bt.h flash.h +msys_doc.o: msys_doc.c msys_doc.h flash.h +mx29f002.o: mx29f002.c mx29f002.h jedec.h flash.h +sst28sf040.o: sst28sf040.c sst28sf040.h jedec.h flash.h +sst39sf020.o: sst39sf020.c sst39sf020.h jedec.h flash.h +sst49lf040.o: sst49lf040.c sst49lf040.h jedec.h flash.h +w49f002u.o: w49f002u.c w49f002u.h jedec.h flash.h +pm49fl004.o: pm49fl004.c pm49fl004.h jedec.h flash.h +flash_enable.o: flash_enable.c +udelay.o: udelay.c +jedec.o: jedec.c jedec.h flash.h diff --git a/util/flashrom/README b/util/flashrom/README new file mode 100644 index 0000000000..48f6fb8754 --- /dev/null +++ b/util/flashrom/README @@ -0,0 +1,20 @@ +on the cs5530 southbridge, + +setpci -s 0:12.0 52.b=ee +setpci -x 0:12.0 5b.b= 0x20 (| with whatever is there) + +I am making this a general-purpose userland flash burner -- RGM + +Earlier notes from Ollie: + +Here is some utilities for using/programming flash ROM on SiS 630/950 M/Bs + + 1. flash_on, turnning on the flash writer enable for 630/950 M/Bs, + you have to run this before load DoC drivers. + + 2. flash_rom, use your 630/950 M/Bs as a flash programmer for some + flash parts. This utility is made as modular as possible. If + you find your flash part is not supported, you can add a driver + your own. Or sending me the data sheet. + +Ollie diff --git a/util/flashrom/am29f040b.c b/util/flashrom/am29f040b.c new file mode 100644 index 0000000000..3ebfe8653f --- /dev/null +++ b/util/flashrom/am29f040b.c @@ -0,0 +1,135 @@ +/* + * am29f040.c: driver for programming AMD am29f040b models + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * AMD Am29F040B data sheet + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" + +static __inline__ int erase_sector_29f040b(volatile char *bios, + unsigned long address) +{ + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x80; + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + address) = 0x30; + + sleep(2); + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios + address); + + return (0); +} + +static __inline__ int write_sector_29f040b(volatile char *bios, + unsigned char *src, + volatile unsigned char *dst, + unsigned int page_size) +{ + int i; + + for (i = 0; i < page_size; i++) { + printf("0x%08lx", + (unsigned long) dst - (unsigned long) bios); + + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0xA0; + *dst++ = *src++; + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + + printf("\b\b\b\b\b\b\b\b\b\b"); + } + + return (0); +} + +int probe_29f040b(struct flashchip *flash) +{ + volatile unsigned char *bios = flash->virt_addr; + unsigned char id1, id2; + + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x90; + + id1 = *bios; + id2 = *(bios + 0x01); + + *bios = 0xF0; + + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + if (id1 == flash->manufacture_id && id2 == flash->model_id) + return 1; + + return 0; +} + +int erase_29f040b(struct flashchip *flash) +{ + volatile unsigned char *bios = flash->virt_addr; + + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x80; + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x10; + + myusec_delay(10); + toggle_ready_jedec(bios); + + return (0); +} + +int write_29f040b(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + /* erase the page before programming */ + erase_sector_29f040b(bios, i * page_size); + + /* write to the sector */ + printf("%04d at address: ", i); + write_sector_29f040b(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + + return (0); +} diff --git a/util/flashrom/am29f040b.h b/util/flashrom/am29f040b.h new file mode 100644 index 0000000000..08c6c92fae --- /dev/null +++ b/util/flashrom/am29f040b.h @@ -0,0 +1,8 @@ +#ifndef __AM29F040B_H__ +#define __AM29F040B_H__ 1 + +extern int probe_29f040b(struct flashchip *flash); +extern int erase_29f040b(struct flashchip *flash); +extern int write_29f040b(struct flashchip *flash, unsigned char *buf); + +#endif /* !__AM29F040B_H__ */ diff --git a/util/flashrom/flash.h b/util/flashrom/flash.h new file mode 100644 index 0000000000..3dfefe259a --- /dev/null +++ b/util/flashrom/flash.h @@ -0,0 +1,65 @@ +#ifndef __FLASH_H__ +#define __FLASH_H__ 1 + +#include <sys/io.h> +#include <unistd.h> + +struct flashchip { + char *name; + int manufacture_id; + int model_id; + + volatile char *virt_addr; + int total_size; + int page_size; + + int (*probe) (struct flashchip * flash); + int (*erase) (struct flashchip * flash); + int (*write) (struct flashchip * flash, unsigned char *buf); + int (*read) (struct flashchip * flash, unsigned char *buf); + + int fd_mem; + volatile char *virt_addr_2; +}; + +#define AMD_ID 0x01 +#define AM_29F040B 0xA4 + +#define ATMEL_ID 0x1F /* Winbond Manufacture ID code */ +#define AT_29C040A 0xA4 /* Winbond w29c020c device code */ + +#define MX_ID 0xC2 +#define MX_29F002 0xB0 + +#define SST_ID 0xBF /* SST Manufacturer ID code */ +#define SST_29EE020A 0x10 /* SST 29EE020 device code */ +#define SST_28SF040 0x04 /* SST 29EE040 device code */ +#define SST_39SF020 0xB6 /* SST 39SF020 device */ +#define SST_39VF020 0xD6 /* SST 39VF020 device */ +#define SST_49LF040 0x51 /* SST 49LF040 device */ +#define SST_49LF080A 0x5B /* SST 48LF080A device */ +#define SST_49LF002A 0x57 /* SST 49LF002A device */ +#define SST_49LF003A 0x1B /* SST 49LF003A device */ +#define SST_49LF004A 0x60 /* SST 49LF004A device */ +#define SST_49LF008A 0x5A /* SST 49LF008A device */ + +#define PMC_ID 0x9D /* PMC Manufacturer ID[B code */ +#define PMC_49FL004 0x6E /* PMC 49FL004 device code */ + +#define WINBOND_ID 0xDA /* Winbond Manufacture ID code */ +#define W_29C011 0xC1 /* Winbond w29c011 device code */ +#define W_29C020C 0x45 /* Winbond w29c020c device code */ +#define W_49F002U 0x0B /* Winbond w29c020c device code */ + +#define ST_ID 0x20 +#define ST_M29F400BT 0xD5 + +#define MSYSTEMS_ID 0x156f +#define MSYSTEMS_MD2200 0xdb /* ? */ +#define MSYSTEMS_MD2800 0x30 /* hmm -- both 0x30 */ +#define MSYSTEMS_MD2802 0x30 /* hmm -- both 0x30 */ + +extern void myusec_delay(int time); +extern void myusec_calibrate_delay(); +extern int enable_flash_write(void); +#endif /* !__FLASH_H__ */ diff --git a/util/flashrom/flash_enable.c b/util/flashrom/flash_enable.c new file mode 100644 index 0000000000..19fd9b07eb --- /dev/null +++ b/util/flashrom/flash_enable.c @@ -0,0 +1,343 @@ +#include <sys/io.h> +#include <stdio.h> +#include <pci/pci.h> +#include <stdlib.h> + +static int enable_flash_sis630(struct pci_dev *dev, char *name) +{ + char b; + + /* get io privilege access PCI configuration space */ + if (iopl(3) != 0) { + perror("Can not set io priviliage"); + exit(1); + } + + /* Enable 0xFFF8000~0xFFFF0000 decoding on SiS 540/630 */ + outl(0x80000840, 0x0cf8); + b = inb(0x0cfc) | 0x0b; + outb(b, 0xcfc); + /* Flash write enable on SiS 540/630 */ + outl(0x80000845, 0x0cf8); + b = inb(0x0cfd) | 0x40; + outb(b, 0xcfd); + + /* The same thing on SiS 950 SuperIO side */ + outb(0x87, 0x2e); + outb(0x01, 0x2e); + outb(0x55, 0x2e); + outb(0x55, 0x2e); + + if (inb(0x2f) != 0x87) { + outb(0x87, 0x4e); + outb(0x01, 0x4e); + outb(0x55, 0x4e); + outb(0xaa, 0x4e); + if (inb(0x4f) != 0x87) { + printf("Can not access SiS 950\n"); + return -1; + } + outb(0x24, 0x4e); + b = inb(0x4f) | 0xfc; + outb(0x24, 0x4e); + outb(b, 0x4f); + outb(0x02, 0x4e); + outb(0x02, 0x4f); + } + + outb(0x24, 0x2e); + printf("2f is %#x\n", inb(0x2f)); + b = inb(0x2f) | 0xfc; + outb(0x24, 0x2e); + outb(b, 0x2f); + + outb(0x02, 0x2e); + outb(0x02, 0x2f); + + return 0; +} + +static int enable_flash_e7500(struct pci_dev *dev, char *name) +{ + /* register 4e.b gets or'ed with one */ + unsigned char old, new; + /* if it fails, it fails. There are so many variations of broken mobos + * that it is hard to argue that we should quit at this point. + */ + + old = pci_read_byte(dev, 0x4e); + + new = old | 1; + + if (new == old) + return 0; + + pci_write_byte(dev, 0x4e, new); + + if (pci_read_byte(dev, 0x4e) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x4e, new, name); + return -1; + } + return 0; +} + +static int enable_flash_ich4(struct pci_dev *dev, char *name) +{ + /* register 4e.b gets or'ed with one */ + unsigned char old, new; + /* if it fails, it fails. There are so many variations of broken mobos + * that it is hard to argue that we should quit at this point. + */ + + old = pci_read_byte(dev, 0x4e); + + new = old | 1; + + if (new == old) + return 0; + + pci_write_byte(dev, 0x4e, new); + + if (pci_read_byte(dev, 0x4e) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x4e, new, name); + return -1; + } + return 0; +} + +static int enable_flash_vt8235(struct pci_dev *dev, char *name) +{ + unsigned char old, new, val; + unsigned int base; + int ok; + + /* get io privilege access PCI configuration space */ + if (iopl(3) != 0) { + perror("Can not set io priviliage"); + exit(1); + } + + old = pci_read_byte(dev, 0x40); + + new = old | 0x10; + + if (new == old) + return 0; + + ok = pci_write_byte(dev, 0x40, new); + if (ok != 0) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + old, new, name); + } + + /* enable GPIO15 which is connected to write protect. */ + base = ((pci_read_byte(dev, 0x88) & 0x80) | pci_read_byte(dev, 0x89) << 8); + val = inb(base + 0x4d); + val |= 0x80; + outb(val, base + 0x4d); + + if (ok != 0) { + return -1; + } else { + return 0; + } +} + +static int enable_flash_vt8231(struct pci_dev *dev, char *name) +{ + unsigned char val; + + val = pci_read_byte(dev, 0x40); + val |= 0x10; + pci_write_byte(dev, 0x40, val); + + if (pci_read_byte(dev, 0x40) != val) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x40, val, name); + return -1; + } + return 0; +} + +static int enable_flash_cs5530(struct pci_dev *dev, char *name) +{ + unsigned char new; + + pci_write_byte(dev, 0x52, 0xee); + + new = pci_read_byte(dev, 0x52); + + if (new != 0xee) { + printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x52, new, name); + return -1; + } + return 0; +} + +static int enable_flash_sc1100(struct pci_dev *dev, char *name) +{ + unsigned char new; + + pci_write_byte(dev, 0x52, 0xee); + + new = pci_read_byte(dev, 0x52); + + if (new != 0xee) { + printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x52, new, name); + return -1; + } + return 0; +} + +static int enable_flash_sis5595(struct pci_dev *dev, char *name) +{ + unsigned char new, newer; + + new = pci_read_byte(dev, 0x45); + + /* clear bit 5 */ + new &= (~0x20); + /* set bit 2 */ + new |= 0x4; + + pci_write_byte(dev, 0x45, new); + + newer = pci_read_byte(dev, 0x45); + if (newer != new) { + printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x45, new, name); + printf("Stuck at 0x%x\n", newer); + return -1; + } + return 0; +} + +static int enable_flash_amd8111(struct pci_dev *dev, char *name) +{ + /* register 4e.b gets or'ed with one */ + unsigned char old, new; + /* if it fails, it fails. There are so many variations of broken mobos + * that it is hard to argue that we should quit at this point. + */ + + /* enable decoding at 0xffb00000 to 0xffffffff */ + old = pci_read_byte(dev, 0x43); + new = old | 0xC0; + if (new != old) { + pci_write_byte(dev, 0x43, new); + if (pci_read_byte(dev, 0x43) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x43, new, name); + } + } + + old = pci_read_byte(dev, 0x40); + new = old | 0x01; + if (new == old) + return 0; + pci_write_byte(dev, 0x40, new); + + if (pci_read_byte(dev, 0x40) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x40, new, name); + return -1; + } + return 0; +} + +//By yhlu +static int enable_flash_ck804(struct pci_dev *dev, char *name) +{ + /* register 4e.b gets or'ed with one */ + unsigned char old, new; + /* if it fails, it fails. There are so many variations of broken mobos + * that it is hard to argue that we should quit at this point. + */ + + //dump_pci_device(dev); + + old = pci_read_byte(dev, 0x88); + new = old | 0xc0; + if (new != old) { + pci_write_byte(dev, 0x88, new); + if (pci_read_byte(dev, 0x88) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x88, new, name); + } + } + + old = pci_read_byte(dev, 0x6d); + new = old | 0x01; + if (new == old) + return 0; + pci_write_byte(dev, 0x6d, new); + + if (pci_read_byte(dev, 0x6d) != new) { + printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", + 0x6d, new, name); + return -1; + } + return 0; +} + +typedef struct penable { + unsigned short vendor, device; + char *name; + int (*doit) (struct pci_dev * dev, char *name); +} FLASH_ENABLE; + +static FLASH_ENABLE enables[] = { + {0x1039, 0x0630, "sis630", enable_flash_sis630}, + {0x8086, 0x2480, "E7500", enable_flash_e7500}, + {0x8086, 0x24c0, "ICH4", enable_flash_ich4}, + {0x1106, 0x8231, "VT8231", enable_flash_vt8231}, + {0x1106, 0x3177, "VT8235", enable_flash_vt8235}, + {0x1078, 0x0100, "CS5530", enable_flash_cs5530}, + {0x100b, 0x0510, "SC1100", enable_flash_sc1100}, + {0x1039, 0x0008, "SIS5595", enable_flash_sis5595}, + {0x1022, 0x7468, "AMD8111", enable_flash_amd8111}, + {0x10de, 0x0050, "NVIDIA CK804", enable_flash_ck804}, // LPC + {0x10de, 0x0051, "NVIDIA CK804", enable_flash_ck804}, // Pro + {0x10de, 0x00d3, "NVIDIA CK804", enable_flash_ck804}, // Slave, should not be here, to fix known bug for A01. +}; + +int enable_flash_write() +{ + int i; + struct pci_access *pacc; + struct pci_dev *dev = 0; + FLASH_ENABLE *enable = 0; + + pacc = pci_alloc(); /* Get the pci_access structure */ + /* Set all options you want -- here we stick with the defaults */ + pci_init(pacc); /* Initialize the PCI library */ + pci_scan_bus(pacc); /* We want to get the list of devices */ + + /* now let's try to find the chipset we have ... */ + for (i = 0; i < sizeof(enables) / sizeof(enables[0]) && (!dev); + i++) { + struct pci_filter f; + struct pci_dev *z; + /* the first param is unused. */ + pci_filter_init((struct pci_access *) 0, &f); + f.vendor = enables[i].vendor; + f.device = enables[i].device; + for (z = pacc->devices; z; z = z->next) + if (pci_filter_match(&f, z)) { + enable = &enables[i]; + dev = z; + } + } + + /* now do the deed. */ + if (enable) { + printf("Enabling flash write on %s...", enable->name); + if (enable->doit(dev, enable->name) == 0) + printf("OK\n"); + } + return 0; +} diff --git a/util/flashrom/flash_on.c b/util/flashrom/flash_on.c new file mode 100644 index 0000000000..f1e8aca38d --- /dev/null +++ b/util/flashrom/flash_on.c @@ -0,0 +1,77 @@ +/* + * flash_rom.c: Turnning on Flash Write Enable for SiS 630/950 M/Bs, + * use this program before loading DoC drivers. + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * 1. SiS 630 Specification + * 2. SiS 950 Specification + * + * $Id$ + */ + +#include <errno.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <sys/io.h> +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> + +int main() +{ + char b; + + /* get io privilege access PCI configuration space */ + if (iopl(3) != 0) { + perror("Can not set io priviliage"); + exit(1); + } + + /* Enable 0xFFF8000~0xFFFF0000 decoding on SiS 540/630 */ + outl(0x80000840, 0x0cf8); + b = inb(0x0cfc) | 0x0b; + outb(b, 0xcfc); + /* Flash write enable on SiS 540/630 */ + outl(0x80000845, 0x0cf8); + b = inb(0x0cfd) | 0x40; + outb(b, 0xcfd); + + /* The same thing on SiS 950 SuperIO side */ + outb(0x87, 0x2e); + outb(0x01, 0x2e); + outb(0x55, 0x2e); + outb(0x55, 0x2e); + + if (inb(0x2f) != 0x87) { + printf("Can not access SiS 950\n"); + return -1; + } + + outb(0x24, 0x2e); + b = inb(0x2f) | 0xfc; + outb(0x24, 0x2e); + outb(b, 0x2f); + + outb(0x02, 0x2e); + outb(0x02, 0x2f); + + return (0); +} diff --git a/util/flashrom/flash_rom.c b/util/flashrom/flash_rom.c new file mode 100644 index 0000000000..ceb56ad8f6 --- /dev/null +++ b/util/flashrom/flash_rom.c @@ -0,0 +1,328 @@ +/* + * flash_rom.c: Flash programming utility for SiS 630/950 M/Bs + * + * + * Copyright 2000 Silicon Integrated System Corporation + * Copyright 2004 Tyan Corp + * yhlu yhlu@tyan.com add exclude start and end option + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * 1. SiS 630 Specification + * 2. SiS 950 Specification + * + * $Id$ + */ + +#include <errno.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <unistd.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include "flash.h" +#include "jedec.h" +#include "m29f400bt.h" +#include "82802ab.h" +#include "msys_doc.h" +#include "am29f040b.h" +#include "sst28sf040.h" +#include "w49f002u.h" +#include "sst39sf020.h" +#include "sst49lf040.h" +#include "pm49fl004.h" +#include "mx29f002.h" +#include "sst_fwhub.h" + +struct flashchip flashchips[] = { + {"Am29F040B", AMD_ID, AM_29F040B, NULL, 512, 64 * 1024, + probe_29f040b, erase_29f040b, write_29f040b, NULL}, + {"At29C040A", ATMEL_ID, AT_29C040A, NULL, 512, 256, + probe_jedec, erase_chip_jedec, write_jedec, NULL}, + {"Mx29f002", MX_ID, MX_29F002, NULL, 256, 64 * 1024, + probe_29f002, erase_29f002, write_29f002, NULL}, + {"SST29EE020A", SST_ID, SST_29EE020A, NULL, 256, 128, + probe_jedec, erase_chip_jedec, write_jedec, NULL}, + {"SST28SF040A", SST_ID, SST_28SF040, NULL, 512, 256, + probe_28sf040, erase_28sf040, write_28sf040, NULL}, + {"SST39SF020A", SST_ID, SST_39SF020, NULL, 256, 4096, + probe_jedec, erase_chip_jedec, write_39sf020,NULL}, + {"SST39VF020", SST_ID, SST_39VF020, NULL, 256, 4096, + probe_jedec, erase_chip_jedec, write_39sf020,NULL}, + {"SST49LF040", SST_ID, SST_49LF040, NULL, 512, 4096, + probe_jedec, erase_49lf040, write_49lf040,NULL}, + {"SST49LF080A", SST_ID, SST_49LF080A, NULL, 1024, 4096, + probe_jedec, erase_chip_jedec, write_49lf040,NULL}, + {"SST49LF002A/B", SST_ID, SST_49LF002A, NULL, 256, 16 * 1024, + probe_sst_fwhub, erase_sst_fwhub, write_sst_fwhub, NULL}, + {"SST49LF003A/B", SST_ID, SST_49LF003A, NULL, 384, 64 * 1024, + probe_sst_fwhub, erase_sst_fwhub, write_sst_fwhub,NULL}, + {"SST49LF004A/B", SST_ID, SST_49LF004A, NULL, 512, 64 * 1024, + probe_sst_fwhub, erase_sst_fwhub, write_sst_fwhub,NULL}, + {"SST49LF008A", SST_ID, SST_49LF008A, NULL, 1024, 64 * 1024 , + probe_sst_fwhub, erase_sst_fwhub, write_sst_fwhub, NULL}, + {"Pm49FL004", PMC_ID, PMC_49FL004, NULL, 512, 64 * 1024, + probe_jedec, erase_chip_jedec, write_49fl004,NULL}, + {"W29C011", WINBOND_ID, W_29C011, NULL, 128, 128, + probe_jedec, erase_chip_jedec, write_jedec, NULL}, + {"W29C020C", WINBOND_ID, W_29C020C, NULL, 256, 128, + probe_jedec, erase_chip_jedec, write_jedec, NULL}, + {"W49F002U", WINBOND_ID, W_49F002U, NULL, 256, 128, + probe_jedec, erase_chip_jedec, write_49f002, NULL}, + {"M29F400BT", ST_ID, ST_M29F400BT, NULL, 512, 64 * 1024, + probe_m29f400bt, erase_m29f400bt, write_linuxbios_m29f400bt, NULL}, + {"82802ab", 137, 173, NULL, 512, 64 * 1024, + probe_82802ab, erase_82802ab, write_82802ab, NULL}, + {"82802ac", 137, 172, NULL, 1024, 64 * 1024, + probe_82802ab, erase_82802ab, write_82802ab, NULL}, + {"MD-2802 (M-Systems DiskOnChip Millennium Module)", + MSYSTEMS_ID, MSYSTEMS_MD2802, + NULL, 8, 8 * 1024, + probe_md2802, erase_md2802, write_md2802, read_md2802}, + {NULL,} +}; + +char *chip_to_probe = NULL; + +struct flashchip *probe_flash(struct flashchip *flash) +{ + int fd_mem; + volatile char *bios; + unsigned long size; + + if ((fd_mem = open("/dev/mem", O_RDWR)) < 0) { + perror("Can not open /dev/mem"); + exit(1); + } + + while (flash->name != NULL) { + if (chip_to_probe && strcmp(flash->name, chip_to_probe) != 0) { + flash++; + continue; + } + printf("Trying %s, %d KB\n", flash->name, flash->total_size); + size = flash->total_size * 1024; + /* BUG? what happens if getpagesize() > size!? + -> ``Error MMAP /dev/mem: Invalid argument'' NIKI */ + if (getpagesize() > size) { + size = getpagesize(); + printf("%s: warning: size: %d -> %ld\n", + __FUNCTION__, flash->total_size * 1024, + (unsigned long) size); + } + bios = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED, + fd_mem, (off_t) (0xffffffff - size + 1)); + if (bios == MAP_FAILED) { + perror("Error MMAP /dev/mem"); + exit(1); + } + flash->virt_addr = bios; + flash->fd_mem = fd_mem; + + if (flash->probe(flash) == 1) { + printf("%s found at physical address: 0x%lx\n", + flash->name, (0xffffffff - size + 1)); + return flash; + } + munmap((void *) bios, size); + flash++; + } + return NULL; +} + +int verify_flash(struct flashchip *flash, char *buf, int verbose) +{ + int i; + int total_size = flash->total_size * 1024; + volatile char *bios = flash->virt_addr; + + printf("Verifying address: "); + for (i = 0; i < total_size; i++) { + if (verbose) + printf("0x%08x", i); + if (*(bios + i) != *(buf + i)) { + printf("FAILED\n"); + return 0; + } + if (verbose) + printf("\b\b\b\b\b\b\b\b\b\b"); + } + if (verbose) + printf("\n"); + else + printf("VERIFIED\n"); + return 1; +} + + +void usage(const char *name) +{ + printf("usage: %s [-rwv] [-c chipname] [-s exclude_start] [-e exclude_end] [file]\n", name); + printf("-r: read flash and save into file\n" + "-w: write file into flash (default when file is specified)\n" + "-v: verify flash against file\n" + "-c: probe only for specified flash chip\n" + "-s: exclude start position\n" + "-e: exclude end postion\n" + " If no file is specified, then all that happens\n" + " is that flash info is dumped\n"); + exit(1); +} + +int exclude_start_page, exclude_end_page; + +int main(int argc, char *argv[]) +{ + char *buf; + unsigned long size; + FILE *image; + struct flashchip *flash; + int opt; + int read_it = 0, write_it = 0, erase_it = 0, verify_it = 0, + verbose = 0; + char *filename = NULL; + + + unsigned int exclude_start_position=0, exclude_end_position=0; // [x,y) + char *tempstr=NULL; + + if (argc > 1) { + /* Yes, print them. */ + int i; + printf ("The arguments are:\n"); + for (i = 1; i < argc; ++i) + printf ("%s\n", argv[i]); + } + + setbuf(stdout, NULL); + + while ((opt = getopt(argc, argv, "rwvVEc:s:e:")) != EOF) { + switch (opt) { + case 'r': + read_it = 1; + break; + case 'w': + write_it = 1; + break; + case 'v': + verify_it = 1; + break; + case 'c': + chip_to_probe = strdup(optarg); + break; + case 'V': + verbose = 1; + break; + case 'E': + erase_it = 1; + break; + case 's': + tempstr = strdup(optarg); + sscanf(tempstr,"%x",&exclude_start_position); + break; + case 'e': + tempstr = strdup(optarg); + sscanf(tempstr,"%x",&exclude_end_position); + break; + + default: + usage(argv[0]); + break; + } + } + + if (read_it && write_it) { + printf("-r and -w are mutually exclusive\n"); + usage(argv[0]); + } + + if (optind < argc) + filename = argv[optind++]; + + printf("Calibrating timer since microsleep sucks ... takes a second\n"); + myusec_calibrate_delay(); + printf("OK, calibrated, now do the deed\n"); + + /* try to enable it. Failure IS an option, since not all motherboards + * really need this to be done, etc., etc. It sucks. + */ + (void) enable_flash_write(); + + if ((flash = probe_flash(flashchips)) == NULL) { + printf("EEPROM not found\n"); + exit(1); + } + + printf("Part is %s\n", flash->name); + if (!filename && !erase_it) { + printf("OK, only ENABLING flash write, but NOT FLASHING\n"); + return 0; + } + size = flash->total_size * 1024; + buf = (char *) calloc(size, sizeof(char)); + + if (erase_it) { + printf("Erasing flash chip\n"); + flash->erase(flash); + exit(0); + } else if (read_it) { + if ((image = fopen(filename, "w")) == NULL) { + perror(filename); + exit(1); + } + printf("Reading Flash..."); + if (flash->read == NULL) + memcpy(buf, (const char *) flash->virt_addr, size); + else + flash->read(flash, buf); + + if (exclude_end_position - exclude_start_position > 0) + memset(buf+exclude_start_position, 0, + exclude_end_position-exclude_start_position); + + fwrite(buf, sizeof(char), size, image); + fclose(image); + printf("done\n"); + } else { + if ((image = fopen(filename, "r")) == NULL) { + perror(filename); + exit(1); + } + fread(buf, sizeof(char), size, image); + fclose(image); + } + + if (exclude_end_position - exclude_start_position > 0) + memcpy(buf+exclude_start_position, + (const char *) flash->virt_addr+exclude_start_position, + exclude_end_position-exclude_start_position); + + exclude_start_page = exclude_start_position/flash->page_size; + if ((exclude_start_position%flash->page_size) != 0) { + exclude_start_page++; + } + exclude_end_page = exclude_end_position/flash->page_size; + + if (write_it || (!read_it && !verify_it)) { + flash->write(flash, buf); + } + if (verify_it) + verify_flash(flash, buf, verbose); + return 0; +} diff --git a/util/flashrom/jedec.c b/util/flashrom/jedec.c new file mode 100644 index 0000000000..353b17ab98 --- /dev/null +++ b/util/flashrom/jedec.c @@ -0,0 +1,219 @@ +/* + * jedec.c: driver for programming JEDEC standard flash parts + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" + +int probe_jedec(struct flashchip *flash) +{ + volatile unsigned char *bios = flash->virt_addr; + unsigned char id1, id2; + + /* Issue JEDEC Product ID Entry command */ + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0x90; + myusec_delay(10); + + /* Read product ID */ + id1 = *(volatile unsigned char *) bios; + id2 = *(volatile unsigned char *) (bios + 0x01); + + /* Issue JEDEC Product ID Exit command */ + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0xF0; + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + if (id1 == flash->manufacture_id && id2 == flash->model_id) + return 1; + + return 0; +} + +int erase_sector_jedec(volatile unsigned char *bios, unsigned int page) +{ + /* Issue the Sector Erase command */ + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0x80; + myusec_delay(10); + + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + page) = 0x30; + myusec_delay(10); + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + + return (0); +} + +int erase_block_jedec(volatile unsigned char *bios, unsigned int block) +{ + /* Issue the Sector Erase command */ + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0x80; + myusec_delay(10); + + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + block) = 0x50; + myusec_delay(10); + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + + return (0); +} + +int erase_chip_jedec(struct flashchip *flash) +{ + volatile unsigned char *bios = flash->virt_addr; + + /* Issue the JEDEC Chip Erase command */ + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0x80; + myusec_delay(10); + + *(volatile char *) (bios + 0x5555) = 0xAA; + myusec_delay(10); + *(volatile char *) (bios + 0x2AAA) = 0x55; + myusec_delay(10); + *(volatile char *) (bios + 0x5555) = 0x10; + myusec_delay(10); + + toggle_ready_jedec(bios); + + return (0); +} + +int write_page_write_jedec(volatile unsigned char *bios, unsigned char *src, + volatile unsigned char *dst, int page_size) +{ + int i; + + /* Issue JEDEC Data Unprotect comand */ + *(volatile unsigned char *) (bios + 0x5555) = 0xAA; + *(volatile unsigned char *) (bios + 0x2AAA) = 0x55; + *(volatile unsigned char *) (bios + 0x5555) = 0xA0; + + /* transfer data from source to destination */ + for (i = 0; i < page_size; i++) { + /* If the data is 0xFF, don't program it */ + if (*src == 0xFF) + continue; + *dst++ = *src++; + } + + toggle_ready_jedec(dst - 1); + + return 0; +} + +int write_byte_program_jedec(volatile unsigned char *bios, unsigned char *src, + volatile unsigned char *dst) +{ + int tried = 0; + + /* If the data is 0xFF, don't program it */ + if (*src == 0xFF) { + return 0; + } + +retry: + /* Issue JEDEC Byte Program command */ + *(volatile unsigned char *) (bios + 0x5555) = 0xAA; + *(volatile unsigned char *) (bios + 0x2AAA) = 0x55; + *(volatile unsigned char *) (bios + 0x5555) = 0xA0; + + /* transfer data from source to destination */ + *dst = *src; + toggle_ready_jedec(bios); + + if (*dst != *src && tried++ < 0x10) { + goto retry; + } + + return 0; +} + +int write_sector_jedec(volatile unsigned char *bios, unsigned char *src, + volatile unsigned char *dst, unsigned int page_size) +{ + int i; + + for (i = 0; i < page_size; i++) { + write_byte_program_jedec(bios, src, dst); + dst++, src++; + } + + return (0); +} + +int write_jedec(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024; + int page_size = flash->page_size; + volatile unsigned char *bios = flash->virt_addr; + + erase_chip_jedec(flash); + if (*bios != (unsigned char) 0xff) { + printf("ERASE FAILED\n"); + return -1; + } + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + printf("%04d at address: 0x%08x", i, i * page_size); + write_page_write_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + protect_jedec(bios); + + return (0); +} diff --git a/util/flashrom/jedec.h b/util/flashrom/jedec.h new file mode 100644 index 0000000000..2a9f977711 --- /dev/null +++ b/util/flashrom/jedec.h @@ -0,0 +1,67 @@ +#ifndef __JEDEC_H__ +#define __JEDEC_H__ 1 +int write_byte_program_jedec(volatile unsigned char *bios, unsigned char *src, + volatile unsigned char *dst); + +extern int probe_jedec(struct flashchip *flash); +extern int erase_chip_jedec(struct flashchip *flash); +extern int write_jedec(struct flashchip *flash, unsigned char *buf); +extern int erase_sector_jedec(volatile unsigned char *bios, unsigned int page); +extern int erase_block_jedec(volatile unsigned char *bios, unsigned int page); +extern int write_sector_jedec(volatile unsigned char *bios, unsigned char *src, + volatile unsigned char *dst, + unsigned int page_size); + +extern __inline__ void toggle_ready_jedec(volatile char *dst) +{ + unsigned int i = 0; + char tmp1, tmp2; + + tmp1 = *dst & 0x40; + + while (i++ < 0xFFFFFFF) { + tmp2 = *dst & 0x40; + if (tmp1 == tmp2) { + break; + } + tmp1 = tmp2; + } +} + +extern __inline__ void data_polling_jedec(volatile char *dst, char data) +{ + unsigned int i = 0; + char tmp; + + data &= 0x80; + + while (i++ < 0xFFFFFFF) { + tmp = *dst & 0x80; + if (tmp == data) { + break; + } + } +} + +extern __inline__ void unprotect_jedec(volatile char *bios) +{ + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0x80; + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0x20; + + usleep(200); +} + +extern __inline__ void protect_jedec(volatile char *bios) +{ + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0xA0; + + usleep(200); +} + +#endif /* !__JEDEC_H__ */ diff --git a/util/flashrom/m29f400bt.c b/util/flashrom/m29f400bt.c new file mode 100644 index 0000000000..842e35d7d8 --- /dev/null +++ b/util/flashrom/m29f400bt.c @@ -0,0 +1,199 @@ +/* + * m29f400bt.c: driver for programming JEDEC standard flash parts + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * + * $Id$ + */ + +#include "flash.h" +#include "m29f400bt.h" + +int probe_m29f400bt(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + unsigned char id1, id2; + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0x90; + + myusec_delay(10); + + id1 = *(volatile unsigned char *) bios; + id2 = *(volatile unsigned char *) (bios + 0x02); + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0xF0; + + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + + + if (id1 == flash->manufacture_id && id2 == flash->model_id) + return 1; + + return 0; +} + +int erase_m29f400bt(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0x80; + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0x10; + + myusec_delay(10); + toggle_ready_m29f400bt(bios); + + return (0); +} + +int block_erase_m29f400bt(volatile char *bios, volatile char *dst) +{ + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0x80; + + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + //*(volatile char *) (bios + 0xAAA) = 0x10; + *dst = 0x30; + + myusec_delay(10); + toggle_ready_m29f400bt(bios); + + return (0); +} + +int write_m29f400bt(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + //erase_m29f400bt (flash); + printf("Programming Page:\n "); + /********************************* + *Pages for M29F400BT: + * 16 0x7c000 0x7ffff TOP + * 8 0x7a000 0x7bfff + * 8 0x78000 0x79fff + * 32 0x70000 0x77fff + * 64 0x60000 0x6ffff + * 64 0x50000 0x5ffff + * 64 0x40000 0x4ffff + *--------------------------------- + * 64 0x30000 0x3ffff + * 64 0x20000 0x2ffff + * 64 0x10000 0x1ffff + * 64 0x00000 0x0ffff BOTTOM + *********************************/ + printf("total_size/page_size = %d\n", total_size / page_size); + for (i = 0; i < (total_size / page_size) - 1; i++) { + printf("%04d at address: 0x%08x\n", i, i * page_size); + block_erase_m29f400bt(bios, bios + i * page_size); + write_page_m29f400bt(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf + ("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + + printf("%04d at address: 0x%08x\n", 7, 0x70000); + block_erase_m29f400bt(bios, bios + 0x70000); + write_page_m29f400bt(bios, buf + 0x70000, bios + 0x70000, + 32 * 1024); + + printf("%04d at address: 0x%08x\n", 8, 0x78000); + block_erase_m29f400bt(bios, bios + 0x78000); + write_page_m29f400bt(bios, buf + 0x78000, bios + 0x78000, + 8 * 1024); + + printf("%04d at address: 0x%08x\n", 9, 0x7a000); + block_erase_m29f400bt(bios, bios + 0x7a000); + write_page_m29f400bt(bios, buf + 0x7a000, bios + 0x7a000, + 8 * 1024); + + printf("%04d at address: 0x%08x\n", 10, 0x7c000); + block_erase_m29f400bt(bios, bios + 0x7c000); + write_page_m29f400bt(bios, buf + 0x7c000, bios + 0x7c000, + 16 * 1024); + + printf("\n"); + //protect_m29f400bt (bios); + + return (0); +} + +int write_linuxbios_m29f400bt(struct flashchip *flash, unsigned char *buf) +{ + volatile char *bios = flash->virt_addr; + + printf("Programming Page:\n "); + /********************************* + *Pages for M29F400BT: + * 16 0x7c000 0x7ffff TOP + * 8 0x7a000 0x7bfff + * 8 0x78000 0x79fff + * 32 0x70000 0x77fff + * 64 0x60000 0x6ffff + * 64 0x50000 0x5ffff + * 64 0x40000 0x4ffff + *--------------------------------- + * 64 0x30000 0x3ffff + * 64 0x20000 0x2ffff + * 64 0x10000 0x1ffff + * 64 0x00000 0x0ffff BOTTOM + *********************************/ + printf("%04d at address: 0x%08x\n", 7, 0x00000); + block_erase_m29f400bt(bios, bios + 0x00000); + write_page_m29f400bt(bios, buf + 0x00000, bios + 0x00000, + 64 * 1024); + + printf("%04d at address: 0x%08x\n", 7, 0x10000); + block_erase_m29f400bt(bios, bios + 0x10000); + write_page_m29f400bt(bios, buf + 0x10000, bios + 0x10000, + 64 * 1024); + + printf("%04d at address: 0x%08x\n", 7, 0x20000); + block_erase_m29f400bt(bios, bios + 0x20000); + write_page_m29f400bt(bios, buf + 0x20000, bios + 0x20000, + 64 * 1024); + + printf("%04d at address: 0x%08x\n", 7, 0x30000); + block_erase_m29f400bt(bios, bios + 0x30000); + write_page_m29f400bt(bios, buf + 0x30000, bios + 0x30000, + 64 * 1024); + + printf("\n"); + //protect_m29f400bt (bios); + + return (0); +} diff --git a/util/flashrom/m29f400bt.h b/util/flashrom/m29f400bt.h new file mode 100644 index 0000000000..efe0953701 --- /dev/null +++ b/util/flashrom/m29f400bt.h @@ -0,0 +1,79 @@ +#ifndef __M29F400BT_H__ +#define __M29F400BT_H__ 1 + +#include <stdio.h> + +extern int probe_m29f400bt(struct flashchip *flash); +extern int erase_m29f400bt(struct flashchip *flash); +extern int block_erase_m29f400bt(volatile char *bios, volatile char *dst); +extern int write_m29f400bt(struct flashchip *flash, unsigned char *buf); +extern int write_linuxbios_m29f400bt(struct flashchip *flash, + unsigned char *buf); + +extern __inline__ void toggle_ready_m29f400bt(volatile char *dst) +{ + unsigned int i = 0; + char tmp1, tmp2; + + tmp1 = *dst & 0x40; + + while (i++ < 0xFFFFFF) { + tmp2 = *dst & 0x40; + if (tmp1 == tmp2) { + break; + } + tmp1 = tmp2; + } +} + +extern __inline__ void data_polling_m29f400bt(volatile char *dst, + unsigned char data) +{ + unsigned int i = 0; + char tmp; + + data &= 0x80; + + while (i++ < 0xFFFFFF) { + tmp = *dst & 0x80; + if (tmp == data) { + break; + } + } +} + +extern __inline__ void protect_m29f400bt(volatile char *bios) +{ + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0xA0; + + usleep(200); +} + +extern __inline__ void write_page_m29f400bt(volatile char *bios, char *src, + volatile char *dst, + int page_size) +{ + int i; + + for (i = 0; i < page_size; i++) { + *(volatile char *) (bios + 0xAAA) = 0xAA; + *(volatile char *) (bios + 0x555) = 0x55; + *(volatile char *) (bios + 0xAAA) = 0xA0; + + /* transfer data from source to destination */ + *dst = *src; + //*(volatile char *) (bios) = 0xF0; + //usleep(5); + toggle_ready_m29f400bt(dst); + printf + ("Value in the flash at address %p = %#x, want %#x\n", + (char *) (dst - bios), *dst, *src); + dst++; + src++; + } + +} + +#endif /* !__M29F400BT_H__ */ diff --git a/util/flashrom/msys_doc.c b/util/flashrom/msys_doc.c new file mode 100644 index 0000000000..7e9ca9ac08 --- /dev/null +++ b/util/flashrom/msys_doc.c @@ -0,0 +1,282 @@ +/* + * msys_doc.c: driver for programming m-systems doc devices + * + * + * Copyright 2003 Niki W. Waibel <niki.waibel@gmx.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + + +#include <stdio.h> +#include <unistd.h> +#include "flash.h" +#include "msys_doc.h" + + + + + +static int doc_wait(volatile char *bios, int timeout); +static unsigned char doc_read_chipid(volatile char *bios); +static unsigned char doc_read_docstatus(volatile char *bios); +static unsigned char doc_read_cdsncontrol(volatile char *bios); +static void doc_write_cdsncontrol(volatile char *bios, unsigned char data); + + + + + +int probe_md2802(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + unsigned char chipid; +#ifndef MSYSTEMS_DOC_NO_55AA_CHECKING + unsigned char id_0x55, id_0xAA; +#endif /* !MSYSTEMS_DOC_NO_55AA_CHECKING */ + int i, toggle_a, toggle_b; + + printf("%s:\n", __FUNCTION__); + printf("%s: *******************************\n", __FUNCTION__); + printf("%s: * THIS IS A PRE ALPHA VERSION *\n", __FUNCTION__); + printf("%s: * IN THE DEVELOPEMENT *********\n", __FUNCTION__); + printf("%s: * PROCESS RIGHT NOW. **********\n", __FUNCTION__); + printf("%s: *******************************\n", __FUNCTION__); + printf("%s: * IF YOU ARE NOT A DEVELOPER **\n", __FUNCTION__); + printf("%s: * THEN DO NOT TRY TO READ OR **\n", __FUNCTION__); + printf("%s: * WRITE TO THIS DEVICE ********\n", __FUNCTION__); + printf("%s: *******************************\n", __FUNCTION__); + printf("%s:\n", __FUNCTION__); + + printf("%s: switching off reset mode ...\n", __FUNCTION__); + doc_write(0x85, bios, DOCControl); + doc_write(0x85, bios, DOCControl); + doc_read_4nop(bios); + if (doc_wait(bios, 5000)) + return (-1); + printf("%s: switching off reset mode ... done\n", __FUNCTION__); + printf("%s:\n", __FUNCTION__); + + printf("%s: switching off write protection ...\n", __FUNCTION__); + doc_write_cdsncontrol(bios, doc_read_cdsncontrol(bios) & (~0x08)); + printf("%s: switching off write protection ... done\n", + __FUNCTION__); + printf("%s:\n", __FUNCTION__); + + + chipid = doc_read_chipid(bios); +#ifndef MSYSTEMS_DOC_NO_55AA_CHECKING + id_0x55 = doc_read(bios, IPL_0x0000); + id_0xAA = doc_read(bios, IPL_0x0001); +#endif /* !MSYSTEMS_DOC_NO_55AA_CHECKING */ + printf("%s: IPL_0x0000: 0x%02x\n", __FUNCTION__, id_0x55); + printf("%s: IPL_0x0001: 0x%02x\n", __FUNCTION__, id_0xAA); + printf("%s: IPL_0x0002: 0x%02x\n", __FUNCTION__, + doc_read(bios, IPL_0x0002)); + printf("%s: IPL_0x0003: 0x%02x\n", __FUNCTION__, + doc_read(bios, IPL_0x0003)); + printf("%s:\n", __FUNCTION__); + printf("%s: ChipID: 0x%02x\n", __FUNCTION__, chipid); + printf("%s: DOCStatus: 0x%02x\n", __FUNCTION__, + doc_read_docstatus(bios)); + printf("%s: FloorSelect: 0x%02x\n", __FUNCTION__, + doc_read(bios, FloorSelect)); + printf("%s: CDSNControl: 0x%02x\n", __FUNCTION__, + doc_read_cdsncontrol(bios)); + printf("%s: CDSNDeviceSelect: 0x%02x\n", __FUNCTION__, + doc_read(bios, CDSNDeviceSelect)); + printf("%s: ECCConfiguration: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCConfiguration)); + printf("%s: CDSNSlowIO: 0x%02x\n", __FUNCTION__, + doc_read(bios, CDSNSlowIO)); + printf("%s: ECCSyndrome0: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome0)); + printf("%s: ECCSyndrome1: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome1)); + printf("%s: ECCSyndrome2: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome2)); + printf("%s: ECCSyndrome3: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome3)); + printf("%s: ECCSyndrome4: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome4)); + printf("%s: ECCSyndrome5: 0x%02x\n", __FUNCTION__, + doc_read(bios, ECCSyndrome5)); + printf("%s: AliasResolution: 0x%02x\n", __FUNCTION__, + doc_read(bios, AliasResolution)); + printf("%s: ConfigurationInput: 0x%02x\n", __FUNCTION__, + doc_read(bios, ConfigurationInput)); + printf("%s: ReadPipelineInitialization: 0x%02x\n", __FUNCTION__, + doc_read(bios, ReadPipelineInitialization)); + printf("%s: LastDataRead: 0x%02x\n", __FUNCTION__, + doc_read(bios, LastDataRead)); + printf("%s:\n", __FUNCTION__); + + printf("%s: checking ECCConfiguration toggle bit\n", __FUNCTION__); + printf("%s:", __FUNCTION__); + toggle_a = toggle_b = 0; + for (i = 0; i < 10; i++) { + unsigned char toggle = doc_toggle(bios); + + printf(" 0x%02x", toggle); + + if (i % 2) + toggle_a += toggle; + else + toggle_b += toggle; + } /* for(i=0; i<10; i++) */ + printf("\n%s: toggle result: %d/%d\n", __FUNCTION__, toggle_a, + toggle_b); + + if (chipid == flash->model_id + && ((toggle_a == 5 && toggle_b == 0) + || (toggle_a == 0 && toggle_b == 5)) +#ifndef MSYSTEMS_DOC_NO_55AA_CHECKING + && id_0x55 == 0x55 && id_0xAA == 0xaa +#endif /* !MSYSTEMS_DOC_NO_55AA_CHECKING */ + ) { + return (1); + } + + return (0); +} /* int probe_md2802(struct flashchip *flash) */ + + + +int read_md2802(struct flashchip *flash, unsigned char *buf) +{ + + return (0); +} /* int read_md2802(struct flashchip *flash, unsigned char *buf) */ + + + +int erase_md2802(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + + return (1); + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0x80; + + *(volatile char *) (bios + 0x5555) = 0xAA; + *(volatile char *) (bios + 0x2AAA) = 0x55; + *(volatile char *) (bios + 0x5555) = 0x10; +} /* int erase_md2802(struct flashchip *flash) */ + + + +int write_md2802(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile unsigned char *bios = flash->virt_addr; + + return (1); + erase_md2802(flash); + if (*bios != (unsigned char) 0xff) { + printf("ERASE FAILED\n"); + return -1; + } + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + printf("%04d at address: 0x%08x", i, i * page_size); + //write_page_md2802(bios, buf + i * page_size, bios + i * page_size, page_size); + printf + ("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + //protect_md2802(bios); + + return 0; +} /* int write_md2802(struct flashchip *flash, char *buf) */ + + + + + + +/* + wait timeout msec for doc to become ready + return: + 0: ready + -1: timeout expired +*/ +static int doc_wait(volatile char *bios, int timeout) +{ + int i = 20; + + doc_read_4nop(bios); + + while (_doc_busy(bios) && (i != 0)) { + usleep(timeout * 1000 / 20); + i--; + } + + doc_read_2nop(bios); + + if (_doc_busy(bios)) { + doc_read_2nop(bios); + return (-1); + } + + return (0); +} /* static int doc_wait(volatile char *bios, int timeout) */ + + + +static unsigned char doc_read_docstatus(volatile char *bios) +{ + doc_read(bios, CDSNSlowIO); + doc_read_2nop(bios); + + return (doc_read(bios, _DOCStatus)); +} /* static unsigned char doc_read_docstatus(volatile char *bios) */ + + + +static unsigned char doc_read_chipid(volatile char *bios) +{ + doc_read(bios, CDSNSlowIO); + doc_read_2nop(bios); + + return (doc_read(bios, _ChipID)); +} /* static unsigned char doc_read_chipid(volatile char *bios) */ + + + +static unsigned char doc_read_cdsncontrol(volatile char *bios) +{ + unsigned char value; + + /* the delays might be necessary when reading the busy bit, + but because a read to this reg reads the busy bit + anyway we better do this delays... */ + doc_read_4nop(bios); + value = doc_read(bios, _CDSNControl); + doc_read_2nop(bios); + + return (value); +} /* static unsigned char doc_read_chipid(volatile char *bios) */ + + + +static void doc_write_cdsncontrol(volatile char *bios, unsigned char data) +{ + doc_write(data, bios, _CDSNControl); + doc_read_4nop(bios); +} /* static void doc_write_chipid(volatile char *bios, unsigned char data) */ diff --git a/util/flashrom/msys_doc.h b/util/flashrom/msys_doc.h new file mode 100644 index 0000000000..3e2028b44b --- /dev/null +++ b/util/flashrom/msys_doc.h @@ -0,0 +1,110 @@ +/* + * msys_doc.h: header file of msys_doc.c + * + * + * Copyright 2003 Niki W. Waibel <niki.waibel@gmx.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + + +#ifndef __MSYS_DOC_H__ +#define __MSYS_DOC_H__ 1 + + + +/* idea from include/linux/mtd/doc2000.h */ +/* registers with __ should not be read/written directly */ +#define MSYSTEMS_DOC_R__ChipID 0x1000 +#define MSYSTEMS_DOC_R__DOCStatus 0x1001 +#define MSYSTEMS_DOC_W_DOCControl 0x1002 +#define MSYSTEMS_DOC_R_FloorSelect 0x1003 +#define MSYSTEMS_DOC_W_FloorSelect 0x1003 +#define MSYSTEMS_DOC_R__CDSNControl 0x1004 +#define MSYSTEMS_DOC_W__CDSNControl 0x1004 +#define MSYSTEMS_DOC_R_CDSNDeviceSelect 0x1005 +#define MSYSTEMS_DOC_W_CDSNDeviceSelect 0x1005 +#define MSYSTEMS_DOC_R_ECCConfiguration 0x1006 +#define MSYSTEMS_DOC_W_ECCConfiguration 0x1006 +#define MSYSTEMS_DOC_R_CDSNSlowIO 0x100d +#define MSYSTEMS_DOC_W_CDSNSlowIO 0x100d +#define MSYSTEMS_DOC_R_ECCSyndrome0 0x1010 +#define MSYSTEMS_DOC_R_ECCSyndrome1 0x1011 +#define MSYSTEMS_DOC_R_ECCSyndrome2 0x1012 +#define MSYSTEMS_DOC_R_ECCSyndrome3 0x1013 +#define MSYSTEMS_DOC_R_ECCSyndrome4 0x1014 +#define MSYSTEMS_DOC_R_ECCSyndrome5 0x1015 +#define MSYSTEMS_DOC_R_AliasResolution 0x101b +#define MSYSTEMS_DOC_W_AliasResolution 0x101b +#define MSYSTEMS_DOC_R_ConfigurationInput 0x101c +#define MSYSTEMS_DOC_W_ConfigurationInput 0x101c +#define MSYSTEMS_DOC_R_ReadPipelineInitialization 0x101d +#define MSYSTEMS_DOC_W_WritePipelineTermination 0x101e +#define MSYSTEMS_DOC_R_LastDataRead 0x101f +#define MSYSTEMS_DOC_W_LastDataRead 0x101f +#define MSYSTEMS_DOC_R_NOP 0x1020 +#define MSYSTEMS_DOC_W_NOP 0x1020 + +#define MSYSTEMS_DOC_R_IPL_0x0000 0x0000 +#define MSYSTEMS_DOC_R_IPL_0x0001 0x0001 +#define MSYSTEMS_DOC_R_IPL_0x0002 0x0002 +#define MSYSTEMS_DOC_R_IPL_0x0003 0x0003 + +#define MSYSTEMS_DOC_R_CDSNIO_BASE 0x0800 +#define MSYSTEMS_DOC_W_CDSNIO_BASE 0x0800 + + + +#define doc_read(base,reg) \ + (*(volatile unsigned char *)(base + MSYSTEMS_DOC_R_##reg)) + +#define doc_read_nop(base) \ + doc_read(base, NOP) + +#define doc_read_2nop(base) \ + { doc_read_nop(base); doc_read_nop(base); } + +#define doc_read_4nop(base) \ + { doc_read_2nop(base); doc_read_2nop(base); } + +#define doc_write(data,base,reg) \ + (*(volatile unsigned char *)(base + MSYSTEMS_DOC_W_##reg)) = data + +#define doc_write_nop(base) \ + doc_write(0, base, NOP) + +#define doc_write_2nop(base) \ + { doc_write_nop(base); doc_write_nop(base); } + +#define doc_write_4nop(base) \ + { doc_write_2nop(base); doc_write_2nop(base); } + +#define _doc_busy(base) /* 0: ready; -1: busy */ \ + ( ((doc_read(base, _CDSNControl) & 0x80) >> 7) - 1) + +#define doc_toggle(base) /* 0, 1, 0, 1, 0, 1, ... if a doc is present */ \ + ( (doc_read(base, ECCConfiguration) & 0x04) >> 2 ) + + + +extern int probe_md2802(struct flashchip *flash); +extern int read_md2802(struct flashchip *flash, unsigned char *buf); +extern int erase_md2802(struct flashchip *flash); +extern int write_md2802(struct flashchip *flash, unsigned char *buf); + + + +#endif /* !__MSYS_DOC_H__ */ diff --git a/util/flashrom/mx29f002.c b/util/flashrom/mx29f002.c new file mode 100644 index 0000000000..b281528935 --- /dev/null +++ b/util/flashrom/mx29f002.c @@ -0,0 +1,119 @@ +/* + * mx29f002.c: driver for MXIC MX29F002 flash models + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * MX29F002/002N data sheet + * + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" +#include "mx29f002.h" + +int probe_29f002(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + unsigned char id1, id2; + + *(bios + 0x5555) = 0xAA; + *(bios + 0x2AAA) = 0x55; + *(bios + 0x5555) = 0x90; + + id1 = *(volatile unsigned char *) bios; + id2 = *(volatile unsigned char *) (bios + 0x01); + + *bios = 0xF0; + + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + if (id1 == flash->manufacture_id && id2 == flash->model_id) + return 1; + + return 0; +} + +int erase_29f002(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + + *(bios + 0x555) = 0xF0; + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x80; + *(bios + 0x555) = 0xAA; + *(bios + 0x2AA) = 0x55; + *(bios + 0x555) = 0x10; + + myusec_delay(100); + toggle_ready_jedec(bios); + + // while ((*bios & 0x40) != 0x40) + //; + +#if 0 + toggle_ready_jedec(bios); + *(bios + 0x0ffff) = 0x30; + *(bios + 0x1ffff) = 0x30; + *(bios + 0x2ffff) = 0x30; + *(bios + 0x37fff) = 0x30; + *(bios + 0x39fff) = 0x30; + *(bios + 0x3bfff) = 0x30; +#endif + + return (0); +} + +int write_29f002(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024; + volatile char *bios = flash->virt_addr; + volatile char *dst = bios; + + *bios = 0xF0; + myusec_delay(10); + erase_29f002(flash); + //*bios = 0xF0; +#if 1 + printf("Programming Page: "); + for (i = 0; i < total_size; i++) { + /* write to the sector */ + if ((i & 0xfff) == 0) + printf("address: 0x%08lx", (unsigned long) i); + *(bios + 0x5555) = 0xAA; + *(bios + 0x2AAA) = 0x55; + *(bios + 0x5555) = 0xA0; + *dst++ = *buf++; + + /* wait for Toggle bit ready */ + toggle_ready_jedec(dst); + + if ((i & 0xfff) == 0) + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } +#endif + printf("\n"); + + return (0); +} diff --git a/util/flashrom/mx29f002.h b/util/flashrom/mx29f002.h new file mode 100644 index 0000000000..7d3cf20ce1 --- /dev/null +++ b/util/flashrom/mx29f002.h @@ -0,0 +1,8 @@ +#ifndef __MX29F002_H__ +#define __MX29F002_H__ 1 + +extern int probe_29f002(struct flashchip *flash); +extern int erase_29f002(struct flashchip *flash); +extern int write_29f002(struct flashchip *flash, unsigned char *buf); + +#endif /* !__MX29F002_H__ */ diff --git a/util/flashrom/pm49fl004.c b/util/flashrom/pm49fl004.c new file mode 100644 index 0000000000..afcd55a063 --- /dev/null +++ b/util/flashrom/pm49fl004.c @@ -0,0 +1,57 @@ +/* + * pm49fl004.c: driver for Pm49FL004 flash models. + * + * + * Copyright 2004 Tyan Corporation + * yhlu yhlu@tyan.com add exclude range + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" +#include "pm49fl004.h" + +extern int exclude_start_page, exclude_end_page; + +int write_49fl004(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + if( (i>=exclude_start_page) && (i<exclude_end_page)) + continue; + + /* erase the page before programming */ + erase_block_jedec(bios, i * page_size); + + /* write to the sector */ + printf("%04d at address: 0x%08x", i, i * page_size); + write_sector_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + fflush(stdout); + } + printf("\n"); + + return (0); +} diff --git a/util/flashrom/pm49fl004.h b/util/flashrom/pm49fl004.h new file mode 100644 index 0000000000..21c880b0bf --- /dev/null +++ b/util/flashrom/pm49fl004.h @@ -0,0 +1,8 @@ +#ifndef __PM49FL004_H__ +#define __PM49FL004_H__ 1 + +extern int probe_49fl004(struct flashchip *flash); +extern int erase_49fl004(struct flashchip *flash); +extern int write_49fl004(struct flashchip *flash, unsigned char *buf); + +#endif diff --git a/util/flashrom/sst28sf040.c b/util/flashrom/sst28sf040.c new file mode 100644 index 0000000000..1853f156b0 --- /dev/null +++ b/util/flashrom/sst28sf040.c @@ -0,0 +1,173 @@ +/* + * sst28sf040.c: driver for SST28SF040C flash models. + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * 4 MEgabit (512K x 8) SuperFlash EEPROM, SST28SF040 data sheet + * + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" + +#define AUTO_PG_ERASE1 0x20 +#define AUTO_PG_ERASE2 0xD0 +#define AUTO_PGRM 0x10 +#define CHIP_ERASE 0x30 +#define RESET 0xFF +#define READ_ID 0x90 + +static __inline__ void protect_28sf040(volatile char *bios) +{ + /* ask compiler not to optimize this */ + volatile unsigned char tmp; + + tmp = *(volatile unsigned char *) (bios + 0x1823); + tmp = *(volatile unsigned char *) (bios + 0x1820); + tmp = *(volatile unsigned char *) (bios + 0x1822); + tmp = *(volatile unsigned char *) (bios + 0x0418); + tmp = *(volatile unsigned char *) (bios + 0x041B); + tmp = *(volatile unsigned char *) (bios + 0x0419); + tmp = *(volatile unsigned char *) (bios + 0x040A); +} + +static __inline__ void unprotect_28sf040(volatile char *bios) +{ + /* ask compiler not to optimize this */ + volatile unsigned char tmp; + + tmp = *(volatile unsigned char *) (bios + 0x1823); + tmp = *(volatile unsigned char *) (bios + 0x1820); + tmp = *(volatile unsigned char *) (bios + 0x1822); + tmp = *(volatile unsigned char *) (bios + 0x0418); + tmp = *(volatile unsigned char *) (bios + 0x041B); + tmp = *(volatile unsigned char *) (bios + 0x0419); + tmp = *(volatile unsigned char *) (bios + 0x041A); +} + +static __inline__ int erase_sector_28sf040(volatile char *bios, + unsigned long address) +{ + *bios = AUTO_PG_ERASE1; + *(bios + address) = AUTO_PG_ERASE2; + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + + return (0); +} + +static __inline__ int write_sector_28sf040(volatile char *bios, + unsigned char *src, + volatile unsigned char *dst, + unsigned int page_size) +{ + int i; + + for (i = 0; i < page_size; i++) { + /* transfer data from source to destination */ + if (*src == 0xFF) { + dst++, src++; + /* If the data is 0xFF, don't program it */ + continue; + } + /*issue AUTO PROGRAM command */ + *dst = AUTO_PGRM; + *dst++ = *src++; + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + } + + return (0); +} + +int probe_28sf040(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + unsigned char id1, id2, tmp; + + /* save the value at the beginning of the Flash */ + tmp = *bios; + + *bios = RESET; + myusec_delay(10); + + *bios = READ_ID; + myusec_delay(10); + id1 = *(volatile unsigned char *) bios; + myusec_delay(10); + id2 = *(volatile unsigned char *) (bios + 0x01); + + *bios = RESET; + myusec_delay(10); + + printf("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2); + if (id1 == flash->manufacture_id && id2 == flash->model_id) + return 1; + + /* if there is no SST28SF040, restore the original value */ + *bios = tmp; + return 0; +} + +int erase_28sf040(struct flashchip *flash) +{ + volatile char *bios = flash->virt_addr; + + unprotect_28sf040(bios); + *bios = CHIP_ERASE; + *bios = CHIP_ERASE; + protect_28sf040(bios); + + myusec_delay(10); + toggle_ready_jedec(bios); + + return (0); +} + +int write_28sf040(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + unprotect_28sf040(bios); + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + /* erase the page before programming */ + erase_sector_28sf040(bios, i * page_size); + + /* write to the sector */ + printf("%04d at address: 0x%08x", i, i * page_size); + write_sector_28sf040(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + + protect_28sf040(bios); + + return (0); +} diff --git a/util/flashrom/sst28sf040.h b/util/flashrom/sst28sf040.h new file mode 100644 index 0000000000..ca57eff1ec --- /dev/null +++ b/util/flashrom/sst28sf040.h @@ -0,0 +1,8 @@ +#ifndef __SST28SF040_H__ +#define __SST28SF040_H__ + +extern int probe_28sf040(struct flashchip *flash); +extern int erase_28sf040(struct flashchip *flash); +extern int write_28sf040(struct flashchip *flash, unsigned char *buf); + +#endif /* !__SST28SF040_H__ */ diff --git a/util/flashrom/sst39sf020.c b/util/flashrom/sst39sf020.c new file mode 100644 index 0000000000..97e87a1c56 --- /dev/null +++ b/util/flashrom/sst39sf020.c @@ -0,0 +1,71 @@ +/* + * sst39sf020.c: driver for SST28SF040C flash models. + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * 4 MEgabit (512K x 8) SuperFlash EEPROM, SST28SF040 data sheet + * + * ToDo: Consilidated to standard JEDEC code. + * + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" +#include "sst39sf020.h" + +#define AUTO_PG_ERASE1 0x20 +#define AUTO_PG_ERASE2 0xD0 + +static __inline__ int erase_sector_39sf020(volatile char *bios, + unsigned long address) +{ + *bios = AUTO_PG_ERASE1; + *(bios + address) = AUTO_PG_ERASE2; + + /* wait for Toggle bit ready */ + toggle_ready_jedec(bios); + + return (0); +} + +int write_39sf020(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + erase_chip_jedec(flash); + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + /* write to the sector */ + printf("%04d at address: 0x%08x", i, i * page_size); + write_sector_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + fflush(stdout); + } + printf("\n"); + + return (0); +} diff --git a/util/flashrom/sst39sf020.h b/util/flashrom/sst39sf020.h new file mode 100644 index 0000000000..698814c3e7 --- /dev/null +++ b/util/flashrom/sst39sf020.h @@ -0,0 +1,7 @@ +#ifndef __SST39SF020_H__ +#define __SST39SF020_H__ 1 + +extern int probe_39sf020(struct flashchip *flash); +extern int write_39sf020(struct flashchip *flash, unsigned char *buf); + +#endif /* !__SST39SF020_H__ */ diff --git a/util/flashrom/sst49lf040.c b/util/flashrom/sst49lf040.c new file mode 100644 index 0000000000..f19b91e1c2 --- /dev/null +++ b/util/flashrom/sst49lf040.c @@ -0,0 +1,72 @@ +/* sst40lf020.c: driver for SST40LF040 flash models. + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * 4 MEgabit (512K x 8) SuperFlash EEPROM, SST49lF040 data sheet + * + * ToDo: Consilidated to standard JEDEC code. + * + * $Id$ + */ +#include <stdio.h> +#include "flash.h" +#include "jedec.h" +#include "sst49lf040.h" + +int erase_49lf040(struct flashchip *flash) +{ + int i; + int total_size = flash->total_size * 1024; + int page_size = flash->page_size; + volatile char *bios = flash->virt_addr; + + for (i = 0; i < total_size / page_size; i++) { + /* Chip erase only works in parallel programming mode + * for the 49lf040. Use sector-erase instead */ + erase_sector_jedec(bios, i * page_size); + } + return 0; +} + +int write_49lf040(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024; + int page_size = flash->page_size; + volatile char *bios = flash->virt_addr; + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + /* erase the page before programming + * Chip erase only works in parallel programming mode + * for the 49lf040. Use sector-erase instead */ + erase_sector_jedec(bios, i * page_size); + + /* write to the sector */ + printf("%04d at address: 0x%08x ", i, i * page_size); + write_sector_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + fflush(stdout); + } + printf("\n"); + + return (0); +} diff --git a/util/flashrom/sst49lf040.h b/util/flashrom/sst49lf040.h new file mode 100644 index 0000000000..79dfec99f2 --- /dev/null +++ b/util/flashrom/sst49lf040.h @@ -0,0 +1,7 @@ +#ifndef __SST49LF040_H__ +#define __SST49LF040_H__ 1 + +extern int erase_49lf040(struct flashchip *flash); +extern int write_49lf040(struct flashchip *flash, unsigned char *buf); + +#endif /* !__SST49LF040_H__ */ diff --git a/util/flashrom/sst_fwhub.c b/util/flashrom/sst_fwhub.c new file mode 100644 index 0000000000..c064ed661b --- /dev/null +++ b/util/flashrom/sst_fwhub.c @@ -0,0 +1,114 @@ +/* + * adapted from the Intel FW hub stuff for 82802ax parts. + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * $Id$ + */ + +#include <errno.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <sys/io.h> +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> + +#include "flash.h" +#include "jedec.h" +#include "sst_fwhub.h" + +// I need that Berkeley bit-map printer +void print_sst_fwhub_status(unsigned char status) +{ + printf("%s", status & 0x80 ? "Ready:" : "Busy:"); + printf("%s", status & 0x40 ? "BE SUSPEND:" : "BE RUN/FINISH:"); + printf("%s", status & 0x20 ? "BE ERROR:" : "BE OK:"); + printf("%s", status & 0x10 ? "PROG ERR:" : "PROG OK:"); + printf("%s", status & 0x8 ? "VP ERR:" : "VPP OK:"); + printf("%s", status & 0x4 ? "PROG SUSPEND:" : "PROG RUN/FINISH:"); + printf("%s", status & 0x2 ? "WP|TBL#|WP#,ABORT:" : "UNLOCK:"); +} + +/* probe_jedec works fine for probing */ +int probe_sst_fwhub(struct flashchip *flash) +{ + volatile unsigned char *bios; + size_t size = flash->total_size * 1024; + + if (probe_jedec(flash) == 0) + return 0; + + bios = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED, + flash->fd_mem, (off_t) (0xFFFFFFFF - 0x400000 - size + 1)); + if (bios == MAP_FAILED) { + // it's this part but we can't map it ... + perror("Error MMAP /dev/mem"); + exit(1); + } + + flash->virt_addr_2 = bios; + return 1; +} + +int erase_sst_fwhub_block(struct flashchip *flash, int offset) +{ + volatile unsigned char *wrprotect = flash->virt_addr_2 + offset + 2; + + // clear write protect + *(wrprotect) = 0; + + erase_block_jedec(flash->virt_addr, offset); + toggle_ready_jedec(flash->virt_addr); + + return (0); +} + +int erase_sst_fwhub(struct flashchip *flash) +{ + int i; + unsigned int total_size = flash->total_size * 1024; + + for (i = 0; i < total_size; i += flash->page_size) + erase_sst_fwhub_block(flash, i); + return (0); +} + +int write_sst_fwhub(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile unsigned char *bios = flash->virt_addr; + + erase_sst_fwhub(flash); + if (*bios != 0xff) { + printf("ERASE FAILED\n"); + return -1; + } + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + printf("%04d at address: 0x%08x", i, i * page_size); + write_sector_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + } + printf("\n"); + return (0); +} diff --git a/util/flashrom/sst_fwhub.h b/util/flashrom/sst_fwhub.h new file mode 100644 index 0000000000..eb2b364e62 --- /dev/null +++ b/util/flashrom/sst_fwhub.h @@ -0,0 +1,8 @@ +#ifndef __SST_FWHUB_H__ +#define __SST_FWHUB_H__ 1 + +extern int probe_sst_fwhub(struct flashchip *flash); +extern int erase_sst_fwhub(struct flashchip *flash); +extern int write_sst_fwhub(struct flashchip *flash, unsigned char *buf); + +#endif /* !__SST_FWHUB_H__ */ diff --git a/util/flashrom/udelay.c b/util/flashrom/udelay.c new file mode 100644 index 0000000000..30b8dde261 --- /dev/null +++ b/util/flashrom/udelay.c @@ -0,0 +1,37 @@ +#include <sys/time.h> +#include <stdio.h> + +// count to a billion. Time it. If it's < 1 sec, count to 10B, etc. +unsigned long micro = 1; + +void myusec_delay(int time) +{ + volatile unsigned long i; + for (i = 0; i < time * micro; i++); +} + +void myusec_calibrate_delay() +{ + int count = 1000; + unsigned long timeusec; + struct timeval start, end; + int ok = 0; + + printf("Setting up microsecond timing loop\n"); + while (!ok) { + gettimeofday(&start, 0); + myusec_delay(count); + gettimeofday(&end, 0); + timeusec = 1000000 * (end.tv_sec - start.tv_sec) + + (end.tv_usec - start.tv_usec); + count *= 2; + if (timeusec < 1000000 / 4) + continue; + ok = 1; + } + + // compute one microsecond. That will be count / time + micro = count / timeusec; + + fprintf(stderr, "%ldM loops per second\n", (unsigned long) micro); +} diff --git a/util/flashrom/w49f002u.c b/util/flashrom/w49f002u.c new file mode 100644 index 0000000000..02667cf1a0 --- /dev/null +++ b/util/flashrom/w49f002u.c @@ -0,0 +1,56 @@ +/* + * w49f002u.c: driver for Winbond 49F002U flash models + * + * + * Copyright 2000 Silicon Integrated System Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * + * Reference: + * W49F002U data sheet + * + * ToDo: Consilidated to standard JEDEC code. + * + * $Id$ + */ + +#include <stdio.h> +#include "flash.h" +#include "jedec.h" +#include "w49f002u.h" + +int write_49f002(struct flashchip *flash, unsigned char *buf) +{ + int i; + int total_size = flash->total_size * 1024, page_size = + flash->page_size; + volatile char *bios = flash->virt_addr; + + erase_chip_jedec(flash); + + printf("Programming Page: "); + for (i = 0; i < total_size / page_size; i++) { + /* write to the sector */ + printf("%04d at address: 0x%08x ", i, i * page_size); + write_sector_jedec(bios, buf + i * page_size, + bios + i * page_size, page_size); + printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); + fflush(stdout); + } + printf("\n"); + + return (0); +} diff --git a/util/flashrom/w49f002u.h b/util/flashrom/w49f002u.h new file mode 100644 index 0000000000..29320b7cef --- /dev/null +++ b/util/flashrom/w49f002u.h @@ -0,0 +1,6 @@ +#ifndef __W49F002U_H__ +#define __W49F002U_H__ 1 + +extern int write_49f002(struct flashchip *flash, unsigned char *buf); + +#endif /* !__W49F002U_H__ */ |