The function below can be used to calculate ECC for a given 64-bit aligned address (no need to left-shift the address) and the corresponding 64-bit data.

//
//Calculate the ECC for an address/data pair
//
uint16 CalcEcc(uint32 address, uint64 data)
{
                const uint32 addrSyndrome[8] =  {0x554ea, 0x0bad1, 0x2a9b5, 0x6a78d, 
                                                 0x19f83, 0x07f80, 0x7ff80, 0x0007f};
                const uint64 dataSyndrome[8] =  {0xb4d1b4d14b2e4b2e, 0x1557155715571557,         
                                                 0xa699a699a699a699, 0x38e338e338e338e3,  
                                                 0xc0fcc0fcc0fcc0fc, 0xff00ff00ff00ff00, 
                                                 0xff0000ffff0000ff, 0x00ffff00ff0000ff};
                const uint16 parity = 0xfc;
                uint64 xorData;
                uint32 xorAddr;
                uint16 bit, eccBit, eccVal;
 
                //
                //Extract bits "20:2" of the address 
                //
                address = (address >> 2) & 0x7ffff;
                //
                //Compute the ECC one bit at a time.
                //
                eccVal = 0;
                for (bit = 0; bit < 8; bit++)
                {
                      //
                      //Apply the encoding masks to the address and data
                      //
                      xorAddr = address & addrSyndrome[bit];
                      xorData = data & dataSyndrome[bit];
                      // 
                      //Fold the masked address into a single bit for parity calculation.
                      //The result will be in the LSB.
                      //
                      xorAddr = xorAddr ^ (xorAddr >> 16);
                      xorAddr = xorAddr ^ (xorAddr >> 8);
                      xorAddr = xorAddr ^ (xorAddr >> 4);
                      xorAddr = xorAddr ^ (xorAddr >> 2);
                      xorAddr = xorAddr ^ (xorAddr >> 1);
                      // 
                      //Fold the masked data into a single bit for parity calculation.
                      //The result will be in the LSB.
                      //
                      xorData = xorData ^ (xorData >> 32);
                      xorData = xorData ^ (xorData >> 16);
                      xorData = xorData ^ (xorData >> 8);
                      xorData = xorData ^ (xorData >> 4);
                      xorData = xorData ^ (xorData >> 2);
                      xorData = xorData ^ (xorData >> 1);
                      //
                      //Merge the address and data, extract the ECC bit, and add it in
                      //
                      eccBit = ((uint16)xorData ^ (uint16)xorAddr) & 0x0001;
                      eccVal |= eccBit << bit;
                }
 
                //
                //Handle the bit parity. For odd parity, XOR the bit with 1
                //
                eccVal ^= parity;
                return eccVal;
}