static int __init tg3_init(void)
{
    //先注册成PCI设备，并初始化，如果是其他的ESIA，PCMCIA，用其他函数
    return pci_module_init(&tg3_driver);
}

static void __exit tg3_cleanup(void)
{
pci_unregister_driver(&tg3_driver);//注销PCI设备
}

module_init(tg3_init); //驱动模块的加载
module_exit(tg3_cleanup); //驱动模块的卸载

static struct pci_driver tg3_driver = {
    .name = DRV_MODULE_NAME,
    .id_table = tg3_pci_tbl, //此驱动所支持的网卡系列，vendor_id, device_id
    .probe = tg3_init_one, //初始化网络设备的回调函数
    .remove = __devexit_p(tg3_remove_one), //注销网络设备的回调函数
    .suspend = tg3_suspend, //设备挂起函数
    .resume = tg3_resume //设备恢复函数
};

static int __devinit tg3_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    //初始化设备，使I/O，memory可用，唤醒设备
    pci_enable_device(pdev);
    //申请内存空间，配置网卡的I/O，memory资源
    pci_request_regions(pdev, DRV_MODULE_NAME);
    pci_set_master(pdev);
    //设置DMA属性
    pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff);
    //网卡 I/O,memory资源的启始地址
    tg3reg_base = pci_resource_start(pdev, 0);
    //网卡I/O,memory资源的大小
    tg3reg_len = pci_resource_len(pdev, 0);
    //分配并设置网络设备
    dev = alloc_etherdev(sizeof(*tp));
    //申明为内核设备模块
    SET_MODULE_OWNER(dev);
    //初始化私有结构中的各成员值
    tp = dev->priv;
    tp->pdev = pdev;
    tp->dev = dev;
    ……
    //锁的初始化
    spin_lock_init(&tp->lock);
    //映射I/O,memory地址到私有域中的寄存器结构
    tp->regs = (unsigned long) ioremap(tg3reg_base, tg3reg_len);
    dev->irq = pdev->irq;
    //网络设备回调函数赋值
    dev->open = tg3_open;
    dev->stop = tg3_close;
    dev->get_stats = tg3_get_stats;
    dev->set_multicast_list = tg3_set_rx_mode;
    dev->set_mac_address = tg3_set_mac_addr;
    dev->do_ioctl = tg3_ioctl;
    dev->tx_timeout = tg3_tx_timeout;
    dev->hard_start_xmit= tg3_start_xmit;
    //网卡的MAC地址赋值dev->addr
    tg3_get_device_address(tp);
    //注册网络设备
    register_netdev(dev);
    //把网络设备指针地址放入PCI设备中的设备指针中
    pci_set_drvdata(pdev, dev);
}

static void __devexit tg3_remove_one(struct pci_dev *pdev)
{
    struct net_device *dev = pci_get_drvdata(pdev);
    //注销网络设备
    unregister_netdev(dev);
    //取消地址映射
    iounmap((void *) ((struct tg3 *)(dev->priv))->regs);
    //释放网络设备
    kfree(dev);
    //释放PCI资源
    pci_release_regions(pdev);
    //停用PCI设备
    pci_disable_device(pdev);
    //PCI设备中的设备指针赋空
    pci_set_drvdata(pdev, NULL);
}

static int tg3_open(struct net_device *dev)
{
    //分配一个中断
    request_irq(dev->irq, tg3_interrupt, SA_SHIRQ, dev->name, dev);
    /* int request_irq(unsigned int irq,
    void (*handler)(int irq, void *dev_id, struct pt_regs *regs),
    unsigned long irqflags,
    const char * devname,
    void *dev_id);
    irq 是要申请的硬件中断号。在Intel平台，范围0--15。
    handler是向系统登记的中断处理函数。这是一个回调函数，中断发生时，系统调用这个函数，传入的参数包括硬件中断号，device id，寄存器值。
    dev_id就是下面的request_irq时传递给系统的参数dev_id。irqflags是中断处理的一些属性。
    比较重要的有 SA_INTERRUPT，标明中断处理程序是快速处理程序(设置SA_INTERRUPT)还是慢速处理程序(不设置SA_INTERRUPT)。快速处理程序被调用时屏蔽所有中断。慢速处理程序不屏蔽。还有一个SA_SHIRQ属性，设置了以后运行多个设备共享中断。dev_id在中断共享时会用到。 一般设置为这个设备的device结构本身或者NULL。中断处理程序可以用dev_id找到相应的控制这个中断的设备，或者用rq2dev_map找到 中断对应的设备。*/
    //初始化硬件
    tg3_init_hw(tp);
    //初始化收包和发包的缓冲区
    tg3_init_rings(tp);
    //初始化定时器
    init_timer(&tp->timer);
    tp->timer.expires = jiffies + tp->timer_offset;
    tp->timer.data = (unsigned long) tp;
    tp->timer.function = tg3_timer; //超时回调函数
    add_timer(&tp->timer);
    //允许网卡开始传输包
    netif_start_queue(dev);
}

static int tg3_close(struct net_device *dev)
{
    //停止网卡传输包
    netif_stop_queue(dev);
    netif_carrier_off(tp->dev);
    //去除定时器
    del_timer_sync(&tp->timer);
    //释放收包和发包的缓冲区
    tg3_free_rings(tp);
    //释放中断
    free_irq(dev->irq, dev);
}

static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    len = (skb->len - skb->data_len);
    //以DMA方式向网卡物理设备传输包。如果是wireless的话，需要根据802.11协议及硬件的规范从新填充
    //硬件帧头，然后提交给硬件发送。
    mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
    tp->tx_buffers[entry].skb = skb;
    pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
    //硬件发送
    tg3_set_txd(tp, entry, mapping, len, base_flags, mss_and_is_end);
    //记录发包开始时间
    dev->trans_start = jiffies;
}

static void tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
    //如果要收包
    tg3_rx(tp);
    //如果要发包
    tg3_tx(tp);
}

static void tg3_tx(struct tg3 *tp)
{
    struct tx_ring_info *ri = &tp->tx_buffers[sw_idx];
    struct sk_buff *skb = ri->skb;
    //以DMA方式向网卡传输包完毕
    pci_unmap_single(tp->pdev, pci_unmap_addr(ri, mapping),
    (skb->len - skb->data_len), PCI_DMA_TODEVICE);
    ri->skb = NULL;
    dev_kfree_skb_irq(skb);
}

static int tg3_rx(struct tg3 *tp, int budget)
{
    struct sk_buff *copy_skb;
    //分配一个包
    copy_skb = dev_alloc_skb(len + 2);
    copy_skb->dev = tp->dev;
    //修改包头空间
    skb_reserve(copy_skb, 2);
    //加入数据到包中
    skb_put(copy_skb, len);
    //以DMA方式从网卡传输回数据
    pci_dma_sync_single(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
    memcpy(copy_skb->data, skb->data, len);
    skb = copy_skb;
    //解析包的协议
    skb->protocol = eth_type_trans(skb, tp->dev);
    //把包送到协议层
    netif_rx(skb);
    //记录收包时间
    tp->dev->last_rx = jiffies;
}

static struct net_device_stats *tg3_get_stats(struct net_device *dev)
{
    //从硬件相关的寄存器读取数据，累加
    //stats->rx_packets, stats->tx_packets, stats->rx_bytes, stats->tx_bytes等
}

static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
    struct mii_ioctl_data *data = (struct mii_ioctl_data *)&ifr->ifr_data;
    switch(cmd) {
        //ethtool程序命令的调用
        case SIOCETHTOOL:
        return tg3_ethtool_ioctl(dev, (void *) ifr->ifr_data);
        //mii程序命令的调用
        case SIOCGMIIREG: {
            err = tg3_readphy(tp, data->reg_num & 0x1f, &mii_regval)
            data->val_out = mii_regval;
            return err;
    }
    ……
    }
}

static int tg3_suspend(struct pci_dev *pdev, u32 state)
{
    //停用网卡的中断寄存器
    tg3_disable_ints(tp);
    //停止网卡收发包
    netif_device_detach(dev);
    //停止网卡某些硬件，fireware的一些功能
    tg3_halt(tp);
    //设置网卡的电源状态
    tg3_set_power_state(tp, state);
}

static int tg3_resume(struct pci_dev *pdev)
{
    //恢复网卡电源
    tg3_set_power_state(tp, 0);
    //允许网卡收发包
    netif_device_attach(dev);
    //初始化收发包的缓冲区
    tg3_init_rings(tp);
    //初始化网卡硬件
    tg3_init_hw(tp);
    //打开网卡中断寄存器
    tg3_enable_ints(tp);
}

typedef struct 
{ 
   volatile int counter; 
} 
atomic_t;

atomic_inc(&v)对变量v用锁定总线的单指令进行不可分解的"原子"级增量操作，避免v的值由于中断或多处理器同时操作造成不确定状态。

原子操作API包括： 
 
int atomic_read(atomic_t * v);
 
　　该函数对原子类型的变量进行原子读操作，它返回原子类型的变量v的值。 
 
 
void atomic_set(atomic_t * v, int i);
 
　　该函数设置原子类型的变量v的值为i。 
 
 
void atomic_add(int i, atomic_t *v);
 
　　该函数给原子类型的变量v增加值i。 
 
 
void atomic_sub(int i, atomic_t *v);
 
　　该函数从原子类型的变量v中减去i。 
 
 
int atomic_sub_and_test(int i, atomic_t *v);
 
　　该函数从原子类型的变量v中减去i，并判断结果是否为0，如果为0，返回真，否则返回假。 
 
 
void atomic_inc(atomic_t *v);
 
　　该函数对原子类型变量v原子地增加1。 
 
 
void atomic_dec(atomic_t *v);
 
　　该函数对原子类型的变量v原子地减1。 
 
 
int atomic_dec_and_test(atomic_t *v);
 
　　该函数对原子类型的变量v原子地减1，并判断结果是否为0，如果为0，返回真，否则返回假。 
 
 
int atomic_inc_and_test(atomic_t *v);
 
　　该函数对原子类型的变量v原子地增加1，并判断结果是否为0，如果为0，返回真，否则返回假。 
 
 
int atomic_add_negative(int i, atomic_t *v);
 
　　该函数对原子类型的变量v原子地增加I，并判断结果是否为负数，如果是，返回真，否则返回假。 
 
 
int atomic_add_return(int i, atomic_t *v);
 
　　该函数对原子类型的变量v原子地增加i，并且返回指向v的指针。 
 
 
int atomic_sub_return(int i, atomic_t *v);
 
　　该函数从原子类型的变量v中减去i，并且返回指向v的指针。 
 
 
int atomic_inc_return(atomic_t * v);
 
　　该函数对原子类型的变量v原子地增加1并且返回指向v的指针。 
 
 
int atomic_dec_return(atomic_t * v);
　　该函数对原子类型的变量v原子地减1并且返回指向v的指针。 

void *check_timeout(void *arg)
{
int second_now = 0;
int count = 0;

//Get current time and second
while (1)
{
count++;
sleep(1);
if(count >= TIMEOUT_CNT)
{
printf("Timeout!\r\n");
            // kill specific proccess
system("ps | grep busybox | grep -v grep | awk '{print $1}' | xargs kill -s 9");
exit(0);
}
        
        // if websocket received data, clear count
if((strlen(idata) >= 1))
{
count = 0;
}
}
}

//creat pthread to check time
pthread_t thread_check_time;
pthread_create(&thread_check_time, NULL, &check_timeout, NULL);

/****************************************************************************

* Copyright (C) 2010 - 2020 Xilinx, Inc.  All rights reserved.
* SPDX-License-Identifier: MIT
  ******************************************************************************/

/******************************************************************************/
/**
*

* @file xscugic_example.c
  *

* This file contains a design example using the Interrupt Controller driver

* (XScuGic) and hardware device. Please reference other device driver examples

* to see more examples of how the intc and interrupts can be used by a software

* application.
  *

* @note
  *

* None
  *

* <pre>
  *

* MODIFICATION HISTORY:

* Ver   Who  Date     Changes

* ----- ---- -------- ----------------------------------------------------

* 1.00a drg  01/18/10 First release

* </pre>
  ******************************************************************************/

/***************************** Include Files *********************************/

#include <stdio.h>
#include <stdlib.h>
#include "xil_io.h"
#include "xil_exception.h"
#include "xparameters.h"
#include "xil_cache.h"
#include "xil_printf.h"
#include "xil_types.h"
#include "xscugic.h"

/************************** Constant Definitions *****************************/

/*

 * The following constants map to the XPAR parameters created in the
 * xparameters.h file. They are defined here such that a user can easily
 * change all the needed parameters in one place.
   */
   #define INTC_DEVICE_IDXPAR_SCUGIC_0_DEVICE_ID
   #define INTC_DEVICE_INT_ID0x0E

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/
int ScuGicExample(u16 DeviceId);
int SetUpInterruptSystem(XScuGic *XScuGicInstancePtr);
void DeviceDriverHandler(void *CallbackRef);

/************************** Variable Definitions *****************************/

XScuGic InterruptController;      /* Instance of the Interrupt Controller */
static XScuGic_Config *GicConfig;    /* The configuration parameters of the
                                       controller */

/*

 * Create a shared variable to be used by the main thread of processing and
 * the interrupt processing
   */
   volatile static int InterruptProcessed = FALSE;

static void AssertPrint(const char8 *FilenamePtr, s32 LineNumber){
xil_printf("ASSERT: File Name: %s ", FilenamePtr);
xil_printf("Line Number: %d\r\n",LineNumber);
}

/*****************************************************************************/
/**
*

* This is the main function for the Interrupt Controller example.
  *
* @paramNone.
  *
* @returnXST_SUCCESS to indicate success, otherwise XST_FAILURE.
  *
* @noteNone.
  *
  ****************************************************************************/
  int main(void)
  {
  int Status;


/*
 * Setup an assert call back to get some info if we assert.
 */
Xil_AssertSetCallback(AssertPrint);

xil_printf("GIC Example Test\r\n");

/*
 *  Run the Gic example , specify the Device ID generated in xparameters.h
 */
Status = ScuGicExample(INTC_DEVICE_ID);
if (Status != XST_SUCCESS) {
xil_printf("GIC Example Test Failed\r\n");
return XST_FAILURE;
}

xil_printf("Successfully ran GIC Example Test\r\n");
return XST_SUCCESS;

}

/*****************************************************************************/
/**
*

* This function is an example of how to use the interrupt controller driver

* (XScuGic) and the hardware device.  This function is designed to

* work without any hardware devices to cause interrupts. It may not return

* if the interrupt controller is not properly connected to the processor in

* either software or hardware.
  *

* This function relies on the fact that the interrupt controller hardware

* has come out of the reset state such that it will allow interrupts to be

* simulated by the software.
  *

* @paramDeviceId is Device ID of the Interrupt Controller Device,

* typically XPAR_<INTC_instance>_DEVICE_ID value from

* xparameters.h
  *

* @returnXST_SUCCESS to indicate success, otherwise XST_FAILURE
  *

* @noteNone.
  *
  ******************************************************************************/
  int ScuGicExample(u16 DeviceId)
  {
  int Status;

  /*

   * Initialize the interrupt controller driver so that it is ready to
   * use.
     */
     GicConfig = XScuGic_LookupConfig(DeviceId);
     if (NULL == GicConfig) {
     return XST_FAILURE;
     }

  Status = XScuGic_CfgInitialize(&InterruptController, GicConfig,
  GicConfig->CpuBaseAddress);
  if (Status != XST_SUCCESS) {
  return XST_FAILURE;
  }


/*
 * Perform a self-test to ensure that the hardware was built
 * correctly
 */
Status = XScuGic_SelfTest(&InterruptController);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}


/*
 * Setup the Interrupt System
 */
Status = SetUpInterruptSystem(&InterruptController);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
 * Connect a device driver handler that will be called when an
 * interrupt for the device occurs, the device driver handler performs
 * the specific interrupt processing for the device
 */
Status = XScuGic_Connect(&InterruptController, INTC_DEVICE_INT_ID,
   (Xil_ExceptionHandler)DeviceDriverHandler,
   (void *)&InterruptController);

if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
 * Enable the interrupt for the device and then cause (simulate) an
 * interrupt so the handlers will be called
 */
XScuGic_Enable(&InterruptController, INTC_DEVICE_INT_ID);

/*
 *  Simulate the Interrupt
 */
Status = XScuGic_SoftwareIntr(&InterruptController,
INTC_DEVICE_INT_ID,
XSCUGIC_SPI_CPU0_MASK);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
 * Wait for the interrupt to be processed, if the interrupt does not
 * occur this loop will wait forever
 */
while (1) {
/*
 * If the interrupt occurred which is indicated by the global
 * variable which is set in the device driver handler, then
 * stop waiting
 */
if (InterruptProcessed) {
break;
}
}

return XST_SUCCESS;

}

/******************************************************************************/
/**
*

* This function connects the interrupt handler of the interrupt controller to

* the processor.  This function is separate to allow it to be customized for

* each application.  Each processor or RTOS may require unique processing to

* connect the interrupt handler.
  *

* @paramXScuGicInstancePtr is the instance of the interrupt controller

* that needs to be worked on.
  *

* @returnNone.
  *

* @noteNone.
  *
  ****************************************************************************/
  int SetUpInterruptSystem(XScuGic *XScuGicInstancePtr)
  {

  /*

   * Connect the interrupt controller interrupt handler to the hardware
   * interrupt handling logic in the ARM processor.
     */
     Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
     (Xil_ExceptionHandler) XScuGic_InterruptHandler,
     XScuGicInstancePtr);

  /*

   * Enable interrupts in the ARM
     */
     Xil_ExceptionEnable();

  return XST_SUCCESS;
  }

/******************************************************************************/
/**
*

* This function is designed to look like an interrupt handler in a device
* driver. This is typically a 2nd level handler that is called from the
* interrupt controller interrupt handler.  This handler would typically
* perform device specific processing such as reading and writing the registers
* of the device to clear the interrupt condition and pass any data to an
* application using the device driver.  Many drivers already provide this
* handler and the user is not required to create it.
  *
* @paramCallbackRef is passed back to the device driver's interrupt
* handler by the XScuGic driver.  It was given to the XScuGic
* driver in the XScuGic_Connect() function call.  It is typically
* a pointer to the device driver instance variable.
* In this example, we do not care about the callback
* reference, so we passed it a 0 when connecting the handler to
* the XScuGic driver and we make no use of it here.
  *
* @returnNone.
  *
* @noteNone.
  *
  ****************************************************************************/
  void DeviceDriverHandler(void *CallbackRef)
  {
  /*
   * Indicate the interrupt has been processed using a shared variable
     */
     InterruptProcessed = TRUE;
     }

int opt = 0;
int cmd = 0;
int data = 0;
const char *optstring = "a:b:c:hz";
//while ((opt = getopt_long(argc, argv, optstring)) != -1)
while ((opt = getopt(argc, argv, optstring)) != -1)
{
    case 'a': //analog voltage
      sscanf(optarg, "%d", &data);
      break;
    case 'b': //set bar
      sscanf(optarg, "%d", &data);
      break;
    case 'c': // do api func
      printf("opt is c, comand is: %s\n", optarg);
      if (!strcmp(optarg, "open"))
      {
        cmd = 1;
      }
      else if (!strcmp(optarg, "close"))
      {
        cmd = 2;
      }
      else
      {
        printf("[ERR] command NG: %s\n", optarg);
        return 0;
      }
      /*
      ret = do_api_func(cmd);
      if (0 != ret)
      {
        printf("[ERR] errcode=%d\n", ret);
        return 0;
      }
      else
      {
        ret = check_api_result_when_ok(cmd);
      }
      break;
      */
    case 'z': //dump parameters for debug
      //debug_dump_api_parameters();
      break;
    case 'h':
      print_usage(argv[0]);
      return 0;
    case '?':
      printf("Try \'%s -h\' for more information.\n", argv[0]);
      return 0;
}

struct option long_options[] = {
    {"cmd", 1, NULL, 'c'},
    {"analog-input", 1, NULL, 'a'},
    {"bar", 1, NULL, 'b'},
    {0, 0, 0, 0},
};

#include<stdio.h>
#include<Lib.h> // include Library function

int Callback() // Callback Function
{
  // TODO
  return 0;
}
int main() // Main program
{
  // TODO
  Library(Callback);
  // TODO
  return 0;
}

#include<stdio.h>

int Callback_1(int x) // Callback Function 1
{
    printf("Hello, this is Callback_1: x = %d ", x);
    return 0;
}

int Callback_2(int x) // Callback Function 2
{
    printf("Hello, this is Callback_2: x = %d ", x);
    return 0;
}

int Callback_3(int x) // Callback Function 3
{
    printf("Hello, this is Callback_3: x = %d ", x);
    return 0;
}

int Handle(int y, int (*Callback)(int))
{
    printf("Entering Handle Function. ");
    Callback(y);
    printf("Leaving Handle Function. ");
}

int main()
{
    int a = 2;
    int b = 4;
    int c = 6;
    printf("Entering Main Function. ");
    Handle(a, Callback_1);
    Handle(b, Callback_2);
    Handle(c, Callback_3);
    printf("Leaving Main Function. ");
    return 0;
}