util/flashrom/82802ab.c

   1 /*
   2  * 82802ab.c: driver for programming JEDEC standard flash parts
   3  *
   4  *
   5  * Copyright 2000 Silicon Integrated System Corporation
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *
  22  * Reference: http://www.intel.com/design/chipsets/datashts/290658.htm
  23  *
  24  */
  25
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <sys/mman.h>
  29 #include <sys/io.h>
  30 #include <unistd.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33
  34 #include "flash.h"
  35 #include "82802ab.h"
  36 #include "debug.h"
  37
  38 // I need that Berkeley bit-map printer
  39 void print_82802ab_status(uint8_t status)
  40 {
  41         printf("%s", status & 0x80 ? "Ready:" : "Busy:");
  42         printf("%s", status & 0x40 ? "BE SUSPEND:" : "BE RUN/FINISH:");
  43         printf("%s", status & 0x20 ? "BE ERROR:" : "BE OK:");
  44         printf("%s", status & 0x10 ? "PROG ERR:" : "PROG OK:");
  45         printf("%s", status & 0x8 ? "VP ERR:" : "VPP OK:");
  46         printf("%s", status & 0x4 ? "PROG SUSPEND:" : "PROG RUN/FINISH:");
  47         printf("%s", status & 0x2 ? "WP|TBL#|WP#,ABORT:" : "UNLOCK:");
  48 }
  49
  50 int probe_82802ab(struct flashchip *flash)
  51 {
  52         volatile uint8_t *bios = flash->virt_addr;
  53         uint8_t id1, id2;
  54
  55 #if 0
  56         *(volatile uint8_t *) (bios + 0x5555) = 0xAA;
  57         *(volatile uint8_t *) (bios + 0x2AAA) = 0x55;
  58         *(volatile uint8_t *) (bios + 0x5555) = 0x90;
  59 #endif
  60
  61         *bios = 0xff;
  62         myusec_delay(10);
  63         *bios = 0x90;
  64         myusec_delay(10);
  65
  66         id1 = *(volatile uint8_t *) bios;
  67         id2 = *(volatile uint8_t *) (bios + 0x01);
  68
  69 #if 1
  70         *(volatile uint8_t *) (bios + 0x5555) = 0xAA;
  71         *(volatile uint8_t *) (bios + 0x2AAA) = 0x55;
  72         *(volatile uint8_t *) (bios + 0x5555) = 0xF0;
  73
  74 #endif
  75         myusec_delay(10);
  76
  77         printf_debug("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2);
  78
  79         if (id1 == flash->manufacture_id && id2 == flash->model_id) {
  80                 size_t size = flash->total_size * 1024;
  81                 // we need to mmap the write-protect space.
  82                 bios = mmap(0, size, PROT_WRITE | PROT_READ, MAP_SHARED,
  83                             flash->fd_mem, (off_t) (0 - 0x400000 - size));
  84                 if (bios == MAP_FAILED) {
  85                         // it's this part but we can't map it ...
  86                         perror("Error MMAP /dev/mem");
  87                         exit(1);
  88                 }
  89
  90                 flash->virt_addr_2 = bios;
  91                 return 1;
  92         }
  93
  94         return 0;
  95 }
  96
  97 uint8_t wait_82802ab(volatile uint8_t *bios)
  98 {
  99
 100         uint8_t status;
 101         uint8_t id1, id2;
 102
 103         *bios = 0x70;
 104         if ((*bios & 0x80) == 0) {      // it's busy
 105                 while ((*bios & 0x80) == 0);
 106         }
 107
 108         status = *bios;
 109
 110         // put another command to get out of status register mode
 111
 112         *bios = 0x90;
 113         myusec_delay(10);
 114
 115         id1 = *(volatile uint8_t *) bios;
 116         id2 = *(volatile uint8_t *) (bios + 0x01);
 117
 118         // this is needed to jam it out of "read id" mode
 119         *(volatile uint8_t *) (bios + 0x5555) = 0xAA;
 120         *(volatile uint8_t *) (bios + 0x2AAA) = 0x55;
 121         *(volatile uint8_t *) (bios + 0x5555) = 0xF0;
 122         return status;
 123
 124 }
 125 int erase_82802ab_block(struct flashchip *flash, int offset)
 126 {
 127         volatile uint8_t *bios = flash->virt_addr + offset;
 128         volatile uint8_t *wrprotect =
 129             flash->virt_addr_2 + offset + 2;
 130         uint8_t status;
 131
 132         // clear status register
 133         *bios = 0x50;
 134         //printf("Erase at %p\n", bios);
 135         // clear write protect
 136         //printf("write protect is at %p\n", (wrprotect));
 137         //printf("write protect is 0x%x\n", *(wrprotect));
 138         *(wrprotect) = 0;
 139         //printf("write protect is 0x%x\n", *(wrprotect));
 140
 141         // now start it
 142         *(volatile uint8_t *) (bios) = 0x20;
 143         *(volatile uint8_t *) (bios) = 0xd0;
 144         myusec_delay(10);
 145         // now let's see what the register is
 146         status = wait_82802ab(flash->virt_addr);
 147         //print_82802ab_status(status);
 148         printf("DONE BLOCK 0x%x\n", offset);
 149         return (0);
 150 }
 151 int erase_82802ab(struct flashchip *flash)
 152 {
 153         int i;
 154         unsigned int total_size = flash->total_size * 1024;
 155
 156         printf("total_size is %d; flash->page_size is %d\n",
 157                total_size, flash->page_size);
 158         for (i = 0; i < total_size; i += flash->page_size)
 159                 erase_82802ab_block(flash, i);
 160         printf("DONE ERASE\n");
 161         return (0);
 162 }
 163
 164 void write_page_82802ab(volatile uint8_t *bios, uint8_t *src, volatile uint8_t *dst,
 165                         int page_size)
 166 {
 167         int i;
 168
 169         for (i = 0; i < page_size; i++) {
 170                 /* transfer data from source to destination */
 171                 *dst = 0x40;
 172                 *dst++ = *src++;
 173                 wait_82802ab(bios);
 174         }
 175
 176 }
 177
 178 int write_82802ab(struct flashchip *flash, uint8_t *buf)
 179 {
 180         int i;
 181         int total_size = flash->total_size * 1024, page_size =
 182             flash->page_size;
 183         volatile uint8_t *bios = flash->virt_addr;
 184
 185         erase_82802ab(flash);
 186         if (*bios != 0xff) {
 187                 printf("ERASE FAILED\n");
 188                 return -1;
 189         }
 190         printf("Programming Page: ");
 191         for (i = 0; i < total_size / page_size; i++) {
 192                 printf("%04d at address: 0x%08x", i, i * page_size);
 193                 write_page_82802ab(bios, buf + i * page_size,
 194                                    bios + i * page_size, page_size);
 195                 printf
 196                     ("\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");
 197         }
 198         printf("\n");
 199         protect_82802ab(bios);
 200         return (0);
 201 }