--- a/packages/devs/flash/atmel/dataflash/current/ChangeLog
+++ b/packages/devs/flash/atmel/dataflash/current/ChangeLog
@@ -1,5 +1,10 @@
 2004-11-22  Bart Veer  <bartv@ecoscentric.com>
 
+	* include/dataflash.h, src/devs_flash_atmel_dataflash.c,
+	src/devs_flash_atmel_dataflash_flash_dev_funs.c: merge the config
+	and priv structures, removing the duplicate spi_dev data in the
+	process. Adjust device driver API as per changes to the generic
+	flash code.
 	* src/devs_flash_atmel_dataflash_flash_dev_funs.c (df_flash_init):
 	Rename cyg_block_info to cyg_flash_block_info
 

--- a/packages/devs/flash/atmel/dataflash/current/include/dataflash.h
+++ b/packages/devs/flash/atmel/dataflash/current/include/dataflash.h
@@ -101,33 +101,33 @@ typedef struct cyg_dataflash_device_s
 #ifdef _FLASH_PRIVATE_
 #include <cyg/io/flash.h>
 
-typedef struct cyg_dataflash_flash_dev_config_s
-{
-    cyg_spi_device  **spi_dev;           // SPI device
-    cyg_uint32        address;           // Memory address (flash driver)
-    cyg_int16         start_sector;      // Start sector of flash driver space
-    cyg_int16         end_sector;        // End sector of flash driver space
-} cyg_dataflash_flash_dev_config_t;
-
 typedef struct cyg_dataflash_flash_dev_priv_s
 {
-    cyg_dataflash_device_t dev;            // DataFlash device
-    cyg_uint32             start_page;     // Start page of flash driver space
-    cyg_uint32             end_page;       // End page of flash driver space
+    cyg_int16               start_sector;   // Start sector of flash driver space
+    cyg_int16               end_sector;     // End sector of flash driver space
+    cyg_dataflash_device_t  dev;            // DataFlash device
+    cyg_uint32              start_page;     // Start page of flash driver space
+    cyg_uint32              end_page;       // End page of flash driver space
+    cyg_flash_block_info_t  block_info[1];
 } cyg_dataflash_flash_dev_priv_t;
 
 externC struct cyg_flash_dev_funs cyg_dataflash_flash_dev_funs;
 
-#define CYG_DATAFLASH_FLASH_DRIVER(name, _sdev, _addr, _start, _end)    \
-    static cyg_dataflash_flash_dev_config_t config_ ## name = {         \
-        .spi_dev      = &_sdev,                                         \
-        .address      = _addr,                                          \
-        .start_sector = _start,                                         \
-        .end_sector   = _end                                            \
-    };                                                                  \
-    CYG_FLASH_DRIVER(name, &cyg_dataflash_flash_dev_funs,               \
-                     &config_ ## name, 0,                               \
-                     sizeof(cyg_dataflash_flash_dev_priv_t))
+#define CYG_DATAFLASH_FLASH_DRIVER(name, _sdev, _addr, _start, _end)            \
+    static cyg_dataflash_flash_dev_priv_t cyg_dataflash_priv_ ## name = {       \
+        .start_sector = _start,                                                 \
+        .end_sector   = _end,                                                   \
+        .dev.spi_dev  = _sdev,                                                  \
+    };                                                                          \
+    CYG_FLASH_DRIVER(name,                                                      \
+                     &cyg_dataflash_flash_dev_funs,                             \
+                     0,                                                         \
+                     _addr,                                                     \
+                     0,                                                         \
+                     1,                                                         \
+                     cyg_dataflash_priv_ ## name.block_info,                    \
+                     & cyg_dataflash_priv_ ## name                              \
+        )
 
 #endif // _FLASH_PRIVATE_
     
@@ -183,8 +183,7 @@ cyg_dataflash_set_blocking_operation(cyg
 
 //----------------------------------------------------------------------------
 
-externC int cyg_dataflash_init(cyg_spi_device         *spi_dev, 
-                               cyg_bool                polled,
+externC int cyg_dataflash_init(cyg_bool                polled,
                                cyg_dataflash_device_t *dev);
 
 externC int cyg_dataflash_aquire(cyg_dataflash_device_t *dev);

--- a/packages/devs/flash/atmel/dataflash/current/src/devs_flash_atmel_dataflash.c
+++ b/packages/devs/flash/atmel/dataflash/current/src/devs_flash_atmel_dataflash.c
@@ -287,11 +287,9 @@ df_detect_device(cyg_dataflash_device_t 
 // cyg_dataflash_init()
 
 int
-cyg_dataflash_init(cyg_spi_device         *spi_dev, 
-                   cyg_bool                polled,
+cyg_dataflash_init(cyg_bool                polled,
                    cyg_dataflash_device_t *dev)
 {
-    dev->spi_dev  = spi_dev;
     dev->polled   = polled;
     dev->blocking = false;
     dev->state    = CYG_DATAFLASH_STATE_IDLE;

--- a/packages/devs/flash/atmel/dataflash/current/src/devs_flash_atmel_dataflash_flash_dev_funs.c
+++ b/packages/devs/flash/atmel/dataflash/current/src/devs_flash_atmel_dataflash_flash_dev_funs.c
@@ -73,21 +73,17 @@
 static int 
 df_flash_init(struct cyg_flash_dev *dev)
 {
-    static cyg_flash_block_info_t block_info[1];
-    
-    cyg_dataflash_flash_dev_config_t *config;
     cyg_dataflash_flash_dev_priv_t   *priv;
     cyg_dataflash_device_t           *df_dev;
     int sector_cnt;
     
-    config = (cyg_dataflash_flash_dev_config_t *) dev->config;
     priv   = (cyg_dataflash_flash_dev_priv_t *) dev->priv; 
     df_dev = &priv->dev;
    
 #ifdef CYGPKG_REDBOOT    
-    if (cyg_dataflash_init(*(config->spi_dev), true, df_dev))
+    if (cyg_dataflash_init(true, df_dev))
 #else
-    if (cyg_dataflash_init(*(config->spi_dev), false, df_dev))
+    if (cyg_dataflash_init(false, df_dev))
 #endif        
         return CYG_DATAFLASH_ERR_WRONG_PART; 
   
@@ -95,53 +91,47 @@ df_flash_init(struct cyg_flash_dev *dev)
 
     sector_cnt = cyg_dataflash_get_sector_count(df_dev);
 
-    if (config->end_sector < 0)
-       config->end_sector = sector_cnt - 1; 
+    if (priv->end_sector < 0)
+       priv->end_sector = sector_cnt - 1; 
     
-    if (config->start_sector >= sector_cnt ||
-        config->end_sector   >= sector_cnt ||
-        config->end_sector   <  config->start_sector)
+    if (priv->start_sector >= sector_cnt ||
+        priv->end_sector   >= sector_cnt ||
+        priv->end_sector   <  priv->start_sector)
         return CYG_DATAFLASH_ERR_INVALID;        
     
     priv->start_page = cyg_dataflash_get_block_size(df_dev) *
-        cyg_dataflash_get_sector_start(df_dev, config->start_sector);
+        cyg_dataflash_get_sector_start(df_dev, priv->start_sector);
 
     priv->end_page = cyg_dataflash_get_block_size(df_dev) *
-        (cyg_dataflash_get_sector_start(df_dev, config->end_sector) +
-         cyg_dataflash_get_sector_size(df_dev, config->end_sector));
+        (cyg_dataflash_get_sector_start(df_dev, priv->end_sector) +
+         cyg_dataflash_get_sector_size(df_dev, priv->end_sector));
     
-    dev->start = (cyg_flashaddr_t)config->address;
-    dev->end   = (cyg_flashaddr_t)(config->address + 
+    dev->end   = (cyg_flashaddr_t)(dev->start +
         ((priv->end_page - priv->start_page) *
          cyg_dataflash_get_page_size(df_dev)) - 1);
-
-    dev->num_block_infos     = 1;
-    dev->block_info          = block_info;
-    block_info[0].block_size = cyg_dataflash_get_page_size(df_dev);
-    block_info[0].blocks     = priv->end_page - priv->start_page;
+    priv->block_info[0].block_size = cyg_dataflash_get_page_size(df_dev);
+    priv->block_info[0].blocks     = priv->end_page - priv->start_page;
 
     return CYG_DATAFLASH_ERR_OK;
 }
 
 static size_t 
-df_flash_query(struct cyg_flash_dev *dev, void *data, const size_t len)
+df_flash_query(struct cyg_flash_dev *dev, void *data, size_t len)
 {
     return len;
 }
 
 static int 
 df_flash_erase_block(struct cyg_flash_dev   *dev, 
-                     const  cyg_flashaddr_t  base)
+                     cyg_flashaddr_t  base)
 {
-    cyg_dataflash_flash_dev_config_t *config;
     cyg_dataflash_flash_dev_priv_t   *priv;
     cyg_uint32 page;
     int        err;
     
-    config = (cyg_dataflash_flash_dev_config_t *) dev->config;
     priv   = (cyg_dataflash_flash_dev_priv_t *) dev->priv;
     
-    page = priv->start_page + ((base - config->address) / 
+    page = priv->start_page + ((base - dev->start) / 
            cyg_dataflash_get_page_size(&priv->dev)); 
    
     RETURN_ON_ERROR( cyg_dataflash_aquire(&priv->dev)                       );
@@ -159,19 +149,17 @@ static int
 df_flash_program(struct cyg_flash_dev *dev, 
                  cyg_flashaddr_t       base, 
                  const void           *data, 
-                 const size_t          len)
+                 size_t                len)
 {
-    cyg_dataflash_flash_dev_config_t *config;
     cyg_dataflash_flash_dev_priv_t   *priv;
     cyg_uint32 page, pos;
     int        err;
  
-    config = (cyg_dataflash_flash_dev_config_t *) dev->config;
     priv   = (cyg_dataflash_flash_dev_priv_t *) dev->priv;
     
-    page = priv->start_page + ((base - config->address) / 
+    page = priv->start_page + ((base - dev->start) / 
            cyg_dataflash_get_page_size(&priv->dev)); 
-    pos  = (base - config->address) % cyg_dataflash_get_page_size(&priv->dev);
+    pos  = (base - dev->start) % cyg_dataflash_get_page_size(&priv->dev);
     
     RETURN_ON_ERROR( cyg_dataflash_aquire(&priv->dev)                       );
     GOTO_ON_ERROR(   cyg_dataflash_mem_to_buf(&priv->dev, 1, page)          );
@@ -190,19 +178,17 @@ static int
 df_flash_read(struct cyg_flash_dev   *dev, 
               const  cyg_flashaddr_t  base, 
               void                   *data, 
-              const size_t            len)
+              size_t                  len)
 {
-    cyg_dataflash_flash_dev_config_t *config;
     cyg_dataflash_flash_dev_priv_t   *priv;
     cyg_uint32 page, pos;
     int        err;
  
-    config = (cyg_dataflash_flash_dev_config_t *) dev->config;
     priv   = (cyg_dataflash_flash_dev_priv_t *) dev->priv;
     
-    page = priv->start_page + ((base - config->address) / 
+    page = priv->start_page + ((base - dev->start) / 
            cyg_dataflash_get_page_size(&priv->dev)); 
-    pos  = (base - config->address) % cyg_dataflash_get_page_size(&priv->dev);
+    pos  = (base - dev->start) % cyg_dataflash_get_page_size(&priv->dev);
  
     RETURN_ON_ERROR( cyg_dataflash_aquire(&priv->dev)                       );
     GOTO_ON_ERROR(   cyg_dataflash_mem_to_buf(&priv->dev, 1, page)          );
@@ -230,6 +216,7 @@ df_flash_hwr_map_error(struct cyg_flash_
     }
 }
 
+#ifdef CYGHWR_IO_FLASH_BLOCK_LOCKING
 static int 
 df_flash_block_lock(struct cyg_flash_dev   *dev, 
                     const  cyg_flashaddr_t  block_base)
@@ -243,6 +230,7 @@ df_flash_block_unlock(struct cyg_flash_d
 {
     return CYG_DATAFLASH_ERR_INVALID;
 }
+#endif
 
 // --------------------------------------------------------------------------