Ignore:
Timestamp:
2010-11-12T23:46:00+01:00 (5 years ago)
Author:
juhosg
Message:

backfire: generic: update gpio_buttons driver (backport of r23984)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/backfire/target/linux/generic-2.6/files/drivers/input/misc/gpio_buttons.c

    r19115 r23985  
    2020#include <linux/module.h> 
    2121#include <linux/init.h> 
    22  
     22#include <linux/slab.h> 
    2323#include <linux/input.h> 
    2424#include <linux/input-polldev.h> 
    2525#include <linux/ioport.h> 
    2626#include <linux/platform_device.h> 
    27  
     27#include <linux/gpio.h> 
    2828#include <linux/gpio_buttons.h> 
    2929 
    30 #include <asm/gpio.h> 
    31  
    3230#define DRV_NAME        "gpio-buttons" 
    33 #define DRV_VERSION     "0.1.2" 
    34 #define PFX             DRV_NAME ": " 
    3531 
    3632struct gpio_button_data { 
    3733        int last_state; 
    3834        int count; 
     35        int can_sleep; 
    3936}; 
    4037 
     
    4542}; 
    4643 
     44static void gpio_buttons_check_state(struct input_dev *input, 
     45                                      struct gpio_button *button, 
     46                                      struct gpio_button_data *bdata) 
     47{ 
     48        int state; 
     49 
     50        if (bdata->can_sleep) 
     51                state = !!gpio_get_value_cansleep(button->gpio); 
     52        else 
     53                state = !!gpio_get_value(button->gpio); 
     54 
     55        if (state != bdata->last_state) { 
     56                unsigned int type = button->type ?: EV_KEY; 
     57 
     58                input_event(input, type, button->code, 
     59                            !!(state ^ button->active_low)); 
     60                input_sync(input); 
     61                bdata->count = 0; 
     62                bdata->last_state = state; 
     63        } 
     64} 
     65 
    4766static void gpio_buttons_poll(struct input_polled_dev *dev) 
    4867{ 
     
    5473        for (i = 0; i < bdev->pdata->nbuttons; i++) { 
    5574                struct gpio_button *button = &pdata->buttons[i]; 
    56                 unsigned int type = button->type ?: EV_KEY; 
    57                 int state; 
    58  
    59                 if (bdev->data[i].count < button->threshold) { 
    60                         bdev->data[i].count++; 
    61                         continue; 
    62                 } 
    63  
    64                 state = gpio_get_value(button->gpio) ? 1 : 0; 
    65                 if (state != bdev->data[i].last_state) { 
    66                         input_event(input, type, button->code, 
    67                                     !!(state ^ button->active_low)); 
    68                         input_sync(input); 
    69                         bdev->data[i].count = 0; 
    70                         bdev->data[i].last_state = state; 
    71                 } 
     75                struct gpio_button_data *bdata = &bdev->data[i]; 
     76 
     77                if (bdata->count < button->threshold) 
     78                        bdata->count++; 
     79                else 
     80                        gpio_buttons_check_state(input, button, bdata); 
     81 
    7282        } 
    7383} 
     
    7686{ 
    7787        struct gpio_buttons_platform_data *pdata = pdev->dev.platform_data; 
     88        struct device *dev = &pdev->dev; 
    7889        struct gpio_buttons_dev *bdev; 
    7990        struct input_polled_dev *poll_dev; 
    8091        struct input_dev *input; 
    81         int error, i; 
     92        int error; 
     93        int i; 
    8294 
    8395        if (!pdata) 
     
    8597 
    8698        bdev = kzalloc(sizeof(struct gpio_buttons_dev) + 
    87                        sizeof(struct gpio_button_data) * pdata->nbuttons, 
     99                       pdata->nbuttons * sizeof(struct gpio_button_data), 
    88100                       GFP_KERNEL); 
    89101        if (!bdev) { 
    90                 printk(KERN_ERR DRV_NAME "no memory for device\n"); 
     102                dev_err(dev, "no memory for private data\n"); 
    91103                return -ENOMEM; 
    92104        } 
     
    96108        poll_dev = input_allocate_polled_device(); 
    97109        if (!poll_dev) { 
    98                 printk(KERN_ERR DRV_NAME "no memory for polled device\n"); 
     110                dev_err(dev, "no memory for polled device\n"); 
    99111                error = -ENOMEM; 
    100112                goto err_free_bdev; 
     
    122134                unsigned int type = button->type ?: EV_KEY; 
    123135 
    124                 error = gpio_request(gpio, button->desc ? 
    125                                 button->desc : DRV_NAME); 
     136                error = gpio_request(gpio, 
     137                                     button->desc ? button->desc : DRV_NAME); 
    126138                if (error) { 
    127                         printk(KERN_ERR PFX "unable to claim gpio %u, " 
    128                                 "error %d\n", gpio, error); 
     139                        dev_err(dev, "unable to claim gpio %u, err=%d\n", 
     140                                gpio, error); 
    129141                        goto err_free_gpio; 
    130142                } 
     
    132144                error = gpio_direction_input(gpio); 
    133145                if (error) { 
    134                         printk(KERN_ERR PFX "unable to set direction on " 
    135                                 "gpio %u, error %d\n", gpio, error); 
     146                        dev_err(dev, 
     147                                "unable to set direction on gpio %u, err=%d\n", 
     148                                gpio, error); 
    136149                        goto err_free_gpio; 
    137150                } 
    138151 
     152                bdev->data[i].can_sleep = gpio_cansleep(gpio); 
     153                bdev->data[i].last_state = -1; 
     154 
    139155                input_set_capability(input, type, button->code); 
    140                 bdev->data[i].last_state = gpio_get_value(button->gpio) ? 1 : 0; 
    141156        } 
    142157 
     
    147162        error = input_register_polled_device(poll_dev); 
    148163        if (error) { 
    149                 printk(KERN_ERR PFX "unable to register polled device, " 
    150                         "error %d\n", error); 
     164                dev_err(dev, "unable to register polled device, err=%d\n", 
     165                        error); 
    151166                goto err_free_gpio; 
    152167        } 
     168 
     169        /* report initial state of the buttons */ 
     170        for (i = 0; i < pdata->nbuttons; i++) 
     171                gpio_buttons_check_state(input, &pdata->buttons[i], 
     172                                         &bdev->data[i]); 
    153173 
    154174        return 0; 
     
    197217static int __init gpio_buttons_init(void) 
    198218{ 
    199         printk(KERN_INFO DRV_NAME " driver version " DRV_VERSION "\n"); 
    200219        return platform_driver_register(&gpio_buttons_driver); 
    201220} 
     
    209228module_exit(gpio_buttons_exit); 
    210229 
    211 MODULE_LICENSE("GPL"); 
    212 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>"); 
    213 MODULE_VERSION(DRV_VERSION); 
    214 MODULE_DESCRIPTION("Polled buttons driver for CPU GPIOs"); 
    215  
     230MODULE_LICENSE("GPL v2"); 
     231MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); 
     232MODULE_DESCRIPTION("Polled GPIO Buttons driver"); 
Note: See TracChangeset for help on using the changeset viewer.