hi_gpio.c

ARM处理器的GPIO口配置输入、输出

      
   	if (bitx > 7)
   	{
      		return -1;
        } 
   	else
   	{   
     		regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE);   
     		regvalue &= (~(1<<(bitx)));
   
     		writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE));

	     	return 0;
   	}		
}

/*
 *	Clear interrupt flags of gpio
 */
int gpio_interruptclear (unsigned int gpio_pathnum ,unsigned int bitx)
{
   	unsigned int regvalue=0;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
      
   	if (bitx > 7)
   	{
      		return -1;
   	}
   	else
   	{   
     		//regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IC);   
     		regvalue = (1<<(bitx));
   
     		writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IC));

     		return 0;
   	}		
}



/*
 *	Select both edge(set to 1) or single edge(set to 0) to sense interrupt
 */
int gpio_interruptsenseboth(unsigned int gpio_pathnum ,unsigned int bitx ,unsigned int bothnsingle)
{
   	unsigned int regvalue;

   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
      
   	if (bitx > 7)
   	{
      		return -1;
   	}
   	else
   	{ 
    		regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IBE);
     		if (bothnsingle == SENSE_SINGLE)  
            		regvalue &= (~(1<<(bitx)));
     		else if (bothnsingle == SENSE_BOTH) 
            		regvalue |= (1<<(bitx));
     		else 
         		return -1;
                
     		writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IBE));
     		return 0;
   	}		
}


/*
 *	Select both edge(set to 1) or single edge(set to 0) to sense interrupt byte
 */
int gpio_interruptsenseboth_byte(unsigned int gpio_pathnum ,unsigned int byte ,unsigned int bothnsingle)
{
   	unsigned int regvalue;

   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
    	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IBE);
    	if (bothnsingle == SENSE_SINGLE)  
            	regvalue &= ~byte;
     	else if (bothnsingle == SENSE_BOTH) 
            	regvalue |= byte;
     	else 
         	return -1;
     	
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IBE));
     	return 0;
}


/*
 *	Select the single interrupt sense Edge(set bit to 0) 
 *	or sense level(set bit to 1) 
 */
int gpio_interruptsenseset(unsigned int gpio_pathnum ,unsigned int bitx ,unsigned int levelnedge)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
      
   	if (bitx > 7)
   	{
      		return -1;
   	}
   	else
   	{ 
     		regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IS);
     		if (levelnedge == SENSE_EDGE)  
            		regvalue &= (~(1<<(bitx)));
     		else if (levelnedge == SENSE_LEVEL) 
            		regvalue |= (1<<(bitx));
     		else 
         		return -1;
                
     		writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IS));
     		return 0;
   	}		
}


/*
  Select the single interrupt  sense Edge(set bit to 0) 
  or sense level(set bit to 1) in a byte 
*/
int gpio_interruptsenseset_byte(unsigned int gpio_pathnum ,unsigned int byte ,unsigned int levelnedge)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
     	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IS);
     	if (levelnedge == SENSE_EDGE)  
            	regvalue &= ~byte ;
     	else if (levelnedge == SENSE_LEVEL) 
            	regvalue |= byte ;
     	else 
         	return -1;
                
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IS));
     	return 0;
}


/*
 *	Select the single interrupt event rising Edge & high level (set bit to 1)
 *	or select the event falling edge or low level (set bit to 0);
 */
int gpio_interruptevenset(unsigned int gpio_pathnum ,unsigned int bitx , unsigned int risingnfalling)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
      
   	if (bitx > 7)
   	{
      		return -1;
   	}
   	else
   	{  
     		regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IEV);
     		if ((risingnfalling == EVENT_RISING_EDGE)||(risingnfalling == EVENT_HIGH_LEVEL)) 
          		regvalue |= (1<<(bitx));
     		else if ((risingnfalling == EVENT_FALLING_EDGE)||(risingnfalling == EVENT_LOW_LEVEL))
          		regvalue &= (~(1<<(bitx)));
     		else 
         		return -1;     
     
     		writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IEV));
     		return 0;
   	}		
}


/*
 *	Select the single interrupt event rising Edge & high level (set bit to 1)
 *	or select the event falling edge or low level (set bit to 0) in a byte;
 */
int gpio_interruptevenset_byte(unsigned int gpio_pathnum ,unsigned int byte , unsigned int risingnfalling)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
      
     	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IEV);
     	if ((risingnfalling == EVENT_RISING_EDGE)||(risingnfalling == EVENT_HIGH_LEVEL)) 
        	regvalue |= byte;
     	else if ((risingnfalling == EVENT_FALLING_EDGE)||(risingnfalling == EVENT_LOW_LEVEL))
          	regvalue &= ~byte;
     	else 
         	return -1;     
    
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IEV));
     	return 0;
}


/* 
 *	Interrupt mode set:include bothnsingle,levelnedge,risingnfalling
 */
int gpio_interruptset
   	(
    		unsigned int gpio_pathnum ,
    		unsigned int bitx ,
    		unsigned int bothnsingle,
    		unsigned int levelnedge,
    		unsigned int risingnfalling
    	)
{
    	int status;
    	status = gpio_interruptsenseboth(gpio_pathnum,bitx,bothnsingle);
    	if(status == -1)
      		return -1;
    	status = gpio_interruptsenseset(gpio_pathnum,bitx,levelnedge);
    	if(status == -1)
      		return -1;
    	status = gpio_interruptevenset(gpio_pathnum,bitx,risingnfalling);    
    	return status;
}


/* 
 *	Interrupt mode set:include bothnsingle,levelnedge,risingnfalling in a byte
 */
int gpio_interruptset_byte
   	(
    		unsigned int gpio_pathnum ,
    		unsigned int byte ,
    		unsigned int bothnsingle,
    		unsigned int levelnedge,
    		unsigned int risingnfalling
    	)
{
    	int status;
    	status = gpio_interruptsenseboth_byte(gpio_pathnum,byte,bothnsingle);
    	if(status == -1)
      		return -1;
    	status = gpio_interruptsenseset_byte(gpio_pathnum,byte,levelnedge);
    	if(status == -1)
      		return -1;
    	status = gpio_interruptevenset_byte(gpio_pathnum,byte,risingnfalling);    
    	return status;
}


/* 
 *	Disable  single interrupt byte
 */
int gpio_interruptdisable_byte (unsigned int gpio_pathnum ,unsigned int byte)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
     	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE);   
     	regvalue &=  ~byte;
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE));
     	return 0;
}	

	
/* 
 *	Enable  single interrupt byte
 */
int gpio_interruptenable_byte (unsigned int gpio_pathnum ,unsigned int byte)
{
   	unsigned int regvalue;
   
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
     	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE);   
     	regvalue |=  byte;
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IE));
     	return 0;
}		

int gpio_interruptclear_byte (unsigned int gpio_pathnum ,unsigned int byte)
{
   	unsigned int regvalue;
   	if (gpio_pathnum >= GPIO_GROUP_NUMBER)
      		return -1;
     	regvalue=readw(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IC);   
     	regvalue |= byte;
     	writew(regvalue,(GPIO_BASE + (gpio_pathnum) * GPIO_SPACE_SIZE + GPIO_IC));
     	return 0;
}


static int __init hi_gpio_init(void)
{  
        return 0;   
}

static void __exit hi_gpio_exit(void)
{    
}

module_init(hi_gpio_init);
module_exit(hi_gpio_exit);

#ifdef MODULE
#include <linux/compile.h>
#endif
MODULE_INFO(build, UTS_VERSION);
MODULE_LICENSE("GPL");

EXPORT_SYMBOL(GPIO_BASE);
EXPORT_SYMBOL(gpio_remap);
EXPORT_SYMBOL(gpio_unmap);
EXPORT_SYMBOL(gpio_modeset);
EXPORT_SYMBOL(gpio_modeget);
EXPORT_SYMBOL(gpio_dirsetbit);
EXPORT_SYMBOL(gpio_dirsetbyte);
EXPORT_SYMBOL(gpio_dirgetbyte);
EXPORT_SYMBOL(gpio_dirgetbit);
EXPORT_SYMBOL(gpio_writebit);
EXPORT_SYMBOL(gpio_writebyte);
EXPORT_SYMBOL(gpio_readbit);
EXPORT_SYMBOL(gpio_readbyte);
EXPORT_SYMBOL(gpio_interruptenable);
EXPORT_SYMBOL(gpio_interruptdisable);
EXPORT_SYMBOL(gpio_interruptclear);
EXPORT_SYMBOL(gpio_interruptsenseboth_byte);
EXPORT_SYMBOL(gpio_interruptsenseboth);
EXPORT_SYMBOL(gpio_interruptsenseset);
EXPORT_SYMBOL(gpio_interruptsenseset_byte);
EXPORT_SYMBOL(gpio_interruptevenset);
EXPORT_SYMBOL(gpio_interruptevenset_byte);
EXPORT_SYMBOL(gpio_interruptset);
EXPORT_SYMBOL(gpio_interruptset_byte);
EXPORT_SYMBOL(gpio_interruptdisable_byte);
EXPORT_SYMBOL(gpio_interruptenable_byte);
EXPORT_SYMBOL(gpio_interruptclear_byte);