Added an optional second ibl config area to the i2c eeprom
authorMike Line <m-line1@ti.com>
Tue, 9 Nov 2010 22:30:06 +0000 (17:30 -0500)
committerMike Line <m-line1@ti.com>
Tue, 9 Nov 2010 22:30:06 +0000 (17:30 -0500)
There can now be two ibl configuration structures in the I2c rom.
One is used by the big endian code, the other by the little. A single
one can be used by simply referring to one reserved area in the
I2C configuration file.

45 files changed:
src/cfg/c6472/iblcfg.h
src/driver/eth/arp.c
src/driver/eth/arp.pretimer.c
src/driver/eth/arp.timer.c [deleted file]
src/driver/eth/bootp.c
src/driver/eth/icmp.c
src/driver/eth/ip.c
src/driver/eth/net.c
src/driver/eth/net_orig.c [deleted file]
src/driver/eth/net_osal.h [new file with mode: 0644]
src/driver/eth/tftp.c
src/driver/eth/udp.c
src/driver/nand/nand.c
src/driver/stream/stream.c
src/driver/stream/stream_osal.h [new file with mode: 0644]
src/driver/timer/timer.c
src/driver/timer/timer_osal.h [new file with mode: 0644]
src/ethboot/ethboot.c
src/hw/macs/cpmac/cpmacdrv.c
src/hw/macs/cpmac/cpmacdrv.orig.c [deleted file]
src/ibl.h
src/iblloc.h
src/interp/btbl/btblpr.c
src/interp/btbl/btblwrap.c
src/interp/btbl/btblwrap.h
src/interp/coff/cload.mike.c [deleted file]
src/interp/coff/osal.h
src/interp/elf/ArrayList.c
src/interp/elf/dlw_client.c
src/interp/elf/file_ovr.h
src/main/iblinit.c
src/main/iblmain.c
src/make/ibl_c6472/ibl.cmd
src/make/makestg2
src/mkdeppath.bat [deleted file]
src/util/i2cConfig/Makefile
src/util/i2cConfig/i2cConfig.gel
src/util/i2cConfig/i2cparam.c
src/util/i2cConfig/makestg2
src/util/romparse/romparse.c
src/util/romparse/romparse.h
src/util/romparse/rparse.flex
src/util/romparse/rparse.tab.c
src/util/romparse/rparse.tab.h
src/util/romparse/rparse.y

index 83620918046de58fb2ed070bc2c3f383b9e8b6f7..8de95221f9c9d989bf5d0e5298e019fe5f8e8802 100644 (file)
 #define BOOTCONFIG_NO_BTBL_IO
 
 /**
- * @brief The I2C bus address and data address of the ibl table.
+ * @brief Estimates of operating parameters. Actual values will be known once they are
+ *        read from the i2c.
  */
 #define IBL_I2C_DEV_FREQ_MHZ            625
 #define IBL_I2C_CLK_FREQ_KHZ            100
 #define IBL_I2C_OWN_ADDR                10
 #define IBL_I2C_CFG_ADDR_DELAY          0x100       /* Delay between sending the address and reading data */
 
-#define IBL_I2C_CFG_EEPROM_BUS_ADDR    0x50
+/* #define IBL_I2C_CFG_EEPROM_BUS_ADDR    0x50 */
 
-#define IBL_I2C_CFG_TABLE_DATA_ADDR     0x500
+#define IBL_I2C_MAP_TABLE_DATA_BUS_ADDR 0x50
 #define IBL_I2C_MAP_TABLE_DATA_ADDR     0x420
  
 
index e299440de17e11c10c7cc0680085b45c159395b5..06a5b430613b2e3bfc4952969a7051388c96d1f6 100644 (file)
@@ -15,7 +15,7 @@
 #include "net.h"
 #include "netif.h"
 #include <string.h>
-
+#include "net_osal.h"
 
 /**********************************************************************
  *************************** LOCAL Structures *************************
@@ -138,12 +138,12 @@ void arp_resolve (IPN dst_ip, IPHDR* ptr_iphdr, Uint16 l3_pkt_size)
 
     /* Initialize the ARP Cache: The cache did not have information for the resolution to work
      * Reset the cache and start again.  */
-    memset ((void *)&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
+    netMemset ((void *)&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
 
     /* Populate the ARP Cache */
     net_arp_cache.ip_address         = dst_ip;    
     net_arp_cache.pending_packet_len = l3_pkt_size;
-    memcpy ((void *)&net_arp_cache.pending_packet[0], (void *)ptr_iphdr, l3_pkt_size);
+    netMemcpy ((void *)&net_arp_cache.pending_packet[0], (void *)ptr_iphdr, l3_pkt_size);
 
     /* Free up the packet now; we have already stored it in the ARP cache. */
     net_free_tx_packet ((Uint8 *)ptr_iphdr);
@@ -161,12 +161,12 @@ void arp_resolve (IPN dst_ip, IPHDR* ptr_iphdr, Uint16 l3_pkt_size)
     ptr_arphdr->Op           = htons(0x1);
 
     /* Populate the Source IP/MAC Address */
-    memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
+    netMemcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
 
     /* Populate the Target IP/MAC Address: This is set to 0 since the cache has been reset above. */
-    memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&dst_ip, 4);
+    netMemcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&dst_ip, 4);
 
     /* Create the Ethernet header. */
     ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &BroadcastMac[0], 0x806);
@@ -223,7 +223,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
 
     /* The ARP packet was meant for us; we need to update the ARP cache with the request. */
     net_arp_cache.ip_address = READ32(ptr_arphdr->IPSrc);
-    memcpy ((void *)&net_arp_cache.mac_address[0], (void *)&ptr_arphdr->SrcAddr[0], 6);
+    netMemcpy ((void *)&net_arp_cache.mac_address[0], (void *)&ptr_arphdr->SrcAddr[0], 6);
 
     /* Check if the packet is an ARP request? */
     if (ptr_arphdr->Op == htons(0x1))
@@ -243,12 +243,12 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
         ptr_arphdr->Op           = htons(0x2);
 
         /* Populate the Source IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
+        netMemcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
+        netMemcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
 
         /* Populate the Target IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
+        netMemcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
+        netMemcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
 
         /* Create the Ethernet header. */
         ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &net_arp_cache.mac_address[0], 0x806);
@@ -272,7 +272,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
             return -1;
 
         /* We now copy the contents of this packet from the ARP cache */
-        memcpy ((void *)ptr_pending_pkt, (void *)&net_arp_cache.pending_packet[0], 
+        netMemcpy ((void *)ptr_pending_pkt, (void *)&net_arp_cache.pending_packet[0], 
                     net_arp_cache.pending_packet_len);
 
         /* We create the Ethernet header. 
@@ -305,7 +305,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
  */
 void arp_init (void)
 {
-    memset (&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
+    netMemset (&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
     return;
 }
 
index e299440de17e11c10c7cc0680085b45c159395b5..f58a99f26978b1eaa1bd4cb5af01e126508be3fe 100644 (file)
@@ -138,12 +138,12 @@ void arp_resolve (IPN dst_ip, IPHDR* ptr_iphdr, Uint16 l3_pkt_size)
 
     /* Initialize the ARP Cache: The cache did not have information for the resolution to work
      * Reset the cache and start again.  */
-    memset ((void *)&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
+    netMemset ((void *)&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
 
     /* Populate the ARP Cache */
     net_arp_cache.ip_address         = dst_ip;    
     net_arp_cache.pending_packet_len = l3_pkt_size;
-    memcpy ((void *)&net_arp_cache.pending_packet[0], (void *)ptr_iphdr, l3_pkt_size);
+    netMemcpy ((void *)&net_arp_cache.pending_packet[0], (void *)ptr_iphdr, l3_pkt_size);
 
     /* Free up the packet now; we have already stored it in the ARP cache. */
     net_free_tx_packet ((Uint8 *)ptr_iphdr);
@@ -161,12 +161,12 @@ void arp_resolve (IPN dst_ip, IPHDR* ptr_iphdr, Uint16 l3_pkt_size)
     ptr_arphdr->Op           = htons(0x1);
 
     /* Populate the Source IP/MAC Address */
-    memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
+    netMemcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
 
     /* Populate the Target IP/MAC Address: This is set to 0 since the cache has been reset above. */
-    memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&dst_ip, 4);
+    netMemcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&dst_ip, 4);
 
     /* Create the Ethernet header. */
     ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &BroadcastMac[0], 0x806);
@@ -223,7 +223,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
 
     /* The ARP packet was meant for us; we need to update the ARP cache with the request. */
     net_arp_cache.ip_address = READ32(ptr_arphdr->IPSrc);
-    memcpy ((void *)&net_arp_cache.mac_address[0], (void *)&ptr_arphdr->SrcAddr[0], 6);
+    netMemcpy ((void *)&net_arp_cache.mac_address[0], (void *)&ptr_arphdr->SrcAddr[0], 6);
 
     /* Check if the packet is an ARP request? */
     if (ptr_arphdr->Op == htons(0x1))
@@ -243,12 +243,12 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
         ptr_arphdr->Op           = htons(0x2);
 
         /* Populate the Source IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
+        netMemcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
+        netMemcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
 
         /* Populate the Target IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
+        netMemcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
+        netMemcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
 
         /* Create the Ethernet header. */
         ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &net_arp_cache.mac_address[0], 0x806);
@@ -272,7 +272,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
             return -1;
 
         /* We now copy the contents of this packet from the ARP cache */
-        memcpy ((void *)ptr_pending_pkt, (void *)&net_arp_cache.pending_packet[0], 
+        netMemcpy ((void *)ptr_pending_pkt, (void *)&net_arp_cache.pending_packet[0], 
                     net_arp_cache.pending_packet_len);
 
         /* We create the Ethernet header. 
@@ -305,7 +305,7 @@ Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
  */
 void arp_init (void)
 {
-    memset (&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
+    netMemset (&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
     return;
 }
 
diff --git a/src/driver/eth/arp.timer.c b/src/driver/eth/arp.timer.c
deleted file mode 100644 (file)
index e8e3169..0000000
+++ /dev/null
@@ -1,352 +0,0 @@
-/** 
- *   @file  arp.c
- *
- *   @brief   
- *      The file implements the NET Module ARP functionality.
- *
- *  \par
- *  NOTE:
- *      (C) Copyright 2008, Texas Instruments, Inc.
- *
- *  \par
- */
-#include "types.h"
-#include "iblloc.h"
-#include "net.h"
-#include "netif.h"
-#include "timer.h"
-#include <string.h>
-
-
-/**********************************************************************
- *************************** LOCAL Structures *************************
- **********************************************************************/
-
-/**
- * @brief 
- *  The structure describes the ARP Cache 
- *
- * @details
- *  This describes the ARP Cache which keeps track of the IPv4 address and
- *  the corresponding Layer2 MAC Address. 
- */
-typedef struct NET_ARP_CACHE
-{
-    /**
-     * @brief   This is the MAC Address i.e. Layer2 address matching the
-     * corresponding IP Address.
-     */
-    Uint8       mac_address[6];
-
-    /**
-     * @brief   This is the IP Address stored in network order.
-     */
-    IPN         ip_address;
-
-    /**
-     * @brief   When the upper layers tries to send a packet and 
-     * the MAC Address is not resolved; packets are stored in this 
-     * temporary area. The ARP stack sends out an ARP request packet 
-     * and resolves the IP  address. Once the resolution is done pending 
-     * packets are transmitted. 
-     */
-    Uint8      pending_packet[NET_MAX_MTU];
-
-    /**
-     * @brief   This is the length of the pending packet. A value of 0
-     * indicates that there is no pending packet in the ARP cache.
-     */    
-    Uint16     pending_packet_len;
-
-    /**
-     * @brief   The timer used to handle arp request timeouts
-     */
-    Int32      timer;
-
-    /**
-     * @brief   The number of times an arp request was resent
-     */
-    Uint32     resend_count;
-
-}NET_ARP_CACHE;
-
-/**********************************************************************
- *************************** GLOBAL Variables *************************
- **********************************************************************/
-
-/**
- * @brief   This is the ARP cache; which keeps track of the IP Address to
- * MAC Address mapping.
- */
-NET_ARP_CACHE      net_arp_cache;
-
-/**********************************************************************
- **************************** ARP Functions ***************************
- **********************************************************************/
-
-void arp_send (void)
-{
-    ARPHDR* ptr_arphdr;
-    ETHHDR* ptr_ethhdr;
-    Uint8   BroadcastMac[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-    /* If the address has been resolved then the arp reply was received, despite the timeout */
-    if ( (net_arp_cache.mac_address[0] != 0x00) || (net_arp_cache.mac_address[1] != 0x00) ||
-         (net_arp_cache.mac_address[2] != 0x00) || (net_arp_cache.mac_address[3] != 0x00) || 
-         (net_arp_cache.mac_address[4] != 0x00) || (net_arp_cache.mac_address[5] != 0x00) )
-        return;
-
-    /* Allocate a new packet to send out the ARP request. */
-    ptr_arphdr = (ARPHDR *)net_alloc_tx_packet(sizeof(ARPHDR));
-    if (ptr_arphdr == NULL)
-        return;
-
-    /* Populate the ARP Header. */
-    ptr_arphdr->HardType     = htons(0x1);
-    ptr_arphdr->ProtocolType = htons(0x800);
-    ptr_arphdr->HardSize     = 0x6;
-    ptr_arphdr->ProtocolSize = 0x4;
-    ptr_arphdr->Op           = htons(0x1);
-
-    /* Populate the Source IP/MAC Address */
-    memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
-
-    /* Populate the Target IP/MAC Address: This is likely set to 0 since the cache has been reset on the first send. */
-    memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-    memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
-
-    /* Create the Ethernet header. */
-    ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &BroadcastMac[0], 0x806);
-    if (ptr_ethhdr == NULL)
-        return;
-
-    /* Send the packet out. */
-    net_send_packet (ptr_ethhdr, sizeof(ETHHDR) + sizeof(ARPHDR));
-
-    /* The packet has been transmitted and we can clean it up now. */
-    net_free_tx_packet ((Uint8 *)ptr_arphdr);
-
-}
-
-void arp_timer_expiry (void)
-{
-    /* ARP request timeout. Resend */
-    arp_send();
-
-    net_arp_cache.resend_count += 1;
-}
-
-/**
- *  @b Description
- *  @n  
- *      This function is called by the IP Layer to resolve the layer3 
- *      address to a layer2 MAC address. The function checks the ARP cache
- *      for a match but if no entry exists then the functions sends out
- *      an ARP request and it places this packet into the pending queue.
- *
- *  @param[in]  dst_ip
- *      This is the destination IP address of the packet.
- *  @param[in]  ptr_iphdr
- *      This is the pointer to the IP header
- *  @param[in]  l3_pkt_size
- *      This is the size of the packet (including the IP Header)
- *
- *  @retval
- *      Not Applicable.
- */
-void arp_resolve (IPN dst_ip, IPHDR* ptr_iphdr, Uint16 l3_pkt_size)
-{
-    ETHHDR* ptr_ethhdr;
-    Uint8   BroadcastMac[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-    /* Special Case: Are we sending the packet to 255.255.255.255? */
-    if (dst_ip == (IPN)0xFFFFFFFF)
-    {
-        /* YES. This implies that the destination MAC Address in the packet is the Broadcast address
-         * We dont need to lookup the cache. */
-        ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_iphdr, (void *)&BroadcastMac[0], 0x800);
-        if (ptr_ethhdr == NULL)
-            return;
-
-        /* We now have a completed Ethernet packet; send it across. */
-        net_send_packet (ptr_ethhdr, sizeof(ETHHDR) + l3_pkt_size);
-
-        /* The packet has been transmitted and we can clean it up now. */
-        net_free_tx_packet ((Uint8 *)ptr_iphdr);
-        return;            
-    }
-
-    /* Check if the destination IP Address matches the ARP cache */
-    if (net_arp_cache.ip_address == dst_ip)
-    {
-        /* Make sure the MAC Address in the CACHE has been resolved i.e. Non-Zero. */
-        if ( (net_arp_cache.mac_address[0] != 0x00) || (net_arp_cache.mac_address[1] != 0x00) ||
-             (net_arp_cache.mac_address[2] != 0x00) || (net_arp_cache.mac_address[3] != 0x00) || 
-             (net_arp_cache.mac_address[4] != 0x00) || (net_arp_cache.mac_address[5] != 0x00) )
-        {
-            /* Perfect; the MAC Address is already resolved. 
-             *  We can simply use the ARP CACHE MAC address to create the layer2 header. */
-            ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_iphdr, (void *)&net_arp_cache.mac_address[0], 0x800);
-            if (ptr_ethhdr == NULL)
-                return;
-
-            /* We now have a completed Ethernet packet; send it across. */
-            net_send_packet (ptr_ethhdr, sizeof(ETHHDR) + l3_pkt_size);
-
-            /* The packet has been transmitted and we can clean it up now. */
-            net_free_tx_packet ((Uint8 *)ptr_iphdr);
-            return;
-        }
-    }
-
-    /* Initialize the ARP Cache: The cache did not have information for the resolution to work
-     * Reset the cache and start again.  */
-    memset ((void *)&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
-
-    /* Populate the ARP Cache */
-    net_arp_cache.ip_address         = dst_ip;    
-    net_arp_cache.pending_packet_len = l3_pkt_size;
-    memcpy ((void *)&net_arp_cache.pending_packet[0], (void *)ptr_iphdr, l3_pkt_size);
-
-    /* Free up the packet now; we have already stored it in the ARP cache. */
-    net_free_tx_packet ((Uint8 *)ptr_iphdr);
-
-    net_arp_cache.timer = timer_add (ARP_TIMEOUT, arp_timer_expiry);
-
-    arp_send ();
-
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function handles the reception and processing of ARP packets.
- *
- *  @param[in]  ptr_arphdr
- *      This is the pointer to the received ARP header.
- *  @param[in]  num_bytes
- *      This is the size of the ARP packet.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-Int32 arp_receive (ARPHDR* ptr_arphdr, Int32 num_bytes)
-{
-    Uint32  IPAddress;
-    Uint8*  ptr_pending_pkt;
-    ETHHDR* ptr_ethhdr;
-
-    /* Extract the intended target and convert it to host format. */
-    IPAddress = READ32(ptr_arphdr->IPDst);
-
-    /* Ensure that the packet has not been looped back and we received our own frame. */
-    if ((ptr_arphdr->SrcAddr[0] == netmcb.net_device.mac_address[0]) &&
-        (ptr_arphdr->SrcAddr[1] == netmcb.net_device.mac_address[1]) &&
-        (ptr_arphdr->SrcAddr[2] == netmcb.net_device.mac_address[2]) &&
-        (ptr_arphdr->SrcAddr[3] == netmcb.net_device.mac_address[3]) &&
-        (ptr_arphdr->SrcAddr[4] == netmcb.net_device.mac_address[4]) &&
-        (ptr_arphdr->SrcAddr[5] == netmcb.net_device.mac_address[5]))
-    {
-        /* We received our own frame; ignore this. */
-        return -1;
-    }
-
-    /* Check if the packet is meant for us? If it not meant for us we drop the packet. */
-    if (IPAddress != netmcb.net_device.ip_address)
-        return -1;
-
-    /* The ARP packet was meant for us; we need to update the ARP cache with the request. */
-    net_arp_cache.ip_address = READ32(ptr_arphdr->IPSrc);
-    memcpy ((void *)&net_arp_cache.mac_address[0], (void *)&ptr_arphdr->SrcAddr[0], 6);
-
-    /* Check if the packet is an ARP request? */
-    if (ptr_arphdr->Op == htons(0x1))
-    {
-        /* YES. We need to send out an ARP Reply; so create the packet. 
-         *  Ensure that the Layer3 headers are aligned on the 4 byte boundary 
-         *  and yet we have sufficient space for the Ethernet header. */
-        ptr_arphdr = (ARPHDR *)net_alloc_tx_packet(sizeof(ARPHDR));
-        if (ptr_arphdr == NULL)
-            return -1;
-
-        /* Populate the ARP Header. */
-        ptr_arphdr->HardType     = htons(0x1);
-        ptr_arphdr->ProtocolType = htons(0x800);
-        ptr_arphdr->HardSize     = 0x6;
-        ptr_arphdr->ProtocolSize = 0x4;
-        ptr_arphdr->Op           = htons(0x2);
-
-        /* Populate the Source IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->SrcAddr[0], (void *)&netmcb.net_device.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPSrc[0], (void *)&netmcb.net_device.ip_address, 4);
-
-        /* Populate the Target IP/MAC Address in the ARP Header */
-        memcpy ((void *)&ptr_arphdr->DstAddr[0], (void *)&net_arp_cache.mac_address[0], 6);
-        memcpy ((void *)&ptr_arphdr->IPDst[0], (void *)&net_arp_cache.ip_address, 4);
-
-        /* Create the Ethernet header. */
-        ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_arphdr, &net_arp_cache.mac_address[0], 0x806);
-        if (ptr_ethhdr == NULL)
-            return -1;
-
-        /* Send the packet out. */
-        net_send_packet (ptr_ethhdr, sizeof(ETHHDR) + sizeof(ARPHDR));
-
-        /* The packet has been transmitted and we can clean it up now. */
-        net_free_tx_packet ((Uint8 *)ptr_arphdr);
-    }
-
-    /* Check if there are any packet awaiting resolution? */
-    if (net_arp_cache.pending_packet_len != 0)
-    {
-        /* There was a packet in the ARP cache which was awaiting resolution. 
-         * We need to send out the packet now. */
-        ptr_pending_pkt = net_alloc_tx_packet(net_arp_cache.pending_packet_len);
-        if (ptr_pending_pkt == NULL)
-            return -1;
-
-        /* We now copy the contents of this packet from the ARP cache */
-        memcpy ((void *)ptr_pending_pkt, (void *)&net_arp_cache.pending_packet[0], 
-                    net_arp_cache.pending_packet_len);
-
-        /* We create the Ethernet header. 
-         *  Only IPv4 packets await resolution. */
-        ptr_ethhdr = net_create_eth_header ((Uint8 *)ptr_pending_pkt, &net_arp_cache.mac_address[0], 0x800);
-        if (ptr_ethhdr == NULL)
-            return -1;
-
-        /* Send the packet out. */
-        net_send_packet (ptr_ethhdr, sizeof(ETHHDR) + net_arp_cache.pending_packet_len);
-
-        /* The pending packet in the cache has been sent out. */
-        net_arp_cache.pending_packet_len = 0;
-
-        /* The packet has been transmitted and can be cleaned up. */
-        net_free_tx_packet (ptr_pending_pkt);
-
-        timer_delete (net_arp_cache.timer);
-    }
-
-    /* ARP Packet has been successfully processed. */
-    return 0;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function initializes the ARP Module in the NET Boot module.
- *
- *  @retval
- *      Not Applicable
- */
-void arp_init (void)
-{
-    memset (&net_arp_cache, 0, sizeof(NET_ARP_CACHE));
-    return;
-}
-
-
-
index bce01327dddd39959b09dc0ad82661140c0fa79b..134c2eae7e3f25e81ec4ca97be9699c8d9b4f35a 100644 (file)
@@ -17,6 +17,7 @@
 #include "timer.h"
 #include "stream.h"
 #include <string.h>
+#include "net_osal.h"
 
 
 /**********************************************************************
@@ -98,7 +99,7 @@ static void bootp_tmr_expiry (void)
     ptr_bootphdr->htype     = BOOTP_HTYPE_ETHERNET;
     ptr_bootphdr->hlen      = 6;
     ptr_bootphdr->xid       = htonl(0x1);
-    memcpy ((void *)&ptr_bootphdr->chaddr, (void *)&netmcb.net_device.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_bootphdr->chaddr, (void *)&netmcb.net_device.mac_address[0], 6);
 
     /* The packet has been populated; send it to the server. */
     udp_sock_send (bootpmcb.sock, (Uint8 *)ptr_bootphdr, sizeof(BOOTPHDR));
@@ -274,7 +275,7 @@ static Int32 bootp_receive (Int32 sock, Uint8* ptr_data, Int32 num_bytes)
     ip_add_route (FLG_RT_NETWORK, netmcb.net_device.ip_address, netmcb.net_device.net_mask, 0);
 
     if (netmcb.net_device.use_bootp_file_name == TRUE)
-        memcpy (netmcb.net_device.file_name, ptr_bootphdr->file, sizeof(netmcb.net_device.file_name));
+        netMemcpy (netmcb.net_device.file_name, ptr_bootphdr->file, sizeof(netmcb.net_device.file_name));
 
     /* Check if we had received a default router? */
     if (defaultRouter != 0)
@@ -319,7 +320,7 @@ void bootp_init (void (*asyncComplete)(void *))
     SOCKET      socket;
 
     /* Initialize the BOOT MCB */ 
-    memset ((void *)&bootpmcb, 0, sizeof(BOOTP_MCB));
+    netMemset ((void *)&bootpmcb, 0, sizeof(BOOTP_MCB));
 
     bootpmcb.asyncComplete = asyncComplete;
 
@@ -351,7 +352,7 @@ void bootp_init (void (*asyncComplete)(void *))
     ptr_bootphdr->htype     = BOOTP_HTYPE_ETHERNET;
     ptr_bootphdr->hlen      = 6;
     ptr_bootphdr->xid       = htonl(0x1);
-    memcpy ((void *)&ptr_bootphdr->chaddr, (void *)&netmcb.net_device.mac_address[0], 6);
+    netMemcpy ((void *)&ptr_bootphdr->chaddr, (void *)&netmcb.net_device.mac_address[0], 6);
 
     /* The packet has been populated; send it to the server. */
     udp_sock_send (bootpmcb.sock, (Uint8 *)ptr_bootphdr, sizeof(BOOTPHDR));
index f3144eca701c7cfb609ed225d1f3ebbc93a5a40d..07bc61954978a830b412f8c8bdc40dbc2f478411 100644 (file)
@@ -12,6 +12,7 @@
  */
 #include <blf.h>
 #include "netif.h"
+#include "net_osal.h"
 
 #ifdef INCLUDE_BLF_NET_MODULE
 #ifdef INCLUDE_BLF_NET_ICMP
@@ -106,7 +107,7 @@ void icmp_receive (IPHDR* ptr_iphdr)
         return;
 
     /* We can blindly copy the 'original' IP packet to the 'reply' IP packet. */
-    utl_memcpy ((void *)ptr_reply_iphdr, (void *)ptr_iphdr, (l4_pkt_size + IPHDR_SIZE));
+    netMemcpy ((void *)ptr_reply_iphdr, (void *)ptr_iphdr, (l4_pkt_size + IPHDR_SIZE));
 
     /* Get the pointer to the new header. 
      *  The new header starts after the IP header. */
index 86c2519ec1226c150b83e03874a54147d8b65dc4..27f0fe9d8d3e7b38dbd831b2178260485c088d75 100644 (file)
@@ -15,6 +15,7 @@
 #include "net.h"
 #include "netif.h"
 #include <string.h>
+#include "net_osal.h"
 
 
 /**
@@ -179,7 +180,7 @@ void ip_del_route (Uint32 flag)
     }
     
     /* Simply reset all the fields */
-    memset ((void *)ptr_rt, 0, sizeof(RT_ENTRY));
+    netMemset ((void *)ptr_rt, 0, sizeof(RT_ENTRY));
     return;
 }
 
@@ -386,7 +387,7 @@ void ip_send (IPHDR* ptr_iphdr, Uint16 size)
 void ip_init (void)
 {
     /* Reset the routing table */
-    memset (&rt_table, 0, sizeof(rt_table));
+    netMemset (&rt_table, 0, sizeof(rt_table));
     return;
 }
 
index 9215bac52afe56d6e6649109dadf8781f4c1142c..e120793ee33a94254a97326d82353354162bb5d6 100644 (file)
@@ -17,6 +17,7 @@
 #include "timer.h"
 #include "stream.h"
 #include <string.h>
+#include "net_osal.h"
 
 
 /**********************************************************************
@@ -120,7 +121,7 @@ Uint8* net_alloc_tx_packet(Int32 packet_len)
     netmcb.txuse = 1;
 
     /* Reset the contents of the packet */
-    memset ((void *)&netmcb.tx_packet[0], 0, sizeof(netmcb.tx_packet));
+    netMemset ((void *)&netmcb.tx_packet[0], 0, sizeof(netmcb.tx_packet));
 
     /* Reserve some space at the head of the packet for the Ethernet headers. */
     return &netmcb.tx_packet[16];
@@ -192,15 +193,15 @@ ETHHDR* net_create_eth_header (Uint8* ptr_l3_hdr, Uint8* dst_mac, Uint16 protoco
     /* Start adding the Ethernet header. 
      *  Move back the data pointer to account for the protocol. */
     ptr_l3_hdr = ptr_l3_hdr - 2;
-    memcpy ((void *)ptr_l3_hdr, (void *)&protocol, sizeof(Uint16));
+    netMemcpy ((void *)ptr_l3_hdr, (void *)&protocol, sizeof(Uint16));
 
     /* Move back the data pointer to account for the source MAC. */
     ptr_l3_hdr = ptr_l3_hdr - 6;
-    memcpy ((void *)ptr_l3_hdr, (void *)&netmcb.net_device.mac_address[0], 6);
+    netMemcpy ((void *)ptr_l3_hdr, (void *)&netmcb.net_device.mac_address[0], 6);
 
     /* Move back the data pointer to account for the destination MAC. */
     ptr_l3_hdr = ptr_l3_hdr - 6;
-    memcpy ((void *)ptr_l3_hdr, (void *)dst_mac, 6);
+    netMemcpy ((void *)ptr_l3_hdr, (void *)dst_mac, 6);
 
     /* Return the pointer to the start of the Ethernet header. */
     return (ETHHDR *)ptr_l3_hdr;
@@ -291,13 +292,13 @@ static Int32 net_open (void* ptr_driver, void (*asyncComplete)(void *))
     }
 
     /* Initialize the NET MCB. */
-    memset (&netmcb, 0, sizeof(NET_MCB));
+    netMemset (&netmcb, 0, sizeof(NET_MCB));
 
     /* Initialize the Network Statistics. */
-    memset (&net_stats, 0, sizeof(NET_STATS));
+    netMemset (&net_stats, 0, sizeof(NET_STATS));
 
     /* Copy the driver information into the NET MCB */
-    memcpy ((void *)&netmcb.net_device, (void *)ptr_net_driver, sizeof(NET_DRV_DEVICE));
+    netMemcpy ((void *)&netmcb.net_device, (void *)ptr_net_driver, sizeof(NET_DRV_DEVICE));
 
     /* Initialize the ARP Module. */
     arp_init ();
@@ -378,7 +379,7 @@ static void proc_packet (void)
     net_stats.num_pkt_rxed++;
 
     /* Extract the destination MAC Address from the received packet. */
-    memcpy ((void *)&dst_mac_address[0], (void *)ptr_data_packet, 6);
+    netMemcpy ((void *)&dst_mac_address[0], (void *)ptr_data_packet, 6);
 
     /* Extract the protocol from the received packet. This is at offset 12 from the 
      * start of the packet. We need to skip the destination and source mac address. */
diff --git a/src/driver/eth/net_orig.c b/src/driver/eth/net_orig.c
deleted file mode 100644 (file)
index 2efcbea..0000000
+++ /dev/null
@@ -1,471 +0,0 @@
-/** 
- *   @file  net.c
- *
- *   @brief   
- *      The file implements the NET Boot Module. 
- *
- *  \par
- *  NOTE:
- *      (C) Copyright 2008, Texas Instruments, Inc.
- *
- *  \par
- */
-#include "types.h"
-#include "iblloc.h"
-#include "net.h"
-#include "netif.h"
-#include "timer.h"
-#include "stream.h"
-#include <string.h>
-
-
-/**********************************************************************
- *************************** Local Functions **************************
- **********************************************************************/
-static Int32 net_open (void* ptr_net_driver);
-static Int32 net_close(void);
-static Int32 net_read (Uint8* ptr_buf, Uint32 num_bytes);
-
-/**********************************************************************
- *************************** GLOBAL Variables *************************
- **********************************************************************/
-
-/**
- * @brief   This is the NETWORK Master control block which keeps track
- * of all the Network boot module related information.
- */
-NET_MCB     netmcb;
-
-/**
- * @brief   This keeps track of the network statistics.
- */
-NET_STATS   net_stats;
-
-/**
- * @brief   This is the global Network Boot Module function table which
- * implements the Boot Module Interface with the kernel.
- */
-BOOT_MODULE_FXN_TABLE net_boot_module = 
-{
-    net_open,       /* Open  API                                      */
-    net_close,      /* Close API                                      */
-    net_read,       /* Read  API                                      */
-    NULL,           /* Write API (NULL: This is not interactive)      */
-    net_peek,       /* Peek  API (TBA)                                */
-};
-
-/**********************************************************************
- **************************** NET Functions ***************************
- **********************************************************************/
-
-/**
- *  @b Description
- *  @n
- *       The function is used to allocate a packet for transmission. This
- *       is called by the higher layer protocols when a packet needs to
- *       be transmitted. The function ensures there is sufficient space
- *       allocated at the beginning of the packet for the Ethernet header.
- *       Since the pointer returned by this API is used to store L3/L4 headers
- *       it always returns a 4 byte aligned buffer data pointer.
- *
- *  @param[in]  packet_len
- *      Length of the packet being transmitted.
- *
- *  @retval
- *      Success -   Pointer to the L3 header. 
- *  @retval
- *      Error   -   NULL
- */
-Uint8* net_alloc_tx_packet(Int32 packet_len)
-{
-    /* Sanity Check: Ensure the packet being allocated does not exceed the
-     * max buffer size that we have. */
-    if (packet_len > NET_MAX_MTU)
-        return NULL;
-
-    /* Sanity Check: Ensure that the packet is available for use. */
-    if (netmcb.txuse == 1)
-        return NULL;
-
-    /* Mark the packet as being in use. */
-    netmcb.txuse = 1;
-
-    /* Reset the contents of the packet */
-    memset ((void *)&netmcb.tx_packet[0], 0, sizeof(netmcb.tx_packet));
-
-    /* Reserve some space at the head of the packet for the Ethernet headers. */
-    return &netmcb.tx_packet[16];
-}
-
-/**
- *  @b Description
- *  @n
- *      The function is called to free up a previously allocated transmit
- *      packet. 
- *
- *  @param[in]  ptr 
- *      Pointer to the packet being cleaned.
- *
- *  @retval
- *      Not Applicable.
- */
-void net_free_tx_packet (Uint8* ptr)
-{
-    /* Sanity Checks: Ensure that the packet being cleaned is the same as the one 
-     * which was allocated. */
-    if (ptr != &netmcb.tx_packet[16])
-        mprintf ("ERROR: NET Free Transmit packet detected corruption\n");
-
-    /* Sanity Checks: Ensure that there is no double free. */
-    if (netmcb.txuse == 0)
-        mprintf ("ERROR: NET Free Transmit packet detected double free\n");
-
-    /* Mark the transmit packet as free and available. */
-    netmcb.txuse = 0;
-    return;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function is used to append an Ethernet header on the packet.
- *       The source MAC Address in the packet is always the one which was
- *       registered by the driver. Higher layer protocol authors need to 
- *       use the 'net_alloc_tx_packet' API to get a transmit buffer.
- *
- *  @param[in]  ptr_l3_hdr
- *      This is the pointer to the layer3 header.
- *  @param[in]  dst_mac
- *      The destination MAC address
- *  @param[in]  protocol
- *      The layer3 protocol version (passed in host order)
- *
- *  @retval
- *      Success -   Pointer to the start of the Ethernet header i.e. L2.
- *  @retval
- *      Error   -   NULL
- */
-ETHHDR* net_create_eth_header (Uint8* ptr_l3_hdr, Uint8* dst_mac, Uint16 protocol)
-{
-    Int32 rsvd_space;
-
-    /* Compute the reserved space. */
-    rsvd_space = (Int32)ptr_l3_hdr - (Int32)&netmcb.tx_packet[0];
-
-    /* Ensure there is sufficient space to add the header. We dont want memory corruption 
-     * to occur here. */
-    if ((rsvd_space < 0) || (rsvd_space > NET_MAX_MTU) || (rsvd_space < ETHHDR_SIZE))
-        return NULL;
-
-    /* Convert the protocol to network order. */
-    protocol = ntohs(protocol);
-
-    /* Start adding the Ethernet header. 
-     *  Move back the data pointer to account for the protocol. */
-    ptr_l3_hdr = ptr_l3_hdr - 2;
-    memcpy ((void *)ptr_l3_hdr, (void *)&protocol, sizeof(Uint16));
-
-    /* Move back the data pointer to account for the source MAC. */
-    ptr_l3_hdr = ptr_l3_hdr - 6;
-    memcpy ((void *)ptr_l3_hdr, (void *)&netmcb.net_device.mac_address[0], 6);
-
-    /* Move back the data pointer to account for the destination MAC. */
-    ptr_l3_hdr = ptr_l3_hdr - 6;
-    memcpy ((void *)ptr_l3_hdr, (void *)dst_mac, 6);
-
-    /* Return the pointer to the start of the Ethernet header. */
-    return (ETHHDR *)ptr_l3_hdr;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function is used to send a packet to the driver.
- *
- *  @param[in]  ptr_l2_hdr
- *      This is the pointer to the L2 header of the packet to be transmitted.
- *      All the headers need to be populated by the time comes to this API.
- *  @param[in]  length
- *      Length of the packet being transmitted. This include the L2 header
- *      information.
- *
- *  @retval
- *      Not Applicable.
- */
-void net_send_packet (ETHHDR* ptr_l2_hdr, Uint16 length)
-{
-    /* Sanity Check: This is called after the LAYER3 and ETHER headers 
-     * have been appended to the packet. Here we ensure that the layer3 header
-     * is aligned on the 4 byte boundary. */
-    if ( (((Uint32)ptr_l2_hdr+ETHHDR_SIZE) % 4) != 0)
-        mprintf ("ERROR: Misaligned Layer3 packet transmitted 0x%p.\n", ptr_l2_hdr);
-
-    /* Increment the stats. */
-    net_stats.num_pkt_txed++;
-
-    /* Pass the packet to the platform API for transmission. */
-    netmcb.net_device.send (&netmcb.net_device, (Uint8 *)ptr_l2_hdr, (Int32)length);
-    return;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function is called from any entity inside the NETWORK Boot Module
- *       to indicate that there has been a FATAL error and that the boot module
- *       processing needs to be aborted.
- *
- *  @retval
- *      Not Applicable.
- */
-void net_set_error (void)
-{
-    /* Set the Error Flag; */
-    netmcb.error_flag = 1;
-    return;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function opens the BLF NET Module. The function initializes
- *       the various internal components of the NET module and also
- *       initializes the peripheral driver controller 
- *
- *  @param[in]  ptr_driver
- *      This is the pointer to the driver block which was passed to 
- *      the BLF through the BOOT Mode descriptor. For the NET boot
- *      module this points to the NET_DRV_DEVICE object.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-static Int32 net_open (void* ptr_driver)
-{
-    NET_DRV_DEVICE* ptr_net_driver;
-
-    /* Get the pointer to the net driver. */
-    ptr_net_driver = (NET_DRV_DEVICE*)ptr_driver;
-
-    /* Basic Validation: Ensure there is a valid driver block being passed. */
-    if (ptr_net_driver == NULL)
-        return -1;
-
-    /* Basic Validation: Ensure that all the required API have been provided */
-    if ((ptr_net_driver->start == NULL)   || (ptr_net_driver->send == NULL) ||
-        (ptr_net_driver->receive == NULL) || (ptr_net_driver->stop == NULL))
-    {
-        /* Error: Required API was not specified. */
-        return -1;
-    }
-
-    /* Initialize the NET MCB. */
-    memset (&netmcb, 0, sizeof(NET_MCB));
-
-    /* Initialize the Network Statistics. */
-    memset (&net_stats, 0, sizeof(NET_STATS));
-
-    /* Copy the driver information into the NET MCB */
-    memcpy ((void *)&netmcb.net_device, (void *)ptr_net_driver, sizeof(NET_DRV_DEVICE));
-
-    /* Initialize the ARP Module. */
-    arp_init ();
-
-    /* Initialize the IP Module. */
-    ip_init ();
-
-    /* Initialize the UDP Module. */
-    udp_init ();
-
-    /* Start the networking device */
-    if (netmcb.net_device.start(&netmcb.net_device) < 0)
-        return -1;
-
-    /* Determine if we need to execute BOOTP or not? */
-    if (netmcb.net_device.ip_address != 0)
-    {
-        /* IP Address was supplied by the device team. There is no need 
-         * to execute the BOOTP protocol; manually create the network route also. */
-        ip_add_route (FLG_RT_NETWORK, netmcb.net_device.ip_address, netmcb.net_device.net_mask, 0);
-
-#ifdef INCLUDE_BLF_NET_TFTP
-        /* Lets download the file from the TFTP Server. */
-        tftp_get_file (netmcb.net_device.server_ip, netmcb.net_device.file_name);
-#endif /* INCLUDE_BLF_NET_TFTP */
-    }
-    else
-    {
-#ifdef INCLUDE_BLF_NET_BOOTP
-        /* No IP Address was supplied we need to execute the BOOTP protocol. */
-        bootp_init ();
-#endif
-    }
-   
-    /* The network module is UP and running.. */ 
-    return 0;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function closes the BLF NET Module.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-static Int32 net_close (void)
-{
-    return 0;
-}
-
-/**
- *  @b Description
- *  @n  
- *       The function reads data from the BLF net module.
- *
- *  @param[in]  ptr_buf
- *      This points to the data buffer which needs to be populated
- *      with the received data.
- *
- *  @param[in]  num_bytes
- *      This is the number of bytes of data which need to be read.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-static Int32 net_read (Uint8* ptr_buf, Uint32 num_bytes)
-{
-    Int32       packet_size;
-    Uint16      protocol;
-    Uint8       dst_mac_address[6];
-    Uint8*      ptr_data_packet;
-    Int32       num_bytes_read       = 0;
-    Int32       total_num_bytes_read = 0;
-
-    /* Basic Validations: Ensure that the parameters are valid. */
-    if ((ptr_buf == NULL) || (num_bytes == 0))
-        return -1;
-
-    /* Execute the network scheduler; till there is no error. */
-    while (netmcb.error_flag == 0) 
-    {
-        /* Call the timer scheduler. */
-        timer_run();
-
-        /* Check if there is data in the STREAM? */
-        if (stream_isempty() == FALSE)
-        {
-            /* STREAM indicates there is some data. Lets read it first. */
-            num_bytes_read = stream_read (((ptr_buf + total_num_bytes_read)), num_bytes);
-
-            /* Keep track of the total amount of data read till now. */
-            total_num_bytes_read = total_num_bytes_read + num_bytes_read;
-
-            /* How much more data do we need to read? */ 
-            num_bytes = num_bytes - num_bytes_read;
-
-            /* Check if we have read all the data that was requested? */
-            if (num_bytes == 0)
-                break;
-    
-            /* Control comes here implies that there was more data to be read into
-             * the buffer. We need it to have it available before we can exit the loop.
-             * So lets fall through! */
-        }
-        else
-        {
-            /* STREAM Module is empty. */
-        }
-
-        /* Initialize the pointer in the received packet is stored. 
-         *  This is misaligned on the 2 byte boundary as this will ensure that
-         *  the layer3 headers i.e. IPv4 and ARP are aligned correctly. */
-        ptr_data_packet = (Uint8 *)&netmcb.rx_packet[2];
-
-        /* Check if a packet has been received? */
-        packet_size = netmcb.net_device.receive(&netmcb.net_device, ptr_data_packet);
-        if (packet_size == 0)
-            continue;
-
-        /* Increment the number of packets received. */
-        net_stats.num_pkt_rxed++;
-
-        /* Extract the destination MAC Address from the received packet. */
-        memcpy ((void *)&dst_mac_address[0], (void *)ptr_data_packet, 6);
-
-        /* Extract the protocol from the received packet. This is at offset 12 from the 
-         * start of the packet. We need to skip the destination and source mac address. */
-        protocol = *((Uint16 *)(ptr_data_packet + 12));
-        protocol = ntohs(protocol);
-
-        /* Process the received data.
-         *  Check the destination mac address to determine if the packet is 
-         *  meant for us or not? We accept only directed UNICAST & BROADCAST
-         *  packets */
-        if(((dst_mac_address[0] != 0xFF) || (dst_mac_address[1] != 0xFF) || 
-            (dst_mac_address[2] != 0xFF) || (dst_mac_address[3] != 0xFF) || 
-            (dst_mac_address[4] != 0xFF) || (dst_mac_address[5] != 0xFF)) && 
-           ((dst_mac_address[0] != netmcb.net_device.mac_address[0]) ||
-            (dst_mac_address[1] != netmcb.net_device.mac_address[1]) ||
-            (dst_mac_address[2] != netmcb.net_device.mac_address[2]) ||
-            (dst_mac_address[3] != netmcb.net_device.mac_address[3]) ||
-            (dst_mac_address[4] != netmcb.net_device.mac_address[4]) ||
-            (dst_mac_address[5] != netmcb.net_device.mac_address[5])))
-        {
-            /* Packet is not meant for us; ignore this packet. */
-            net_stats.rx_l2_dropped++;
-            continue;
-        }
-
-        /* Move the pointer to the data packet and skip the ethernet header. */
-        ptr_data_packet = ptr_data_packet + sizeof(ETHHDR);
-
-        /* Deduct the Ethernet header size from the total number of bytes received. */
-        packet_size = packet_size - sizeof(ETHHDR);
-
-        /* Sanity Check: We need to ensure that the Layer3 headers are aligned on the
-         * 4 byte boundary at this stage. */
-        if (((Uint32)ptr_data_packet % 4) != 0)
-            mprintf ("ERROR: Misaligned Layer3 packet received 0x%p.\n", ptr_data_packet);
-
-        /* Demux on the protocol basis and pass it to the upper layer. */
-        switch (protocol)
-        {
-            case ETH_IP:
-            {
-                /* IPv4 Packet. */
-                if (ip_receive ((IPHDR *)ptr_data_packet, packet_size) < 0)
-                    net_stats.rx_ip_dropped++;
-                break;
-            }
-            case ETH_ARP:
-            {
-                /* ARP Packet. */
-                if (arp_receive ((ARPHDR *)ptr_data_packet, packet_size) < 0)
-                    net_stats.rx_arp_dropped++;
-                break;
-            }
-            default:
-            {
-                /* Unexpected packet. Drop the packet! */
-                net_stats.rx_l2_dropped++;
-                break;
-            }
-        }
-    }
-
-    /* Did we come out because of error or not? */
-    if (netmcb.error_flag == 0)
-        return 0;
-
-    /* Return error */
-    return -1;
-}
-
-
diff --git a/src/driver/eth/net_osal.h b/src/driver/eth/net_osal.h
new file mode 100644 (file)
index 0000000..21233f4
--- /dev/null
@@ -0,0 +1,11 @@
+/**
+ *  @file net_osal.h
+ *
+ *  @brief
+ *             operating system abstraction layer definitions specific for the c64x ibl
+ */
+#include "iblloc.h"
+
+#define netMemset iblMemset
+#define netMemcpy iblMemcpy
index 2d7c526e4b78f2018b955e82e9914c43c6dbcd45..42e5d12c05c99a249dda3d36191a90f15918a8c5 100644 (file)
@@ -17,6 +17,7 @@
 #include "timer.h"
 #include "stream.h"
 #include <string.h>
+#include "net_osal.h"
 
 
 /**********************************************************************
@@ -195,7 +196,7 @@ static void tftp_send_ack(void)
     TFTPHDR* ptr_tftphdr;
 
     /* Initialize the data buffer. */ 
-    memset ((void *)&tftpmcb.buffer[0], 0, TFTP_DATA_SIZE + TFTPHEADER_SIZE);
+    netMemset ((void *)&tftpmcb.buffer[0], 0, TFTP_DATA_SIZE + TFTPHEADER_SIZE);
 
     /* Create an ACK packet which is to be sent out. Get the pointer to the
      * TFTP Header. */
@@ -453,7 +454,7 @@ Int32 tftp_get_file (IPN server_ip, Int8* filename)
     }
 
     /* Initialize the TFTP MCB at this stage... */
-    memset ((void *)&tftpmcb, 0, sizeof(TFTP_MCB));
+    netMemset ((void *)&tftpmcb, 0, sizeof(TFTP_MCB));
 
     /* Populate the socket structure and register this with the UDP module. */
     socket.local_port       = 1234;
index 7283d2c57e5dd3ce6bc1aa4d6c3493412e5371d0..c5d32a56eec87757c8f20f44d07b6305d99bc662 100644 (file)
@@ -16,6 +16,7 @@
 #include "netif.h"
 #include "iblcfg.h"
 #include <string.h>
+#include "net_osal.h"
 
 
 /**********************************************************************
@@ -190,7 +191,7 @@ Int32 udp_sock_open (SOCKET* ptr_socket)
         if (udp_socket[index].local_port == 0)
         {
             /* Got a free slot. Copy the socket data over and return the index as the handle. */
-            memcpy ((void *)&udp_socket[index], (void *)ptr_socket, sizeof(SOCKET));
+            netMemcpy ((void *)&udp_socket[index], (void *)ptr_socket, sizeof(SOCKET));
             return index;
         }
     }
@@ -245,7 +246,7 @@ Int32 udp_sock_send (Int32 sock, Uint8* ptr_app_data, Int32 num_bytes)
     /*******************************************************************************
      ********************************* APP Data ************************************
      *******************************************************************************/
-    memcpy ((void *)ptr_data, (void *)ptr_app_data, num_bytes);
+    netMemcpy ((void *)ptr_data, (void *)ptr_app_data, num_bytes);
 
     /*******************************************************************************
      ********************************* UDP Header **********************************
@@ -299,7 +300,7 @@ void udp_sock_close (Int32 sock)
     ptr_socket = &udp_socket[sock];
 
     /* Reset the memory block */
-    memset ((void *)ptr_socket, 0, sizeof(SOCKET));
+    netMemset ((void *)ptr_socket, 0, sizeof(SOCKET));
     return;
 }
 
@@ -314,7 +315,7 @@ void udp_sock_close (Int32 sock)
 void udp_init (void)
 {
     /* Initialize the socket table */
-    memset (&udp_socket, 0, sizeof(udp_socket));
+    netMemset (&udp_socket, 0, sizeof(udp_socket));
     return;
 }
 
index 90e80167128892c29ad61bb1287457bc3244b906..8bb5570cec1d9e97ba30e0c9c3e351705cca770f 100644 (file)
@@ -104,16 +104,16 @@ Int32 nand_seek (Int32 loc, Int32 from)
 Int32 nand_free_return (Int32 retcode)
 {
     if (nandmcb.page != NULL)
-        free (nandmcb.page);
+        iblFree (nandmcb.page);
 
     if (nandmcb.logicalToPhysMap != NULL)
-        free (nandmcb.logicalToPhysMap);
+        iblFree (nandmcb.logicalToPhysMap);
 
     if (nandmcb.physToLogicalMap != NULL)
-        free (nandmcb.physToLogicalMap);
+        iblFree (nandmcb.physToLogicalMap);
 
     if (nandmcb.blocks != NULL)
-        free (nandmcb.blocks);
+        iblFree (nandmcb.blocks);
 
     return (retcode);
 
@@ -137,8 +137,8 @@ Int32 nand_open (void *ptr_driver, void (*asyncComplete)(void *))
     Int32 i, j;
 
     /* Initialize the control info */
-    memset (&nandmcb, 0, sizeof(nandmcb));
-    memcpy (&nandmcb.devInfo, &ibln->nandInfo, sizeof(iblNand_t));
+    iblMemset (&nandmcb, 0, sizeof(nandmcb));
+    iblMemcpy (&nandmcb.devInfo, &ibln->nandInfo, sizeof(iblNand_t));
 
     nandmcb.page             = NULL;
     nandmcb.logicalToPhysMap = NULL;
@@ -151,25 +151,25 @@ Int32 nand_open (void *ptr_driver, void (*asyncComplete)(void *))
 
     /* allocate memory for the page data and the logical to physical block map */
     size = nandmcb.devInfo.pageSizeBytes + nandmcb.devInfo.pageEccBytes;
-    nandmcb.page = malloc (size * sizeof(Uint8));
+    nandmcb.page = iblMalloc (size * sizeof(Uint8));
     if (nandmcb.page == NULL)
         nand_free_return (NAND_MALLOC_PAGE_FAIL);
 
 
     /* Logical to physical map data */
-    nandmcb.logicalToPhysMap = malloc (nandmcb.devInfo.totalBlocks * sizeof(Uint16));
+    nandmcb.logicalToPhysMap = iblMalloc (nandmcb.devInfo.totalBlocks * sizeof(Uint16));
     if (nandmcb.logicalToPhysMap == NULL)  
         nand_free_return (NAND_MALLOC_MAP_LTOP_FAIL);
     
 
     /* Physical to logical map data */
-    nandmcb.physToLogicalMap = malloc (nandmcb.devInfo.totalBlocks * sizeof(Uint16));
+    nandmcb.physToLogicalMap = iblMalloc (nandmcb.devInfo.totalBlocks * sizeof(Uint16));
     if (nandmcb.physToLogicalMap == NULL)  
         nand_free_return (NAND_MALLOC_MAP_PTOL_FAIL);
 
     /* Block info */
     size = nandmcb.devInfo.totalBlocks * sizeof(Uint8);
-    nandmcb.blocks = malloc (size);
+    nandmcb.blocks = iblMalloc (size);
     if (nandmcb.blocks == NULL)  
         nand_free_return (NAND_MALLOC_BLOCK_INFO_FAIL);
 
index 26a1c2708037d79af29eb687f27b95e43305061c..4c137a29b281d6e34810eb5fde7e8f0b21abf8e7 100644 (file)
@@ -17,6 +17,7 @@
  **********************************************************************/
 #include "types.h"
 #include "iblcfg.h"
+#include "stream_osal.h"
 #include <string.h>
 
 /** 
@@ -313,7 +314,7 @@ void stream_close (void)
 void stream_init (void)
 {
     /* Reset the memory contents. */
-    memset ((void *)&stream_mcb, 0, sizeof(STREAM_MCB));
+    streamMemset ((void *)&stream_mcb, 0, sizeof(STREAM_MCB));
 
     /* Make sure we initialize the free size correctly. */
     stream_mcb.free_size = MAX_SIZE_STREAM_BUFFER;
diff --git a/src/driver/stream/stream_osal.h b/src/driver/stream/stream_osal.h
new file mode 100644 (file)
index 0000000..a74583b
--- /dev/null
@@ -0,0 +1,10 @@
+/**
+ *  @file stream_osal.h
+ *
+ *  @brief
+ *             operating system abstraction layer definitions specific for the c64x ibl
+ */
+#include "iblloc.h"
+
+#define streamMemset iblMemset
index 51b3e4b46c9c46981fe114bb568ac8c86a8dde35..4462bbd1508701a25232bc52db2e7dc46bfad3e7 100644 (file)
@@ -15,6 +15,7 @@
  #include "timer.h"
  #include "devtimer.h"
  #include "iblcfg.h"
+ #include "timer_osal.h"
  #include <string.h>
 
 
@@ -97,7 +98,7 @@ TIMER_MCB   timermcb;
 void timer_init (void)
 {
     /* Initialize the Timer Master Control Block. */
-    memset (&timermcb, 0, sizeof(TIMER_MCB));
+    timerMemset (&timermcb, 0, sizeof(TIMER_MCB));
     return;
 }
 
@@ -184,7 +185,7 @@ void timer_delete (Int32 handle)
     if (timermcb.num_active_timers > 0)
     {
         /* Simply reset the memory contents */
-        memset ((void *)&timermcb.timer[handle], 0, sizeof(TIMER_BLOCK));
+        timerMemset ((void *)&timermcb.timer[handle], 0, sizeof(TIMER_BLOCK));
 
         /* Decrement the number of active timers in the system */
         timermcb.num_active_timers--;
diff --git a/src/driver/timer/timer_osal.h b/src/driver/timer/timer_osal.h
new file mode 100644 (file)
index 0000000..41953b9
--- /dev/null
@@ -0,0 +1,10 @@
+/**
+ *  @file timer_osal.h
+ *
+ *  @brief
+ *             operating system abstraction layer definitions specific for the c64x ibl
+ */
+#include "iblloc.h"
+
+#define timerMemset iblMemset
index c4e2f52f845b47163ab325f256bb6e2cdeccc258..e0f7548997a4a761416880edc32f51bc489d4a1e 100644 (file)
@@ -21,6 +21,7 @@
 #include "device.h"
 #include "mdioapi.h"
 #include <string.h>
+#include "net_osal.h"
 
 /**
  *  @brief Remove the possible re-definition of iblEthBoot. iblcfg.h defines this to be a void
@@ -56,7 +57,7 @@ void ibl_rec_params (void *params)
     UNFORM_IPN(iblStatus.ethParams.ipAddr, netdev->ip_address);
     UNFORM_IPN(iblStatus.ethParams.serverIp, netdev->server_ip);
 
-    memcpy (iblStatus.ethParams.hwAddress, netdev->mac_address, sizeof(iblStatus.ethParams.hwAddress));
+    netMemcpy (iblStatus.ethParams.hwAddress, netdev->mac_address, sizeof(iblStatus.ethParams.hwAddress));
     strncpy (iblStatus.ethParams.fileName, netdev->file_name, sizeof(iblStatus.ethParams.fileName));
 
 }
@@ -94,7 +95,7 @@ void iblEthBoot (Int32 eIdx)
     nDevice.port_num = ibl.ethConfig[eIdx].port;
 
     /* Simple transation to initialize the driver */
-    memcpy (nDevice.mac_address, ibl.ethConfig[eIdx].ethInfo.hwAddress, sizeof(nDevice.mac_address));
+    netMemcpy (nDevice.mac_address, ibl.ethConfig[eIdx].ethInfo.hwAddress, sizeof(nDevice.mac_address));
 
     nl = FORM_IPN(ibl.ethConfig[eIdx].ethInfo.ipAddr);
     if (ibl.ethConfig[eIdx].doBootp == TRUE)
@@ -110,7 +111,7 @@ void iblEthBoot (Int32 eIdx)
     nDevice.use_bootp_server_ip = ibl.ethConfig[eIdx].useBootpServerIp;
 
     /* Note - the file name structure in nDevice is only 64 bytes, but 128 in ethInfo */
-    memcpy (nDevice.file_name, ibl.ethConfig[eIdx].ethInfo.fileName, sizeof(nDevice.file_name));
+    netMemcpy (nDevice.file_name, ibl.ethConfig[eIdx].ethInfo.fileName, sizeof(nDevice.file_name));
     nDevice.use_bootp_file_name = ibl.ethConfig[eIdx].useBootpFileName;
 
 
index 11adee8b953bb9ab1bb0f3d99ce018f4b07a4d74..c32f5bd33478df110868861fbde16d6bf14a6307 100644 (file)
@@ -418,7 +418,7 @@ Int32 cpmac_drv_receive (NET_DRV_DEVICE* ptr_device, Uint8* buffer)
         pDesc->PktFlgLen = EMAC_DSC_FLAG_OWNER;
 
         /* Copy the data from the descriptor buffer to the supplied buffer. */
-        memcpy((void *)buffer, (void *)pDesc->pBuffer, bytes_received);
+        iblMemcpy((void *)buffer, (void *)pDesc->pBuffer, bytes_received);
 
         /* Put this descriptor back to the HDP. */
         ptr_EMACRegs->RX0HDP = (Uint32)pDesc;
diff --git a/src/hw/macs/cpmac/cpmacdrv.orig.c b/src/hw/macs/cpmac/cpmacdrv.orig.c
deleted file mode 100644 (file)
index 00d15eb..0000000
+++ /dev/null
@@ -1,392 +0,0 @@
-/**
- *   @file  cpmacdrv.c
- *
- *   @brief   
- *      The driver is written for the CPMAC Ethernet controller. It follows
- *      the Network Boot Module Ethernet Driver Specifications.
- *
- *      If there are modifications to this driver required for it to work
- *      on the specific device then device authors are recommended to 
- *      create a copy of this file in the RBL directory and do the 
- *      necessary modifications. Please pass on the appropriate information
- *      to the ROM Boot Loader Framework Development Team.
- *
- *  \par
- *  NOTE:
- *      (C) Copyright 2008, Texas Instruments, Inc.
- *  \par
- */
-#include "types.h"
-#include "iblloc.h"
-#include "device.h"
-#include "net.h"
-#include "cpmac_regs.h"
-#include <string.h>
-
-
-/**********************************************************************
- ************************** Local Definitions *************************
- **********************************************************************/
-
-// Packet Flags for TX and RX
-#define EMAC_DSC_FLAG_SOP                       0x80000000u
-#define EMAC_DSC_FLAG_EOP                       0x40000000u
-#define EMAC_DSC_FLAG_OWNER                     0x20000000u
-#define EMAC_DSC_FLAG_EOQ                       0x10000000u
-#define EMAC_DSC_FLAG_TDOWNCMPLT                0x08000000u
-#define EMAC_DSC_FLAG_PASSCRC                   0x04000000u
-
-// The following flags are RX only
-#define EMAC_DSC_FLAG_JABBER                    0x02000000u
-#define EMAC_DSC_FLAG_OVERSIZE                  0x01000000u
-#define EMAC_DSC_FLAG_FRAGMENT                  0x00800000u
-#define EMAC_DSC_FLAG_UNDERSIZED                0x00400000u
-#define EMAC_DSC_FLAG_CONTROL                   0x00200000u
-#define EMAC_DSC_FLAG_OVERRUN                   0x00100000u
-#define EMAC_DSC_FLAG_CODEERROR                 0x00080000u
-#define EMAC_DSC_FLAG_ALIGNERROR                0x00040000u
-#define EMAC_DSC_FLAG_CRCERROR                  0x00020000u
-#define EMAC_DSC_FLAG_NOMATCH                   0x00010000u
-
-/**********************************************************************
- ************************** Local Structures **************************
- **********************************************************************/
-
-/**
- * @brief 
- *  The structure describes the EMAC Descriptor.
- *
- * @details
- *  Ethernet drivers receives and transmits data through the descriptor
- *  object described here.
- */
-typedef struct _EMAC_Desc 
-{
-    /**
-     * @brief   Pointer to next descriptor in chain
-     */
-    struct _EMAC_Desc* pNext;
-
-    /**
-     * @brief   Pointer to the data buffer.
-     */
-    Uint8*             pBuffer;
-
-    /**
-     * @brief   Buffer Offset(MSW) and Length(LSW)
-     */
-    Uint32             BufOffLen;
-
-    /**
-     * @brief   Packet Flags(MSW) and Length(LSW)
-     */
-    volatile Uint32    PktFlgLen;
-}EMAC_Desc;
-
-/**
- * @brief 
- *  The structure describes the EMAC Master Control Block.
- *
- * @details
- *  The structure stores information required by the EMAC Driver;
- *  which includes the Receive and Transmit Buffer Descriptors.
- */
-typedef struct EMAC_MCB
-{
-    /**
-     * @brief   Pointer to the Receive Buffer Descriptor
-     */
-    EMAC_Desc*      rx_bd;
-
-    /**
-     * @brief   Pointer to the Transmit Buffer Descriptor
-     */
-    EMAC_Desc*      tx_bd;
-
-    /**
-     * @brief   Buffer for receiving data linked with the receive
-     * buffer descriptor.
-     */
-    Uint8           rx_buffer[NET_MAX_MTU];
-}EMAC_MCB;
-
-/**********************************************************************
- ************************** Global Variables **************************
- **********************************************************************/
-
-/**
- * @brief   Global Driver structure which keeps track of all the Ethernet
- * Driver related information.
- */
-EMAC_MCB   emacMCB;
-
-/**
- * @brief   EMAC Registers.
- */
-CPMAC_REGS*  ptr_EMACRegs = (CPMAC_REGS *)EMAC_BASE_ADDRESS;
-
-/**********************************************************************
- ************************** ETHDRV Functions **************************
- **********************************************************************/
-
-/**
- *  @b Description
- *  @n  
- *      This is the Network Open API which is registered with the 
- *      NET Boot module to initialize the Ethernet device.
- *
- *  @param[in]  ptr_device
- *      Pointer to the NET Device structure which is being opened.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-Int32 cpmac_drv_start (NET_DRV_DEVICE* ptr_device)
-{
-    Uint32           tmpval;
-    volatile Uint32* pRegAddr;
-    Int32            index;
-    EMAC_Desc*       pDesc;
-    
-    /* Reset EMAC */
-    ptr_EMACRegs->SOFTRESET = 0x1;
-    while (ptr_EMACRegs->SOFTRESET != 0x0);
-
-    /* Reset MAC Control */
-    ptr_EMACRegs->MACCONTROL = 0;
-
-    /* Must manually init HDPs to NULL */
-    pRegAddr = &ptr_EMACRegs->TX0HDP;
-    for( index=0; index<8; index++ )
-        *pRegAddr++ = 0;
-    pRegAddr = &ptr_EMACRegs->RX0HDP;
-    for( index=0; index<8; index++ )
-        *pRegAddr++ = 0;
-
-    /* Initialize the RAM locations */
-    for (index = 0; index < 32; index++)
-    {
-        ptr_EMACRegs->MACINDEX  = index;
-        ptr_EMACRegs->MACADDRHI = 0;
-        ptr_EMACRegs->MACADDRLO = 0;
-    }
-
-    /* Setup device MAC address */
-    ptr_EMACRegs->MACINDEX = 0x0;
-
-    /* Configure the MAC Address into the EMAC Controller. */
-    tmpval = 0;
-    for( index=3; index>=0; index-- )
-        tmpval = (tmpval<<8) | *(ptr_device->mac_address+index);
-    ptr_EMACRegs->MACADDRHI = tmpval;
-    tmpval = *(ptr_device->mac_address+5);
-    ptr_EMACRegs->MACADDRLO = CPMAC_MACADDRLO_VALID | CPMAC_MACADDRLO_MATCHFILT | 
-                              (tmpval<<8) | *(ptr_device->mac_address+4);
-
-    /* For us buffer offset will always be zero */
-    ptr_EMACRegs->RXBUFFEROFFSET = 0;
-
-    /* Reset RX (M)ulticast (B)roadcast (P)romiscuous Enable register */
-    ptr_EMACRegs->RXMBPENABLE = 0;
-    ptr_EMACRegs->MACHASH1    = 0;
-    ptr_EMACRegs->MACHASH2    = 0;
-
-    /* Clear Unicast RX on channel 0-7 */
-    ptr_EMACRegs->RXUNICASTCLEAR = 0xFF;
-
-    /* Make sure there are none of the interrupts are enabled. */
-    ptr_EMACRegs->RXINTMASKCLEAR = 0xFF;
-    ptr_EMACRegs->TXINTMASKCLEAR = 0xFF;
-    ptr_EMACRegs->MACINTMASKCLEAR = 0x0;
-
-    /* Setup the receive buffer descriptors. */
-    pDesc = (EMAC_Desc *)_EMAC_DSC_BASE_ADDR;
-
-    /* Initialize the receive buffer descriptor. */
-    pDesc->pNext     = 0;
-    pDesc->pBuffer   = &emacMCB.rx_buffer[0];
-    pDesc->BufOffLen = NET_MAX_MTU;
-    pDesc->PktFlgLen = EMAC_DSC_FLAG_OWNER;
-
-    /* Store this buffer descriptor in the global EMAC MCB */
-    emacMCB.rx_bd = pDesc;
-
-    /* Get the transmit buffer descriptor; it comes right after the receive BD. */
-    pDesc = pDesc + 1;
-
-    /* Initialize the transmit buffer descriptor. */
-    pDesc->pNext     = 0;
-    pDesc->pBuffer   = 0;
-    pDesc->BufOffLen = 0;
-    pDesc->PktFlgLen = 0;
-
-    /* Store this buffer descriptor in the global EMAC MCB */
-    emacMCB.tx_bd = pDesc;
-
-#ifdef EMAC_CACHE_SUPPORT
-    /* Writeback the EMAC MCB Information to the PHYSICAL Memory. 
-     * This is required because the buffer in the cache will always be
-     * invalidated on the RECEIVE; if the buffer is not aligned on the
-     * CACHE Line then it will result in the RX & TX BD in the structure
-     * to also get invalidated to what resides in the PHYSICAL memory.
-     * But if we have written back the structure here then the PHYSICAL
-     * and CACHE are one and the same as far as the BD's are concerned. */
-    Cache_wbL2((void *)&emacMCB, sizeof(emacMCB));
-#endif
-
-    /* Enable the receive and transmit. */
-    ptr_EMACRegs->TXCONTROL = 0x1;
-    ptr_EMACRegs->RXCONTROL = 0x1;
-    
-    /* Initialize the MAC Control: We set the Receive Ownership Bit and the Receive
-     * Offset Length Word and enable the MII. */
-    ptr_EMACRegs->MACCONTROL = CPMAC_MACCONTROL_RXOWNERSHIP | 
-                               CPMAC_MACCONTROL_RXOFFLENBLOCK | 
-                               CPMAC_MACCONTROL_MIIEN;
-
-    /* Startup RX */
-    ptr_EMACRegs->RX0HDP = (Uint32)emacMCB.rx_bd;
-
-    /* Enable receive filters for channel 1 and all broadcast packets. */
-    ptr_EMACRegs->RXUNICASTSET = 1;
-    ptr_EMACRegs->RXMBPENABLE = CPMAC_RXMBPENABLE_RXBROADEN;
-
-    /* Initialize the Device MDIO layer: The function returns only when 
-     * the LINK is UP and RUNNING. */
-    if (dev_mdio_open () < 0)
-        return -1;        
-
-    /* Debug Message: */
-    mprintf ("DEBUG: Ethernet Link is UP \n");
-
-    /* Hardware is up and running. */
-    return 0;
-}
-
-/**
- *  @b Description
- *  @n
- *      This is the Network Send API which is registered with the NET boot module
- *      to send out packets. 
- *
- *  @param[in]   ptr_device
- *      Pointer to the network interface descriptor object.
- *  @param[in]   buffer
- *      Pointer to the packet which is to be transmitted.
- *  @param[in]   num_bytes
- *      Length of the packet which is transmitted.
- *
- *  @retval
- *      Success -   Number of bytes transmitted.
- *  @retval
- *      Error   -   <0
- */
-Int32 cpmac_drv_send (NET_DRV_DEVICE* ptr_device, Uint8* buffer, int num_bytes)
-{
-    volatile EMAC_Desc* pDesc;
-
-    /* Ensure the minimum ethernet size is sent out. */
-    if (num_bytes < 64)
-        num_bytes = 64;
-
-#ifdef EMAC_CACHE_SUPPORT
-    /* Clean the cache for external addesses */
-    Cache_wbL2((void *)buffer, num_bytes);
-#endif
-
-    /* Get the pointer to the transmit buffer descriptor. */
-    pDesc = emacMCB.tx_bd;
-
-    /* Fill out the transmit buffer descriptor */
-    pDesc->pNext     = 0;
-    pDesc->pBuffer   = buffer;
-    pDesc->BufOffLen = num_bytes;
-    pDesc->PktFlgLen = EMAC_DSC_FLAG_SOP | EMAC_DSC_FLAG_EOP | num_bytes | EMAC_DSC_FLAG_OWNER;
-
-    /* Send the packet out. */
-    ptr_EMACRegs->TX0HDP = (Uint32)pDesc;
-
-    /* Loop around till the transmission is complete. */
-    pDesc = (EMAC_Desc *)ptr_EMACRegs->TX0CP;
-    while (pDesc->PktFlgLen & EMAC_DSC_FLAG_OWNER);
-
-    /* The packet has been successfully transmitted. */
-    return num_bytes;
-}
-
-/**
- *  @b Description
- *  @n
- *      This is the Network Receive API which is registered with the NET boot module
- *      to receive packets. 
- *
- *  @param[in]   ptr_device
- *      Pointer to the network interface descriptor object.
- *  @param[out]   buffer
- *      Pointer to the packet which is populated with the received data
- *
- *  @retval
- *      Success -   Number of bytes received.
- *  @retval
- *      Error   -   <0
- */
-Int32 cpmac_drv_receive (NET_DRV_DEVICE* ptr_device, Uint8* buffer)
-{
-    Int32       bytes_received = 0;
-    EMAC_Desc*  pDesc;
-
-    /* Initialize the number of bytes received. */
-    bytes_received = 0;
-
-    /* Read the completion register. We know for sure if the SOP flag is set then
-     * a packet has been received and needs to be picked up from the controller. */
-    pDesc = (EMAC_Desc *)ptr_EMACRegs->RX0CP;
-    if (pDesc->PktFlgLen & EMAC_DSC_FLAG_SOP)
-    {
-        /* Acknowledge that the descriptor has been processed. */
-        ptr_EMACRegs->RX0CP = (Uint32)pDesc;
-
-#ifdef EMAC_CACHE_SUPPORT
-               /* External Memory Support: Invalidate the cache. */
-        Cache_invL2((void *)(pDesc->pBuffer), NET_MAX_MTU);
-#endif
-        /* Remember the number of bytes received. */
-        bytes_received = (pDesc->PktFlgLen & 0xFFFF);
-
-        /* The descriptor is now free to receive more data. Set the status accordingly. */
-        pDesc->BufOffLen = NET_MAX_MTU;
-        pDesc->PktFlgLen = EMAC_DSC_FLAG_OWNER;
-
-        /* Copy the data from the descriptor buffer to the supplied buffer. */
-        memcpy((void *)buffer, (void *)pDesc->pBuffer, bytes_received);
-
-        /* Put this descriptor back to the HDP. */
-        ptr_EMACRegs->RX0HDP = (Uint32)pDesc;
-    }
-
-    /* Return the number of bytes received. */
-    return bytes_received;
-}
-
-/**
- *  @b Description
- *  @n
- *      This is the Network Close API which is registered with the NET boot module
- *      to close and shutdown the Ethernet controller.
- *
- *  @param[in]   ptr_device
- *      Pointer to the network interface descriptor object.
- *
- *  @retval
- *      Success -   0
- *  @retval
- *      Error   -   <0
- */
-Int32 cpmac_drv_stop (NET_DRV_DEVICE* ptr_device)
-{
-    return 0;
-}
-
-
index f8e75d5bb0f2b5648246b842fbacf2250c40a287..5574d05bf03ad3bb7448a75f8869c094e7152a61 100644 (file)
--- a/src/ibl.h
+++ b/src/ibl.h
@@ -497,8 +497,12 @@ typedef struct iblI2cMap_s
 {
     uint16  length;         /**<  Size of the structure in bytes */
     uint16  chkSum;         /**<  Value which makes the ones complement checksum over the block equal to 0 or -0 */
+    
     uint32  addrLe;         /**<  Base address of the boot tables for the little endian image */
+    uint32  configLe;       /**<  Base address of the ibl structure for use with the little endian image */
+    
     uint32  addrBe;         /**<  Base address of the boot tables for the big endian image */
+    uint32  configBe;       /**<  Base address of the ibl structure for use with the big endian image */
 
 } iblI2cMap_t;
 
index 02d28e2d12afd9b2d8a0a4736c866eeab6855f6f..62d1e045e72706bde295edc284e73d575a537688 100644 (file)
@@ -73,6 +73,11 @@ typedef struct BOOT_MODULE_FXN_TABLE
 /* Prototypes */
 Uint32 iblBoot (BOOT_MODULE_FXN_TABLE *bootFxn, int32 dataFormat, void *formatParams);
 
+/* Stdlibs referenced through functions to use a single copy in the two stage boot */
+void *iblMalloc (Uint32 size);
+void  iblFree   (void *mem);
+void *iblMemset (void *mem, Int32 ch, Uint32 n);
+void *iblMemcpy (void *s1, const void *s2, Uint32 n);
 
 /* squash printfs */
 void mprintf(char *x, ...);
index 25f75ecf1cde92b2093ea132586c454962c50a0e..1786ab322ccd282f6fac77e94da428ce3fdbe2d1 100644 (file)
@@ -456,7 +456,7 @@ void boot_proc_boot_tbl_flush(BOOT_TBL_CB_T* p_inst)
  *****************************************************************************/
 void boot_init_boot_tbl_inst(BOOT_TBL_CB_T *p_btbl_inst)
 {
-    memset(p_btbl_inst, 0, sizeof(BOOT_TBL_CB_T));
+    btblMemset(p_btbl_inst, 0, sizeof(BOOT_TBL_CB_T));
     p_btbl_inst->state = BOOT_TBL_STATE_INIT;
     
     /*
index e6284481aeec3064fe4c13df4318c4fe8ef523f0..ae113cd18445d3c458860cb9a27d8f8ca4ae9c11 100644 (file)
@@ -54,11 +54,11 @@ void iblBootBtbl (BOOT_MODULE_FXN_TABLE *bootFxn, Uint32 *entry_point)
     btblWrapEcode = 0;
 
     /* Initialize stats and btbl state */
-    memset (&bootStats, 0, sizeof(bootStats_t));
+    iblMemset (&bootStats, 0, sizeof(bootStats_t));
     
     boot_init_boot_tbl_inst (&tiBootTable);    
 
-    data = malloc (TI_BTBL_BLOCK_SIZE);
+    data = iblMalloc (TI_BTBL_BLOCK_SIZE);
     if (data == NULL)  {
         btblWrapEcode = BTBL_WRAP_ECODE_MALLOC_FAIL;
         return;
@@ -91,7 +91,7 @@ void iblBootBtbl (BOOT_MODULE_FXN_TABLE *bootFxn, Uint32 *entry_point)
             /* No recovery on block read failure */
             if ((*bootFxn->read)(data, blockSize) < 0)  {
                 btblWrapEcode = BTBL_WRAP_ECODE_READ_FAIL;
-                free (data);
+                iblFree (data);
                 return;
             }
 
@@ -117,7 +117,7 @@ void iblBootBtbl (BOOT_MODULE_FXN_TABLE *bootFxn, Uint32 *entry_point)
     if (btblEcode == 0)
         *entry_point = tiBootTable.code_start_addr;
 
-    free (data);
+    iblFree (data);
 
 }
 
index bba10b468da310ad310cf37979625bb4df0aa322..ec04bd904df859d7ea231a7cfeff1af7334dfff9 100644 (file)
@@ -82,6 +82,8 @@ void btblBootException (UINT32 ecode);
 #define BTBL_WRAP_ECODE_READ_FAIL       101
 #define BTBL_WRAP_ECODE_BTBL_FAIL       102
 
+#define btblMemset iblMemset
+
 
 #endif /* BTBLWRAP_H */
 
diff --git a/src/interp/coff/cload.mike.c b/src/interp/coff/cload.mike.c
deleted file mode 100644 (file)
index 67c0593..0000000
+++ /dev/null
@@ -1,2122 +0,0 @@
-/***************************************************************************
-* FILENAME: cload.c
-* VERSION:  2.6  5/2/96  13:11:03
-* SCCS ID:  "@(#)cload.c       2.6  5/2/96"
-***************************************************************************/
-/******************************************************************************/
-/* CLOAD.C  - Generic COFF Loader                      Version 6.00 4/96      */
-/******************************************************************************/
-/*                                                                            */
-/*  This module contains functions to read in and load a COFF object file.    */
-/*  The following routines are defined here:                                  */
-/*                                                                            */
-/*    cload()           - Main driver for COFF loader.                        */
-/*    cload_headers()   - Read in the various headers of the COFF file.       */
-/*    cload_data()      - Read in the raw data and load it into memory.       */
-/*    cload_sect_data() - Read, relocate, and write out one section.          */
-/*    cload_cinit()     - Process one buffer of C initialization records.     */
-/*    cload_symbols()   - Read in the symbol table.                           */
-/*    cload_strings()   - Read in the string table.                           */
-/*    str_free()        - Free a string table.                                */
-/*    sym_read()        - Read and relocate a symbol and its aux entry.       */
-/*    sym_name()        - Return a pointer to the name of a symbol.           */
-/*    sym_add_name()    - Add a symbol name to the string table.              */
-/*    reloc_add()       - Add a symbol to the relocation symbol table.        */
-/*    relocate()        - Perform a single relocation.                        */
-/*    reloc_read()      - Read in and swap one relocation entry.              */
-/*    reloc_size()      - Return the field size of a relocation type.         */
-/*    reloc_offset()    - Return the field offset of a relocation type.       */
-/*    reloc_stop()      - Return the number of bits to read for a reloc type. */
-/*    sym_reloc_amount()- Return relocation amount for a relocation entry.    */
-/*    unpack()          - Extract a relocation field from object bytes.       */
-/*    repack()          - Encode a relocated field into object bytes.         */
-/*    cload_lineno()    - Read in & swap line number entries.                 */
-/*    swap4byte()       - Swap the order of bytes in a int.                  */
-/*    swap2byte()       - Swap the order of bytes in a short.                 */
-/*                                                                            */
-/*  The loader calls the following external functions to perform application  */
-/*  specific tasks:                                                           */
-/*                                                                            */
-/*   set_reloc_amount() - Define relocation amounts for each section.         */
-/*   mem_write()        - Load a buffer of data into memory.                  */
-/*   lookup_sym()       - Look up a symbol in an external symbol table.       */
-/*   load_syms()        - Build the symbol table for the application.         */
-/*   load_msg()         - Write diagnostic messages during loading.           */
-/*                                                                            */
-/******************************************************************************/
-#include "types.h"
-#include "ibl.h"
-#include "iblloc.h"
-#include "iblcfg.h"
-#include "coff.h"
-#include "coff_trg.h"
-#include "cload.h"
-#include <string.h>
-
-#if (FILE_BASED)
-#include <stdio.h>
-#endif
-/*----------------------------------------------------------------------------*/
-/* CONSTANTS, MACROS, VARIABLES, AND STRUCTURES FOR THE LOADER.               */
-/*----------------------------------------------------------------------------*/
-#define MIN(a,b) ((a)<(b)?(a):(b))
-#define MAX(a,b) ((a)>(b)?(a):(b))
-
-#define TRUE 1
-#define FALSE 0
-#define WORDSZ sizeof(T_DATA)           /* SIZE OF DATA UNITS IN OBJ FILE     */
-
-#ifdef TMS320C60
-   extern int target_coff (unsigned short flags);
-#endif
-
-/*----------------------------------------------------------------------------*/
-/* APPLICATION VARIABLES                                                      */
-/*----------------------------------------------------------------------------*/
-#if (FILE_BASED)
-FILE   *fin;                                                   /* INPUT FILE                         */
-#else
-/* extern unsigned char gRxBuffer[0x400040]; */
-extern unsigned char gRxBuffer[0x10];
-#endif
-
-unsigned char gRxBuffer[0x10];
-
-
-int     need_data    = TRUE;            /* APPLICATION NEEDS RAW DATA         */
-int     need_symbols = FALSE;           /* APPLICATION NEEDS SYMBOL TABLE     */
-int     clear_bss    = FALSE;           /* CLEAR BSS SECTION                  */
-
-
-/*----------------------------------------------------------------------------*/
-/* FILL VALUES TO BE USED BY LOADERS                                          */
-/*----------------------------------------------------------------------------*/
-#if defined(OTIS)
-extern int fill_bss;
-extern int fill_bss_value;
-#else
-#define fill_bss 0
-#define fill_bss_value 0
-#endif
-
-/*----------------------------------------------------------------------------*/
-/* LOADER VARIABLES                                                           */
-/*----------------------------------------------------------------------------*/
-FILHDR  file_hdr;                       /* FILE HEADER STRUCTURE              */
-int     coff_version;                   /* COFF VERSION USED IN FILE          */
-AOUTHDR o_filehdr;                      /* OPTIONAL (A.OUT) FILE HEADER       */
-T_ADDR  entry_point;                    /* ENTRY POINT OF MODULE              */
-T_ADDR *reloc_amount = NULL;            /* AMOUNT OF RELOCATION PER SECTION   */
-int     n_sections;                     /* NUMBER OF SECTIONS IN THE FILE     */
-int     big_e_target;                   /* TARGET DATA IN BIG-ENDIAN FORMAT   */
-int     byte_swapped;                   /* BYTE ORDERING OPPOSITE OF HOST     */
-int     curr_sect;                      /* SECTION NUMBER CURRENTLY LOADING   */
-int     load_err;                       /* ERROR CODE RETURNED IF LOADER FAILS*/
-struct strtab *str_head = NULL;         /* LIST OF STRING TABLE BUFFERS       */
-
-static T_SIZE  init_size = 0;           /* CURRENT SIZE OF C INITIALIZATION   */
-static int     need_reloc;              /* RELOCATION REQUIRED                */
-
-
-int  n_array_sections;                  /* The number of sections in sect_hdrs */
-
-SCNHDR   sect_hdrs[MAX_COFF_SECTION_HEADERS];  /* Array of loadable sections */
-O_SCNHDR o_sect_hdrs;                          /* A single old section header */
-
-unsigned int paBuf[LOADBUFSIZE];        /* Temp buffer for packet load */
-
-int stream_offset;                      /* The current stream offset */
-                            
-
-#if TMS320C60
-int big_e_config = TRG_DEF_BIG_E;       /* ENDIANNESS CONFIGURATION           */
-#else
-int big_e_config = DONTCARE;            /* ENDIANNESS CONFIGURATION           */
-#endif
-
-/*----------------------------------------------------------------------------*/
-/* THIS STRUCTURE IS USED TO STORE THE RELOCATION AMOUNTS FOR SYMBOLS.        */
-/* EACH RELOCATABLE SYMBOL HAS A CORRESPONDING ENTRY IN THIS TABLE.           */
-/* THE TABLE IS SORTED BY SYMBOL INDEX; LOOKUP USES A BINARY SEARCH.          */
-/*----------------------------------------------------------------------------*/
-typedef struct
-{
-   int rt_index;                       /* INDEX OF SYMBOL IN SYMBOL TABLE    */
-   int rt_disp;                        /* AMOUNT OF RELOCATION               */
-} RELOC_TAB;
-
-/*----------------------------------------------------------------------------*/
-/* THE RELOCATION SYMBOL TABLE IS ALLOCATED DYNAMICALLY, AND REALLOCATED      */
-/* AS MORE SPACE IS NEEDED.                                                   */
-/*----------------------------------------------------------------------------*/
-#define RELOC_TAB_START 128             /* STARTING SIZE OF TABLE             */
-#define RELOC_GROW_SIZE 128             /* REALLOC AMOUNT FOR TABLE           */
-
-static RELOC_TAB *reloc_tab = NULL;     /* RELOCATION SYMBOL TABLE            */
-
-static int        reloc_tab_size;       /* CURRENT ALLOCATED AMOUNT           */
-static int        reloc_sym_index;      /* CURRENT SIZE OF TABLE              */
-
-/*----------------------------------------------------------------------------*/
-/* RUN-TIME RELOCATION (AS OPPOSED TO LOAD-TIME) RELOCATION IS DETERMINED     */
-/* AS FOLLOWS:  IF THE SECTION'S RUNTIME ADDRESS == LOADTIME ADDRESS, USE     */
-/* LOADTIME RELOCATION.  OTHERWISE, ASSUME LOADTIME RELOC ONLY (RUNTIME RELOC */
-/* == 0).                                                                     */
-/*----------------------------------------------------------------------------*/
-#define RUN_RELOC_AMOUNT(i) ((SECT_HDR(i)->s_paddr == SECT_HDR(i)->s_vaddr) ?  \
-                                   reloc_amount[i] : 0)
-
-/*----------------------------------------------------------------------------*/
-/* DEFINE A STRUCTURE FOR STRING TABLE BUFFERS.  THESE BUFFERS ARE STORED     */
-/* AS A LINKED LIST OF MEMORY PACKETS, EACH CONTAINING UP TO 64K OF THE       */
-/* STRING TABLE.                                                              */
-/*----------------------------------------------------------------------------*/
-typedef struct strtab
-{
-   unsigned int  size;                 /* SIZE OF THIS PACKET                */
-   unsigned int  offset;               /* STARTING OFFSET OF THIS PACKET     */
-   unsigned int  index;                /* AMOUNT CURRENTLY FILLED            */
-   struct strtab *next;                 /* NEXT BUFFER                        */
-   char           buf[1];               /* STRING DATA (EXPAND AS ALLOCATED)  */
-} STRTAB;
-
-#define MAX_STRING_ALLOC (unsigned int)(0xffff-sizeof(STRTAB)+1)
-                                       /* MAX STRING BUFFER: 64K (SMALL HOSTS)*/
-#define MIN_STRING_ALLOC 0x0400        /* MIN STRING BUFFER: 1K               */
-
-unsigned int unpack();
-
-/* extern void mem_copy(unsigned char* dst, unsigned char* src, int nbytes); */
-#define mem_copy(dest,src,nbytes) memcpy((void *)(dest),(void *)(src),nbytes)
-#define mem_write(buf, nbytes, addr, page)  memcpy((void *)(addr),(void *)(buf),nbytes)
-#define str_comp strcmp
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD() - Main driver for COFF loader.                                     */
-/*                                                                            */
-/******************************************************************************/
-int cload(BOOT_MODULE_FXN_TABLE *bootFxn, Uint32 *ientry_point)
-{
-   int result;
-
-   load_err      = 0;
-   stream_offset = 0;
-   result        = cload_headers(bootFxn, ientry_point) && cload_data(bootFxn);
-
-   if (reloc_tab) free(reloc_tab);
-   reloc_tab = NULL;
-
-   if(result == TRUE)
-       return 0;
-   else  {
-       *ientry_point = 0;
-       return -1;
-   }
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_HEADERS() - Read in the various headers of the COFF file.            */
-/*                                                                            */
-/******************************************************************************/
-int cload_headers(BOOT_MODULE_FXN_TABLE *bootFxn, Uint32 *ientry_point)
-{
-   int i;
-
-   byte_swapped = FALSE;
-   need_reloc   = FALSE;
-
-   *ientry_point = NULL;   /* Error return value */
-
-    if ((*bootFxn->read)((Uint8 *)&file_hdr, FILHSZ) < 0)
-        return (FALSE);
-    stream_offset += FILHSZ;
-
-
-   /*-------------------------------------------------------------------------*/
-   /* MAKE SURE THIS IS REALLY A COFF FILE. CHECK FOR SWAPPED FILES.          */
-   /* DETERMINE BYTE ORDERING OF OBJECT DATA.                                 */
-   /*-------------------------------------------------------------------------*/
-   if (!ISCOFF(file_hdr.f_magic))
-   {
-       swap2byte(&file_hdr.f_magic);
-
-       if (!ISCOFF(file_hdr.f_magic)) { load_err = E_MAGIC; return FALSE; }
-
-       byte_swapped = TRUE;
-
-       swap2byte(&file_hdr.f_nscns);  swap4byte(&file_hdr.f_timdat);
-       swap4byte(&file_hdr.f_symptr); swap4byte(&file_hdr.f_nsyms);
-       swap2byte(&file_hdr.f_opthdr); swap2byte(&file_hdr.f_flags);
-#if COFF_VERSION_1 || COFF_VERSION_2
-       swap2byte(&file_hdr.f_target_id); 
-#endif
-   }
-
-   /*-------------------------------------------------------------------------*/
-   /* DETERMINE THE ENDIANNESS OF THE COFF FILE, AND ENSURE THE ENDIANNESS OF */
-   /* THE FILE IS THE SAME AS THE TARGET, IF THERE IS A TARGET.               */
-   /*-------------------------------------------------------------------------*/
-   big_e_target = ((file_hdr.f_flags & F_BIG) != 0);
-   if (big_e_config != DONTCARE && big_e_target != big_e_config) 
-      { load_err = E_ENDIAN; return FALSE; }
-
-   /*-------------------------------------------------------------------------*/
-   /* DETERMINE VERSION OF COFF BEING USED, CHECK TARGET ID IF NEEDED.        */
-   /*-------------------------------------------------------------------------*/
-   if (ISCOFF_1(file_hdr.f_magic) || ISCOFF_2(file_hdr.f_magic))
-   {
-       if (!ISMAGIC(file_hdr.f_target_id)) { load_err = E_MAGIC; return FALSE; }
-       coff_version = file_hdr.f_magic;
-   } 
-   else coff_version = COFF_MAGIC_0;
-
-#ifdef TMS320C60
-   /*-------------------------------------------------------------------------*/
-   /* DETERMINE WHETHER THE RIGHT COFF IS BEING LOADED                        */
-   /*-------------------------------------------------------------------------*/
-   if ( !target_coff( file_hdr.f_flags) )
-       { load_err = E_FILE; return FALSE; }
-#endif
-   /*-------------------------------------------------------------------------*/
-   /* READ IN OPTIONAL HEADER, IF THERE IS ONE, AND SWAP IF NEEDED.           */
-   /*-------------------------------------------------------------------------*/
-   if (file_hdr.f_opthdr == AOUTSZ)
-   {
-
-    if ((*bootFxn->read)((Uint8 *)&o_filehdr, file_hdr.f_opthdr) < 0)
-        return (FALSE);
-    stream_offset += file_hdr.f_opthdr;
-
-      if (byte_swapped)
-      {
-         swap2byte(&o_filehdr.magic);      swap2byte(&o_filehdr.vstamp);
-         swap4byte(&o_filehdr.tsize);      swap4byte(&o_filehdr.dsize);
-         swap4byte(&o_filehdr.bsize);      swap4byte(&o_filehdr.entrypt);
-         swap4byte(&o_filehdr.text_start); swap4byte(&o_filehdr.data_start);
-      }
-
-      entry_point   = o_filehdr.entrypt;
-      *ientry_point = entry_point;
-   }
-
-   /*-------------------------------------------------------------------------*/
-   /* Read in string table so that we can see long section names, if needed.  */
-   /* This used tobe read right before the symbol table was read, but now the */
-   /* section headers use "flexname" method to specify section names and so   */
-   /* might need access to a string table entry.                              */
-   /*-------------------------------------------------------------------------*/
-   //if (!cload_strings()) return FALSE;
-
-   /*-------------------------------------------------------------------------*/
-   /* READ IN SECTION HEADERS.                                                */
-   /*-------------------------------------------------------------------------*/
-
-   n_array_sections = 0;
-   for (i = 0; i < file_hdr.f_nscns; i++)  {
-
-     SCNHDR   *sptr = (SCNHDR *)&sect_hdrs[n_array_sections];
-     O_SCNHDR *tptr = (O_SCNHDR *)&o_sect_hdrs;
-
-     if (ISCOFF_2(coff_version))  {
-
-        if ((*bootFxn->read)((Uint8 *)sptr, SCNHSZ_IN(coff_version)) < 0)
-            return (FALSE);
-        stream_offset += SCNHSZ_IN(coff_version);
-
-
-       if (byte_swapped)  {
-
-         if (sptr->s_zeroes == 0L) swap4byte(&sptr->s_offset);
-             swap4byte(&sptr->s_paddr);  
-            swap4byte(&sptr->s_vaddr);
-             swap4byte(&sptr->s_size);   
-            swap4byte(&sptr->s_scnptr);
-             swap4byte(&sptr->s_relptr); 
-            swap4byte(&sptr->s_lnnoptr);
-             swap4byte(&sptr->s_nreloc); 
-            swap4byte(&sptr->s_nlnno);
-             swap4byte(&sptr->s_flags);  
-             /* s_mwidth   - single byte */
-             /* s_reserved - single byte */
-            swap2byte(&sptr->s_page);
-         }
-
-
-    }  else  {
-
-        if ((*bootFxn->read)((Uint8 *)tptr, SCNHSZ_IN(coff_version)) < 0)
-            return (FALSE);
-        stream_offset += SCNHSZ_IN(coff_version);
-
-       if (byte_swapped)  {
-             swap4byte(&tptr->os_paddr);  
-            swap4byte(&tptr->os_vaddr);
-             swap4byte(&tptr->os_size);   
-            swap4byte(&tptr->os_scnptr);
-             swap4byte(&tptr->os_relptr); 
-            swap4byte(&tptr->os_lnnoptr);
-             swap2byte(&tptr->os_nreloc); 
-            swap2byte(&tptr->os_nlnno);
-             swap2byte(&tptr->os_flags);
-            /* os_reserved - one byte */
-            /* os_page     - one byte */
-       }
-    
-          strncpy(sptr->s_name, tptr->os_name, SYMNMLEN);
-          sptr->s_paddr   = tptr->os_paddr;
-          sptr->s_vaddr   = tptr->os_vaddr;
-          sptr->s_size    = tptr->os_size;
-          sptr->s_scnptr  = tptr->os_scnptr;
-          sptr->s_relptr  = tptr->os_relptr;
-          sptr->s_lnnoptr = tptr->os_lnnoptr;
-          sptr->s_nreloc  = tptr->os_nreloc;
-          sptr->s_nlnno   = tptr->os_nlnno;
-          sptr->s_flags   = tptr->os_flags;
-          sptr->s_page    = tptr->os_page;
-       }
-
-     /* Dont keep the section if it is not loaded */
-
-     if ((sptr->s_scnptr || ((clear_bss || fill_bss) && IS_BSS(sptr)))   &&
-            (sptr->s_size)                                                  &&
-        !(sptr->s_flags & (STYP_DSECT | STYP_NOLOAD)))
-
-       n_array_sections += 1;
-
-   }
-
-
-   return TRUE;
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_DATA() - Read in the raw data and load it into memory.               */
-/*                                                                            */
-/******************************************************************************/
-int cload_data(BOOT_MODULE_FXN_TABLE *bootFxn)
-{
-   int ok = TRUE;
-
-   if (!need_data) return TRUE;
-
-   /*-------------------------------------------------------------------------*/
-   /* LOOP THROUGH THE SECTIONS AND LOAD THEM ONE AT A TIME.                  */
-   /*-------------------------------------------------------------------------*/
-   for (curr_sect = 0; curr_sect < n_array_sections && ok; curr_sect++)
-   {
-      SCNHDR *sptr = &sect_hdrs[curr_sect];
-      char   *sname = (sptr->s_zeroes == 0L) ? 
-                               sptr->s_nptr : SNAMECPY(sptr->s_name);
-
-      /*----------------------------------------------------------------------*/
-      /* IF THIS IS THE TEXT SECTION, RELOCATE THE ENTRY POINT.               */
-      /*----------------------------------------------------------------------*/
-      if ((sptr->s_flags & STYP_TEXT) && !strcmp(sname, ".text"))
-        entry_point += RUN_RELOC_AMOUNT(curr_sect);
-
-      /*----------------------------------------------------------------------*/
-      /* IGNORE EMPTY SECTIONS OR SECTIONS WHOSE FLAGS INDICATE THE           */
-      /* SECTION IS NOT TO BE LOADED.  IF THE CLEAR_BSS FLAG IS SET, BSS      */
-      /* IS "LOADED" EVEN THOUGH IT HAS NO DATA                               */
-      /*----------------------------------------------------------------------*/
-      if ((sptr->s_scnptr || ((clear_bss || fill_bss) && IS_BSS(sptr)))   &&
-             (sptr->s_size)                                              &&
-         !(sptr->s_flags & (STYP_DSECT | STYP_NOLOAD)))  {
-
-        if (!(sptr->s_flags & STYP_COPY))
-               ok &= cload_sect_data(sptr, bootFxn);
-        else
-            ok &= cload_sect_data(sptr, bootFxn);
-      }
-   }
-
-
-   return ok;
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_SECT_DATA() - Read, relocate, and write out the data for one section.*/
-/*                                                                            */
-/******************************************************************************/
-int cload_sect_data(SCNHDR *sptr, BOOT_MODULE_FXN_TABLE *bootFxn)
-{
-   T_ADDR        addr    = sptr->s_vaddr; /* CURRENT ADDRESS IN SECTION       */
-   unsigned int nbytes;                  /* BYTE COUNT WITHIN SECTION        */
-   int           packet_size = 0;         /* SIZE OF CURRENT DATA BUFFER      */
-   int           excess  = 0;             /* BYTES LEFT FROM PREVIOUS BUFFER  */
-   unsigned int  n_reloc = 0;             /* COUNTER FOR RELOCATION ENTRIES   */
-   RELOC         reloc;                   /* RELOCATION ENTRY                 */
-   int           relsz   = RELSZ_IN(coff_version); 
-   unsigned char *packet = (unsigned char *)paBuf; /* LOAD BUFFER                      */
-   unsigned int section_length = (unsigned int)LOCTOBYTE(sptr->s_size);
-   unsigned int buffer_size    = LOADBUFSIZE;
-
-#if defined (UNBUFFERED) && UNBUFFERED
-   /*-------------------------------------------------------------------------*/
-   /* IF UNBUFFERED, THEN SET SIZE TO SECTION LENGTH ROUNDED UP TO MULTIPLE   */
-   /* 32 BYTES.  WE MAINTAIN A MINIMIUM OF LOADBUFSIZE IN THE EVENT SOMEONE   */
-   /* CONTINUES TO USE THAT MACRO AS A SIZE LIMIT.                            */
-   /*-------------------------------------------------------------------------*/
-   buffer_size = MAX(buffer_size, (section_length + 32) & ~31ul); 
-#endif
-
-   /*-------------------------------------------------------------------------*/
-   /* ENSURE LOADBUFSIZE IS A MULTIPLE OF 2                                   */
-   /*-------------------------------------------------------------------------*/
-   if (LOADBUFSIZE % 2) 
-   {
-       return -1;
-   }
-
-   /*-------------------------------------------------------------------------*/
-   /* ALLOCATE THE PACKET BUFFER                                              */
-   /*-------------------------------------------------------------------------*/
-   if (!packet) { load_err = E_ALLOC; return FALSE; }
-
-#ifdef OTIS
-   if (IS_BSS(sptr))
-   {
-      TRG_MVAL filval = fill_bss_value;
-
-      free (packet);
-
-      if (!mem_fill(filval, LOCTOBYTE(sptr->s_size), addr, sptr->s_page))
-         { load_err = E_MEMWRITE; return FALSE; }
-      return TRUE;
-   }
-#else
-   /*-------------------------------------------------------------------------*/
-   /* Always want to clear memory for cases where memsize is not a multiple   */
-   /* of the data size being written out.  If we do not clear the array, the  */
-   /* last byte or so can be corrupted with data from the last buffer read.   */
-   /*-------------------------------------------------------------------------*/
-   for (nbytes = 0; nbytes < buffer_size; ++nbytes) packet[nbytes] = 0;
-#endif
-
-
-   /* Advance the stream to the start of the section */
-   if (sptr->s_scnptr)  {
-
-        unsigned int offset;
-
-        offset = sptr->s_scnptr;
-
-        /* Advance the stream to the next section */
-        if (offset > stream_offset)  {
-
-            unsigned int delta, rsize;
-            int k;
-            
-                
-            delta = sptr->s_scnptr - stream_offset;
-
-            for (k = 0; k < delta; k += rsize)  {
-
-                rsize = MIN(delta, sizeof(paBuf));
-
-                if ((*bootFxn->read)((Uint8 *)paBuf, rsize) < 0)
-                    return (FALSE);
-                stream_offset += rsize;
-
-            }
-
-         }
-
-    }
-
-       
-   /*-------------------------------------------------------------------------*/
-   /* COPY ALL THE DATA IN THE SECTION.                                       */
-   /*-------------------------------------------------------------------------*/
-
-   for (nbytes = 0; nbytes < section_length; nbytes += packet_size)
-   {
-      int j;
-
-      /*----------------------------------------------------------------------*/
-      /* READ IN A BUFFER OF DATA.  IF THE PREVIOUS RELOCATION SPANNED        */
-      /* ACROSS THE END OF THE LAST BUFFER, COPY THE LEFTOVER BYTES INTO      */
-      /* THE BEGINNING OF THE NEW BUFFER.                                     */
-      /*----------------------------------------------------------------------*/
-      for (j = 0; j < excess; ++j) packet[j] = packet[packet_size + j];
-
-      packet_size = (int)MIN(LOCTOBYTE(sptr->s_size) - nbytes, buffer_size);
-
-      if (sptr->s_scnptr)  {
-
-         if ((*bootFxn->read)((Uint8 *)((Uint8 *)packet+ excess), packet_size - excess) < 0)
-            return (FALSE);
-         stream_offset += (packet_size - excess);
-
-      }
-
-
-      excess = 0;
-
-      /*----------------------------------------------------------------------*/
-      /* Clear out end of packet in case we write padding.                    */
-      /*----------------------------------------------------------------------*/
-      if (excess + packet_size < buffer_size)
-         for(j = excess + packet_size; j < buffer_size; j++)
-             packet[j] = 0;
-
-
-#if 0       /* For some reason I have a section with STYP_COPY set, but
-             * the name is not .cinit (first section). The address of
-             * this section is 0, so if memcpy is called it returns 0,
-             * which results in the load_err case */
-             
-      /*----------------------------------------------------------------------*/
-      /* WRITE OUT THE RELOCATED DATA TO THE TARGET DEVICE.  IF THIS IS A     */
-      /* CINIT SECTION, CALL A SPECIAL FUNCTION TO HANDLE IT.                 */
-      /*----------------------------------------------------------------------*/
-      if (!(IS_CINIT(sptr) ?
-             cload_cinit(packet, &packet_size, &excess) :
-              (int)memcpy ((void *)addr, packet, packet_size)))
-         { load_err = E_MEMWRITE; free (packet); return FALSE; }
-#endif
-
-
-
-      if (IS_CINIT(sptr))  {
-        if (cload_cinit(packet, &packet_size, &excess))  {
-            load_err = E_MEMWRITE; return (FALSE); 
-           
-        }
-
-      }  else  {
-        
-        /* If a copy section, but not cinit, ignore it */
-        if (!(sptr->s_flags & STYP_COPY)) 
-              memcpy ((void *)addr, packet, packet_size);
-
-     }
-
-
-      /*----------------------------------------------------------------------*/
-      /* KEEP TRACK OF THE ADDRESS WITHIN THE SECTION.                        */
-      /*----------------------------------------------------------------------*/
-      addr += BYTETOLOC(packet_size);
-
-   }
-
-   return TRUE;
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_CINIT() - Process one buffer of C initialization records.            */
-/*                                                                            */
-/******************************************************************************/
-int cload_cinit(unsigned char *packet, int *packet_size, int *excess)
-{
-   int           i;                      /* BYTE COUNTER                      */
-   int           init_packet_size;       /* SIZE OF CURRENT INITIALIZATION    */
-   static T_ADDR init_addr;              /* ADDRESS OF CURRENT INITIALIZATION */
-   int           bss_page = 0;           /* BSS SECTION PAGE NUMBER           */
-   /*-------------------------------------------------------------------------*/
-   /* FIND THE BSS SECTION ASSOCIATED WITH THE THE CINIT SECTION CURRENTLY    */
-   /* BEING LOADED.                                                           */
-   /*-------------------------------------------------------------------------*/
-   for (i = 0; i < n_sections; ++i)
-      if (IS_BSS(SECT_HDR(i))) 
-          { bss_page = SECT_HDR(i)->s_page; break; }
-
-   /*-------------------------------------------------------------------------*/
-   /*  PROCESS ALL THE INITIALIZATION RECORDS IN THE BUFFER.                  */
-   /*-------------------------------------------------------------------------*/
-   for (i = 0; i < *packet_size; i += init_packet_size)
-   {
-      /*----------------------------------------------------------------------*/
-      /* IF STARTING A NEW INITIALIZATION, READ THE SIZE AND ADDRESS FROM     */
-      /* THE TABLE.                                                           */
-      /*----------------------------------------------------------------------*/
-      if (init_size == 0)
-      {
-        T_SIZE temp;
-        int    align;
-
-        /*-------------------------------------------------------------------*/
-        /* POSITION THE BYTE INDEX ON THE NEXT INIT RECORD.                  */
-        /*-------------------------------------------------------------------*/
-         if (align = (i % INIT_ALIGN)) i += (INIT_ALIGN - align);
-
-        /*-------------------------------------------------------------------*/
-        /* IF THE SIZE AND ADDRESS ARE NOT FULLY CONTAINED IN THIS BUFFER,   */
-        /* STOP HERE.  SET THE 'EXCESS' COUNTER TO THE NUMBER OF UNPROCESSED */
-        /* BYTES - THESE WILL BE COPIED TO THE HEAD OF THE NEXT BUFFER.      */
-        /*-------------------------------------------------------------------*/
-        if ((int)(i + sizeof(T_SIZE)) > *packet_size)
-           { *excess += *packet_size - i;  *packet_size = i;  break; }
-
-        /*-------------------------------------------------------------------*/
-        /* IF THE NEXT SIZE FIELD IS ZERO, BREAK.                            */
-        /*-------------------------------------------------------------------*/
-        temp = unpack(packet + i, sizeof(T_SIZE)*8, sizeof(T_SIZE)*8, 0);
-        if (temp == 0) break;
-
-        /*-------------------------------------------------------------------*/
-        /* READ THE ADDRESS FIELD ,IF IT'S ALL HERE.                         */
-        /*-------------------------------------------------------------------*/
-         if ((int)(i + sizeof(T_SIZE) + sizeof(T_IADDR)) > *packet_size)
-             { *excess += *packet_size - i;  *packet_size = i;  break; }
-
-         i         += sizeof(T_SIZE);
-         init_size  = temp;
-         init_addr  = unpack(packet+i,sizeof(T_IADDR)*8,sizeof(T_IADDR)*8,0);
-         i         += sizeof(T_IADDR);
-      }
-
-      /*----------------------------------------------------------------------*/
-      /* WRITE OUT THE CURRENT PACKET, UP TO THE END OF THE BUFFER.           */
-      /*----------------------------------------------------------------------*/
-      if (init_packet_size = MIN(*packet_size-i, (int)(init_size * INIT_WSIZE)))
-      {
-       
-        if (!mem_write(packet + i, init_packet_size, init_addr, bss_page))
-            return FALSE;
-
-        init_addr += BYTETOLOC(init_packet_size);
-        init_size -= init_packet_size / INIT_WSIZE;
-      }
-   }
-   return TRUE;
-}
-
-#if 0
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_SYMBOLS() - Read in the symbol table.                                */
-/*                                                                            */
-/******************************************************************************/
-int cload_symbols()
-{
-   SYMENT sym;
-   AUXENT aux;
-   int first, next;
-
-   if (file_hdr.f_nsyms == 0 || (!need_symbols && !need_reloc)) return TRUE;
-
-   /*------------------------------------------------------------------------*/
-   /* ALLOCATE THE RELOCATION SYMBOL TABLE.                                  */
-   /*------------------------------------------------------------------------*/
-   if (need_reloc)
-   {
-      reloc_sym_index = 0;
-      reloc_tab_size  = MIN(RELOC_TAB_START, (int)file_hdr.f_nsyms);
-
-      if (!(reloc_tab = (RELOC_TAB *)malloc(reloc_tab_size*sizeof(RELOC_TAB))))
-          { load_err = E_ALLOC; return FALSE; }
-   }
-
-   /*------------------------------------------------------------------------*/
-   /* IF THE APPLICATION NEEDS THE SYMBOL TABLE, LET IT READ IT IN.          */
-   /* PASS NEED_RELOC TO THE APPLICATION SO THAT IT CAN CALL RELOC_ADD().    */
-   /*------------------------------------------------------------------------*/
-   if (need_symbols) 
-   {
-      if (load_syms(need_reloc)) return TRUE;
-      else { load_err = E_SYM; return FALSE; }
-   }
-
-   /*------------------------------------------------------------------------*/
-   /*  READ THE SYMBOL TABLE AND BUILD THE RELOCATION SYMBOL TABLE           */
-   /*  FOR SYMBOLS THAT CAN BE USED IN RELCOATION, STORE THEM IN A           */
-   /*  SPECIAL SYMBOL TABLE THAT CAN BE SEARCHED QUICKLY DURING              */
-   /*  RELOCATION.                                                           */
-   /*------------------------------------------------------------------------*/
-   for (first = 0; first < file_hdr.f_nsyms; first = next)
-   {
-       if (!(next = sym_read(first, &sym, &aux))) 
-          { load_err = E_FILE; return FALSE; }
-
-       if (sym.n_sclass == C_EXT     || sym.n_sclass == C_EXTREF  ||
-           sym.n_sclass == C_STAT    || sym.n_sclass == C_LABEL   ||
-           sym.n_sclass == C_SYSTEM  || sym.n_sclass == C_BLOCK   || 
-          sym.n_sclass == C_FCN     || sym.n_sclass == C_STATLAB || 
-          sym.n_sclass == C_EXTLAB) 
-         if (!reloc_add(first, &sym)) return FALSE;
-   }
-   return TRUE;
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_STRINGS() - Read in the string table.                                */
-/*                                                                            */
-/******************************************************************************/
-int cload_strings()
-{
-   unsigned int str_size;              /* SIZE OF STRING TABLE              */
-   unsigned int bufsize;               /* SIZE OF CURRENT BUFFER            */
-   unsigned int ntoread;                /* AMOUNT TO READ FROM FILE          */
-   int excess;                          /* AMOUNT LEFT OVER FROM LAST BUFFER */
-   STRTAB *packet;                      /* STRING TABLE BUFFER PACKET        */
-   unsigned int i = 0;
-
-   /*----------------------------------------------------------------------*/
-   /* Do not load if not loading/saving the symbol tables.                 */
-   /* This is because the string table is an extension of the symbol table */
-   /* and if you free and rebuild it, the symbol table's str_head will be  */
-   /* incorrect.                                                           */
-   /*----------------------------------------------------------------------*/
-   if (!need_symbols) return TRUE;
-
-   /*------------------------------------------------------------------------*/
-   /* FREE ANY PREVIOUS STRING BUFFERS                                       */
-   /*------------------------------------------------------------------------*/
-   str_free(str_head); str_head = NULL;
-
-   /*------------------------------------------------------------------------*/
-   /* SEEK TO THE END OF THE SYMBOL TABLE AND READ IN THE SIZE OF THE STRING */
-   /* TABLE.                                                                 */
-   /*------------------------------------------------------------------------*/
-#if FILE_BASED
-   if ((file_hdr.f_nsyms == 0) ||
-          fseek(fin, file_hdr.f_symptr + (file_hdr.f_nsyms * SYMESZ), 0) != 0 ||
-       fread(&str_size, sizeof(int), 1, fin) != 1)
-       return TRUE;
-#else
-   mem_copy(&str_size, &gRxBuffer[file_hdr.f_symptr + (file_hdr.f_nsyms * SYMESZ)], sizeof(int));      
-   if ((file_hdr.f_nsyms == 0))
-       return TRUE; 
-#endif
-   if (byte_swapped) swap4byte(&str_size);
-
-   /*------------------------------------------------------------------------*/
-   /* THE STRING TABLE IS READ IN AS A LINKED LIST OF BUFFERS.  TO           */
-   /* PREVENT NAMES FROM BEING SPLIT ACROSS MULTIPLE BUFFERS, ANY PARTIAL    */
-   /* NAME AT THE END OF A BUFFER IS COPIED INTO THE BEGINNING OF THE        */
-   /* NEXT BUFFER.  THE VARIABLE 'EXCESS' KEEPS TRACK OF HOW MUCH NEEDS      */
-   /* TO BE COPIED FROM THE PREVIOUS BUFFER.                                 */
-   /*------------------------------------------------------------------------*/
-   str_size -= 4;                       /* SUBTRACT OFF 4 BYTES ALREADY READ */
-   excess    = 0;                       /* INITIALIZE LAST-BUFFER OVERFLOW   */
-
-
-   /*------------------------------------------------------------------------*/
-   /* READ STRING BUFFERS UNTIL THE WHOLE STRING TABLE IS READ.              */
-   /*------------------------------------------------------------------------*/
-   while (str_size)
-   {
-      /*---------------------------------------------------------------------*/
-      /* ALLOCATE A NEW BUFFER.  ON 16-BIT MACHINES, RESTRICT THE            */
-      /* BUFFER SIZE TO THE MAXIMUM THAT CAN BE ALLOCATED AT ONCE.           */
-      /*---------------------------------------------------------------------*/
-      bufsize = str_size + excess;
-
-      if (sizeof(int) < 4  && bufsize > MAX_STRING_ALLOC)
-        bufsize = MAX_STRING_ALLOC;
-
-      if (!(packet = (struct strtab *)malloc(sizeof(STRTAB) + 
-                                             (unsigned int)bufsize - 1)))
-         { load_err = E_ALLOC; return FALSE; }
-
-      /*---------------------------------------------------------------------*/
-      /* COPY ANY PARTIAL STRING FROM THE LAST BUFFER INTO THIS ONE.         */
-      /* THEN FILL THE REST OF THE BUFFER BY READING FROM THE FILE.          */
-      /*---------------------------------------------------------------------*/
-      if (excess)
-        strn_copy(packet->buf, str_head->buf + str_head->size, excess);
-
-      ntoread = (unsigned int)(bufsize - excess);
-#if FILE_BASED
-      if (fread(packet->buf + excess, ntoread, 1, fin) != 1) 
-        { load_err = E_FILE; return FALSE; }
-#else
-       mem_copy(packet->buf + excess, &gRxBuffer[file_hdr.f_symptr + (file_hdr.f_nsyms * SYMESZ) +sizeof(int)+ i++*ntoread], ntoread);
-#endif  
-      str_size -= ntoread;
-
-      /*---------------------------------------------------------------------*/
-      /* IF THE BUFFER ENDS IN A PARTIAL STRING (DOESN'T END IN NULL),       */
-      /* KEEP TRACK OF HOW MANY CHARACTERS ARE IN THE PARTIAL STRING         */
-      /* SO THEY CAN BE COPIED INTO THE NEXT BUFFER.                         */
-      /*---------------------------------------------------------------------*/
-      for (excess = 0; packet->buf[bufsize - 1]; --bufsize, ++excess) ;
-
-      /*---------------------------------------------------------------------*/
-      /* LINK THE NEW BUFFER INTO THE HEAD OF THE LIST.                      */
-      /*---------------------------------------------------------------------*/
-      packet->size   = 
-      packet->index  = bufsize;
-      packet->next   = str_head;
-      packet->offset = str_head ? (str_head->offset + str_head->size) : 4;
-      str_head       = packet;
-   }
-   return TRUE;
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* STR_FREE() - Free the list of string table buffers.                        */
-/*                                                                            */
-/******************************************************************************/
-void str_free(STRTAB *head)
-{
-   STRTAB *this_one, *next;
-   for (this_one = head; this_one; this_one = next)
-   {
-      next = this_one->next;
-      free(this_one);
-   }
-}
-
-
-
-/******************************************************************************/
-/*                                                                            */
-/* SYM_READ() - Read and relocate a symbol and its aux entry.  Return the     */
-/*              index of the next symbol.                                     */
-/*                                                                            */
-/******************************************************************************/
-int sym_read(int index, SYMENT *sym, AUXENT *aux)
-{
-    /*------------------------------------------------------------------------*/
-    /* READ IN A SYMBOL AND ITS AUX ENTRY.                                    */
-    /*------------------------------------------------------------------------*/
-#if FILE_BASED
-    if (fseek(fin, file_hdr.f_symptr + (index * SYMESZ), 0) != 0 ||
-        fread(sym, SYMESZ, 1, fin) != 1                                ||
-        (sym->n_numaux && fread(aux, SYMESZ, 1, fin) != 1)) 
-      { load_err = E_FILE; return FALSE; }
-#else
-       mem_copy((void*)sym, (void*)&gRxBuffer[file_hdr.f_symptr + (index * SYMESZ)], SYMESZ); 
-    if (sym->n_numaux) 
-    { 
-       mem_copy((void*)aux, (void*)&gRxBuffer[file_hdr.f_symptr + ( (index+1) * SYMESZ)], SYMESZ);
-       load_err = E_FILE; 
-       return FALSE; 
-    }
-#endif
-    if (byte_swapped)
-    {
-        /*--------------------------------------------------------------------*/
-       /* SWAP THE SYMBOL TABLE ENTRY.                                       */
-        /*--------------------------------------------------------------------*/
-        if (sym->n_zeroes == 0) swap4byte(&sym->n_offset);
-        swap4byte(&sym->n_value);
-        swap2byte(&sym->n_scnum);
-        swap2byte(&sym->n_type);
-
-        /*--------------------------------------------------------------------*/
-       /* SWAP THE AUX ENTRY, BASED ON THE STORAGE CLASS.                    */
-        /*--------------------------------------------------------------------*/
-        if (sym->n_numaux) switch(sym->n_sclass)
-        {
-          case C_FILE    : break;
-
-          case C_STRTAG  :
-          case C_UNTAG   :
-          case C_ENTAG   : swap4byte(&aux->x_tag.x_fsize);
-                           swap4byte(&aux->x_tag.x_endndx);
-                           break;
-
-          case C_FCN     : if (!str_comp(sym->n_name, ".bf"))
-                          {
-                              swap2byte(&aux->x_block.x_lcnt);
-                              swap4byte(&aux->x_block.x_regmask); 
-                              swap4byte(&aux->x_block.x_framesize);
-                          }
-                               
-          case C_BLOCK   : swap2byte(&aux->x_block.x_lnno);
-                          swap4byte(&aux->x_block.x_endndx);
-                           break;
-
-          case C_EOS     : swap4byte(&aux->x_eos.x_fsize);
-                           swap4byte(&aux->x_eos.x_tagndx);
-                           break;
-
-          default        : /*-------------------------------------------------*/
-                           /* HANDLE FUNCTION DEFINITION SYMBOL               */
-                           /*-------------------------------------------------*/
-                           if (((sym->n_type >> 4) & 3) == DCT_FCN)
-                           {
-                               swap4byte(&aux->x_func.x_tagndx);
-                               swap4byte(&aux->x_func.x_fsize);
-                               swap4byte(&aux->x_func.x_lnnoptr);
-                               swap4byte(&aux->x_func.x_endndx);
-                           }
-
-                           /*-------------------------------------------------*/
-                           /* HANDLE ARRAYS.                                  */
-                           /*-------------------------------------------------*/
-                           else if (((sym->n_type >> 4) & 3) == DCT_ARY)
-                           {
-                               swap4byte(&aux->x_array.x_tagndx);
-                               swap4byte(&aux->x_array.x_fsize);
-                               swap2byte(&aux->x_array.x_dimen[0]);
-                               swap2byte(&aux->x_array.x_dimen[1]);
-                               swap2byte(&aux->x_array.x_dimen[2]);
-                               swap2byte(&aux->x_array.x_dimen[3]);
-                           }
-
-                           /*-------------------------------------------------*/
-                           /* HANDLE SECTION DEFINITIONS                      */
-                           /*-------------------------------------------------*/
-                           else if (sym->n_type == 0)
-                           {
-                               swap4byte(&aux->x_scn.x_scnlen);
-                               swap2byte(&aux->x_scn.x_nreloc);
-                               swap2byte(&aux->x_scn.x_nlinno);
-                           }
-
-                           /*-------------------------------------------------*/
-                           /* HANDLE MISC SYMBOL RECORD                       */
-                           /*-------------------------------------------------*/
-                           else
-                           {
-                               swap4byte(&aux->x_sym.x_fsize);
-                               swap4byte(&aux->x_sym.x_tagndx);
-                           }
-        }
-    }
-
-    /*------------------------------------------------------------------------*/
-    /* RELOCATE THE SYMBOL, BASED ON ITS STORAGE CLASS.                       */
-    /*------------------------------------------------------------------------*/
-    switch(sym->n_sclass)
-    {
-       case C_SYSTEM  :
-       case C_EXT     :
-       case C_EXTREF  :
-       case C_STAT    :
-       case C_LABEL   :
-       case C_BLOCK   :
-       case C_FCN     : 
-       case C_STATLAB :
-       case C_EXTLAB  :
-         /*------------------------------------------------------------------*/
-         /* IF THE SYMBOL IS UNDEFINED, CALL AN APPLICATION ROUTINE TO LOOK  */
-         /* IT UP IN AN EXTERNAL SYMBOL TABLE.  IF THE SYMBOL IS DEFINED,    */
-         /* RELOCATE IT ACCORDING TO THE SECTION IT IS DEFINED IN.           */
-         /*------------------------------------------------------------------*/
-          if (sym->n_scnum == 0) 
-            lookup_sym((short)index, sym, aux);
-          else if (sym->n_scnum > 0) 
-         {
-            if (sym->n_sclass == C_STATLAB || sym->n_sclass == C_EXTLAB)
-                 sym->n_value += reloc_amount[sym->n_scnum - 1];
-            else sym->n_value += RUN_RELOC_AMOUNT(sym->n_scnum - 1);
-          }
-    }
-
-    return (index + sym->n_numaux + 1);
-}
-
-\f
-/******************************************************************************/
-/*                                                                            */
-/* SYM_NAME() - Return a pointer to the name of a symbol in either the symbol */
-/*              entry or the string table.                                    */
-/*                                                                            */
-/******************************************************************************/
-char *sym_name(SYMENT *symptr)
-{
-    static char temp[9];
-
-    if (symptr->n_zeroes == 0)
-    {
-       STRTAB *packet = str_head;
-
-       /*---------------------------------------------------------------------*/
-       /* Return the empty string if this symbol has no name (offset == 0)    */
-       /*---------------------------------------------------------------------*/
-       if (symptr->n_offset < 4) /* Anything below 4 isn't valid */
-       {
-          temp[0] = 0;
-          return temp;
-       }
-
-       /*---------------------------------------------------------------------*/
-       /* Otherwise, return the string in the string table.                   */
-       /*---------------------------------------------------------------------*/
-       while (packet && symptr->n_offset < (int)packet->offset)
-          packet = packet->next;
-
-       /*---------------------------------------------------------------------*/
-       /* Return the empty string if packet NULL (invalid offset)             */
-       /*---------------------------------------------------------------------*/
-       if (!packet)
-       {
-          temp[0] = 0;
-          return temp;
-       }
-
-       return packet->buf + (symptr->n_offset - packet->offset);
-    }
-    
-    strn_copy(temp, symptr->n_name, 8);
-    temp[8] = 0;
-    return temp;
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/* SYM_ADD_NAME() - Given a symbol table entry, return a pointer to the       */
-/*                  symbol's name in the string table.  Add the name to the   */
-/*                  table if it's not already there.                          */
-/*                                                                            */
-/******************************************************************************/
-char *sym_add_name(SYMENT *symptr)
-{
-    char *dest;
-    char *result;
-    int i;
-
-    /*------------------------------------------------------------------------*/
-    /* IF THE SYMBOL'S NAME WAS IN THE COFF STRING TABLE, LOOK THROUGH THE    */
-    /* LIST OF STRING TABLE BUFFERS UNTIL FINDING THE ONE THE NAME IS IN,     */
-    /* AND SIMPLY POINT INTO THE BUFFER.                                      */
-    /*------------------------------------------------------------------------*/
-    if (symptr->n_zeroes == 0)
-       return sym_name(symptr);
-
-    /*------------------------------------------------------------------------*/
-    /* OTHERWISE ADD THE STRING TO THE STRING TABLE.                          */
-    /* ALLOCATE AND LINK IN A NEW PACKET IF NECESSARY.  NEW PACKETS ARE       */
-    /* LINKED TO THE HEAD OF THE LIST TO EASE ADDING NEW SYMBOLS.             */
-    /*------------------------------------------------------------------------*/
-    if (!str_head || str_head->index + SYMNMLEN + 1 > str_head->size)
-    {
-       STRTAB *packet;
-
-       if (!(packet = (STRTAB *)malloc(sizeof(STRTAB) + MIN_STRING_ALLOC - 1)))
-          { load_err = E_ALLOC; return NULL; }
-
-       packet->size   = MIN_STRING_ALLOC;
-       packet->index  = 0;
-       packet->next   = str_head;
-       packet->offset = str_head ? (str_head->offset + str_head->size) : 4;
-       str_head       = packet;
-    }
-
-    /*------------------------------------------------------------------------*/
-    /* COPY THE NAME INTO THE STRING TABLE.                                   */
-    /*------------------------------------------------------------------------*/
-    result = dest = str_head->buf + str_head->index; 
-    for (i = 0; *dest++ = symptr->n_name[i++]; )
-       if (i == SYMNMLEN) { *dest++ = '\0'; ++i; break; }
-
-    symptr->n_zeroes = 0;
-    symptr->n_offset = str_head->offset + str_head->index;
-    str_head->index += i;
-    return result;
-}
-#endif
-
-/******************************************************************************/
-/*                                                                            */
-/* RELOC_ADD() - Add an entry to the relocation symbol table.  This table     */
-/*               stores relocation information for each relocatable symbol.   */
-/*                                                                            */
-/******************************************************************************/
-int reloc_add(int index, SYMENT *sym)
-{
-   int disp;                            /* RELOCATION AMOUNT FOR THIS SYMBOL */
-
-   if (!need_reloc) return TRUE;
-
-   /*-------------------------------------------------------------------------*/
-   /* USE THE SYMBOL VALUE TO CALCULATE THE RELOCATION AMOUNT:                */
-   /* 1) IF THE SYMBOL WAS UNDEFINED (DEFINED IN SECTION 0), USE THE          */
-   /*    SYMBOL'S VALUE.                                                      */
-   /* 2) IF THE SYMBOL HAS A POSITIVE SECTION NUMBER, USE THE RELOCATION      */
-   /*    AMOUNT FOR THE SECTION IN WHICH THE SYMBOL IS DEFINED.               */
-   /* 3) OTHERWISE, THE SYMBOL IS ABSOLUTE, SO THE RELOCATION AMOUNT IS 0.    */
-   /*-------------------------------------------------------------------------*/
-   if (sym->n_scnum == 0)
-      disp = sym->n_value;
-   else if (sym->n_scnum > 0)
-   {
-      if (sym->n_sclass == C_STATLAB || sym->n_sclass == C_EXTLAB)
-          disp = reloc_amount[sym->n_scnum - 1];
-      else disp = RUN_RELOC_AMOUNT(sym->n_scnum - 1);
-   }
-   else disp = 0;
-
-   /*-------------------------------------------------------------------------*/
-   /* IF THERE IS A NON-ZERO RELOCATION AMOUNT, ADD THE SYMBOL TO THE TABLE.  */
-   /*-------------------------------------------------------------------------*/
-   if (disp == 0) return TRUE;
-
-   if (reloc_sym_index >= reloc_tab_size)
-   {
-      reloc_tab_size += RELOC_GROW_SIZE;
-      reloc_tab = (RELOC_TAB *)realloc((char *)reloc_tab, 
-                                       reloc_tab_size*sizeof(RELOC_TAB));
-
-      if (!reloc_tab) { load_err = E_ALLOC; return FALSE; }
-   }
-   reloc_tab[reloc_sym_index  ].rt_index = index;
-   reloc_tab[reloc_sym_index++].rt_disp  = disp;
-
-   return TRUE;
-}
-
-/******************************************************************************/
-/*                                                                            */
-/* RELOCATE() - Perform a single relocation by patching the raw data.         */
-/*                                                                            */
-/******************************************************************************/
-int relocate(RELOC *rp, unsigned char *data, int s)
-{
-/*   RELOC         *rp;                    RELOCATION ENTRY                   */
-/*   unsigned char *data;                  DATA BUFFER                        */
-/*   int            s;                     INDEX OF CURRENT SECTION           */
-   int fieldsz = reloc_size(rp->r_type);     /* SIZE OF ACTUAL PATCH VALUE    */
-   int offset  = reloc_offset(rp->r_type);   /* OFFSET OF ACTUAL PATCH VALUE  */
-   int wordsz  = MAX(fieldsz, reloc_stop(rp->r_type)); /* SIZE CONTAINING FLD */
-   int objval;                              /* FIELD TO BE PATCHED           */
-   int reloc_amt;                           /* AMOUNT OF RELOCATION          */
-
-   int pp_shift_cnt = 0;
-   int pp_local     = FALSE;
-
-   if (rp->r_type == R_ABS) return TRUE;          /* NOTHING TO DO   */
-
-   /*-------------------------------------------------------------------------*/
-   /* DETERMINE THE RELOCATION AMOUNT FROM THE RELOCATION SYMBOL TABLE.       */
-   /*-------------------------------------------------------------------------*/
-   reloc_amt = (rp->r_symndx == -1) ? RUN_RELOC_AMOUNT(s) 
-                                   : sym_reloc_amount(rp);
-
-   /*-------------------------------------------------------------------------*/
-   /* EXTRACT THE RELOCATABLE FIELD FROM THE OBJECT DATA.                     */
-   /*-------------------------------------------------------------------------*/
-   objval = unpack(data, fieldsz, wordsz, offset + BIT_OFFSET(rp->r_vaddr));
-
-   /*-------------------------------------------------------------------------*/
-   /* MODIFY THE FIELD BASED ON THE RELOCATION TYPE.                          */
-   /*-------------------------------------------------------------------------*/
-   switch (rp->r_type)
-   {
-      /*----------------------------------------------------------------------*/
-      /* NORMAL RELOCATIONS: ADD IN THE RELOCATION AMOUNT.                    */
-      /*----------------------------------------------------------------------*/
-      case R_RELBYTE:
-      case R_RELWORD:
-      case R_REL24:
-      case R_RELLONG:
-      case R_DIR32:
-      case R_PARTLS16:
-        objval += reloc_amt;
-        break;
-
-      /*--------------------------------------------------------------------*/
-      /* ADD IN THE RELOCATION AMOUNT, BUT MAKE SURE WE'RE STILL IN THE     */
-      /* 370'S REGISTER FILE.                                               */
-      /*--------------------------------------------------------------------*/
-      case R_RRNREG:
-      case R_RRRELREG:
-        if (rp->r_type == R_RRNREG)
-           objval = ((char)objval + reloc_amt);
-        else objval += reloc_amt;
-         if (objval & ((-1L >> 8*fieldsz) << 8*fieldsz))
-         {
-           /* ERROR */
-         }
-         break;
-      /*--------------------------------------------------------------------*/
-      /* PP UNSCALED 15-BIT OFFSET RELOCATION.                              */
-      /*--------------------------------------------------------------------*/
-      case R_PP15    :
-      case R_PPL15   :
-      case R_PPN15   :
-      case R_PPLN15  :
-        {
-           int  bit;
-           char *sname = (SECT_HDR(s)->s_zeroes == 0L) ?
-                         SECT_HDR(s)->s_nptr : SNAMECPY(SECT_HDR(s)->s_name);
-
-           pp_local = (rp->r_type == R_PPL15) || (rp->r_type == R_PPLN15);
-
-           /*--------------------------------------------------------------*/
-           /* IF NEGATIVE RELOC TYPE, THEN TREAT CONST OFFSET AS A NEGATIVE*/
-           /*--------------------------------------------------------------*/
-           if (rp->r_type == R_PPN15 || rp->r_type == R_PPLN15)
-           {
-               objval      = -objval;
-                rp->r_type -= 010;           /* CHANGE TYPE TO NON NEG.     */
-            }
-
-           objval += reloc_amt;
-
-           /*--------------------------------------------------------------*/
-            /* IF THE ADDRESS STILL FALLS WITHIN AN APPROPRIATE RANGE       */
-           /*--------------------------------------------------------------*/
-           if ((objval >= 0x00000000 && objval <= 0x00007fff) || 
-               (objval >= 0x01000000 && objval <= 0x010007ff) )
-               break;
-
-           /*--------------------------------------------------------------*/
-            /* IF THE ADDRESS FALLS OUTSIDE AN APPROPRIATE RANGE, BUT CAN   */
-           /* BE SCALED BY SIZE TO GET BACK INTO RANGE, THEN READ THE UPPER*/
-           /* BIT OF THE SIZE FIELD.  IF IT IS A 1, THEN WE CAN SCALE THIS */
-           /* OFFSET BY 4, IF IT IS 0, THEN WE CAN SCALE THIS OFFSET BY 2. */ 
-           /*--------------------------------------------------------------*/
-           bit = unpack(data, 1, 64, pp_local ? 30 : 8);
-           /*--------------------------------------------------------------*/
-           /* DETERMINE IF THE OFFSET IS ALIGNED FOR SCALING.  IF SO,      */
-           /* THEN PACK THE SCALED OFFSET INTO INSTRUCTION, CHANGE THE     */
-           /* RELOC TYPE TO SCALED, AND TURN ON SCALE BIT IN INSTRUCT.     */
-           /*--------------------------------------------------------------*/
-           if (!(objval & ((2<<bit)-1)) && 
-                (objval >>= (bit+1)) >= 0 && objval <= 0x7fff)
-           {
-               rp->r_type = pp_local ? (bit ? R_PPL15W : R_PPL15H) : 
-                                       (bit ? R_PP15W : R_PP15H);
-               repack(1, data, 1, 64, pp_local ? 28 : 6);
-               break;
-           }
-           
-           /*--------------------------------------------------------------*/
-           /* ERROR, THE OFFSET WILL NOT FIT SCALED OR UNSCALED.           */
-           /*--------------------------------------------------------------*/
-           
-           load_err = E_RELOCENT;
-           return FALSE;
-         }
-
-      /*--------------------------------------------------------------------*/
-      /* PP SCALED 15-BIT OFFSET RELOCATION. FOR R_PP15W THE RELOC_AMT IS   */
-      /* DIVIDED BY 4.  FOR R_PP15H THE RELOC_AMT IS DIVIDED BY 2.          */ 
-      /*--------------------------------------------------------------------*/
-      case R_PP15W   :
-      case R_PPL15W  :
-      case R_PPN15W  :
-      case R_PPLN15W : pp_shift_cnt++;   /* FALL THROUGH */
-
-      case R_PP15H   :
-      case R_PPL15H  :
-      case R_PPN15H  :
-      case R_PPLN15H :  pp_shift_cnt++;   /* FALL THROUGH */
-        {
-           int obj_addr_x;
-           char *sname = (SECT_HDR(s)->s_zeroes == 0) ? 
-                         SECT_HDR(s)->s_nptr : SNAMECPY(SECT_HDR(s)->s_name);
-
-           /*--------------------------------------------------------------*/
-           /* NOTE THAT THIS IS DEPENDENT ON THE NUMBERING OF THESE RELOC  */
-           /* VALUES.                                                      */
-           /*--------------------------------------------------------------*/
-           pp_local = (rp->r_type & 4);
-
-           /*--------------------------------------------------------------*/
-           /* IF NEGATIVE RELOC TYPE, THEN TREAT CONST OFFSET AS NEGATIVE  */
-           /*--------------------------------------------------------------*/
-           if (rp->r_type >= R_PPN15) 
-           {
-               objval      = -objval;
-                rp->r_type -= 010;           /* CHANGE TYPE TO NON NEG.     */
-            }
-
-           obj_addr_x = (objval << pp_shift_cnt) + reloc_amt;
-
-           /*--------------------------------------------------------------*/
-            /* LINK TIME ADDRESS VIOLATES THE SCALING FACTOR WE ARE USING   */
-           /* FOR THIS OPERAND. UNSCALE THE VALUE IF IT WILL FIT IN 15 BITS*/
-           /* BY CHANGING RELOC TYPE TO UNSCALED, AND CHANGING SCALE BIT   */
-           /* IN THE INSTRUCTION.                                          */
-           /*--------------------------------------------------------------*/
-           if (pp_shift_cnt && (reloc_amt & ((1<<pp_shift_cnt)-1)))
-           {
-               objval     = obj_addr_x;
-               rp->r_type = (pp_local ? R_PPL15 : R_PP15);
-               repack(0, data, 1, 64, pp_local ? 28 : 6);
-           }
-           else objval = obj_addr_x >> pp_shift_cnt;
-
-           /*--------------------------------------------------------------*/
-            /* IF THE ADDRESS STILL FALLS WITHIN AN APPROPRIATE RANGE       */
-           /*--------------------------------------------------------------*/
-           if ((objval     >= 0x00000000  && objval     <= 0x00007fff) || 
-               (obj_addr_x >= 0x01000000  && obj_addr_x <= 0x010007ff) )
-               break;
-
-           /*--------------------------------------------------------------*/
-           /* ERROR, THE OFFSET WILL NOT FIT SCALED OR UNSCALED.           */
-           /*--------------------------------------------------------------*/
-           
-           load_err = E_RELOCENT;
-           return FALSE;
-         }
-
-      /*--------------------------------------------------------------------*/
-      /* PP 16-bit byte offset relocation. For R_PP16B the lower 15-bits    */
-      /* are handled just like R_PP15, and the upper bit is placed in the   */
-      /* scale indicator bit of the field.                                  */
-      /*--------------------------------------------------------------------*/
-      case R_PP16B   :
-      case R_PPL16B  :
-      case R_PPN16B  :
-      case R_PPLN16B :
-        {
-           char *sname = (SECT_HDR(s)->s_zeroes == 0) ? 
-                         SECT_HDR(s)->s_nptr : SNAMECPY(SECT_HDR(s)->s_name);
-
-           pp_local = (rp->r_type == R_PPL16B) || (rp->r_type == R_PPLN16B);
-
-            /*--------------------------------------------------------------*/
-           /* READ THE SCALE BIT (16th BIT) AND CREATE 16 BIT CONSTANT OFF */
-            /*--------------------------------------------------------------*/
-           objval |= (unpack(data, 1, 64, pp_local ? 28 : 6) << 15);
-
-           /*--------------------------------------------------------------*/
-           /* IF NEGATIVE RELOC TYPE, THEN TREAT CONST OFFSET AS NEGATIVE  */
-           /*--------------------------------------------------------------*/
-           if (rp->r_type == R_PPN16B || rp->r_type == R_PPLN16B)
-           {
-              objval      = - objval;
-               rp->r_type -= 010; /* CHANGE THE TYPE TO A NON NEG TYPE.     */
-            }
-
-           objval += reloc_amt;
-
-           /*--------------------------------------------------------------*/
-            /* IF THE ADDRESS STILL FALLS WITHIN AN APPROPRIATE RANGE       */
-           /*--------------------------------------------------------------*/
-           if ((objval >= 0x00000000 && objval <= 0x0000ffff) || 
-               (objval >= 0x01000000 && objval <= 0x010007ff) )
-           {
-              /*-----------------------------------------------------------*/
-              /* RELOCATE THE 16TH BIT OF THE ADDRESS.                     */
-              /*-----------------------------------------------------------*/
-              repack(((objval&0x8000) >> 15), data, 1, 64, pp_local ? 28 : 6);
-              break;
-            }
-
-           /*--------------------------------------------------------------*/
-            /* ADDRESS IS OUT OF RANGE.                                     */
-           /*--------------------------------------------------------------*/
-           
-           load_err = E_RELOCENT;
-           return FALSE;
-         }
-
-      /*--------------------------------------------------------------------*/
-      /* PP BASE ADDRESS RELOCATION.  BIT 0 IS 0 IF IN DATA RAM, 1 IF IN    */
-      /* PARAMETER RAM.  THIS CODE ASSUMES THAT WE DO NOT RELOCATE FROM     */
-      /* PRAM TO DRAM OR FROM DRAM TO PRAM AT LOAD TIME.                    */
-      /*--------------------------------------------------------------------*/
-      case R_PPLBASE: pp_local = TRUE;
-      case R_PPBASE:
-         {
-          /*---------------------------------------------------------------*/
-          /* IF WAS DRAM AND RELOC_AMT IS GREAT ENOUGH TO MOVE INTO PRAM,  */
-          /* CHANGE TO PRAM                                                */
-          /*---------------------------------------------------------------*/
-          if (!objval && reloc_amt > (int)(0x01000000 - 0xC000)) objval = 1;
-
-          /*---------------------------------------------------------------*/
-          /* IF WAS PRAM AND RELOC_AMT IS NEGATIVE AND CAN MOVE INTO DRAM, */
-          /* CHANGE TO DRAM                                                */
-          /*---------------------------------------------------------------*/
-          else if (objval && (-reloc_amt) > (int)(0x01000000 - 0xC000))
-              objval = 0;
-
-          break;
-         }
-
-      /*----------------------------------------------------------------------*/
-      /* 34010 ONE'S COMPLEMENT RELOCATION.  SUBTRACT INSTEAD OF ADD.         */
-      /*----------------------------------------------------------------------*/
-      case R_OCRLONG:
-        objval -= reloc_amt;
-        break;
-
-      /*----------------------------------------------------------------------*/
-      /* 34020 WORD-SWAPPED RELOCATION.  SWAP BEFORE RELOCATING.              */
-      /*----------------------------------------------------------------------*/
-      case R_GSPOPR32:
-      case R_OCBD32:
-          objval  = ((objval >> 16) & 0xFFFF) | (objval << 16); 
-          objval += (rp->r_type == R_GSPOPR32) ? reloc_amt : -reloc_amt; 
-          objval  = ((objval >> 16) & 0xFFFF) | (objval << 16);
-          break; 
-
-      /*----------------------------------------------------------------------*/
-      /* PC-RELATIVE RELOCATIONS.  IN THIS CASE THE RELOCATION AMOUNT         */
-      /* IS ADJUSTED BY THE PC DIFFERENCE.   IF THIS IS AN INTERNAL           */
-      /* RELOCATION TO THE CURRENT SECTION, NO ADJUSTMENT IS NEEDED.          */
-      /*----------------------------------------------------------------------*/
-      case R_PCRBYTE:
-      case R_PCRWORD:
-      case R_GSPPCR16:
-      case R_GSPPCA16:
-      case R_PCRLONG:
-      case R_PCR24:
-      case R_ANKPCR16:
-      case R_ANKPCR8:
-         {
-            int           shift = 8 * (4 - fieldsz);
-           unsigned int pcdif = RUN_RELOC_AMOUNT(s);
-
-           /*----------------------------------------------------------------*/
-           /* HANDLE SPECIAL CASES OF JUMPING FROM ABSOLUTE SECTIONS (SPECIAL*/
-           /* RELOC TYPE) OR TO ABSOLUTE DESTINATION (SYMNDX == -1).  IN     */
-           /* EITHER CASE, SET THE APPROPRIATE RELOCATION AMOUNT TO 0.       */
-           /*----------------------------------------------------------------*/
-           if( rp->r_symndx == -1 )      reloc_amt = 0;
-           if( rp->r_type == R_GSPPCA16) pcdif = 0;
-
-            /*----------------------------------------------------------------*/
-            /* Handle ankoor's offset where upper 14 (PCR8) and upper 6(PCR16)*/
-            /* bits of 22 bit address is held in r_disp field of reloc entry  */
-            /*----------------------------------------------------------------*/
-            if(rp->r_type == R_ANKPCR8 || rp->r_type == R_ANKPCR16)
-            {
-                shift = 10;
-                objval |= rp->r_disp << ((rp->r_type == R_ANKPCR8) ? 8 : 16);
-            }
-
-           reloc_amt -= pcdif;
-
-            if (rp->r_type == R_GSPPCR16 || rp->r_type == R_GSPPCA16)
-              reloc_amt >>= 4;                              /* BITS TO WORDS */
-
-           objval  = (int)(objval << shift) >> shift;      /* SIGN EXTEND   */
-           objval += reloc_amt;
-            break;
-         }
-
-      /*--------------------------------------------------------------------*/
-      /* Ankoor page-addressing.  Calculate address from the 22-bit         */
-      /* value in the relocation field plus the relocation amount. Shift    */
-      /* out the lower 16 bits.                                             */
-      /*--------------------------------------------------------------------*/
-      case R_PARTMS6:
-          objval = (objval & 0xC0) |
-                   (((rp->r_disp += reloc_amt) >> 16) & 0x3F);
-          break;
-
-      /*----------------------------------------------------------------------*/
-      /* 320C30 PAGE-ADDRESSING RELOCATION.  CALCULATE THE ADDRESS FROM       */
-      /* THE 8-BIT PAGE VALUE IN THE FIELD, THE 16-BIT OFFSET IN THE RELOC    */
-      /* ENTRY, AND THE RELOCATION AMOUNT.  THEN, STORE THE 8-BIT PAGE        */
-      /* VALUE OF THE RESULT BACK IN THE FIELD.                               */
-      /*----------------------------------------------------------------------*/
-      case R_PARTMS8:
-         objval = (int)((objval << 16) + rp->r_disp + reloc_amt) >> 16;
-         break;
-
-      /*----------------------------------------------------------------------*/
-      /* DSP(320) PAGE-ADDRESSING.  CALCULATE ADDRESS FROM THE 16-BIT         */
-      /* VALUE IN THE RELOCATION FIELD PLUS THE RELOCATION AMOUNT.  OR THE    */
-      /* TOP 9 BITS OF THIS RESULT INTO THE RELOCATION FIELD.                 */
-      /*----------------------------------------------------------------------*/
-      case R_PARTMS9:
-         objval = (objval & 0xFE00) | 
-                  (((int)(rp->r_disp + reloc_amt) >> 7) & 0x1FF);
-          break;
-
-      /*----------------------------------------------------------------------*/
-      /* DSP(320) PAGE-ADDRESSING.  CALCULATE ADDRESS AS ABOVE, AND OR THE    */
-      /* 7-BIT DISPLACEMENT INTO THE FIELD.                                   */
-      /*----------------------------------------------------------------------*/
-      case R_PARTLS7:
-         objval = (objval & 0x80) | ((rp->r_disp + reloc_amt) & 0x7F);
-         break;
-
-      /*--------------------------------------------------------------------*/
-      /* Ankoor page-addressing.  Calculate address from the 22-bit         */
-      /* value in the relocation field plus the relocation amount. Mask off */
-      /* bits [21:16] and [5:0] to extract a data page within a 64K page    */
-      /*--------------------------------------------------------------------*/
-      case R_PARTMID10:
-          objval = (objval & 0xFC00) |
-                   (((rp->r_disp += reloc_amt) >> 6) & 0x3FF);
-          break;
-
-      /*--------------------------------------------------------------------*/
-      /* RR(370) MSB RELOCATION.  CALCULATE ADDRESS FROM THE 16-BIT VALUE   */
-      /* IN THE RELOCATION ENTRY PLUS THE RELOCATION AMOUNT.  PATCH THE     */
-      /* MSB OF THE RESULT INTO THE RELOCATION FIELD.                       */
-      /*--------------------------------------------------------------------*/
-      case R_HIWORD:
-         objval += (rp->r_disp += (unsigned short)reloc_amt) >> 8;
-         break;
-
-      /*--------------------------------------------------------------------*/
-      /* C8+ High byte of 24-bit address.  Calculate address from 24-bit    */
-      /* value in the relocation entry plus the relocation amount.  Patch   */
-      /* the MSB of the result into the relocation field.                   */
-      /*--------------------------------------------------------------------*/
-      case R_C8PHIBYTE:
-          objval = (int)((objval << 16) + rp->r_disp + reloc_amt) >> 16;
-          break;
-
-      /*--------------------------------------------------------------------*/
-      /* C8+ Middle byte of 24-bit address.  Calculate address from 24-bit  */
-      /* value in the relocation entry plus the relocation amount.  Patch   */
-      /* the middle byte of the result into the relocation field.           */
-      /*--------------------------------------------------------------------*/
-      case R_C8PMIDBYTE:
-          objval = (int)((objval << 16) + rp->r_disp + reloc_amt) >> 8;
-          break;
-
-      /*--------------------------------------------------------------------*/
-      /* C8+ Vector Address.  Calculate address from 24-bit value in the    */
-      /* relocation entry plus the relocation amount.  MSB must be 0xFF     */
-      /* since interrupt and trap handlers must be programmed in the top-   */
-      /* most segment of memory.  Patch bottom 16-bits of the result into   */
-      /* the relocation field.                                              */
-      /*--------------------------------------------------------------------*/
-      case R_C8PVECADR:
-          objval += reloc_amt;
-          if ((objval & 0xFF0000) != 0xFF0000)
-          {
-            /* ERROR */
-          }
-          objval &= 0xFFFF;
-          break;
-
-      /*----------------------------------------------------------------------*/
-      /* C8+ 24-bit Address.  The byte ordering for 24-bit addresses on the   */
-      /* C8+ is reversed (low, middle, high).  Needs to be unordered, add     */
-      /* in reloc_amt, then re-ordered.                                       */
-      /*----------------------------------------------------------------------*/
-      case R_C8PADR24:
-          objval = ((objval>>16) | (objval&0xff00) | ((objval&0xff)<<16));
-          objval += reloc_amt;
-          objval = ((objval>>16) | (objval&0xff00) | ((objval&0xff)<<16));
-          break;
-
-      /*----------------------------------------------------------------------*/
-      /* DSP(320) 13-BIT CONSTANT.  RELOCATE ONLY THE LOWER 13 BITS OF THE    */
-      /* FIELD.                                                               */
-      /*----------------------------------------------------------------------*/
-      case R_REL13:
-          objval = (objval & 0xE000) | ((objval + reloc_amt) & 0x1FFF);
-          break;
-
-      /*--------------------------------------------------------------------*/
-      /* ANKOOR 22-bit extended address.  Calculate address by masking      */
-      /* off the opcode and OR in the lower 16-bit constant + the           */
-      /* amount.                                                            */
-      /*--------------------------------------------------------------------*/
-      case R_REL22:
-         {
-            unsigned int obj_hi = unpack(data  , 16, 16, 0);
-            unsigned int obj_lo = unpack(data+2, 16, 16, 0);
-
-            /*--------------------------------------------------------------*/
-            /* BUILD THE OFFSET TO BE RELOCATED.                            */
-            /*--------------------------------------------------------------*/
-            objval = ((obj_hi & 0x003F) << 16) | (obj_lo & 0xFFFF);
-
-            /*--------------------------------------------------------------*/
-            /* Calculate displacement                                       */
-            /*--------------------------------------------------------------*/
-            objval += reloc_amt;
-
-            /*--------------------------------------------------------------*/
-            /* REPACK THE RELOCATED VALUE BACK IN THE OBJECT VALUE.         */
-            /*--------------------------------------------------------------*/
-            obj_hi = (obj_hi & 0xFFC0) | ((objval & 0x3F0000) >> 16);
-            obj_lo = objval & 0xFFFF;
-            repack(obj_hi, data  , 16, 16, 0);
-            repack(obj_lo, data+2, 16, 16, 0);
-
-            return TRUE;
-         }
-
-      /*--------------------------------------------------------------------*/
-      /* DSP, LEAD 23-bit extended address.  Calculate address by masking   */
-      /* off the opcode and OR in the lower 16-bit constant + the           */
-      /* amount.                                                            */
-      /*--------------------------------------------------------------------*/
-      case R_REL23:
-         {
-            unsigned int obj_hi = unpack(data  , 16, 16, 0);
-            unsigned int obj_lo = unpack(data+2, 16, 16, 0);
-
-            /*--------------------------------------------------------------*/
-            /* BUILD THE OFFSET TO BE RELOCATED.                            */
-            /*--------------------------------------------------------------*/
-            objval = ((obj_hi & 0x007F) << 16) | (obj_lo & 0xFFFF);
-
-            /*--------------------------------------------------------------*/
-            /* Calculate displacement                                       */
-            /*--------------------------------------------------------------*/
-            objval += reloc_amt;
-
-            /*--------------------------------------------------------------*/
-            /* REPACK THE RELOCATED VALUE BACK IN THE OBJECT VALUE.         */
-            /*--------------------------------------------------------------*/
-            obj_hi = (obj_hi & 0xFF80) | ((objval & 0x7F0000) >> 16);
-            obj_lo = objval & 0xFFFF;
-            repack(obj_hi, data  , 16, 16, 0);
-            repack(obj_lo, data+2, 16, 16, 0);
-
-            return TRUE;
-         }
-
-
-      /*----------------------------------------------------------------------*/
-      /* PRISM (370/16) code label relocation.  Convert word address to byte  */
-      /* address, add in relocation, convert back to word address.            */
-      /*----------------------------------------------------------------------*/
-      case R_LABCOD:
-         objval = ((objval << 1) + reloc_amt) >> 1;
-         break;
-   }
-
-   /*-------------------------------------------------------------------------*/
-   /* PACK THE RELOCATED FIELD BACK INTO THE OBJECT DATA.                     */
-   /*-------------------------------------------------------------------------*/
-   repack(objval, data, fieldsz, wordsz, offset + BIT_OFFSET(rp->r_vaddr));
-   return TRUE;
-} 
-
-
-/******************************************************************************/
-/*                                                                            */
-/* RELOC_READ() - Read a single relocation entry.                             */
-/*                                                                            */
-/******************************************************************************/
-#if FILE_BASED
-int reloc_read(RELOC *rptr)
-#else
-int reloc_read(RELOC *rptr, unsigned int offset)
-#endif
-{
-#if COFF_VERSION_1 || COFF_VERSION_2
-   /*------------------------------------------------------------------------*/
-   /* THE FOLLOWING UNION IS USED TO READ IN VERSION 0 OR 1 RELOC ENTRIES    */
-   /*------------------------------------------------------------------------*/
-   /* THE FORMAT OF RELOCATION ENTRIES CHANGED BETWEEN COFF VERSIONS 0 AND 1.*/
-   /* VERSION 0 HAS A 16 BIT SYMBOL INDEX, WHILE VERSION 1 HAS A 32 BIT INDX.*/
-   /*------------------------------------------------------------------------*/
-   union { RELOC new_c; RELOC_OLD old; } input_entry;
-#if FILE_BASED
-   if (fread(&input_entry, RELSZ_IN(coff_version), 1, fin) != 1)
-      { load_err = E_FILE; return FALSE; }
-#else
-       mem_copy((void*)&input_entry, (void*)&gRxBuffer[offset], RELSZ_IN(coff_version));
-#endif
-   /*------------------------------------------------------------------------*/
-   /* IF LOADING A VERSION 0 FILE, TRANSLATE ENTRY TO VERSION 1 FORMAT.      */
-   /* (THIS COULD BE SIMPLER - ALL THE SWAPS EXCEPT FOR THE SYMBOL INDEX     */
-   /* COULD BE DONE AFTER THE TRANSLATION - BUT THIS SEEMS TO BE CLEARER)    */
-   /*------------------------------------------------------------------------*/
-   if (ISCOFF_0(coff_version))
-   {
-      if (byte_swapped)
-      {
-         swap4byte(&input_entry.old.r_vaddr);
-        swap2byte(&input_entry.old.r_type);
-
-        /* if a field reloc, fields are chars, so don't swap */
-        if (!isfldrel(input_entry.old.r_type))
-        {
-            swap2byte(&input_entry.old.r_symndx);
-            swap2byte(&input_entry.old.r_disp);
-        }
-      }
-
-      rptr->r_vaddr  = input_entry.old.r_vaddr;
-      rptr->r_symndx = input_entry.old.r_symndx;
-      rptr->r_disp   = input_entry.old.r_disp;
-      rptr->r_type   = input_entry.old.r_type;
-   }
-   else
-   {
-      *rptr = input_entry.new_c;
-
-      if (byte_swapped)
-      {
-         swap4byte(&rptr->r_vaddr); 
-        swap2byte(&rptr->r_type);
-
-        /* Again, if a field reloc, fields are chars, so don't swap */
-        if (!isfldrel(rptr->r_type))
-        {
-            swap4byte(&rptr->r_symndx);
-            swap2byte(&rptr->r_disp);  
-        }
-      }
-   }
-
-#else
-   /*-------------------------------------------------------------------------*/
-   /* READ IN AND BYTE SWAP AN VERSION 0 RELOC ENTRY                          */
-   /*-------------------------------------------------------------------------*/
-   if (fread(rptr, RELSZ, 1, fin) != 1) { load_err = E_FILE; return FALSE; }
-
-   if (byte_swapped)
-   {
-      swap4byte(&rptr->r_vaddr);
-      swap2byte(&rptr->r_type);  
-
-      /* If a field reloc, fields are chars, so don't swap */
-      if (!isfldrel(rptr->r_type))
-      {
-         swap2byte(&rptr->r_symndx);
-         swap2byte(&rptr->r_disp);
-      }
-   }
-#endif
-
-   return TRUE;
-}
-
-
-/*************************************************************************/
-/*                                                                       */
-/*   RELOC_SIZE()-                                                       */
-/*      Return the field size of a relocation type.                      */
-/*                                                                       */
-/*************************************************************************/
-
-int reloc_size(int type)
-{
-   switch (type)
-   {
-       case R_PPBASE:
-       case R_PPLBASE:      return 1;
-
-       case R_HIWORD:
-       case R_C8PHIBYTE:
-       case R_C8PMIDBYTE:
-       case R_RELBYTE:
-       case R_PCRBYTE:
-       case R_RRNREG:
-       case R_RRRELREG:
-       case R_ANKPCR8:
-       case R_PARTLS6:
-       case R_PARTMS6:
-       case R_PARTLS7:      return 8;
-
-       case R_PP15:
-       case R_PP15W:
-       case R_PP15H:
-       case R_PP16B:
-       case R_PPN15:
-       case R_PPN15W:
-       case R_PPN15H:
-       case R_PPN16B:
-       case R_PPL15:
-       case R_PPL15W:
-       case R_PPL15H:
-       case R_PPL16B:
-       case R_PPLN15:
-       case R_PPLN15W:
-       case R_PPLN15H:
-       case R_PPLN16B:      return 15;
-
-       case R_LABCOD:
-       case R_RELWORD:
-       case R_PCRWORD:
-       case R_ANKPCR16:
-       case R_GSPPCR16:
-       case R_GSPPCA16:
-       case R_PARTLS16:
-       case R_PARTMS8:
-       case R_PARTMS9:
-       case R_PARTMID10:
-       case R_PARTMS16:
-       case R_REL22:
-       case R_REL13:        
-       case R_C8PVECADR:    return 16;
-
-       case R_REL24:
-       case R_PCR24:
-       case R_PCR24W:
-      case R_C8PADR24:      return 24;
-
-       case R_MPPCR:
-       case R_GSPOPR32:
-       case R_RELLONG:
-       case R_PCRLONG:
-       case R_OCBD32:
-       case R_OCRLONG:
-       case R_DIR32:        return 32;
-
-       default:             return 0;
-   }
-}
-
-
-/*************************************************************************/
-/*                                                                       */
-/*   RELOC_OFFSET()-                                                     */
-/*      Return the offset of a relocation type field.  The value of      */
-/*      offset should be the bit offset of the LSB of the field in       */
-/*      little-endian mode.                                              */
-/*                                                                       */
-/*************************************************************************/
-
-int reloc_offset(int type)
-{
-   switch (type)
-   {
-       case R_PP15    :
-       case R_PP15W   :
-       case R_PP15H   :
-       case R_PP16B   :
-       case R_PPN15   :
-       case R_PPN15W  :
-       case R_PPN15H  :
-       case R_PPN16B  :
-       case R_PPLBASE :     return 22;
-
-       case R_PPL15   :
-       case R_PPL15W  :
-       case R_PPL15H  :
-       case R_PPL16B  :
-       case R_PPLN15  :
-       case R_PPLN15W :
-       case R_PPLN15H :
-       case R_PPLN16B :
-       case R_PPBASE  :     return 0;
-
-       default        :     return 0;
-   }
-}
-
-
-/*************************************************************************/
-/*                                                                       */
-/*   RELOC_STOP() -                                                      */
-/*      Return the number of bits to read for a relocation type.         */
-/*                                                                       */
-/*************************************************************************/
-
-int reloc_stop(int type)
-{
-   switch (type)
-   {
-       case R_PPBASE  :
-       case R_PPLBASE :
-
-       case R_PP15    :
-       case R_PP15W   :
-       case R_PP15H   :
-       case R_PP16B   :
-
-       case R_PPL15   :
-       case R_PPL15W  :
-       case R_PPL15H  :
-       case R_PPL16B  :
-
-       case R_PPN15   :
-       case R_PPN15W  :
-       case R_PPN15H  :
-       case R_PPN16B  :
-
-       case R_PPLN15  :
-       case R_PPLN15W :
-       case R_PPLN15H :
-       case R_PPLN16B :   return 64;
-
-       default       :    return WORDSZ * 8;
-   }
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/* SYM_RELOC_AMOUNT() - Determine the amount of relocation for a particular   */
-/*                      relocation entry.  Search the relocation symbol table */
-/*                      for the referenced symbol, and return the amount from */
-/*                      the table.                                            */
-/*                                                                            */
-/******************************************************************************/
-int sym_reloc_amount(RELOC *rp)
-{
-   int index = rp->r_symndx;
-
-   int i = 0,
-       j = reloc_sym_index - 1;
-
-   /*-------------------------------------------------------------------------*/
-   /* THIS IS A SIMPLE BINARY SEARCH (THE RELOC TABLE IS ALWAYS SORTED).      */
-   /*-------------------------------------------------------------------------*/
-   while (i <= j)
-   {
-      int m = (i + j) / 2;
-      if      (reloc_tab[m].rt_index < index) i = m + 1;
-      else if (reloc_tab[m].rt_index > index) j = m - 1;
-      else return reloc_tab[m].rt_disp;                              /* FOUND */
-   }
-
-   /*-------------------------------------------------------------------------*/
-   /* IF NOT FOUND, SYMBOL WAS NOT RELOCATED.                                 */
-   /*-------------------------------------------------------------------------*/
-   return 0;
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/*  UNPACK() - Extract a relocation field from object bytes and convert into  */
-/*             a int so it can be relocated.                                 */
-/*                                                                            */
-/******************************************************************************/
-unsigned int unpack(unsigned char *data, int fieldsz, int wordsz, int bit_offset)
-{
-   register int  i;
-   unsigned int objval;
-   int           start;                       /* MS byte with reloc data      */
-   int           stop;                        /* LS byte with reloc data      */
-   int           r  = bit_offset & 7;         /* num unused LS bits in stop   */
-   int           l  = 8 - r;                  /* num used   MS bits in stop   */
-   int           tr = ((bit_offset+fieldsz-1) & 7)+1; /* # LS bits in strt*/
-   int           tl = 8 - tr;                /* num unused MS bits in start  */
-
-   start = (big_e_target ? (wordsz-fieldsz-bit_offset) : 
-                          (bit_offset+fieldsz-1)) >>3;
-   stop  = (big_e_target ? (wordsz-bit_offset-1) : bit_offset) >>3;
-
-   if (start == stop) return (data[stop] >> r) & ((0x1 << fieldsz) - 0x1);
-
-   objval = (unsigned)((data[start] << tl) & 0xFF) >> tl;
-   
-   if (big_e_target) 
-        for (i=start+1; i<stop; ++i) objval = (objval << 8) | data[i];
-   else  for (i=start-1; i>stop; --i) objval = (objval << 8) | data[i];
-   
-   return (objval << l) | (data[stop] >> r);
-}
-
-
-
-/******************************************************************************/
-/*                                                                            */
-/* REPACK() - Encode a binary relocated field back into the object data.      */
-/*                                                                            */
-/******************************************************************************/
-void repack(unsigned int objval, unsigned char *data, int fieldsz,
-            int  wordsz, int bit_offset)
-{
-   register int  i;
-   int           start;                      /* MS byte with reloc data       */
-   int           stop;                       /* LS byte with reloc data       */
-   int           r     = bit_offset & 7;     /* num unused LS bits in stop    */
-   int           l     = 8 - r;              /* num used   MS bits in stop    */
-   int           tr    = ((bit_offset+fieldsz-1) & 7)+1; /* # LS bits in strt */
-   unsigned int mask  = (1ul << fieldsz) - 1ul;
-
-   if (fieldsz < sizeof(objval)) objval &= mask;
-   
-   start = (big_e_target ? (wordsz-fieldsz-bit_offset) : 
-                          (bit_offset+fieldsz-1)) >>3;
-   stop  = (big_e_target ? (wordsz-bit_offset-1) : bit_offset) >>3;
-
-   if (start == stop)
-   {
-       data[stop] &= ~(mask << r);
-       data[stop] |= (objval << r); 
-       return;
-   }
-
-   data[start] &= ~((1<<tr)-1);
-   data[stop]  &=  ((1<< r)-1);
-   data[stop]  |= (objval << r); 
-   objval     >>= l;
-
-   if (big_e_target) 
-        for (i = stop - 1; i > start; objval >>= 8) data[i--] = objval;
-   else for (i = stop + 1; i < start; objval >>= 8) data[i++] = objval;
-   
-   data[start] |= objval; 
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/* CLOAD_LINENO() - Read in, swap, and relocate line number entries.  This    */
-/*                  function is not called directly by the loader, but by the */
-/*                  application when it needs to read in line number entries. */
-/*                                                                            */
-/******************************************************************************/
-int cload_lineno(int filptr, int count, LINENO *lptr, int scnum) 
-{
-/*   int    filptr;                      WHERE TO READ FROM                  */
-/*   int     count;                       HOW MANY TO READ                    */
-/*   LINENO *lptr;                        WHERE TO PUT THEM                   */
-/*   int     scnum;                       SECTION NUMBER OF THESE ENTRIES     */
-
-    int i;
-
-    /*------------------------------------------------------------------------*/
-    /* READ IN THE REQUESTED NUMBER OF LINE NUMBER ENTRIES AS A BLOCK.        */
-    /*------------------------------------------------------------------------*/
-#if FILE_BASED
-    if (fseek(fin, filptr, 0) != 0) { load_err = E_FILE; return FALSE; }
-    for (i = 0; i < count; i++)
-        if (fread(lptr + i, 1, LINESZ, fin) != LINESZ) 
-                                    { load_err = E_FILE; return FALSE; }
-#else
-       for (i = 0; i < count; i++)
-       mem_copy((void*)(lptr+i), (void*)&gRxBuffer[filptr + i*LINESZ], LINESZ);
-#endif
-    /*------------------------------------------------------------------------*/
-    /* SWAP AND RELOCATE EACH ENTRY, AS NECESSARY.                            */
-    /*------------------------------------------------------------------------*/
-    if (byte_swapped || RUN_RELOC_AMOUNT(scnum - 1))
-       for (i = 0; i < count; i++, lptr++)
-       {
-         if (byte_swapped)
-         {
-             swap2byte(&lptr->l_lnno);
-             swap4byte(&lptr->l_addr.l_paddr);
-         }
-
-         if (lptr->l_lnno != 0) 
-            lptr->l_addr.l_paddr += RUN_RELOC_AMOUNT(scnum - 1);
-       }
-    
-    return TRUE;
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/*  SWAP4BYTE() - Swap the order of bytes in a int.                          */
-/*                                                                            */
-/******************************************************************************/
-void swap4byte(void *addr)
-{
-   unsigned int *value = (unsigned int *)addr;
-   unsigned int temp1, temp2, temp3, temp4;
-
-   temp1 = (*value)       & 0xFF;
-   temp2 = (*value >> 8)  & 0xFF;
-   temp3 = (*value >> 16) & 0xFF;
-   temp4 = (*value >> 24) & 0xFF;
-
-   *value = (temp1 << 24) | (temp2 << 16) | (temp3 << 8) | temp4;
-}
-
-
-/******************************************************************************/
-/*                                                                            */
-/*  SWAP2BYTE() - Swap the order of bytes in a short.                         */
-/*                                                                            */
-/******************************************************************************/
-void swap2byte(void *addr)
-{
-   unsigned short *value = (unsigned short *)addr;
-   unsigned short temp1,temp2;
-
-   temp1 = temp2 = *value;
-   *value = ((temp2 & 0xFF) << 8) | ((temp1 >> 8) & 0xFF);
-}
index 9dd3ef3b6b7a13ac88ac262a7747ebc2dd1e8a8e..a499bba3300cecebd5b23d6050ab73163d45ac48 100644 (file)
 #define fread(w,x,y,z)      (((*z->read)((Uint8 *)(w),(Uint32)((x)*(y)))) == 0 ? (y) : 0)
 
 /* Use stdlib functions where possible */
-#define mem_copy(dest,src,nbytes)           memcpy((void *)(dest),(void *)(src),nbytes)
-#define mem_write(buf, nbytes, addr, page)  memcpy((void *)(addr),(void *)(buf),nbytes)
+#define mem_copy(dest,src,nbytes)           iblMemcpy((void *)(dest),(void *)(src),nbytes)
+#define mem_write(buf, nbytes, addr, page)  iblMemcpy((void *)(addr),(void *)(buf),nbytes)
 #define str_comp                            strcmp
 #define strn_copy                           strncpy
 
+#define malloc                              iblMalloc
+#define free                                iblFree
+
 
 /***********************
  * Function Prototypes
index f602563eb1f2afb11281ae0d32c6effc9739fcc3..b3bb2984eccdd125236a282006b385c87850c04b 100644 (file)
@@ -65,6 +65,7 @@
 #include "ArrayList.h"
 #include "ewrap.h"
 #include "dload_api.h"
+#include "file_ovr.h"
 
 /*****************************************************************************/
 /* AL_INITIALIZE() - Initialize a newly created Array_List object.           */
@@ -120,5 +121,5 @@ int32_t AL_size(Array_List* obj)
 /*****************************************************************************/
 void AL_destroy(Array_List* obj)
 {
-   free(obj->buf);
+   DLIF_free(obj->buf);
 }
index cd7985424995f3e956fbd9c77a8a29e63b779c16..90cdb039c881ca0c66723336a8a3290e99fb79f4 100644 (file)
@@ -111,7 +111,7 @@ int32_t DLIF_fclose(LOADER_FILE_DESC *fd)
 /*****************************************************************************/
 void* DLIF_malloc(size_t size)
 {
-   return malloc(size*sizeof(uint8_t));
+   return iblMalloc(size*sizeof(uint8_t));
 }
 
 /*****************************************************************************/
@@ -119,7 +119,7 @@ void* DLIF_malloc(size_t size)
 /*****************************************************************************/
 void DLIF_free(void* ptr)
 {
-   free(ptr);
+   iblFree(ptr);
 }
 
 /*****************************************************************************/
index d3e261936d4f7a0806bf71bd2fdbb7a1431233b7..8db75f0205461437d1468081121050bd93ab5f51 100644 (file)
 #define fclose(x)           0
 
 
+/* Redirect memory operations */
+#define malloc      iblMalloc
+#define free        iblFree
+#define memset      iblMemset
+#define memcpy      iblMemcpy
+
 #define FILE BOOT_MODULE_FXN_TABLE
 
 #endif /* _FILE_OVR_H */
index 39557ad3aa3ea7105320550ddf21aaa505fd3e1a..3fee3f2ec1984dd2ccb13176deebadc2ceffa76a 100644 (file)
@@ -54,6 +54,43 @@ bool littleEndian;
  */
 extern Int32 btblWrapEcode;
 
+/**
+ *  @brief
+ *      The malloc function used for both boot stages of the ibl
+ */
+void *iblMalloc (Uint32 size)
+{
+    return (malloc (size));
+}
+
+/**
+ *  @brief
+ *      The free function used for both stages of the ibl
+ */
+void iblFree (void *mem)
+{
+    free (mem);
+}
+
+/**
+ *  @brief
+ *      The memset function used for both stages of the ibl
+ */
+void *iblMemset (void *mem, Int32 ch, Uint32 n)
+{
+    return (memset (mem, ch, n));
+}
+
+/**
+ *  @brief
+ *      The memcpy function used for both stages of the ibl
+ */
+void *iblMemcpy (void *s1, const void *s2, Uint32 n)
+{
+    return (memcpy (s1, s2, n));
+
+}
+
 /**
  *  @brief
  *      Ones complement addition
@@ -331,6 +368,27 @@ Int32 iblI2cRead (Uint8 *buf, Uint32 num_bytes)
 
 }
 
+#define iblBITMASK(x,y)      (   (   (  ((UINT32)1 << (((UINT32)x)-((UINT32)y)+(UINT32)1) ) - (UINT32)1 )   )   <<  ((UINT32)y)   )
+#define iblREAD_BITFIELD(z,x,y)   (((UINT32)z) & iblBITMASK(x,y)) >> (y)
+/**
+ *  @brief
+ *      Return the lower 16 bits of a 32 bit value. A function is used (with cross-function optomization off)
+ *      which results in an endian independent version
+ */
+uint16 readLower16 (uint32 v)
+{
+    return (iblREAD_BITFIELD(v,15,0));
+
+}
+
+/**
+ * @brief
+ *      Return the upper 16 bits of a 32 bit value. A function is used to force an endian independent version
+ */
+uint16 readUpper16 (uint32 v)
+{
+  return (iblREAD_BITFIELD(v,31,16));
+}
 
 
 /**
@@ -364,6 +422,8 @@ void main (void)
 {
 
     uint16       v;
+    uint16       configAddrLsw;
+    uint16       configAddrMsw;
     uint32       entry;
     void         (*exit)();
     iblI2cMap_t  map;
@@ -383,14 +443,67 @@ void main (void)
                IBL_I2C_OWN_ADDR);           /* The address used by this device on the i2c bus */
 
 
+    /* Read the I2C mapping information from the eeprom */
+    for (;;)  {
+        if (hwI2cMasterRead (IBL_I2C_MAP_TABLE_DATA_ADDR,     /* The address on the eeprom of the data mapping */
+                             sizeof(iblI2cMap_t),             /* The number of bytes to read */
+                             (UINT8 *)&map,                   /* Where to store the bytes */
+                             IBL_I2C_MAP_TABLE_DATA_BUS_ADDR, /* The bus address of the eeprom */
+                             IBL_I2C_CFG_ADDR_DELAY)          /* The delay between sending the address and reading data */
+
+             == I2C_RET_OK)  {
+
+                /* On the I2C EEPROM the table is always formatted with the most significant
+                 * byte first. So if the device is running little endain the endian must be
+                 * swapped */
+                if (littleEndian == TRUE)  {
+                    map.length   = swap16val (map.length);
+                    map.chkSum   = swap16val (map.chkSum);
+                    map.addrLe   = swap32val (map.addrLe);
+                    map.configLe = swap32val (map.configLe);
+                    map.addrBe   = swap32val (map.addrBe);
+                    map.configBe = swap32val (map.configBe);
+
+                    configAddrLsw = readLower16 (map.configLe);
+                    configAddrMsw = readUpper16 (map.configLe);
+
+                }  else  {
+                    configAddrLsw = readLower16 (map.configBe);
+                    configAddrMsw = readUpper16 (map.configLe);
+
+                }
+
+
+                if (map.length != sizeof(iblI2cMap_t))  {
+                    iblStatus.mapSizeFail += 1;
+                    continue;
+                }
+
+                if (map.chkSum != 0)  {
+                    
+                    v = onesComplementChksum ((UINT16 *)&map, sizeof(iblI2cMap_t));
+                    if ((v != 0) && (v != 0xffff))  {
+                        iblStatus.mapRetries += 1;
+                        continue;
+                    }
+                }
+
+                break;
+        }
+
+        iblStatus.mapRetries += 1;
+
+    }
+
+
     /* Read the i2c configuration tables until the checksum passes and the magic number
      * matches. The checksum must be verified before the endian re-ordering is done */
     for (;;)  {
 
-        if (hwI2cMasterRead (IBL_I2C_CFG_TABLE_DATA_ADDR,    /* The address on the eeprom of the table */
+        if (hwI2cMasterRead (configAddrLsw,                  /* The address on the eeprom of the table */
                              sizeof(ibl_t),                  /* The number of bytes to read */
                              (UINT8 *)&ibl,                  /* Where to store the bytes */
-                             IBL_I2C_CFG_EEPROM_BUS_ADDR,    /* The bus address of the eeprom */
+                             configAddrMsw,                  /* The bus address of the eeprom */
                              IBL_I2C_CFG_ADDR_DELAY)         /* The delay between sending the address and reading data */
 
              == I2C_RET_OK)  {
@@ -424,47 +537,6 @@ void main (void)
     /* Pll configuration is device specific */
     devicePllConfig ();
 
-    /* The IBL table is in place. Read the I2C map information from the eeprom */
-    for (;;)  {
-        if (hwI2cMasterRead (IBL_I2C_MAP_TABLE_DATA_ADDR,    /* The address on the eeprom of the data mapping */
-                             sizeof(iblI2cMap_t),            /* The number of bytes to read */
-                             (UINT8 *)&map,                  /* Where to store the bytes */
-                             IBL_I2C_CFG_EEPROM_BUS_ADDR,    /* The bus address of the eeprom */
-                             IBL_I2C_CFG_ADDR_DELAY)         /* The delay between sending the address and reading data */
-
-             == I2C_RET_OK)  {
-
-                /* On the I2C EEPROM the table is always formatted with the most significant
-                 * byte first. So if the device is running little endain the endian must be
-                 * swapped */
-                if (littleEndian == TRUE)  {
-                    map.length = swap16val (map.length);
-                    map.chkSum = swap16val (map.chkSum);
-                    map.addrLe = swap32val (map.addrLe);
-                    map.addrBe = swap32val (map.addrBe);
-                }
-
-                if (map.length != sizeof(iblI2cMap_t))  {
-                    iblStatus.mapSizeFail += 1;
-                    continue;
-                }
-
-                if (map.chkSum != 0)  {
-                    
-                    v = onesComplementChksum ((UINT16 *)&map, sizeof(iblI2cMap_t));
-                    if ((v != 0) && (v != 0xffff))  {
-                        iblStatus.mapRetries += 1;
-                        continue;
-                    }
-                }
-
-                break;
-        }
-
-        iblStatus.mapRetries += 1;
-
-    }
-
 
     /* The rest of the IBL is in boot table format. Read and process the data */
     if (littleEndian == TRUE) 
index 20d51df37249f051a4c54c1627dacb0cf4605cad..f112ee85b0a02c7f1a3459b513c08f0d818c6acb 100644 (file)
@@ -91,7 +91,7 @@ void main (void)
     int32 i, j;
 
     /* Initialize the status structure */
-    memset (&iblStatus, 0, sizeof(iblStatus_t));
+    iblMemset (&iblStatus, 0, sizeof(iblStatus_t));
     iblStatus.iblMagic = ibl_MAGIC_VALUE;
 
 
index 53ad8745498e136296aaf904e62199c8b7d3e71f..e7862c88985baa4089dd8f77412be52b0e5329e8 100644 (file)
@@ -20,7 +20,6 @@
 /* Common memory and section areas between ibl_init and ibl */
 #include "ibl_common.inc"
 
-
 SECTIONS
 {
        .cinit  > TEXT
index 13b6139905c1b534540acad78ee277aa85814ecb..f2f196da2dd034b888b795fac58031985d9afad9 100644 (file)
@@ -16,7 +16,7 @@ CLEAN_MODULES=$(addprefix clean_,$(MODULES))
 
 TARGETS= c6472 c6474 c6474l c6455 c6457
 
-COMMON_SYMBOLS= hwI2Cinit hwI2cMasterRead iblBootBtbl
+COMMON_SYMBOLS= hwI2Cinit hwI2cMasterRead iblBootBtbl iblMalloc iblFree iblMemset iblMemcpy
 
 ifeq ($(ENDIAN),little)
        HEX_OPT= -order L
diff --git a/src/mkdeppath.bat b/src/mkdeppath.bat
deleted file mode 100644 (file)
index d2ed041..0000000
+++ /dev/null
@@ -1 +0,0 @@
-set MAKEDEPPATH=/data/projects/ibl/git/ibl/src/make/makedep/makedep.exe
index e8025f5ea24f9d162de9256ddcb6705e290d9cae..606aced1a9507a9e582f3da1dacceb116ef5f1e1 100644 (file)
@@ -20,19 +20,6 @@ endif
 
 export ENDIAN
 
-# The value of I2C_PARAM_BUS_ADDR determines the I2C bus address used
-# to read the ibl configuration table from. The default values are
-# 0x50 for little endian and 0x51 for big endian
-
-ifndef I2C_PARAM_BUS_ADDR
- ifeq ($(ENDIAN),little)
-   I2C_PARAM_BUS_ADDR=0x50
- else
-   I2C_PARAM_BUS_ADDR=0x51
- endif
-endif
-
-export I2C_PARAM_BUS_ADDR
 
 $(DEVICES):
        make -f makestg2 ARCH=c64x TARGET=$@ $@
index 3cbe2ef163ab960d0760d0216dea8e6834fadcd3..744b2306bbe38b757a9182776bb22f3062c7d926 100644 (file)
@@ -63,9 +63,9 @@ hotmenu setConfig_c6472()
     ibl.ethConfig[0].bootFormat       = ibl_BOOT_FORMAT_BBLOB;\r
 \r
 \r
-    SETIP(ibl.ethConfig[0].ethInfo.ipAddr,    158,218,100,113);\r
-    SETIP(ibl.ethConfig[0].ethInfo.serverIp,  158,218,100,25);\r
-    SETIP(ibl.ethConfig[0].ethInfo.gatewayIp, 158,218,100,2);\r
+    SETIP(ibl.ethConfig[0].ethInfo.ipAddr,    10,218,109,21);\r
+    SETIP(ibl.ethConfig[0].ethInfo.serverIp,  10,218,109,196);\r
+    SETIP(ibl.ethConfig[0].ethInfo.gatewayIp, 10,218,109,2);\r
     SETIP(ibl.ethConfig[0].ethInfo.netmask,   255,255,255,0);\r
 \r
     /* Leave the hardware address as 0 so the e-fuse value will be used */\r
@@ -73,18 +73,18 @@ hotmenu setConfig_c6472()
 \r
 \r
 \r
-    ibl.ethConfig[0].ethInfo.fileName[0]  = 'c';\r
-    ibl.ethConfig[0].ethInfo.fileName[1]  = '6';\r
-    ibl.ethConfig[0].ethInfo.fileName[2]  = '4';\r
-    ibl.ethConfig[0].ethInfo.fileName[3]  = '7';\r
-    ibl.ethConfig[0].ethInfo.fileName[4]  = '2';\r
-    ibl.ethConfig[0].ethInfo.fileName[5]  = '-';\r
+    ibl.ethConfig[0].ethInfo.fileName[0]  = 't';\r
+    ibl.ethConfig[0].ethInfo.fileName[1]  = 'e';\r
+    ibl.ethConfig[0].ethInfo.fileName[2]  = 's';\r
+    ibl.ethConfig[0].ethInfo.fileName[3]  = 't';\r
+    ibl.ethConfig[0].ethInfo.fileName[4]  = '.';\r
+    ibl.ethConfig[0].ethInfo.fileName[5]  = 'b';\r
     ibl.ethConfig[0].ethInfo.fileName[6]  = 'l';\r
-    ibl.ethConfig[0].ethInfo.fileName[7]  = 'e';\r
-    ibl.ethConfig[0].ethInfo.fileName[8]  = '.';\r
-    ibl.ethConfig[0].ethInfo.fileName[9]  = 'b';\r
-    ibl.ethConfig[0].ethInfo.fileName[10] = 'i';\r
-    ibl.ethConfig[0].ethInfo.fileName[11] = 'n';\r
+    ibl.ethConfig[0].ethInfo.fileName[7]  = 'o';\r
+    ibl.ethConfig[0].ethInfo.fileName[8]  = 'b';\r
+    ibl.ethConfig[0].ethInfo.fileName[9]  = '\0';\r
+    ibl.ethConfig[0].ethInfo.fileName[10] = '\0';\r
+    ibl.ethConfig[0].ethInfo.fileName[11] = '\0';\r
     ibl.ethConfig[0].ethInfo.fileName[12] = '\0';\r
     ibl.ethConfig[0].ethInfo.fileName[13] = '\0';\r
     ibl.ethConfig[0].ethInfo.fileName[14] = '\0';\r
index b4ba1dff75fa182ad163bd584965c48496558998..6ef8df5abc881c3d1c33efea362de3fed7f14ba1 100644 (file)
 
 ibl_t ibl;
 
+/* The configAddress must be programmed. On images which support both endians
+ * there can be two seperate configurations, one for big endian, and one for little */
+unsigned int configBusAddress = 0x50;
+unsigned int configAddress    = 0;
+
 
 /**
  *  @brief
@@ -138,6 +143,15 @@ void main (void)
 
     volatile Int32 i;
 
+    if (configAddress == 0)  {
+      printf ("Error: The global variable config address must be setup prior to running this program\n");
+      printf ("       This is the address in the I2C eeprom where the parameters live. On configurations\n");
+      printf ("       which support both big and little endian it is possible to configure the IBL to\n");
+      printf ("       usage a different configuration table for each endian, so this program must be run\n");
+      printf ("       twice. The value 0 is invalid for configAddress\n");
+      return;
+    }
+
     printf ("Run the GEL for for the device to be configured, press return to program the I2C\n");
     getchar ();
 
@@ -167,15 +181,15 @@ void main (void)
     currentOffset = 0;
     do  {
 
-        n = formBlock ((UINT8 *)&ibl, sizeof(ibl_t), &currentOffset, writeBlock, IBL_I2C_CFG_TABLE_DATA_ADDR);
+        n = formBlock ((UINT8 *)&ibl, sizeof(ibl_t), &currentOffset, writeBlock, configAddress);
 
         if (n > 0)  {
 
-            iret = hwI2cMasterWrite (IBL_I2C_CFG_EEPROM_BUS_ADDR,   /* The I2C bus address of the eeprom */
-                                     writeBlock,                    /* The data to write */
-                                     n,                             /* The number of bytes to write */
-                                     I2C_RELEASE_BUS,               /* Release the bus when the write is done */
-                                     FALSE );                       /* Bus is not owned at start of operation */
+            iret = hwI2cMasterWrite (configBusAddress,   /* The I2C bus address of the eeprom */
+                                     writeBlock,         /* The data to write */
+                                     n,                  /* The number of bytes to write */
+                                     I2C_RELEASE_BUS,    /* Release the bus when the write is done */
+                                     FALSE );            /* Bus is not owned at start of operation */
 
             if (iret != I2C_RET_OK)  {
                 sprintf (iline, "Block at offset %d\n", currentOffset);
index 190e815e7b2159acc3b8b11cbbc320086e17aa1c..2cd74507927967d6fe99952a8c5d378dc3016c96 100644 (file)
@@ -46,8 +46,6 @@ export C6X_C_DIR
 export ARCH
 export TARGET
 
-CDEFS += -DIBL_I2C_CFG_EEPROM_BUS_ADDR=$(I2C_PARAM_BUS_ADDR)
-
 .PHONY: i2cparam.cmd
 
 $(DEVICES): gen_cdefdep $(MODULES) $(OBJS) i2cparam.cmd
index 21dc8522a68884d92bf5019a60377609f2720d57..087cf8b4bbb287780c416861cbe7459d33008509 100644 (file)
@@ -160,7 +160,7 @@ void rBegin (int blockType)
 void initLayout (layout_t *cl)
 {
 
-  cl->nFiles   = 0;
+  cl->nPlt     = 0;
   cl->dev_addr = 0x50;
   cl->address  = 0;
   cl->align    = 0;
@@ -179,12 +179,16 @@ void setLayout (void)
   int currentAlign;
   int newAlign;
 
-  for (i = 0; i < layouts[currentLayout].nFiles; i++)  {
-    currentAlign = progFile[layouts[currentLayout].file[i]].align;
-    newAlign     = layouts[currentLayout].align;
+  for (i = 0; i < layouts[currentLayout].nPlt; i++)  {
 
-    if (newAlign > currentAlign)
-      progFile[layouts[currentLayout].file[i]].align = newAlign;
+    if (layouts[currentLayout].plt[i].type == PLT_FILE)  {
+
+      currentAlign = progFile[layouts[currentLayout].plt[i].index].align;
+      newAlign     = layouts[currentLayout].align;
+
+      if (newAlign > currentAlign)
+        progFile[layouts[currentLayout].plt[i].index].align = newAlign;
+    }
 
   }
 
@@ -207,8 +211,10 @@ void setLayout (void)
  *************************************************************************************/
 void initPad (pad_t *p)
 {
-  p->address = 0;
-  p->len     = 0;
+  p->id       = -1;
+  p->address  = 0;
+  p->dev_addr = 0x50;
+  p->len      = 0;
 }
 
 
@@ -466,6 +472,15 @@ void assignKeyVal (int field, int value)
         case ALIGN:        layouts[currentLayout].align = value;
                            break;
 
+        case PAD_FILE_ID:   if (layouts[currentLayout].nPlt >= MAX_LAYOUT_FILES)  {
+                              fprintf (stderr, "romparse: line %d: number of layout entries exceeds maximum of %d\n", line, MAX_LAYOUT_FILES);
+                              exit (-1);
+                            }
+                            layouts[currentLayout].plt[layouts[currentLayout].nPlt].type  = PLT_PAD;
+                            layouts[currentLayout].plt[layouts[currentLayout].nPlt].index = value;
+                            layouts[currentLayout].nPlt += 1;
+                            break;
+
 
         default:
             fprintf (stderr, "romparase: Invalid assignment in layout specification (line %d)\n", line);
@@ -490,6 +505,9 @@ void assignKeyVal (int field, int value)
         case LENGTH:    pads[currentPad].len = value;
                         break;
 
+        case PAD_FILE_ID: pads[currentPad].id = value;
+                          break;
+
         default:
           fprintf (stderr, "romparse: Invalid assignment in pad specificaiton (line %d)\n", line);
           break;
@@ -535,9 +553,16 @@ void assignKeyStr (int value, char *y)
 
       }  else  {   /* LAYOUT */
 
-        if (currentLayout < MAX_LAYOUTS)
-          layouts[currentLayout].file[layouts[currentLayout].nFiles++] = i;
-        else
+        if (currentLayout < MAX_LAYOUTS)  {
+          if (layouts[currentLayout].nPlt <= MAX_LAYOUT_FILES)  {
+            layouts[currentLayout].plt[layouts[currentLayout].nPlt].type  = PLT_FILE;
+            layouts[currentLayout].plt[layouts[currentLayout].nPlt].index = i;
+            layouts[currentLayout].nPlt += 1;
+
+          }  else  {
+            fprintf (stderr, "romparse: line %d: Max number (%d) of layout specification exceeded\n", line, MAX_LAYOUT_FILES);
+          }
+        }  else
           fprintf (stderr, "romparse: Number of layout sections exceeded (max = %d)\n", MAX_LAYOUTS);
 
       }
@@ -560,9 +585,16 @@ void assignKeyStr (int value, char *y)
 
     }  else  {  /* LAYOUT */
         
-        if (currentLayout < MAX_LAYOUTS)
-          layouts[currentLayout].file[layouts[currentLayout].nFiles++] = i;
-        else
+        if (currentLayout < MAX_LAYOUTS)  {
+          if (layouts[currentLayout].nPlt <= MAX_LAYOUT_FILES)  {
+            layouts[currentLayout].plt[layouts[currentLayout].nPlt].type  = PLT_FILE;
+            layouts[currentLayout].plt[layouts[currentLayout].nPlt].index = i;
+            layouts[currentLayout].nPlt += 1;
+
+          }  else  {
+            fprintf (stderr, "romparse: line %d: Max number (%d) of layout specification exceeded\n", line, MAX_LAYOUT_FILES);
+          }
+        }  else
           fprintf (stderr, "romparse: Number of layout sections exceeded (max = %d)\n", MAX_LAYOUTS);
 
     }
@@ -639,7 +671,7 @@ void createOutput (void)
 {
   FILE *str;
   int   totalLenBytes;
-  int   i, j;
+  int   i, j, k;
   int   nTables, len;
   unsigned int value, v1, v2;
   unsigned int base, obase;
@@ -664,6 +696,25 @@ void createOutput (void)
     base = base + PCI_EEAI_PARAM_SIZE;
 
 
+  /* Change the layout index value for pad mapping to a true array index value.
+   * Also reflect the device address from the layout into the pad */
+  for (i = 0; i < currentLayout; i++)  {
+    
+    for (j = 0; j < layouts[i].nPlt; j++)  {
+
+      if (layouts[i].plt[j].type == PLT_PAD)  {
+
+        for (k = 0; k < currentPad; k++)  {
+
+          if (layouts[i].plt[j].index == pads[k].id)  {
+            layouts[i].plt[j].index = k;
+            pads[k].dev_addr = layouts[i].dev_addr;
+          }
+        }
+      }
+    }
+  }
+
   /* Pad, layout tables */
   for (i = 0; i < currentPL; i++)  {
 
@@ -672,7 +723,7 @@ void createOutput (void)
     if (padLayoutOrder[i].type == LAYOUT)  {
 
       /* Determine the size of the table. Four bytes for each file, plus the 4 byte header */ 
-      v1 = (layouts[j].nFiles * 4) + 4;
+      v1 = (layouts[j].nPlt * 4) + 4;
 
       v2 = (layouts[j].dev_addr << 16) + layouts[j].address;
 
@@ -771,13 +822,22 @@ void createOutput (void)
     if (v1 > 0)
       base  = imagePad (base, image, v1);
     obase = base;
-    len   = (layouts[i].nFiles * 4) + 4;
+    len   = (layouts[i].nPlt * 4) + 4;
 
     /* Write out the block size and checksum */
     base = imageWord(base, image, len << 16);
 
-    for (j = 0; j < layouts[i].nFiles; j++)
-        base = imageWord (base, image, progFile[layouts[i].file[j]].addressBytes);
+    for (j = 0; j < layouts[i].nPlt; j++)  {
+        
+        if (layouts[i].plt[j].type == PLT_FILE) 
+          base = imageWord (base, image, progFile[layouts[i].plt[j].index].addressBytes);
+        else  {
+          v1 = pads[layouts[i].plt[j].index].dev_addr;
+          v2 = pads[layouts[i].plt[j].index].address;
+          base = imageWord (base, image, (v1 << 16) + v2);
+        }
+
+    }
 
   }
                                 
index 506c0eac810e9f0fc01d7c2be7edaf0fc0af2830..1ab0c54b1ffbf388d3568203bdbf190f16d91b01 100644 (file)
@@ -52,14 +52,22 @@ typedef struct {
 } pciFile_t;
 
 
+/* Distinguish between a layout and pad */
+#define PLT_PAD     10
+#define PLT_FILE    11
+typedef struct {
+  int type;
+  int index;
+} plt_t;
+
 /* Define a layout table. A layout table is a block of data which contains the addresses
  * of data files. Each address is 32 bits, with the upper 16 bits specifying the i2c 
  * id, the lower address the byte address of the 1st block in the table */
 #define MAX_LAYOUTS         2
 #define MAX_LAYOUT_FILES    8
 typedef struct  {
-  int nFiles;                   /* Number of files in file list*/
-  int file[MAX_LAYOUT_FILES];   /* Index of each file in progFile array */
+  int nPlt;                      /* Number of elements in the plt array */
+  plt_t plt[MAX_LAYOUT_FILES];   /* Index of each file/pad in order */
   
   unsigned int address;         /* I2c data address of the table */
   unsigned int dev_addr;        /* I2c device address of the table */
@@ -74,7 +82,9 @@ typedef struct  {
 /* Pad section. The pad section creates a gap in the i2c memory map */
 #define MAX_PADS        8
 typedef struct  {
-  unsigned int address;
+  int          id;
+  unsigned int address;     /* I2C data address */
+  unsigned int dev_addr;    /* I2C device address */
   unsigned int len;
 } pad_t;
 
index 0e4ef610745e7558748ad9068ceeedfd7aa88a6b..5c7c2bd13ee28547c38442259217f73215719e39 100644 (file)
@@ -29,6 +29,7 @@ address_delay     { yylval = ADDRESS_DELAY;                      return (ADDRESS
 sw_pll                   { yylval = SWPLL;                                              return (SWPLL);                         }
 align                    { yylval = ALIGN;                                                          return (ALIGN);             }
 len                              { yylval = LENGTH;                                                     return (LENGTH);                        }
+pad_file_id       { yylval = PAD_FILE_ID;                                               return (PAD_FILE_ID);           }
 
 
 [0-9]+                  { yylval = atoi(yytext); return (VALUE);  }
@@ -36,6 +37,7 @@ len                             { yylval = LENGTH;                                                     return (LENGTH);                        }
 
 \".*\"         return (STRING);
 
+;.*\n       line++ ;
 [ \t]+         ;
 [\n]           line++ ;
 
index 9a9440ad9c0d9278e13c6b792eb7d706c9310852..dc2ca6c82a02525b58e808daf52eee0e6648467c 100644 (file)
@@ -30,6 +30,7 @@
 #define        ALIGN   280
 #define        PAD     281
 #define        LENGTH  282
+#define        PAD_FILE_ID     283
 
 #line 2 "rparse.y"
 
@@ -48,11 +49,11 @@ extern char *yytext;
 
 
 
-#define        YYFINAL         45
+#define        YYFINAL         46
 #define        YYFLAG          -32768
-#define        YYNTBASE        28
+#define        YYNTBASE        29
 
-#define YYTRANSLATE(x) ((unsigned)(x) <= 282 ? yytranslate[x] : 36)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 283 ? yytranslate[x] : 37)
 
 static const char yytranslate[] = {     0,
      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -83,25 +84,25 @@ static const char yytranslate[] = {     0,
      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
-    26,    27
+    26,    27,    28
 };
 
 #if YYDEBUG != 0
 static const short yyprhs[] = {     0,
      0,     2,     5,     7,     9,    11,    16,    20,    25,    30,
     32,    35,    39,    43,    45,    47,    49,    51,    53,    55,
-    57,    59,    61,    63,    65,    67,    69,    71,    73
+    57,    59,    61,    63,    65,    67,    69,    71,    73,    75
 };
 
-static const short yyrhs[] = {    29,
-     0,    28,    29,     0,    30,     0,    31,     0,    32,     0,
-     5,     3,    33,     4,     0,    17,     6,     8,     0,    24,
-     3,    33,     4,     0,    26,     3,    33,     4,     0,    34,
-     0,    33,    34,     0,    35,     6,     7,     0,    35,     6,
+static const short yyrhs[] = {    30,
+     0,    29,    30,     0,    31,     0,    32,     0,    33,     0,
+     5,     3,    34,     4,     0,    17,     6,     8,     0,    24,
+     3,    34,     4,     0,    26,     3,    34,     4,     0,    35,
+     0,    34,    35,     0,    36,     6,     7,     0,    36,     6,
      8,     0,     9,     0,    10,     0,    11,     0,    12,     0,
     13,     0,    14,     0,    15,     0,    16,     0,    18,     0,
     19,     0,    22,     0,    20,     0,    21,     0,    23,     0,
-    25,     0,    27,     0
+    25,     0,    27,     0,    28,     0
 };
 
 #endif
@@ -110,7 +111,7 @@ static const short yyrhs[] = {    29,
 static const short yyrline[] = { 0,
     12,    13,    16,    17,    18,    21,    23,    27,    31,    36,
     37,    40,    42,    46,    47,    48,    49,    50,    51,    52,
-    53,    54,    55,    56,    57,    58,    59,    60,    61
+    53,    54,    55,    56,    57,    58,    59,    60,    61,    62
 };
 #endif
 
@@ -121,77 +122,77 @@ static const char * const yytname[] = {   "$","error","$undefined.","LBRACE",
 "RBRACE","SECTION","EQU","VALUE","STRING","BOOT_MODE","PARAM_INDEX","OPTIONS",
 "MULTI_I2C_ID","MY_I2C_ID","CORE_FREQ_MHZ","I2C_CLK_FREQ_KHZ","EXE_FILE","PCI_PARMS",
 "NEXT_DEV_ADDR","NEXT_DEV_ADDR_EXT","ADDRESS_DELAY","SWPLL","DEV_ADDR_EXT","DEV_ADDR",
-"LAYOUT","ALIGN","PAD","LENGTH","promspec","segment","bootParams","layout","pad",
-"assigns","assign","keyword", NULL
+"LAYOUT","ALIGN","PAD","LENGTH","PAD_FILE_ID","promspec","segment","bootParams",
+"layout","pad","assigns","assign","keyword", NULL
 };
 #endif
 
 static const short yyr1[] = {     0,
-    28,    28,    29,    29,    29,    30,    30,    31,    32,    33,
-    33,    34,    34,    35,    35,    35,    35,    35,    35,    35,
-    35,    35,    35,    35,    35,    35,    35,    35,    35
+    29,    29,    30,    30,    30,    31,    31,    32,    33,    34,
+    34,    35,    35,    36,    36,    36,    36,    36,    36,    36,
+    36,    36,    36,    36,    36,    36,    36,    36,    36,    36
 };
 
 static const short yyr2[] = {     0,
      1,     2,     1,     1,     1,     4,     3,     4,     4,     1,
      2,     3,     3,     1,     1,     1,     1,     1,     1,     1,
-     1,     1,     1,     1,     1,     1,     1,     1,     1
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1
 };
 
 static const short yydefact[] = {     0,
      0,     0,     0,     0,     0,     1,     3,     4,     5,     0,
      0,     0,     0,     2,    14,    15,    16,    17,    18,    19,
     20,    21,    22,    23,    25,    26,    24,    27,    28,    29,
-     0,    10,     0,     7,     0,     0,     6,    11,     0,     8,
-     9,    12,    13,     0,     0
+    30,     0,    10,     0,     7,     0,     0,     6,    11,     0,
+     8,     9,    12,    13,     0,     0
 };
 
 static const short yydefgoto[] = {     5,
-     6,     7,     8,     9,    31,    32,    33
+     6,     7,     8,     9,    32,    33,    34
 };
 
 static const short yypact[] = {    -3,
-    -2,     7,     1,     3,     0,-32768,-32768,-32768,-32768,    77,
-     8,    77,    77,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+    -2,     7,     1,     3,     0,-32768,-32768,-32768,-32768,    78,
+     8,    78,    78,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-    18,-32768,     9,-32768,    38,    58,-32768,-32768,     2,-32768,
--32768,-32768,-32768,    19,-32768
+-32768,    18,-32768,     9,-32768,    38,    58,-32768,-32768,     2,
+-32768,-32768,-32768,-32768,    19,-32768
 };
 
 static const short yypgoto[] = {-32768,
-    13,-32768,-32768,-32768,    -1,   -28,-32768
+    13,-32768,-32768,-32768,    -1,   -29,-32768
 };
 
 
-#define        YYLAST          104
+#define        YYLAST          106
 
 
-static const short yytable[] = {    44,
-    10,     1,    38,    12,     1,    13,    38,    38,    42,    43,
-    35,    36,    11,     2,    39,    34,     2,    14,    45,     0,
-     3,    37,     4,     3,     0,     4,    15,    16,    17,    18,
+static const short yytable[] = {    45,
+    10,     1,    39,    12,     1,    13,    39,    39,    43,    44,
+    36,    37,    11,     2,    40,    35,     2,    14,    46,     0,
+     3,    38,     4,     3,     0,     4,    15,    16,    17,    18,
     19,    20,    21,    22,     0,    23,    24,    25,    26,    27,
-    28,    40,    29,     0,    30,     0,    15,    16,    17,    18,
+    28,    41,    29,     0,    30,    31,    15,    16,    17,    18,
     19,    20,    21,    22,     0,    23,    24,    25,    26,    27,
-    28,    41,    29,     0,    30,     0,    15,    16,    17,    18,
+    28,    42,    29,     0,    30,    31,    15,    16,    17,    18,
     19,    20,    21,    22,     0,    23,    24,    25,    26,    27,
-    28,     0,    29,     0,    30,    15,    16,    17,    18,    19,
-    20,    21,    22,     0,    23,    24,    25,    26,    27,    28,
-     0,    29,     0,    30
+    28,     0,    29,     0,    30,    31,    15,    16,    17,    18,
+    19,    20,    21,    22,     0,    23,    24,    25,    26,    27,
+    28,     0,    29,     0,    30,    31
 };
 
 static const short yycheck[] = {     0,
-     3,     5,    31,     3,     5,     3,    35,    36,     7,     8,
+     3,     5,    32,     3,     5,     3,    36,    37,     7,     8,
     12,    13,     6,    17,     6,     8,    17,     5,     0,    -1,
     24,     4,    26,    24,    -1,    26,     9,    10,    11,    12,
     13,    14,    15,    16,    -1,    18,    19,    20,    21,    22,
-    23,     4,    25,    -1,    27,    -1,     9,    10,    11,    12,
+    23,     4,    25,    -1,    27,    28,     9,    10,    11,    12,
+    13,    14,    15,    16,    -1,    18,    19,    20,    21,    22,
+    23,     4,    25,    -1,    27,    28,     9,    10,    11,    12,
     13,    14,    15,    16,    -1,    18,    19,    20,    21,    22,
-    23,     4,    25,    -1,    27,    -1,     9,    10,    11,    12,
+    23,    -1,    25,    -1,    27,    28,     9,    10,    11,    12,
     13,    14,    15,    16,    -1,    18,    19,    20,    21,    22,
-    23,    -1,    25,    -1,    27,     9,    10,    11,    12,    13,
-    14,    15,    16,    -1,    18,    19,    20,    21,    22,    23,
-    -1,    25,    -1,    27
+    23,    -1,    25,    -1,    27,    28
 };
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 #line 3 "bison.simple"
@@ -777,6 +778,10 @@ case 28:
     break;}
 case 29:
 #line 61 "rparse.y"
+{  yyval=yyvsp[0];  ;
+    break;}
+case 30:
+#line 62 "rparse.y"
 {  yyval=yyvsp[0];  ;
     break;}
 }
@@ -977,7 +982,7 @@ yyerrhandle:
   yystate = yyn;
   goto yynewstate;
 }
-#line 64 "rparse.y"
+#line 65 "rparse.y"
 
 
 
index 324c9b8911a49e1e0df326ba2240091934bdc6ac..28e38ffcfa88a9e48a6cc779c4d8000f34adfcef 100644 (file)
@@ -26,6 +26,7 @@
 #define        ALIGN   280
 #define        PAD     281
 #define        LENGTH  282
+#define        PAD_FILE_ID     283
 
 
 extern YYSTYPE yylval;
index bc72a7b1f9eb072f0fc6cd6d2ee4795825fe8395..df7a25c60f05ead419f4f1d79b7aee6ec2d32e6f 100644 (file)
@@ -6,7 +6,7 @@ extern char *yytext;
 %token LBRACE RBRACE SECTION EQU VALUE STRING BOOT_MODE PARAM_INDEX OPTIONS 
 %token MULTI_I2C_ID MY_I2C_ID CORE_FREQ_MHZ I2C_CLK_FREQ_KHZ 
 %token EXE_FILE PCI_PARMS NEXT_DEV_ADDR NEXT_DEV_ADDR_EXT ADDRESS_DELAY SWPLL
-%token DEV_ADDR_EXT DEV_ADDR LAYOUT ALIGN PAD LENGTH
+%token DEV_ADDR_EXT DEV_ADDR LAYOUT ALIGN PAD LENGTH PAD_FILE_ID
 %%
 
 promspec   : segment
@@ -59,6 +59,7 @@ keyword    : BOOT_MODE                     {  $$=$1;  }
                   | DEV_ADDR                    {  $$=$1;  }
                   | ALIGN                               {  $$=$1;  }
                   | LENGTH              {  $$=$1;  }
+                  | PAD_FILE_ID         {  $$=$1;  }
                   ;
 
 %%