417 lines
9.7 KiB
C
417 lines
9.7 KiB
C
/* $Id:
|
|
*
|
|
* Portions of this program which I authored may be used for any purpose
|
|
* so long as this notice is left intact.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "flashintelc3.h"
|
|
#include "flash_filter.h"
|
|
#include <stdint.h>
|
|
|
|
#if HOST_FLASHING
|
|
# include <stdio.h>
|
|
# include <BDMlib.h>
|
|
# include <string.h>
|
|
#endif
|
|
|
|
|
|
typedef struct
|
|
{
|
|
const char *name;
|
|
const uint32_t manufacturer, device_id;
|
|
const uint32_t size; /* in bytes */
|
|
const uint32_t num_sectors;
|
|
const uint32_t top;
|
|
} chip_t;
|
|
|
|
/*
|
|
* Warning! do not change this struct without changing the download_struct
|
|
* function.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint32_t flash_address;
|
|
uint32_t flash_size;
|
|
uint32_t num_sectors;
|
|
uint32_t top;
|
|
} chiptype_t;
|
|
|
|
static const chip_t chips[] = {
|
|
{"28F800C3T", 0x0089, 0x88C0, 0x100000, 23, 1}, /* INTEL */
|
|
{"28F800C3B", 0x0089, 0x88C1, 0x100000, 23, 0}, /* INTEL */
|
|
{"28F160C3T", 0x0089, 0x88C2, 0x200000, 39, 1}, /* INTEL */
|
|
{"28F160C3B", 0x0089, 0x88C3, 0x200000, 39, 0}, /* INTEL */
|
|
{"28F320C3T", 0x0089, 0x88C4, 0x400000, 71, 1}, /* INTEL */
|
|
{"28F320C3B", 0x0089, 0x88C5, 0x400000, 71, 0}, /* INTEL */
|
|
{"28F640C3T", 0x0089, 0x88CC, 0x800000, 135, 1}, /* INTEL */
|
|
{"28F640C3B", 0x0089, 0x88CD, 0x800000, 135, 0}, /* INTEL */
|
|
};
|
|
|
|
#if HOST_FLASHING
|
|
|
|
# define DEFINE_READ_FUNC(funcname,vartype,bdmfunc) \
|
|
static uint32_t funcname (uint32_t adr) { \
|
|
vartype val; \
|
|
if (bdmfunc (adr, &val) < 0) \
|
|
fprintf (stderr, #bdmfunc "(0x%08lx,xxx): %s\n", \
|
|
adr, bdmErrorString()); \
|
|
return (uint32_t) val; \
|
|
}
|
|
|
|
# define DEFINE_WRITE_FUNC(funcname,vartype,bdmfunc) \
|
|
static void funcname (uint32_t adr, uint32_t val) { \
|
|
if (bdmfunc (adr, val) < 0) \
|
|
fprintf (stderr, #bdmfunc "(0x%08lx,0x%08x): %s\n", \
|
|
adr, val, bdmErrorString()); \
|
|
}
|
|
|
|
#else
|
|
|
|
# define DEFINE_READ_FUNC(funcname,vartype,bdmfunc) \
|
|
static uint32_t funcname (uint32_t adr) { \
|
|
return *(volatile vartype *)adr; \
|
|
}
|
|
|
|
# define DEFINE_WRITE_FUNC(funcname,vartype,bdmfunc) \
|
|
static void funcname (uint32_t adr,uint32_t val) { \
|
|
*(volatile vartype *)adr = val; \
|
|
}
|
|
|
|
#endif
|
|
|
|
static inline uint16_t
|
|
swap16(uint16_t a_v)
|
|
{
|
|
return (uint16_t) (((a_v >> 8) & 0x00ff) | ((a_v << 8) & 0xff00));
|
|
}
|
|
|
|
static inline int
|
|
is_little_endian(void)
|
|
{
|
|
uint32_t i = 1;
|
|
return (int) *((uint8_t *) &i);
|
|
}
|
|
|
|
DEFINE_READ_FUNC(chip_rd_word, unsigned short, bdmReadWord)
|
|
DEFINE_WRITE_FUNC(chip_wr_word, uint16_t, bdmWriteWord)
|
|
|
|
/* We need a unique symbol to associate a (target-based) plugin with its
|
|
(host-based) driver.
|
|
*/
|
|
static char driver_magic[] = "flashintelc3";
|
|
|
|
#if HOST_FLASHING
|
|
static char *
|
|
prog_entry(void)
|
|
{
|
|
return "flashintelc3_prog";
|
|
}
|
|
#endif
|
|
|
|
static uint32_t
|
|
flashintelc3_sector_size(chiptype_t* chip, int sector)
|
|
{
|
|
if(chip->top) {
|
|
if(sector < (chip->num_sectors - 8)) {
|
|
return 0x10000;
|
|
}
|
|
else {
|
|
return 0x2000;
|
|
}
|
|
}
|
|
else {
|
|
if(sector < 8) {
|
|
return 0x2000;
|
|
}
|
|
else {
|
|
return 0x10000;
|
|
}
|
|
}
|
|
}
|
|
|
|
static uint32_t
|
|
flashintelc3_sector_offset(chiptype_t* chip, int sector)
|
|
{
|
|
if(chip->top) {
|
|
uint32_t d = chip->num_sectors - 8;
|
|
if(sector < d) {
|
|
return 0x10000 * sector;
|
|
}
|
|
else {
|
|
return (0x10000 * d) + (0x2000 * (sector - d));
|
|
}
|
|
}
|
|
else {
|
|
if(sector < 8) {
|
|
return 0x2000 * sector;
|
|
}
|
|
else {
|
|
return 0x10000 + (0x10000 * (sector - 8));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 0=unlock, 1=lock */
|
|
static void
|
|
flashintelc3_lock(void *chip_descr, uint32_t start, uint32_t bytes, int cmd)
|
|
{
|
|
chiptype_t *ct = (chiptype_t *) chip_descr;
|
|
int i, s = 0, e = 0;
|
|
int ucmd = (cmd) ? 0x01 : 0xD0;
|
|
|
|
if(bytes == 0)
|
|
return;
|
|
|
|
/* find start sector */
|
|
for(i = 0; i < ct->num_sectors; ++i) {
|
|
uint32_t off = flashintelc3_sector_offset(ct, i);
|
|
uint32_t size = flashintelc3_sector_size(ct, i);
|
|
if((start >= ct->flash_address + off) &&
|
|
(start < ct->flash_address + off + size)) {
|
|
s = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* find end */
|
|
for(; i < ct->num_sectors; ++i) {
|
|
uint32_t off = flashintelc3_sector_offset(ct, i);
|
|
uint32_t size = flashintelc3_sector_size(ct, i);
|
|
if(start + bytes <= ct->flash_address + off + size) {
|
|
e = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* unlock range */
|
|
for(i = s; i <= e; ++i) {
|
|
uint32_t off = flashintelc3_sector_offset(ct, i);
|
|
chip_wr_word(ct->flash_address + off, 0x60);
|
|
chip_wr_word(ct->flash_address + off, ucmd);
|
|
}
|
|
}
|
|
|
|
/* The actual programming function.
|
|
* NOTE: pos and cnt need to be 2 byte aligned!
|
|
*/
|
|
static uint32_t
|
|
flashintelc3_prog(void *chip_descr,
|
|
uint32_t pos, unsigned char *data, uint32_t cnt)
|
|
{
|
|
chiptype_t *ct = (chiptype_t *) chip_descr;
|
|
uint32_t n = 0;
|
|
uint16_t status;
|
|
|
|
flashintelc3_lock(ct, pos, cnt, 0);
|
|
|
|
cnt /= 2;
|
|
for (n = 0; n < cnt; ++n) {
|
|
uint16_t d = ((uint16_t *) (void*) data)[n];
|
|
|
|
chip_wr_word(pos, 0x40);
|
|
|
|
/* write_word on host assumes host endianess so will perform a
|
|
* byte order swap if host is little endian. we need to swap if little
|
|
* endian such that the swap will just swap back to the correct endianess
|
|
*/
|
|
if(is_little_endian())
|
|
d = swap16(d);
|
|
chip_wr_word(pos, d);
|
|
|
|
/*
|
|
* Wait for program operation to finish
|
|
*/
|
|
do {
|
|
chip_wr_word(pos, 0x70);
|
|
status = chip_rd_word(pos);
|
|
}
|
|
while (!(status & 0x80));
|
|
|
|
pos += 2;
|
|
}
|
|
|
|
chip_wr_word(ct->flash_address, 0xff);
|
|
|
|
return n * 2;
|
|
}
|
|
|
|
static void
|
|
flashintelc3_erase(void *chip_descr, int32_t sector_address)
|
|
{
|
|
chiptype_t *ct = (chiptype_t *) chip_descr;
|
|
uint16_t status;
|
|
int i;
|
|
#if HOST_FLASHING
|
|
int spin = 0;
|
|
#endif
|
|
|
|
if(sector_address == -1) {
|
|
flashintelc3_lock(ct, ct->flash_address, ct->flash_size, 0);
|
|
|
|
/* erasing all sectors */
|
|
for(i = 0; i < ct->num_sectors; ++i) {
|
|
uint32_t off = flashintelc3_sector_offset(ct, i);
|
|
|
|
chip_wr_word(ct->flash_address + off, 0x20);
|
|
chip_wr_word(ct->flash_address + off, 0xD0);
|
|
|
|
/* wait */
|
|
do {
|
|
chip_wr_word(ct->flash_address + off, 0x70);
|
|
status = chip_rd_word(ct->flash_address + off);
|
|
#if HOST_FLASHING
|
|
spin = flash_spin(spin);
|
|
#endif
|
|
} while(!(status & 0x80));
|
|
}
|
|
}
|
|
else {
|
|
uint32_t off = flashintelc3_sector_offset(ct, sector_address);
|
|
flashintelc3_lock(ct, ct->flash_address + off, 1, 0);
|
|
|
|
/* erasing said sector address */
|
|
chip_wr_word(ct->flash_address + off, 0x20);
|
|
chip_wr_word(ct->flash_address + off, 0xD0);
|
|
|
|
/* wait */
|
|
do {
|
|
chip_wr_word(ct->flash_address + off, 0x70);
|
|
status = chip_rd_word(ct->flash_address + off);
|
|
#if HOST_FLASHING
|
|
spin = flash_spin(spin);
|
|
#endif
|
|
} while(!(status & 0x80));
|
|
}
|
|
|
|
chip_wr_word(ct->flash_address, 0xff);
|
|
}
|
|
|
|
/* Blank check operation. Sector address is relative to chip-base.
|
|
With sector address==-1, the whole chip is checked.
|
|
*/
|
|
static int
|
|
flashintelc3_blank_chk(void *chip_descr, int32_t sector_address)
|
|
{
|
|
#if HOST_FLASHING
|
|
printf("intelc3: blank_chk not implemented!\n");
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* wait for queued erasing operations to finish
|
|
*/
|
|
static int
|
|
flashintelc3_erase_wait(void *chip_descr)
|
|
{
|
|
#if HOST_FLASHING
|
|
printf("intelc3: no wait needed!\n");
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if HOST_FLASHING
|
|
|
|
# ifndef NUMOF
|
|
# define NUMOF(ary) (sizeof(ary)/sizeof(ary[0]))
|
|
# endif
|
|
|
|
/* autodetect
|
|
*/
|
|
static uint32_t
|
|
flashintelc3_search_chip(void *chip_descr, char *description, uint32_t pos)
|
|
{
|
|
uint32_t size = 0;
|
|
uint32_t m, d;
|
|
chiptype_t *ct = (chiptype_t *) chip_descr;
|
|
const chip_t *chip;
|
|
int i;
|
|
|
|
/* read the manufacturer id */
|
|
chip_wr_word(pos, 0x90);
|
|
m = chip_rd_word(pos + 0);
|
|
|
|
/* read the device id */
|
|
chip_wr_word(pos, 0x90);
|
|
d = chip_rd_word(pos + 2);
|
|
|
|
/* find our device */
|
|
for (i = 0; i < NUMOF(chips); i++) {
|
|
chip = &chips[i];
|
|
if(chip->manufacturer == m && chip->device_id == d) {
|
|
ct->flash_address = pos;
|
|
ct->flash_size = chip->size;
|
|
ct->num_sectors = chip->num_sectors;
|
|
ct->top = chip->top;
|
|
size = chip->size;
|
|
|
|
if (description) {
|
|
sprintf(description, "%10s @ 0x%08lx..0x%08lx "
|
|
"manuf:0x%02lx device:0x%04lx size:0x%08lx",
|
|
chip->name, pos, pos + chip->size, m, d, chip->size);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* put the device back into read mode */
|
|
chip_wr_word(pos, 0xff);
|
|
|
|
return size;
|
|
}
|
|
|
|
static int
|
|
download_struct(void *chip_descr, uint32_t adr)
|
|
{
|
|
chiptype_t *ct = (chiptype_t *) chip_descr;
|
|
|
|
bdmWriteLongWord(adr, ct->flash_address);
|
|
adr += 4;
|
|
bdmWriteLongWord(adr, ct->flash_size);
|
|
adr += 4;
|
|
bdmWriteLongWord(adr, ct->num_sectors);
|
|
adr += 4;
|
|
bdmWriteLongWord(adr, ct->top);
|
|
adr += 4;
|
|
|
|
return adr;
|
|
}
|
|
|
|
void
|
|
init_flashintelc3(int num)
|
|
{
|
|
register_algorithm(num, driver_magic, sizeof(chiptype_t),
|
|
download_struct,
|
|
flashintelc3_search_chip,
|
|
flashintelc3_erase,
|
|
flashintelc3_blank_chk,
|
|
flashintelc3_erase_wait, flashintelc3_prog, prog_entry);
|
|
}
|
|
|
|
#else
|
|
|
|
void
|
|
init_flashintelc3(int num)
|
|
{
|
|
register_algorithm(num, driver_magic, 0,
|
|
0,
|
|
0,
|
|
flashintelc3_erase,
|
|
flashintelc3_blank_chk,
|
|
flashintelc3_erase_wait, flashintelc3_prog, 0);
|
|
}
|
|
|
|
#endif
|