I/O模型之異步(在中斷基礎上------jz2440）

異步通知

在應用層使用signal爲一個信號綁定一個處理函數，應用層執行signal之後接着往下執行。當硬件中的數據準備好的時候硬件會給驅動發送中斷，驅動收到中斷後給應用程序發送信號，應用程序收到信號後執行信號處理函數，並在信號處理函數中調用read函數讀取數據。

#include <signal.h>

sighandler_t signal(int signum, sighandler_t handler);

參數1 signum信號量

參數2 handler處理函數‘

功能描述：根據文件描述詞來操作文件的特性。

int fcntl(int fd, int cmd);

int fcntl(int fd, int cmd, long arg);

int fcntl(int fd, int cmd, struct flock *lock);

描述： fcntl()針對(文件)描述符提供控制.參數fd是被參數cmd操作(如下面的描述)的描述符.

針對cmd的值,fcntl能夠接受第三個參數（arg）

參數1 fd 文件描述符

參數2 cmd

複製一個現有的描述符（cmd=F_DUPFD）.

獲得／設置文件描述符標記(cmd=F_GETFD或F_SETFD).

獲得／設置文件狀態標記(cmd=F_GETFL或F_SETFL).

獲得／設置異步I/O所有權(cmd=F_GETOWN或F_SETOWN).

獲得／設置記錄鎖(cmd=F_GETLK,F_SETLK或F_SETLKW)

注意:在修改文件描述符標誌或文件狀態標誌時必須謹慎，先要取得現在的標誌值然後按照希望修改它，最後設置新標誌值。不能只是執行F_SETFD或F_SETFL命令，這樣會關閉以前設置的標誌位。

[返回值]

fcntl()的返回值與命令有關：如果出錯，所有命令都返回－1，如果成功則返回某個其他值。下列三個命令有特定返回值：F_DUPFD , F_GETFD , F_GETFL以及F_GETOWN。

F_DUPFD 返回新的文件描述符

F_GETFD 返回相應標誌

F_GETFL , F_GETOWN 返回一個正的進程ID或負的進程組ID

cmd值的F_GETFL和F_SETFL :F_GETFL取得fd的文件狀態標誌，如同下面的描述一樣(arg被忽略)，在說明open函數時，已說明了文件狀態標誌。不幸的是，三個存取方式標誌 (O_RDONLY , O_WRONLY , 以及O_RDWR)並不各佔1位。(這三種標誌的值各是0 , 1和2，由於歷史原因，這三種值互斥 — 一個文件只能有這三種值之一。) 因此首先必須用屏蔽字O_ACCMODE相與取得存取方式位，然後將結果與這三種值相比較。

F_SETFL 設置給arg描述符狀態標誌，可以更改的幾個標誌是：O_APPEND，O_NONBLOCK，O_SYNC 和 O_ASYNC。而fcntl的文件狀態標誌總共有7個：O_RDONLY , O_WRONLY , O_RDWR , O_APPEND , O_NONBLOCK , O_SYNC和O_ASYNC

可更改的幾個標誌如下面的描述：

O_NONBLOCK 非阻塞I/O，如果read(2)調用沒有可讀取的數據，或者如果write(2)操作將阻塞，則read或write調用將返回-1和EAGAIN錯誤

O_APPEND 強制每次寫(write)操作都添加在文件大的末尾，相當於open(2)的O_APPEND標誌

O_DIRECT 最小化或去掉reading和writing的緩存影響。系統將企圖避免緩存你的讀或寫的數據。如果不能夠避免緩存，那麼它將最小化已經被緩存了的數據造成的影響。如果這個標誌用的不夠好，將大大的降低性能

O_ASYNC 當I/O可用的時候，允許SIGIO信號發送到進程組，例如：當有數據可以讀的時候

cmd值的F_GETOWN和F_SETOWN：

F_GETOWN 取得當前正在接收SIGIO或者SIGURG信號的進程id或進程組id，進程組id返回的是負值(arg被忽略)

F_SETOWN 設置將接收SIGIO和SIGURG信號的進程id或進程組id，進程組id通過提供負值的arg來說明(arg絕對值的一個進程組ID)，否則arg將被認爲是進程id

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/device.h>
#include<linux/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/interrupt.h> 
#include <linux/poll.h>
struct    led_dev_struct{
     int  major;
     struct class *dev_class;
     struct device *device_class;
     wait_queue_head_t wq; //定義等待隊列頭
    
};

struct     led_dev_struct   *key_drv;
 struct fasync_struct *fapp;
#define  GPFx    0x56000050
#define  GPGx   0x56000060
volatile  unsigned   int  *gpfcon;
volatile  unsigned  int   *gpfdat;

volatile  unsigned   int  *gpgcon;
volatile  unsigned  int   *gpgdat; 
static unsigned     int     key_val;
/* 中斷事件標誌, 中斷服務程序將它置1，third_drv_read將它清0 */

static volatile int ev_press = 0;

static   irqreturn_t   key_interrupt(int irq, void *dev_id)
{

	  if(irq==IRQ_EINT0)
	  {
                 printk("key1-----------\n");
		key_val=*gpfdat;
	 	key_val=(key_val&(1<<0))?0:1;
	  }
	  if(irq==IRQ_EINT2)
	  {
                printk("key2------------\n");
		key_val=*gpfdat;
	 	key_val=(key_val&(1<<2))?0:1;	   
	  }
	  if(irq==IRQ_EINT11)
	  {
	       printk("key3-----------\n");
	      key_val=*gpgdat;
	      key_val=(key_val&(1<<3))?0:1;
	  }
	    ev_press = 1;                  /* 表示中斷髮生了 */
             wake_up_interruptible(&(key_drv->wq));   /* 喚醒休眠的進程 */
	    kill_fasync(&fapp,  SIGIO,  POLL_IN);
	    return IRQ_HANDLED;//表示中斷完成
	   
}
static   int  key_open(struct inode *inode, struct file *file)
{
            //申請中斷
           int ret;
           ret=request_irq(IRQ_EINT0, key_interrupt,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,"key1",NULL);
	   if(ret)
	   {  
	            return  -EINVAL;
	   }
	  ret=request_irq(IRQ_EINT2, key_interrupt,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,"key2",NULL);
	   if(ret)
	   {  
	            return  -EINVAL;
	   }
	  ret=request_irq(IRQ_EINT11,key_interrupt,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,"key11",NULL);
	    if(ret)
	   {  
	            return  -EINVAL;
	   }
           return 0;
		
}
static  ssize_t  key_read(struct file *file, char __user *buffer, size_t size, loff_t *ppos)
{      
           printk("%d\n",key_val);
           /* 如果沒有按鍵動作, 休眠 */
	   wait_event_interruptible(key_drv->wq, ev_press);
	   copy_to_user(buffer,&key_val,sizeof(key_val));
	   printk("rrrrrrrrrrrrrrrrrrrrrr\n");
	   ev_press = 0;
	 
          return sizeof(key_val);
}


static  ssize_t  key_write(struct file *file, const char __user *buffer, size_t size,loff_t *ppos)
{
	   
         printk("xxxxxxxxxxxxxx\n");
	 return 0;
}
//poll機制

static unsigned  key_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	poll_wait(file, &key_drv->wq, wait); // 不會立即休眠

	if (ev_press)
		mask |= POLLIN | POLLRDNORM;
	return mask;
}


//記錄信號發送給誰
int   key_fasync (int  fd, struct file *file, int  on)
{
         //記錄信號發送給誰
        return fasync_helper(fd,file,on,&fapp);

}



struct  file_operations key_fops={
            .open       =  key_open,   
            .read        =  key_read,
            .write       =  key_write,
            .poll         =  key_poll,
            .fasync     = key_fasync,
};  


//入口函數
static int __init key_init(void)
{
       int  ret;
      //給機構體申請空間
      key_drv=kmalloc(sizeof(struct  led_dev_struct), GFP_KERNEL);
       //申請設備號
      key_drv->major=register_chrdev(0, "key_led", &key_fops);
      if ( key_drv->major < 0) { 
		printk("register_chrdev  error\n");
		ret=-EINVAL;
	}  
      //創建類
     key_drv->dev_class=class_create(THIS_MODULE, "leds");
     if (IS_ERR( key_drv->dev_class)) {
	   ret= PTR_ERR( key_drv->dev_class);
	   goto  flag1;
	}
     //創建設備
    key_drv->device_class=device_create(key_drv->dev_class, NULL,MKDEV( key_drv->major,0), "led1");
    if (IS_ERR( key_drv->device_class)){
	    ret=PTR_ERR( key_drv->device_class);
	  goto flag2;	
    }
     init_waitqueue_head(&(key_drv->wq));//初始化等待隊列頭
    //進行映射把物理地址變成虛擬地址
       gpfcon= ioremap(GPFx, 16);    
       gpfdat=gpfcon+1;
	  
      gpgcon=ioremap(GPGx,12);
      gpgdat=gpgcon+1;
       return 0;
flag2: 
	class_destroy( key_drv->dev_class);
flag1:
	unregister_chrdev(0, "key_led");
	return  ret;

}
//出口函數
static  void __exit  key_exit(void)
{    
       iounmap( gpgcon);
       iounmap( gpfcon);
       device_destroy(key_drv->dev_class, MKDEV( key_drv->major,0));    
       class_destroy(key_drv->dev_class);
       unregister_chrdev(0, "key_led");
       kfree(key_drv);
       free_irq(IRQ_EINT0,NULL);
       free_irq(IRQ_EINT2,NULL);
       free_irq(IRQ_EINT11,NULL);
}

//入口函數和出口函數的修飾
module_init(key_init);
module_exit(key_exit);

MODULE_LICENSE("GPL");

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <unistd.h>
#include <signal.h>
int  fd;
unsigned int flag;
int key_val;
void sig_handler(int sig)
{
	   read(fd, &key_val, sizeof(key_val));
            printf("key_val = 0x%x\n", key_val);
     
}

int main(void)
{
   char buf[20];
   int f_flags;


   fd = open("/dev/led1", O_RDWR);
   if(fd < 0)
   {
     perror("open");
     return -1;
   }
  /*三個步驟*/
        //設置信號處理函數，驅動程序應當通過SIGIO來通知
	signal(SIGIO, sig_handler); 
	//設置設備文件的屬主，設置爲進程本身
	fcntl(fd, F_SETOWN, getpid());
	//設置設備文件FASYNC屬性
	f_flags  = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, f_flags | FASYNC); //此時會調用驅動 fasync方法
	
	   while(1);
	 
	   close(fd);
   return 0;
 }

I/O模型之異步(在中斷基礎上------jz2440）

redis的key亂碼問題和值自增問題

CORS error 但是 status code 是200 OK

一個開源且全面的C#算法實戰教程

一款.NET開源、功能強大、跨平臺的繪圖庫 - OxyPlot

壓縮上傳的GPU數據的方案

使用skopeo同步鏡像

針對ji2440進行的分區的擴充方法(源於製作的內核鏡像大於2M）

Linux通過移植linux-3.4.2，將製作好的yaffs2，通過nfs掛載根文件系統失敗解決辦法

I/O模型之非阻塞(在中斷基礎上------jz2440）

I/O模型之多路複用epoll(在中斷基礎上------jz2440）

I/O模型之多路複用select(在中斷基礎上------jz2440）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結