精华内容
下载资源
问答
  • 性能好的LCD背光驱动芯片,可以使LCD显示清晰,亮度均匀,没有闪烁等问题,并且高效率的驱动芯片增加手机的待机时间,所以选择一款合适的,性能优异的LCD背光驱动芯片是非常重要的。  根据LCD屏幕内的LED连接方式...
  • 性能好的LCD背光驱动芯片,可以使LCD显示清晰,亮度均匀,没有闪烁等问题,并且高效率的驱动芯片增加手机的待机时间,所以选择一款合适的,性能优异的LCD背光驱动芯片是非常重要的。  根据LCD屏幕内的LED连接方式...
  • fandar 液晶屏LCD背光驱动芯片MP3302

    千次阅读 2018-03-07 11:38:56
    在制作LCD PCB的时候,液晶屏LCD背光驱动芯片MP3302 LED的驱动电路想省事 ,直接接上VCC·GND ,结果就是不行,因为液晶的led串联,分压基本上就分干净了,2.然后出现了一个错误,C4这个电容让我给省略了,导致...

    学习

    1.在制作LCD PCB的时候,液晶屏LCD背光驱动芯片MP3302 LED的驱动电路想省事 ,

    直接接上VCC·GND ,结果就是不行,因为液晶的led串联,分压基本上就分干净了,






    2.然后出现了一个错误,C4这个电容让我给省略了,导致后面 各种奇葩错误,电压直接飙到最高,发热的厉害


    后来看了下升压电路,才发现 学的知识不用全部忘记了,二极管 电感 电容 是必不可少的

    {原理自行百度}



    3.R9的取值 参考手册 我用的10k 不算很亮 不过还可以

    结果



    展开全文
  • MTK LCD背光驱动——背光芯片

    千次阅读 2013-12-09 18:02:48
    由上图可知,Tigris3G的LCD背光是由背光芯片控制的,而键盘背光则是由KPLED外设控制的。 本文重点讲述使用背光IC控制背光的方式,对于KPLED控制背光的内容不做分析,关于使用KPLED控制背光的方法,请参阅Tango+3G...

    Tigris3G背光电路示意图如下:

     

    由上图可知,Tigris3GLCD背光是由背光芯片控制的,而键盘背光则是由KPLED外设控制的。

    本文重点讲述使用背光IC控制背光的方式,对于KPLED控制背光的内容不做分析,关于使用KPLED控制背光的方法,请参阅《MTK LCD+KEYPAD背光驱动》

     

    背光IC

     

    Tigris3G使用的背光ICSGM3132,它与SGM3131兼容。该芯片的数据手册可到我的共享目录

    \\172.24.220.189\document\Tigris3G电路原理图\datasheet 查看。

     

    下图为该芯片的一个典型应用电路:

     

    通过对EN引脚发送脉冲来调节流过LED的电流强度。

     

     

     

    下图为芯片SGM3132的内部结构示意图:

    由上图所见,该芯片内部有一个步进脉冲控制器和一个关断延时处理器

    步进脉冲控制器:当收到1个脉冲,就递减一次电流,以16个脉冲为1次循环;

    关断延时处理器:当检测到EN引脚低电平的时间大于3ms时,确认为关断操作,即输出电流为0.

     

     

     

    下图为亮度调节的时序图:

    (上半部为EN输入脉冲电压/时间图,下半部为输出LED电流/时间图)

     

    下图为EN引脚输入脉冲的详细时序图:

     

    TREADY:芯片启动时的高电平持续时间,必须大于30us

    THI:单个脉冲高电平持续时间,必须大于0.5us

    TLO:两个相邻脉冲之间低电平的持续时间,必须大于0.5us且小于500us

    TSHDN:关断操作时,无效电平的持续时间,必须大于3ms

    ILEDx:流过单个LED的电流强度。

     

    总结:

    SGM3132就像步进电机一样,你给它一个脉冲,它就调整一次电流,当调整到最小值时,又重新跳回到最大值,如此循环。电流每次调整的刻度为 Imax1/16。当要使 ILED稳定在某一刻度时,只需保持EN高电平即可;要停止背光IC工作,只需拉低EN引脚即可。需注意的是,当连续调整时,要注意相邻脉冲之间的间隔不能超过3ms,否则就视为关断操作。

     

    LCD背光驱动代码

     

    custom_cfg_gpio_set_level()函数中,调用驱动芯片控制函数SGM3131_Set_Level()

     

     

     

     

    函数SGM3131_Set_Level()定义如下:

     

     

     

    全局数组lcdbl_pcc_SGM3131定义如下:

     

      

    SGM3131_Pulse_Count()函数是真正控制背光IC的驱动函数,它用于向EN引脚发送指定脉冲个数:

     

     

    从以上代码可知,当要发送多个脉冲时,先将IC关断,然后再开启,接着连续发送指定脉冲个数。这样做的好处是不用记录当前背光IC内部实际的电流等级,以免造成计数混乱。

    展开全文
  • 如何为智能机和类智能机选择合适的背光驱动方案,是设计人员当前和未来需要考虑的问题,手机背光驱动芯片按架构分主要有:自适应电荷泵升压型、低压降恒流型和电感升压型等。
  • 本文分析了电感升压型背光驱动的EMI辐射来源,以及电感升压型背光驱动芯片如何通过内部电路的优化设计,来降低电感产生的EMI辐射和调光时VOUT的EMI辐射,并对PCB设计提出了优化EMI性能。
  • 罗杰斯DUREL事业部发布了冷光发光灯最新版本的高性能驱动... DUREL D392A背光驱动芯片可适应于各种频率的产品,同时可以通过分立的原器件,模拟电压控制和脉冲宽度调节信号达到灯片亮度渐变的效果。驱动芯片能通过ESD
  • 德州仪器(TI)宣布推出其款针对背光应用的有机发光二极管(OLED)显示电源转换集成电路(IC)以及新型的白光LED充电泵,从而进一步满足了支持新一代便携式彩色显示的所有电源需求。  TI的TPS65130是一款经过精心设计...
  • 日前,德州仪器 (TI) 宣布推出其第一款针对背光应用的有机发光二极管 (OLED) 显示电源转换集成电路 (IC) 以及新型的白光 LED 充电泵,从而进一步满足了支持新一代便携式彩色显示的所有电源需求。如欲了解更多详情,...
  • 德州仪器(TI)宣布推出其第一款针对背光应用的有机发光二极管(OLED)显示电源转换集成电路(IC)以及新型的白光LED充电泵,从而进一步满足了支持新一代便携式彩色显示的所有电源需求。  TI的TPS65130是一款经过精心...
  • 随着电力电子技术的发展,越来越多的便携设备开始使用中小尺寸(7`~10`)的液晶面板作为显示输出装置。由于便携设备电池容量有限,低... AP3031是BCD公司基于Poly emitter 工艺研制的新一代背光驱动IC,其特点是将芯片
  • LCD背光控制芯片

    2012-09-29 15:30:00
    但CPU的pwm引脚驱动能力太弱,常外接一个背光芯片。rt9293就是这样的一个恒流升压转换器。 Iled=Vref/Rset Vfb=Duty * 300mV (Duty是EN输入信号的占空比,300mV是内部参考电压) PWM占空比...


    PWM信号可通过调整占空比来调节输出电压,可以使用PWM来控制LCD的背光。


    但CPU的pwm引脚驱动能力太弱,常外接一个背光芯片。rt9293就是这样的一个恒流升压转换器。



    Iled=Vref/Rset
    Vfb=Duty * 300mV (Duty是EN输入信号的占空比,300mV是内部参考电压)



    PWM占空比就是用来对内部300mV进行分压的。经过低通滤波器来过滤脉冲信号,最后输出连接到误差放大器(EA),回送FB信号。


    输入PWM信号频率小于500Hz时,VA也是一个PWM信号,控制输出电压。
    输入PWM信号频率大于500Hz时,VA相当于一个直流信号。

    两个频率的典型值是200Hz和20kHz.

    误差放大器回送反馈信号,占空比低时会产生更大误差。所以对PWM输入信号的占空比有最低值要求。

    转载于:https://www.cnblogs.com/sammei/archive/2012/09/29/3295617.html

    展开全文
  • 随着数码产品的飞速发展和迅速普及,数码产品的内部器件也面临了更高的要求,由于大多数便携式数码产品例如手机,数码相机,MP3, PMP以及数码相框都会需要显示模块,其中的WLED背光驱动电源的设计也就越来越受到...
  • tiny4412 设备树之LCD背光驱动(五)

    千次阅读 2017-09-20 22:04:36
    开发板:tiny4412(1611) 内核:linux4.4 编译器: arm-none-linux-gnueabi-gcc (gcc version 4.8.3 20140320) 4412芯片gpx1 2接到双向电平转换器上: ...关于一线背光驱动: http://www....

    开发板:tiny4412(1611)
    内核:linux4.4
    编译器: arm-none-linux-gnueabi-gcc (gcc version 4.8.3 20140320)
    4412芯片gpx1 2接到双向电平转换器上:
    这里写图片描述
    LCD上有一个STM8单片机控制背光和传输触屏数据,通过一线协议。(触屏数据也可通过i2c直接读取)
    这里写图片描述
    关于一线背光驱动:
    http://www.360doc.com/content/15/1031/21/6828497_509742486.shtml


    devicetree

            backlight@139D0000{
                    compatible         = "tiny4412,backlight_demo";
                    reg = <0x139D0000 0x48>;
                    tiny4412,backlight = <&gpx1 2 GPIO_ACTIVE_HIGH>;
                    pinctrl-names = "backlight_out","backlight_in";
                    pinctrl-0 = <&backlight_out>;
                    pinctrl-1 = <&backlight_in>;
                    interrupts = <0 40 0>;
                    clocks = <&clock CLK_PWM>;
                    clock-names = "timers";
            };
    
    &pinctrl_1 {
            backlight_out: backlight_out{
                    samsung,pins = "gpx1-2";
                    samsung,pin-function = <1>;
                    samsung,pin-pud = <0>;
                    samsung,pin-drv = <0>;
            };
             backlight_in: backlight_in{
                    samsung,pins = "gpx1-2";
                    samsung,pin-function = <0>;
                    samsung,pin-pud = <0>;
                    samsung,pin-drv = <0>;
            };
    };
    

    驱动

    //移植linux-3.5/drivers/input/touchscreen/tiny4412_1wire_host.c
    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/cdev.h>
    #include <linux/device.h>
    #include <linux/platform_device.h>
    #include <linux/gpio.h>
    #include <linux/of.h>
    #include <linux/of_gpio.h>
    #include <linux/fs.h>
    #include <asm/uaccess.h>
    #include <linux/bitops.h>
    #include <linux/clk.h>
    #include <linux/export.h>
    #include <linux/err.h>
    #include <linux/io.h>
    #include <linux/pwm.h>
    #include <linux/slab.h>
    #include <linux/spinlock.h>
    #include <linux/time.h>
    #include <linux/interrupt.h>
    #include <linux/delay.h>
    #include <linux/sched.h>
    
    #define dev_num 1
    
    #define timer_debug printk("TCFG0:      %08x\n",timer->TCFG0);   \
                printk("TCFG1:      %08x\n",timer->TCFG1);   \
                printk("TCON:       %08x\n",timer->TCON);    \
                printk("TCNTB3:     %08x\n",timer->TCNTB3);  \
                printk("TCMPB3:     %08x\n",timer->TCMPB3);  \
                printk("TCNTO3:     %08x\n",timer->TCNTO3);  \
                printk("TINT_CSTAT: %08x\n",timer->TINT_CSTAT)
    
    struct device *dev;
    static struct pinctrl *pinctrl; 
    static struct pinctrl_state *pinctrl_in;
    static struct pinctrl_state *pinctrl_out;
    static struct cdev gpj1_3_cdev;
    static struct class *gpj_class;
    static struct device *class_dev;
    static int major;
    static dev_t devid;
    static int onewrite_pin;
    static char devname[]="one_write";
    //from tiny4412-1write-host.c
    static DECLARE_WAIT_QUEUE_HEAD(bl_waitq);
    static int bl_ready;
    static unsigned char backlight_req = 0;
    static unsigned char backlight_init_success;
    enum {
        IDLE,
        START,
        REQUEST,
        WAITING,
        RESPONSE,
        STOPING,
    } one_wire_status = IDLE;
    //static int err_i = 0;
    
    static volatile unsigned int io_bit_count;
    static volatile unsigned int io_data;
    static volatile unsigned char one_wire_request;
    
    struct TIMER_BASEADDR{
    unsigned int TCFG0;
    unsigned int TCFG1;
    unsigned int TCON; 
    unsigned int TCNTB0; 
    unsigned int TCMPB0; 
    unsigned int TCNTO0; 
    unsigned int TCNTB1;
    unsigned int TCMPB1;
    unsigned int TCNTO1; 
    unsigned int TCNTB2; 
    unsigned int TCMPB2; 
    unsigned int TCNTO2; 
    unsigned int TCNTB3; 
    unsigned int TCMPB3; 
    unsigned int TCNTO3; 
    unsigned int TCNTB4; 
    unsigned int TCNTO4; 
    unsigned int TINT_CSTAT; 
    };
    
    volatile struct TIMER_BASEADDR *timer;
    
    static inline void set_pin_up(void)
    {
        /* TODO: */
    #if 0
        unsigned long tmp;
        tmp = readl(S3C64XX_GPFPUD);
        tmp &= ~(3U <<30);
        tmp |= (2U << 30);
        writel(tmp, S3C64XX_GPFPUD);
    #endif
    }
    
    static inline void set_pin_as_input(void)
    {
        pinctrl_select_state(pinctrl,pinctrl_in);
    }
    
    static inline void set_pin_as_output(void)
    {
        pinctrl_select_state(pinctrl,pinctrl_out);
    }
    
    static inline void set_pin_value(int v)
    {
        if (v) {
            gpio_set_value(onewrite_pin, 1);
        } else {
            gpio_set_value(onewrite_pin, 0);
        }
    }
    
    static inline int get_pin_value(void)
    {
        return gpio_get_value(onewrite_pin);
    }
    
    
    // CRC
    //
    static const unsigned char crc8_tab[] = {
    0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
    0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
    0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
    0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
    0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
    0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
    0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
    0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
    0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
    0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
    0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
    0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
    0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
    0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
    0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
    0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
    0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
    0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
    0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
    0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
    0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
    0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
    0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
    0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
    0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
    0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
    0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
    0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
    0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
    0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
    0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
    0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3,
    };
    
    
    #define crc8_init(crc) ((crc) = 0XACU)
    #define crc8(crc, v) ( (crc) = crc8_tab[(crc) ^(v)])
    
    // once a session complete
    static unsigned total_received, total_error;
    static unsigned last_req, last_res;
    
    static inline void notify_bl_data(unsigned char a, unsigned char b, unsigned char c)
    {
        bl_ready = 1;
        backlight_init_success = 1;
        wake_up_interruptible(&bl_waitq);
    }
    
    static void one_wire_session_complete(unsigned char req, unsigned int res)
    {
        unsigned char crc;
        const unsigned char *p = (const unsigned char*)&res;
        total_received ++;
    
        last_res = res;
    
        crc8_init(crc);
        crc8(crc, p[3]);
        crc8(crc, p[2]);
        crc8(crc, p[1]);
    
        if (crc != p[0]) {
            // CRC dismatch
            if (total_received > 100) {
                total_error++;
            }
            return;
        }
    
        notify_bl_data(p[3], p[2], p[1]);
    
    }
    
    #define S3C2410_TCON_T3START      (1<<16)
    // one-wire protocol core
    static unsigned long TCNT_FOR_SAMPLE_BIT;
    static unsigned long TCNT_FOR_FAST_LOOP;
    static unsigned long TCNT_FOR_SLOW_LOOP;
    #define SAMPLE_BPS 9600
    
    #define SLOW_LOOP_FEQ 25
    #define FAST_LOOP_FEQ 60
    #define S3C2410_TCFG1_MUX3_MASK   (15<<12)
    
    static int init_timer_for_1wire(struct clk *clk)
    {
        //unsigned long tcfg1;
        unsigned long tcfg0;
    
        unsigned prescale1_value;
    
        unsigned long pclk;
        //struct clk *clk;
    
        // get pclk
        clk = clk_get(dev, "timers");
        if (IS_ERR(clk)) {
            printk("ERROR to get PCLK\n");
            return -EIO;
        }
        clk_enable(clk);
    
        pclk = clk_get_rate(clk);
        printk("PWM clock = %ld\n", pclk);
    
        // get prescaler
        tcfg0 = timer->TCFG0;
        // we use system prescaler value because timer 4 uses same one
        prescale1_value = (tcfg0 >> 8) & 0xFF;
    
        // calc the TCNT_FOR_SAMPLE_BIT, that is one of the goal
        TCNT_FOR_SAMPLE_BIT = pclk / (prescale1_value + 1) / SAMPLE_BPS - 1;
        TCNT_FOR_FAST_LOOP  = pclk / (prescale1_value + 1) / FAST_LOOP_FEQ - 1;
        TCNT_FOR_SLOW_LOOP  = pclk / (prescale1_value + 1) / SLOW_LOOP_FEQ - 1;
    
        // select timer 3, the 2rd goal
    #if 0
        tcfg1 = timer->TCFG1;
        tcfg1 &= ~S3C2410_TCFG1_MUX3_MASK;
        timer->TCFG1=tcfg1;
    #endif
        printk("TCNT_FOR_SAMPLE_BIT = %ld, TCFG1 = %08x\n",
                TCNT_FOR_SAMPLE_BIT,timer->TCFG1);
        return 0;
    }
    
    
    static inline void stop_timer_for_1wire(void)
    {
        unsigned long tcon;
        tcon = timer->TCON;
        tcon &= ~S3C2410_TCON_T3START;
        timer->TCON=tcon;
    }
    
    static irqreturn_t timer_for_1wire_interrupt(int irq, void *dev_id)
    {
        unsigned int tint;
        tint = timer->TINT_CSTAT;
        tint |= 0x100;
        timer->TINT_CSTAT=tint;
    
        io_bit_count--;
        switch(one_wire_status) {
        case START:
            if (io_bit_count == 0) {
                io_bit_count = 16;
                one_wire_status = REQUEST;
            }
            break;
    
        case REQUEST:
            // Send a bit
            set_pin_value(io_data & (1U << 31));
            io_data <<= 1;
            if (io_bit_count == 0) {
                io_bit_count = 2;
                one_wire_status = WAITING;
            }
            break;
    
        case WAITING:
            if (io_bit_count == 0) {
                io_bit_count = 32;
                one_wire_status = RESPONSE;
            }
            if (io_bit_count == 1) {
                set_pin_as_input();
                set_pin_value(1);
            }
            break;
    
        case RESPONSE:
            // Get a bit
            io_data = (io_data << 1) | get_pin_value();
            if (io_bit_count == 0) {
                io_bit_count = 2;
                one_wire_status = STOPING;
                set_pin_value(1);
                set_pin_as_output();
                one_wire_session_complete(one_wire_request, io_data);
            }
            break;
    
        case STOPING:
            if (io_bit_count == 0) {
                one_wire_status = IDLE;
                stop_timer_for_1wire();
            }
            break;
    
        default:
            stop_timer_for_1wire();
        }
        return IRQ_HANDLED;
    }
    
    #define S3C2410_TCON_T3RELOAD     (1<<19)
    #define S3C2410_TCON_T3MANUALUPD  (1<<17)
    
    
    static void start_one_wire_session(unsigned char req)
    {
        unsigned int tcon;
        printk("backlight_write\n");
        one_wire_status = START;
        //gpio_set_value(one_write_pin, 1);
        //pinctrl_select_state(pctrl, pstate_out);
        set_pin_value(1);
        set_pin_as_output();
    
        // IDLE to START
        {
            unsigned char crc;
            crc8_init(crc);
            crc8(crc, req);
            io_data = (req << 8) + crc;
            io_data <<= 16;
        }
        io_bit_count = 1;
        set_pin_as_output();
        //pinctrl_select_state(pctrl, pstate_out);
        timer->TCNTB3 = 650;
        //init tranfer and start timer
        tcon = timer->TCON;
        tcon &= ~(0xF << 16);
        tcon |= (1 << 17);
        timer->TCON = tcon;
        tcon |= (1 << 16);
        tcon |= (1 << 19);
        tcon &= ~(1 << 17);
        timer->TCON = tcon;
        timer->TINT_CSTAT |= 0x08;
        //gpio_set_value(one_write_pin, 0);
        set_pin_value(0);
    }
    
    static int backlight_open(struct inode * inode, struct file * file){
        printk("%s enter.\n", __func__);
    
    
    
        return 0;
    }
    
    
    static ssize_t backlight_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
    {
        int ret;
        char buf[4] = {0, 0, 0, 0};
        unsigned v;
        unsigned len;
    
        if (count == 0) {
            return -EINVAL;
        }
    
        if (count > sizeof buf - 1) {
            len = sizeof buf - 1;
        } else {
            len = count;
        }
    
        ret = copy_from_user(buf, buffer, len);
        if (ret) {
            return -EFAULT;
        }
    
        if (sscanf(buf, "%u", &v) != 1) {
            return -EINVAL;
        }
    
        if (v > 127) {
            v = 127;
        }
    
        bl_ready = 0;
        backlight_req = v + 0x80U;
    
        start_one_wire_session(backlight_req);
    
        ret = wait_event_interruptible_timeout(bl_waitq, bl_ready, HZ / 10);
        if (ret < 0) {
            return ret;
        }
        if (ret == 0) {
            return -ETIMEDOUT;
        }
    
        return count;
    }
    
    static int backlight_release(struct inode *inode, struct file *file){
        devm_gpio_free(dev,onewrite_pin);
    
        return 0;
    }
    
    static const struct file_operations gpj1_3_fops={  
        .owner   = THIS_MODULE,  
        .open     = backlight_open,   
        .write    = backlight_write,
        .release = backlight_release,  
    };  
    
    struct clk *clk=NULL;
    
    static int pinctrl_probe(struct platform_device *pdev) {
        int error,ret;
        struct resource *res=NULL,*irq=NULL;
    
        dev = &pdev->dev;
        printk("%s enter.\n", __func__);
    
        if (!dev->of_node) {
                dev_err(dev, "no platform data.\n");
                goto err0;
        }
        /*request resource*/
        onewrite_pin=of_get_named_gpio(dev->of_node,"tiny4412,backlight",0);
        devm_gpio_request_one(dev, onewrite_pin,GPIOF_OUT_INIT_HIGH,"onewrite_pin");
        pinctrl=devm_pinctrl_get(dev);
        pinctrl_out=pinctrl_lookup_state(pinctrl,"backlight_out");
        pinctrl_in=pinctrl_lookup_state(pinctrl,"backlight_in");
    
        res=platform_get_resource(pdev,IORESOURCE_MEM,0);
        if(!res){
            dev_err(dev, "failed to get timer base mem resource\n");
            return -ENOMEM;
        }
    
        timer=devm_ioremap_resource(dev,res);
        if(timer<0){
            dev_err(dev, "failed to get timer base mem\n");
            return -ENOMEM;
        }
        printk("p:\ttimer: %p\n",timer);
    
        clk=devm_clk_get(dev,"timers");
        if(IS_ERR(clk)){
            dev_err(dev, "failed to get timer base clk\n");
            return PTR_ERR(clk);
            }   
    
        clk_prepare(clk);
        //timer_debug;
    
        timer->TCFG0  = 0xf00;
            timer->TCFG1  = 0x10004;
        error=init_timer_for_1wire(clk);
    
        //error = clk_enable((clk));
        if(error){
            printk("init timer error");
            return -1;
        }
    
        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
        if (irq == NULL){
                printk("platform_get_resource irq error\n");
            return -EINVAL;
            }
        ret = devm_request_irq(dev, irq->start, timer_for_1wire_interrupt , IRQF_TIMER, "backlight", NULL);
            if (ret)
            {
            dev_err(dev, "unable to request irq\n");
            return -EINVAL;
            }   
    
        timer->TINT_CSTAT=0x108;
    
        /*create cdev*/
        error=alloc_chrdev_region(&devid, 0, dev_num, "one_write");
        if(error){
            dev_err(dev, "alloc region failed.\n");
            goto err0;
        }
        major = MAJOR(devid);
        cdev_init(&gpj1_3_cdev, &gpj1_3_fops);
        cdev_add(&gpj1_3_cdev, MKDEV(major, 0), dev_num);
            gpj_class=class_create(THIS_MODULE,"gpj_1_3");  
            class_dev=device_create(gpj_class, NULL, devid, NULL, devname); 
    
        start_one_wire_session(0xf0);
        //printk("after first session\n");
        //timer_debug;
    
        start_one_wire_session(0xf0);
        //printk("after first session\n");
        //timer_debug;
    
    
        return 0;
    
    err0:
            return -EINVAL;
    }
    
    static int pinctrl_remove(struct platform_device *pdev) {
        printk("%s enter.\n", __func__);
        clk_enable(clk);
        unregister_chrdev_region(devid,dev_num);
        cdev_del(&gpj1_3_cdev);
        device_destroy(gpj_class,MKDEV(major, 0));
        class_destroy(gpj_class);
        return 0;
    }
    
    static const struct of_device_id dt_ids[] = {
            { .compatible = "tiny4412,backlight_demo", },
            {},
    };
    
    MODULE_DEVICE_TABLE(of, dt_ids);
    
    static struct platform_driver backlight_driver = {
        .driver        = {
             .name    = "one_write",
             .of_match_table    = of_match_ptr(dt_ids),
        },
         .probe        = pinctrl_probe,
         .remove        = pinctrl_remove,
    };
    
    static int backlight_init(void){
        int ret;
    
        printk("%s enter.\n", __func__); 
            ret = platform_driver_register(&backlight_driver);
            if (ret)
                printk(KERN_ERR "int demo: probe failed: %d\n", ret);
    
            return ret;
    }
    
    static void backlight_exit(void){
    
        printk("%s enter.\n", __func__);
        platform_driver_unregister(&backlight_driver);
    }
    
    module_init(backlight_init);
    module_exit(backlight_exit);
    MODULE_LICENSE("GPL");
    

    效果:

    这里写图片描述

    展开全文
  • 我的背光驱动解决方案

    千次阅读 2013-12-01 14:13:35
    这里将我自己在按键驱动上修改的背光驱动部分贴出来。供大家参考。 问题描述: CPU:PXA270,背光显示控制芯片LT1937ES5。要求实现空闲状态下关闭LED背光灯,工作时,第一次按键点亮LED灯,后面的按键才是工作。 ...
  • MTK LCD+KEYPAD背光驱动

    千次阅读 2013-12-09 17:33:45
    由于Tango+3G的背光电路没有加上背光芯片,所以上图中的Backlight IC为虚线框。但在硬件电路上是预留出了背光IC的位置,只是没有焊上芯片而已。 由上图可知,Tango+3G的LCD背光和KEYPAD背光是由KPLED引脚一起控制的...
  • 由于大多数便携式数码产品,例如手机、数码相机、MP3、PMP以及数码相框都会需要显示模块,因而WLED背光驱动电源的设计也就越来越受到关注。它的性能会直接影响到显示效果,显示模块的寿命及电池的待机时间。为此,很...
  • 为了迎合智能手机市场的这种需求并和手机行业一同成长,国内一些芯片设计公司都陆续推出了Turnkey智能手机解决方案,其中有支持Windows Mobile操作系统的海思半导体的K3智能手机,还有支持Android操作系统的福州...
  • 随着数码产品的飞速发展和迅速普及,数码产品的内部器件也而临更高的要求,由于大多数便携式数码产品例如手机、数码相机、MP3、PMP以及数码相框都会需要显示模块,其中的WLED背光驱动电源的设计也就越来越受到关注。...
  • AnalogicTech 推出创新解决方案的模拟半导体公司,于今天正式宣布进入 LED 背光 液晶电视市场,将开始研发创新型电源管理半导体系统,并发布了可显著增强 LED 背光液晶电视能效和用户体验的个芯片组系列,以此作为其...
  • 于今天正式宣布进入 LED 背光液晶电视市场,将开始研发创新型电源管理半导体系统,并发布了可显著增强 LED 背光液晶电视能效和用户体验的个芯片组系列,以此作为其市场扩张和多元化战略的一部分。  “推出这些瞄准...
  • 随着数码产品的飞速发展和迅速普及,数码产品的内部器件也面临了更高的要求,由于大多数便携式数码产品例如手机,数码相机,MP3,PMP以及数码相框都会需要显示模块,其中的WLED背光驱动电源的设计也就越来越受到关注...
  • 启攀微电子(上海)有限公司(Chiphomer Technology Limited)日前发布一款具有开路保护功能的串联白光驱动芯片CP2129。作为恒流驱动白光LED的升压DC/DC转换器件,CP2129可驱动2~6颗串联LED,特别适用作手机、数码相机、...
  • AIC1848是台湾沛亨半导体股份有限公司针对手机、PDA(掌上电脑)、数字相机等可携式电子产品,推出的一款并联式白光LED的驱动芯片。 AIC1848采用两倍电荷泵(2XCharge-Pump)提供稳定的5V输出电压,并以恒定电压的...
  • LCD(四)LCD背光驱动之misc

    千次阅读 2018-05-06 22:12:35
     电源管理芯片是一个LED驱动器,相当于一个LED开关。MMU通过操作PWM相关寄存器来产生不同的波形,从而间接控制LCD背光灯的亮度。 二、原理图分析     由原理图可得背光由GPD0_0口控制。 三、backl...
  • 惠博升HBS1621E LCD显示驱动芯片pdf,LCD液晶屏显示驱动芯片介绍: HBS1621 SSOP48 32Seg*4com, 128点阵, HBS1622C SOP28 12seg*8com点阵 HBS1622D SOP28 15seg*8com点阵 HBS1721 SSOP48 32seg*4com ,4*6按键...
  • 聚积科技独具特色的在其LED驱动芯片上皆内建了ESD防护架构。这些芯片包括用于显示应用的MBI517、用于照明应用的MBI1816和用于背光应用的MBI1816。    为了提升ESD防护能力,聚积所推出的新产品更由传统的HBM ...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 244
精华内容 97
关键字:

背光驱动芯片