lcd.c

Go to the documentation of this file.

/*
 *  The contents of this file are subject to the Mozilla Public License
 *  Version 1.0 (the "License"); you may not use this file except in
 *  compliance with the License. You may obtain a copy of the License at
 *  http://www.mozilla.org/MPL/
 *
 *  Software distributed under the License is distributed on an "AS IS"
 *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 *  License for the specific language governing rights and limitations
 *  under the License.
 *
 *  The Original Code is legOS code, released October 17, 1999.
 *
 *  The Initial Developer of the Original Code is Markus L. Noga.
 *  Portions created by Markus L. Noga are Copyright (C) 1999
 *  Markus L. Noga. All Rights Reserved.
 *
 *  Contributor(s): Markus L. Noga <markus@noga.de>
 */

#include <config.h>
#include <dlcd.h>
#include <conio.h>
#include <string.h>
#include <sys/h8.h>
#include <sys/lcd.h>
#include <rom/registers.h>
#include <lnp/sys/irq.h>

//
// Variables
//

#ifdef CONF_LCD_REFRESH
unsigned char lcd_refresh_counter;    
unsigned char lcd_byte_counter;       
unsigned char lcd_refresh_period = 2; 
#endif


static unsigned char lcd_shadow[LCD_DATA_OFFSET + LCD_DATA_SIZE];

//
// Functions
//


void lcd_number(int i,lcd_number_style n,lcd_comma_style c  );
#ifndef DOXYGEN_SHOULD_SKIP_THIS
__asm__("\n\
.text\n\
.align 1\n\
.globl _lcd_number\n\
_lcd_number:\n\
        push r6         ; save r6\n\
    \n\
        push r2         ; comma_style  -> stack\n\
        push r0         ; number       -> stack\n\
    \n\
        mov.w r1,r6     ; number_style -> r6\n\
    \n\
        jsr @lcd_number ; call ROM\n\
    \n\
        adds #0x02,sp   ; clear stack\n\
        adds #0x02,sp\n\
        \n\
        pop r6          ; restore r6\n\
        rts\n\
        \n\
       ");
#endif // DOXYGEN_SHOULD_SKIP_THIS

#define set(b)  __asm__ __volatile__("bset %0,@0xbb:8" : : "i"(b));

#define clr(b)  __asm__ __volatile__("bclr %0,@0xbb:8" : : "i"(b));


#define slowdown()

static __inline__ void i2c_start(void)
{
    set(SDA);
    set(SCL);
    slowdown();
    clr(SDA);
    slowdown();
    clr(SCL);
    slowdown();
}

static __inline__ void i2c_stop(void)
{
    clr(SDA);
    set(SCL);
    slowdown();
    set(SDA);
    slowdown();
    clr(SCL);
    slowdown();
    set(SCL);           // relax output driver (saves 0.5 mA)
}


static __inline__ void i2c_read_ack(void)
{
    rom_port6_ddr &= ~(1 << SDA);
    PORT6_DDR      = rom_port6_ddr;
    slowdown();
    set(SCL);
    slowdown();
    clr(SCL);
    rom_port6_ddr |= (1 << SDA);
    PORT6_DDR      = rom_port6_ddr;
    slowdown();
}


static __inline__ void i2c_write(unsigned char val)
{
    unsigned char bit;

    for (bit = (1 << 7); bit; bit >>= 1) {
        if (bit & val) {
            set(SDA);
        } else {
            clr(SDA);
        }
        slowdown();
        set(SCL);
        slowdown();
        clr(SCL);
        slowdown();
    }
}


static void lcd_write_data(unsigned char *data, unsigned char len)
{
    unsigned char i;

    i2c_start();
    for (i = 0; i < len; i++) {
        i2c_write(*data++);
        i2c_read_ack();
    }
    i2c_stop();
}


#ifdef CONF_LCD_REFRESH


#ifdef CONF_RCX_COMPILER
void lcd_refresh_next_byte(void)
#else
HANDLER_WRAPPER("lcd_refresh_next_byte", "lcd_refresh_next_byte_core");

void lcd_refresh_next_byte_core(void)
#endif
{
    unsigned char byte;

    byte = lcd_byte_counter++;
    if (lcd_byte_counter >= LCD_DATA_SIZE)
        lcd_byte_counter = 0;

    if (lcd_shadow[byte + LCD_DATA_OFFSET] == display_memory[byte])
        return;

    lcd_shadow[byte + LCD_DATA_OFFSET] = display_memory[byte];
    lcd_shadow[LCD_SHORT_CMD + 1] = byte << 1;
    lcd_shadow[LCD_SHORT_CMD + 2] = display_memory[byte];
    lcd_write_data(&lcd_shadow[LCD_SHORT_CMD], 3);
}

#endif // CONF_LCD_REFRESH


void lcd_refresh(void)
{
    unsigned char i;

    for (i = 0; i < LCD_DATA_SIZE; i++)
        lcd_shadow[i + LCD_DATA_OFFSET] = display_memory[i];
    lcd_write_data(&lcd_shadow[LCD_LONG_CMD], 11);
}


void lcd_power_on(void)
{
    lcd_shadow[LCD_SHORT_CMD + 1] = LCD_MODE_SET | LCD_ENABLE;
    lcd_write_data(&lcd_shadow[LCD_SHORT_CMD], 2);
}


void lcd_power_off(void)
{
    lcd_refresh();

    lcd_shadow[LCD_SHORT_CMD + 1] = LCD_MODE_SET | LCD_DISABLE;
    lcd_write_data(&lcd_shadow[LCD_SHORT_CMD], 2);

    clr(SCL);
    clr(SDA);
}


void lcd_init(void)
{
    rom_port6_ddr |= (1 << SCL);
    PORT6_DDR      = rom_port6_ddr;
    clr(SCL);
    rom_port6_ddr |= (1 << SDA);
    PORT6_DDR      = rom_port6_ddr;
    clr(SDA);

    memset(lcd_shadow, 0, sizeof(lcd_shadow));
    lcd_shadow[LCD_SHORT_CMD] = LCD_DEV_ID | I2C_WRITE;
    lcd_shadow[LCD_LONG_CMD]  = LCD_DEV_ID | I2C_WRITE;

    lcd_power_on();

#ifdef CONF_LCD_REFRESH
    lcd_refresh_counter = 0;
    lcd_byte_counter = 0;
#endif
}

---