led-driver.c~

LINUX下控制LED屏的驱动程序

/*
 *	$Id: scan_keyb.c,v 1.2 2000/07/04 06:24:42 yaegashi Exp $ 
 *	Copyright (C) 2000 YAEGASHI Takeshi
 *	Generic scan keyboard driver
 GPIO                  EXT     Direct     LED PIN
 ----------------------------------------------------------------------------------
 EINT9/GPG1             6      output     EN
 nSS1/EINT11/GPG3       9      output     CK
 SPIMISO1/EINT13/GPG5   12     output     ST
 SPIMISI1/EINT14/GPG6   11     output     A
 SPICLK1/EINT15/GPG7    10     output     B
 EINT16/GPG8            7      output     C
 EINT17/GPG9            8      output     D
 TXD1/GPH4              13     output     R1
 RXD1/GPH5              14     output     R2
 nRTS1/TXD2/GPH6        15     output     G1
 nCTS01/RXD2/GPH7       16     output     G2
 
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/tty.h>
#include <linux/mm.h>
#include <linux/signal.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include "S3C2410.h"
/*
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
*/

#undef DEBUG
#ifdef DEBUG
#define DPRINTK( x... ) printk( ##x )
#else
#define DPRINTK( x... )
#endif

#define TWH           10
#define TWL           10
#define TCS           15
#define TCH           20
#define TCR           30
#define TCKS          20
#define TCKH          20
#define TDS           50
#define TDH           50
#define TRD           25
#define TRZ           10
#define TRF           20

#define GPIO_LED_EN            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G1)
#define GPIO_LED_CK            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G3)
#define GPIO_LED_ST            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G5)
#define GPIO_LED_A             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G6)
#define GPIO_LED_B             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G7)
#define GPIO_LED_C             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G8)
#define GPIO_LED_D             (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_G9)
#define GPIO_LED_R1            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_H4)
#define GPIO_LED_R2            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_H5)
#define GPIO_LED_G1            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_H6)
#define GPIO_LED_G2            (GPIO_MODE_OUT | GPIO_PULLUP_DIS | GPIO_H7)

#define ENABLE  1
#define DISABLE 0

#define LED_PIPE "LEDEmbedded-%1"

#define LEDSCREEN_NAME "leds"
#define LEDSCREEN_VERSION "version 0.1"
#define LEDSCREEN_MAJOR 252

#define SCANHZ	(HZ/20)

static int scan_jiffies=0;
struct timer_list scan_timer;
static int disp_frame = 0;


typedef struct led_screen_para {
	u16 screewidth;
	u16 screenheight;
	u8  depth;
	u8  scanline;
	u8  pages;
	void* vram;
} LED_SCREEN_PARA;

LED_SCREEN_PARA ledscreen = {
	128,
	64,
	8,
	16,
	2,
	NULL
};

u32 RED_GPIO[2] = {GPIO_LED_R1, GPIO_LED_R2};
u32 GREEN_GPIO[2] = {GPIO_LED_G1, GPIO_LED_G2};


typedef unsigned int QRgb;                        // RGB triplet

struct QVFbHeader
{
    int width;
    int height;
    int depth;
    int linestep;
    int dataoffset;
//    MWRECT update;
    bool dirty;
    int  numcols;
//    QRgb clut[256];
    int viewerVersion;
    int serverVersion;
};

static unsigned char *shmrgn;
static QVFbHeader *hdr;

static int SetScreenShm(LED_SCREEN_PARA *screen);
static void LEDScreen_Enable(void);
static void LED_Disable(void);
static void write_pixel(LED_SCREEN_PARA *screen, int frame, int x, int y);
static void write_frame(LED_SCREEN_PARA *screen, int frame);
static int LEDScreen_starttimer(void);

int LEDScreen_open(struct inode *minode, struct file *mfile);
int LEDScreen_release(struct inode *minode, struct file *mfile);

int __init LEDScreen_init(void)
{
   register_chrdev(LEDSCREEN_MAJOR, LEDSCREEN_NAME, &device_fops);
   DPRINTK("%s %s initialized.\n", LEDSCREEN_NAME,LEDSCREEN_VERSION);
   return 0;
}


module_init(LEDScreen_init);

void __exit LEDScreen_exit(void)
{

   unregister_chrdev(LEDSCREEN_MAJOR, LEDSCREEN_NAME);
   DPRINTK("%s unregister.\n", LEDSCREEN_NAME);
   
}

module_exit(LEDScreen_exit)

static struct file_operation device_fops = {
	open:     LEDScreen_open,
	release:  LEDScreen_release,	
	ioctl:    LEDScreen_ioctl,
};

static int SetScreenShm(LED_SCREEN_PARA *screen)
{
    int w, int h, int d;
    int bpl, dataSize;
    unsigned char *data;    
    key_t key;
    char keybuf[256];
    
        
    //displayID may be changed
    unlink( keybuf );

    sprintf(keybuf, LED_PIPE, 0)
    key = ftok(keybuf, 'b');
    
    w = screen->width;
    h = screen->height;
    d = screen->depth; 
    
    if ( d == 1 )
	bpl = (w*d+7)/8;
    else
	bpl = ((w*d+31)/32)*4;
    
    dataSize = bpl * h + 1024;
    shmId = shmget( key, dataSize, IPC_CREAT|0666);
    if ( shmId != -1 )
	data = (unsigned char *)shmat( shmId, 0, 0 );
    else {
	struct shmid_ds shm;
	shmctl( shmId, IPC_RMID, &shm );
	shmId = shmget( key, dataSize, IPC_CREAT|0666);
	data = (unsigned char *)shmat( shmId, 0, 0 );
    }

    DPRINTK( "Led driver: width(%d),height(%d),depth(%d)\n",w,h,d );	

    if ( (int)data == -1 )
    {
      DPRINTK( "Cannot attach to shared memory \n" );	
      return 0;
    }

    hdr = (QVFbHeader *)data;
    hdr->width = screen->width;
    hdr->height = screen->height;
    hdr->depth = screen->depth;  
    hdr->linestep = bpl;
    hdr->numcols = 0;
    hdr->dataoffset = 1024;
    //hdr->update = QRect();
//    screen->scanline = 16;
//    screen->pages = 2;
    screen->vram = data+hdr->dataoffset;

    DPRINTK( "Led driver: Set share memory ok \n" );	

    return 1;
}


static int LEDScreen_open(struct inode *minode, struct file *mfile)
{
   
   SetScreenShm(&ledscreen);
   disp_frame = 0;
   
   LEDScreen_Enable();
   LEDScreen_starttimer();   
   tty_module_get(THIS_MODULE);

   DPRINTK( "LED driver: open \n" );	
   return 0;
}

static void LEDScreen_Enable()
{
   set_gpio_ctrl(GPIO_LED_EN);
   set_gpio_ctrl(GPIO_LED_CK);
   set_gpio_ctrl(GPIO_LED_ST);
   set_gpio_ctrl(GPIO_LED_A);
   set_gpio_ctrl(GPIO_LED_B);
   set_gpio_ctrl(GPIO_LED_C);
   set_gpio_ctrl(GPIO_LED_D);
   set_gpio_ctrl(GPIO_LED_R1);
   set_gpio_ctrl(GPIO_LED_R2);
   set_gpio_ctrl(GPIO_LED_G1);
   set_gpio_ctrl(GPIO_LED_G2);
   
   udelay(TCKS);   
   
   write_gpio_bit(GPIO_LED_EN, ENABLE);
   
   udelay(TCS);   
}

static int LEDScreen_release(struct inode *minode, struct file *mfile)
{
   tty_module_get(THIS_MODULE);
   del_timer(&scan_timer);
   LED_Disable();

   DPRINTK( "LED driver: release \n" );	
   return 0;
}
	
static void LED_Disable(void)
{
   write_gpio_bit(GPIO_LED_EN, DISABLE);
   udelay(TCR);      
}

static void write_pixel(LED_SCREEN_PARA *screen, int frame, int x, int y)
{
   unsigned char *addr = screen->vram;
   int page = 0;
        
   write_gpio_bit(GPIO_LED_CK, DISABLE);
   udelay(TWL);      
   for (page = 0; page < screen->pages; page++)
   {
      if (addr[x + (y+page*screen->scanline)*screen->width] > frame)
         write_gpio_bit(RED_GPIO[page], ENABLE);	  
      else
         write_gpio_bit(RED_GPIO[page], DISABLE);	  
   }
   udelay(TDS);

   write_gpio_bit(GPIO_LED_CK, ENABLE);
   udelay(TWH);
        
   write_gpio_bit(GPIO_LED_ST, ENABLE);
   udelay(TWH);
}

static void write_frame(LED_SCREEN_PARA *screen, int frame)
{
   int x, y;
   
   printk(KERN_INFO "led driver write frame %d\n", frame);
   
   for (y=0; y<screen->scanline; y++)
   {
       write_gpio_bit(GPIO_LED_A, y|0x01);       
       write_gpio_bit(GPIO_LED_B, y|0x02);       
       write_gpio_bit(GPIO_LED_C, y|0x04);       
       write_gpio_bit(GPIO_LED_D, y|0x08);       
       
       for (x=0; x<screen->width; x++)
         write_pixel(screen, frame, x, y);        
        
   }
}

void led_scan(void)
{
   int color, colors;
   
   colors = 1>>screen->depth;
   for(color=0 ; color<colors ; color++)
     write_frame(ledscreen, color);
}

static int LEDScreen_starttimer(void)
{
   init_timer(&scan_timer);
   scan_timer.expires = jiffies + SCANHZ;
   scan_timer.data = 0;
   scan_timer.function = led_scan;
   add_timer(&scan_timer);

   DPRINTK( "LED driver: start timer \n" );	
}

/*
void write_register(char address, char data)
{
   EXTPORT0_ClearBit(RTC_CLK);
   CPCR0 |= GPIO_LED_DATA;
   LED_Enable();
   write_4bits(LED_WR_MODE);
   write_4bits(address);
   write_4bits(data);
   LED_Disable();   
}

void write_4bits(char data)
{
   write_nbits(data, 4);
}

unsigned long read_nbits(unsigned long nbit)
{
   unsigned long data = 0;
   int i;
   
   GPDR0 &= ~GPIO_LED_DATA;
   
   for (i=0; i < nbit; i++)
   {
      EXTPORT0_SetBit(LED_CLK);
      udelay(TWH);
      data |= (((GPLR0&GPIO_LED_DATA)!=0)?0x01<<i:0);
      EXTPORT0_ClearBit(RTC_CLK);
      udelay(TWL);      
   }
   udelay(TRZ);
   return data;
}

void write_nbits(unsigned long put_data, unsigned long nbit)
{
   int i;
   
   GPDR0 |= GPIO_LED_DATA;
   
   for (i=0; i < nbit; i++)
   {
      if (put_data & (0x01 << i))
        GPSR0 |= GPIO_LED_DATA;
      else
        GPCR0 |= GPIO_LED_DATA;
        
      udelay(TDS);
      EXTPORT0_SetBit(LED_CLK);
      udelay(TWH);
      EXTPORT0_ClearBit(RTC_CLK);
      udelay(TWL);      
   }
   udelay(TRZ);
   return data;
 }
*/