Subversion Repositories openarty

#include "artyboard.h"

#include "zipsys.h"

void    idle_task(void) {

        while(1)

                zip_idle();

}

extern int      splash[], mug[];

#define OLED_PMODEN             0x0010001

#define OLED_PMODEN_OFF         0x0010000

#define OLED_IOPWR              OLED_PMODEN

#define OLED_VCCEN              0x0020002

#define OLED_VCC_DISABLE        0x0020000

#define OLED_RESET              0x0040000

#define OLED_RESET_CLR          0x0040004

#define OLED_PWRRESET           (OLED_PMODEN|OLED_RESET) // 5

#define OLED_FULLPOWER          (OLED_PMODEN|OLED_VCCEN|OLED_RESET_CLR) // 3->7

#define OLED_POWER_DOWN         (OLED_PMODEN_OFF|OLED_VCC_DISABLE)

#define OLED_BUSY               1

#define OLED_DISPLAYON          0x0af

#define MICROSECOND             (CLOCKFREQ_HZ/1000000)

#define OLED_DISPLAY_OFF

        const int       init_sequence[] = {

                //  Unlock commands

                0x01fd12,

                //  Display off

                0x0ae,

                //  Set remap and data format

                0x01a072,

                //  Set the start line

                0x01a100,

                //  Set the display offset

                0x01a200,

                //  Normal display mode

                0x0000a4,

                //  Set multiplex ratio

                0x01a83f,

                //  Set master configuration:

                //      Use External VCC

                0x01ad8e,

                //  Disable power save mode

                0x01b00b,

                //  Set phase length

                0x01b131,

                //  Set clock divide

                0x01b3f0,

                //  Set Second Pre-change Speed For ColorA

                0x018a64,

                //  5l) Set Set Second Pre-charge Speed of Color B

                0x018b78,

                //  5m) Set Second Pre-charge Speed of Color C

                0x018c64,

                //  5n) Set Pre-Charge Voltage

                0x01bb3a,

                //  50) Set VCOMH Deselect Level

                0x01be3e,

                //  5p) Set Master Current

                0x018706,

                //  5q) Set Contrast for Color A

                0x018191,

                //  5r) Set Contrast for Color B

                0x018250,

                //  5s) Set Contrast for Color C

                0x01837D,

                //  disable scrolling

                0x02e };

void    timer_delay(int counts) {

        // Clear the PIC.  We want to exit from here on timer counts alone

        zip->pic = CLEARPIC;

        if (counts > 10) {

                // Set our timer to count down the given number of counts

                zip->tma = counts;

                zip->pic = EINT(SYSINT_TMA);

                zip_rtu();

                zip->pic = CLEARPIC;

        } // else anything less has likely already passed

}

void oled_clear(void);

void    oled_init(void) {

        int     i;

        for(i=0; i<sizeof(init_sequence); i++) {

                while(sys->io_oled.o_ctrl & OLED_BUSY)

                        ;

                sys->io_oled.o_ctrl = init_sequence[i];

        }

        // 5u) Clear Screen

        oled_clear();

        zip->tma = (CLOCKFREQ_HZ/200);

        zip->pic = EINT(SYSINT_TMA);

        zip_rtu();

        zip->pic = CLEARPIC;

        // Turn on VCC and wait 100ms

        sys->io_oled.o_data = OLED_VCCEN;

        // Wait 100 ms

        timer_delay(CLOCKFREQ_HZ/10);

        // Send Display On command

        sys->io_oled.o_ctrl = 0xaf;

}

void    oled_clear(void) {

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

        sys->io_oled.o_a = 0x5f3f0000;

        sys->io_oled.o_ctrl = 0x40250000;

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

}

void    oled_fill(int c, int r, int w, int h, int pix) {

        int     ctrl; // We'll send this value out the control/command port

        if (c > 95) c = 95;

        if (c <  0) c =  0;

        if (r > 63) r = 63;

        if (r <  0) r =  0;

        if (w <  0) w = 0;

        if (h <  0) h = 0;

        if (c+w > 95) w = 95-c;

        if (r+h > 63) h = 63-r;

        // Enable a rectangle to fill

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

        sys->io_oled.o_ctrl = 0x12601;

        // Now, let's build the actual copy command

        ctrl = 0xa0220000 | ((c&0x07f)<<8) | (r&0x03f);

        sys->io_oled.o_a = (((c+w)&0x07f)<<24) | (((r+h)&0x03f)<<16);

        sys->io_oled.o_a|= ((pix >> 11) & 0x01f)<< 9;

        sys->io_oled.o_a|= ((pix >>  5) & 0x03f)    ;

        sys->io_oled.o_b = ((pix >> 11) & 0x01f)<<17;

        sys->io_oled.o_b|= ((pix >>  5) & 0x03f)<< 8;

        sys->io_oled.o_b|= ((pix      ) & 0x01f)<< 1;

        // Make certain we had finished with the port (should've ...)

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

        // and send our new command

        sys->io_oled.o_ctrl = ctrl;

        // To be nice to whatever routine follows, we'll wait 'til the port

        // is clear again.

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

}

void    entry(void) {

        unsigned        user_regs[16];

        for(int i=0; i<15; i++)

                user_regs[i] = 0;

        user_regs[15] = (unsigned int)idle_task;

        zip_restore_context(user_regs);

        // Clear the PIC.  We'll come back and use it later.

        zip->pic = CLEARPIC;

        if (0) { // Wait till we've had power for at least a quarter second

                int pwrcount = sys->io_pwrcount;

                do {

                        pwrcount = sys->io_pwrcount;

                } while((pwrcount>0)&&(pwrcount < CLOCKFREQ_HZ/4));

        } else {

                int pwrcount = sys->io_pwrcount;

                if ((pwrcount > 0)&&(pwrcount < CLOCKFREQ_HZ/4)) {

                        pwrcount = CLOCKFREQ_HZ/4 - pwrcount;

                        timer_delay(pwrcount);

                }

        }

        // If the OLED is already powered, such as might be the case if

        // we rebooted but the board was still hot, shut it down

        if (sys->io_oled.o_data & 0x07) {

                sys->io_oled.o_data = OLED_VCC_DISABLE;

                // Wait 100 ms

                timer_delay(CLOCKFREQ_HZ/10);

                // Shutdown the entire devices power

                sys->io_oled.o_data = OLED_POWER_DOWN;

                // Wait 100 ms

                timer_delay(CLOCKFREQ_HZ/10);

                // Now let's try to restart it

        }

        // 1. Power up the OLED by applying power to VCC

        //      This means we need to apply power to both the VCCEN line as well

        //      as the PMODEN line.  We'll also set the reset line low, so the

        //      device starts in a reset condition.

        sys->io_oled.o_data = OLED_PMODEN|OLED_RESET_CLR;

        timer_delay(4*MICROSECOND);

        sys->io_oled.o_data = OLED_RESET;

        timer_delay(4*MICROSECOND);

        // 2. Send the Display OFF command

        //      This isn't necessary, since we already pulled RESET low.

        //

        // sys->io_oled.o_ctrl = OLED_DISPLAY_OFF;

        //

        // However, we must hold the reset line low for at least 3us, as per

        // the spec.  We may also need to wait another 2us after that.  Let's

        // hold reset low for 4us here.

        timer_delay(4*MICROSECOND);

        // Clear the reset condition.

        sys->io_oled.o_data = OLED_RESET_CLR;

        // Wait another 4us.

        timer_delay(4*MICROSECOND);

        // 3. Initialize the display to the default settings

        //      This just took place during the reset cycle we just completed.

        //

        oled_init();

        // 4. Clear screen

        // sys->io_oled.o_ctrl = OLED_CLEAR_SCREEN;

        // Wait for the command to complete

        while(sys->io_oled.o_ctrl & OLED_BUSY)

                ;

        // 5. Apply power to VCCEN

        sys->io_oled.o_data = OLED_FULLPOWER;

        // 6. Delay 100ms

        timer_delay(CLOCKFREQ_HZ/10);

        while(1) {

        // 7. Send Display On command

        // sys->io_oled.o_ctrl = OLED_CLEAR_SCREEN; // ?? What command is this?

                sys->io_ledctrl = 0x0ff;

                sys->io_oled.o_ctrl = OLED_DISPLAYON;

                oled_clear();

                while(sys->io_oled.o_ctrl & OLED_BUSY)

                        ;

                sys->io_oled.o_ctrl = 0x2015005f;

                while(sys->io_oled.o_ctrl & OLED_BUSY)

                        ;

                sys->io_oled.o_ctrl = 0x2075003f;

                sys->io_ledctrl = 0x0fe;

                // Now ... finally ... we can send our image.

                for(int i=0; i<6144; i++) {

                        while(sys->io_oled.o_ctrl & OLED_BUSY)

                                ;

                        sys->io_oled.o_data = splash[i];

                }

                sys->io_ledctrl = 0x0fc;

                timer_delay(CLOCKFREQ_HZ*5);

                timer_delay(CLOCKFREQ_HZ*5);

                timer_delay(CLOCKFREQ_HZ*5);

                timer_delay(CLOCKFREQ_HZ*5);

                timer_delay(CLOCKFREQ_HZ*5);

                for(int i=0; i<6144; i++) {

                        while(sys->io_oled.o_ctrl & OLED_BUSY)

                                ;

                        sys->io_oled.o_data = mug[i];

                }

                sys->io_ledctrl = 0x0f0;

                timer_delay(CLOCKFREQ_HZ*5);

        }

        zip_halt();

}