#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()

/* 写32位宽的寄存器 */

#define wr_regl(port, reg, val) \

    do { iowrite32(val, portaddr(port, reg)); } while()

/* 禁止串口发送数据 */

static void gprs_uart_stop_tx(struct uart_port *port)

{

    if (tx_enabled(port))            /* 若串口已启动发送 */

    {

        disable_irq(TX_IRQ(port));   /* 禁止发送中断 */

        tx_enabled(port) = ;        /* 设置串口为未启动发送 */

    }

}

/* 使能串口发送数据 */

static void gprs_uart_start_tx(struct uart_port *port)

{

    if (!tx_enabled(port))           /* 若串口未启动发送 */

    {

        enable_irq(TX_IRQ(port));    /* 使能发送中断 */

        tx_enabled(port) = ;        /* 设置串口为已启动发送 */

    }

}

/* 禁止串口接收数据 */

static void gprs_uart_stop_rx(struct uart_port *port)

{

    if (rx_enabled(port))            /* 若串口已启动接收 */

    {

        disable_irq(RX_IRQ(port));   /* 禁止接收中断 */

        rx_enabled(port) = ;        /* 设置串口为未启动接收 */

    }

}

/* 使能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 = ;

    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

                (ufstat & S3C2410_UFSTAT_TXFULL))       /* FIFO满 */

            ret = ;

    }

    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字节数据 */

    while (max_count-- > )

    {

        ufcon = rd_regl(port, S3C2410_UFCON);

        ufstat = rd_regl(port, S3C2410_UFSTAT);

        /* 若Rx FIFO无数据了,跳出循环 */

        if (gprs_uart_rx_fifocnt(ufstat) == )

            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 = ;

    /* 若设置了xChar字符 */

    if (port->x_char)

    {

        /* 将该xChar发送出去 */

        wr_regb(port, S3C2410_UTXH, port->x_char);

        /* 递增发送计数 */

        port->icount.tx++;

        /* 清除xChar */

        port->x_char = ;

        /* 退出中断处理 */

        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-- > )

    {

        /* 若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 + ) & (UART_XMIT_SIZE - );

        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) = ;

    tx_enabled(port) = ;

    spin_lock_irqsave(&port->lock, flags);

    /* 申请接收中断 */

    ret = request_irq(RX_IRQ(port), gprs_uart_rx_chars, , portname, port);

    if (ret != )

    {

        printk(KERN_ERR "cannot get irq %d\n", RX_IRQ(port));

        return ret;

    }    

    /* 设置串口为允许接收 */

    rx_enabled(port) = ;

    /* 申请发送中断 */

    ret = request_irq(TX_IRQ(port), gprs_uart_tx_chars, , portname, port);

    if (ret)

    {

        printk(KERN_ERR "cannot get irq %d\n", TX_IRQ(port));

        rx_enabled(port) = ;

        free_irq(RX_IRQ(port), port);

        goto err;

    }    

    /* 设置串口为允许发送 */

    tx_enabled(port) = ;

err:

    spin_unlock_irqrestore(&port->lock, flags);

    return ret;

}

/* 关闭串口,在关闭驱动的设备文件时会调用该函数,释放串口中断 */

static void gprs_uart_shutdown(struct uart_port *port)

{

    rx_enabled(port) = ;                /* 设置串口为不允许接收    */

    free_irq(RX_IRQ(port), port);        /* 释放接收中断    */

    tx_enabled(port) = ;                /* 设置串口为不允许发送    */

    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 = ;

    /* 不支持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, , *);

    if (baud ==  && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)

        quot = port->custom_divisor;

    else

        quot = port->uartclk / baud /  - ;

    /* 设置数据字长 */

    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 > )

        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 = ;

    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) == )

        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 ;

}

/* 释放串口已申请的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 == )

        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 = ,                             /* 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        = ,                        /* 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) << );

    writel(gphcon, S3C2410_GPHCON);

    spin_unlock_irqrestore(&port->lock, flags);

    return ;

}

/* 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 < )

    {

        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 < )

    {

        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 ;

}

/* 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 ;

}

/* 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 ;

}

/* Resume after a previous suspend */

static int gprs_uart_resume(struct platform_device *dev)

{

    uart_resume_port(&gprs_uart_driver, &gprs_uart_port);

    return ;

}

/* 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 ( != 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, , NULL, );

    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 ( != retval)

    {

        printk(KERN_ERR "gprs_init_module: can't register platform driver %d\n", retval);

        goto fail_reg_plat_drv;

    }

    return ; /* 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");

s3c2440串口驱动是在drivers/tty/serial/Samsung.c下定义的。

static int __init s3c24xx_serial_modinit(void)

{

int ret;

//注册uart驱动

ret = uart_register_driver(&s3c24xx_uart_drv);

if (ret < ) {

printk(KERN_ERR"failed to register UART driver\n");

return -;

}

//注册平台驱动

returnplatform_driver_register(&samsung_serial_driver);

}

uart驱动的结构为：

static struct uart_driver s3c24xx_uart_drv = {

.owner = THIS_MODULE,

.driver_name = "s3c2410_serial", //驱动名，在/proc/tty/driver/目录下显示的名字

.nr = CONFIG_SERIAL_SAMSUNG_UARTS, //uart的端口数

.cons = S3C24XX_SERIAL_CONSOLE,

.dev_name = S3C24XX_SERIAL_NAME, //设备名——ttySAC

.major = S3C24XX_SERIAL_MAJOR, //主设备号——204

.minor = S3C24XX_SERIAL_MINOR, //次设备号——64

};

平台驱动的结构为：

static struct platform_drivers amsung_serial_driver = {

.probe = s3c24xx_serial_probe,

.remove = __devexit_p(s3c24xx_serial_remove),

.id_table = s3c24xx_serial_driver_ids,

.driver = {

.name = "samsung-uart",

.owner = THIS_MODULE,

.pm = SERIAL_SAMSUNG_PM_OPS,

.of_match_table = s3c24xx_uart_dt_match,

},

};

知道了平台驱动，那它所对应的平台设备是什么呢？在平台驱动结构中，如果定义了id_table，则需要匹配与id_table列表中一致的设备，如果没有定义id_table，则需要匹配与name一致的设备名。因为在这里定义了.id_table = s3c24xx_serial_driver_ids,，所以系统要匹配与串口驱动列表s3c24xx_serial_driver_ids中定义的驱动名一致的设备名。

static struct platform_device_id s3c24xx_serial_driver_ids[] = {

……

{

.name = "s3c2440-uart",

.driver_data = S3C2440_SERIAL_DRV_DATA,

},

……

{},

};

由于本开发板是s3c2440，因此设备名一定是s3c2440-uart。另外.driver_data成员主要定义了一些配置s3c2440串口寄存器的数据。

下面介绍一下linux是如何定义串口平台设备的。

在Mach-zhaocj2440.c（在arch/arm/mach-s3c24xx目录下）文件中定义了zhaocj2440_uartcfgs数组（即s3c2440中的三个uart端口寄存器），并且在zhaocj2440_map_io函数内调用s3c24xx_init_uarts函数对其进行初始化，而zhaocj2440_map_io是在MACHINE_START中被赋予.map_io，因此系统一旦启动，开发板上的串口就会被初始化。

我们再来看看uart是如何初始化的。在s3c24xx_init_uarts函数内通过cpu->init_uarts调用s3c244x_init_uarts函数（在arch/arm/mach-s3c24xx/S3c244x.c文件内），而在该函数内又调用s3c24xx_init_uartdevs函数，如：

void __init s3c244x_init_uarts(struct s3c2410_uartcfg *cfg, int no)

{

s3c24xx_init_uartdevs("s3c2440-uart", s3c2410_uart_resources, cfg, no);

}

我们发现传递给s3c24xx_init_uartdevs函数的第一个参数正是"s3c2440-uart"，与上文我们分析的uart平台驱动名是一致的。而第二个参数是串口资源，主要定义了串口寄存器的地址及中断矢量。s3c24xx_init_uartdevs函数（在arch/arm/plat-samsung/Init.c文件内）具体负责uart平台设备的赋值，即定义uart的设备名和端口资源，其中通过platdev->name =name;语句使平台设备的名字为"s3c2440-uart"，这样平台设备和平台驱动就匹配了。并且系统又通过s3c_arch_init函数（仍然在Init.c文件内）调用platform_add_devices函数，使刚刚定义的串口平台设备s3c24xx_uart_devs添加到系统平台设备表中，从而最终完成串口平台设备的定义。

我们再回过头来继续介绍uart的平台驱动。

当设备和驱动匹配上了后，系统会调用s3c24xx_serial_probe函数。

static int s3c24xx_serial_probe(struct platform_device *pdev)

{

structs3c24xx_uart_port *ourport;

intret;

dbg("s3c24xx_serial_probe(%p) %d\n", pdev,probe_index);

//逐一得到s3c2440的uart端口结构——s3c24xx_serial_ports，即s3c2440有几个uart端口，s3c24xx_serial_probe就会被调用几次

ourport= &s3c24xx_serial_ports[probe_index];

//得到驱动数据

ourport->drv_data= s3c24xx_get_driver_data(pdev);

if(!ourport->drv_data) {

dev_err(&pdev->dev,"could not find driver data\n");

return-ENODEV;

}

//得到s3c2440的串口驱动数据信息，即s3c2440_serial_drv_data结构中的info成员信息

ourport->info= ourport->drv_data->info;

//得到uart的相关寄存器

ourport->cfg= (pdev->dev.platform_data) ?

(structs3c2410_uartcfg*)pdev->dev.platform_data :

ourport->drv_data->def_cfg;

//得到uart端口的fifo大小

ourport->port.fifosize= (ourport->info->fifosize) ?

ourport->info->fifosize:

ourport->drv_data->fifosize[probe_index];

probe_index++;

dbg("%s:initialising port %p...\n", __func__, ourport);

//初始化uart的端口

ret= s3c24xx_serial_init_port(ourport,pdev);

if(ret < )

gotoprobe_err;

dbg("%s:adding port\n", __func__);

//添加定义好驱动数据的串行端口

uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);

//设置平台驱动数据

platform_set_drvdata(pdev,&ourport->port);

//创建系统文件及属性

ret= device_create_file(&pdev->dev, &dev_attr_clock_source);

if(ret < )

dev_err(&pdev->dev,"failed to add clock source attr.\n");

ret= s3c24xx_serial_cpufreq_register(ourport);

if(ret < )

dev_err(&pdev->dev,"failed to add cpufreq notifier\n");

return0;

probe_err:

returnret;

}

在s3c24xx_serial_probe函数内，涉及到了两个重要的结构：s3c24xx_serial_ports和s3c2440_serial_drv_data：

static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS]= {

[]= { //端口0

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[].port.lock),

.iotype = UPIO_MEM,

.uartclk = , //时钟值

.fifosize = , //FIFO缓存区大小

.ops = &s3c24xx_serial_ops, //串口相关操作

.flags = UPF_BOOT_AUTOCONF,

.line = , //线路

}

},

[]= { //端口1

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[].port.lock),

.iotype = UPIO_MEM,

.uartclk = ,

.fifosize = ,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = ,

}

},

#if CONFIG_SERIAL_SAMSUNG_UARTS > 2

[]= { //端口2

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[].port.lock),

.iotype = UPIO_MEM,

.uartclk = ,

.fifosize = ,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = ,

}

},

#endif

#if CONFIG_SERIAL_SAMSUNG_UARTS > 3

[]= {

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[].port.lock),

.iotype = UPIO_MEM,

.uartclk = ,

.fifosize = ,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = ,

}

}

#endif

};

static struct s3c24xx_serial_drv_data s3c2440_serial_drv_data= {

.info= &(struct s3c24xx_uart_info){ //uart信息

.name = "Samsung S3C2440 UART",

.type = PORT_S3C2440,

.fifosize = ,

.has_divslot = ,

.rx_fifomask = S3C2440_UFSTAT_RXMASK,

.rx_fifoshift = S3C2440_UFSTAT_RXSHIFT,

.rx_fifofull = S3C2440_UFSTAT_RXFULL,

.tx_fifofull = S3C2440_UFSTAT_TXFULL,

.tx_fifomask = S3C2440_UFSTAT_TXMASK,

.tx_fifoshift = S3C2440_UFSTAT_TXSHIFT,

.def_clk_sel = S3C2410_UCON_CLKSEL2,

.num_clks = ,

.clksel_mask = S3C2412_UCON_CLKMASK,

.clksel_shift = S3C2412_UCON_CLKSHIFT,

},

.def_cfg= &(struct s3c2410_uartcfg){ //定义缺省的uart寄存器值

.ucon = S3C2410_UCON_DEFAULT,

.ufcon = S3C2410_UFCON_DEFAULT,

},

};

在s3c24xx_serial_ports中，定义了串口相关操作——s3c24xx_serial_ops：

static struct uart_ops s3c24xx_serial_ops = {

.pm = s3c24xx_serial_pm, //电源管理

.tx_empty = s3c24xx_serial_tx_empty, //发送缓存区空

.get_mctrl = s3c24xx_serial_get_mctrl, //得到modem控制设置

.set_mctrl = s3c24xx_serial_set_mctrl, //设置modem控制

.stop_tx = s3c24xx_serial_stop_tx, //停止发送

.start_tx = s3c24xx_serial_start_tx, //开始发送

.stop_rx = s3c24xx_serial_stop_rx, //停止接受

.enable_ms = s3c24xx_serial_enable_ms, //modem状态中断使能

.break_ctl = s3c24xx_serial_break_ctl, //控制break信号的传输

.startup = s3c24xx_serial_startup, //启动端口

.shutdown = s3c24xx_serial_shutdown, //禁止端口

.set_termios = s3c24xx_serial_set_termios, //设置端口参数

.type = s3c24xx_serial_type, //返回描述特定端口的常量字符串指针

.release_port = s3c24xx_serial_release_port, //释放端口所占的内存和资源

.request_port = s3c24xx_serial_request_port, //申请端口所需的内存和资源

.config_port = s3c24xx_serial_config_port, //配置端口

.verify_port = s3c24xx_serial_verify_port, //验证端口

};

在这里，我们只分析s3c24xx_serial_startup函数和s3c24xx_serial_set_termios函数。

static int s3c24xx_serial_startup(struct uart_port *port)

{

structs3c24xx_uart_port *ourport= to_ourport(port);

intret;

dbg("s3c24xx_serial_startup: port=%p(%08lx,%p)\n",

port->mapbase, port->membase);

rx_enabled(port) = ; //接收数据使能

//申请接收数据中断，s3c24xx_serial_rx_chars为中断处理函数

ret =request_irq(ourport->rx_irq, s3c24xx_serial_rx_chars,,

s3c24xx_serial_portname(port),ourport);

if(ret != ) {

printk(KERN_ERR"cannot get irq %d\n", ourport->rx_irq);

returnret;

}

ourport->rx_claimed= ; //���志

dbg("requestingtx irq...\n");

tx_enabled(port)= ; //发送数据使能

//申请发送数据中断，s3c24xx_serial_tx_chars为中断处理函数

ret= request_irq(ourport->tx_irq, s3c24xx_serial_tx_chars,,

s3c24xx_serial_portname(port),ourport);

if(ret) {

printk(KERN_ERR"cannot get irq %d\n", ourport->tx_irq);

gotoerr;

}

ourport->tx_claimed= ; //标志

dbg("s3c24xx_serial_startup ok\n");

/*the port reset code should have done the correct

* register setup for the port controls */

returnret;

err:

s3c24xx_serial_shutdown(port);

returnret;

}

static void s3c24xx_serial_set_termios(struct uart_port *port,

struct ktermios *termios,

struct ktermios *old)

{

structs3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);

structs3c24xx_uart_port *ourport =to_ourport(port);

structclk *clk = NULL;

unsignedlong flags;

unsignedint baud, quot, clk_sel = ;

unsignedint ulcon;

unsignedint umcon;

unsignedint udivslot = ;

/*

* We don't support modem control lines.

*/

//不支持modem控制线

termios->c_cflag&= ~(HUPCL | CMSPAR);

termios->c_cflag|= CLOCAL;

/*

* Ask the core to calculate the divisor forus.

*/

//请求内核计算分频以便产生对应的波特率

baud= uart_get_baud_rate(port, termios, old, , *);

quot= s3c24xx_serial_getclk(ourport,baud, &clk, &clk_sel);

if(baud ==  && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)

quot= port->custom_divisor;

if(!clk)

return;

/*check to see if we need to change clocksource */

//检查是否需要改变时钟源

if(ourport->baudclk != clk) {

s3c24xx_serial_setsource(port, clk_sel);

if(ourport->baudclk != NULL && !IS_ERR(ourport->baudclk)) {

clk_disable(ourport->baudclk);

ourport->baudclk = NULL;

}

clk_enable(clk);

ourport->baudclk= clk;

ourport->baudclk_rate= clk ? clk_get_rate(clk) : ;

}

if(ourport->info->has_divslot) {

unsignedint div = ourport->baudclk_rate / baud;

if(cfg->has_fracval) {

udivslot= (div & );

dbg("fracval= %04x\n", udivslot);

}else {

udivslot= udivslot_table[div & ];

dbg("udivslot= %04x (div %d)\n", udivslot, div & );

}

}

//设置字长

switch(termios->c_cflag & CSIZE) {

caseCS5:

dbg("config:5bits/char\n");

ulcon= S3C2410_LCON_CS5;

break;

caseCS6:

dbg("config:6bits/char\n");

ulcon= S3C2410_LCON_CS6;

break;

caseCS7:

dbg("config:7bits/char\n");

ulcon= S3C2410_LCON_CS7;

break;

caseCS8:

default:

dbg("config:8bits/char\n");

ulcon= S3C2410_LCON_CS8;

break;

}

/*preserve original lcon IR settings */

//保留以前的lcon的IR设置

ulcon|= (cfg->ulcon & S3C2410_LCON_IRM);

//设置停止位

if(termios->c_cflag & CSTOPB)

ulcon|= S3C2410_LCON_STOPB;

//设置是否采用RTS、CTS自动流控制

umcon= (termios->c_cflag & CRTSCTS) ? S3C2410_UMCOM_AFC : ;

//设置奇偶校验位

if(termios->c_cflag & PARENB) {

if(termios->c_cflag & PARODD)

ulcon|= S3C2410_LCON_PODD; //奇校验

else

ulcon|= S3C2410_LCON_PEVEN; //偶校验

}else {

ulcon|= S3C2410_LCON_PNONE; //不校验

}

spin_lock_irqsave(&port->lock,flags);

dbg("settingulcon to %08x, brddiv to %d, udivslot %08x\n",

ulcon, quot, udivslot);

//写入寄存器

wr_regl(port,S3C2410_ULCON, ulcon);

wr_regl(port,S3C2410_UBRDIV, quot);

wr_regl(port,S3C2410_UMCON, umcon);

if(ourport->info->has_divslot)

wr_regl(port,S3C2443_DIVSLOT, udivslot);

dbg("uart:ulcon = 0x%08x, ucon = 0x%08x, ufcon = 0x%08x\n",

rd_regl(port, S3C2410_ULCON),

rd_regl(port, S3C2410_UCON),

rd_regl(port, S3C2410_UFCON));

/*

* Update the per-port timeout.

*/

//更新端口超时

uart_update_timeout(port,termios->c_cflag, baud);

/*

* Which character status flags are weinterested in?

*/

//对哪些字符状态标志感兴趣

port->read_status_mask= S3C2410_UERSTAT_OVERRUN;

if(termios->c_iflag & INPCK)

port->read_status_mask|= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;

/*

* Which character status flags should weignore?

*/

//可以忽略哪些字符状态标志

port->ignore_status_mask= ;

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;

/*

* Ignore all characters if CREAD is not set.

*/

//如果CREAD未设置，忽略所有字符

if((termios->c_cflag & CREAD) == )

port->ignore_status_mask|= RXSTAT_DUMMY_READ;

spin_unlock_irqrestore(&port->lock,flags);

}

下面再来介绍串口接收和发送中断处理函数。

static irqreturn_t s3c24xx_serial_rx_chars(intirq, void *dev_id)

{

structs3c24xx_uart_port *ourport= dev_id;

struct uart_port *port =&ourport->port;

struct tty_struct*tty = port->state->port.tty;

unsignedint ufcon, ch, flag, ufstat, uerstat;

intmax_count = ;

while(max_count-- > ) {

ufcon= rd_regl(port, S3C2410_UFCON);

ufstat= rd_regl(port, S3C2410_UFSTAT);

//如果接收到0个字符，则退出

if(s3c24xx_serial_rx_fifocnt(ourport,ufstat) == )

break;

uerstat= rd_regl(port, S3C2410_UERSTAT); //读取错误状态信息

ch= rd_regb(port, S3C2410_URXH); //，读取字符，接收数据

if(port->flags & UPF_CONS_FLOW) {

inttxe = s3c24xx_serial_txempty_nofifo(port);

if(rx_enabled(port)) { //如果接收端口为使能状态

if(!txe) { //如果发送缓存为空

rx_enabled(port)= ; //设置接收端口为无效状态

continue;

}

}else { //接收端口为无效状态

if(txe) { //如果发送缓存不为空

ufcon|= S3C2410_UFCON_RESETRX;

wr_regl(port,S3C2410_UFCON, ufcon); //发送缓存复位，即清空

rx_enabled(port)= ; //设置接收端口为使能状态

gotoout;

}

continue;

}

}

/*insert the character into the buffer */

//将接收到的字符写入进buffer中

flag = TTY_NORMAL;

port->icount.rx++;

//如果接收字符时，发生了任何一种错误

if(unlikely(uerstat & S3C2410_UERSTAT_ANY)){

dbg("rxerr: port ch=0x%02x,rxs=0x%08x\n",

ch, uerstat);

/*check for break */

//发生了break错误

if(uerstat & S3C2410_UERSTAT_BREAK){

dbg("break!\n");

port->icount.brk++;

if(uart_handle_break(port))

goto ignore_char;

}

if(uerstat & S3C2410_UERSTAT_FRAME) //发生了帧错误

port->icount.frame++;

if(uerstat & S3C2410_UERSTAT_OVERRUN) //发生了溢出错误

port->icount.overrun++;

uerstat&= port->read_status_mask;

if(uerstat & S3C2410_UERSTAT_BREAK)

flag= TTY_BREAK;

elseif (uerstat & S3C2410_UERSTAT_PARITY)

flag= TTY_PARITY;

elseif (uerstat & (S3C2410_UERSTAT_FRAME|

S3C2410_UERSTAT_OVERRUN))

flag = TTY_FRAME;

}

if(uart_handle_sysrq_char(port, ch))

gotoignore_char;

//把字符插入到tty设备的flip缓存

uart_insert_char(port,uerstat, S3C2410_UERSTAT_OVERRUN,

ch, flag);

ignore_char:

continue;

}

tty_flip_buffer_push(tty); //刷新tty设备的flip设备

out:

returnIRQ_HANDLED;

}

static irqreturn_t s3c24xx_serial_tx_chars(intirq, void *id)

{

structs3c24xx_uart_port *ourport= id;

struct uart_port *port =&ourport->port;

struct circ_buf*xmit = &port->state->xmit;

intcount = ; //一次最多发送256个字符

if(port->x_char) { //如果有待发送的字符，则发送

wr_regb(port, S3C2410_UTXH, port->x_char);

port->icount.tx++;

port->x_char = ;

goto out;

}

/*if there isn't anything more to transmit, or the uart is now

* stopped, disable the uart and exit

*/

//如果没有更多的字符需要发送，或者uart的tx停止，则停止uart并退出

if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {

s3c24xx_serial_stop_tx(port);

gotoout;

}

/*try and drain the buffer... */

//尝试把环形buffer中的数据发空

while(!uart_circ_empty(xmit) && count-- > ) {

if(rd_regl(port, S3C2410_UFSTAT)& ourport->info->tx_fifofull)

break;

wr_regb(port,S3C2410_UTXH,xmit->buf[xmit->tail]);

xmit->tail = (xmit->tail + ) &(UART_XMIT_SIZE - );

port->icount.tx++;

}

//如果环形缓存中剩余的字符少于WAKEUP_CHARS，唤醒上层

if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)

uart_write_wakeup(port);

if(uart_circ_empty(xmit)) //如果发送环形buffer为空

s3c24xx_serial_stop_tx(port); //停止发送

out:

returnIRQ_HANDLED;

}

最后，我们再来看串口驱动的核心层文件——Serial_core.c（在drivers/tty/serial目录下）。前面介绍的在Samsung.c中调用的许多与底层打交道的函数都是在Serial_core.c内定义的，如

uart_register_driver函数，uart_add_one_port函数，uart_insert_char函数。

在uart_register_driver函数中，设置了uart_ops，它负责对uart镜像一系列操作。

static const struct tty_operations uart_ops= {

.open = uart_open, //打开串口

.close = uart_close, //关闭串口

.write = uart_write, //发送串口数据

.put_char = uart_put_char,

.flush_chars = uart_flush_chars,

.write_room = uart_write_room,

.chars_in_buffer=uart_chars_in_buffer,

.flush_buffer = uart_flush_buffer,

.ioctl = uart_ioctl,

.throttle = uart_throttle,

.unthrottle = uart_unthrottle,

.send_xchar = uart_send_xchar,

.set_termios = uart_set_termios,

.set_ldisc = uart_set_ldisc,

.stop = uart_stop,

.start = uart_start,

.hangup = uart_hangup,

.break_ctl = uart_break_ctl,

.wait_until_sent=uart_wait_until_sent,

#ifdef CONFIG_PROC_FS

.proc_fops = &uart_proc_fops,

#endif

.tiocmget = uart_tiocmget,

.tiocmset = uart_tiocmset,

.get_icount = uart_get_icount,

#ifdef CONFIG_CONSOLE_POLL

.poll_init = uart_poll_init,

.poll_get_char = uart_poll_get_char,

.poll_put_char = uart_poll_put_char,

#endif

};

  原文链接：http://www.linuxidc.com/Linux/2013-10/91993p7.htm