imx28 leds 平台总线驱动-凯发app官方网站

点击(此处)折叠或打开

1. enum led_brightness {
   
2.     led_off    = 0, //熄灭
   
3.     led_half    = 127,
   
4.     led_full    = 255,
   
5. };

点击(此处)折叠或打开

1. struct led_classdev {
   
2.     const char     *name;
   
3.     int     brightness; //当前亮度,imx28 通过控制pwm控制led端的电压
   
4.     int     max_brightness; //最大亮度 led_full
   
5.     int     flags; //标志，目前只支持 led_suspended
   
6.     /*设置led的亮度，不可以睡眠*/
   
7.     void     (*brightness_set)(struct led_classdev *led_cdev,
   
8.     enum led_brightness brightness);
   
9.     /* 获取亮度 */
   
10.     enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
    
11.     /* 激活硬件加速闪烁 */
    
12.     int     (*blink_set)(struct led_classdev *led_cdev,
    
13.      unsigned long *delay_on,
    
14.      unsigned long *delay_off);
    
15. 
    
16.     struct device     *dev;
    
17.     struct list_head     node;     /* 串联起所有已经注册的led_classdev */
    
18.     const char     *default_trigger;    /* 默认触发器 */
    
19.     #ifdef config_leds_triggers
    
20.     /* 这个读写信号量保护触发器数据 */
    
21.     struct rw_semaphore     trigger_lock;
    
22.     struct led_trigger    *trigger; //触发器指针
    
23.      /*触发器使用的链表节点，用来连接同一触发器上的所有led_classdev */
    
24.     struct list_head     trig_list;
    
25.     void     *trigger_data; //触发器使用的私有数据
    
26.     #endif
    
27. };

点击(此处)折叠或打开

1. 　　struct led_trigger {
   
2.         const char     *name; //触发器名字
   
3. 　　     /*led_classdev和触发器建立连接时会调用这个方法。*/
   
4.         void        (*activate)(struct led_classdev *led_cdev);
   
5. 　　    /*led_classdev和触发器取消连接时会调用这个方法 */
   
6.         void        (*deactivate)(struct led_classdev *led_cdev);
   
7. 
   
8.         rwlock_t     leddev_list_lock; //保护链表的锁
   
9.         struct list_head led_cdevs;
   
10. 
    
11. 　     　/* 连接下一个已注册触发器的链表节点,所有已注册的触发器都会被加入一个全局链表*/
    
12.         struct list_head next_trig;
    
13. 　　};

点击(此处)折叠或打开

1. struct led_info {
   
2.      const char *name;     //led 的名字
   
3.      char *default_trigger; //默认触发器
   
4.      int flags;
   
5. };
   
6. 
   
7. struct led_platform_data {
   
8.      int num_leds; //led 个数 imx28 有2个led
   
9.      struct led_info *leds; //每个led 信息
   
10. };

点击(此处)折叠或打开

1. struct mxs_pwm_led {
   
2.     struct led_classdev dev; //每个led对应一个led_classdev
   
3.     const char *name; //名字
   
4.     unsigned int pwm; //pwm通道,最大8个通道
   
5. };
   
6. struct mxs_pwm_leds_plat_data {
   
7.     unsigned int num;
   
8.     struct mxs_pwm_led *leds;
   
9. };
   
10. struct mxs_pwm_leds {
    
11.     struct clk *pwm_clk; //pwm 模块的时钟
    
12.     unsigned int base; //寄存器基地址
    
13.     unsigned int led_num; //led 个数，这里开发板只有2个led
    
14.     struct mxs_pwm_led *leds; //指向2个led
    
15. };

点击(此处)折叠或打开

1. static int __init leds_init(void)
   
2. {
   
3.     leds_class = class_create(this_module, "leds");
   
4.     if (is_err(leds_class))
   
5.         return ptr_err(leds_class);
   
6.     leds_class->suspend = led_suspend;
   
7.     leds_class->resume = led_resume;
   
8.     return 0;
   
9. }
   
10. 
    
11. static void __exit leds_exit(void)
    
12. {
    
13.     class_destroy(leds_class);
    
14. }
    
15. 
    
16. static device_attr(brightness, 0644, led_brightness_show, led_brightness_store);
    
17. static device_attr(max_brightness, 0444, led_max_brightness_show, null);
    
18. #ifdef config_leds_triggers
    
19. static device_attr(trigger, 0644, led_trigger_show, led_trigger_store);
    
20. #endif

点击(此处)折叠或打开

1. int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
   
2. {
   
3.     int rc;
   
4.     /*创建device 在leds_class生成的目录下*/
   
5.     led_cdev->dev = device_create(leds_class, parent, 0, led_cdev,
   
6.       "%s", led_cdev->name);
   
7.     if (is_err(led_cdev->dev))
   
8.         return ptr_err(led_cdev->dev);
   
9.     /* register the attributes */
   
10.     rc = device_create_file(led_cdev->dev, &dev_attr_brightness);
    
11.     //在sys/class/leds/led-pwmx 下创建一个属性文件。
    
12.     if (rc)
    
13.         goto err_out;
    
14.     #ifdef config_leds_triggers
    
15.     init_rwsem(&led_cdev->trigger_lock);
    
16.     #endif
    
17.     /* add to the list of leds */
    
18.     down_write(&leds_list_lock);
    
19.     list_add_tail(&led_cdev->node, &leds_list);//将新的led加入全局链表
    
20.     up_write(&leds_list_lock);
    
21.     if (!led_cdev->max_brightness)
    
22.         led_cdev->max_brightness = led_full;
    
23.     rc = device_create_file(led_cdev->dev, &dev_attr_max_brightness);
    
24.     if (rc)
    
25.         goto err_out_attr_max;
    
26.     led_update_brightness(led_cdev);//获取led的当前亮度 更新led_cdev->brightness
    
27.     #ifdef config_leds_triggers
    
28.     rc = device_create_file(led_cdev->dev, &dev_attr_trigger);
    
29.     if (rc)
    
30.         goto err_out_led_list;
    
31.     led_trigger_set_default(led_cdev);//为led_cdev设置默认的触发器
    
32.     #endif
    
33.     printk(kern_info "registered led device: %s\n",
    
34.     led_cdev->name);
    
35.         return 0;
    
36.     #ifdef config_leds_triggers
    
37.     err_out_led_list:
    
38.     device_remove_file(led_cdev->dev, &dev_attr_max_brightness);
    
39.     #endif
    
40.     err_out_attr_max:
    
41.     device_remove_file(led_cdev->dev, &dev_attr_brightness);
    
42.     list_del(&led_cdev->node);
    
43.     err_out:
    
44.         device_unregister(led_cdev->dev);
    
45.     return rc;
    
46. }

点击(此处)折叠或打开

1. static ssize_t led_brightness_show(struct device *dev,
   
2.        struct device_attribute *attr, char *buf)
   
3. {
   
4.     struct led_classdev *led_cdev = dev_get_drvdata(dev);
   
5.     led_update_brightness(led_cdev);
   
6.     return sprintf(buf, "%u\n", led_cdev->brightness); //显示当前亮度
   
7. }
   
8. 
   
9. static ssize_t led_brightness_store(struct device *dev,
   
10.        struct device_attribute *attr, const char *buf, size_t size)
    
11. {
    
12.     /*取得led_classdev ,放在device的driver_data里。*/
    
13.     struct led_classdev *led_cdev = dev_get_drvdata(dev);
    
14.     ssize_t ret = -einval;
    
15.     char *after;
    
16.     unsigned long state = simple_strtoul(buf, &after, 10); //字符串形式的亮度值转换成数字。
    
17.     size_t count = after - buf;
    
18.     if (*after && isspace(*after))
    
19.     count;
    
20.     if (count == size) {
    
21.     ret = count;
    
22.     if (state == led_off)
    
23.     led_trigger_remove(led_cdev);
    
24.     //如果亮度值为0，移除trigger led_cdev->trigger = null;
    
25.     led_set_brightness(led_cdev, state); //设置亮度值
    
26.     }
    
27.     return ret;
    
28. }

点击(此处)折叠或打开

1. static struct platform_driver mxs_pwm_led_driver = {
   
2.     .probe = mxs_pwm_led_probe,
   
3.     .remove = __devexit_p(mxs_pwm_led_remove),
   
4.     .driver = {
   
5.     .name = "mxs-leds",
   
6.     },
   
7. };
   
8. static int __init mxs_pwm_led_init(void)
   
9. {
   
10.     return platform_driver_register(&mxs_pwm_led_driver);
    
11. }
    
12. static void __exit mxs_pwm_led_exit(void)
    
13. {
    
14.     platform_driver_unregister(&mxs_pwm_led_driver);
    
15. }

点击(此处)折叠或打开

1. static int __devinit mxs_pwm_led_probe(struct platform_device *pdev)
   
2. {
   
3.     struct mxs_pwm_leds_plat_data *plat_data;
   
4.     struct resource *res;
   
5.     struct led_classdev *led;
   
6.     unsigned int pwmn;
   
7.     int leds_in_use = 0, rc = 0;
   
8.     int i;
   
9.     plat_data = (struct mxs_pwm_leds_plat_data *)pdev->dev.platform_data;
   
10.     //pdev->dev.platform_data 在mx28evk_init_leds()设置了
    
11.     if (plat_data == null)
    
12.         return -enodev;
    
13.     res = platform_get_resource(pdev, ioresource_mem, 0);
    
14.     //得到资源，即pwm寄存器的物理地址
    
15.     if (res == null)
    
16.         return -enodev;
    
17.     leds.base = (unsigned int)io_address(res->start);
    
18.      //物理地址转化为虚拟地址(静态映射方式)
    
19.     mxs_reset_block((void __iomem *)leds.base, 1);
    
20.     leds.led_num = plat_data->num;
    
21.     if (leds.led_num <= 0 || leds.led_num > config_mxs_pwm_channels)
    
22.         return -efault;
    
23.     leds.leds = plat_data->leds;
    
24.     if (leds.leds == null)
    
25.         return -efault;
    
26.     leds.pwm_clk = clk_get(&pdev->dev, "pwm"); //得到pwm控制器的时钟
    
27.     if (is_err(leds.pwm_clk)) {
    
28.         rc = ptr_err(leds.pwm_clk);
    
29.         return rc;
    
30.     }
    
31.     clk_enable(leds.pwm_clk); //开启时钟
    
32.     for (i = 0; i < leds.led_num; i) {
    
33.         pwmn = leds.leds[i].pwm;
    
34.         if (pwmn >= config_mxs_pwm_channels) {//检测pwm的通道
    
35.         dev_err(&pdev->dev,
    
36.         "[led-pwm%d]:pwm %d doesn't exist\n",
    
37.         i, pwmn);
    
38.         continue;
    
39.     }
    
40.     led = &(leds.leds[i].dev);
    
41.     led->name = leds.leds[i].name;
    
42.     led->brightness = led_half;
    
43.     led->flags = 0;
    
44.     led->brightness_set = mxs_pwm_led_brightness_set;
    
45.     led->default_trigger = 0;
    
46.     //led_trigger_register 中会设置default_trigger
    
47.     rc = led_classdev_register(&pdev->dev, led);
    
48.     if (rc < 0) {
    
49.         dev_err(&pdev->dev,
    
50.         "unable to register led device %d (err=%d)\n",
    
51.         i, rc);
    
52.         continue;
    
53.     }
    
54.     leds_in_use;
    
55.     /* set default brightness */
    
56.     mxs_pwm_led_brightness_set(led, led_half);
    
57.     }
    
58.     if (leds_in_use == 0) {
    
59.         dev_info(&pdev->dev, "no pwm leds available\n");
    
60.         clk_disable(leds.pwm_clk);
    
61.         clk_put(leds.pwm_clk);
    
62.         return -enodev;
    
63.     }
    
64.     return 0;
    
65. }
    
66. 
    
67. static struct mxs_pwm_led mx28evk_led_pwm[2] = {
    
68.     [0] = {
    
69.     .name = "led-pwm0",
    
70.     .pwm = 0,//通道0
    
71.     },
    
72.     [1] = {
    
73.     .name = "led-pwm1",
    
74.     .pwm = 1,//通道1
    
75.     },
    
76. };
    
77. 
    
78. struct mxs_pwm_leds_plat_data mx28evk_led_data = {
    
79.     .num = array_size(mx28evk_led_pwm),
    
80.     .leds = mx28evk_led_pwm,
    
81. };
    
82. static struct resource mx28evk_led_res = {
    
83.     .flags = ioresource_mem,
    
84.     .start = pwm_phys_addr,
    
85.     .end = pwm_phys_addr 0x3fff, //pwm寄存器地址范围
    
86. };
    
87. 
    
88. static void __init mx28evk_init_leds(void) //系统启动时候调用
    
89. {
    
90.     struct platform_device *pdev;
    
91.     pdev = mxs_get_device("mxs-leds", 0);
    
92.     if (pdev == null || is_err(pdev))
    
93.     return;
    
94.     pdev->resource = &mx28evk_led_res;
    
95.     pdev->num_resources = 1;
    
96.     pdev->dev.platform_data = &mx28evk_led_data;
    
97.     mxs_add_device(pdev, 3);
    
98. }

点击(此处)折叠或打开

1. #define bm_pwm_ctrl_pwm_enable    ((1<<(config_mxs_pwm_channels)) - 1)
   
2. #define bf_pwm_ctrl_pwm_enable(n) ((1<<(n)) & bm_pwm_ctrl_pwm_enable)
   
3. #define bf_pwm_periodn_settings     \
   
4. (bf_pwm_periodn_cdiv(5) | /* divide by 64 */     \
   
5.  bf_pwm_periodn_inactive_state(3) | /* low */
   
6.  bf_pwm_periodn_active_state(2) | /* high */     \
   
7.  bf_pwm_periodn_period(led_full)) /* 255 cycles */
   
8.  //24mhz 进行64分频
   
9.  //这里代码注释好像有问题。通过查看数据手册，inactive_state(3)时 pwm output
   
10.  //定义为1，active_state(2) 时，为0
    
11.  //一个pwm为256个clk
    
12. 
    
13. static void mxs_pwm_led_brightness_set(struct led_classdev *pled,
    
14.     enum led_brightness value)
    
15. {
    
16.     struct mxs_pwm_led *pwm_led;
    
17.     pwm_led = container_of(pled, struct mxs_pwm_led, dev);
    
18.     if (pwm_led->pwm < config_mxs_pwm_channels) {
    
19.         //先关闭pwm
    
20.          __raw_writel(bf_pwm_ctrl_pwm_enable(pwm_led->pwm),
    
21.                leds.base hw_pwm_ctrl_clr);
    
22.        //设置无效时间和无效时间
    
23.          __raw_writel(bf_pwm_activen_inactive(led_full) |
    
24.                       bf_pwm_activen_active(value),
    
25.                leds.base hw_pwm_activen(pwm_led->pwm));
    
26.        //设置周期
    
27.        __raw_writel(bf_pwm_periodn_settings,
    
28.              leds.base hw_pwm_periodn(pwm_led->pwm));
    
29.       //打开pwm
    
30.        __raw_writel(bf_pwm_ctrl_pwm_enable(pwm_led->pwm),
    
31.              leds.base hw_pwm_ctrl_set);
    
32.     }
    
33. }