kolibrios/programs/system/drivers/ati2d/init.c

static Bool rhdMapMMIO(RHDPtr rhdPtr)
{
     rhdPtr->MMIOMapSize = 1 << rhdPtr->memsize[RHD_MMIO_BAR];
     rhdPtr->MMIOBase = MapIoMem((void*)rhdPtr->memBase[RHD_MMIO_BAR],
                                 rhdPtr->MMIOMapSize,PG_SW+PG_NOCACHE);
     if( rhdPtr->MMIOBase==0)
        return 0;

     DBG(dbgprintf("Mapped IO at %x (size %x)\n", rhdPtr->MMIOBase, rhdPtr->MMIOMapSize));
     return 1;
}

/* Read MC register */
unsigned INMC(RHDPtr info, int addr)
{
    u32_t       data;

    if ((info->ChipFamily == CHIP_FAMILY_RS690) ||
       (info->ChipFamily == CHIP_FAMILY_RS740)) {
       OUTREG(RS690_MC_INDEX, (addr & RS690_MC_INDEX_MASK));
       data = INREG(RS690_MC_DATA);
    } else if (info->ChipFamily == CHIP_FAMILY_RS600) {
       OUTREG(RS600_MC_INDEX, (addr & RS600_MC_INDEX_MASK));
       data = INREG(RS600_MC_DATA);
    } else if (IS_AVIVO_VARIANT) {
       OUTREG(AVIVO_MC_INDEX, (addr & 0xff) | 0x7f0000);
       (void)INREG(AVIVO_MC_INDEX);
       data = INREG(AVIVO_MC_DATA);

       OUTREG(AVIVO_MC_INDEX, 0);
       (void)INREG(AVIVO_MC_INDEX);
    } else {
       OUTREG(R300_MC_IND_INDEX, addr & 0x3f);
       (void)INREG(R300_MC_IND_INDEX);
       data = INREG(R300_MC_IND_DATA);

       OUTREG(R300_MC_IND_INDEX, 0);
       (void)INREG(R300_MC_IND_INDEX);
    }

    return data;
}


#define LOC_FB 0x1
#define LOC_AGP 0x2

static void radeon_read_mc_fb_agp_location(RHDPtr info, int mask,
                                u32_t *fb_loc, u32_t *agp_loc, u32_t *agp_loc_hi)
{

    if (info->ChipFamily >= CHIP_FAMILY_RV770) {
       if (mask & LOC_FB)
	    *fb_loc = INREG(R700_MC_VM_FB_LOCATION);
	if (mask & LOC_AGP) {
	    *agp_loc = INREG(R600_MC_VM_AGP_BOT);
	    *agp_loc_hi = INREG(R600_MC_VM_AGP_TOP);
	}
    } else if (info->ChipFamily >= CHIP_FAMILY_R600) {
	if (mask & LOC_FB)
	    *fb_loc = INREG(R600_MC_VM_FB_LOCATION);
	if (mask & LOC_AGP) {
	    *agp_loc = INREG(R600_MC_VM_AGP_BOT);
	    *agp_loc_hi = INREG(R600_MC_VM_AGP_TOP);
	}
    } else if (info->ChipFamily == CHIP_FAMILY_RV515) {
	if (mask & LOC_FB)
        *fb_loc = INMC(info, RV515_MC_FB_LOCATION);
	if (mask & LOC_AGP) {
        *agp_loc = INMC(info, RV515_MC_AGP_LOCATION);
	    *agp_loc_hi = 0;
	}
    } else if (info->ChipFamily == CHIP_FAMILY_RS600) {
	if (mask & LOC_FB)
        *fb_loc = INMC(info, RS600_MC_FB_LOCATION);
	if (mask & LOC_AGP) {
	    *agp_loc = 0;//INMC(pScrn, RS600_MC_AGP_LOCATION);
	    *agp_loc_hi = 0;
	}
    } else if ((info->ChipFamily == CHIP_FAMILY_RS690) ||
	       (info->ChipFamily == CHIP_FAMILY_RS740)) {
	if (mask & LOC_FB)
        *fb_loc = INMC(info, RS690_MC_FB_LOCATION);
	if (mask & LOC_AGP) {
        *agp_loc = INMC(info, RS690_MC_AGP_LOCATION);
	    *agp_loc_hi = 0;
	}
    } else if (info->ChipFamily >= CHIP_FAMILY_R520) {
	if (mask & LOC_FB)
        *fb_loc = INMC(info, R520_MC_FB_LOCATION);
	if (mask & LOC_AGP) {
        *agp_loc = INMC(info, R520_MC_AGP_LOCATION);
	    *agp_loc_hi = 0;
	}
    } else {
	if (mask & LOC_FB)
	    *fb_loc = INREG(RADEON_MC_FB_LOCATION);
	if (mask & LOC_AGP)
	    *agp_loc = INREG(RADEON_MC_AGP_LOCATION);
    }
}

static void RADEONInitMemoryMap(RHDPtr info)
{
     u32_t       mem_size;
     u32_t       aper_size;

     radeon_read_mc_fb_agp_location(info, LOC_FB | LOC_AGP, &info->mc_fb_location,
                    &info->mc_agp_location, &info->mc_agp_location_hi);

     /* We shouldn't use info->videoRam here which might have been clipped
      * but the real video RAM instead
      */
     if (info->ChipFamily >= CHIP_FAMILY_R600){
        mem_size = INREG(R600_CONFIG_MEMSIZE);
        aper_size = INREG(R600_CONFIG_APER_SIZE);
     }
     else {
        mem_size = INREG(RADEON_CONFIG_MEMSIZE);
        aper_size = INREG(RADEON_CONFIG_APER_SIZE);
     }

     if (mem_size == 0)
        mem_size = 0x800000;

     /* Fix for RN50, M6, M7 with 8/16/32(??) MBs of VRAM -
        Novell bug 204882 + along with lots of ubuntu ones */
     if (aper_size > mem_size)
        mem_size = aper_size;


     if ( (info->ChipFamily != CHIP_FAMILY_RS600) &&
          (info->ChipFamily != CHIP_FAMILY_RS690) &&
          (info->ChipFamily != CHIP_FAMILY_RS740)) {
        if (info->IsIGP)
           info->mc_fb_location = INREG(RADEON_NB_TOM);
        else
        {
           u32_t aper0_base;

           if (info->ChipFamily >= CHIP_FAMILY_R600) {
              aper0_base = INREG(R600_CONFIG_F0_BASE);
           }
           else {
              aper0_base = INREG(RADEON_CONFIG_APER_0_BASE);
           }

         /* Recent chips have an "issue" with the memory controller, the
          * location must be aligned to the size. We just align it down,
          * too bad if we walk over the top of system memory, we don't
          * use DMA without a remapped anyway.
          * Affected chips are rv280, all r3xx, and all r4xx, but not IGP
          */
           if ( info->ChipFamily == CHIP_FAMILY_RV280 ||
                info->ChipFamily == CHIP_FAMILY_R300 ||
                info->ChipFamily == CHIP_FAMILY_R350 ||
                info->ChipFamily == CHIP_FAMILY_RV350 ||
                info->ChipFamily == CHIP_FAMILY_RV380 ||
                info->ChipFamily == CHIP_FAMILY_R420 ||
                info->ChipFamily == CHIP_FAMILY_RV410)
              aper0_base &= ~(mem_size - 1);

           if ( info->ChipFamily >= CHIP_FAMILY_R600) {
              info->mc_fb_location = (aper0_base >> 24) |
              (((aper0_base + mem_size - 1) & 0xff000000U) >> 8);
              dbgprintf("mc fb loc is %08x\n", (unsigned int)info->mc_fb_location);
           }
           else {
              info->mc_fb_location = (aper0_base >> 16) |
              ((aper0_base + mem_size - 1) & 0xffff0000U);
           }
        }
     }
     if (info->ChipFamily >= CHIP_FAMILY_R600) {
        info->fbLocation = (info->mc_fb_location & 0xffff) << 24;
     }
     else {
        info->fbLocation = (info->mc_fb_location & 0xffff) << 16;
     }
     /* Just disable the damn AGP apertures for now, it may be
      * re-enabled later by the DRM
      */

     if (IS_AVIVO_VARIANT) {
        if (info->ChipFamily >= CHIP_FAMILY_R600) {
           OUTREG(R600_HDP_NONSURFACE_BASE, (info->mc_fb_location << 16) & 0xff0000);
     }
     else {
        OUTREG(AVIVO_HDP_FB_LOCATION, info->mc_fb_location);
     }
         info->mc_agp_location = 0x003f0000;
     }
     else
         info->mc_agp_location = 0xffffffc0;

      dbgprintf("RADEONInitMemoryMap() : \n");
      dbgprintf("  mem_size         : 0x%08x\n", (unsigned)mem_size);
      dbgprintf("  MC_FB_LOCATION   : 0x%08x\n", (unsigned)info->mc_fb_location);
      dbgprintf("  MC_AGP_LOCATION  : 0x%08x\n", (unsigned)info->mc_agp_location);
}

static void RADEONGetVRamType(RHDPtr info)
{
     u32_t tmp;

     if (info->IsIGP || (info->ChipFamily >= CHIP_FAMILY_R300))
        info->IsDDR = TRUE;
     else if (INREG(RADEON_MEM_SDRAM_MODE_REG) & RADEON_MEM_CFG_TYPE_DDR)
        info->IsDDR = TRUE;
     else
        info->IsDDR = FALSE;

     if ( (info->ChipFamily >= CHIP_FAMILY_R600) &&
          (info->ChipFamily <= CHIP_FAMILY_RV635))
     {
        int chansize;
        /* r6xx */
        tmp = INREG(R600_RAMCFG);
        if (tmp & R600_CHANSIZE_OVERRIDE)
            chansize = 16;
        else if (tmp & R600_CHANSIZE)
            chansize = 64;
        else
            chansize = 32;
        if (info->ChipFamily == CHIP_FAMILY_R600)
            info->RamWidth = 8 * chansize;
        else if (info->ChipFamily == CHIP_FAMILY_RV670)
            info->RamWidth = 4 * chansize;
        else if ((info->ChipFamily == CHIP_FAMILY_RV610) ||
             (info->ChipFamily == CHIP_FAMILY_RV620))
            info->RamWidth = chansize;
        else if ((info->ChipFamily == CHIP_FAMILY_RV630) ||
             (info->ChipFamily == CHIP_FAMILY_RV635))
            info->RamWidth = 2 * chansize;
     }
     else if (info->ChipFamily == CHIP_FAMILY_RV515) {
     /* rv515/rv550 */
        tmp = INMC(info, RV515_MC_CNTL);
        tmp &= RV515_MEM_NUM_CHANNELS_MASK;
        switch (tmp) {
           case 0: info->RamWidth = 64; break;
           case 1: info->RamWidth = 128; break;
           default: info->RamWidth = 128; break;
        }
     }
     else if ((info->ChipFamily >= CHIP_FAMILY_R520) &&
              (info->ChipFamily <= CHIP_FAMILY_RV570)){
     /* r520/rv530/rv560/rv570/r580 */
        tmp = INMC(info, R520_MC_CNTL0);
        switch ((tmp & R520_MEM_NUM_CHANNELS_MASK) >> R520_MEM_NUM_CHANNELS_SHIFT) {
           case 0: info->RamWidth = 32; break;
           case 1: info->RamWidth = 64; break;
           case 2: info->RamWidth = 128; break;
           case 3: info->RamWidth = 256; break;
           default: info->RamWidth = 64; break;
        }
        if (tmp & R520_MC_CHANNEL_SIZE) {
           info->RamWidth *= 2;
        }
     }
     else if ((info->ChipFamily >= CHIP_FAMILY_R300) &&
              (info->ChipFamily <= CHIP_FAMILY_RV410)) {
     /* r3xx, r4xx */
        tmp = INREG(RADEON_MEM_CNTL);
        tmp &= R300_MEM_NUM_CHANNELS_MASK;
        switch (tmp) {
           case 0: info->RamWidth = 64; break;
           case 1: info->RamWidth = 128; break;
           case 2: info->RamWidth = 256; break;
           default: info->RamWidth = 128; break;
        }
     }
     else if ((info->ChipFamily == CHIP_FAMILY_RV100) ||
              (info->ChipFamily == CHIP_FAMILY_RS100) ||
              (info->ChipFamily == CHIP_FAMILY_RS200)){
     tmp = INREG(RADEON_MEM_CNTL);
     if (tmp & RV100_HALF_MODE)
        info->RamWidth = 32;
     else
        info->RamWidth = 64;

///    if (!info->HasCRTC2) {
///        info->RamWidth /= 4;
///        info->IsDDR = TRUE;
///    }
     }
     else if (info->ChipFamily <= CHIP_FAMILY_RV280) {
        tmp = INREG(RADEON_MEM_CNTL);
     if (tmp & RADEON_MEM_NUM_CHANNELS_MASK)
        info->RamWidth = 128;
     else
        info->RamWidth = 64;
     } else {
     /* newer IGPs */
        info->RamWidth = 128;
     }

     /* This may not be correct, as some cards can have half of channel disabled
      * ToDo: identify these cases
      */
}

/*
 * Depending on card genertation, chipset bugs, etc... the amount of vram
 * accessible to the CPU can vary. This function is our best shot at figuring
 * it out. Returns a value in KB.
 */
static u32_t RADEONGetAccessibleVRAM(RHDPtr info)
{
    u32_t       aper_size;
    unsigned char  byte;

    if (info->ChipFamily >= CHIP_FAMILY_R600)
       aper_size = INREG(R600_CONFIG_APER_SIZE) / 1024;
    else
       aper_size = INREG(RADEON_CONFIG_APER_SIZE) / 1024;


    /* Set HDP_APER_CNTL only on cards that are known not to be broken,
     * that is has the 2nd generation multifunction PCI interface
     */
    if (info->ChipFamily == CHIP_FAMILY_RV280 ||
        info->ChipFamily == CHIP_FAMILY_RV350 ||
        info->ChipFamily == CHIP_FAMILY_RV380 ||
        info->ChipFamily == CHIP_FAMILY_R420  ||
        info->ChipFamily == CHIP_FAMILY_RV410 ||
        IS_AVIVO_VARIANT) {
        MASKREG (RADEON_HOST_PATH_CNTL, RADEON_HDP_APER_CNTL,
		     ~RADEON_HDP_APER_CNTL);
        dbgprintf("Generation 2 PCI interface, using max accessible memory\n");
	    return aper_size * 2;
    }

    /* Older cards have all sorts of funny issues to deal with. First
     * check if it's a multifunction card by reading the PCI config
     * header type... Limit those to one aperture size
     */
//    PCI_READ_BYTE(info->PciInfo, &byte, 0xe);
//    if (byte & 0x80) {
//    xf86DrvMsg(pScrn->scrnIndex, X_INFO,
//           "Generation 1 PCI interface in multifunction mode"
//           ", accessible memory limited to one aperture\n");
//    return aper_size;
//    }

    /* Single function older card. We read HDP_APER_CNTL to see how the BIOS
     * have set it up. We don't write this as it's broken on some ASICs but
     * we expect the BIOS to have done the right thing (might be too optimistic...)
     */
//    if (INREG(RADEON_HOST_PATH_CNTL) & RADEON_HDP_APER_CNTL)
//        return aper_size * 2;

    return aper_size;
}


static Bool RADEONPreInitVRAM(RHDPtr info)
{
     u32_t accessible, bar_size;

     if ((!IS_AVIVO_VARIANT) && info->IsIGP)
     {
        u32_t tom = INREG(RADEON_NB_TOM);

        info->videoRam = (((tom >> 16) -
                 (tom & 0xffff) + 1) << 6);

        OUTREG(RADEON_CONFIG_MEMSIZE, info->videoRam * 1024);
     }
     else
     {
        if (info->ChipFamily >= CHIP_FAMILY_R600)
           info->videoRam = INREG(R600_CONFIG_MEMSIZE) / 1024;
        else
        {
         /* Read VRAM size from card */
           info->videoRam      = INREG(RADEON_CONFIG_MEMSIZE) / 1024;

         /* Some production boards of m6 will return 0 if it's 8 MB */
           if (info->videoRam == 0)
           {
              info->videoRam = 8192;
              OUTREG(RADEON_CONFIG_MEMSIZE, 0x800000);
           }
        }
     }

     RADEONGetVRamType(info);

     /* Get accessible memory */
     accessible = RADEONGetAccessibleVRAM(info);

     /* Crop it to the size of the PCI BAR */
//     bar_size = PCI_REGION_SIZE(info->PciInfo, 0) / 1024;

     bar_size = 1 << (info->memsize[RHD_FB_BAR] - 10);

     if (bar_size == 0)
        bar_size = 0x20000;
     if (accessible > bar_size)
        accessible = bar_size;

     dbgprintf("Detected total video RAM=%dK width=%dbit,"
                "accessible=%uK (PCI BAR=%uK)\n",
                info->videoRam, info->RamWidth,
                (unsigned)accessible, (unsigned)bar_size);

     if (info->videoRam > accessible)
        info->videoRam = accessible;

     if (!IS_AVIVO_VARIANT)
        info->MemCntl            = INREG(RADEON_SDRAM_MODE_REG);
        info->BusCntl            = INREG(RADEON_BUS_CNTL);

     info->videoRam  &= ~1023;
     info->FbMapSize  = info->videoRam * 1024;

     /* if the card is PCI Express reserve the last 32k for the gart table */

//    if (info->cardType == CARD_PCIE )
      /* work out the size of pcie aperture */
//        info->FbSecureSize = RADEONDRIGetPciAperTableSize(info);
//    else
//    info->FbSecureSize = 0;

    return TRUE;
}

/*

#define RADEON_NB_TOM             0x15c

static size_t rhdGetVideoRamSize(RHDPtr rhdPtr)
{
  size_t RamSize, BARSize;

  if (rhdPtr->ChipFamily == CHIP_FAMILY_RS690)
    RamSize = (_RHDRegRead(rhdPtr, R5XX_CONFIG_MEMSIZE))>>10;
  else
    if (rhdPtr->IsIGP)
    {
      u32_t tom = _RHDRegRead(rhdPtr, RADEON_NB_TOM);
      RamSize = (((tom >> 16) - (tom & 0xffff) + 1) << 6);
      _RHDRegWrite(rhdPtr,R5XX_CONFIG_MEMSIZE, RamSize<<10);
    }
    else
    {
      if (rhdPtr->ChipFamily < CHIP_FAMILY_R600)
      {
        RamSize = (_RHDRegRead(rhdPtr, R5XX_CONFIG_MEMSIZE)) >> 10;
        if(RamSize==0) RamSize=8192;
      }
      else
        RamSize = (_RHDRegRead(rhdPtr, R6XX_CONFIG_MEMSIZE)) >> 10;
    };

  BARSize = 1 << (rhdPtr->memsize[RHD_FB_BAR] - 10);
  if(BARSize==0)
    BARSize = 0x20000;

  if (RamSize > BARSize) {
    DBG(dbgprintf("The detected amount of videoram"
           " exceeds the PCI BAR aperture.\n"));
    DBG(dbgprintf("Using only %dkB of the total "
           "%dkB.\n", (int) BARSize, (int) RamSize));
    return BARSize;
  }
  else return RamSize;
}
*/

#if 0
static Bool
rhdMapFB(RHDPtr rhdPtr)
{
  rhdPtr->FbMapSize = 1 << rhdPtr->memsize[RHD_FB_BAR];
  rhdPtr->PhisBase = rhdPtr->memBase[RHD_FB_BAR];

 // rhdPtr->FbBase = MapIoMem(rhdPtr->PhisBase, rhdPtr->FbMapSize,PG_SW+PG_NOCACHE);

 //  if (!rhdPtr->FbBase)
 //   return FALSE;

    /* These devices have an internal address reference, which some other
     * address registers in there also use. This can be different from the
     * address in the BAR */
  if (rhdPtr->ChipFamily < CHIP_FAMILY_R600)
    rhdPtr->FbIntAddress = _RHDRegRead(rhdPtr, HDP_FB_LOCATION)<< 16;
  else
    rhdPtr->FbIntAddress = _RHDRegRead(rhdPtr, R6XX_CONFIG_FB_BASE);

//    rhdPtr->FbIntAddress = _RHDRegRead(rhdPtr, 0x6110);
//    dbgprintf("rhdPtr->FbIntAddress %x\n",rhdPtr->FbIntAddress);

  if (rhdPtr->FbIntAddress != rhdPtr->PhisBase)
    dbgprintf("PCI FB Address (BAR) is at "
              "0x%08X while card Internal Address is 0x%08X\n",
              (unsigned int) rhdPtr->PhisBase,rhdPtr->FbIntAddress);
 // dbgprintf("Mapped FB at %p (size 0x%08X)\n",rhdPtr->FbBase, rhdPtr->FbMapSize);
  return TRUE;
}
#endif

static Bool RADEONPreInitChipType(RHDPtr rhdPtr)
{
     u32_t cmd_stat;

     rhdPtr->ChipErrata = 0;

     if ( (rhdPtr->ChipFamily == CHIP_FAMILY_R300) &&
          ((_RHDRegRead(rhdPtr,RADEON_CONFIG_CNTL) & RADEON_CFG_ATI_REV_ID_MASK)
           == RADEON_CFG_ATI_REV_A11))
        rhdPtr->ChipErrata |= CHIP_ERRATA_R300_CG;

     if ( (rhdPtr->ChipFamily == CHIP_FAMILY_RV200) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS200) )
        rhdPtr->ChipErrata |= CHIP_ERRATA_PLL_DUMMYREADS;

     if ( (rhdPtr->ChipFamily == CHIP_FAMILY_RV100) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS100) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS200) )
        rhdPtr->ChipErrata |= CHIP_ERRATA_PLL_DELAY;

     rhdPtr->cardType = CARD_PCI;


     cmd_stat = pciReadLong(rhdPtr->PciTag, PCI_CMD_STAT_REG);

     if (cmd_stat & RADEON_CAP_LIST)
     {
        u32_t cap_ptr, cap_id;

        cap_ptr = pciReadLong(rhdPtr->PciTag, RADEON_CAPABILITIES_PTR_PCI_CONFIG);
        cap_ptr &= RADEON_CAP_PTR_MASK;

        while(cap_ptr != RADEON_CAP_ID_NULL)
        {
           cap_id = pciReadLong(rhdPtr->PciTag, cap_ptr);
           if ((cap_id & 0xff)== RADEON_CAP_ID_AGP) {
              rhdPtr->cardType = CARD_AGP;
              break;
           }
           if ((cap_id & 0xff)== RADEON_CAP_ID_EXP) {
              rhdPtr->cardType = CARD_PCIE;
              break;
           }
           cap_ptr = (cap_id >> 8) & RADEON_CAP_PTR_MASK;
        }
     }

     dbgprintf("%s card detected\n",(rhdPtr->cardType==CARD_PCI) ? "PCI" :
               (rhdPtr->cardType==CARD_PCIE) ? "PCIE" : "AGP");

    /* treat PCIE IGP cards as PCI  */
     if (rhdPtr->cardType == CARD_PCIE && rhdPtr->IsIGP)
         rhdPtr->cardType = CARD_PCI;

     if ( (rhdPtr->ChipFamily == CHIP_FAMILY_RS100) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS200) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS300) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS400) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS480) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS600) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS690) ||
          (rhdPtr->ChipFamily == CHIP_FAMILY_RS740))
        rhdPtr->has_tcl = FALSE;
     else {
        rhdPtr->has_tcl = TRUE;
     }

     rhdPtr->LinearAddr = rhdPtr->memBase[RHD_FB_BAR];

     return TRUE;
}

Bool RHDPreInit()
{
    /* We need access to IO space already */
     if ( !rhdMapMMIO(&rhd) ) {
        dbgprintf("Failed to map MMIO.\n");
        return FALSE;
     };


     if( !RADEONPreInitChipType(&rhd))
        return FALSE;

     if (!RADEONPreInitVRAM(&rhd))
        return FALSE;

     RADEONInitMemoryMap(&rhd);

     if (!rhd.videoRam)
     {
        dbgprintf("No Video RAM detected.\n");
        goto error1;
     }
     dbgprintf("VideoRAM: %d kByte\n",rhd.videoRam);

     rhd.FbFreeStart = 0;
     rhd.FbFreeSize = rhd.videoRam << 10;

 // if( !rhdMapFB(&rhd))
//    return FALSE;

//  rhd.FbScanoutStart = 0;
//  rhd.FbScanoutSize  = 8*1024*1024;

  rhd.FbFreeStart    = 10*1024*1024;
  rhd.FbFreeSize     = rhd.FbMapSize - rhd.FbFreeStart;

  rhdInitHeap(&rhd);
  return TRUE;

error1:
  return FALSE;
};