// *******************************

// FILE: raspberrylib.c

// AUTHOR: SharpCoder

// DATE: 2012-03-18

// ABOUT: This is the heart of my C++ library for

// low-level raspberry pi interfacing.

// It will grow over time as I learn more about

// the architecture.

//

// LICENSE: Provided "AS IS". USE AT YOUR OWN RISK.

// *******************************

#include "raspberrylib.h"

#include "common.h"

namespace RaspberryLib {

volatile uint32 GET32( uint32 addr ) {

// Create a pointer to our location in memory.

volatile uint32* ptr = (volatile uint32*)( addr );

// Return the value.

return (uint32)(*ptr);

}

volatile void PUT32( uint32 addr, uint32 value ) {

// Create a pointer to our location in memory.

volatile uint32* ptr = (volatile uint32*)( addr );

// Set the value.

*ptr = value;

}

volatile char GET4( uint32 addr ) {

// Create a pointer to our location in memory.

volatile char* ptr = (volatile char*)( addr );

// Return the value.

return (char)(*ptr);

}

volatile void PUT4( uint32 addr, char value ) {

// Create a pointer to our location in memory.

volatile char* ptr = (volatile char*)( addr );

// Set the value.

*ptr = value;

}

void SetGPIO( uint32 pin, uint32 state ) {

// Setup some initial things.

uint32 bytes = 0, value = ( state == 1 ) ? 0x28 : 0x1C;

// Calculate the byte shift variables.

while( pin > 10 ) {

pin -= 10;

bytes++;

}

// Add 4 to bytes.

bytes *= 4;

// Set the proper locations in memory.

PUT32( ARM_GPIO_BASE_ADDR + bytes, (uint32)1 << (pin * 3) );

PUT32( ARM_GPIO_BASE_ADDR + value, (uint32)1 << (bytes * 4) );

}

uint32 CheckCounter( void ) {

return GET32( ARM_COUNTER_ADDR );

}

// This method will wait 'time' in 'ticks'

// (or cycles) instead of nanoseconds.

void WaitQuick( uint32 time ) {

uint32 ticks = CheckCounter();

uint32 target = ticks + time;

while(CheckCounter() < target ) { /* Do nothing... */ }

}

void Wait( uint32 time ) {

// Read the current time from

uint32 ticks = CheckCounter();

// Calculate how long to wait.

uint32 target = ticks + ( time * 800 );

// Loop until then.

while ( CheckCounter() < target ) {

/* Do Nothing */

}

}

void Blink( uint32 count, uint32 time ) {

// Loop 'count' times.

for( ; count > 0; count-- ) {

// Turn on the light.

SetGPIO( 16, true );

// Wait

Wait( time );

// Turn the light off.

SetGPIO( 16, false );

// Wait

Wait( time );

}

}

void PiFault( const char* msg ) {

// This is the generic "raspberry pi is busted

// and there is no screen to write to yet"

// error function. The message variable is just

// in the hopes that I can someday write to the

// sd card. But until I get there, it won't be used.

Blink( 4, 200 );

return;

}

void MailboxWrite( char channel, uint32 data ) {

// Worf: We're ready to fire captain!

// Picard: On my mark...

while ( GET32( ARM_MAIL_BASE + ARM_MAIL_STATUS ) & MAIL_FULL ) {

/* Do Nothing. */

}

// If we made it here, beam our data aboard!

// (Note the bit math is basically stripping off the last 4 bits of

// the data and replacing it with the channel number, because that's

// how the raspberry pi rolls).

// ALSO NOTE: YOU MUST USE THE MEMORY BARRIER!

Memory::Barrier();

// Store our data in the proper register.

PUT32( ARM_MAIL_BASE + ARM_MAIL_WRITE, channel | (data & 0xFFFFFFF0) );

// This one might be optional...

Memory::Barrier();

}

uint32 MailboxCheck( char channel ) {

// Define some variables.

uint32 data = 0, count = 0;

// Worf: Sir! They're firing on us!

// Picard: Evasive maneuver alpha.

while ( true ) {

// First, loop over the status.

while ( GET32( ARM_MAIL_BASE + ARM_MAIL_STATUS ) & MAIL_EMPTY ) {

/* Do Nothing */

if ( count++ >= (1<<20) ) {

PiFault( "Error. Circular loop checking for status." );

return 0xFFFFFFFF;

}

}

// NOTE: You absolutely MUST use the memory barriers

// here!!! Without them, the evil empire will win

// a bloody victory against the federation.

Memory::Barrier();

// Read the data.

data = GET32( ARM_MAIL_BASE );

// This one MIGHT be optional. But do you really want

// the evil empire to win?

Memory::Barrier();

// Derrive the channel bit.

if ( (data & 0xF) == channel )

// If they match, then break out.

break;

}

// Return our data.

return (data & 0xFFFFFFF0);

}

GPU* AcquireFrameBuffer( uint32 xres, uint32 yres ) {

// Create a structure in memory to hold

// our request to the GPU.

// [0] = Monitor Width, [1] = Monitor Height

// [2] = Virtual Width, [3] = Virtual Height

// [4] = Pitch (set by GPU), [5] = Depth

// [6] = X Offset, [7] = Y Offset,

// [8] = Frame Buffer Pointer, [9] = Frame Buffer Size.

GPU* request = (GPU*)(KERNEL_FB_LOC);

request->screen_width = xres;

request->screen_height = yres;

request->virtual_width = xres;

request->virtual_height = yres;

request->pitch = 0;

request->depth = 24;

request->xoffset = 0;

request->yoffset = 0;

request->framePtr = 0;

request->bufferSize = 0;

request->valid = false;

// Snag the pointer value in uint32 form.

uint32 requestAddress = Memory::PHYSICAL_TO_BUS( (uint32)request );

// And then write a letter to our dearest GPU.

MailboxWrite( 1, requestAddress );

// And then read the response... Really read it.

uint32 response = 0xFF, explode = 10000;

do {

response = MailboxCheck( 1 );

} while ( response != 0 && explode-- > 0 ) ;

// Check if we've exploded.

if ( explode <= 0 ) {

PiFault( "Error! The mailbox didn't return a suitable value in a timely manner." );

return request;

}

// Check the meaning of the response.

if ( request->framePtr == 0 ) {

PiFault( "Error! The framebuffer returned is invalid. Aborting framebuffer acquisition" );

return request;

}

if ( request->pitch == 0 ) {

PiFault( "Error! The pitch returned is invalid. Aborting framebuffer acquisition." );

return request;

}

// Initialize the success variables.

request->valid = true;

request->framePtr = Memory::BUS_TO_PHYSICAL( request->framePtr );

// Return the GPU object.

return request;

}

}