为什么IMX6ULL的GPT2定时器选ipg_clk时钟源，计时的快慢由Linux系统的繁忙程度决定？

zlk1214

CPU型号：MCIMX6Y2CVM08AB
系统环境：正点原子出厂状态（uboot2016.03 + linux4.1.15内核 + busybox根文件系统）

经检查，CCM_CCGR0寄存器的gpt2_bus_clk_enable位为0，GPT2的时钟没有开，认定GPT2没有被系统占用，可以自己使用。
于是在CCM_CCGR0中打开GPT2的时钟：CCM_CCGR_CG12(gpt2_bus_clk_enable)=1或3。（测试发现不打开这个，GPT2的寄存器就无法读写）
GPT2的时钟源选择Peripheral Clock (ipg_clk)时钟，该时钟源的倍频路径如下：
(pre_periph_clk_sel=0)PLL2(528MHz) -> GLITCHLESS MUX(=0) -> ahb_podf divider=4 -> ipg_podf divider=2 -> IPG_CLK_ROOT -> PERCLK_PODF divider=1 -> PERIPH_CLK_ROOT
IPG_CLK_ROOT=528MHz/4/2=66MHz
PERIPH_CLK_ROOT=66MHz/1=66MHz
因此，理论上GPT2的输入时钟源频率为66MHz，这和正点原子驱动教程里讲的一样。

编写一个利用定时器溢出中断扫描8位数码管（由两片74HC595驱动）的程序。定时器每溢出一次，点亮一位数码管。
实际测试发现，Linux系统越繁忙，数码管扫描速度越快。系统越空闲，数码管扫描速度越慢。
例如，串口命令行空闲时，数码管扫描速度非常慢，几秒钟才扫描一位。
在串口中输入命令时，数码管扫描速度稍快一些，大约一秒钟扫描一位。
运行一个冒泡排序的C程序，数码管扫描速度非常快，一秒钟能扫描整个数码管好几遍。按Ctrl+C程序一退出，扫描马上就慢下来了。
把GPT2_CNT的值打印出来，可以明显发现定时器计数有时快，有时慢。
测试还发现，GPT2如果选择Crystal oscillator as Reference Clock (ipg_clk_24M)时钟，且GPT2_CR_EN_24M=1，那么定时器完全不走时。

令GPT2_OCR1=19999，GPT2_PR=3299，理论上定时器的溢出频率是66MHz/(19999+1)/(3299+1)=1Hz，即每秒钟溢出一次。
实际测试：Linux系统空闲时3秒一次（时钟源实际频率约24MHz），Linux系统繁忙时约0.3秒一次（时钟源实际频率约2.4MHz）。
这都和时钟源的理论频率66MHz相差很远。

板上晶振的频率是24MHz，而PLL2的倍频系数是不可编程的，是固定的528MHz。那为何GPT2的ipg_clk时钟源会这么不稳定呢？而且ipg_clk_24M这个时钟源完全无法使用！
谁能帮我解释一下呢？

附：一些寄存器的值。
[ 4735.694601] CCM->CCGR0=0xcfc03f0f
[ 4735.697943] CCM->CCGR1=0x3fff0030
[ 4735.701263] GPT2->CR=0x00000000
[ 4735.706800] GPT2->IR=0x01
[ 4735.709446] GPT2->SR=0x00
[ 4735.731338] gpt2 irq number=213
[ 4735.736296] GPT2->CR=0x00000041

[ 4796.616176] CCM_CBCDR=0x00018d00
[ 4796.619431]   [IPG_PODF]=1 (divide by 2)
[ 4796.625408]   [AHB_PODF]=3 (divide by 4)
[ 4796.629358]   [GLITCHLESS MUX]=[PERIPH_CLK_SEL]|[PLL_BYPASS_EN2]=0|0=0
[ 4796.637781] CCM_CBCMR=0x25228324
[ 4796.641844]   [PRE_PERIPH_CLK_SEL]=0
[ 4796.646642] CCM_CSCMR1=0x14902140
[ 4796.649984]   [PERCLK_PODF]=0 (divide by 1)
[ 4796.655812] CCM_CMEOR=0x7fffffff
[ 4796.659065]   [MOD_EN_OV_GPT]=1

zlk1214

数码管驱动代码：

1. #include <asm/io.h>
   
2. #include <asm/uaccess.h>
   
3. #include <linux/cdev.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/of.h>
   
6. #include <linux/of_address.h>
   
7. #include <linux/of_irq.h>
   
8. #include <linux/gpio/consumer.h>
   
9. #include <linux/interrupt.h>
   
10. #include <linux/module.h>
    
11. #include <linux/platform_device.h>
    
12. #include <linux/slab.h>
    
13. 
    
14. #define _BV(n) (1ull << (n))
    
15. 
    
16. #define GPT_CR_EN_24M _BV(10)
    
17. #define GPT_CR_CLKSRC_Pos 6
    
18. #define GPT_CR_ENMOD _BV(1)
    
19. #define GPT_CR_EN _BV(0)
    
20. #define GPT_SR_OF1 _BV(0)
    
21. #define GPT_IR_OF1IE _BV(0)
    
22. 
    
23. struct imx6ull_gpt
    
24. {
    
25.         u32 CR;
    
26.         u32 PR;
    
27.         u32 SR;
    
28.         u32 IR;
    
29.         u32 OCR1;
    
30.         u32 OCR2;
    
31.         u32 OCR3;
    
32.         u32 ICR1;
    
33.         u32 ICR2;
    
34.         u32 CNT;
    
35. };
    
36. 
    
37. struct test_data
    
38. {
    
39.         struct gpio_descs *gpios;
    
40.         dev_t devid;
    
41.         struct cdev cdev;
    
42.         struct class *class;
    
43.         struct device *device;
    
44.       
    
45.         struct imx6ull_gpt __iomem *GPT2;
    
46.         u32 __iomem (*CCGR)[2];
    
47.         unsigned int irq;
    
48.       
    
49.         int number;
    
50.         int number_bit;
    
51.         int number_tmp;
    
52. };
    
53. 
    
54. struct test_file
    
55. {
    
56.         struct test_data *data;
    
57.         char msg[50];
    
58.         int len;
    
59. };
    
60. 
    
61. static int test_remove(struct platform_device *pdev);
    
62. 
    
63. static const u8 seg_table[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
    
64. 
    
65. static int test_open(struct inode *inode, struct file *file)
    
66. {
    
67.         struct test_file *p;
    
68.       
    
69.         p = kzalloc(sizeof(struct test_file), GFP_KERNEL);
    
70.         if (p == NULL)
    
71.                 return -ENOMEM;
    
72.         file->private_data = p;
    
73.       
    
74.         p->data = container_of(inode->i_cdev, struct test_data, cdev);
    
75.         snprintf(p->msg, sizeof(p->msg), "Number: %d\nCounter: %d\nGPT2->SR=0x%02x\n", p->data->number, readl(&p->data->GPT2->CNT), readl(&p->data->GPT2->SR));
    
76.         p->len = strlen(p->msg);
    
77.         return 0;
    
78. }
    
79. 
    
80. static int test_release(struct inode *inode, struct file *file)
    
81. {
    
82.         if (file->private_data != NULL)
    
83.                 kfree(file->private_data);
    
84.         return 0;
    
85. }
    
86. 
    
87. static ssize_t test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
    
88. {
    
89.         int ret;
    
90.         struct test_file *p = file->private_data;
    
91.       
    
92.         if (*off + size > p->len)
    
93.                 size = p->len - *off;
    
94.         if (size > 0)
    
95.         {
    
96.                 ret = copy_to_user(buf, p->msg, size);
    
97.                 if (ret != 0)
    
98.                         return -EFAULT;
    
99.                 *off += size;
    
100.         }
     
101.         return size;
     
102. }
     
103. 
     
104. static ssize_t test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
     
105. {
     
106.         char ch;
     
107.         char *s;
     
108.         int ret;
     
109.         struct test_file *p = file->private_data;
     
110.       
     
111.         if (size == 0)
     
112.                 return -EFAULT;
     
113.         get_user(ch, &buf[size - 1]);
     
114.         if (ch != '\r' && ch != '\n')
     
115.                 return -EFAULT;
     
116.       
     
117.         s = kzalloc(size, GFP_KERNEL);
     
118.         if (s == NULL)
     
119.                 return -ENOMEM;
     
120.         ret = copy_from_user(s, buf, size - 1);
     
121.         if (ret != 0)
     
122.         {
     
123.                 kfree(s);
     
124.                 return -EFAULT;
     
125.         }
     
126.       
     
127.         p->data->number = simple_strtol(s, NULL, 10);
     
128.         if (p->data->number < 0)
     
129.                 p->data->number = 0;
     
130.         else if (p->data->number > 99999999)
     
131.                 p->data->number = 99999999;
     
132.         kfree(s);
     
133.         return size;
     
134. }
     
135. 
     
136. static long test_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
     
137. {
     
138.         return 0;
     
139. }
     
140. 
     
141. static const struct file_operations test_fops = {
     
142.         .owner = THIS_MODULE,
     
143.         .open = test_open,
     
144.         .release = test_release,
     
145.         .read = test_read,
     
146.         .write = test_write,
     
147.         .unlocked_ioctl = test_unlocked_ioctl
     
148. };
     
149. 
     
150. static void ser_in(struct test_data *p, u8 data)
     
151. {
     
152.         int i;
     
153.       
     
154.         for (i = 0; i < 8; i++)
     
155.         {
     
156.                 gpiod_set_value(p->gpios->desc[0], 0);
     
157.                 if (data & 0x80)
     
158.                         gpiod_set_value(p->gpios->desc[2], 1);
     
159.                 else
     
160.                         gpiod_set_value(p->gpios->desc[2], 0);
     
161.                 gpiod_set_value(p->gpios->desc[0], 1);
     
162.                 data <<= 1;
     
163.         }
     
164. }
     
165. 
     
166. static void par_out(struct test_data *p)
     
167. {
     
168.         gpiod_set_value(p->gpios->desc[1], 0);
     
169.         gpiod_set_value(p->gpios->desc[1], 1);
     
170. }
     
171. 
     
172. static irqreturn_t gpt2_irqhandler(int irq, void *dev)
     
173. {
     
174.         struct test_data *p = dev;
     
175.       
     
176.         // 74HC595扫描数码管
     
177.         if (p->number_bit == 0)
     
178.                 p->number_tmp = p->number;
     
179.         else
     
180.                 p->number_tmp /= 10;
     
181.         ser_in(p, seg_table[p->number_tmp % 10]);
     
182.         ser_in(p, 1 << p->number_bit);
     
183.         par_out(p);
     
184.       
     
185.         p->number_bit++;
     
186.         if (p->number_bit == 8)
     
187.                 p->number_bit = 0;
     
188.                
     
189.         writel(GPT_SR_OF1, &p->GPT2->SR); // 写1清除中断
     
190.         return IRQ_HANDLED;
     
191. }
     
192. 
     
193. static int test_probe(struct platform_device *pdev)
     
194. {
     
195.         int ret;
     
196.         struct device_node *node;
     
197.         struct resource res;
     
198.         struct test_data *data;
     
199.       
     
200.         /* 创建结构体 */
     
201.         pr_err("test_probe(0x%p);\n", pdev);
     
202.         data = devm_kzalloc(&pdev->dev, sizeof(struct test_data), GFP_KERNEL);
     
203.         if (data == NULL)
     
204.         {
     
205.                 pr_err("devm_kzalloc() failed\n");
     
206.                 return -ENOMEM;
     
207.         }
     
208.         platform_set_drvdata(pdev, data);
     
209.       
     
210.         /* 创建设备 */
     
211.         ret = alloc_chrdev_region(&data->devid, 100, 1, "mydeviceid");
     
212.         if (ret != 0)
     
213.         {
     
214.                 pr_err("alloc_chrdev_region() failed\n");
     
215.                 return ret;
     
216.         }
     
217.         pr_err("Device ID: %d,%d\n", MAJOR(data->devid), MINOR(data->devid));
     
218.         cdev_init(&data->cdev, &test_fops);
     
219.         ret = cdev_add(&data->cdev, data->devid, 1);
     
220.         if (ret != 0)
     
221.         {
     
222.                 pr_err("cdev_add() failed\n");
     
223.                 goto err;
     
224.         }
     
225.       
     
226.         /* 创建设备文件 */
     
227.         data->class = class_create(THIS_MODULE, "classname");
     
228.         if (IS_ERR(data->class))
     
229.         {
     
230.                 pr_err("class_create() failed\n");
     
231.                 ret = PTR_ERR(data->class);
     
232.                 goto err;
     
233.         }
     
234.         data->device = device_create(data->class, NULL, data->devid, NULL, "devicename");
     
235.         if (IS_ERR(data->device))
     
236.         {
     
237.                 pr_err("device_create() failed\n");
     
238.                 ret = PTR_ERR(data->device);
     
239.                 goto err;
     
240.         }
     
241.       
     
242.         /* 获取GPIO端口 */
     
243.         data->gpios = devm_gpiod_get_array(&pdev->dev, NULL, GPIOD_OUT_LOW);
     
244.         if (IS_ERR(data->gpios))
     
245.         {
     
246.                 pr_err("devm_gpiod_get_array() failed\n");
     
247.                 ret = PTR_ERR(data->gpios);
     
248.                 goto err;
     
249.         }
     
250.       
     
251.         /* 配置GPT2定时器 */
     
252.         data->number = 20220605; // 数码管默认显示的数字
     
253.         data->GPT2 = ioremap(0x020e8000, sizeof(struct imx6ull_gpt)); // 映射GPT2外设的寄存器
     
254.         data->CCGR = ioremap(0x020c4068, sizeof(*data->CCGR)); // 映射CCM外设的CCGR0~1寄存器
     
255.         if (data->GPT2 == NULL || data->CCGR == NULL)
     
256.         {
     
257.                 // 寄存器映射失败
     
258.                 pr_err("ioremap() failed\n");
     
259.                 ret = -EFAULT;
     
260.                 goto err;
     
261.         }
     
262.         writel(readl(&data->CCGR[0]) | _BV(24), &data->CCGR[0]); // 在CCM中使能GPT2的时钟: gpt2_bus_clk_enable=1
     
263.         pr_err("CCGR0=0x%08x\n", readl(&data->CCGR[0]));
     
264.         pr_err("CCGR1=0x%08x\n", readl(&data->CCGR[1]));
     
265.         pr_err("GPT2->CR=0x%08x\n", readl(&data->GPT2->CR));
     
266.       
     
267.         writel(GPT_IR_OF1IE, &data->GPT2->IR); // 开中断
     
268.         pr_err("GPT2->IR=0x%02x\n", readl(&data->GPT2->IR));
     
269.         pr_err("GPT2->SR=0x%02x\n", readl(&data->GPT2->SR));
     
270.       
     
271.         // 循环遍历设备树中所有指定compatible的节点
     
272.         // node使用完毕后必须调用of_find_compatible_node或of_node_put释放掉
     
273.         node = NULL;
     
274.         while ((node = of_find_compatible_node(node, NULL, "fsl,imx6ul-gpt")) != NULL)
     
275.         {
     
276.                 ret = of_address_to_resource(node, 0, &res);
     
277.                 pr_err("name=%s, full_name=%s, start=0x%08x\n", node->name, node->full_name, res.start);
     
278.                 if (ret == 0 && res.start == 0x020e8000)
     
279.                 {
     
280.                         // 已找到gpt2节点
     
281.                         data->irq = irq_of_parse_and_map(node, 0); // 解析interrupts属性, 得到linux中断号
     
282.                         pr_err("found gpt2 node: irq=%d\n", data->irq);
     
283.                         of_node_put(node);
     
284.                         break;
     
285.                 }
     
286.         }
     
287.         if (data->irq == 0)
     
288.         {
     
289.                 // 没有找到gpt2节点, 或者解析gpt2节点的interrupts属性失败
     
290.                 pr_err("no IRQ found\n");
     
291.                 ret = -ENODEV;
     
292.                 goto err;
     
293.         }
     
294.         // 请求中断
     
295.         ret = devm_request_irq(&pdev->dev, data->irq, gpt2_irqhandler, IRQF_TRIGGER_RISING, "gpt2_int", data);
     
296.         if (ret != 0)
     
297.         {
     
298.                 pr_err("request_irq() failed! ret=%d\n", ret);
     
299.                 goto err;
     
300.         }
     
301.       
     
302.         writel(999, &data->GPT2->OCR1); // 计数最大值
     
303.         writel(249, &data->GPT2->PR); // 分频系数
     
304.         writel(GPT_SR_OF1, &data->GPT2->SR); // 打开定时器前必须清除中断, 以免中断线一直为高, 没有边沿出现, 无法进入中断函数
     
305.         writel((1 << GPT_CR_CLKSRC_Pos) | GPT_CR_EN, &data->GPT2->CR); // 开始定时
     
306.         pr_err("GPT2->CR=0x%08x\n", readl(&data->GPT2->CR));
     
307.         return 0;
     
308.       
     
309. err:
     
310.         test_remove(pdev);
     
311.         return ret;
     
312. }
     
313. 
     
314. static int test_remove(struct platform_device *pdev)
     
315. {
     
316.         struct test_data *data;
     
317.       
     
318.         pr_err("test_remove(0x%p);\n", pdev);
     
319.         data = platform_get_drvdata(pdev);
     
320.         if (data != NULL)
     
321.         {
     
322.                 if (data->GPT2 != NULL)
     
323.                 {
     
324.                         pr_err("GPT2->CR=0x%08x\n", readl(&data->GPT2->CR));
     
325.                         writel(readl(&data->GPT2->CR) & ~GPT_CR_EN, &data->GPT2->CR); // 停止定时
     
326.                         pr_err("GPT2->CR=0x%08x\n", readl(&data->GPT2->CR));
     
327.                         iounmap(data->GPT2);
     
328.                 }
     
329.                 if (data->CCGR != NULL)
     
330.                         iounmap(data->CCGR);
     
331.                 if (data->device != NULL && !IS_ERR(data->device))
     
332.                         device_destroy(data->class, data->devid);
     
333.                 if (data->class != NULL && !IS_ERR(data->class))
     
334.                         class_destroy(data->class);
     
335.                 cdev_del(&data->cdev);
     
336.                 unregister_chrdev_region(data->devid, 1);
     
337.                 platform_set_drvdata(pdev, NULL);
     
338.         }
     
339.         return 0;
     
340. }
     
341. 
     
342. static const struct of_device_id test_match_ids[] = {
     
343.         {.compatible = "mygpiotest,myboard2"},
     
344.         {}
     
345. };
     
346. 
     
347. MODULE_DEVICE_TABLE(of, test_match_ids);
     
348. 
     
349. static struct platform_driver test_driver = {
     
350.         .driver = {
     
351.                 .name = "mytestdriver",
     
352.                 .of_match_table = of_match_ptr(test_match_ids)
     
353.         },
     
354.         .probe = test_probe,
     
355.         .remove = test_remove
     
356. };
     
357. 
     
358. module_platform_driver(test_driver);
     
359. 
     
360. MODULE_AUTHOR("Oct1158");
     
361. MODULE_LICENSE("GPL");

复制代码

zlk1214

设备树代码：
（说明：要想使设备树中的pinctrl-*属性生效，这个节点的compatible属性就必须要匹配上某个驱动。所以驱动程序必须写成platform_driver的形式，不能光是module_init，这个在正点原子的教程里面没有说）

1. #include "imx6ull-14x14-emmc-4.3-800x480-c.dts"
   
2. 
   
3. / {
   
4.         mygpiotest {
   
5.                 compatible = "mygpiotest,myboard2";
   
6.                 pinctrl-names = "default";
   
7.                 pinctrl-0 = <&pinctrl_mygpiotest>;
   
8.                 gpios = <&gpio4 26 GPIO_ACTIVE_HIGH /* 引脚名: CSI_DATA05, 板上丝印: CAMERA D5  */
   
9.                          &gpio4 25 GPIO_ACTIVE_HIGH /* 引脚名: CSI_DATA04, 板上丝印: CAMERA D4 */
   
10.                                  &gpio4 28 GPIO_ACTIVE_HIGH /* 引脚名: CSI_DATA07, 板上丝印: CAMERA D7 */
    
11.                                  &gpio4 27 GPIO_ACTIVE_HIGH /* 引脚名: CSI_DATA06, 板上丝印: CAMERA D6 */
    
12.                 >;
    
13.         };
    
14. };
    
15. 
    
16. &iomuxc {
    
17.         imx6ul-evk {
    
18.                 /delete-node/csi1grp;
    
19.                
    
20.                 pinctrl_mygpiotest: mygpiotestgrp {
    
21.                         fsl,pins = <
    
22.                                 MX6UL_PAD_CSI_DATA05__GPIO4_IO26 0x10b0 /* 引脚名为CSI_DATA05的引脚复用为GPIO4_IO26 */
    
23.                                 MX6UL_PAD_CSI_DATA04__GPIO4_IO25 0x10b0
    
24.                                 MX6UL_PAD_CSI_DATA07__GPIO4_IO28 0x10b0
    
25.                                 MX6UL_PAD_CSI_DATA06__GPIO4_IO27 0x10b0
    
26.                         >;
    
27.                 };
    
28.         };
    
29. };
    
30. 
    
31. /* 删除不需要的节点 */
    
32. &i2c2 {
    
33.         /delete-node/ov5640@3c;
    
34. };
    
35. &csi {
    
36.         status = "disabled";
    
37.         /delete-node/port;
    
38. };

复制代码

zlk1214

冒泡排序C程序代码：

1. #include <stdlib.h>
   
2. 
   
3. #define N 10000
   
4. 
   
5. static void sort(void)
   
6. {
   
7.         int arr[N];
   
8.         int i, j, temp;
   
9.         
   
10.         for (i = 0; i < N; i++)
    
11.                 arr[i] = rand();
    
12.         for (i = 0; i < N - 1; i++)
    
13.         {
    
14.                 for (j = 0; j < N - i - 1; j++)
    
15.                 {
    
16.                         if (arr[j] > arr[j + 1])
    
17.                         {
    
18.                                 temp = arr[j];
    
19.                                 arr[j] = arr[j + 1];
    
20.                                 arr[j + 1] = temp;
    
21.                         }
    
22.                 }
    
23.         }
    
24. }
    
25. 
    
26. int main(void)
    
27. {
    
28.         while (1)
    
29.                 sort();
    
30.         return 0;
    
31. }

复制代码

查看寄存器的值的程序：

1. #include <asm/io.h>
   
2. #include <linux/module.h>
   
3. 
   
4. static int __init cv_init(void)
   
5. {
   
6.         u32 temp, value;
   
7.         void __iomem *CCM_CBCMR;
   
8.         void __iomem *CCM_CBCDR;
   
9.         void __iomem *CCM_CSCMR1;
   
10.         void __iomem *CCM_CMEOR;
    
11.       
    
12.         CCM_CBCDR = ioremap(0x020c4014, 4);
    
13.         value = readl(CCM_CBCDR);
    
14.         iounmap(CCM_CBCDR);
    
15.         pr_err("CCM_CBCDR=0x%08x\n", value);
    
16.         temp = (value >> 8) & 3;
    
17.         pr_err("  [IPG_PODF]=%d (divide by %d)\n", temp, temp + 1);
    
18.         temp = (value >> 10) & 7;
    
19.         pr_err("  [AHB_PODF]=%d (divide by %d)\n", temp, temp + 1);
    
20.         temp = (value >> 26) & 1;
    
21.         pr_err("  [GLITCHLESS MUX]=[PERIPH_CLK_SEL]|[PLL_BYPASS_EN2]=%d|0=%d\n", temp, temp);
    
22.       
    
23.         CCM_CBCMR = ioremap(0x020c4018, 4);
    
24.         value = readl(CCM_CBCMR);
    
25.         iounmap(CCM_CBCMR);
    
26.         pr_err("CCM_CBCMR=0x%08x\n", value);
    
27.         temp = (value >> 18) & 2;
    
28.         pr_err("  [PRE_PERIPH_CLK_SEL]=%d\n", temp);
    
29.       
    
30.         CCM_CSCMR1 = ioremap(0x020c401c, 4);
    
31.         value = readl(CCM_CSCMR1);
    
32.         iounmap(CCM_CSCMR1);
    
33.         pr_err("CCM_CSCMR1=0x%08x\n", value);
    
34.         temp = value & 0x3f;
    
35.         pr_err("  [PERCLK_PODF]=%d (divide by %d)\n", temp, temp + 1);
    
36.       
    
37.         CCM_CMEOR = ioremap(0x020c4088, 4);
    
38.         value = readl(CCM_CMEOR);
    
39.         iounmap(CCM_CMEOR);
    
40.         pr_err("CCM_CMEOR=0x%08x\n", value);
    
41.         temp = (value >> 5) & 1;
    
42.         pr_err("  [MOD_EN_OV_GPT]=%d\n", temp);
    
43.       
    
44.         return -ENODEV;
    
45. }
    
46. 
    
47. static void __exit cv_exit(void)
    
48. {
    
49. }
    
50. 
    
51. module_init(cv_init);
    
52. module_exit(cv_exit);
    
53. MODULE_AUTHOR("Oct1158");
    
54. MODULE_LICENSE("GPL");

复制代码

zlk1214

linux系统空闲情况下，扫描速度很慢：

驱动中GPT2->PR改成24，同时在linux系统里面运行冒泡排序的C程序，数码管才能完整显示8个数字，且各数位不闪烁。
冒泡排序的程序一旦退出，数码管数位扫描就很慢了，七八秒才扫描完一遍。

GPT2时钟树：

xiaoxiao315

试试将代码换成软件定时器，硬件定时器可能会被内核占用