Chinaunix首页 | 论坛 | 博客

Johnson的嵌入式技术博客jason2012.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

gfvvz

  • 博客访问： 458074
  • 博文数量： 40
  • 博客积分： 1410
  • 博客等级： 军士长
  • 技术积分： 1396
  • 用 户 组： 普通用户
  • 注册时间： 2011-03-22 19:26
个人简介

嵌入式系统工程师，从事视频、图像、网络、虚拟化等方面的底层软件开发与优化。

文章分类

全部博文（40）

文章存档

2014年（4）

2013年（10）

2012年（14）

2011年（12）

我的朋友
最近访客
推荐博文
相关博文
（五）触摸屏驱动程序分析及其在BSP上的添加

分类： LINUX

2012-04-28 19:21:40

注：我的硬件平台是Tiny6410,触摸屏部分把默认的一线触摸改成了标准的四线触摸，硬件上就是把屏幕背面四个零欧电阻R34/R35/R36/R37取了，把取了的零欧电阻焊接到R28/R29/R30/R31。这样，软件上就可以用内核自带的触摸屏驱动了。

一、触摸屏驱动移植与tslib移植部分

（一）. 触摸屏驱动移植

  1. Kconfig修改
arch/arm/mach-s3c64xx/Kconfig里配置用到arch/arm/plat-samsung/devs.c里的平台设备，如下配置：

点击(此处)折叠或打开

  1. @arch/arm/mach-s3c64xx/Kconfig
  2. about line 98 add:
  3.     select SAMSUNG_DEV_ADC
  4.     select SAMSUNG_DEV_TS

  6. then, it like this:
  7. config MACH_JASON6410
  8.     bool "JASON6410"
  9.     select CPU_S3C6410
  10.     select S3C_DEV_FB
  11.     select S3C64XX_SETUP_FB_24BPP
  12.     select SAMSUNG_DEV_ADC
  13.     select SAMSUNG_DEV_TS
  14.     help
  15.      Machine support for the JASON6410
下面是截取自devs.c里的用到的平台设备：

点击(此处)折叠或打开

  2. #if defined(CONFIG_SAMSUNG_DEV_ADC)
  3. static struct resource s3c_adc_resource[] = {
  4. [0] = DEFINE_RES_MEM(SAMSUNG_PA_ADC, SZ_256),
  5. [1] = DEFINE_RES_IRQ(IRQ_TC),
  6. [2] = DEFINE_RES_IRQ(IRQ_ADC),
  7. };

  9. struct platform_device s3c_device_adc = {
  10. .name = "samsung-adc",
  11. .id = -1,
  12. .num_resources = ARRAY_SIZE(s3c_adc_resource),
  13. .resource = s3c_adc_resource,
  14. };
  15. #endif /* CONFIG_SAMSUNG_DEV_ADC */

  17.  
  18. #ifdef CONFIG_SAMSUNG_DEV_TS
  19. static struct resource s3c_ts_resource[] = {
  20.     [0] = DEFINE_RES_MEM(SAMSUNG_PA_ADC, SZ_256),
  21.     [1] = DEFINE_RES_IRQ(IRQ_TC),
  22. };

  24. static struct s3c2410_ts_mach_info default_ts_data __initdata = {
  25.     .delay            = 10000,
  26.     .presc            = 49,
  27.     .oversampling_shift    = 2,
  28. };

  30. struct platform_device s3c_device_ts = {
  31.     .name        = "s3c64xx-ts",
  32.     .id        = -1,
  33.     .num_resources    = ARRAY_SIZE(s3c_ts_resource),
  34.     .resource    = s3c_ts_resource,
  35. };

  37. void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *pd)
  38. {
  39.     if (!pd)
  40.         pd = &default_ts_data;

  42.     s3c_set_platdata(pd, sizeof(struct s3c2410_ts_mach_info),
  43.              &s3c_device_ts);
  44. }
  45. #endif /* CONFIG_SAMSUNG_DEV_TS */
  
  2. 内核配置
配置Event interface是因为tslib的TSLIB_TSDEVICE环境变量需要用到/dev/input/event0设备节点。

点击(此处)折叠或打开

  1. Device Drivers --->
  2.         Input device support --->         
  3.             [*] Touchscreens --->
  4.                 <*> Samsung S3C2410/generic touchscreen input driver

  6. Device Drivers --->
  7.         Input device support --->
  8.             <*> Event interface

  3. BSP部分修改
如下绿色部分，是针对触摸屏驱动，在BSP上添加的代码。

点击(此处)折叠或打开

  1. /* linux/arch/arm/mach-s3c64xx/mach-jason6410.c
  2.  *
  3.  * Copyright 2012 Jason Lu <gfvvz@yahoo.com.cn>
  4.  *     http://jason2012.blog.chinaunix.net
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License version 2 as
  8.  * published by the Free Software Foundation.
  9.  *
  10. */

  12. #include <linux/init.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/fb.h>
  15. #include <linux/gpio.h>
  16. #include <linux/kernel.h>
  17. #include <linux/list.h>
  18. #include <linux/dm9000.h>
  19. #include <linux/mtd/mtd.h>
  20. #include <linux/mtd/partitions.h>
  21. #include <linux/serial_core.h>
  22. #include <linux/types.h>

  24. #include <asm/mach-types.h>
  25. #include <asm/mach/arch.h>
  26. #include <asm/mach/map.h>

  28. #include <mach/map.h>
  29. #include <mach/regs-gpio.h>
  30. #include <mach/regs-modem.h>
  31. #include <mach/regs-srom.h>

  33. #include <plat/s3c6410.h>
  34. #include <plat/adc.h>
  35. #include <plat/cpu.h>
  36. #include <plat/devs.h>
  37. #include <plat/fb.h>
  38. #include <plat/nand.h>
  39. #include <plat/regs-serial.h>
  40. #include <plat/ts.h>
  41. #include <plat/regs-fb-v4.h>
  42. #include <plat/iic.h>

  44. #include <video/platform_lcd.h>

  46. #define UCON S3C2410_UCON_DEFAULT
  47. #define ULCON (S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB)
  48. #define UFCON (S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE)

  50. static struct s3c2410_uartcfg jason6410_uartcfgs[] __initdata = {
  51.     [0] = {
  52.         .hwport    = 0,
  53.         .flags    = 0,
  54.         .ucon    = UCON,
  55.         .ulcon    = ULCON,
  56.         .ufcon    = UFCON,
  57.     },
  58.     [1] = {
  59.         .hwport    = 1,
  60.         .flags    = 0,
  61.         .ucon    = UCON,
  62.         .ulcon    = ULCON,
  63.         .ufcon    = UFCON,
  64.     },
  65.     [2] = {
  66.         .hwport    = 2,
  67.         .flags    = 0,
  68.         .ucon    = UCON,
  69.         .ulcon    = ULCON,
  70.         .ufcon    = UFCON,
  71.     },
  72.     [3] = {
  73.         .hwport    = 3,
  74.         .flags    = 0,
  75.         .ucon    = UCON,
  76.         .ulcon    = ULCON,
  77.         .ufcon    = UFCON,
  78.     },
  79. };

  81. /* Framebuffer. */

  83. static struct s3c_fb_pd_win jason6410_fb_win0 = {
  84.     /* this is to ensure we use win0 */
  85.     .win_mode    = {
  86. #if 0
  87.         .pixclock    = 115440,
  88. #endif
  89.         .left_margin    = 0x03,
  90.         .right_margin    = 0x02,
  91.         .upper_margin    = 0x01,
  92.         .lower_margin    = 0x01,
  93.         .hsync_len    = 0x28,
  94.         .vsync_len    = 0x01,
  95.         .xres        = 480,
  96.         .yres        = 272,
  97.     },
  98.     .max_bpp    = 32,
  99.     .default_bpp    = 16,
  100. };

  102. /* 405566 clocks per frame => 60Hz refresh requires 24333960Hz clock */
  103. static struct s3c_fb_platdata jason6410_lcd_pdata __initdata = {
  104.     .setup_gpio    = s3c64xx_fb_gpio_setup_24bpp,
  105.     .win[0]        = &jason6410_fb_win0,
  106.     .vidcon0    = VIDCON0_VIDOUT_RGB | VIDCON0_PNRMODE_RGB,
  107.     .vidcon1    = VIDCON1_INV_HSYNC | VIDCON1_INV_VSYNC,
  108. };

  110. /* Nand flash */
  111. static struct mtd_partition jason6410_nand_part[] = {
  112.     {
  113.         .name        = "u-boot-2011.06",
  114.         .offset        = 0,
  115.         .size        = (4 * 128 *SZ_1K),
  116.         .mask_flags    = MTD_CAP_NANDFLASH,
  117.     },
  118.     {
  119.         .name        = "Linux Kernel 3.2.8",
  120.         .offset        = MTDPART_OFS_APPEND,
  121.         .size        = (5*SZ_1M) ,
  122.         .mask_flags    = MTD_CAP_NANDFLASH,
  123.     },
  124.     {
  125.         .name        = "UBI File System",
  126.         .offset        = MTDPART_OFS_APPEND,
  127.         .size        = MTDPART_SIZ_FULL,
  128.     }
  129. };

  131. static struct s3c2410_nand_set jason6410_nand_sets[] = {
  132.     [0] = {
  133.         .name        = "nand",
  134.         .nr_chips    = 1,
  135.         .nr_partitions    = ARRAY_SIZE(jason6410_nand_part),
  136.         .partitions    = jason6410_nand_part,
  137.     },
  138. };

  140. static struct s3c2410_platform_nand jason6410_nand_info = {
  141.     .tacls        = 25,
  142.     .twrph0        = 55,
  143.     .twrph1        = 40,
  144.     .nr_sets    = ARRAY_SIZE(jason6410_nand_sets),
  145.     .sets        = jason6410_nand_sets,
  146. };

  148. static struct map_desc jason6410_iodesc[] = {
  149. };

  151. static struct platform_device *jason6410_devices[] __initdata = {
  152.     &s3c_device_nand,
  153.     &s3c_device_i2c0,
  154.     &s3c_device_fb,
  155.     &s3c_device_ts,
  156.     &s3c_device_adc,
  157. };

  159. static struct i2c_board_info i2c_devs0[] __initdata = {
  160.     { I2C_BOARD_INFO("24c08", 0x50), },
  161. };

  163. static struct i2c_board_info i2c_devs1[] __initdata = {
  164.     /* Add your i2c device here */
  165. };

  167. static struct s3c2410_ts_mach_info s3c_ts_platform __initdata = {
  168.     .delay            = 0xFFFF,
  169.     .presc            = 0xFF,
  170.     .oversampling_shift    = 2,
  171. };

  173. static void __init jason6410_map_io(void)
  174. {
  175.     u32 tmp;

  177.     s3c64xx_init_io(jason6410_iodesc, ARRAY_SIZE(jason6410_iodesc));
  178.     s3c24xx_init_clocks(12000000);
  179.     s3c24xx_init_uarts(jason6410_uartcfgs, ARRAY_SIZE(jason6410_uartcfgs));

  181.     /* set the LCD type */
  182.     tmp = __raw_readl(S3C64XX_SPCON);
  183.     tmp &= ~S3C64XX_SPCON_LCD_SEL_MASK;
  184.     tmp |= S3C64XX_SPCON_LCD_SEL_RGB;
  185.     __raw_writel(tmp, S3C64XX_SPCON);

  187.     /* remove the lcd bypass */
  188.     tmp = __raw_readl(S3C64XX_MODEM_MIFPCON);
  189.     tmp &= ~MIFPCON_LCD_BYPASS;
  190.     __raw_writel(tmp, S3C64XX_MODEM_MIFPCON);
  191. }

  193. static void __init jason6410_machine_init(void)
  194. {
  195.     s3c_device_nand.name = "s3c6410-nand";
  196.     s3c_nand_set_platdata(&jason6410_nand_info);

  198.     s3c_i2c0_set_platdata(NULL);
  199.     s3c_fb_set_platdata(&jason6410_lcd_pdata);
  200.     s3c24xx_ts_set_platdata(&s3c_ts_platform);

  202.     if (ARRAY_SIZE(i2c_devs0)) {
  203.         i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
  204.     }
  205.     if (ARRAY_SIZE(i2c_devs1)) {
  206.         i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
  207.     }

  209.     platform_add_devices(jason6410_devices, ARRAY_SIZE(jason6410_devices));
  210. }

  212. MACHINE_START(JASON6410, "JASON6410")
  213.     /* Maintainer: Darius Augulis <augulis.darius@gmail.com> */
  214.     .atag_offset    = 0x100,
  215.     .init_irq    = s3c6410_init_irq,
  216.     .map_io        = jason6410_map_io,
  217.     .init_machine    = jason6410_machine_init,
  218.     .timer        = &s3c24xx_timer,
  219. MACHINE_END

(二). tslib移植及测试
我的内核版本是3.2.8,使用tslib-1.4，在执行ts_calibrate会报段错误。在下载了最新的tslib，重新编译，就能使用了。 kergoth-tslib-1.0-106-gf6c499a.zip   
    1. 为虚拟机里的Linux系统安装工具：

点击(此处)折叠或打开

  1. sudo apt-get install autoconf
  2. sudo apt-get install automake
  3. sudo apt-get install libtool
    2. 解压后编译

点击(此处)折叠或打开

  1. mv xxx(解压后名字) tslib  //名字改为tslib 

  3. cd tslib

  5. ./autogen.sh 

  7. mkdir tmp

  9. echo "ac_cv_func_malloc_0_nonnull=yes" >arm-linux.cache

  11. ./configure --host=arm-linux --cache-file=arm-linux.cache --prefix=$(pwd)/tmp

  13. make

  15. make install
    3. 打开tmp目录，里面有四个文件夹，分别是bin、etc、include、lib。将etc目录下的ts.conf里的第2行去掉注释。即：

点击(此处)折叠或打开

  1. # module_raw input
  2. 改为：
  3. module_raw input
    4. 将bin/etc/lib目录下的文件及连接拷贝到文件系统下对应同名目录。include目录估计是编译应用程序时用的，在此可以不使用。
    5. 修改etc/init.d/rcS,注释掉启动QT界面的代码:
    6. 重新生成文件系统镜像，并且重新烧写新的内核与文件系统。
    7. 在串口终端，顺序输入下列环境变量。

点击(此处)折叠或打开

  1. export TSLIB_TSDEVICE=/dev/input/event0
  2. export TSLIB_CALIBFILE=/etc/pointercal
  3. export TSLIB_CONFFILE=/etc/ts.conf
  4. export TSLIB_PLUGINDIR=/lib/ts
  5. export TSLIB_CONSOLEDEVICE=none
  6. export TSLIB_FBDEVICE=/dev/fb0
    8. 终端输入命令ts_calibrate,LCD如下显示类似如下界面，触摸校准触摸屏。
    9. 终端输入命令ts_test，LCD显示类似如下界面，可以触摸屏幕，十字光标跟随触摸点移动，按Draw按钮，可以画出触摸轨迹。




二、触摸屏及ADC驱动分析
(一)代码详细分析
  1. 触摸屏驱动中的probe函数分析

点击(此处)折叠或打开

  1. /**
  2.  * s3c2410ts_probe - device core probe entry point
  3.  * @pdev: The device we are being bound to.
  4.  *
  5.  * Initialise, find and allocate any resources we need to run and then
  6.  * register with the ADC and input systems.
  7.  */
  8. static int __devinit s3c2410ts_probe(struct platform_device *pdev)
  9. {
  10.     struct s3c2410_ts_mach_info *info;
  11.     struct device *dev = &pdev->dev;
  12.     struct input_dev *input_dev;
  13.     struct resource *res;
  14.     int ret = -EINVAL;

  16.     /* Initialise input stuff */
  17.     memset(&ts, 0, sizeof(struct s3c2410ts)); //清零ts结构体

  19.     ts.dev = dev; //ts的设备成员指向匹配的平台设备

  21.     info = pdev->dev.platform_data; //info指向平台设备的平台数据
  22.     if (!info) {
  23.         dev_err(dev, "no platform data, cannot attach\n");
  24.         return -EINVAL;
  25.     }

  27.     dev_dbg(dev, "initialising touchscreen\n");

  29.     ts.clock = clk_get(dev, "adc"); //获取ADC时钟
  30.     if (IS_ERR(ts.clock)) {
  31.         dev_err(dev, "cannot get adc clock source\n");
  32.         return -ENOENT;
  33.     }

  35.     clk_enable(ts.clock); //使能ADC时钟
  36.     dev_dbg(dev, "got and enabled clocks\n");

  38.     ts.irq_tc = ret = platform_get_irq(pdev, 0); //获取中断号并赋给irq_tc成员
  39.     if (ret < 0) {
  40.         dev_err(dev, "no resource for interrupt\n");
  41.         goto err_clk;
  42.     }

  44.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  45.     if (!res) {
  46.         dev_err(dev, "no resource for registers\n");
  47.         ret = -ENOENT;
  48.         goto err_clk;
  49.     }

  51.     ts.io = ioremap(res->start, resource_size(res)); //映射寄存器组所在地址范围
  52.     if (ts.io == NULL) {
  53.         dev_err(dev, "cannot map registers\n");
  54.         ret = -ENOMEM;
  55.         goto err_clk;
  56.     }

  58.     /* inititalise the gpio */
  59.     if (info->cfg_gpio) //如果定义了GPIO，就在这里初始化GPIO
  60.         info->cfg_gpio(to_platform_device(ts.dev));

  62.     ts.client = s3c_adc_register(pdev, s3c24xx_ts_select, //客户端函数指定
  63.                  s3c24xx_ts_conversion, 1);
  64.     if (IS_ERR(ts.client)) {
  65.         dev_err(dev, "failed to register adc client\n");
  66.         ret = PTR_ERR(ts.client);
  67.         goto err_iomap;
  68.     }

  70.     /* Initialise registers */ //初始化寄存器组
  71.     if ((info->delay & 0xffff) > 0)
  72.         writel(info->delay & 0xffff, ts.io + S3C2410_ADCDLY); //看下图

  75.     writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); //写入0xd3，看下图

  78.     input_dev = input_allocate_device(); //分配一个input_dev结构体
  79.     if (!input_dev) {
  80.         dev_err(dev, "Unable to allocate the input device !!\n");
  81.         ret = -ENOMEM;
  82.         goto err_iomap;
  83.     }

  85.     ts.input = input_dev; //ts的input成员指向新分配的input_dev结构体
  86.     ts.input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);  //设备支持的事件类型
  87.     ts.input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); //设备支持的按键
  88.     input_set_abs_params(ts.input, ABS_X, 0, 0x3FF, 0, 0);  //X轴
  89.     input_set_abs_params(ts.input, ABS_Y, 0, 0x3FF, 0, 0);  //Y轴

  91.     ts.input->name = "S3C24XX TouchScreen"; //输入设备名、总线类型等信息
  92.     ts.input->id.bustype = BUS_HOST;
  93.     ts.input->id.vendor = 0xDEAD;
  94.     ts.input->id.product = 0xBEEF;
  95.     ts.input->id.version = 0x0102;

  97.     ts.shift = info->oversampling_shift; //多次采样次数
  98.     ts.features = platform_get_device_id(pdev)->driver_data; //驱动数据

  99. 点击(此处)折叠或打开

    1. static struct platform_device_id s3cts_driver_ids[] = {
    2.     { "s3c2410-ts", 0 },
    3.     { "s3c2440-ts", 0 },
    4.     { "s3c64xx-ts", FEAT_PEN_IRQ }, //程序中获取的驱动数据
    5.     { }
    6. };

  101.     ret = request_irq(ts.irq_tc, stylus_irq, 0, //注册触摸屏中断
  102.              "s3c2410_ts_pen", ts.input);
  103.     if (ret) {
  104.         dev_err(dev, "cannot get TC interrupt\n");
  105.         goto err_inputdev;
  106.     }

  108.     dev_info(dev, "driver attached, registering input device\n");

  110.     /* All went ok, so register to the input system */
  111.     ret = input_register_device(ts.input); //注册输入设备
  112.     if (ret < 0) {
  113.         dev_err(dev, "failed to register input device\n");
  114.         ret = -EIO;
  115.         goto err_tcirq;
  116.     }

  118.     return 0;

  120.  err_tcirq:
  121.     free_irq(ts.irq_tc, ts.input);
  122.  err_inputdev:
  123.     input_free_device(ts.input);
  124.  err_iomap:
  125.     iounmap(ts.io);
  126.  err_clk:
  127.     del_timer_sync(&touch_timer);
  128.     clk_put(ts.clock);
  129.     return ret;
  130. }
  2. 触摸屏驱动中的stylus_irq函数分析

点击(此处)折叠或打开

  1. /**
  2.  * stylus_irq - touchscreen stylus event interrupt
  3.  * @irq: The interrupt number
  4.  * @dev_id: The device ID.
  5.  *
  6.  * Called when the IRQ_TC is fired for a pen up or down event.
  7.  */
  8. static irqreturn_t stylus_irq(int irq, void *dev_id)
  9. {
  10.     unsigned long data0;
  11.     unsigned long data1;
  12.     bool down;
  13.  
  14.     //读取ADCDAT0寄存器中数据，最高位UPDOWN是按下/释放标志
  15.     data0 = readl(ts.io + S3C2410_ADCDAT0);
  16.     data1 = readl(ts.io + S3C2410_ADCDAT1);

  18.     down = get_down(data0, data1); //根据ADCDAT0/ADCDAT1最高位值判断按下还是释放触摸屏

  20.     /* TODO we should never get an interrupt with down set while
  21.      * the timer is running, but maybe we ought to verify that the
  22.      * timer isn't running anyways. */

  24.     if (down)
  25.         s3c_adc_start(ts.client, 0, 1 << ts.shift); //如果是按下，启动ADC采样
  26.     else
  27.         dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count);

  29.     if (ts.features & FEAT_PEN_IRQ) {
  30.         /* Clear pen down/up interrupt */
  31.         writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP); //清零触摸中断
  32.     }

  34.     return IRQ_HANDLED;
  35. }
  3. ADC驱动中的probe函数分析
stylus_irq中的s3c_adc_start函数位于ADC驱动中，在分析它之前，还是先分析ADC驱动的probe函数。有一点要说明的是，在devs.c中定义的ADC平台设备，名称是"samsung-adc"，然而在ADC平台驱动结构体的id_table里没有这个名称，只有"s3c64xx-adc"，启动信息里可以看到，匹配名就是这个，那么这个名称是从哪来的呢？通过搜索内核代码，发现在s3c6410.c里，有如下代码：

点击(此处)折叠或打开

  1. void __init s3c6410_map_io(void)
  2. {
  3.     /* initialise device information early */
  4.     s3c6410_default_sdhci0();
  5.     s3c6410_default_sdhci1();
  6.     s3c6410_default_sdhci2();

  8.     /* the i2c devices are directly compatible with s3c2440 */
  9.     s3c_i2c0_setname("s3c2440-i2c");
  10.     s3c_i2c1_setname("s3c2440-i2c");

  12.     s3c_adc_setname("s3c64xx-adc");
  13.     s3c_device_nand.name = "s3c6400-nand";
  14.     s3c_onenand_setname("s3c6410-onenand");
  15.     s3c64xx_onenand1_setname("s3c6410-onenand");
  16.     s3c_cfcon_setname("s3c64xx-pata");
  17. }
如上s3c_adc_setname函数的源码如下，给函数就是重命名结构体名字用的！

点击(此处)折叠或打开

  1. /* re-define device name depending on support. */
  2. static inline void s3c_adc_setname(char *name)
  3. {
  4. #if defined(CONFIG_SAMSUNG_DEV_ADC) || defined(CONFIG_PLAT_S3C24XX)
  5.     s3c_device_adc.name = name;
  6. #endif
  7. }
接下来还有一个问题，就是调用s3c_adc_setname函数的s3c6410_map_io函数在内核启动的什么时候被调用？被哪个函数调用？通过代码追踪，发下如下关系：

点击(此处)折叠或打开

  1. MACHINE_START(JASON6410, "JASON6410")
  2.     /* Maintainer: Darius Augulis <augulis.darius@gmail.com> */
  3.     .atag_offset = 0x100,
  4.     .init_irq = s3c6410_init_irq,
  5.     .map_io = jason6410_map_io,
  6.     .init_machine = jason6410_machine_init,
  7.     .timer = &s3c24xx_timer,
  8. MACHINE_END
  9.  
  10. jason6410_map_io
  11. s3c64xx_init_io
  12. s3c_init_cpu(samsung_cpu_id, cpu_ids, ARRAY_SIZE(cpu_ids));
  14. static struct cpu_table cpu_ids[] __initdata = {
  15. {
  16. .idcode = S3C6400_CPU_ID,
  17. .idmask = S3C64XX_CPU_MASK,
  18. .map_io = s3c6400_map_io,
  19. .init_clocks = s3c6400_init_clocks,
  20. .init_uarts = s3c6400_init_uarts,
  21. .init = s3c6400_init,
  22. .name = name_s3c6400,
  23. }, {
  24. .idcode = S3C6410_CPU_ID,
  25. .idmask = S3C64XX_CPU_MASK,
  26. .map_io = s3c6410_map_io,
  27. .init_clocks = s3c6410_init_clocks,
  28. .init_uarts = s3c6410_init_uarts,
  29. .init = s3c6410_init,
  30. .name = name_s3c6410,
  31. },
  32. };
好了，圆规正传，开始分析probe函数。

点击(此处)折叠或打开

  1. static int s3c_adc_probe(struct platform_device *pdev)
  2. {
  3.     struct device *dev = &pdev->dev;
  4.     struct adc_device *adc;
  5.     struct resource *regs;
  6.     enum s3c_cpu_type cpu = platform_get_device_id(pdev)->driver_data;
  7.     int ret;
  8.     unsigned tmp;

  10.     adc = kzalloc(sizeof(struct adc_device), GFP_KERNEL);  //分配一个adc_device结构体
  11.     if (adc == NULL) {
  12.         dev_err(dev, "failed to allocate adc_device\n");
  13.         return -ENOMEM;
  14.     }

  16.     spin_lock_init(&adc->lock); //初始化自旋锁

  18.     adc->pdev = pdev;
  19.     adc->prescale = S3C2410_ADCCON_PRSCVL(49); //预分频

  21.     adc->vdd = regulator_get(dev, "vdd");
  22.     if (IS_ERR(adc->vdd)) {
  23.         dev_err(dev, "operating without regulator \"vdd\" .\n");
  24.         ret = PTR_ERR(adc->vdd);
  25.         goto err_alloc;
  26.     }

  28.     adc->irq = platform_get_irq(pdev, 1); //获取ADC中断
  29.     if (adc->irq <= 0) {
  30.         dev_err(dev, "failed to get adc irq\n");
  31.         ret = -ENOENT;
  32.         goto err_reg;
  33.     }

  35.     ret = request_irq(adc->irq, s3c_adc_irq, 0, dev_name(dev), adc); //注册ADC中断
  36.     if (ret < 0) {
  37.         dev_err(dev, "failed to attach adc irq\n");
  38.         goto err_reg;
  39.     }

  41.     adc->clk = clk_get(dev, "adc"); //获取ADC时钟
  42.     if (IS_ERR(adc->clk)) {
  43.         dev_err(dev, "failed to get adc clock\n");
  44.         ret = PTR_ERR(adc->clk);
  45.         goto err_irq;
  46.     }

  48.     regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); //获取ADC寄存器地址范围
  49.     if (!regs) {
  50.         dev_err(dev, "failed to find registers\n");
  51.         ret = -ENXIO;
  52.         goto err_clk;
  53.     }

  55.     adc->regs = ioremap(regs->start, resource_size(regs)); //寄存器地址映射到内存
  56.     if (!adc->regs) {
  57.         dev_err(dev, "failed to map registers\n");
  58.         ret = -ENXIO;
  59.         goto err_clk;
  60.     }

  62.     ret = regulator_enable(adc->vdd);
  63.     if (ret)
  64.         goto err_ioremap;

  66.     clk_enable(adc->clk); //使能ADC时钟

  68.     tmp = adc->prescale | S3C2410_ADCCON_PRSCEN; //预分频使能

  70.     /* Enable 12-bit ADC resolution */
  71.     if (cpu == TYPE_ADCV12)
  72.         tmp |= S3C2416_ADCCON_RESSEL;
  73.     if (cpu == TYPE_ADCV2 || cpu == TYPE_ADCV3)
  74.         tmp |= S3C64XX_ADCCON_RESSEL;
  75.  
  76.     //ADCCON寄存器配置：12位、预分频使能、预分频值49
  77.     writel(tmp, adc->regs + S3C2410_ADCCON);

  79.     dev_info(dev, "attached adc driver\n");

  81.     platform_set_drvdata(pdev, adc);
  82.     adc_dev = adc; //adc_dev指向这里分配和设置的adc_device结构体，下面的函数要用到

  84.     return 0;

  86.  err_ioremap:
  87.     iounmap(adc->regs);
  88.  err_clk:
  89.     clk_put(adc->clk);

  91.  err_irq:
  92.     free_irq(adc->irq, adc);
  93.  err_reg:
  94.     regulator_put(adc->vdd);
  95.  err_alloc:
  96.     kfree(adc);
  97.     return ret;
  98. }
  4. ADC驱动中的s3c_adc_start函数分析

点击(此处)折叠或打开

  1. int s3c_adc_start(struct s3c_adc_client *client,
  2.          unsigned int channel, unsigned int nr_samples)
  3. {
  4.     struct adc_device *adc = adc_dev;
  5.     unsigned long flags;
  6.   
  7.     /* 先判断adc所指向的adc_device是否有效，可以作为设备驱动是否匹配的判断依据；
  8.      * 因为adc_dev是在上面的probe函数里被复制的
  9.      */
  10.     if (!adc) {
  11.         printk(KERN_ERR "%s: failed to find adc\n", __func__);
  12.         return -EINVAL;
  13.     }

  15.     if (client->is_ts && adc->ts_pend) //如果是触摸屏并且是当前有客户，则返回
  16.         return -EAGAIN;

  18.     spin_lock_irqsave(&adc->lock, flags); //获取自旋锁，并把中断状态存入flags

  20.     client->channel = channel; //采样通道
  21.     client->nr_samples = nr_samples; //采样次数

  23.     if (client->is_ts) //如果是触摸屏，将client保存在adc->ts_pend中
  24.         adc->ts_pend = client;
  25.     else //如果不是触摸屏，将client->pend插入adc_pending链表中
  26.         list_add_tail(&client->pend, &adc_pending);

  28.     if (!adc->cur) //如果当前没有处理其他用户请求，则执行新的用户请求
  29.         s3c_adc_try(adc);

  31.     spin_unlock_irqrestore(&adc->lock, flags); //释放自旋锁，恢复中断状态

  33.     return 0;
  34. }
  35. EXPORT_SYMBOL_GPL(s3c_adc_start); //将函数导出，让所有遵循GPL协议的模块都可以使用
  5. ADC驱动中的s3c_adc_try函数分析

点击(此处)折叠或打开

  1. static void s3c_adc_try(struct adc_device *adc)
  2. {
  3.     struct s3c_adc_client *next = adc->ts_pend;

  5.     if (!next && !list_empty(&adc_pending)) {
  6.         next = list_first_entry(&adc_pending,
  7.                     struct s3c_adc_client, pend);
  8.         list_del(&next->pend);
  9.     } else
  10.         adc->ts_pend = NULL; //去除客户

  12.     if (next) { //如果触摸屏有客户请求，则执行下列函数
  13.         adc_dbg(adc, "new client is %p\n", next);
  14.         adc->cur = next;
  15.         s3c_adc_select(adc, next);
  16.         s3c_adc_convert(adc);
  17.         s3c_adc_dbgshow(adc); //打印ADCCON,ADCTSC,ADCDLY三个寄存器值
  18.     }
  19. }
  6. ADC驱动中的s3c_adc_select函数分析

点击(此处)折叠或打开

  1. static inline void s3c_adc_select(struct adc_device *adc,
  2.                  struct s3c_adc_client *client)
  3. {
  4.     unsigned con = readl(adc->regs + S3C2410_ADCCON); //读取ADCCON寄存器当前值
  5.     enum s3c_cpu_type cpu = platform_get_device_id(adc->pdev)->driver_data; //CPU类型
  6.  
  7.     //执行客户定义的select回调函数，也就是触摸屏驱动中的s3c24xx_ts_select函数
  8.     client->select_cb(client, 1); 

  9. 点击(此处)折叠或打开

    1. /**
    2.  * s3c24xx_ts_select - ADC selection callback.
    3.  * @client: The client that was registered with the ADC core.
    4.  * @select: The reason for select.
    5.  *
    6.  * Called when the ADC core selects (or deslects) us as a client.
    7.  */
    8. static void s3c24xx_ts_select(struct s3c_adc_client *client, unsigned select)
    9. {
    10.     if (select) {//启用自动(连续)x/y轴坐标转换模式
    11.         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST,
    12.          ts.io + S3C2410_ADCTSC);
    13.     } else {//将touch_timer定时器定时时间设置为此后一个时钟滴答，并进入中断等待模式
    14.         mod_timer(&touch_timer, jiffies+1);  //1 jiffies = 1/Hz s Hz可取100
    15.         writel(WAIT4INT | INT_UP, ts.io + S3C2410_ADCTSC);
    16.     }
    17. }

  11.     if (cpu == TYPE_ADCV1 || cpu == TYPE_ADCV2)
  12.         con &= ~S3C2410_ADCCON_MUXMASK;
  13.     con &= ~S3C2410_ADCCON_STDBM;
  14.     con &= ~S3C2410_ADCCON_STARTMASK;

  16.     if (!client->is_ts) {
  17.         if (cpu == TYPE_ADCV3)
  18.             writel(client->channel & 0xf, adc->regs + S5P_ADCMUX);
  19.         else if (cpu == TYPE_ADCV11 || cpu == TYPE_ADCV12)
  20.             writel(client->channel & 0xf,
  21.                         adc->regs + S3C2443_ADCMUX);
  22.         else
  23.             con |= S3C2410_ADCCON_SELMUX(client->channel);
  24.     }

  26.     writel(con, adc->regs + S3C2410_ADCCON);
  27. }
  7. ADC驱动中的s3c_adc_convert函数分析

点击(此处)折叠或打开

  1. static inline void s3c_adc_convert(struct adc_device *adc)
  2. {
  3.     unsigned con = readl(adc->regs + S3C2410_ADCCON);

  5.     con |= S3C2410_ADCCON_ENABLE_START; //启动ADC转换
  6.     writel(con, adc->regs + S3C2410_ADCCON);
  7. }
  8. ADC驱动中的s3c_adc_irq函数分析

点击(此处)折叠或打开

  1. static irqreturn_t s3c_adc_irq(int irq, void *pw)
  2. {
  3.     struct adc_device *adc = pw;
  4.     struct s3c_adc_client *client = adc->cur;
  5.     enum s3c_cpu_type cpu = platform_get_device_id(adc->pdev)->driver_data;
  6.     unsigned data0, data1;

  8.     if (!client) {
  9.         dev_warn(&adc->pdev->dev, "%s: no adc pending\n", __func__);
  10.         goto exit;
  11.     }

  13.     data0 = readl(adc->regs + S3C2410_ADCDAT0);
  14.     data1 = readl(adc->regs + S3C2410_ADCDAT1);
  15.     adc_dbg(adc, "read %d: 0x%04x, 0x%04x\n", client->nr_samples, data0, data1);

  17.     client->nr_samples--; //s3c_adc_start函数中被首次复制

  19.     if (cpu == TYPE_ADCV1 || cpu == TYPE_ADCV11) {
  20.         data0 &= 0x3ff;
  21.         data1 &= 0x3ff;
  22.     } else {
  23.         /* S3C2416/S3C64XX/S5P ADC resolution is 12-bit */
  24.         data0 &= 0xfff;
  25.         data1 &= 0xfff;
  26.     }
  27.  
  28.     //回调函数，在触摸屏驱动中定义
  29.     if (client->convert_cb)
  30.         (client->convert_cb)(client, data0, data1, &client->nr_samples);

  31. 点击(此处)折叠或打开

    1. /**
    2.  * s3c24xx_ts_conversion - ADC conversion callback
    3.  * @client: The client that was registered with the ADC core.
    4.  * @data0: The reading from ADCDAT0.
    5.  * @data1: The reading from ADCDAT1.
    6.  * @left: The number of samples left.
    7.  *
    8.  * Called when a conversion has finished.
    9.  */
    10. static void s3c24xx_ts_conversion(struct s3c_adc_client *client,
    11.                  unsigned data0, unsigned data1,
    12.                  unsigned *left)
    13. {
    14.     dev_dbg(ts.dev, "%s: %d,%d\n", __func__, data0, data1);

    16.     ts.xp += data0;
    17.     ts.yp += data1;

    19.     ts.count++;

    21.     /* From tests, it seems that it is unlikely to get a pen-up
    22.      * event during the conversion process which means we can
    23.      * ignore any pen-up events with less than the requisite
    24.      * count done.
    25.      *
    26.      * In several thousand conversions, no pen-ups where detected
    27.      * before count completed.
    28.      */
    29. }

  33.     if (client->nr_samples > 0) { //如果大于零，表示还未达到多次采样的次数，继续启动
  34.         /* fire another conversion for this */

  36.         client->select_cb(client, 1);
  37.         s3c_adc_convert(adc);
  38.     } else { //如果等于零，表示已到达多次采样次数，启动最后一次采样
  39.         spin_lock(&adc->lock);
  40.         //将touch_timer定时器定时时间设置为此后一个时钟滴答，并进入中断等待模式
  41.         (client->select_cb)(client, 0);
  42.         adc->cur = NULL;

  44.         s3c_adc_try(adc); //启动最后一次采样
  45.         spin_unlock(&adc->lock);
  46.     }

  48. exit:
  49.     if (cpu == TYPE_ADCV2 || cpu == TYPE_ADCV3) {
  50.         /* Clear ADC interrupt */
  51.         writel(0, adc->regs + S3C64XX_ADCCLRINT);
  52.     }
  53.     return IRQ_HANDLED;
  54. }
  9. 触摸屏驱动中的touch_timer_fire函数分析
当上面select_cb回调函数中设置的定时器定时时间到到达时，会调用如下函数。

点击(此处)折叠或打开

  1. static void touch_timer_fire(unsigned long data)
  2. {
  3.     unsigned long data0;
  4.     unsigned long data1;
  5.     bool down;

  7.     data0 = readl(ts.io + S3C2410_ADCDAT0);
  8.     data1 = readl(ts.io + S3C2410_ADCDAT1);

  10.     down = get_down(data0, data1);

  12.     if (down) { //按下触摸屏
  13.         if (ts.count == (1 << ts.shift)) { //如果到达多次采样数
  14.             ts.xp >>= ts.shift; //除以多次采样数
  15.             ts.yp >>= ts.shift;

  17.             dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n",
  18.                 __func__, ts.xp, ts.yp, ts.count);

  20.             input_report_abs(ts.input, ABS_X, ts.xp); //向上报告X坐标
  21.             input_report_abs(ts.input, ABS_Y, ts.yp); //向上报告Y坐标

  23.             input_report_key(ts.input, BTN_TOUCH, 1); //向上报告按下
  24.             input_sync(ts.input); //同步

  26.             ts.xp = 0; 清零
  27.             ts.yp = 0;
  28.             ts.count = 0;
  29.         }

  31.         s3c_adc_start(ts.client, 0, 1 << ts.shift); //启动采样
  32.     } else { //释放触摸屏
  33.         ts.xp = 0;
  34.         ts.yp = 0;
  35.         ts.count = 0;

  37.         input_report_key(ts.input, BTN_TOUCH, 0); //向上报告释放
  38.         input_sync(ts.input); //同步

  40.         writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); //等待中断模式
  41.     }
  42. }
（二）总结过程
首先probe函数执行完后，触摸屏进入等待中断模式。当有触摸屏中断发生时，即检测到被触摸时，进入触摸屏中断处理函数。中断函数判断是否被按下，如果是，调用s3c_adc_start，s3c_adc_start完成一些初始化工作后，调用s3c_adc_try，该函数检测等待处理的客户(client)，然后调用s3c_adc_select，该函数会调用客户定义的select回调函数选择客户(client)。s3c_adc_try执行完s3c_adc_select后，又会调用s3c_adc_convert，该函数启动AD转换，转换结束后，触发中断，中断处理函数s3c_adc_irq会首先调用s3c24xx_ts_conversion，累加x,y坐标值及采样次数，如果采样次数未到达多次采样次数，继续采样，否者调用client->select_cb(client, 0)设置定时器和重新进入等待中断模式。

点击(此处)折叠或打开

  1. stylus_irq ->
  2. s3c_adc_start ->
  3. s3c_adc_try ->
  4. s3c_adc_select -> 
  5. client->select_cb(client, 1)
  6. s3c_adc_convert -> 
  7. s3c_adc_irq ->
  8. (client->convert_cb)(client, data0, data1, &client->nr_samples)
  9. (client->select_cb)(client, 0)



阅读(6436) | 评论(0) | 转发(4) |
5

上一篇：嵌入式软件开发问题及其解决办法记录

下一篇：Ubuntu 11.10(32 bit)下搭建Android开发环境

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6