Re: [LinuxBIOS] CAR for Geode GX1 / GX2

[Juergen Beisert]

Hi Peter,

On Monday 07 May 2007 15:41, Peter Stuge wrote:
> On Mon, May 07, 2007 at 09:43:06AM +0200, Juergen Beisert wrote:
> > I could provide some code to map the Geode GX1 cache anywhere you
> > like. It simply uses the tr3, tr4 and tr5 registers to map each
> > cache line to a physical address. I'm currently using it to map the
> > scratch pad RAM to enable and use the video acceleration. Its
> > written in C, but its very easy to rewrite it in assembler.
> > Maybe it achieves LinuxBIOS's requirements, but I'm not sure.
>
> I would love to see the code.
>
> If we can keep it in C that's a lot better than rewriting it in
> assembly, too!

Hmmm, I think we must rewrite it in Assembler as I think it should
prepare some RAM to be used to setup the SDRAM in C. Or am I wrong?

Here is the code. Runs on my Geode GX1 based system to map a part of
the cache to a specific address. It maps always the set 0 of the cache
due to this part can be used as Scratch Pad RAM. But it should be not
a big problem to expand it, to map all sets of the cache (16 kiB in
this case).

/* ---------------------------------------------------------- */

static inline void write_tr3(u32 tr3)
{
    asm volatile ("movl %0, %%tr3" : : "r" (tr3));
}

static inline void write_tr4(u32 tr4)
{
    asm volatile ("movl %0, %%tr4" : : "r" (tr4));
}

static inline void write_tr5(u32 tr5)
{
    asm volatile ("movl %0, %%tr5" : : "r" (tr5));
}

#define invalidate_cache() __asm__ __volatile__ ("invd": : :"memory")

/*
 * Disable and write back the cache
 *
 * Call this function with interrupts disabled!
 */
static void disable_cache(void)
{
    unsigned long cr0;

wbinvd();
    cr0 = read_cr0();
    cr0 |= 0x40000000;
    write_cr0(cr0);
    wbinvd();
}

/*
 * Enable the cache
 *
 * Call this function with interrupts disabled!
 */
static void enable_cache(void)
{
    unsigned long cr0;

cr0 = read_cr0();
    cr0 &= 0x9fffffff;
    write_cr0(cr0);
}

/*
 * write 16 bytes into cache' fill buffer
 *
 * This data will be cacheline's content after mapping
 */
static void setup_fill_buffer(u32 value)
{
    write_tr5(0x0);
    write_tr3(value);
    write_tr5(0x4);
    write_tr3(value);
    write_tr5(0x8);
    write_tr3(value);
    write_tr5(0xc);
    write_tr3(value);
}

/*
 * map_cache_line - map a cachline of set 0 to a specific address
 * @mapping_address: physical address to map this line to
 *
 * Always set 0 will be mapped due to this set is used
 * as a scratch pad ram only
 *
 * Note: Call this function only when cache is disabled
 */
static void map_cache_line(u32 mapping_address)
{
    write_tr4((mapping_address & 0xFFFFF000) | 0x400);
    write_tr5((mapping_address & 0xFF0) | 0x00 << 2 | 0x1);
}

/*
 * init_scratch_pad_size
 * @info hardware info
 * @size: new size of the scratch pad ram
 *
 * Note: Called with size = 0 will disable the scratch pad ram.
 */
static int geode_gx1_init_scratch_pad_size(struct geode_gx1_info * info,u32 size)
{
    int i;
    u32 base;
    unsigned long flags;

if (size > 4096)
    	return -1;

if ((size != 0) && (size < 2048))
    	return -1;

if (size < 3072)
    	size=2048;
    else if (size < 4096)
    	size=3072;
    /*
     * The mapping uses always the base
     * address of the internal chipset
     * registers
     */
    info->scratch_pad_phys = info->physical_base;
    base = info->physical_base+(4096-size);

spin_lock_irqsave(&geode_gx1_memory_lock, flags);
    /*
     * first disable and invalidate the remaining cache
     */
    disable_cache();
    invalidate_cache();
    /*
     * now free the _whole_ RAM for cache and invalidate
     * it again to unmap currently used scratch pad ram
     */
    set_scratch_pad_size(info,0);
    invalidate_cache();
    /*
     * remap the cache lines again
     */
    for (i=0; i<size; i+=16,base+=16) {
    	setup_fill_buffer(0xdeadbeef);
    	map_cache_line(base);
    }
    /*
     * freeze the mapped cache lines
     */
    set_scratch_pad_size(info,size);
    /*
     * and again use the remaining
     * cache lines as usual
     */
    enable_cache();

spin_unlock_irqrestore(&geode_gx1_memory_lock, flags);

return 0;
}

/* ---------------------------------------------------------- */

setup_fill_buffer() and map_cache_line() are the most important functions
and map_cache_line() must be extended to also support the other three cache
sets -> ...| 0x00 << 2 |... stands for set 0, ...| 0x01 << 2 |... would be
set 1 and so on.

The functions above do their work in my LinuxBIOS based Geode GX1 system,
with a special Xorg driver and graphics acceleration.

Hope it helps,

Juergen