util/flashrom/82802ab.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2000 Silicon Integrated System Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 /*
  22  * Datasheet:
  23  *  - Name: Intel 82802AB/82802AC Firmware Hub (FWH)
  24  *  - URL: http://www.intel.com/design/chipsets/datashts/290658.htm
  25  *  - PDF: http://download.intel.com/design/chipsets/datashts/29065804.pdf
  26  *  - Order number: 290658-004
  27  */
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdint.h>
  32 #include "flash.h"
  33
  34 // I need that Berkeley bit-map printer
  35 void print_82802ab_status(uint8_t status)
  36 {
  37         printf("%s", status & 0x80 ? "Ready:" : "Busy:");
  38         printf("%s", status & 0x40 ? "BE SUSPEND:" : "BE RUN/FINISH:");
  39         printf("%s", status & 0x20 ? "BE ERROR:" : "BE OK:");
  40         printf("%s", status & 0x10 ? "PROG ERR:" : "PROG OK:");
  41         printf("%s", status & 0x8 ? "VP ERR:" : "VPP OK:");
  42         printf("%s", status & 0x4 ? "PROG SUSPEND:" : "PROG RUN/FINISH:");
  43         printf("%s", status & 0x2 ? "WP|TBL#|WP#,ABORT:" : "UNLOCK:");
  44 }
  45
  46 int probe_82802ab(struct flashchip *flash)
  47 {
  48         volatile uint8_t *bios = flash->virtual_memory;
  49         uint8_t id1, id2;
  50
  51 #if 0
  52         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
  53         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
  54         *(volatile uint8_t *)(bios + 0x5555) = 0x90;
  55 #endif
  56
  57         *bios = 0xff;
  58         myusec_delay(10);
  59         *bios = 0x90;
  60         myusec_delay(10);
  61
  62         id1 = *(volatile uint8_t *)bios;
  63         id2 = *(volatile uint8_t *)(bios + 0x01);
  64
  65         /* Leave ID mode */
  66         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
  67         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
  68         *(volatile uint8_t *)(bios + 0x5555) = 0xF0;
  69
  70         myusec_delay(10);
  71
  72         printf_debug("%s: id1 0x%02x, id2 0x%02x\n", __FUNCTION__, id1, id2);
  73
  74         if (id1 != flash->manufacture_id || id2 != flash->model_id)
  75                 return 0;
  76
  77         map_flash_registers(flash);
  78
  79         return 1;
  80 }
  81
  82 uint8_t wait_82802ab(volatile uint8_t *bios)
  83 {
  84         uint8_t status;
  85         uint8_t id1, id2;
  86
  87         *bios = 0x70;
  88         if ((*bios & 0x80) == 0) {      // it's busy
  89                 while ((*bios & 0x80) == 0) ;
  90         }
  91
  92         status = *bios;
  93
  94         // put another command to get out of status register mode
  95
  96         *bios = 0x90;
  97         myusec_delay(10);
  98
  99         id1 = *(volatile uint8_t *)bios;
 100         id2 = *(volatile uint8_t *)(bios + 0x01);
 101
 102         // this is needed to jam it out of "read id" mode
 103         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
 104         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
 105         *(volatile uint8_t *)(bios + 0x5555) = 0xF0;
 106
 107         return status;
 108 }
 109
 110 int erase_82802ab_block(struct flashchip *flash, int offset)
 111 {
 112         volatile uint8_t *bios = flash->virtual_memory + offset;
 113         volatile uint8_t *wrprotect = flash->virtual_registers + offset + 2;
 114         int j;
 115         uint8_t status;
 116
 117         // clear status register
 118         *bios = 0x50;
 119         //printf("Erase at %p\n", bios);
 120         // clear write protect
 121         //printf("write protect is at %p\n", (wrprotect));
 122         //printf("write protect is 0x%x\n", *(wrprotect));
 123         *(wrprotect) = 0;
 124         //printf("write protect is 0x%x\n", *(wrprotect));
 125
 126         // now start it
 127         *(volatile uint8_t *)(bios) = 0x20;
 128         *(volatile uint8_t *)(bios) = 0xd0;
 129         myusec_delay(10);
 130         // now let's see what the register is
 131         status = wait_82802ab(flash->virtual_memory);
 132         //print_82802ab_status(status);
 133         for (j = 0; j < flash->page_size; j++) {
 134                 if (*(bios + j) != 0xFF) {
 135                         printf("BLOCK ERASE failed at 0x%x\n", offset);
 136                         return -1;
 137                 }
 138         }
 139         printf("DONE BLOCK 0x%x\n", offset);
 140
 141         return 0;
 142 }
 143
 144 int erase_82802ab(struct flashchip *flash)
 145 {
 146         int i;
 147         unsigned int total_size = flash->total_size * 1024;
 148
 149         printf("total_size is %d; flash->page_size is %d\n",
 150                total_size, flash->page_size);
 151         for (i = 0; i < total_size; i += flash->page_size)
 152                 erase_82802ab_block(flash, i);
 153         printf("DONE ERASE\n");
 154
 155         return 0;
 156 }
 157
 158 void write_page_82802ab(volatile uint8_t *bios, uint8_t *src,
 159                         volatile uint8_t *dst, int page_size)
 160 {
 161         int i;
 162
 163         for (i = 0; i < page_size; i++) {
 164                 /* transfer data from source to destination */
 165                 *dst = 0x40;
 166                 *dst++ = *src++;
 167                 wait_82802ab(bios);
 168         }
 169 }
 170
 171 int write_82802ab(struct flashchip *flash, uint8_t *buf)
 172 {
 173         int i;
 174         int total_size = flash->total_size * 1024;
 175         int page_size = flash->page_size;
 176         volatile uint8_t *bios = flash->virtual_memory;
 177
 178         printf("Programming page: \n");
 179         for (i = 0; i < total_size / page_size; i++) {
 180                 printf
 181                     ("\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");
 182                 printf("%04d at address: 0x%08x", i, i * page_size);
 183
 184                 /* Auto Skip Blocks, which already contain the desired data
 185                  * Faster, because we only write, what has changed
 186                  * More secure, because blocks, which are excluded
 187                  * (with the exclude or layout feature)
 188                  * or not erased and rewritten; their data is retained also in
 189                  * sudden power off situations
 190                  */
 191                 if (!memcmp((void *)(buf + i * page_size),
 192                             (void *)(bios + i * page_size), page_size)) {
 193                         printf("SKIPPED\n");
 194                         continue;
 195                 }
 196
 197                 /* erase block by block and write block by block; this is the most secure way */
 198                 erase_82802ab_block(flash, i * page_size);
 199                 write_page_82802ab(bios, buf + i * page_size,
 200                                    bios + i * page_size, page_size);
 201         }
 202         printf("\n");
 203         protect_jedec(bios);
 204
 205         return 0;
 206 }