led_driver.c

LINUX下控制LED屏的驱动程序

   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(TPHL);   
   
   write_gpio_bit(GPIO_LED_EN, ENABLE);
   
   udelay(TPHL);   
}

////////////////////////////////////////////////////////////////////////
static void LED_Disable(LED_SCREEN_PARA *screen)
{
   write_gpio_bit(GPIO_LED_EN, DISABLE);
   udelay(TPHL);      

   if (screen->vram) 
     rvfree(screen->vram, screen->datasize);
   
}

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++)
   {
      write_gpio_bit(GREEN_GPIO[page], DISABLE);	  
      if (addr[x + (y+page*screen->scanline)*screen->linestep] > frame)
         write_gpio_bit(RED_GPIO[page], ENABLE);	  
      else
         write_gpio_bit(RED_GPIO[page], DISABLE);	  
   }
   udelay(TH);

//test driver!!!!!!!!!!! 
//delay 3s
   mdelay(2000);

   write_gpio_bit(GPIO_LED_CK, ENABLE);
   udelay(TH);
//test driver!!!!!!!!!!! 
//delay 3s
   mdelay(2000);
        
}

static void write_frame(LED_SCREEN_PARA *screen, int frame)
{
   int x, y;
   
   DPRINTK(KERN_INFO "led driver write frame %d\n", frame);	
   
//   for (y=0; y<screen->scanline; y++)
//test driver!!!!!!!!!!! 
   for (y=0; y<9; y++)
   {
       
       write_gpio_bit(GPIO_LED_ST, DISABLE);
       
//test driver!!!!!!!!!!! 
//       for (x=0; x<screen->screenwidth; x++)
       for (x=0; x<4; x++)
         write_pixel(screen, frame, x, y);        
       
       write_gpio_bit(GPIO_LED_ST, ENABLE);
       udelay(TSU);
//test driver!!!!!!!!!!! 
//delay 3s
       mdelay(2000);

       DPRINTK(KERN_INFO "led driver output line %d\n", y);	

       write_gpio_bit(GPIO_LED_A, y&0x01);       
       write_gpio_bit(GPIO_LED_B, (y&0x02)>>1);       
       write_gpio_bit(GPIO_LED_C, (y&0x04)>>2);       
       write_gpio_bit(GPIO_LED_D, (y&0x08)>>3);       
       udelay(TWH);
        
   }
}

void led_scan(unsigned long data)
{
   int color, colors;
   
   colors = 1>>ledscreens->depth;
//test driver!!!!!!!!!!! 
//   for(color=0 ; color<colors ; color++)
//     write_frame(ledscreens, color);
     write_frame(ledscreens, 128);

   LEDScreen_starttimer();

}

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

   DPRINTK(KERN_INFO "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;
 }
*/

MODULE_AUTHOR("LED Driver <[e-mail]>");
MODULE_DESCRIPTION("driver for led driver");
MODULE_SUPPORTED_DEVICE(LEDSCREEN_NAME);
MODULE_LICENSE("GPL");

static void __exit LEDScreen_exit_module (void)
{
	unregister_chrdev(LEDSCREEN_MAJOR, LEDSCREEN_NAME);
        
        printk("LED driver: %s unregister.\n", LEDSCREEN_NAME);

        DPRINTK(KERN_INFO "LED driver: %s unregister.\n", LEDSCREEN_NAME);
}

static int __init LEDScreen_init_module (void)
{
        printk("LED driver: %s %s initialized.\n", LEDSCREEN_NAME,LEDSCREEN_VERSION);

	if (register_chrdev(LEDSCREEN_MAJOR, LEDSCREEN_NAME,
				&device_fops)) {
		DPRINTK(KERN_INFO "LED driver: LEDScreen: unable to get major %d\n",LEDSCREEN_MAJOR);
		return -EIO;
	}

       DPRINTK(KERN_INFO "LED driver: %s %s initialized.\n", LEDSCREEN_NAME,LEDSCREEN_VERSION);
	return 0;
}

module_init(LEDScreen_init_module);
module_exit(LEDScreen_exit_module);


int LEDScreen_open(struct inode *minode, struct file *mfile)
{
    LED_SCREEN_PARA *leds;

   printk(KERN_INFO "led driver: start open \n");

   leds = kmalloc(sizeof(LED_SCREEN_PARA), GFP_KERNEL);
   if (leds == NULL)
   {
       printk(KERN_INFO "led driver: open faile!\n");
       return -ENOMEM;
   }  
   ledscreens = leds;
	
   memset(ledscreens, 0, sizeof(LED_SCREEN_PARA));
   ledscreens->screenwidth = 64;
   ledscreens->screenheight = 32;
   ledscreens->depth = 8;
   ledscreens->scanline = 16;
   ledscreens->pages = 2;
   ledscreens->datasize = 0;
   ledscreens->vram = NULL;
   
   
   SetScreenMemory(ledscreens);
   disp_frame = 0;
   
   LEDScreen_Enable();
   LEDScreen_starttimer();   
   //tty_module_get(THIS_MODULE);

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

int LEDScreen_release(struct inode *minode, struct file *mfile)
{
   //tty_module_get(THIS_MODULE);
   if (ledscreens)
   {
     del_timer(&scan_timer);
     LED_Disable(ledscreens);
     kfree(ledscreens);
   }

   DPRINTK(KERN_INFO "LED driver: release \n" );	
   MOD_DEC_USE_COUNT;
   return 0;
}


int LEDScreen_mmap(struct file *file, struct vm_area_struct *vma)
{
        LED_SCREEN_PARA *screen = ledscreens;
        unsigned long start=(unsigned long)vma->vm_start;
        unsigned long page,pos;
        unsigned long size;

        size = (unsigned long)(vma->vm_end-vma->vm_start);
        
        if (!screen->vram) {
		DPRINTK(KERN_INFO "LED driver:  No video memory");
		return -EINVAL;
	}

        pos=(unsigned long) screen->vram;
        while (size > 0) {
                page = kvirt_to_pa(pos);
                if (remap_page_range(start, page, PAGE_SIZE, PAGE_SHARED))
                {
		    DPRINTK(KERN_INFO "LED driver:  remap_page_range error");
                    return -EAGAIN;
                }
                start+=PAGE_SIZE;
                pos+=PAGE_SIZE;
                size-=PAGE_SIZE;
        }
        
        DPRINTK(KERN_INFO "LED driver: mmap OK\n" );	
        
        return 0;
	
}

static int LEDScreen_ioctl(struct inode *inode, struct file *file,
			   unsigned int cmd, unsigned long arg)
{

	switch(cmd)
	{
	case LEDDRV_GETSCREEINFO:
	{
                LED_SCREEN_PARA *screen = ledscreens;
		QVFbHeader qvfb;
		
		DPRINTK(KERN_INFO "LED driver: ioctl GETSCREEINFO");
		
                memset (&qvfb, 0, sizeof(QVFbHeader));
                qvfb.width = screen->screenwidth;
                qvfb.height = screen->screenheight;
                qvfb.depth = screen->depth;  
                qvfb.linestep = screen->linestep;

		if(copy_to_user((void *)arg, &qvfb, sizeof(qvfb)))
			return -EFAULT;

		return 0;
                
	}
	default:
		return -EINVAL;
	}
}