source: trunk/target/linux/ixp4xx/patches-2.6.35/295-latch_led_driver.patch @ 22645

Last change on this file since 22645 was 22645, checked in by juhosg, 6 years ago

ixp4xx: include linux/slab.h in the latch LED driver

File size: 4.8 KB
  • drivers/leds/Kconfig

    a b config LEDS_LP3944 
    157157          To compile this driver as a module, choose M here: the 
    158158          module will be called leds-lp3944. 
    159159 
     160config LEDS_LATCH 
     161        tristate "LED Support for Memory Latched LEDs" 
     162        depends on LEDS_CLASS 
     163        help 
     164                -- To Do -- 
     165 
     166 
    160167config LEDS_CLEVO_MAIL 
    161168        tristate "Mail LED on Clevo notebook" 
    162169        depends on LEDS_CLASS && X86 && SERIO_I8042 && DMI 
  • new file drivers/leds/leds-latch.c

    - +  
     1/* 
     2 * LEDs driver for Memory Latched Devices 
     3 * 
     4 * Copyright (C) 2008 Gateworks Corp. 
     5 * Chris Lang <clang@gateworks.com> 
     6 * 
     7 * This program is free software; you can redistribute it and/or modify 
     8 * it under the terms of the GNU General Public License version 2 as 
     9 * published by the Free Software Foundation. 
     10 * 
     11 */ 
     12#include <linux/kernel.h> 
     13#include <linux/slab.h> 
     14#include <linux/init.h> 
     15#include <linux/platform_device.h> 
     16#include <linux/leds.h> 
     17#include <linux/workqueue.h> 
     18#include <asm/io.h> 
     19#include <linux/spinlock.h> 
     20#include <linux/slab.h> 
     21 
     22static unsigned int mem_keep = 0xFF; 
     23static spinlock_t mem_lock; 
     24static unsigned char *iobase; 
     25 
     26struct latch_led_data { 
     27        struct led_classdev cdev; 
     28        struct work_struct work; 
     29        u8 new_level; 
     30        u8 bit; 
     31        void (*set_led)(u8 bit, enum led_brightness value); 
     32}; 
     33 
     34static void latch_set_led(u8 bit, enum led_brightness value) 
     35{ 
     36        if (value == LED_OFF) 
     37                mem_keep |= (0x1 << bit); 
     38        else 
     39                mem_keep &= ~(0x1 << bit); 
     40 
     41        writeb(mem_keep, iobase); 
     42} 
     43 
     44static void latch_led_set(struct led_classdev *led_cdev, 
     45        enum led_brightness value) 
     46{ 
     47        struct latch_led_data *led_dat = 
     48                container_of(led_cdev, struct latch_led_data, cdev); 
     49 
     50        raw_spin_lock(mem_lock); 
     51 
     52        led_dat->set_led(led_dat->bit, value); 
     53 
     54        raw_spin_unlock(mem_lock); 
     55} 
     56 
     57static int latch_led_probe(struct platform_device *pdev) 
     58{ 
     59        struct latch_led_platform_data *pdata = pdev->dev.platform_data; 
     60        struct latch_led *cur_led; 
     61        struct latch_led_data *leds_data, *led_dat; 
     62        int i, ret = 0; 
     63 
     64        if (!pdata) 
     65                return -EBUSY; 
     66 
     67        leds_data = kzalloc(sizeof(struct latch_led_data) * pdata->num_leds, 
     68                                GFP_KERNEL); 
     69        if (!leds_data) 
     70                return -ENOMEM; 
     71 
     72        for (i = 0; i < pdata->num_leds; i++) { 
     73                cur_led = &pdata->leds[i]; 
     74                led_dat = &leds_data[i]; 
     75 
     76                led_dat->cdev.name = cur_led->name; 
     77                led_dat->cdev.default_trigger = cur_led->default_trigger; 
     78                led_dat->cdev.brightness_set = latch_led_set; 
     79                led_dat->cdev.brightness = LED_OFF; 
     80                led_dat->bit = cur_led->bit; 
     81                led_dat->set_led = pdata->set_led ? pdata->set_led : latch_set_led; 
     82 
     83                ret = led_classdev_register(&pdev->dev, &led_dat->cdev); 
     84                if (ret < 0) { 
     85                        goto err; 
     86                } 
     87        } 
     88 
     89        if (!pdata->set_led) { 
     90                iobase = ioremap_nocache(pdata->mem, 0x1000); 
     91                writeb(0xFF, iobase); 
     92        } 
     93        platform_set_drvdata(pdev, leds_data); 
     94 
     95        return 0; 
     96 
     97err: 
     98        if (i > 0) { 
     99                for (i = i - 1; i >= 0; i--) { 
     100                        led_classdev_unregister(&leds_data[i].cdev); 
     101                } 
     102        } 
     103 
     104        kfree(leds_data); 
     105 
     106        return ret; 
     107} 
     108 
     109static int __devexit latch_led_remove(struct platform_device *pdev) 
     110{ 
     111        int i; 
     112        struct latch_led_platform_data *pdata = pdev->dev.platform_data; 
     113        struct latch_led_data *leds_data; 
     114 
     115        leds_data = platform_get_drvdata(pdev); 
     116 
     117        for (i = 0; i < pdata->num_leds; i++) { 
     118                led_classdev_unregister(&leds_data[i].cdev); 
     119                cancel_work_sync(&leds_data[i].work); 
     120        } 
     121 
     122        kfree(leds_data); 
     123 
     124        return 0; 
     125} 
     126 
     127static struct platform_driver latch_led_driver = { 
     128        .probe          = latch_led_probe, 
     129        .remove         = __devexit_p(latch_led_remove), 
     130        .driver         = { 
     131                .name   = "leds-latch", 
     132                .owner  = THIS_MODULE, 
     133        }, 
     134}; 
     135 
     136static int __init latch_led_init(void) 
     137{ 
     138        return platform_driver_register(&latch_led_driver); 
     139} 
     140 
     141static void __exit latch_led_exit(void) 
     142{ 
     143        platform_driver_unregister(&latch_led_driver); 
     144} 
     145 
     146module_init(latch_led_init); 
     147module_exit(latch_led_exit); 
     148 
     149MODULE_AUTHOR("Chris Lang <clang@gateworks.com>"); 
     150MODULE_DESCRIPTION("Latch LED driver"); 
  • drivers/leds/Makefile

    +MODULE_LICENSE("GPL");
    a b obj-$(CONFIG_LEDS_COBALT_RAQ) += leds-c 
    2020obj-$(CONFIG_LEDS_SUNFIRE)              += leds-sunfire.o 
    2121obj-$(CONFIG_LEDS_PCA9532)              += leds-pca9532.o 
    2222obj-$(CONFIG_LEDS_GPIO)                 += leds-gpio.o 
     23obj-$(CONFIG_LEDS_LATCH)                += leds-latch.o 
    2324obj-$(CONFIG_LEDS_LP3944)               += leds-lp3944.o 
    2425obj-$(CONFIG_LEDS_CLEVO_MAIL)           += leds-clevo-mail.o 
    2526obj-$(CONFIG_LEDS_HP6XX)                += leds-hp6xx.o 
  • include/linux/leds.h

    a b struct gpio_led_platform_data { 
    161161                                        unsigned long *delay_off); 
    162162}; 
    163163 
     164/* For the leds-latch driver */ 
     165struct latch_led { 
     166        const char *name; 
     167        char *default_trigger; 
     168        unsigned  bit; 
     169}; 
     170 
     171struct latch_led_platform_data { 
     172        int     num_leds; 
     173        u32     mem; 
     174        struct latch_led *leds; 
     175        void    (*set_led)(u8 bit, enum led_brightness value); 
     176}; 
     177 
    164178 
    165179#endif          /* __LINUX_LEDS_H_INCLUDED */ 
Note: See TracBrowser for help on using the repository browser.