/* $NetBSD: flash_vrip.c,v 1.15 2023/09/12 19:32:00 andvar Exp $ */

/*
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Naoto Shimazaki of YOKOGAWA Electric Corporation.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Flash Memory Driver
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: flash_vrip.c,v 1.15 2023/09/12 19:32:00 andvar Exp $");

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/proc.h>
#include <sys/systm.h>

#include <machine/bus.h>

#include <hpcmips/vr/vripif.h>
#include <hpcmips/vr/cfireg.h>
#include <hpcmips/vr/flashreg.h>
#include <hpcmips/vr/flashvar.h>

#ifdef FLASH_DEBUG
int     flash_debug = 0;
#define DPRINTF(x)      if (flash_debug) printf x
#else
#define DPRINTF(x)
#endif

static int flash_probe(device_t, cfdata_t, void *);
static void flash_attach(device_t, device_t, void *);

const static struct flashops * find_command_set(u_int8_t cmdset0,
                                               u_int8_t cmdset1);
static int i28f128_probe(bus_space_tag_t, bus_space_handle_t);
static int mbm29160_probe(bus_space_tag_t, bus_space_handle_t);
static int is_block_same(struct flash_softc *, bus_size_t, const void *);
static int probe_cfi(bus_space_tag_t iot, bus_space_handle_t ioh);

static int intel_erase(struct flash_softc *, bus_size_t);
static int intel_write(struct flash_softc *, bus_size_t);
static int amd_erase(struct flash_softc *, bus_size_t);
static int amd_write(struct flash_softc *, bus_size_t);

extern struct cfdriver vrflash_cd;

CFATTACH_DECL_NEW(flash_vrip, sizeof(struct flash_softc),
             flash_probe, flash_attach, NULL, NULL);

dev_type_open(flashopen);
dev_type_close(flashclose);
dev_type_read(flashread);
dev_type_write(flashwrite);

const struct cdevsw vrflash_cdevsw = {
       .d_open = flashopen,
       .d_close = flashclose,
       .d_read = flashread,
       .d_write = flashwrite,
       .d_ioctl = noioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

static const struct flash_command_set {
       u_int8_t        fc_set0;
       u_int8_t        fc_set1;
       struct flashops fc_ops;
} flash_cmd[] = {
       {
               .fc_set0        = CFI_COMMSET_INTEL0,
               .fc_set1        = CFI_COMMSET_INTEL1,
               .fc_ops         = {
                       .fo_name        = "Intel",
                       .fo_erase       = intel_erase,
                       .fo_write       = intel_write,
               }
       },
       {
               .fc_set0        = CFI_COMMSET_AMDFJITU0,
               .fc_set1        = CFI_COMMSET_AMDFJITU1,
               .fc_ops         = {
                       .fo_name        = "AMD/Fujitsu",
                       .fo_erase       = amd_erase,
                       .fo_write       = amd_write,
               }
       },
       {
               .fc_set0        = 0,
               .fc_set1        = 0,
               .fc_ops         = {
                       .fo_name        = NULL,
                       .fo_erase       = NULL,
                       .fo_write       = NULL,
               }
       }
};


const static struct flashops *
find_command_set(u_int8_t cmdset0, u_int8_t cmdset1)
{
       const struct flash_command_set  *fc;

       for (fc = flash_cmd; fc->fc_ops.fo_name; fc++) {
               if (cmdset0 == fc->fc_set0 && cmdset1 == fc->fc_set1)
                       return &fc->fc_ops;
       }
       return NULL;
}

static int
probe_cfi(bus_space_tag_t iot, bus_space_handle_t ioh)
{
       const u_int8_t  *idstr = CFI_QUERY_ID_STR;
       int             i;
       u_int8_t        cmdset0;
       u_int8_t        cmdset1;

       /* start Common Flash Interface Query */
       bus_space_write_2(iot, ioh, CFI_QUERY_OFFSET, CFI_READ_CFI_QUERY);

       /* read CFI Query ID string */
       i = CFI_QUERY_ID_STR_REG << 1;
       do {
               if (bus_space_read_2(iot, ioh, i) != *idstr) {
                       bus_space_write_2(iot, ioh, 0, FLASH_RESET);
                       return 1;
               }
               i += 2;
               idstr++;
       } while (*idstr);

       cmdset0 = bus_space_read_2(iot, ioh, CFI_PRIM_COMM_REG0 << 1);
       cmdset1 = bus_space_read_2(iot, ioh, CFI_PRIM_COMM_REG1 << 1);

       /* switch flash to read mode */
       bus_space_write_2(iot, ioh, 0, FLASH_RESET);

       if (!find_command_set(cmdset0, cmdset1))
               return 1;

       return 0;
}

static int
flash_probe(device_t parent, cfdata_t match, void *aux)
{
       struct vrip_attach_args *va = aux;
       bus_space_handle_t      ioh;

       if (bus_space_map(va->va_iot, va->va_addr, va->va_size, 0, &ioh))
               return 0;
       if (!probe_cfi(va->va_iot, ioh)) {
               DPRINTF(("CFI ID str and command set recognized\n"));
               goto detect;
       }
       if (!i28f128_probe(va->va_iot, ioh)) {
               DPRINTF(("28F128 detected\n"));
               goto detect;
       }
       if (!mbm29160_probe(va->va_iot, ioh)) {
               DPRINTF(("29LV160 detected\n"));
               goto detect;
       }
       return 0;

detect:
       bus_space_unmap(va->va_iot, ioh, va->va_size);
       return 1;
}

static void
flash_attach(device_t parent, device_t self, void *aux)
{
       struct flash_softc      *sc = device_private(self);
       struct vrip_attach_args *va = aux;
       int                     i;
       int                     fence;
       bus_space_tag_t         iot = va->va_iot;
       bus_space_handle_t      ioh;
       size_t                  block_size;

       if (bus_space_map(iot, va->va_addr, va->va_size, 0, &ioh)) {
               printf(": can't map i/o space\n");
               return;
       }

       sc->sc_iot = iot;
       sc->sc_ioh = ioh;
       sc->sc_size = va->va_size;
       sc->sc_status = 0;

       /*
        * Read entire CFI structure
        */
       bus_space_write_2(iot, ioh, CFI_QUERY_OFFSET, CFI_READ_CFI_QUERY);
       for (i = 0; i < CFI_TOTAL_SIZE; i++) {
               sc->sc_cfi_raw[i] = bus_space_read_2(iot, ioh, i << 1);
       }
       bus_space_write_2(iot, ioh, 0, FLASH_RESET);

       sc->sc_ops = find_command_set(sc->sc_cfi_raw[CFI_PRIM_COMM_REG0],
                                     sc->sc_cfi_raw[CFI_PRIM_COMM_REG1]);
       if (sc->sc_ops) {
               printf(": using %s command set", sc->sc_ops->fo_name);
       } else {
               printf("opps sc->sc_ops is NULL\n");
       }

       /*
        * determine size of the largest block
        */
       sc->sc_block_size = 0;
       i = CFI_EBLK1_INFO_REG;
       fence = sc->sc_cfi_raw[CFI_NUM_ERASE_BLK_REG] * CFI_EBLK_INFO_SIZE
               + i;
       for (; i < fence; i += CFI_EBLK_INFO_SIZE) {
               if (sc->sc_cfi_raw[i + CFI_EBLK_INFO_NSECT0] == 0
                   && sc->sc_cfi_raw[i + CFI_EBLK_INFO_NSECT1] == 0)
                       continue;
               block_size
                       = (sc->sc_cfi_raw[i + CFI_EBLK_INFO_SECSIZE0] << 8)
                       + (sc->sc_cfi_raw[i + CFI_EBLK_INFO_SECSIZE1] << 16);
               if (sc->sc_block_size < block_size)
                       sc->sc_block_size = block_size;
       }

       sc->sc_buf = kmem_alloc(sc->sc_block_size, KM_SLEEP);

       sc->sc_write_buffer_size
               = 1 << (sc->sc_cfi_raw[CFI_MAX_WBUF_SIZE_REG0]
                       + (sc->sc_cfi_raw[CFI_MAX_WBUF_SIZE_REG1] << 8));
       sc->sc_typ_word_prog_timo
               = 1 << sc->sc_cfi_raw[CFI_TYP_WORD_PROG_REG];
       sc->sc_max_word_prog_timo
               = 1 << sc->sc_cfi_raw[CFI_MAX_WORD_PROG_REG];
       sc->sc_typ_buffer_write_timo
               = 1 << sc->sc_cfi_raw[CFI_TYP_BUF_WRITE_REG];
       sc->sc_max_buffer_write_timo
               = 1 << sc->sc_cfi_raw[CFI_MAX_BUF_WRITE_REG];
       sc->sc_typ_block_erase_timo
               = 1 << sc->sc_cfi_raw[CFI_TYP_BLOCK_ERASE_REG];
       sc->sc_max_block_erase_timo
               = 1 << sc->sc_cfi_raw[CFI_MAX_BLOCK_ERASE_REG];

       printf("\n");

#ifdef FLASH_DEBUG
       printf("read_cfi: extract cfi\n");
       printf("max block size: %dbyte\n", sc->sc_block_size);
       printf("write buffer size: %dbyte\n", sc->sc_write_buffer_size);
       printf("typical word program timeout: %dusec\n",
              sc->sc_typ_word_prog_timo);
       printf("maximam word program timeout: %dusec (%d time of typ)\n",
              sc->sc_typ_word_prog_timo * sc->sc_max_word_prog_timo,
              sc->sc_max_word_prog_timo);
       printf("typical buffer write timeout: %dusec\n",
              sc->sc_typ_buffer_write_timo);
       printf("maximam buffer write timeout: %dusec (%d time of typ)\n",
              sc->sc_typ_buffer_write_timo * sc->sc_max_buffer_write_timo,
              sc->sc_max_buffer_write_timo);
       printf("typical block erase timeout: %dmsec\n",
              sc->sc_typ_block_erase_timo);
       printf("maximam block erase timeout: %dmsec (%d time of typ)\n",
              sc->sc_typ_block_erase_timo * sc->sc_max_block_erase_timo,
              sc->sc_max_block_erase_timo);

       printf("read_cfi: dump cfi\n");
       for (i = 0; i < CFI_TOTAL_SIZE;) {
               int     j;
               for (j = 0; j < 16; j++) {
                       printf("%02x ", sc->sc_cfi_raw[i++]);
               }
               printf("\n");
       }
#endif
}

int
flashopen(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct flash_softc      *sc;

       sc = device_lookup_private(&vrflash_cd, minor(dev));
       if (sc == NULL)
               return ENXIO;
       if (sc->sc_status & FLASH_ST_BUSY)
               return EBUSY;
       sc->sc_status |= FLASH_ST_BUSY;
       return 0;
}

int
flashclose(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct flash_softc      *sc;

       sc = device_lookup_private(&vrflash_cd, minor(dev));
       sc->sc_status &= ~FLASH_ST_BUSY;
       return 0;
}

int
flashread(dev_t dev, struct uio *uio, int flag)
{
       struct flash_softc      *sc;
       bus_space_tag_t         iot;
       bus_space_handle_t      ioh;
       bus_size_t              off;
       int                     total;
       int                     count;
       int                     error;

       sc = device_lookup_private(&vrflash_cd, minor(dev));
       iot = sc->sc_iot;
       ioh = sc->sc_ioh;

       off = uio->uio_offset;
       total = uimin(sc->sc_size - off, uio->uio_resid);

       while (total > 0) {
               count = uimin(sc->sc_block_size, uio->uio_resid);
               bus_space_read_region_1(iot, ioh, off, sc->sc_buf, count);
               if ((error = uiomove(sc->sc_buf, count, uio)) != 0)
                       return error;
               off += count;
               total -= count;
       }
       return 0;
}


int
flashwrite(dev_t dev, struct uio *uio, int flag)
{
       struct flash_softc      *sc;
       bus_size_t              off;
       int                     stat;
       int                     error;

       sc = device_lookup_private(&vrflash_cd, minor(dev));

       if (sc->sc_size < uio->uio_offset + uio->uio_resid)
               return ENOSPC;
       if (uio->uio_offset % sc->sc_block_size)
               return EINVAL;
       if (uio->uio_resid % sc->sc_block_size)
               return EINVAL;

       for (off = uio->uio_offset;
            uio->uio_resid > 0;
            off += sc->sc_block_size) {
               if ((error = uiomove(sc->sc_buf, sc->sc_block_size, uio)) != 0)
                       return error;
               if (is_block_same(sc, off, sc->sc_buf))
                       continue;
               if ((stat = flash_block_erase(sc, off)) != 0) {
                       printf("block erase failed status = 0x%x\n", stat);
                       return EIO;
               }
               if ((stat = flash_block_write(sc, off)) != 0) {
                       printf("block write failed status = 0x%x\n", stat);
                       return EIO;
               }
       }
       return 0;
}

/*
* XXX
* this function is too much specific for the device.
*/
static int
i28f128_probe(bus_space_tag_t iot, bus_space_handle_t ioh)
{
       static const u_int8_t   vendor_code[] = {
               0x89,   /* manufacturer code:   intel */
               0x18,   /* device code:         28F128 */
       };

       static const u_int8_t   idstr[] = {
               'Q', 'R', 'Y',
               0x01, 0x00,
               0x31, 0x00,
               0xff
       };

       int     i;

       /* start Common Flash Interface Query */
       bus_space_write_2(iot, ioh, 0, CFI_READ_CFI_QUERY);
       /* read CFI Query ID string */
       for (i = 0; idstr[i] != 0xff; i++) {
               if (bus_space_read_2(iot, ioh, (0x10 + i) << 1) != idstr[i])
                       return 1;
       }

       /* read manufacturer code and device code */
       if (bus_space_read_2(iot, ioh, 0x00) != vendor_code[0])
               return 1;
       if (bus_space_read_2(iot, ioh, 0x02) != vendor_code[1])
               return 1;

       bus_space_write_2(iot, ioh, 0, I28F128_RESET);
       return 0;
}

/*
* XXX
* this function is too much specific for the device.
*/
static int
mbm29160_probe(bus_space_tag_t iot, bus_space_handle_t ioh)
{
       static const u_int16_t  vendor_code[] = {
               0x0004, /* manufacturer code:   intel */
               0x2249, /* device code:         29LV160BE */
       };

       static const u_int8_t   idstr[] = {
               'Q', 'R', 'Y',
               0x02, 0x00,
               0x40, 0x00,
               0xff
       };

       int     i;

       /* start Common Flash Interface Query */
       bus_space_write_2(iot, ioh, 0xaa, CFI_READ_CFI_QUERY);
       /* read CFI Query ID string */
       for (i = 0; idstr[i] != 0xff; i++) {
               if (bus_space_read_2(iot, ioh, (0x10 + i) << 1) != idstr[i])
                       return 1;
       }

       bus_space_write_2(iot, ioh, 0, 0xff);

       /* read manufacturer code and device code */
       bus_space_write_2(iot, ioh, 0x555 << 1, 0xaa);
       bus_space_write_2(iot, ioh, 0x2aa << 1, 0x55);
       bus_space_write_2(iot, ioh, 0x555 << 1, 0x90);
       if (bus_space_read_2(iot, ioh, 0x00) != vendor_code[0])
               return 1;
       if (bus_space_read_2(iot, ioh, 0x02) != vendor_code[1])
               return 1;

       bus_space_write_2(iot, ioh, 0, 0xff);
       return 0;
}

static int
is_block_same(struct flash_softc *sc, bus_size_t offset, const void *bufp)
{
       bus_space_tag_t         iot = sc->sc_iot;
       bus_space_handle_t      ioh = sc->sc_ioh;
       const u_int8_t          *p = bufp;
       int                     count = sc->sc_block_size;

       while (count-- > 0) {
               if (bus_space_read_1(iot, ioh, offset++) != *p++)
                       return 0;
       }
       return 1;
}

static int
intel_erase(struct flash_softc *sc, bus_size_t offset)
{
       bus_space_tag_t         iot = sc->sc_iot;
       bus_space_handle_t      ioh = sc->sc_ioh;
       int                     status;
       int                     i;

       bus_space_write_2(iot, ioh, offset, I28F128_BLK_ERASE_1ST);
       bus_space_write_2(iot, ioh, offset, I28F128_BLK_ERASE_2ND);

       status = 0;
       for (i = sc->sc_max_block_erase_timo; i > 0; i--) {
               tsleep(sc, PRIBIO, "blockerase",
                      1 + (sc->sc_typ_block_erase_timo * hz) / 1000);
               if ((status = bus_space_read_2(iot, ioh, offset))
                   & I28F128_S_READY)
                       break;
       }
       if (i == 0)
               status |= FLASH_TIMEOUT;

       bus_space_write_2(iot, ioh, offset, I28F128_CLEAR_STATUS);
       bus_space_write_2(iot, ioh, offset, I28F128_RESET);

       return status & (FLASH_TIMEOUT
                        | I28F128_S_ERASE_SUSPEND
                        | I28F128_S_COMSEQ_ERROR
                        | I28F128_S_ERASE_ERROR
                        | I28F128_S_BLOCK_LOCKED);
}

static int
intel_write(struct flash_softc *sc, bus_size_t offset)
{
       bus_space_tag_t         iot = sc->sc_iot;
       bus_space_handle_t      ioh = sc->sc_ioh;
       int                     wbuf_size;
       int                     timo;
       int                     status;
       bus_size_t              fence;
       int                     i;
       const u_int16_t         *p;

       /* wbuf_size = size in u_int16_t */
       wbuf_size = sc->sc_write_buffer_size >> 1;

       p = (u_int16_t *) sc->sc_buf;
       fence = offset + sc->sc_block_size;
       do {
               status = 0;
               for (timo = sc->sc_max_buffer_write_timo; timo > 0; timo--) {
                       bus_space_write_2(iot, ioh, offset,
                                         I28F128_WRITE_BUFFER);
                       status = bus_space_read_2(iot, ioh, offset);
                       if (status & I28F128_XS_BUF_AVAIL)
                               break;
                       DELAY(sc->sc_typ_buffer_write_timo);
               }
               if (timo == 0) {
                       status |= FLASH_TIMEOUT;
                       goto errout;
               }

               bus_space_write_2(iot, ioh, offset, wbuf_size - 1);

               for (i = wbuf_size; i > 0; i--, p++, offset += 2)
                       bus_space_write_2(iot, ioh, offset, *p);

               bus_space_write_2(iot, ioh, offset, I28F128_WBUF_CONFIRM);

               do {
                       bus_space_write_2(iot, ioh, offset,
                                         I28F128_READ_STATUS);
                       status = bus_space_read_2(iot, ioh, offset);
               } while (!(status & I28F128_S_READY));

       } while (offset < fence);

       bus_space_write_2(iot, ioh, offset, I28F128_CLEAR_STATUS);
       bus_space_write_2(iot, ioh, offset, I28F128_RESET);

       return 0;

errout:
       bus_space_write_2(iot, ioh, offset, I28F128_CLEAR_STATUS);
       bus_space_write_2(iot, ioh, offset, I28F128_RESET);

       status &= (FLASH_TIMEOUT
                  | I28F128_S_PROG_ERROR
                  | I28F128_S_COMSEQ_ERROR
                  | I28F128_S_LOW_VOLTAGE
                  | I28F128_S_PROG_SUSPEND
                  | I28F128_S_BLOCK_LOCKED);
       return status;
}

static int
amd_erase_sector(struct flash_softc *sc, bus_size_t offset)
{
       bus_space_tag_t         iot = sc->sc_iot;
       bus_space_handle_t      ioh = sc->sc_ioh;
       int                     i;

       DPRINTF(("amd_erase_sector offset = %08lx\n", offset));

       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR0, MBM29LV160_COMM_CMD0);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR1, MBM29LV160_COMM_CMD1);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR2, MBM29LV160_ESECT_CMD2);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR3, MBM29LV160_ESECT_CMD3);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR4, MBM29LV160_ESECT_CMD4);
       bus_space_write_2(iot, ioh, offset, MBM29LV160_ESECT_CMD5);

       for (i = sc->sc_max_block_erase_timo; i > 0; i--) {
               tsleep(sc, PRIBIO, "blockerase",
                      1 + (sc->sc_typ_block_erase_timo * hz) / 1000);
               if (bus_space_read_2(iot, ioh, offset) == 0xffff)
                       return 0;
       }

       return FLASH_TIMEOUT;
}

static int
amd_erase(struct flash_softc *sc, bus_size_t offset)
{
       static const struct mbm29lv_subsect {
               u_int16_t       devcode;
               u_int32_t       subsect_mask;
               u_int32_t       subsect_addr;
       } subsect[] = {
               {
                       MBM29LV160TE_DEVCODE,
                       MBM29LV160_SUBSECT_MASK,
                       MBM29LV160TE_SUBSECT_ADDR
               },
               {
                       MBM29LV160BE_DEVCODE,
                       MBM29LV160_SUBSECT_MASK,
                       MBM29LV160BE_SUBSECT_ADDR
               },
               { 0, 0, 0 }
       };

       bus_space_tag_t                 iot = sc->sc_iot;
       bus_space_handle_t              ioh = sc->sc_ioh;
       u_int16_t                       devcode;
       const struct mbm29lv_subsect    *ss;
       bus_size_t                      fence;
       int                             step;
       int                             status;

       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR0, MBM29LV160_COMM_CMD0);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR1, MBM29LV160_COMM_CMD1);
       bus_space_write_2(iot, ioh,
                         MBM29LV160_COMM_ADDR2, MBM29LV160_SIGN_CMD2);
       devcode = bus_space_read_2(iot, ioh, MBM29LV160_DEVCODE_REG);

       for (ss = subsect; ss->devcode; ss++) {
               if (ss->devcode == devcode)
                       break;
       }
       if (ss->devcode == 0) {
               printf("flash: amd_erase(): unknown device code %04x\n",
                      devcode);
               return -1;
       }

       DPRINTF(("flash: amd_erase(): devcode = %04x subsect = %08x\n",
                devcode, ss->subsect_addr));

       fence = offset + sc->sc_block_size;
       step = (offset & ss->subsect_mask) == ss->subsect_addr
               ? MBM29LV160_SUBSECT_SIZE : MBM29LV160_SECT_SIZE;
       do {
               if ((status = amd_erase_sector(sc, offset)) != 0)
                       return status;
               offset += step;
       } while (offset < fence);

       return 0;
}

static int
amd_write(struct flash_softc *sc, bus_size_t offset)
{
       bus_space_tag_t         iot = sc->sc_iot;
       bus_space_handle_t      ioh = sc->sc_ioh;
       int                     timo;
       bus_size_t              fence;
       const u_int16_t         *p;

       p = (u_int16_t *) sc->sc_buf;
       fence = offset + sc->sc_block_size;
       do {
               bus_space_write_2(iot, ioh,
                                 MBM29LV160_COMM_ADDR0,
                                 MBM29LV160_COMM_CMD0);
               bus_space_write_2(iot, ioh,
                                 MBM29LV160_COMM_ADDR1,
                                 MBM29LV160_COMM_CMD1);
               bus_space_write_2(iot, ioh,
                                 MBM29LV160_COMM_ADDR2,
                                 MBM29LV160_PROG_CMD2);
               bus_space_write_2(iot, ioh, offset, *p);

               for (timo = sc->sc_max_word_prog_timo; timo > 0; timo--) {
                       if (bus_space_read_2(iot, ioh, offset) == *p)
                               break;
                       DELAY(sc->sc_typ_word_prog_timo);
               }
               if (timo == 0)
                       return FLASH_TIMEOUT;

               p++;
               offset += 2;
       } while (offset < fence);

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.