Subversion Repositories Kolibri OS

{

    local_pixmap_t *pixmap;

    size_t size;

    addr_t  mem_dma   = 0;

    void   *mapped;

        (io->height == 0)|| (io->height > 2048))

    {

        dbgprintf("Invalid pixmap size w:%d h:%d\n", io->width,io->height);

        return ERR_PARAM;

    };

        return ERR_PARAM;

    size = pitch*io->height;

        mem_local = rhd_mem_alloc(&rhd,RHD_MEM_FB,size);

        mem_dma = mem_local + rhd.fbLocation;

    }

    else

        mem_local = mem_dma = AllocPages( size >> 12 );

        dbgprintf("Not enough memory for pixmap\n");

        free(pixmap);

        return ERR_PARAM;

    };

    pixmap->local   = mem_dma;

    {

        CommitPages(mapped, mem_dma|7|(1<<9), size);

        io->pitch   = pitch;

        io->handle  = (u32_t)pixmap;

        pixmap->height  = io->height;

        pixmap->format  = PICT_a8r8g8b8;

        pixmap->flags   = io->flags;

        pixmap->pitch   = pitch;

        pixmap->mapped  = mapped;

        dbgprintf("width: %d height: %d\n",pixmap->width,pixmap->height );

        dbgprintf("map at %x\n", pixmap->mapped);

    };

    rhd_mem_free(&rhd, RHD_MEM_FB, mem_local);

    free(pixmap);

};

{

    local_pixmap_t *pixmap;

    size_t size;

        return ERR_PARAM;

    else

        pixmap = (local_pixmap_t*)io->handle;

    UserFree(pixmap->mapped);

    {

        rhd_mem_free(&rhd,RHD_MEM_FB,pixmap->local-rhd.fbLocation);

    }

    else

    {

        count_t pages = size >> 12;

        addr_t  base  = pixmap->local;

        {

            addr_t tmp;

 //           __asm__ __volatile__(

//            "call *__imp__PageFree"

//            :"=eax" (tmp):"a" (base) );

//            base+= 4096;

        };

    }

    io->pitch   = 0;

    io->mapped  = NULL;

    io->handle  = 0;

};

# define ATI_PCIGART_PAGE_MASK		(~(ATI_PCIGART_PAGE_SIZE-1))

#define ATI_PCIE_READ   0x8

{

    addr_t page_base;

    {

        page_base = base & ATI_PCIGART_PAGE_MASK;

        page_base |= (upper_32_bits(base) & 0xff) << 24;

        page_base |= ATI_PCIE_READ | ATI_PCIE_WRITE;

        base+= 4096;

        gart++;

    }

    __asm__ __volatile("sfence":::"memory");

                      RADEON_PCIE_TX_GART_EN

                     | RADEON_PCIE_TX_GART_INVALIDATE_TLB);

}

{

    u32_t tmp;

    OUTREG(RADEON_AIC_CNTL, tmp & ~RADEON_PCIGART_TRANSLATE_EN);

    {

        *gart = base & ATI_PCIGART_PAGE_MASK;

         base+= 4096;

         gart++;

    }

    __asm__ __volatile("sfence":::"memory");

    OUTREG(RADEON_AIC_PT_BASE, rhd.gart_table_dma);

}

{

    u32_t   *gart = rhd.gart_table;

    count_t  pages = ((pixmap->height * pixmap->pitch+4095)&~4095)>>12;

    addr_t   base = pixmap->local;

        bind_pcie(gart, base, pages);

    else

        bind_pci(gart, base, pages);

}

{

   pixmap_t *pixmap;

   size_t    size;

   void     *usermap;

     return ERR_PARAM;

   else

     pixmap = io->pixmap;

     return ERR_PARAM;

   if (usermap = UserAlloc(size))

   {

     CommitPages(usermap, ((u32_t)pixmap->raw+rhd.PhisBase)|7|(1<<9), size);

     pixmap->flags |= PX_LOCK;

     pixmap->usermap = usermap;

     io->usermap = usermap;

     io->pitch   = pixmap->pitch;

     dbgprintf("map at %x\n", io->usermap);

   }

   else

     return ERR_PARAM;

};

{

  pixmap_t *pixmap;

  size_t    size;

    return ERR_PARAM;

  else

    pixmap = io->pixmap;

    return ERR_PARAM;

      ((u32_t)pixmap->usermap >= 0x80000000) ||

      ((u32_t)pixmap->usermap & 4095)

    )

    return ERR_PARAM;

  UserFree(pixmap->usermap);

  pixmap->usermap =  NULL;

  pixmap->flags  &= ~PX_LOCK;

  io->usermap     =  NULL;

  io->pitch       =  0;

};