lcd_controller.c

在SOPC平台上

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "lcd_controller.h"
#include "io.h"
#include "sys/alt_alarm.h"
#include "sys/alt_cache.h"
#include "system.h"
#include "priv/alt_file.h"

// LCD device list (usualy just one)
ALT_LLIST_HEAD(lcd_dev_list);

/******************************************************************
*  Function: lcd_dev_init
*
*  Purpose: HAL device driver initialization.  
*           Called by alt_sys_init.
*
******************************************************************/
int lcd_dev_init ( lcd_controller_dev* lcd )
{
  int ret_code = 0;
 
  ret_code = lcd_device_register( &(lcd->dev) );
 
  return ret_code;
}

/******************************************************************
*  Function: alt_lcd_open_dev
*
*  Purpose: Opens the LCD controller for use.  
*           Returns a file descriptor for the controller
*
******************************************************************/
alt_dev* alt_lcd_open_dev(const char* name)
{
  alt_dev* dev = (alt_dev*)alt_find_dev(name, &lcd_dev_list);

  return dev;
}

/******************************************************************
*  Function: alt_lcd_close_dev
*
*  Purpose: Closes the LCD controller.
*
******************************************************************/
void alt_lcd_close_dev(alt_dev* fd)
{
  return;
}

/******************************************************************
*  Function: lcd_init_no_interrupt
*
*  Purpose: Initializes the LCD controller for the NEC NL2432HC22 
*           LCD daughterboard. Gets memory for the frame buffer,
*           sets the resolution of the frame buffer, resets the 
*           controller hardware, gives the controller the base 
*           address of the frame buffer, then enables
*           the controller.  Interrupts are NOT enabled.
*
******************************************************************/
frame_buffer_struct* lcd_init_no_interrupt ( lcd_controller_dev* lcd, int buffer_location)
{
  frame_buffer_struct* frame_buffer;
  int bytes_per_pixel, bytes_per_frame;
  
  // We'll need these values more than once, so let's pre-calculate them.
  bytes_per_pixel = lcd->color_depth >> 3; // same as /8
  bytes_per_frame = (( lcd->width * lcd->height ) * bytes_per_pixel);

  // Allocate our frame buffers
  if( buffer_location == HEAP )
  {
    frame_buffer = (frame_buffer_struct*) alt_uncached_malloc(sizeof (frame_buffer_struct));
    frame_buffer->frame0 = (frame_array*) alt_uncached_malloc(( bytes_per_frame ));
    // If we're double-buffering, grab an extra buffer, if not, just make 
    // both pointers point to the same buffer.
    if(lcd->frame_buffers == 2)
    {
      frame_buffer->frame1 = (frame_array*) alt_uncached_malloc(( bytes_per_frame ));
    }
    else
    {
      frame_buffer->frame1 = frame_buffer->frame0;
    }
  }
  else
  {
    frame_buffer = (frame_buffer_struct*)buffer_location;
    frame_buffer->frame0 = (frame_array*)(buffer_location + sizeof(frame_buffer_struct));
    // If we're double-buffering, grab an extra buffer, if not, just make 
    // both pointers point to the same buffer.
    if(lcd->frame_buffers == 2)
    {
      frame_buffer->frame1 = (frame_buffer->frame0 + bytes_per_frame);
    }
    else
    {
      frame_buffer->frame1 = frame_buffer->frame0;
    }
  }
	frame_buffer->width = lcd->width;
	frame_buffer->height = lcd->height;
	frame_buffer->color_depth = lcd->color_depth;
	frame_buffer->frame_buffers = lcd->frame_buffers;
	frame_buffer->bytes_per_frame = bytes_per_frame;
	frame_buffer->bytes_per_pixel = (lcd->color_depth / 8);
	frame_buffer->lcd_controller_base = lcd->base_addr;
  
  //Clear all frame buffers to black
  lcd_clear_screen( frame_buffer, BLACK_8 );
  lcd_flip_frame_buffers( frame_buffer );
  lcd_clear_screen( frame_buffer, BLACK_8 );
  
  IOWR_32DIRECT( lcd->base_addr, 0, 0x0 ); /* Reset the LCD controller */
  IOWR_32DIRECT( lcd->base_addr, 4, ( int )frame_buffer->frame0 ); /* Where our frame buffer starts */
  IOWR_32DIRECT( lcd->base_addr, 8, ( ( lcd->width * lcd->height ) * bytes_per_pixel ) ); /* amount of memory needed */   
  IOWR_32DIRECT( lcd->base_addr, 0, 0x1 ); /* Set the go bit. */
 
  return ( frame_buffer );
}

/******************************************************************
*  Function: lcd_clear_screen
*
*  Purpose: Uses the fast memset routine to clear the entire frame
*           buffer.  User can specify black(0x00) or white(0xFF).
*
******************************************************************/
inline void lcd_clear_screen (frame_buffer_struct* frame_buffer, char color)
{
  memset( (void*)(frame_buffer->frame1), color, frame_buffer->bytes_per_frame );
}


/******************************************************************
*  Function: lcd_flip_frame_buffers
*
*  Purpose: If there are two frame buffers, this routine swaps
*           the pointers to those buffers, then writes the frame0
*           pointer to the LCD controller so it will display it
*           next. 
*
******************************************************************/
int lcd_flip_frame_buffers( frame_buffer_struct* frame_buffer )
{
  frame_array* temp_frame;
  int ret_code;
  
  if( frame_buffer->frame_buffers == 2 )
  {
    temp_frame = frame_buffer->frame0;
    frame_buffer->frame0 = frame_buffer->frame1;
    frame_buffer->frame1 = temp_frame;
    IOWR_32DIRECT( frame_buffer->lcd_controller_base, 8, ( int )frame_buffer->frame0 );
    ret_code = 0;
  }
  else
  {
    ret_code = 1;
  }
  return(ret_code);
}