struct fb_info {

    int node;

    int flags;

    struct fb_var_screeninfo var;/*LCD可变参数结构体*/

    struct fb_fix_screeninfo fix;/*LCD固定参数结构体*/

    struct fb_monspecs monspecs; /*LCD显示器标准*/

    struct work_struct queue;    /*帧缓冲事件队列*/

    struct fb_pixmap pixmap;     /*图像硬件mapper*/

    struct fb_pixmap sprite;     /*光标硬件mapper*/

    struct fb_cmap cmap;         /*当前的颜色表*/

    struct fb_videomode *mode;   /*当前的显示模式*/

#ifdef CONFIG_FB_BACKLIGHT

    struct backlight_device *bl_dev;/*对应的背光设备*/

    struct mutex bl_curve_mutex;

    u8 bl_curve[FB_BACKLIGHT_LEVELS];/*背光调整*/

#endif

#ifdef CONFIG_FB_DEFERRED_IO

    struct delayed_work deferred_work;

    struct fb_deferred_io *fbdefio;

#endif

    struct fb_ops *fbops; /*对底层硬件操作的函数指针*/

    struct device *device;

    struct device *dev;   /*fb设备*/

    int class_flag;

#ifdef CONFIG_FB_TILEBLITTING

    struct fb_tile_ops *tileops; /*图块Blitting*/

#endif

    char __iomem *screen_base;   /*虚拟基地址*/

    unsigned long screen_size;   /*LCD IO映射的虚拟内存大小*/

    void *pseudo_palette;        /*伪16色颜色表*/

#define FBINFO_STATE_RUNNING    0

#define FBINFO_STATE_SUSPENDED  1

    u32 state;  /*LCD的挂起或恢复状态*/

    void *fbcon_par;

    void *par;

};  

struct fb_info {

    atomic_t count;

    int node;

    int flags;

    struct mutex lock;        /* Lock for open/release/ioctl funcs */

    struct mutex mm_lock;        /* Lock for fb_mmap and smem_* fields */

    struct fb_var_screeninfo var;    /* Current var */

    struct fb_fix_screeninfo fix;    /* Current fix */

    struct fb_monspecs monspecs;    /* Current Monitor specs */

    struct work_struct queue;    /* Framebuffer event queue */

    struct fb_pixmap pixmap;    /* Image hardware mapper */

    struct fb_pixmap sprite;    /* Cursor hardware mapper */

    struct fb_cmap cmap;        /* Current cmap */

    struct list_head modelist;      /* mode list */

    struct fb_videomode *mode;    /* current mode */

#ifdef CONFIG_FB_BACKLIGHT

    /* assigned backlight device */

    /* set before framebuffer registration,

       remove after unregister */

    struct backlight_device *bl_dev;

    /* Backlight level curve */

    struct mutex bl_curve_mutex;

    u8 bl_curve[FB_BACKLIGHT_LEVELS];

#endif

#ifdef CONFIG_FB_DEFERRED_IO

    struct delayed_work deferred_work;

    struct fb_deferred_io *fbdefio;

#endif

    struct fb_ops *fbops;

    struct device *device;        /* This is the parent */

    struct device *dev;        /* This is this fb device */

    int class_flag;                    /* private sysfs flags */

#ifdef CONFIG_FB_TILEBLITTING

    struct fb_tile_ops *tileops;    /* Tile Blitting */

#endif

    char __iomem *screen_base;    /* Virtual address */

    unsigned long screen_size;    /* Amount of ioremapped VRAM or 0 */

    void *pseudo_palette;        /* Fake palette of 16 colors */

#define FBINFO_STATE_RUNNING    0

#define FBINFO_STATE_SUSPENDED    1

    u32 state;            /* Hardware state i.e suspend */

    void *fbcon_par;                /* fbcon use-only private area */

    /* From here on everything is device dependent */

    void *par;

    /* we need the PCI or similar aperture base/size not

       smem_start/size as smem_start may just be an object

       allocated inside the aperture so may not actually overlap */

    struct apertures_struct {

        unsigned int count;

        struct aperture {

            resource_size_t base;

            resource_size_t size;

        } ranges[];

    } *apertures;

};

struct fb_var_screeninfo {

    __u32 xres;                /*可见屏幕一行有多少个像素点*/

    __u32 yres;                /*可见屏幕一列有多少个像素点*/

    __u32 xres_virtual;        /*虚拟屏幕一行有多少个像素点*/

    __u32 yres_virtual;        /*虚拟屏幕一列有多少个像素点*/

    __u32 xoffset;             /*虚拟到可见屏幕之间的行偏移*/

    __u32 yoffset;             /*虚拟到可见屏幕之间的列偏移*/

    __u32 bits_per_pixel;      /*每个像素的位数即BPP*/

    __u32 grayscale;           /*非0时，指的是灰度*/

    struct fb_bitfield red;    /*fb缓存的R位域*/

    struct fb_bitfield green;  /*fb缓存的G位域*/

    struct fb_bitfield blue;   /*fb缓存的B位域*/

    struct fb_bitfield transp; /*透明度*/

    __u32 nonstd;              /* != 0 非标准像素格式*/

    __u32 activate;

    __u32 height;              /*高度*/

    __u32 width;               /*宽度*/

    __u32 accel_flags;

    /*定时：除了pixclock本身外，其他的都以像素时钟为单位*/

    __u32 pixclock;            /*像素时钟(皮秒)*/

    __u32 left_margin;         /*行切换，从同步到绘图之间的延迟*/

    __u32 right_margin;        /*行切换，从绘图到同步之间的延迟*/

    __u32 upper_margin;        /*帧切换，从同步到绘图之间的延迟*/

    __u32 lower_margin;        /*帧切换，从绘图到同步之间的延迟*/

    __u32 hsync_len;           /*水平同步的长度*/

    __u32 vsync_len;           /*垂直同步的长度*/

    __u32 sync;

    __u32 vmode;

    __u32 rotate;

    __u32 reserved[];         /*保留*/

};   

struct fb_var_screeninfo {

    __u32 xres;            /* visible resolution        */

    __u32 yres;

    __u32 xres_virtual;        /* virtual resolution        */

    __u32 yres_virtual;

    __u32 xoffset;            /* offset from virtual to visible */

    __u32 yoffset;            /* resolution            */

    __u32 bits_per_pixel;        /* guess what            */

    __u32 grayscale;        /* 0 = color, 1 = grayscale,    */

                    /* >1 = FOURCC            */

    struct fb_bitfield red;        /* bitfield in fb mem if true color, */

    struct fb_bitfield green;    /* else only length is significant */

    struct fb_bitfield blue;

    struct fb_bitfield transp;    /* transparency            */    

    __u32 nonstd;            /* != 0 Non standard pixel format */

    __u32 activate;            /* see FB_ACTIVATE_*        */

    __u32 height;            /* height of picture in mm    */

    __u32 width;            /* width of picture in mm     */

    __u32 accel_flags;        /* (OBSOLETE) see fb_info.flags */

    /* Timing: All values in pixclocks, except pixclock (of course) */

    __u32 pixclock;            /* pixel clock in ps (pico seconds) */

    __u32 left_margin;        /* time from sync to picture    */

    __u32 right_margin;        /* time from picture to sync    */

    __u32 upper_margin;        /* time from sync to picture    */

    __u32 lower_margin;

    __u32 hsync_len;        /* length of horizontal sync    */

    __u32 vsync_len;        /* length of vertical sync    */

    __u32 sync;            /* see FB_SYNC_*        */

    __u32 vmode;            /* see FB_VMODE_*        */

    __u32 rotate;            /* angle we rotate counter clockwise */

    __u32 colorspace;        /* colorspace for FOURCC-based modes */

    __u32 reserved[];        /* Reserved for future compatibility */

};

struct fb_fix_screeninfo {

    char id[];                /*字符串形式的标示符 */

    unsigned long smem_start;   /*fb缓存的开始位置 */

    __u32 smem_len;             /*fb缓存的长度 */

    __u32 type;                 /*看FB_TYPE_* */

    __u32 type_aux;             /*分界*/

    __u32 visual;               /*看FB_VISUAL_* */

    __u16 xpanstep;             /*如果没有硬件panning就赋值为0 */

    __u16 ypanstep;             /*如果没有硬件panning就赋值为0 */

    __u16 ywrapstep;            /*如果没有硬件ywrap就赋值为0 */

    __u32 line_length;          /*一行的字节数 */

    unsigned long mmio_start;   /*内存映射IO的开始位置*/

    __u32 mmio_len;             /*内存映射IO的长度*/

    __u32 accel;

    __u16 reserved[];          /*保留*/

}; 

struct fb_fix_screeninfo {

    char id[];            /* identification string eg "TT Builtin" */

    unsigned long smem_start;    /* Start of frame buffer mem */

                    /* (physical address) */

    __u32 smem_len;            /* Length of frame buffer mem */

    __u32 type;            /* see FB_TYPE_*        */

    __u32 type_aux;            /* Interleave for interleaved Planes */

    __u32 visual;            /* see FB_VISUAL_*        */

    __u16 xpanstep;            /* zero if no hardware panning  */

    __u16 ypanstep;            /* zero if no hardware panning  */

    __u16 ywrapstep;        /* zero if no hardware ywrap    */

    __u32 line_length;        /* length of a line in bytes    */

    unsigned long mmio_start;    /* Start of Memory Mapped I/O   */

                    /* (physical address) */

    __u32 mmio_len;            /* Length of Memory Mapped I/O  */

    __u32 accel;            /* Indicate to driver which    */

                    /*  specific chip/card we have    */

    __u16 capabilities;        /* see FB_CAP_*            */

    __u16 reserved[];        /* Reserved for future compatibility */

};

struct fb_ops {

    struct module *owner;

    //检查可变参数并进行设置

    int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);

    //根据设置的值进行更新，使之有效

    int (*fb_set_par)(struct fb_info *info);

    //设置颜色寄存器

    int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,

             unsigned blue, unsigned transp, struct fb_info *info);

    //显示空白

    int (*fb_blank)(int blank, struct fb_info *info);

    //矩形填充

    void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);

    //复制数据

    void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);

    //图形填充

    void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);

}；  

4418

struct fb_ops {

    /* open/release and usage marking */

    struct module *owner;

    int (*fb_open)(struct fb_info *info, int user);

    int (*fb_release)(struct fb_info *info, int user);

    /* For framebuffers with strange non linear layouts or that do not

     * work with normal memory mapped access

     */

    ssize_t (*fb_read)(struct fb_info *info, char __user *buf,

               size_t count, loff_t *ppos);

    ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,

                size_t count, loff_t *ppos);

    /* checks var and eventually tweaks it to something supported,

     * DO NOT MODIFY PAR */

    int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);

    /* set the video mode according to info->var */

    int (*fb_set_par)(struct fb_info *info);

    /* set color register */

    int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,

                unsigned blue, unsigned transp, struct fb_info *info);

    /* set color registers in batch */

    int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);

    /* blank display */

    int (*fb_blank)(int blank, struct fb_info *info);

    /* pan display */

    int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);

    /* Draws a rectangle */

    void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);

    /* Copy data from area to another */

    void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);

    /* Draws a image to the display */

    void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);

    /* Draws cursor */

    int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);

    /* Rotates the display */

    void (*fb_rotate)(struct fb_info *info, int angle);

    /* wait for blit idle, optional */

    int (*fb_sync)(struct fb_info *info);

    /* perform fb specific ioctl (optional) */

    int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,

            unsigned long arg);

    /* Handle 32bit compat ioctl (optional) */

    int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,

            unsigned long arg);

    /* perform fb specific mmap */

    int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);

    /* get capability given var */

    void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,

                struct fb_var_screeninfo *var);

    /* teardown any resources to do with this framebuffer */

    void (*fb_destroy)(struct fb_info *info);

    /* called at KDB enter and leave time to prepare the console */

    int (*fb_debug_enter)(struct fb_info *info);

    int (*fb_debug_leave)(struct fb_info *info);

};

六、Framebuffer设备注册
S3cfb.c中的s3cfb_probe设备探测，是驱动注册的主要函数，

/*定义一个结构体用来维护驱动程序中各函数中用到的变量
  先别看结构体要定义这些成员，到各函数使用的地方就明白了*/

static int __devinit s3cfb_probe(struct platform_device *pdev)

{

    struct s3c_platform_fb *pdata;/*LCD屏配置信息结构体*/

    struct s3cfb_global *fbdev;/*驱动程序全局变量结构体*/

    struct resource *res; /*用来保存从LCD平台设备中获取的LCD资源*/

    int i, j, ret = ;  

    printk("%s\n",__func__);

    fbdev = kzalloc(sizeof(struct s3cfb_global), GFP_KERNEL);

    if (!fbdev) {

        dev_err(&pdev->dev, "failed to allocate for "

            "global fb structure\n");

        ret = -ENOMEM;

        goto err_global;

    }

    fbdev->dev = &pdev->dev;  

    fbdev->regulator = regulator_get(&pdev->dev, "pd");

    if (!fbdev->regulator) {

        dev_err(fbdev->dev, "failed to get regulator\n");

        ret = -EINVAL;

        goto err_regulator;

    }

    ret = regulator_enable(fbdev->regulator);

    if (ret < ) {

        dev_err(fbdev->dev, "failed to enable regulator\n");

        ret = -EINVAL;

        goto err_regulator;

    }  

    /*获取LCD参数信息*/

    pdata = to_fb_plat(&pdev->dev);

    if (!pdata) {

        dev_err(fbdev->dev, "failed to get platform data\n");

        ret = -EINVAL;

        goto err_pdata;

    }  

    fbdev->lcd = (struct s3cfb_lcd *)pdata->lcd;  

    /*配置GPIO端口*/

    if (pdata->cfg_gpio)

        pdata->cfg_gpio(pdev);  

    /*设置时钟参数*/

    if (pdata->clk_on)

        pdata->clk_on(pdev, &fbdev->clock);  

    /*获取LCD平台设备所使用的IO端口资源，注意这个IORESOURCE_MEM标志和LCD平台设备定义中的一致*/

    res = platform_get_resource(pdev, IORESOURCE_MEM, );

    if (!res) {

        dev_err(fbdev->dev, "failed to get io memory region\n");

        ret = -EINVAL;

        goto err_io;

    }  

    /*申请LCD IO端口所占用的IO空间(注意理解IO空间和内存空间的区别),request_mem_region定义在ioport.h中*/

    res = request_mem_region(res->start,

                 res->end - res->start + , pdev->name);

    if (!res) {

        dev_err(fbdev->dev, "failed to request io memory region\n");

        ret = -EINVAL;

        goto err_io;

    }  

    /*将LCD的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中

         注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作*/

    fbdev->regs = ioremap(res->start, res->end - res->start + );

    if (!fbdev->regs) {

        dev_err(fbdev->dev, "failed to remap io region\n");

        ret = -EINVAL;

        goto err_mem;

    }

#ifdef CONFIG_FB_S3C_LTE480WV

    /*设置寄存器初始状态*/

    s3cfb_pre_init_para(fbdev);

#endif  

    /*设置gamma 值*/

    s3cfb_set_gamma(fbdev);

    /*设置VSYNC中断*/

    s3cfb_set_vsync_interrupt(fbdev, );

    /*设置全局中断*/

    s3cfb_set_global_interrupt(fbdev, );

    /*fb设备参数信息初始化*/

    s3cfb_init_global(fbdev);  

    /*为framebuffer分配空间，进行内存映射，填充fb_info*/

    if (s3cfb_alloc_framebuffer(fbdev)) {

        ret = -ENOMEM;

        goto err_alloc;

    }  

    /*注册fb设备到系统中*/

    if (s3cfb_register_framebuffer(fbdev)) {

        ret = -EINVAL;

        goto err_register;

    }  

    s3cfb_set_clock(fbdev);

    s3cfb_set_window(fbdev, pdata->default_win, );  

    s3cfb_display_on(fbdev);  

    fbdev->irq = platform_get_irq(pdev, );

    if (request_irq(fbdev->irq, s3cfb_irq_frame, IRQF_SHARED,

            pdev->name, fbdev)) {

        dev_err(fbdev->dev, "request_irq failed\n");

        ret = -EINVAL;

        goto err_irq;

    }  

#ifdef CONFIG_FB_S3C_LCD_INIT

    if (pdata->backlight_on)

        pdata->backlight_on(pdev);  

    if (!bootloaderfb && pdata->reset_lcd)

        pdata->reset_lcd(pdev);  

    if (pdata->lcd_on)

        pdata->lcd_on(pdev);

#endif  

#ifdef CONFIG_HAS_EARLYSUSPEND

    fbdev->early_suspend.suspend = s3cfb_early_suspend;

    fbdev->early_suspend.resume = s3cfb_late_resume;

    fbdev->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;

    register_early_suspend(&fbdev->early_suspend);

#endif  

    /*对设备文件系统的支持，创建fb设备文件*/

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

    if (ret < )

        dev_err(fbdev->dev, "failed to add sysfs entries\n");  

    dev_info(fbdev->dev, "registered successfully\n");  

    /*显示开机logo*/

#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)

    if (fb_prepare_logo( fbdev->fb[pdata->default_win], FB_ROTATE_UR)) {

        printk("Start display and show logo\n");

        /* Start display and show logo on boot */

        fb_set_cmap(&fbdev->fb[pdata->default_win]->cmap, fbdev->fb[pdata->default_win]);

        fb_show_logo(fbdev->fb[pdata->default_win], FB_ROTATE_UR);

    }

#endif  

    return ;

}  

4418的是在kernel\drivers\video 主要包括 nxp-fb.c

LCD控制器作为挂载在S5P4418 CPU总线上的一个模块，是platform虚拟总线上的一个设备。因此，在外面的驱动里应该将该驱动注册到platform bus。同时，我们根据第二篇所学知识，容易理解该驱动应该是一个字符设备类驱动。代码如下：

static int nxp_fb_probe(struct platform_device *pdev)

{

    struct nxp_fb_plat_data *plat = pdev->dev.platform_data;

    struct fb_info *info = NULL;

#ifdef CONFIG_FB_NXP_ION_MEM

    struct nxp_fb_device *fbdev;

    struct nxp_fb_param *fbpar;

#endif

    int i = , ret = ;

    pr_debug("\n%s (name=%s, id=%d)\n", __func__, dev_name(&pdev->dev), pdev->id);

    /*    allocate fb_info and init */

    info = nxp_fb_init_fb(pdev->id, &pdev->dev);

    if(! info) {

        ret = -ENOMEM;

        goto err_fb;

    }

    ret = nxp_fb_setup_param(pdev->id, info, plat);

    if ( > ret)

        goto err_map;

    nxp_fb_setup_info(info);

#ifdef CONFIG_FB_NXP_ION_MEM

    fbpar = info->par;

    fbdev = &fbpar->fb_dev;

    fbdev->dev = &pdev->dev;

    ret = nxp_fb_setup_ion(&fbpar->fb_dev.dma_buf_data);

    if (ret) {

        printk(KERN_ERR "Fail to setup ion\n");

        goto err_map;

    }

#endif

    /*    allocate frame buffer memory from here */

    ret = nxp_fb_alloc_mem(info);

    if(ret) {

        printk(KERN_ERR "Fail, unable to allcate frame buffer (%d)\n", pdev->id);

        goto err_map;

    }

    nxp_fb_init_display(info);

    /*

      *     device_create '/proc/fb0' & fb class

     *     register machine file operation to frame buffer file operation

      *     registered_fb[]

      *     (drivers/video/fbmem.c)

      */

    if (pdev->id != ) {

        for (i = ; pdev->id > i; i++) {

            if (!registered_fb[i]) {

                printk("FB: Reserve dev/node [%d]\n", i);

                registered_fb[i] = info;

            }

        }

    }

    ret = register_framebuffer(info);
if(ret < ) {

        printk(KERN_ERR "Fail, unable to register frame buffer(%d)\n", pdev->id);

        goto err_reg;

    }

    /* register to driver data, use platform_get_drvdata */

    platform_set_drvdata(pdev, info);

    //gpio_request(CFG_IO_LCD_POWER, "LCE_POWER");

    //gpio_direction_output(CFG_IO_LCD_POWER,0);

    //mdelay(300);

    //gpio_direction_output(CFG_IO_LCD_POWER,1);

    printk("--%s----\n\n",__func__);

    return ret;

err_reg:
unregister_framebuffer(info);

err_map:

    nxp_fb_free_mem(info);

err_fb:

    nxp_fb_exit_fb(info);

    return ret;

}

七、如何阅读LCD规格书
首先我们调试LCD的时候要获得的一些参数，没必要把整个规格书通读一遍，我刚开始调试屏的时候拿到一个规格书不知道从何入手，也不知那些参数有用，比较模糊，其实只提取一些有用的信息就可以，下面这些对初学者也许有点用处。

1、GeneralSpecification
尺寸、分辨率、位数、色彩、像素时钟频率、接口类型
（1）、尺寸：

（2）、分辨率：1920 1200；

（3）、接口：双通道LVDS；

（4）、色彩：16.7M，这里可以确认数据位数8bitRGB三色：3*8=24，2的24次方=16.7M

6bitRGB 三色：3*6=18，2的18次方=262 144;

所以当看到色彩是1.7M是，说明LCD是24bit的，如果是262 144说明LCD是18bit的。

2、Timing Characteristics

（1）、Frame rate :是60HZ，也就是帧率；
（2）、clock frequency:像素时钟，这里面有最大值、中间值和最小值，这个屏默认值为：76.36MHz；
（3）、Vertical Seciton：VSWidth +Back Porc+Front Porch，前间距、后间距。这个我们再RGB信号哪里详细解释，这个我们前面有说过；
（4）、Horizontal Section：HS Width +Back Porc+Front Porch，这个跟VS的Porch相同。

3、LCD  Timing diagram信号时序图，如下所示

有些读者会问，为什么没有行、场、数据等信号。其实这个是LVDS信号的时序，这个根据屏厂的习惯，有的画的是LVDS输入的信号时序，有的是TTL（RGB）的时序。

上面我们以一个例子说明，做驱动的（软件方面）要知道的一些参数，如果是硬件方面的问题，可以再对一下接口。其实一个LCD规格书要了解的也就这么多，调试软件就够用：
（1）、General Specification中可得到，尺寸、分辨率、位数、色彩、像素时钟频率、接口类型；
（2）、Timing Characteristics中可以得到一些具体的参数；
（3）、LCD  Timing diagram信号时序图，可以看到一些信号的时序、极性等；

八、PWM概述
1、先解释两个名词：
PWM：脉冲宽度调制(PWM)，是英文“Pulse WidthModulation”的缩写，简称脉宽调制。
占空比：占空比(DutyRation)在电信领域中有如下含义：
在一串理想的脉冲周期序列中（如方波），正脉冲的持续时间与脉冲总周期的比值。例如：（假设脉冲为3V）
脉冲宽度 1μs，信号周期4μs的脉冲序列占空比为0.25，平均电压为：3*0.25=0.75V；
脉冲宽度 0μs，信号周期4μs的脉冲序列占空比为0，平均电压为：0V；
脉冲宽度 4μs，信号周期4μs的脉冲序列占空比为1，平均电压为：3V；

平均电压的变化成阶梯型变化，如果T足够小，成线性。

看下芯片片规格书中的描述：寄存器填不同值是，脉冲宽度不一样。

2、samusng 中的PWM控制器

PWM时钟分频。跟单片机里面的有点像。死区控制器：这个是根据晶体管的特性，设置这个功能的，不过我工作中还没有用到死区控制这块。了解有这个概念。

看这些寄存器，记得用MINI2440写裸机程序的时候，直接写这些寄存器，记得上学时把s3c2440当单片机玩，有点浪费。学生时代，已经逝去的青春？？