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