LPC2129 CAN Register initialization

Anybody familiar with CAN;please do give some inputs...

I have worked a lot with CAN on the 2129. I do believe that they have some RX vec interrupt problems. Check your registers first to see if you are getting an overrun error. I was never able to solve this problem and just went to a pulled interrupt because it was acceptable for the project.
The CAN example in the LCP2000 forum group is good code to use, but it needs a few fixes on the init to update it.

here is an snippet of acceptance filter set up:

/**************************************************************************
Setting a CAN receive filter
as described in LPC_FullCAN_SW.h
***************************************************************************/
short FullCAN_SetFilter (
  unsigned short can_port, // CAN interface number
  unsigned int CANID // 11-bit CAN ID
  )
{
unsigned int p, n;
unsigned int buf0, buf1;
unsigned int ID_lower, ID_upper;
unsigned int candata;
unsigned int *pAddr;

  // Double check can_port value
  if ((can_port < 1) || (can_port > MAX_CANPORTS))
  { // Illegal value for can_port
    return 0;
  }

can_port = can_port - 1;

  // Acceptance Filter Mode Register = off !
  AFMR = 0x00000001L;

  if (gCANFilter == 0)
  { // First call, init entry zero
    gFullCANList[0].Dat1 = 0x000037FFL; // CAN 1, disabled and unused
  }
  if (gCANFilter >= MAX_FILTERS)
  {
    return 0;
  }

  CANID &= 0x000007FFL; // Mask out 11-bit ID
  CANID |= (can_port << 13); // Put can_port info in bits 13-15

  // Filters must be sorted by interface, then by priority
  // new filter is sorted into array
  p = 0;
  while (p < gCANFilter) // loop through all existing filters
  {
    if ((gFullCANList[p].Dat1 & 0x0000FFFFL) > CANID)
    {
      break;
    }
    p++;
  }

  // insert new filter here
  buf0 = gFullCANList[p].Dat1; // save current entry
  gFullCANList[p].Dat1 = CANID; // insert the new entry

  // move all remaining entries one row up
  gCANFilter++;
  while (p < gCANFilter)
  {
    p++;
    buf1 = gFullCANList[p].Dat1;
    gFullCANList[p].Dat1 = buf0;
    buf0 = buf1;
  }

  // Now work on Acceptance Filter Configuration
  // Set CAN filter for 11-bit standard identifiers
  p = 0;

  // Set pointer for Standard Frame Individual
  // Standard Frame Explicit
  SFF_sa = p;

  pAddr = (unsigned int *) ACCEPTANCE_FILTER_RAM_BASE;
  for (n = 0; n < ((gCANFilter+1)/2); n++)
  {
    ID_lower = gFullCANList[n * 2].Dat1 & 0x0000FFFFL;
    ID_upper = gFullCANList[n * 2 + 1].Dat1 & 0x0000FFFFL;
    candata = (ID_lower << 16) + ID_upper;
    *pAddr = candata;
    p += 4;
    pAddr++;
  }

  // p is still pointing to ENDofTable;

  // Set pointer for Standard Frame Groups
  // Standard Frame Group Start Address Register
  SFF_GRP_sa = p;

  // Set pointer for Extended Frame Individual
  // Extended Frame Start Address Register
  EFF_sa = p;

  // Set pointer for Extended Frame Groups
  // Extended Frame Group Start Address Register
  EFF_GRP_sa = p;

  // Set ENDofTable
  // End of AF Tables Register
  ENDofTable = p;

  // Acceptance Filter Mode Register, start using filter
  AFMR = 0;

  return 1;
}

Finally, i got it. They are supposed to hold offset values relative to the table start address.
This app note is great!
www.nxp.com/.../AN10674_1.pdf

An excerpt:

Each of the pointers is used to define the start of a section. They are relative (offset)pointers
to the starting address of the Filter Table. When a section is not defined, the register should be
set to the current free entry in the Filter Table. It is assumed that for the FULLCAN message ID
section the starting address (offset) is always 0.

Thank you guys for the inputs.