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 <stdio.h>
  27 #include <stdint.h>
  28 #include "flash.h"
  29
  30 // I need that Berkeley bit-map printer
  31 void print_82802ab_status(uint8_t status)
  32 {
  33         printf("%s", status & 0x80 ? "Ready:" : "Busy:");
  34         printf("%s", status & 0x40 ? "BE SUSPEND:" : "BE RUN/FINISH:");
  35         printf("%s", status & 0x20 ? "BE ERROR:" : "BE OK:");
  36         printf("%s", status & 0x10 ? "PROG ERR:" : "PROG OK:");
  37         printf("%s", status & 0x8 ? "VP ERR:" : "VPP OK:");
  38         printf("%s", status & 0x4 ? "PROG SUSPEND:" : "PROG RUN/FINISH:");
  39         printf("%s", status & 0x2 ? "WP|TBL#|WP#,ABORT:" : "UNLOCK:");
  40 }
  41
  42 int probe_82802ab(struct flashchip *flash)
  43 {
  44         volatile uint8_t *bios = flash->virtual_memory;
  45         uint8_t id1, id2;
  46
  47 #if 0
  48         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
  49         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
  50         *(volatile uint8_t *)(bios + 0x5555) = 0x90;
  51 #endif
  52
  53         *bios = 0xff;
  54         myusec_delay(10);
  55         *bios = 0x90;
  56         myusec_delay(10);
  57
  58         id1 = *(volatile uint8_t *)bios;
  59         id2 = *(volatile uint8_t *)(bios + 0x01);
  60
  61         /* Leave ID mode */
  62         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
  63         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
  64         *(volatile uint8_t *)(bios + 0x5555) = 0xF0;
  65
  66         myusec_delay(10);
  67
  68         printf_debug("%s: id1 0x%x, id2 0x%x\n", __FUNCTION__, id1, id2);
  69
  70         if (id1 != flash->manufacture_id || id2 != flash->model_id)
  71                 return 0;
  72
  73         map_flash_registers(flash);
  74
  75         return 1;
  76 }
  77
  78 uint8_t wait_82802ab(volatile uint8_t *bios)
  79 {
  80
  81         uint8_t status;
  82         uint8_t id1, id2;
  83
  84         *bios = 0x70;
  85         if ((*bios & 0x80) == 0) {      // it's busy
  86                 while ((*bios & 0x80) == 0) ;
  87         }
  88
  89         status = *bios;
  90
  91         // put another command to get out of status register mode
  92
  93         *bios = 0x90;
  94         myusec_delay(10);
  95
  96         id1 = *(volatile uint8_t *)bios;
  97         id2 = *(volatile uint8_t *)(bios + 0x01);
  98
  99         // this is needed to jam it out of "read id" mode
 100         *(volatile uint8_t *)(bios + 0x5555) = 0xAA;
 101         *(volatile uint8_t *)(bios + 0x2AAA) = 0x55;
 102         *(volatile uint8_t *)(bios + 0x5555) = 0xF0;
 103         return status;
 104
 105 }
 106 int erase_82802ab_block(struct flashchip *flash, int offset)
 107 {
 108         volatile uint8_t *bios = flash->virtual_memory + offset;
 109         volatile uint8_t *wrprotect = flash->virtual_registers + offset + 2;
 110         uint8_t status;
 111
 112         // clear status register
 113         *bios = 0x50;
 114         //printf("Erase at %p\n", bios);
 115         // clear write protect
 116         //printf("write protect is at %p\n", (wrprotect));
 117         //printf("write protect is 0x%x\n", *(wrprotect));
 118         *(wrprotect) = 0;
 119         //printf("write protect is 0x%x\n", *(wrprotect));
 120
 121         // now start it
 122         *(volatile uint8_t *)(bios) = 0x20;
 123         *(volatile uint8_t *)(bios) = 0xd0;
 124         myusec_delay(10);
 125         // now let's see what the register is
 126         status = wait_82802ab(flash->virtual_memory);
 127         //print_82802ab_status(status);
 128         printf("DONE BLOCK 0x%x\n", offset);
 129         return (0);
 130 }
 131 int erase_82802ab(struct flashchip *flash)
 132 {
 133         int i;
 134         unsigned int total_size = flash->total_size * 1024;
 135
 136         printf("total_size is %d; flash->page_size is %d\n",
 137                total_size, flash->page_size);
 138         for (i = 0; i < total_size; i += flash->page_size)
 139                 erase_82802ab_block(flash, i);
 140         printf("DONE ERASE\n");
 141         return (0);
 142 }
 143
 144 void write_page_82802ab(volatile uint8_t *bios, uint8_t *src,
 145                         volatile uint8_t *dst, int page_size)
 146 {
 147         int i;
 148
 149         for (i = 0; i < page_size; i++) {
 150                 /* transfer data from source to destination */
 151                 *dst = 0x40;
 152                 *dst++ = *src++;
 153                 wait_82802ab(bios);
 154         }
 155
 156 }
 157
 158 int write_82802ab(struct flashchip *flash, uint8_t *buf)
 159 {
 160         int i;
 161         int total_size = flash->total_size * 1024;
 162         int page_size = flash->page_size;
 163         volatile uint8_t *bios = flash->virtual_memory;
 164
 165         erase_82802ab(flash);
 166         if (*bios != 0xff) {
 167                 printf("ERASE FAILED\n");
 168                 return -1;
 169         }
 170         printf("Programming Page: ");
 171         for (i = 0; i < total_size / page_size; i++) {
 172                 printf("%04d at address: 0x%08x", i, i * page_size);
 173                 write_page_82802ab(bios, buf + i * page_size,
 174                                    bios + i * page_size, page_size);
 175                 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");
 176         }
 177         printf("\n");
 178         protect_jedec(bios);
 179         return (0);
 180 }