<form id="bpvnp"></form>

            <address id="bpvnp"><listing id="bpvnp"><meter id="bpvnp"></meter></listing></address>

                <address id="bpvnp"><nobr id="bpvnp"><menuitem id="bpvnp"></menuitem></nobr></address>

                    技术文摘

                    input子系统(二)——GSC3280一线触摸屏驱动












                    一、系统简介

                    本文介绍友善之臂一线触摸屏接到GSC3280开发板的驱动。本文中,首先讲述GSC3280内部定时器驱动,该驱动作为一线触摸屏数据传送时的采样定时器。然后讲述一线触摸屏协议驱动。最后讲述通过一线触摸屏的协议,控制触摸屏的背光,并且通过滑动变阻器来线性控制触摸屏的背光,提供了底层和应用层程序。

                    二、GSC3280内部定时器驱动

                    GSC3280芯片包含一个TIMER定时器???,TIMER定时器??榘琓IMER0~TIMER3共4个相对独立的32bit 定时器,每一个定时器都有自己独立的时钟源,均支持循环定时模式和单次定时模式两种工作模式,每个定时器都有各自的中断,TIMER定时器??榻?个中断合并为一个中断输出给中断控制器,并额外提供一个int_for_adc中断。

                    首先看下定时器??槌跏蓟齡sc3280_timer_init():

                    1.  struct gsc3280_timer {

                    2.      bool in_use;

                    3.      void __iomem *base;

                    4.      unsigned long rate;

                    5.      struct gsc3280_hard_timer *h_timer;

                    6.      char *name;

                    7.  };

                    8.  static struct gsc3280_timer gsc3280_timer_priv[GSC3280_H_TIMER_NR] = {

                    9.      {false, (__iomem void *)GSC3280_TIMER_BASEADDR + 0x00,    0, NULL, "Timer0"},

                    10.    {false, (__iomem void *)GSC3280_TIMER_BASEADDR + 0x14,    0, NULL, "Timer1"},

                    11.    {false, (__iomem void *)GSC3280_TIMER_BASEADDR + 0x28,    0, NULL, "Timer2"},

                    12.    {false, (__iomem void *)GSC3280_TIMER_BASEADDR + 0x3C,    0, NULL, "Timer3"}

                    13.};

                    14.static int __init gsc3280_timer_init(void)

                    15.{

                    16.    int i = 0;

                    17.    struct clk *clk = NULL;

                    18.    timer_tcr_u tcr = {.w32 = 0};

                    19. 

                    20.    DBG("############");

                    21.    DBG("gsc3280 timer init start\n");

                    22.    //enable timer modules

                    23.    sysctl_mod_enable(SYSCTL_MOD_TIMER0);

                    24.    sysctl_mod_enable(SYSCTL_MOD_TIMER1);

                    25.    sysctl_mod_enable(SYSCTL_MOD_TIMER2);

                    26.    sysctl_mod_enable(SYSCTL_MOD_TIMER3);

                    27.    //get 4 timer rate, use this cal LC

                    28.    clk = clk_get(NULL, "timer0");

                    29.    gsc3280_timer_priv[TIMER0].rate = clk_get_rate(clk);

                    30.    clk = clk_get(NULL, "timer1");

                    31.    gsc3280_timer_priv[TIMER1].rate = clk_get_rate(clk);

                    32.    clk = clk_get(NULL, "timer2");

                    33.    gsc3280_timer_priv[TIMER2].rate = clk_get_rate(clk);

                    34.    clk = clk_get(NULL, "timer3");

                    35.    gsc3280_timer_priv[TIMER3].rate = clk_get_rate(clk);

                    36.    for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    37.        if (gsc3280_timer_priv[i].rate == 0) {

                    38.            DBG("GSC3280 TIMER%d Get Rate Failed!", i);

                    39.            return -EAGAIN;

                    40.        }

                    41.        DBG("timer[%d] = %ld\n", i, gsc3280_timer_priv[i].rate);

                    42.        tcr.w32 = __raw_readl(gsc3280_timer_priv[i].base + TIMER_CR);

                    43.        tcr.b.enable = 0;    //disable timer

                    44.        tcr.b.irq_mask = 1;        //mask timer irq

                    45.        __raw_writel(tcr.w32, gsc3280_timer_priv[i].base + TIMER_CR);

                    46.    }

                    47.    printk(KERN_INFO "GSC3280 TIMER0~3 Enable Success!");

                    48.    DBG("############");

                    49.    return 0;

                    50.}

                    51.core_initcall(gsc3280_timer_init);


                    说明:

                    1) 首先在系统控制??橹惺鼓芩母龆ㄊ逼髂??。

                    2) 分别获取定时器的时钟频率。

                    3) 最后,分别初始化定时器的控制寄存器。

                    4) 注意此处初始化使用的是core_initcall()宏,具有很高的执行优先级。

                    然后看下申请定时器函数,该函数即为一线触摸屏驱动中使用的申请定时器函数。

                    1.  int gsc3280_request_hard_timer(struct gsc3280_hard_timer *h_timer)

                    2.  {

                    3.      int i = 0, ret = 0;

                    4.   

                    5.      for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    6.          if (gsc3280_timer_priv[i].h_timer == NULL) {

                    7.              gsc3280_timer_priv[i].h_timer = h_timer;

                    8.              ret = request_irq(EXT_GSC3280_TIMER_IRQ, &gsc3280_timer_interrupt, 

                    9.                                  IRQF_SHARED, gsc3280_timer_priv[i].name, 

                    10.                                &gsc3280_timer_priv[i]);

                    11.            if (ret) {

                    12.                printk(KERN_ERR "Start hard Timer request irq failed!\n");

                    13.                return ret;

                    14.            }

                    15.            DBG("GSC3280 Request Timer Success.");

                    16.            return 0;

                    17.        }

                    18.    }

                    19.    DBG("GSC3280 Request Timer error!");

                    20.    return -EBUSY;

                    21.}

                    22.EXPORT_SYMBOL(gsc3280_request_hard_timer);


                    说明:

                    1) 首先通过for循环找到第一个没有被使用的硬件定时器。

                    2) 找到后,申请中断。由前面介绍可知,四个定时器共享中断。该中断函数接下里会讲述。

                    3) 如果申请中断失败,直接退出。

                    gsc3280_timer_interrupt()函数如下所示:

                    1.  static irqreturn_t gsc3280_timer_interrupt(int irq, void *_ptr)

                    2.  {

                    3.      irqreturn_t ret = IRQ_NONE;

                    4.      struct gsc3280_timer *timer = (struct gsc3280_timer *)_ptr;

                    5.   

                    6.      if (__raw_readl(timer->base + TIMER_IS) & 0x01) {

                    7.          //is real interrupt

                    8.          timer->h_timer->function(timer->h_timer->data);

                    9.          ret = IRQ_HANDLED;

                    10.    }

                    11.    //clr interrupt bit

                    12.    __raw_readl(timer->base + TIMER_EOI);

                    13.    return ret;

                    14.}


                    说明:

                    1) 进入中断后,首先读取中断状态寄存器查看是否真的有中断,不是误触发。

                    2) 如果是真的中断,执行中断回调函数。

                    3) 通过读取方式清除中断标志,以便下次能够再次进入中断。       

                    释放硬件定时器函数如下所示:

                    1.  void gsc3280_free_hard_timer(struct gsc3280_hard_timer *h_timer)

                    2.  {

                    3.      int i = 0;

                    4.   

                    5.      for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    6.          if (gsc3280_timer_priv[i].h_timer == h_timer) {

                    7.              if (gsc3280_timer_priv[i].in_use)

                    8.                  gsc3280_timer_stop(h_timer);

                    9.              free_irq(EXT_GSC3280_TIMER_IRQ, &gsc3280_timer_priv[i]);

                    10.            gsc3280_timer_priv[i].h_timer = NULL;

                    11.        }

                    12.    }

                    13.}

                    14.EXPORT_SYMBOL(gsc3280_free_hard_timer);


                    说明:

                    1) 通过for循环和传入的形参找到释放的定时器

                    2) 判断定时器是否在使用,如果使用,停止定时器。

                    3) 释放定时器中断。

                    4) 定时器变量清除。

                    接下来讲述比较重要的函数,开启定时器gsc3280_timer_start():
                    1.  static void start_hard_timer(struct gsc3280_timer *timer)

                    2.  {

                    3.      unsigned long tlc = 0;

                    4.      timer_tcr_u tcr = {.w32 = 0};

                    5.      

                    6.      if (timer->h_timer->value_type == 0)

                    7.          tlc = (timer->rate * timer->h_timer->expires) /1000;

                    8.      else

                    9.          tlc = timer->rate / timer->h_timer->bps - 1;

                    10.    tcr.w32 = __raw_readl(timer->base + TIMER_CR);

                    11.    if (timer->h_timer->type == LOOP)

                    12.        tcr.b.mode = 1;

                    13.    else

                    14.        tcr.b.mode = 0;

                    15.    __raw_writel(tcr.w32, timer->base + TIMER_CR);

                    16.    __raw_writel(tlc, timer->base + TIMER_LC);

                    17.    //Enable Timer Interupt

                    18.    tcr.w32 = __raw_readl(timer->base + TIMER_CR);

                    19.    tcr.b.irq_mask = 0;        //not mask timer irq

                    20.    tcr.b.enable = 1;    //enable timer

                    21.    __raw_writel(tcr.w32, timer->base + TIMER_CR);

                    22.    __raw_readl(timer->base + TIMER_EOI);

                    23.    timer->in_use = true;

                    24.}

                    25.int gsc3280_timer_start(struct gsc3280_hard_timer *h_timer)

                    26.{

                    27.    int i =0;

                    28. 

                    29.    if ((h_timer->data == 0) || (h_timer->function == NULL)) {

                    30.        printk(KERN_ERR "GSC3280 Request Timer, But The Param Wrong!");

                    31.        return -EINVAL;

                    32.    }

                    33.    for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    34.        if (gsc3280_timer_priv[i].h_timer == h_timer) {

                    35.            if (!gsc3280_timer_priv[i].in_use)

                    36.                start_hard_timer(&gsc3280_timer_priv[i]);

                    37.            return 0;

                    38.        }

                    39.    }

                    40.    DBG("gsc3280_timer_start error!!!!\n");

                    41.    return -EBUSY;

                    42.}

                    43.EXPORT_SYMBOL(gsc3280_timer_start);


                    说明:

                    1) 首先检查形参变量,如果变量错误,直接返回。

                    2) 根据形参变量寻找相应的定时器,调用start_hard_timer()函数开启定时器。

                    3) start_hard_timer()函数首先根据需要定时的类型,计算定时器的重载值。对于本定时器驱动,支持两种分辨率的定时时间。第一种为毫秒级,该方法定时误差较大。第二种为bit每秒,即高精度定时,本文所使用的即是此种定时方法。然后操作控制寄存器,打开中断,使能定时器,让定时器开始工作。        

                    接下来讲述停止定时器函数gsc3280_timer_stop():

                    1.  static void stop_hard_timer(struct gsc3280_timer *timer)

                    2.  {

                    3.      timer_tcr_u tcr = {.w32 = 0};

                    4.   

                    5.      tcr.w32 = __raw_readl(timer->base + TIMER_CR);

                    6.      tcr.b.irq_mask = 1;        //mask timer irq

                    7.      tcr.b.enable = 0;    //disable timer

                    8.      __raw_writel(tcr.w32, timer->base + TIMER_CR);

                    9.      timer->in_use = false;

                    10.}

                    11.void gsc3280_timer_stop(struct gsc3280_hard_timer *h_timer)

                    12.{

                    13.    int i= 0;

                    14. 

                    15.    for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    16.        if (gsc3280_timer_priv[i].h_timer == h_timer) {

                    17.            if (gsc3280_timer_priv[i].in_use) {

                    18.                stop_hard_timer(&gsc3280_timer_priv[i]);

                    19.                break;

                    20.            }

                    21.        }

                    22.    }

                    23.}

                    24.EXPORT_SYMBOL(gsc3280_timer_stop);


                    说明:

                    1) 首先根据形参寻找相应的定时器。

                    2) 找到后,判断定时器是否在使用,如果在使用,调用函数stop_hard_timer()停止定时器。

                    3) stop_hard_timer()函数中,就是操作控制寄存器,屏蔽中断,禁止定时器。       

                    最后介绍重新启动定时器函数gsc3280_mod_timer():

                    1.  int gsc3280_mod_timer(struct gsc3280_hard_timer *h_timer)

                    2.  {

                    3.      int i = 0;

                    4.   

                    5.      for (i = 0; i < GSC3280_H_TIMER_NR; i++) {

                    6.          if (gsc3280_timer_priv[i].h_timer == h_timer) {

                    7.              if (gsc3280_timer_priv[i].in_use) {

                    8.                  stop_hard_timer(&gsc3280_timer_priv[i]);

                    9.                  start_hard_timer(&gsc3280_timer_priv[i]);

                    10.            }

                    11.        }

                    12.    }

                    13.    return 0;

                    14.}

                    15.EXPORT_SYMBOL(gsc3280_mod_timer);


                    说明:

                    1) 该函数首先通过形参寻找相应的定时器。

                    2) 找到后,判断定时器是否在使用,如果在使用,首先停止定时器,然后再一次开启。







                    三、一线触摸屏协议驱动

                    3.1、一线触摸屏协议的基本内容

                    一线触摸屏首先定义一个软定时器,该定时器每隔25ms执行一次,在该定时器的中断函数中,会判断此次是什么类型的数据传输,包括初始化一线触摸屏、控制背光命令或者读取触摸屏位置信息命令。命令设置成功后,进入测量函数,在测量函数中,打开硬件定时器,使用位速率为9600和一线触摸屏通信,最后取得有效数据后,如果是测量位置信息,通过input子系统将其报告给应用层,如果是控制背光,则什么也不做。






                    3.2、一线触摸屏系统初始化和退出函数

                    1.  #if defined(CONFIG_GSC3280_1WIRE_TS)

                    2.  static struct platform_device ts_1wire_device = {

                    3.      .name    = "ts_1wire_device",

                    4.      .id        = -1,

                    5.  };

                    6.  #endif

                    7.  static struct platform_driver ts_1wire_device_driver = {

                    8.      .probe    = ts_1wire_probe,

                    9.      .remove    = __devexit_p(ts_1wire_remove),

                    10.    .driver    = {

                    11.        .name    = "ts_1wire_device",

                    12.        .owner    = THIS_MODULE,

                    13.    }

                    14.};

                    15. 

                    16.static int __init ts_1wire_init(void)

                    17.{

                    18.    return platform_driver_register(&ts_1wire_device_driver);

                    19.}

                    20.static void __exit ts_1wire_exit(void)

                    21.{

                    22.    platform_driver_unregister(&ts_1wire_device_driver);

                    23.}

                    24.module_init(ts_1wire_init);

                    25.module_exit(ts_1wire_exit);

                    26. 

                    27.MODULE_AUTHOR("Davied<apple_guet@126.com>");

                    28.MODULE_DESCRIPTION("GSC3280 one wire ts Driver");

                    29.MODULE_LICENSE("GPL");

                    30.MODULE_ALIAS("gsc3280 one wire ts")

                           
                    说明:

                    1) 将一线触摸屏定义为平台设备,因为它不操作任何CPU内部资源,所以平台设备的定义中只有名称和id。

                    2) 使用平台设备的注册和注销函数对其进行操作。

                    接下来讲述平台设备的探测函数ts_1wire_probe(),程序如下:

                    1.  static int ts_1wire_probe(struct platform_device *pdev)

                    2.  {

                    3.      int ret = 0;

                    4.      struct ts_1wire_t *ts = NULL;

                    5.      struct input_dev *input = NULL;

                    6.   

                    7.      DBG("############\n");

                    8.      printk(KERN_INFO "ts 1wire probe start.\n");

                    9.      ts = kzalloc(sizeof(struct ts_1wire_t), GFP_KERNEL);

                    10.    if (!ts) {

                    11.        DBG("kzalloc error\n");

                    12.        return -ENOMEM;

                    13.    }

                    14.    input = input_allocate_device();

                    15.    if (!input) {

                    16.        ret = -ENOMEM;

                    17.        goto err_free_mem;

                    18.    }

                    19.    spin_lock_init(&ts->slock);

                    20.    ts->dev = &pdev->dev;

                    21.    snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(ts->dev));

                    22.    input->name = "h3600_ts";

                    23.    input->phys = ts->phys;

                    24.    input->dev.parent = ts->dev;

                    25.    input->id.vendor = 0x00;    //tsdev->vendor;

                    26.    input->id.version = 0x00;    //tsdev->rev;

                    27.    input->id.product = 0x03;    //tsdev->rev;

                    28.    input->id.bustype = BUS_HOST;    //should be spi 

                    29.    input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);

                    30.    input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);

                    31.    ts->input = input;

                    32.    input_set_abs_params(ts->input, ABS_X, GSC_X_MIN, GSC_X_MAX, GSC_X_FUZZ, 0);

                    33.    input_set_abs_params(ts->input, ABS_Y, GSC_Y_MIN, GSC_Y_MAX, GSC_Y_FUZZ, 0);

                    34.    input_set_abs_params(ts->input, ABS_PRESSURE, GSC_PRESSURE_MIN, GSC_PRESSURE_MAX, 0, 0);

                    35.    ret = input_register_device(ts->input);

                    36.    if (ret) {

                    37.        DBG("!!!!input register device error!\n");

                    38.        goto err_free_input;

                    39.    }

                    40.    strlcpy(ts->name, TS_1WIRE_NAME, sizeof(ts->name));

                    41.    ret = gpio_request(TS_1WIRE_DATA_PIN, "TS_1WIRE_DATA_PIN");

                    42.    if (ret) {

                    43.        DBG("gpio request error!\n");

                    44.        goto err_free_input;

                    45.    }

                    46.    set_pin_up();

                    47.    set_pin_value(1);

                    48.    set_pin_as_output();

                    49.    

                    50.    init_hard_timer_for_1wire(ts);

                    51.    ret = gsc3280_request_hard_timer(&ts->ts_hard_timer);

                    52.    if (ret) {

                    53.        DBG("gsc3280 request hard timer error\n");

                    54.        goto err_gpio_req;

                    55.    }

                    56.    ret = misc_register(&bl_misc);

                    57.    if (ret != 0) {

                    58.        DBG("misc_register bl_misc error!\n");

                    59.        goto err_hard_timer_req;

                    60.    }

                    61.    ts->one_wire_status = IDLE;

                    62.    init_timer(&ts_1wire_timer);

                    63.    ts_1wire_timer.data = (unsigned long)ts;

                    64.    ts_1wire_timer.expires = jiffies + TIMER_DELAY;

                    65.    ts_1wire_timer.function = one_wire_timer_callback;

                    66.    add_timer(&ts_1wire_timer);

                    67.    mutex_lock(&wire1_ts_list_lock);

                    68.    list_add(&ts->device_entry, &wire1_ts_list);

                    69.    mutex_unlock(&wire1_ts_list_lock);

                    70.    platform_set_drvdata(pdev, ts);

                    71.    printk(KERN_INFO "ts 1wire probe success.\n");

                    72.    DBG("############\n");

                    73.    return 0;

                    74. 

                    75.err_hard_timer_req:

                    76.    gsc3280_free_hard_timer(&ts->ts_hard_timer);

                    77.err_gpio_req:

                    78.    gpio_free(TS_1WIRE_DATA_PIN);

                    79.err_free_input:

                    80.    input_free_device(input);

                    81.err_free_mem:

                    82.    kfree(ts);

                    83.    printk(KERN_INFO "!!!!ts 1wire probe error!!!!!\n");

                    84.    return ret;

                    85.}

                    说明:

                    1) 首先申请一线触摸屏结构体内存。

                    2) 然后申请input设备内存。

                    3) 接下来初始化一线触摸屏结构体成员变量,包括自旋锁、IO申请等。

                    4) 申请硬件定时器。将控制背光定义为混杂设备。

                    5) 申请软件定时器,包括设置数据、延时时间和回调函数,然后将这个软定时器加入到系统中。




                    3.3、软定时器程序分析

                    根据前面的一线电阻触摸屏原理分析,首先看下回调函数one_wire_timer_callback():

                    1.  static void one_wire_timer_callback(unsigned long data)

                    2.  {

                    3.      unsigned long flags = 0;

                    4.      struct ts_1wire_t *ts = (struct ts_1wire_t *)data;

                    5.   

                    6.      //mod_timer(&ts_1wire_timer, jiffies + TIMER_DELAY);

                    7.      spin_lock_irqsave(&ts->slock, flags);

                    8.      if (ts->lcd_type == 0) {

                    9.          //DBG("REQ_INFO\n");

                    10.        ts->req = REQ_INFO;

                    11.    }

                    12.    else if (!ts->backlight_init_success) {

                    13.        //DBG("backlight_init_success\n");

                    14.        ts->backlight_init_success = 1;

                    15.        ts->req = BL_INIT;

                    16.    }

                    17.    else if (ts->backlight_req) {

                    18.        //DBG("backlight_req\n");

                    19.        ts->req = ts->backlight_req;

                    20.        ts->backlight_req = 0;

                    21.    } else {

                    22.        //DBG("REQ_TS\n");

                    23.        ts->req = REQ_TS;

                    24.    }

                    25.    spin_unlock_irqrestore(&ts->slock, flags);

                    26.    start_one_wire_session(ts);

                    27.}

                    说明:

                    1) 首先上自旋锁,防止多个CPU在执行此函数。

                    2) 根据不同的类型,赋值不同的命令?;袢〈ッ廖恢眯畔⑹悄厦?。系统启动后,REQ_INFO和BL_INIT命令一般只执行一次。

                    3) 释放自旋锁,开始一次会话。

                    会话函数start_one_wire_session(ts)如下所示:

                    1.  static void start_one_wire_session(struct ts_1wire_t *ts)

                    2.  {

                    3.      u8 crc = 0;

                    4.      unsigned long flags = 0;

                    5.      

                    6.      if (ts->one_wire_status != IDLE) {

                    7.          DBG("one_wire_status: %d error!!!!\n", ts->one_wire_status);

                    8.          return;

                    9.      }

                    10.    spin_lock_irqsave(&ts->slock, flags);

                    11.    ts->one_wire_status = START;    //IDLE to START

                    12.    set_pin_value(1);

                    13.    set_pin_as_output();

                    14.    crc8_init(crc);

                    15.    crc8(crc, ts->req);

                    16.    ts->io_data = (ts->req << 8) + crc;

                    17.    ts->io_data <<= 16;

                    18.    ts->io_bit_count = 1;

                    19.    set_pin_as_output();

                    20.    spin_unlock_irqrestore(&ts->slock, flags);

                    21.    

                    22.    local_irq_save(flags);

                    23.    gsc3280_timer_start(&ts->ts_hard_timer);

                    24.    set_pin_value(0);

                    25.    local_irq_restore(flags);

                    26.}

                    说明:

                    1) 首先判断触摸屏状态,如果是不是IDLE,错误退出。

                    2) 上自旋锁,初始化触摸屏状态为开始,设置一线IO管脚状态,计算crc,组装数据。

                    3) 解自旋锁,开启硬件定时器,启动传输。


                            


                    3.4、硬件定时器传输数据

                    1.  static void init_hard_timer_for_1wire(struct ts_1wire_t *ts)

                    2.  {

                    3.      ts->ts_hard_timer.type = LOOP;

                    4.      ts->ts_hard_timer.value_type = 1;

                    5.      ts->ts_hard_timer.bps = SAMPLE_BPS;

                    6.      ts->ts_hard_timer.function = ts_1wire_hardtimer_callback;

                    7.      ts->ts_hard_timer.data = (unsigned long)ts;

                    8.  }

                    9.  static void ts_1wire_hardtimer_callback(unsigned long data)

                    10.{

                    11.    struct ts_1wire_t *ts = (struct ts_1wire_t *)data;

                    12. 

                    13.    //DBG("ts_1wire_hardtimer_callback start\n");

                    14.    ts->io_bit_count--;

                    15.    switch(ts->one_wire_status) {

                    16.    case START:

                    17.        //DBG("START\n");

                    18.        if (ts->io_bit_count == 0) {

                    19.            ts->io_bit_count = 16;

                    20.            ts->one_wire_status = REQUEST;

                    21.        }

                    22.        break;

                    23.    case REQUEST:

                    24.        //Send a bit

                    25.        //DBG("REQUEST\n");

                    26.        set_pin_value(ts->io_data & (1U << 31));

                    27.        ts->io_data <<= 1;

                    28.        if (ts->io_bit_count == 0) {

                    29.            ts->io_bit_count = 2;

                    30.            ts->one_wire_status = WAITING;

                    31.        }

                    32.        break;

                    33.    case WAITING:

                    34.        //DBG("WAITING\n");

                    35.        if (ts->io_bit_count == 0) {

                    36.            ts->io_bit_count = 32;

                    37.            ts->one_wire_status = RESPONSE;

                    38.        }

                    39.        else if (ts->io_bit_count == 1) {

                    40.            set_pin_as_input();

                    41.            set_pin_value(1);

                    42.        }

                    43.        break;

                    44.    case RESPONSE:

                    45.        //Get a bit

                    46.        //DBG("RESPONSE\n");

                    47.        ts->io_data = (ts->io_data << 1) | get_pin_value();

                    48.        if (ts->io_bit_count == 0) {

                    49.            ts->io_bit_count = 2;

                    50.            ts->one_wire_status = STOPING;

                    51.            set_pin_value(1);

                    52.            set_pin_as_output();

                    53.            one_wire_session_complete(ts);

                    54.        }

                    55.        break;

                    56.    case STOPING:

                    57.        //DBG("STOPING\n");

                    58.        if (ts->io_bit_count == 0) {

                    59.            ts->one_wire_status = IDLE;

                    60.            gsc3280_timer_stop(&ts->ts_hard_timer);

                    61.            mod_timer(&ts_1wire_timer, jiffies + TIMER_DELAY);

                    62.        }

                    63.        break;

                    64.    default:

                    65.        //DBG("default\n");

                    66.        gsc3280_timer_stop(&ts->ts_hard_timer);

                    67.        mod_timer(&ts_1wire_timer, jiffies + TIMER_DELAY);

                    68.        break;

                    69.    }

                    70.}

                    说明:

                    1) 硬件定时器初始化init_hard_timer_for_1wire()函数在驱动探测函数中执行,此函数定义了硬件定时器工作在循环模式,数据类型为位速率,位速率为9600,定义了硬件定时器的回调函数。

                    2) 在硬件定时函数中,通过一个switch-case结构来区分不同的工作状态。启动一次会话后,其工作状态分别经过:START->REQUEST->WAITING->RESPONSE->STOPING。

                    3) 在START中,首先设置REQUEST中需要传送的位数为16位。在REQUEST中传送完16位数据后,设置进入两次WAITING状态。第一次WAITING将IO管脚设置为输入,准备接收数据。第二次WAITING设置当前状态为RESPONSE,接收数据长度为32位。在RESPONSE中,接收到32位数据后,设置进入两次STOPING,并且调用one_wire_session_complete(ts);函数表示一次会话完成。第二次进入STOPING后,停止硬件定时器,重新启动软件定时器。

                    one_wire_session_complete(ts);函数如下所示:

                    1.  static inline void notify_info_data(struct ts_1wire_t *ts, unsigned char lcd_type, 

                    2.                                      unsigned char ver_year, unsigned char week)

                    3.  {

                    4.      if (lcd_type != 0xFF) {

                    5.          ts->lcd_type = lcd_type;

                    6.          //firmware_ver = ver_year * 100 + week;

                    7.      }

                    8.  }

                    9.  static inline void notify_bl_data(struct ts_1wire_t *ts, u8 a, u8 b, u8 c)

                    10.{

                    11.    ts->bl_ready = 1;

                    12.    wake_up_interruptible(&bl_waitq);

                    13.}

                    14.static void one_wire_session_complete(struct ts_1wire_t *ts)

                    15.{

                    16.    u8 crc = 0;

                    17.    const unsigned char *p = (const u8*)&(ts->io_data);

                    18. 

                    19.    crc8_init(crc);

                    20.    crc8(crc, p[3]);

                    21.    crc8(crc, p[2]);

                    22.    crc8(crc, p[1]);

                    23.    if (crc != p[0]) {

                    24.        DBG("one_wire_session_complete crc error\n");

                    25.        return;

                    26.    }

                    27.    switch(ts->req) {

                    28.    case REQ_TS:

                    29.        ts->x = ((p[3] >> 4U) << 8U) + p[2];

                    30.        ts->y = ((p[3] & 0xFU) << 8U) + p[1];

                    31.        ts->z = (ts->x != 0xFFFU) && (ts->y != 0xFFFU);

                    32.        notify_ts_data(ts);

                    33.        break;

                    34.    case REQ_INFO:

                    35.        notify_info_data(ts, p[3], p[2], p[1]);

                    36.        break;

                    37.    default:

                    38.        notify_bl_data(ts, p[3], p[2], p[1]);

                    39.        break;

                    40.    }

                    41.}

                    说明:

                    1) 函数首先进行crc校验,如果crc错误,则直接退出。

                    2) 如果校验正确,根据不同的命令,进入不同的报告类型。其中REQ_TS和REQ_INFO不需要向应用层报告数据。notify_info_data()函数通过修改ts->lcd_type变量来保证系统起来以后,一线触摸屏执行REQ_INFO命令只有一次。


                    notify_ts_data(ts);函数如下所示:

                    1.  static void gsc3280_report_event(struct ts_1wire_t *ts, u32 z)

                    2.  {

                    3.  #ifdef CONFIG_GSC3280_POS_PRINT

                    4.      printk(KERN_INFO "x = %d\n", ts->x);

                    5.      printk(KERN_INFO "y = %d\n", ts->y);

                    6.      printk(KERN_INFO "z = %d\n", z);

                    7.  #endif

                    8.   

                    9.      input_report_abs(ts->input, ABS_PRESSURE, z);

                    10.    input_report_abs(ts->input, ABS_X, ts->x);

                    11.    input_report_abs(ts->input, ABS_Y, ts->y);

                    12.    if (z > 0)

                    13.        input_report_key(ts->input, BTN_TOUCH, 1);

                    14.    else

                    15.        input_report_key(ts->input, BTN_TOUCH, 0);

                    16.    input_sync(ts->input);

                    17.}

                    18.static inline void notify_ts_data(struct ts_1wire_t *ts)

                    19.{

                    20.    if (ts->z == 1) {

                    21.        ts->x = ((ts->x -285) * gXres) / (3944 - 285);

                    22.        ts->y = ((3936 - ts->y) * gYres) / (3936 - 102);

                    23.        if ((ts->x > 0) && (ts->x < gXres) && (ts->y > 0) && (ts->y < gYres)) {

                    24.            if (ts->flg == 0) {

                    25.                ts->flg = 1;

                    26.                gsc3280_report_event(ts, 0);

                    27.            }

                    28.            gsc3280_report_event(ts, ts->z);

                    29.        }

                    30.    } else if (ts->z == 0) {

                    31.        if (ts->flg == 1) {

                    32.            ts->flg = 0;

                    33.            gsc3280_report_event(ts, 0);

                    34.        }

                    35.    }

                    36.}

                    说明:

                    1) 首先根据公式计算触摸点的绝对坐标,如果该坐标值在正确的范围内,则上报该位置信息。

                    2) 由于是电阻触摸屏,其电阻值和位置是线性的,公式为:(电压- 0) / (总电压) = (分辨个数- 0) / (总个数)。即分辨个数= 总个数* (电压) / (总电压)。通过测量触摸屏四个脚点的电压值,分别得到X和Y方向上的最大总电压,然后在实际测量中,根据测得的电压值,带入公式中的电压项,分别计算出X和Y方向的绝对坐标。本文使用的触摸屏分辨率为800*480,所以X方向的总个数为800,Y方向的为480。

                    3) 位置报告函数将在第三篇文章----input核心中讲述。

                    4) 本文设计的程序可以通过make menuconfig命令输入分辨率,Kconfig程序如下:

                    1.  config INPUT_TSDEV_SCREEN_X

                    2.      int "Horizontal screen resolution"

                    3.      depends on INPUT_TOUCHSCREEN

                    4.      default "800"

                    5.      help

                    6.       If you're using a digitizer, this is the X window screen resolution you are 

                    7.       using to correctly scale the data. If you're not using a digitizer, this value 

                    8.       is ignored.

                    9.   

                    10.config INPUT_TSDEV_SCREEN_Y

                    11.    int "Vertical screen resolution"

                    12.    depends on INPUT_TOUCHSCREEN

                    13.    default "480"

                    14.    help

                    15.     If you're using a digitizer, this is the Y window screen resolution you are 

                    16.     using to correctly scale the data. If you're not using a digitizer, this value 

                    17.     is ignored.

                            在.c文件中通过下列程序获得输入的值:

                    1.  #ifndef CONFIG_INPUT_TSDEV_SCREEN_X

                    2.  #define CONFIG_INPUT_TSDEV_SCREEN_X    800

                    3.  #endif

                    4.  #ifndef CONFIG_INPUT_TSDEV_SCREEN_Y

                    5.  #define CONFIG_INPUT_TSDEV_SCREEN_Y    480

                    6.  #endif

                    7.   

                    8.  static const int gXres = CONFIG_INPUT_TSDEV_SCREEN_X;

                    9.  static const int gYres = CONFIG_INPUT_TSDEV_SCREEN_Y;




                    四、控制背光驱动和应用层程序

                    4.1、驱动程序

                    在系统探测函数中,将控制背光驱动定义为混杂设备并进行注册,定义混杂设备的源码如下:

                    1.  static struct file_operations bl_fops = {

                    2.      owner    : THIS_MODULE,

                    3.      write    : bl_write,

                    4.      open    : bl_open,

                    5.  };

                    6.  static struct miscdevice bl_misc = {

                    7.      .minor    = MISC_DYNAMIC_MINOR,

                    8.      .name    = BACKLIGHT_DEVICE_NAME,

                    9.      .fops    = &bl_fops,

                    10.};

                    说明:

                    1) 混杂设备的文件操作函数中有打开和写,首先看下打开函数:

                    1.  static int bl_open(struct inode *inode, struct file *filp)

                    2.  {

                    3.      int status = -ENXIO;

                    4.      struct ts_1wire_t *ts = NULL;

                    5.   

                    6.      mutex_lock(&wire1_ts_list_lock);

                    7.      list_for_each_entry(ts, &wire1_ts_list, device_entry) {

                    8.          if(strcmp(ts->name, TS_1WIRE_NAME) == 0) {

                    9.              status = 0;

                    10.            break;

                    11.        }

                    12.    }

                    13.    mutex_unlock(&wire1_ts_list_lock);

                    14.    if (status == 0) {

                    15.        filp->private_data = ts;

                    16.    } else {

                    17.        return status;

                    18.    }

                    19.    return nonseekable_open(inode, filp);

                    20.}

                    说明:

                    1) 首先通过本地全局链表和锁获得在探测函数中定义的设备结构体内存指针。

                    2) 然后调用无定位打开函数返回。

                    写数据即发送命令控制背光,程序如下:

                    1.  static ssize_t bl_write(struct file *filp, const char __user *buffer, size_t count, loff_t *ppos)

                    2.  {

                    3.      int ret = 0;

                    4.      u8 bl_data = 0;

                    5.      struct ts_1wire_t *ts = filp->private_data;

                    6.   

                    7.      DBG("bl_write start\n");

                    8.      if (get_user(bl_data, (u8 __user *)buffer)) {

                    9.          printk(KERN_INFO "get_user error!\n");

                    10.        return -EFAULT;

                    11.    }

                    12.    if (bl_data > 127) {

                    13.        bl_data = 127;

                    14.    }

                    15.    ts->bl_ready = 0;

                    16.    ts->backlight_req = bl_data + 0x80U;

                    17.    ret = wait_event_interruptible_timeout(bl_waitq, ts->bl_ready, HZ);

                    18.    if (ret < 0) {

                    19.        printk(KERN_INFO "wait_event_interruptible_timeout error!\n");

                    20.        return ret;

                    21.    } else if (ret == 0) {

                    22.        printk(KERN_INFO "time out error!\n");

                    23.        return -ETIMEDOUT;

                    24.    } else {

                    25.        return count;

                    26.    }

                    27.}

                    说明:

                    1) 首先从应用层获取写入背光值。

                    2) 组合数据,形成背光控制命令。

                    3) 在会话函数中由于ts->backlight_req不为0,即可发送背光控制命令。







                    4.2、应用层程序

                    通过滑动变阻器来控制背光。根据协议,背光总共可以分为0~127个档位,滑动变阻器的测量值范围为2010~4010,也就是说,背光每变化一个档位,滑动变阻器电阻值变化:(4010 - 2010) / 128 = 16。那么我们给背光发送的档位值即为:(x - 2010) / 16。应用层程序如下:

                    1.  #include <fcntl.h>

                    2.  #include <stdio.h>

                    3.  #include <stdlib.h>

                    4.  #include <sys/ioctl.h>

                    5.  #include <linux/ioctl.h>

                    6.   

                    7.   

                    8.  #define ADC_DEV_IOC_MAGIC        'a'

                    9.  #define ADC_DEV_IOC_MAXNR        2

                    10.#define ADC_DEV_CON_PBAT        _IOR(ADC_DEV_IOC_MAGIC, 0, int)

                    11.#define ADC_DEV_CON_CHX            _IOWR(ADC_DEV_IOC_MAGIC, 1, int)

                    12. 

                    13.int main(int argc, char **argv)

                    14.{

                    15.    unsigned int idCmd = 0;

                    16.    //unsigned char buffer[4] = {0};

                    17.    unsigned char bl_data = 0;

                    18.    int fd1 = 0, fd2 = 0, ret = 0, data = 0;

                    19.    

                    20.    //以阻塞方式打开设备文件,非阻塞时flags=O_NONBLOCK

                    21.    fd1 = open("/dev/adc0", 0);

                    22.    if (fd1 < 0) {

                    23.        printf("Open ADC Device Faild!\n");

                    24.        exit(1);

                    25.    }

                    26.    fd2 = open("/dev/backlight-1wire", O_RDWR);

                    27.    if (fd2 < 0) {

                    28.        printf("Open wire1 backlight Device Faild!\n");

                    29.        exit(1);

                    30.    }

                    31.    while(1) {

                    32.        data = 1;

                    33.        idCmd = ADC_DEV_CON_CHX;

                    34.        ret = ioctl(fd1, idCmd, &data);

                    35.        if (ret != 0) {

                    36.            printf("Read ADC Device Faild!\n");

                    37.            break;

                    38.        }

                    39.        //printf("data = %d\n", data);

                    40.        bl_data = (data - 2010) /16;

                    41.        //printf("bl_data = %d\n", bl_data);

                    42.        ret = write(fd2, &bl_data, 1);

                    43.        if (ret < 0) {

                    44.            printf("wire1 backlight ret = %d\n", ret);

                    45.            //break;

                    46.        }

                    47.        //sleep(1);

                    48.        for (ret = 0; ret < 655360; ret++)

                    49.            ;;;;

                    50.    }

                    51.    close(fd1);

                    52.    close(fd2);

                    53.    return 0;

                    54.}

                    编译后,将程序设为后台执行,系统启动后,任何时间滑动变阻器,一线触摸屏的背光都会根据电阻的位置而做相应的变化。







                    原文参见:http://blog.chinaunix.net/uid-25445243-id-4111354.html









                     
                    彩神ll【中国】股份有限公司