goto err;
        }
 
+       asf->flash.sector_size = page_size;
        asf->flash.size = page_size * params->pages_per_block
                                * params->blocks_per_sector
                                * params->nr_sectors;
 
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, page_size);
-       print_size(asf->flash.size, "\n");
-
        return &asf->flash;
 
 err:
 
 
 int eon_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       struct eon_spi_flash *eon = to_eon_spi_flash(flash);
-       return spi_flash_cmd_erase(flash, CMD_EN25Q128_BE,
-               eon->params->page_size * eon->params->pages_per_sector *
-                       eon->params->sectors_per_block;
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_EN25Q128_BE, offset, len);
 }
 
 struct spi_flash *spi_flash_probe_eon(struct spi_slave *spi, u8 *idcode)
        eon->flash.write = eon_write;
        eon->flash.erase = eon_erase;
        eon->flash.read = spi_flash_cmd_read_fast;
+       eon->flash.sector_size = params->page_size * params->pages_per_sector
+           * params->sectors_per_block;
        eon->flash.size = params->page_size * params->pages_per_sector
            * params->nr_sectors;
 
-       debug("SF: Detected %s with page size %u, total %u bytes\n",
-             params->name, params->page_size, eon->flash.size);
-
        return &eon->flash;
 }
 
 
 int macronix_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       struct macronix_spi_flash *mcx = to_macronix_spi_flash(flash);
-       return spi_flash_cmd_erase(flash, CMD_MX25XX_BE,
-               mcx->params->page_size * mcx->params->pages_per_sector *
-                       mcx->params->sectors_per_block,
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_MX25XX_BE, offset, len);
 }
 
 struct spi_flash *spi_flash_probe_macronix(struct spi_slave *spi, u8 *idcode)
        mcx->flash.write = macronix_write;
        mcx->flash.erase = macronix_erase;
        mcx->flash.read = spi_flash_cmd_read_fast;
-       mcx->flash.size = params->page_size * params->pages_per_sector
-           * params->sectors_per_block * params->nr_blocks;
-
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, params->page_size);
-       print_size(mcx->flash.size, "\n");
+       mcx->flash.sector_size = params->page_size * params->pages_per_sector
+               * params->sectors_per_block;
+       mcx->flash.size = mcx->flash.sector_size * params->nr_blocks;
 
        return &mcx->flash;
 }
 
        sn->flash.erase = ramtron_erase;
        sn->flash.size = params->size;
 
-       printf("SF: Detected %s with size ", params->name);
-       print_size(sn->flash.size, "\n");
-
        return &sn->flash;
 }
 
 
 int spansion_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       struct spansion_spi_flash *spsn = to_spansion_spi_flash(flash);
-       return spi_flash_cmd_erase(flash, CMD_S25FLXX_SE,
-               spsn->params->page_size * spsn->params->pages_per_sector,
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_S25FLXX_SE, offset, len);
 }
 
 struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode)
        spsn->flash.write = spansion_write;
        spsn->flash.erase = spansion_erase;
        spsn->flash.read = spi_flash_cmd_read_fast;
-       spsn->flash.size = params->page_size * params->pages_per_sector
-           * params->nr_sectors;
-
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, params->page_size);
-       print_size(spsn->flash.size, "\n");
+       spsn->flash.sector_size = params->page_size * params->pages_per_sector;
+       spsn->flash.size = spsn->flash.sector_size * params->nr_sectors;
 
        return &spsn->flash;
 }
 
 }
 
 int spi_flash_cmd_erase(struct spi_flash *flash, u8 erase_cmd,
-                       u32 erase_size, u32 offset, size_t len)
+                       u32 offset, size_t len)
 {
-       u32 start, end;
+       u32 start, end, erase_size;
        int ret;
        u8 cmd[4];
 
+       erase_size = flash->sector_size;
        if (offset % erase_size || len % erase_size) {
                debug("SF: Erase offset/length not multiple of erase size\n");
                return -1;
                goto err_manufacturer_probe;
        }
 
+       printf("SF: Detected %s with page size %u, total ",
+              flash->name, flash->sector_size);
+       print_size(flash->size, "\n");
+
        spi_release_bus(spi);
 
        return flash;
 
 
 /* Erase sectors. */
 int spi_flash_cmd_erase(struct spi_flash *flash, u8 erase_cmd,
-                       u32 erase_size, u32 offset, size_t len);
+                       u32 offset, size_t len);
 
 /* Manufacturer-specific probe functions */
 struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode);
 
 
 int sst_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       return spi_flash_cmd_erase(flash, CMD_SST_SE, SST_SECTOR_SIZE,
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_SST_SE, offset, len);
 }
 
 static int
 
        stm->flash.write = sst_write;
        stm->flash.erase = sst_erase;
-       stm->flash.size = SST_SECTOR_SIZE * params->nr_sectors;
-
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, SST_SECTOR_SIZE);
-       print_size(stm->flash.size, "\n");
+       stm->flash.sector_size = SST_SECTOR_SIZE;
+       stm->flash.size = stm->flash.sector_size * params->nr_sectors;
 
        /* Flash powers up read-only, so clear BP# bits */
        sst_unlock(&stm->flash);
 
 
 int stmicro_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       struct stmicro_spi_flash *stm = to_stmicro_spi_flash(flash);
-       return spi_flash_cmd_erase(flash, CMD_M25PXX_SE,
-               stm->params->page_size * stm->params->pages_per_sector,
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_M25PXX_SE, offset, len);
 }
 
 struct spi_flash *spi_flash_probe_stmicro(struct spi_slave *spi, u8 * idcode)
        stm->flash.write = stmicro_write;
        stm->flash.erase = stmicro_erase;
        stm->flash.read = spi_flash_cmd_read_fast;
-       stm->flash.size = params->page_size * params->pages_per_sector
-           * params->nr_sectors;
-
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, params->page_size);
-       print_size(stm->flash.size, "\n");
+       stm->flash.sector_size = params->page_size * params->pages_per_sector;
+       stm->flash.size = stm->flash.sector_size * params->nr_sectors;
 
        return &stm->flash;
 }
 
 
 int winbond_erase(struct spi_flash *flash, u32 offset, size_t len)
 {
-       struct winbond_spi_flash *stm = to_winbond_spi_flash(flash);
-       return spi_flash_cmd_erase(flash, CMD_W25_SE,
-               (1 << stm->params->l2_page_size) * stm->params->pages_per_sector,
-               offset, len);
+       return spi_flash_cmd_erase(flash, CMD_W25_SE, offset, len);
 }
 
 struct spi_flash *spi_flash_probe_winbond(struct spi_slave *spi, u8 *idcode)
        stm->flash.write = winbond_write;
        stm->flash.erase = winbond_erase;
        stm->flash.read = spi_flash_cmd_read_fast;
+       stm->flash.sector_size = (1 << stm->params->l2_page_size) *
+               stm->params->pages_per_sector;
        stm->flash.size = page_size * params->pages_per_sector
                                * params->sectors_per_block
                                * params->nr_blocks;
 
-       printf("SF: Detected %s with page size %u, total ",
-              params->name, page_size);
-       print_size(stm->flash.size, "\n");
-
        return &stm->flash;
 }
 
 
        u32             size;
 
+       u32             sector_size;
+
        int             (*read)(struct spi_flash *flash, u32 offset,
                                size_t len, void *buf);
        int             (*write)(struct spi_flash *flash, u32 offset,