一、核心資料結構
串列埠驅動有3個核心資料結構，它們都定義在<#include linux/serial_core.h>
1、uart_driver

uart_driver包含了串列埠裝置名、串列埠驅動名、主次裝置號、串列埠控制檯(可選)等資訊，還封裝了tty_driver(底層串列埠驅動無需關心tty_driver)。

struct uart_driver {
    struct module     *owner;           /* 擁有該uart_driver的模組,一般為THIS_MODULE */
    const char        *driver_name;     /* 串列埠驅動名，串列埠裝置檔名以驅動名為基礎 */
    const char        *dev_name;        /* 串列埠裝置名 */
    int                major;           /* 主裝置號 */
    int                minor;           /* 次裝置號 */
    int                nr;              /* 該uart_driver支援的串列埠個數(最大) */
    struct console    *cons;            /* 其對應的console.若該uart_driver支援serial console,否則為NULL */

    /*
     * these are private; the low level driver should not
     * touch these; they should be initialised to NULL
     */
    struct uart_state *state;
    struct tty_driver *tty_driver;
};
 

2、uart_port
uart_port用於描述串列埠埠的I/O埠或I/O記憶體地址、FIFO大小、埠型別、串列埠時鐘等資訊。實際上，一個uart_port例項對應一個串列埠裝置

struct uart_port {
    spinlock_t             lock;           /* 串列埠埠鎖 */
    unsigned int           iobase;         /* IO埠基地址 */
    unsigned char __iomem *membase;        /* IO記憶體基地址,經對映(如ioremap)後的IO記憶體虛擬基地址 */
    unsigned int           irq;            /* 中斷號 */
    unsigned int           uartclk;        /* 串列埠時鐘 */
    unsigned int           fifosize;       /* 串列埠FIFO緩衝大小 */
    unsigned char          x_char;         /* xon/xoff字元 */
    unsigned char          regshift;       /* 暫存器位移 */
    unsigned char          iotype;         /* IO訪問方式 */
    unsigned char          unused1;

#define UPIO_PORT        (0)               /* IO埠 */
#define UPIO_HUB6        (1)
#define UPIO_MEM         (2)               /* IO記憶體 */
#define UPIO_MEM32       (3)
#define UPIO_AU          (4)               /* Au1x00 type IO */
#define UPIO_TSI         (5)               /* Tsi108/109 type IO */
#define UPIO_DWAPB       (6)               /* DesignWare APB UART */
#define UPIO_RM9000      (7)               /* RM9000 type IO */

    unsigned int        read_status_mask;  /* 關心的Rx error status */
    unsigned int        ignore_status_mask;/* 忽略的Rx error status */
    struct uart_info      *info;           /* pointer to parent info */
    struct uart_icount     icount;         /* 計數器 */

    struct console        *cons;           /* console結構體 */
#ifdef CONFIG_SERIAL_CORE_CONSOLE
    unsigned long         sysrq;           /* sysrq timeout */
#endif

    upf_t                 flags;

#define UPF_FOURPORT         ((__force upf_t) (1 << 1))
#define UPF_SAK              ((__force upf_t) (1 << 2))
#define UPF_SPD_MASK         ((__force upf_t) (0x1030))
#define UPF_SPD_HI           ((__force upf_t) (0x0010))
#define UPF_SPD_VHI          ((__force upf_t) (0x0020))
#define UPF_SPD_CUST         ((__force upf_t) (0x0030))
#define UPF_SPD_SHI          ((__force upf_t) (0x1000))
#define UPF_SPD_WARP         ((__force upf_t) (0x1010))
#define UPF_SKIP_TEST        ((__force upf_t) (1 << 6))
#define UPF_AUTO_IRQ         ((__force upf_t) (1 << 7))
#define UPF_HARDPPS_CD       ((__force upf_t) (1 << 11))
#define UPF_LOW_LATENCY      ((__force upf_t) (1 << 13))
#define UPF_BUGGY_UART       ((__force upf_t) (1 << 14))
#define UPF_MAGIC_MULTIPLIER ((__force upf_t) (1 << 16))
#define UPF_CONS_FLOW        ((__force upf_t) (1 << 23))
#define UPF_SHARE_IRQ        ((__force upf_t) (1 << 24))
#define UPF_BOOT_AUTOCONF    ((__force upf_t) (1 << 28))
#define UPF_FIXED_PORT       ((__force upf_t) (1 << 29))
#define UPF_DEAD             ((__force upf_t) (1 << 30))
#define UPF_IOREMAP          ((__force upf_t) (1 << 31))

#define UPF_CHANGE_MASK      ((__force upf_t) (0x17fff))
#define UPF_USR_MASK         ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))

    unsigned int             mctrl;        /* 當前的moden設定 */
    unsigned int             timeout;      /* character-based timeout */        
    unsigned int             type;         /* 埠型別 */
    const struct uart_ops   *ops;          /* 串列埠埠操作函式集 */
    unsigned int             custom_divisor;
    unsigned int             line;         /* 埠索引 */
    resource_size_t          mapbase;      /* IO記憶體物理基地址，可用於ioremap */
    struct device           *dev;          /* 父裝置 */
    unsigned char            hub6;         /* this should be in the 8250 driver */
    unsigned char            suspended;
    unsigned char            unused[2];
    void                    *private_data; /* 埠私有資料,一般為platform資料指標 */
};
 

uart_iconut為串列埠資訊計數器，包含了傳送字元計數、接收字元計數等。在串列埠的傳送中斷處理函式和接收中斷處理函式中，我們需要管理這些計數。

struct uart_icount {
    __u32    cts;
    __u32    dsr;
    __u32    rng;
    __u32    dcd;
    __u32    rx;      /* 傳送字元計數 */
    __u32    tx;      /* 接受字元計數 */
    __u32    frame;   /* 幀錯誤計數 */
    __u32    overrun; /* Rx FIFO溢位計數 */
    __u32    parity;  /* 幀校驗錯誤計數 */
    __u32    brk;     /* break計數 */
    __u32    buf_overrun;
};
 

uart_info有兩個成員在底層串列埠驅動會用到：xmit和tty。使用者空間程式通過串列埠傳送資料時，上層驅動將使用者資料儲存在xmit；而串列埠傳送中斷處理函式就是通過xmit獲取到使用者資料並將它們傳送出去。串列埠接收中斷處理函式需要通過tty將接收到的資料傳遞給行規則層。

/* uart_info例項僅在串列埠埠開啟時有效，它可能在串列埠關閉時被串列埠核心層釋放。因此，在使用uart_port的uart_info成員時必須保證串列埠已開啟。底層驅動和核心層驅動都可以修改uart_info例項。
 * This is the state information which is only valid when the port
 * is open; it may be freed by the core driver once the device has
 * been closed. Either the low level driver or the core can modify
 * stuff here.
 */
struct uart_info {
    struct tty_struct     *tty;
    struct circ_buf        xmit;
    uif_t                  flags;

/*
 * Definitions for info->flags. These are _private_ to serial_core, and
 * are specific to this structure. They may be queried by low level drivers.
 */
#define UIF_CHECK_CD        ((__force uif_t) (1 << 25))
#define UIF_CTS_FLOW        ((__force uif_t) (1 << 26))
#define UIF_NORMAL_ACTIVE    ((__force uif_t) (1 << 29))
#define UIF_INITIALIZED        ((__force uif_t) (1 << 31))
#define UIF_SUSPENDED        ((__force uif_t) (1 << 30))

    int                     blocked_open;

    struct tasklet_struct   tlet;

    wait_queue_head_t       open_wait;
    wait_queue_head_t       delta_msr_wait;
};

3、uart_ops

uart_ops涵蓋了串列埠驅動可對串列埠裝置進行的所有操作。

/*
 * This structure describes all the operations that can be
 * done on the physical hardware.
 */
struct uart_ops {
    unsigned int (*tx_empty)(struct uart_port *); /* 串列埠的Tx FIFO快取是否為空 */
    void         (*set_mctrl)(struct uart_port *, unsigned int mctrl); /* 設定串列埠modem控制 */
    unsigned int (*get_mctrl)(struct uart_port *); /* 獲取串列埠modem控制 */
    void         (*stop_tx)(struct uart_port *); /* 禁止串列埠傳送資料 */
    void         (*start_tx)(struct uart_port *); /* 使能串列埠傳送資料 */
    void         (*send_xchar)(struct uart_port *, char ch);/* 傳送xChar */
    void         (*stop_rx)(struct uart_port *); /* 禁止串列埠接收資料 */
    void         (*enable_ms)(struct uart_port *); /* 使能modem的狀態訊號 */
    void         (*break_ctl)(struct uart_port *, int ctl); /* 設定break訊號 */
    int          (*startup)(struct uart_port *); /* 啟動串列埠,應用程式開啟串列埠裝置檔案時,該函式會被呼叫 */
    void         (*shutdown)(struct uart_port *); /* 關閉串列埠,應用程式關閉串列埠裝置檔案時,該函式會被呼叫 */
    void         (*set_termios)(struct uart_port *, struct ktermios *new, struct ktermios *old); /* 設定串列埠引數 */
    void         (*pm)(struct uart_port *, unsigned int state,
             unsigned int oldstate); /* 串列埠電源管理 */
    int          (*set_wake)(struct uart_port *, unsigned int state); /*  */
    const char  *(*type)(struct uart_port *); /* 返回一描述串列埠型別的字串 */
    void         (*release_port)(struct uart_port *); /* 釋放串列埠已申請的IO埠/IO記憶體資源,必要時還需iounmap */
    int          (*request_port)(struct uart_port *); /* 申請必要的IO埠/IO記憶體資源,必要時還可以重新對映串列埠埠 */
    void         (*config_port)(struct uart_port *, int); /* 執行串列埠所需的自動配置 */
    int          (*verify_port)(struct uart_port *, struct serial_struct *); /* 核實新串列埠的資訊 */
    int          (*ioctl)(struct uart_port *, unsigned int, unsigned long); /* IO控制 */
};

二、串列埠驅動API 1、uart_register_driver

/* 功能：    uart_register_driver用於將串列埠驅動uart_driver註冊到核心(串列埠核心層)中，通常在模組初始化函式呼叫該函式。
 * 引數 drv：要註冊的uart_driver
 * 返回值：  成功，返回0；否則返回錯誤碼
 */
int uart_register_driver(struct uart_driver *drv)

/* 功能：    uart_unregister_driver用於登出我們已註冊的uart_driver，通常在模組解除安裝函式呼叫該函式
 * 引數 drv：要登出的uart_driver
 * 返回值：  成功，返回0；否則返回錯誤碼
 */
void uart_unregister_driver(struct uart_driver *drv)

/* 功能：    uart_add_one_port用於為串列埠驅動新增一個串列埠埠，通常在探測到裝置後(驅動的裝置probe方法)呼叫該函式
 * 引數 drv：串列埠驅動
 *      port:要新增的串列埠埠
 * 返回值：  成功，返回0；否則返回錯誤碼
 */
int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)

/* 功能：     uart_remove_one_port用於刪除一個已新增到串列埠驅動中的串列埠埠，通常在驅動解除安裝時呼叫該函式
 * 引數 drv： 串列埠驅動
 *      port: 要刪除的串列埠埠
 * 返回值：   成功，返回0；否則返回錯誤碼
 */
int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)

/* 功能：     uart_write_wakeup喚醒上層因向串列埠埠寫資料而阻塞的程序，通常在串列埠傳送中斷處理函式中呼叫該函式
 * 引數 port：需要喚醒寫阻塞程序的串列埠埠
 */
void uart_write_wakeup(struct uart_port *port)

/* 功能：     uart_suspend_port用於掛起特定的串列埠埠
 * 引數 drv： 要掛起的串列埠埠所屬的串列埠驅動
 *      port：要掛起的串列埠埠
 * 返回值：   成功返回0；否則返回錯誤碼
 */
int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)

/* 功能：     uart_resume_port用於恢復某一已掛起的串列埠
 * 引數 drv： 要恢復的串列埠埠所屬的串列埠驅動
 *      port：要恢復的串列埠埠
 * 返回值：   成功返回0；否則返回錯誤碼
 */
int uart_resume_port(struct uart_driver *drv, struct uart_port *port)

/* 功能：        uart_get_baud_rate通過解碼termios結構體來獲取指定串列埠的波特率
 * 引數 port：  要獲取波特率的串列埠埠
 *     termios：當前期望的termios配置(包含串列埠波特率)
 *     old：    以前的termios配置，可以為NULL
 *     min：    可接受的最小波特率
 *     max：    可接受的最大波特率
 * 返回值：     串列埠的波特率
 */
unsigned int
uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
     struct ktermios *old, unsigned int min, unsigned int max)


/* 功能：     uart_get_divisor用於計算某一波特率的串列埠時鐘分頻數（串列埠波特率除數）
 * 引數 port：要計算時鐘分頻數的串列埠埠
 *      baud：期望的波特率
 *返回值：    串列埠時鐘分頻數
 */
unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud)


/* 功能：      uart_update_timeout用於更新（設定）串列埠FIFO超時時間
 * 引數 port： 要更新超時時間的串列埠埠
 *     cflag：termios結構體的cflag值
 *     baud： 串列埠的波特率
 */
void uart_update_timeout(struct uart_port *port, unsigned int cflag, unsigned int baud)

/* 功能：uart_match_port用於判斷兩串列埠埠是否為同一埠
 * 引數 port1、port2：要判斷的串列埠埠
 * 返回值：不同返回0；否則返回非0
 */
int uart_match_port(struct uart_port *port1, struct uart_port *port2)


/* 功能：        uart_console_write用於向串列埠埠寫一控制檯資訊
 * 引數 port:    要寫資訊的串列埠埠
 *     s:       要寫的資訊
 *     count:   資訊的大小
 *     putchar: 用於向串列埠埠寫字元的函式，該函式函式有兩個引數：串列埠埠和要寫的字元
 */
void uart_console_write(struct uart_port *port, const char *s,
            unsigned int count,
            void (*putchar)(struct uart_port *, int))

三、串列埠驅動例子 該串列埠驅動例子是我針對s3c2410處理器的串列埠2(uart2)獨立開發的。因為我通過博創2410s開發板的GRPS擴充套件板來測試該驅動（已通過測試），所以我叫該串列埠為gprs_uart。 該驅動將串列埠看作平臺(platform)裝置。platform可以看作一偽匯流排，用於將集成於片上系統的輕量級裝置與Linux裝置驅動模型聯絡到一起，它包含以下兩部分（有關platform的宣告都在#include <linux/platform_device.h>,具體實現在drivers/base/platform.c）： 1、platform裝置。我們需要為每個裝置定義一個platform_device例項

struct platform_device {
    const char      *name;         /* 裝置名 */
    int              id;           /* 裝置的id號 */
    struct device    dev;          /* 其對應的device */
    u32              num_resources;/* 該裝置用有的資源數 */
    struct resource *resource;     /* 資源陣列 */
};

為我們的裝置建立platform_device例項有兩種方法：填充一個platform_device結構體後用platform_device_register(一次註冊一個)或platform_add_devices（一次可以註冊多個platform裝置）將platform_device註冊到核心；更簡單的是使用platform_device_register_simple來建立並註冊我們的platform_device。
2、platform驅動。platform裝置由platform驅動進行管理。當裝置加入到系統中時，platform_driver的probe方法會被呼叫來見對應的裝置新增或者註冊到核心；當裝置從系統中移除時，platform_driver的remove方法會被呼叫來做一些清理工作，如移除該裝置的一些例項、登出一些已註冊到系統中去的東西。

struct platform_driver {
    int  (*probe)(struct platform_device *);
    int  (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
    int  (*suspend)(struct platform_device *, pm_message_t state);
    int  (*suspend_late)(struct platform_device *, pm_message_t state);
    int  (*resume_early)(struct platform_device *);
    int  (*resume)(struct platform_device *);
    struct device_driver driver;
};

更詳細platform資料可參考網上相關文章。

例子驅動中申請和釋放IO記憶體區的整個過程如下：

insmod gprs_uart.ko→gprs_init_module()→uart_register_driver()→gprs_uart_probe()→ uart_add_one_port()→gprs_uart_config_port()→gprs_uart_request_port()→request_mem_region()

rmmod gprs_uart.ko→gprs_exit_module()→uart_unregister_driver()→gprs_uart_remove()→uart_remove_one_port()→gprs_uart_release_port()→release_mem_region()

例子驅動中申請和釋放IRQ資源的整個過程如下：

open /dev/gprs_uart→gprs_uart_startup()→request_irq()

close /dev/gprs_uart→gprs_uart_shutdown()→free_irq()

想了解更詳細的呼叫過程可以在驅動模組各函式頭插入printk(KERN_DEBUG "%s\n", __FUNCTION__);並在函式尾插入printk(KERN_DEBUG "%s done\n", __FUNCTION__);

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>       /* printk() */
#include <linux/slab.h>         /* kmalloc() */
#include <linux/fs.h>           /* everything... */
#include <linux/errno.h>        /* error codes */
#include <linux/types.h>        /* size_t */
#include <linux/fcntl.h>        /* O_ACCMODE */
#include <asm/system.h>         /* cli(), *_flags */
#include <asm/uaccess.h>        /* copy_*_user */
#include <linux/ioctl.h>
#include <linux/device.h>

#include <linux/platform_device.h>
#include <linux/sysrq.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial_core.h>
#include <linux/serial.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/console.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/hardware.h>
#include <asm/plat-s3c/regs-serial.h>
#include <asm/arch/regs-gpio.h>


#define DEV_NAME            "gprs_uart"     /* 裝置名 */
/* 這裡將串列埠的主裝置號設為0,則串列埠裝置編號由核心動態分配;你也可指定串列埠的裝置編號 */
#define GPRS_UART_MAJOR        0            /* 主裝置號 */
#define GPRS_UART_MINOR        0            /* 次裝置號 */
#define GPRS_UART_FIFO_SIZE    16           /* 串列埠FIFO的大小 */
#define RXSTAT_DUMMY_READ    (0x10000000)
#define MAP_SIZE             (0x100)        /* 要對映的串列埠IO記憶體區大小 */

/* 串列埠傳送中斷號 */
#define TX_IRQ(port) ((port)->irq + 1)
/* 串列埠接收中斷號 */
#define RX_IRQ(port) ((port)->irq)

/* 允許串列埠接收字元的標誌 */
#define tx_enabled(port) ((port)->unused[0])
/* 允許串列埠傳送字元的標誌 */
#define rx_enabled(port) ((port)->unused[1])

/* 獲取暫存器地址 */
#define portaddr(port, reg) ((port)->membase + (reg))

/* 讀8位寬的暫存器 */
#define rd_regb(port, reg) (ioread8(portaddr(port, reg)))
/* 讀32位寬的暫存器 */
#define rd_regl(port, reg) (ioread32(portaddr(port, reg)))
/* 寫8位寬的暫存器 */
#define wr_regb(port, reg, val) \
    do { iowrite8(val, portaddr(port, reg)); } while(0)
/* 寫32位寬的暫存器 */        
#define wr_regl(port, reg, val) \
    do { iowrite32(val, portaddr(port, reg)); } while(0)


/* 禁止串列埠傳送資料 */
static void gprs_uart_stop_tx(struct uart_port *port)
{
    if (tx_enabled(port))            /* 若串列埠已啟動傳送 */
    {        
        disable_irq(TX_IRQ(port));   /* 禁止傳送中斷 */
        tx_enabled(port) = 0;        /* 設定串列埠為未啟動傳送 */
    }
}

/* 使能串列埠傳送資料 */
static void gprs_uart_start_tx(struct uart_port *port)
{
    if (!tx_enabled(port))           /* 若串列埠未啟動傳送 */
    {
        enable_irq(TX_IRQ(port));    /* 使能傳送中斷 */
        tx_enabled(port) = 1;        /* 設定串列埠為已啟動傳送 */
    }    
}

/* 禁止串列埠接收資料 */
static void gprs_uart_stop_rx(struct uart_port *port)
{
    if (rx_enabled(port))            /* 若串列埠已啟動接收 */
    {
        disable_irq(RX_IRQ(port));   /* 禁止接收中斷 */
        rx_enabled(port) = 0;        /* 設定串列埠為未啟動接收 */
    }
}

/* 使能modem的狀態訊號 */
static void gprs_uart_enable_ms(struct uart_port *port)
{
}

/* 串列埠的Tx FIFO快取是否為空 */
static unsigned int gprs_uart_tx_empty(struct uart_port *port)
{
    int ret = 1;
    unsigned long ufstat = rd_regl(port, S3C2410_UFSTAT);
    unsigned long ufcon = rd_regl(port, S3C2410_UFCON);

    if (ufcon & S3C2410_UFCON_FIFOMODE)    /* 若使能了FIFO */
    {
        if ((ufstat & S3C2410_UFSTAT_TXMASK) != 0 ||    /* 0 <FIFO <=15 */
                (ufstat & S3C2410_UFSTAT_TXFULL))       /* FIFO滿 */
            ret = 0;
    }
    else    /* 若未使能了FIFO,則判斷髮送快取和傳送移位暫存器是否均為空 */
    {
        ret = rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE;
    }
            
    return ret;
}

/* 獲取串列埠modem控制,因為uart2無modem控制,所以CTS、DSR直接返回有效 */
static unsigned int gprs_uart_get_mctrl(struct uart_port *port)
{
    return (TIOCM_CTS | TIOCM_DSR | TIOCM_CAR);
}

/* 設定串列埠modem控制 */
static void gprs_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
{

}

/* 設定break訊號 */
static void gprs_uart_break_ctl(struct uart_port *port, int break_state)
{
    unsigned long flags;
    unsigned int ucon;

    spin_lock_irqsave(&port->lock, flags);

    ucon = rd_regl(port, S3C2410_UCON);

    if (break_state)
        ucon |= S3C2410_UCON_SBREAK;
    else
        ucon &= ~S3C2410_UCON_SBREAK;

    wr_regl(port, S3C2410_UCON, ucon);

    spin_unlock_irqrestore(&port->lock, flags);
}

/* 返回Rx FIFO已存多少資料 */
static int gprs_uart_rx_fifocnt(unsigned long ufstat)
{
    /* 若Rx FIFO已滿,返回FIFO的大小 */
    if (ufstat & S3C2410_UFSTAT_RXFULL)
        return GPRS_UART_FIFO_SIZE;

    /* 若FIFO未滿,返回Rx FIFO已存了多少位元組資料 */
    return (ufstat & S3C2410_UFSTAT_RXMASK) >> S3C2410_UFSTAT_RXSHIFT;
}

#define S3C2410_UERSTAT_PARITY (0x1000)

/* 串列埠接收中斷處理函式,獲取串列埠接收到的資料,並將這些資料遞交給行規則層 */
static irqreturn_t gprs_uart_rx_chars(int irq, void *dev_id)
{
    struct uart_port *port = dev_id;
    struct tty_struct *tty = port->info->tty;
    unsigned int ufcon, ch, flag, ufstat, uerstat;
    int max_count = 64;

    /* 迴圈接收資料,最多一次中斷接收64位元組資料 */
    while (max_count-- > 0)
    {
        ufcon = rd_regl(port, S3C2410_UFCON);
        ufstat = rd_regl(port, S3C2410_UFSTAT);

        /* 若Rx FIFO無資料了,跳出迴圈 */
        if (gprs_uart_rx_fifocnt(ufstat) == 0)
            break;

        /* 讀取Rx error狀態暫存器 */
        uerstat = rd_regl(port, S3C2410_UERSTAT);
        /* 讀取已接受到的資料 */
        ch = rd_regb(port, S3C2410_URXH);

        /* insert the character into the buffer */
        /* 先將tty標誌設為正常 */
        flag = TTY_NORMAL;
        /* 遞增接收字元計數器 */
        port->icount.rx++;

        /* 判斷是否存在Rx error
         * if (unlikely(uerstat & S3C2410_UERSTAT_ANY))等同於
         * if (uerstat & S3C2410_UERSTAT_ANY)
         * 只是unlikely表示uerstat & S3C2410_UERSTAT_ANY的值為假的可能性大一些
         * 另外還有一個likely(value)表示value的值為真的可能性更大一些
         */
        if (unlikely(uerstat & S3C2410_UERSTAT_ANY))
        {
            /* 若break錯誤,遞增icount.brk計算器 */
            if (uerstat & S3C2410_UERSTAT_BREAK)
            {
                port->icount.brk++;
                if (uart_handle_break(port))
                 goto ignore_char;
            }

            /* 若frame錯誤,遞增icount.frame計算器 */
            if (uerstat & S3C2410_UERSTAT_FRAME)
                port->icount.frame++;
            /* 若overrun錯誤,遞增icount.overrun計算器 */
            if (uerstat & S3C2410_UERSTAT_OVERRUN)
                port->icount.overrun++;

            /* 檢視我們是否關心該Rx error
             * port->read_status_mask儲存著我們感興趣的Rx error status
             */
            uerstat &= port->read_status_mask;

            /* 若我們關心該Rx error,則將flag設定為對應的error flag */
            if (uerstat & S3C2410_UERSTAT_BREAK)
                flag = TTY_BREAK;
            else if (uerstat & S3C2410_UERSTAT_PARITY)
                flag = TTY_PARITY;
            else if (uerstat & ( S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_OVERRUN))
                flag = TTY_FRAME;
        }

        /* 處理sys字元 */
        if (uart_handle_sysrq_char(port, ch))
            goto ignore_char;

        /* 將接收到的字元插入到tty裝置的flip緩衝 */
        uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN, ch, flag);

ignore_char:
        continue;
    }
    
    /* 重新整理tty裝置的flip緩衝,將接受到的資料傳給行規則層 */
    tty_flip_buffer_push(tty);

    return IRQ_HANDLED;
}

/* 串列埠傳送中斷處理函式,將使用者空間的資料(儲存在環形緩衝xmit裡)傳送出去 */
static irqreturn_t gprs_uart_tx_chars(int irq, void *dev_id)
{
    struct uart_port *port = dev_id;
    struct circ_buf *xmit = &port->info->xmit;        /* 獲取環線緩衝 */
    int count = 256;

    /* 若設定了xChar字元 */
    if (port->x_char)
    {
        /* 將該xChar傳送出去 */
        wr_regb(port, S3C2410_UTXH, port->x_char);
        /* 遞增傳送計數 */
        port->icount.tx++;
        /* 清除xChar */        
        port->x_char = 0;
        /* 退出中斷處理 */        
        goto out;
    }

    /* 如果沒有更多的字元需要傳送(環形緩衝為空)，
     * 或者uart Tx已停止，
     * 則停止uart並退出中斷處理函式
     */
    if (uart_circ_empty(xmit) || uart_tx_stopped(port))
    {
        gprs_uart_stop_tx(port);
        goto out;
    }

    /* 迴圈傳送資料,直到環形緩衝為空,最多一次中斷髮送256位元組資料 */
    while (!uart_circ_empty(xmit) && count-- > 0)
    {
        /* 若Tx FIFO已滿,退出迴圈 */
        if (rd_regl(port, S3C2410_UFSTAT) & S3C2410_UFSTAT_TXFULL)
            break;

        /* 將要傳送的資料寫入Tx FIFO */
        wr_regb(port, S3C2410_UTXH, xmit->buf[xmit->tail]);
        /* 移向迴圈緩衝中下一要傳送的資料 */
        xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
        port->icount.tx++;
    }

    /* 如果環形緩衝區中剩餘的字元少於WAKEUP_CHARS，喚醒上層 */    
    if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
        uart_write_wakeup(port);

    /* 如果環形緩衝為空，則停止傳送 */
    if (uart_circ_empty(xmit))
        gprs_uart_stop_tx(port);

 out:
    return IRQ_HANDLED;
}

/* 啟動串列埠埠,在開啟該驅動的裝置檔案時會呼叫該函式來申請串列埠中斷,並設定串列埠為可接受,也可傳送 */
static int gprs_uart_startup(struct uart_port *port)
{
    unsigned long flags;
    int ret;
    const char *portname = to_platform_device(port->dev)->name;

    /* 設定串列埠為不可接受,也不可傳送 */
    rx_enabled(port) = 0;
    tx_enabled(port) = 0;

    spin_lock_irqsave(&port->lock, flags);

    /* 申請接收中斷 */
    ret = request_irq(RX_IRQ(port), gprs_uart_rx_chars, 0, portname, port);
    if (ret != 0)
    {
        printk(KERN_ERR "cannot get irq %d\n", RX_IRQ(port));
        return ret;
    }    

    /* 設定串列埠為允許接收 */
    rx_enabled(port) = 1;

    /* 申請傳送中斷 */
    ret = request_irq(TX_IRQ(port), gprs_uart_tx_chars, 0, portname, port);
    if (ret)
    {
        printk(KERN_ERR "cannot get irq %d\n", TX_IRQ(port));
        rx_enabled(port) = 0;
        free_irq(RX_IRQ(port), port);
        goto err;
    }    
    
    /* 設定串列埠為允許傳送 */
    tx_enabled(port) = 1;

err:
    spin_unlock_irqrestore(&port->lock, flags);
    return ret;
}

/* 關閉串列埠,在關閉驅動的裝置檔案時會呼叫該函式,釋放串列埠中斷 */
static void gprs_uart_shutdown(struct uart_port *port)
{
    rx_enabled(port) = 0;                /* 設定串列埠為不允許接收    */
    free_irq(RX_IRQ(port), port);        /* 釋放接收中斷    */
    tx_enabled(port) = 0;                /* 設定串列埠為不允許傳送    */
    free_irq(TX_IRQ(port), port);        /* 釋放傳送中斷    */
}

/* 設定串列埠引數 */
static void gprs_uart_set_termios(struct uart_port *port,
                 struct ktermios *termios,
                 struct ktermios *old)
{
    unsigned long flags;
    unsigned int baud, quot;
    unsigned int ulcon, ufcon = 0;

    /* 不支援moden控制訊號線
     * HUPCL:    關閉時結束通話moden
     * CMSPAR:    mark or space (stick) parity
     * CLOCAL:    忽略任何moden控制線
     */
    termios->c_cflag &= ~(HUPCL | CMSPAR);
    termios->c_cflag |= CLOCAL;

    /* 獲取使用者設定的串列埠波特率,並計算分頻數(串列埠波特率除數quot) */
    baud = uart_get_baud_rate(port, termios, old, 0, 115200*8);
    if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
        quot = port->custom_divisor;
    else
        quot = port->uartclk / baud / 16 - 1;

    /* 設定資料字長 */
    switch (termios->c_cflag & CSIZE)
    {
    case CS5:
        ulcon = S3C2410_LCON_CS5;
        break;
    case CS6:
        ulcon = S3C2410_LCON_CS6;
        break;
    case CS7:
        ulcon = S3C2410_LCON_CS7;
        break;
    case CS8:
    default:
        ulcon = S3C2410_LCON_CS8;
        break;
    }

    /* 是否要求設定兩個停止位(CSTOPB) */        
    if (termios->c_cflag & CSTOPB)
        ulcon |= S3C2410_LCON_STOPB;

    /* 是否使用奇偶檢驗 */
    if (termios->c_cflag & PARENB)
    {
        if (termios->c_cflag & PARODD)  /* 奇校驗 */
            ulcon |= S3C2410_LCON_PODD;
        else                            /* 偶校驗 */
            ulcon |= S3C2410_LCON_PEVEN;
    }
    else                                /* 無校驗 */
    {
        ulcon |= S3C2410_LCON_PNONE;
    }

    if (port->fifosize > 1)
        ufcon |= S3C2410_UFCON_FIFOMODE | S3C2410_UFCON_RXTRIG8;

    spin_lock_irqsave(&port->lock, flags);

    /* 設定FIFO控制暫存器、線控制暫存器和波特率除數暫存器 */
    wr_regl(port, S3C2410_UFCON, ufcon);
    wr_regl(port, S3C2410_ULCON, ulcon);
    wr_regl(port, S3C2410_UBRDIV, quot);

    /* 更新串列埠FIFO的超時時限 */
    uart_update_timeout(port, termios->c_cflag, baud);

    /* 設定我們感興趣的Rx error */
    port->read_status_mask = S3C2410_UERSTAT_OVERRUN;
    if (termios->c_iflag & INPCK)
        port->read_status_mask |= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;

    /* 設定我們忽略的Rx error */
    port->ignore_status_mask = 0;
    if (termios->c_iflag & IGNPAR)
        port->ignore_status_mask |= S3C2410_UERSTAT_OVERRUN;
    if (termios->c_iflag & IGNBRK && termios->c_iflag & IGNPAR)
        port->ignore_status_mask |= S3C2410_UERSTAT_FRAME;

    /* 若未設定CREAD(使用接收器),則忽略所有Rx error*/
    if ((termios->c_cflag & CREAD) == 0)
        port->ignore_status_mask |= RXSTAT_DUMMY_READ;

    spin_unlock_irqrestore(&port->lock, flags);
}

/* 獲取串列埠型別 */
static const char *gprs_uart_type(struct uart_port *port)
{/* 返回描述串列埠型別的字串指標 */
    return port->type == PORT_S3C2410 ? "gprs_uart:s3c2410_uart2" : NULL;
}

/* 申請串列埠一些必要的資源,如IO埠/IO記憶體資源,必要時還可以重新對映串列埠埠 */
static int gprs_uart_request_port(struct uart_port *port)
{
    struct resource *res;
    const char *name = to_platform_device(port->dev)->name;

    /* request_mem_region請求分配IO記憶體,從開始port->mapbase,大小MAP_SIZE
     * port->mapbase儲存當前串列埠的暫存器基地址(物理)
     * uart2: 0x50008000
     */
    res = request_mem_region(port->mapbase, MAP_SIZE, name);
    if (res == NULL)
    {
        printk(KERN_ERR"request_mem_region error: %p\n", res);
        return -EBUSY;
    }
    
    return 0;
}

/* 釋放串列埠已申請的IO埠/IO記憶體資源,必要時還需iounmap */
static void gprs_uart_release_port(struct uart_port *port)
{
    /* 釋放已分配IO記憶體 */
    release_mem_region(port->mapbase, MAP_SIZE);
}

/* 執行串列埠所需的自動配置 */
static void gprs_uart_config_port(struct uart_port *port, int flags)
{    
    int retval;

    /* 請求串列埠 */
    retval = gprs_uart_request_port(port);
    /* 設定串列埠型別 */
    if (flags & UART_CONFIG_TYPE && retval == 0)
        port->type = PORT_S3C2410;
}

/* The UART operations structure */
static struct uart_ops gprs_uart_ops = {
    .start_tx        = gprs_uart_start_tx,      /* Start transmitting */
    .stop_tx        = gprs_uart_stop_tx,        /* Stop transmission */
    .stop_rx        = gprs_uart_stop_rx,        /* Stop reception */
    .enable_ms        = gprs_uart_enable_ms,    /* Enable modem status signals */
    .tx_empty        = gprs_uart_tx_empty,      /* Transmitter busy? */
    .get_mctrl        = gprs_uart_get_mctrl,    /* Get modem control */
    .set_mctrl        = gprs_uart_set_mctrl,    /* Set modem control */
    .break_ctl        = gprs_uart_break_ctl,    /* Set break signal */
    .startup        = gprs_uart_startup,        /* App opens GPRS_UART */
    .shutdown        = gprs_uart_shutdown,      /* App closes GPRS_UART */
    .set_termios    = gprs_uart_set_termios,    /* Set termios */
    .type            = gprs_uart_type,          /* Get UART type */
    .request_port    = gprs_uart_request_port,  /* Claim resources associated with a GPRS_UART port */
    .release_port    = gprs_uart_release_port,  /* Release resources associated with a GPRS_UART port */
    .config_port    = gprs_uart_config_port,    /* Configure when driver adds a GPRS_UART port */
};

/* Uart driver for GPRS_UART */
static struct uart_driver gprs_uart_driver = {
    .owner = THIS_MODULE,                /* Owner */
    .driver_name = DEV_NAME,             /* Driver name */
    .dev_name = DEV_NAME,                /* Device node name */
    .major = GPRS_UART_MAJOR,            /* Major number */
    .minor = GPRS_UART_MINOR,            /* Minor number start */
    .nr = 1,                             /* Number of UART ports */
};

/* Uart port for GPRS_UART port */
static struct uart_port gprs_uart_port = {
        .irq        = IRQ_S3CUART_RX2,           /* IRQ */
        .fifosize    = GPRS_UART_FIFO_SIZE,      /* Size of the FIFO */
        .iotype        = UPIO_MEM,               /* IO memory */
        .flags        = UPF_BOOT_AUTOCONF,       /* UART port flag */
        .ops        = &gprs_uart_ops,            /* UART operations */
        .line        = 0,                        /* UART port number */
        .lock        = __SPIN_LOCK_UNLOCKED(gprs_uart_port.lock),
};

/* 初始化指定串列埠埠 */
static int gprs_uart_init_port(struct uart_port *port, struct platform_device *platdev)
{
    unsigned long flags;
    unsigned int gphcon;
    
    if (platdev == NULL)
        return -ENODEV;

    port->dev        = &platdev->dev;

    /* 設定串列埠波特率時鐘頻率 */
    port->uartclk    = clk_get_rate(clk_get(&platdev->dev, "pclk"));

    /* 設定串列埠的暫存器基地址(物理): 0x50008000 */
    port->mapbase    = S3C2410_PA_UART2;
    
    /* 設定當前串列埠的暫存器基地址(虛擬): 0xF5008000 */        
    port->membase    = S3C24XX_VA_UART + (S3C2410_PA_UART2 - S3C24XX_PA_UART);

    spin_lock_irqsave(&port->lock, flags);

    wr_regl(port, S3C2410_UCON, S3C2410_UCON_DEFAULT);
    wr_regl(port, S3C2410_ULCON, S3C2410_LCON_CS8 | S3C2410_LCON_PNONE);
    wr_regl(port, S3C2410_UFCON, S3C2410_UFCON_FIFOMODE
        | S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_RESETBOTH);

    /* 將I/O port H的gph6和gph7設定為TXD2和RXD2 */
    gphcon = readl(S3C2410_GPHCON);
    gphcon &= ~((0x5) << 12);
    writel(gphcon, S3C2410_GPHCON);
    
    spin_unlock_irqrestore(&port->lock, flags);
    
    return 0;
}

/* Platform driver probe */
static int __init gprs_uart_probe(struct platform_device *dev)
{
    int ret;
    
    /* 初始化串列埠 */
    ret = gprs_uart_init_port(&gprs_uart_port, dev);
    if (ret < 0)
    {
        printk(KERN_ERR"gprs_uart_probe: gprs_uart_init_port error: %d\n", ret);
        return ret;
    }    

    /* 新增串列埠 */
    ret = uart_add_one_port(&gprs_uart_driver, &gprs_uart_port);
    if (ret < 0)
    {
        printk(KERN_ERR"gprs_uart_probe: uart_add_one_port error: %d\n", ret);
        return ret;    
    }

    /* 將串列埠uart_port結構體儲存在platform_device->dev->driver_data中 */
    platform_set_drvdata(dev, &gprs_uart_port);

    return 0;
}

/* Called when the platform driver is unregistered */
static int gprs_uart_remove(struct platform_device *dev)
{
    platform_set_drvdata(dev, NULL);

    /* 移除串列埠 */
    uart_remove_one_port(&gprs_uart_driver, &gprs_uart_port);
    return 0;
}

/* Suspend power management event */
static int gprs_uart_suspend(struct platform_device *dev, pm_message_t state)
{
    uart_suspend_port(&gprs_uart_driver, &gprs_uart_port);
    return 0;
}

/* Resume after a previous suspend */
static int gprs_uart_resume(struct platform_device *dev)
{
    uart_resume_port(&gprs_uart_driver, &gprs_uart_port);
    return 0;
}

/* Platform driver for GPRS_UART */
static struct platform_driver gprs_plat_driver = {
    .probe = gprs_uart_probe,                /* Probe method */
    .remove = __exit_p(gprs_uart_remove),    /* Detach method */
    .suspend = gprs_uart_suspend,            /* Power suspend */
    .resume = gprs_uart_resume,              /* Resume after a suspend */
    .driver = {
        .owner    = THIS_MODULE,
        .name = DEV_NAME,                    /* Driver name */
    },
};

/* Platform device for GPRS_UART */
struct platform_device *gprs_plat_device; 

static int __init gprs_init_module(void)
{
    int retval;

    /* Register uart_driver for GPRS_UART */
    retval = uart_register_driver(&gprs_uart_driver);
    if (0 != retval)
    {
        printk(KERN_ERR "gprs_init_module: can't register the GPRS_UART driver %d\n", retval);
        return retval;
    }

    /* Register platform device for GPRS_UART. Usually called
    during architecture-specific setup */
    gprs_plat_device = platform_device_register_simple(DEV_NAME, 0, NULL, 0);
    if (IS_ERR(gprs_plat_device)) 
    {
        retval = PTR_ERR(gprs_plat_device);
        printk(KERN_ERR "gprs_init_module: can't register platform device %d\n", retval);
        goto fail_reg_plat_dev;
    }

    /* Announce a matching driver for the platform
    devices registered above */
    retval = platform_driver_register(&gprs_plat_driver);
    if (0 != retval)
    {
        printk(KERN_ERR "gprs_init_module: can't register platform driver %d\n", retval);
        goto fail_reg_plat_drv;
    }

    return 0; /* succeed */

fail_reg_plat_drv:
    platform_device_unregister(gprs_plat_device);
fail_reg_plat_dev:
    uart_unregister_driver(&gprs_uart_driver);
    return retval;
}

static void __exit gprs_exit_module(void)
{
    /* The order of unregistration is important. Unregistering the
    UART driver before the platform driver will crash the system */

    /* Unregister the platform driver */
    platform_driver_unregister(&gprs_plat_driver);

    /* Unregister the platform devices */
    platform_device_unregister(gprs_plat_device);

    /* Unregister the GPRS_UART driver */
    uart_unregister_driver(&gprs_uart_driver);
}

module_init(gprs_init_module);
module_exit(gprs_exit_module);

MODULE_AUTHOR("lingd");
MODULE_LICENSE("Dual BSD/GPL");