PIC32MK EEPROM write operation

EEADDR = ee_addr<<2;
&~3 would make more sense
I would assume you are trying to align on 32bits

I'm not assuming that's the whole problem, I'm just pointing out you are probably setting EEADDR to something you do not want as you are multiplying the incoming address by 4. Either you do want to multiply by 4 for some reason, or you more than likely intended to align on 32bits but used the wrong method to do it. One or the other, with completely different results. Which is it?
 
step 2.
 
EEKEY = 0xED87; // Write unlock sequence
should be 0xEDB7 ?
 
datasheet register description shows EDB7
example code shows ED87- http://ww1.microchip.com/...eviceDoc/60001326A.pdf
(and it looks like you are somewhat following the example, which is why its a little strange you were using ee_addr<<2 - if you use the examples, why not copy verbatim?)

which makes more sense for unlock keys?
EDB7 = 1110 1101 1011 0111
1248 = 0001 0010 0100 1000

ED87 = 1110 1101 1000 0111
1248 = 0001 0010 0100 1000

my money is on EDB7 (example code writers didn't have their glasses on it seems)

After looking at the forums for a while I figured out why everyone is having problems with the EEPROM module. The first issue is the correct key values are 0xEDB7 and 0x1248. Not 0xED87 like in several examples. The second issue is ECONbits.RW = 1; does not work. You must use EECONSET = _EECON_RW_MASK;
 
 
 

#define EEKEY1 0xEDB7
#define EEKEY2 0x1248

void EEInitialize(void) // Basic EEPROM enable and initialization
{ 
    __builtin_disable_interrupts();
    
    CFGCON2bits.EEWS = 7;// 8 = for system clocks < 75MHz 
    
    EECONbits.ON = 1;

    while (EECONbits.RDY == 0);// Wait until EEPROM is ready (~125 us)

    EECONbits.WREN = 1;// Enable writing to the EEPROM
    EECONbits.CMD = 0b100;// Set the command to Configuration Write

    EEADDR = 0x00;// Addr 0x00 = DEVEE1;
    EEDATA = DEVEE0;
    EEKEY = EEKEY1; // Unlock the EEPROM to enable writing
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK;
    while (EECONbits.RW); // desired

    EEADDR = 0x04;// Addr 0x04 = DEVEE2;
    EEDATA = DEVEE1;
    EEKEY = EEKEY1; // Unlock the EEPROM to enable writing
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK;
    while (EECONbits.RW); // desired

    EEADDR = 0x08;// Addr 0x08 = DEVEE3;
    EEDATA = DEVEE2;
    EEKEY = EEKEY1; // Unlock the EEPROM to enable writing
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK;
    while (EECONbits.RW); // desired

    EEADDR = 0x0C;// Addr 0x08 = DEVEE3;
    EEDATA = DEVEE3;
    EEKEY = EEKEY1; // Unlock the EEPROM to enable writing
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK;
    while (EECONbits.RW); // desired

    EECONbits.WREN = 0; // Turn off writes.
    
    __builtin_enable_interrupts();
    
}

uint32_t data_EEPROM_read(uint32_t ee_addr)
{
    uint32_t Data;
    
    EEADDR = ee_addr & 0xFFC; // Set address on 32-bit boundary
    EECONbits.CMD = 0; // Load CMD<2:0> with
    // Data EEPROM read command
    EECONbits.WREN = 0; // Access for read

    __builtin_disable_interrupts();
    EEKEY = EEKEY1; // Write unlock sequence
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK; // Start the operation 
    __builtin_enable_interrupts();

    while (EECONbits.RW==1); // Wait until read is complete
    Data = EEDATA; // Read the data
    
    return Data;
}


void data_EEPROM_write(uint32_t ee_addr, uint32_t ee_data)
{
    EECONbits.CMD = 1; // Load CMD<2:0> with write command
    EECONbits.WREN = 1; // Access for write

    EEADDR = ee_addr & 0xFFC; // Load address on a 32-bit boundary
    EEDATA = ee_data;

    __builtin_disable_interrupts();
    EEKEY = EEKEY1; // Write unlock sequence
    EEKEY = EEKEY2;
    EECONSET = _EECON_RW_MASK; 
    __builtin_enable_interrupts();

    while (EECONbits.RW == 1);
}

 
I'm still trying to get the interrupt to work since it is not documented anywhere and even when I clear the flag it is still set and triggering the interrupt.