Changeset 23984


Ignore:
Timestamp:
2010-11-12T19:53:01+01:00 (6 years ago)
Author:
juhosg
Message:

generic: update gpio_buttons driver

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/files/drivers/input/misc/gpio_buttons.c

    r21952 r23984  
    2121#include <linux/init.h> 
    2222#include <linux/slab.h> 
    23  
    2423#include <linux/input.h> 
    2524#include <linux/input-polldev.h> 
    2625#include <linux/ioport.h> 
    2726#include <linux/platform_device.h> 
    28  
     27#include <linux/gpio.h> 
    2928#include <linux/gpio_buttons.h> 
    3029 
    31 #include <asm/gpio.h> 
    32  
    3330#define DRV_NAME        "gpio-buttons" 
    34 #define DRV_VERSION     "0.1.2" 
    35 #define PFX             DRV_NAME ": " 
    3631 
    3732struct gpio_button_data { 
    3833        int last_state; 
    3934        int count; 
     35        int can_sleep; 
    4036}; 
    4137 
     
    4642}; 
    4743 
     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 
    4866static void gpio_buttons_poll(struct input_polled_dev *dev) 
    4967{ 
     
    5573        for (i = 0; i < bdev->pdata->nbuttons; i++) { 
    5674                struct gpio_button *button = &pdata->buttons[i]; 
    57                 unsigned int type = button->type ?: EV_KEY; 
    58                 int state; 
    59  
    60                 if (bdev->data[i].count < button->threshold) { 
    61                         bdev->data[i].count++; 
    62                         continue; 
    63                 } 
    64  
    65                 state = gpio_get_value(button->gpio) ? 1 : 0; 
    66                 if (state != bdev->data[i].last_state) { 
    67                         input_event(input, type, button->code, 
    68                                     !!(state ^ button->active_low)); 
    69                         input_sync(input); 
    70                         bdev->data[i].count = 0; 
    71                         bdev->data[i].last_state = state; 
    72                 } 
     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 
    7382        } 
    7483} 
     
    7786{ 
    7887        struct gpio_buttons_platform_data *pdata = pdev->dev.platform_data; 
     88        struct device *dev = &pdev->dev; 
    7989        struct gpio_buttons_dev *bdev; 
    8090        struct input_polled_dev *poll_dev; 
    8191        struct input_dev *input; 
    82         int error, i; 
     92        int error; 
     93        int i; 
    8394 
    8495        if (!pdata) 
     
    8697 
    8798        bdev = kzalloc(sizeof(struct gpio_buttons_dev) + 
    88                        sizeof(struct gpio_button_data) * pdata->nbuttons, 
     99                       pdata->nbuttons * sizeof(struct gpio_button_data), 
    89100                       GFP_KERNEL); 
    90101        if (!bdev) { 
    91                 printk(KERN_ERR DRV_NAME "no memory for device\n"); 
     102                dev_err(dev, "no memory for private data\n"); 
    92103                return -ENOMEM; 
    93104        } 
     
    97108        poll_dev = input_allocate_polled_device(); 
    98109        if (!poll_dev) { 
    99                 printk(KERN_ERR DRV_NAME "no memory for polled device\n"); 
     110                dev_err(dev, "no memory for polled device\n"); 
    100111                error = -ENOMEM; 
    101112                goto err_free_bdev; 
     
    123134                unsigned int type = button->type ?: EV_KEY; 
    124135 
    125                 error = gpio_request(gpio, button->desc ? 
    126                                 button->desc : DRV_NAME); 
     136                error = gpio_request(gpio, 
     137                                     button->desc ? button->desc : DRV_NAME); 
    127138                if (error) { 
    128                         printk(KERN_ERR PFX "unable to claim gpio %u, " 
    129                                 "error %d\n", gpio, error); 
     139                        dev_err(dev, "unable to claim gpio %u, err=%d\n", 
     140                                gpio, error); 
    130141                        goto err_free_gpio; 
    131142                } 
     
    133144                error = gpio_direction_input(gpio); 
    134145                if (error) { 
    135                         printk(KERN_ERR PFX "unable to set direction on " 
    136                                 "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); 
    137149                        goto err_free_gpio; 
    138150                } 
    139151 
     152                bdev->data[i].can_sleep = gpio_cansleep(gpio); 
     153                bdev->data[i].last_state = -1; 
     154 
    140155                input_set_capability(input, type, button->code); 
    141                 bdev->data[i].last_state = gpio_get_value(button->gpio) ? 1 : 0; 
    142156        } 
    143157 
     
    148162        error = input_register_polled_device(poll_dev); 
    149163        if (error) { 
    150                 printk(KERN_ERR PFX "unable to register polled device, " 
    151                         "error %d\n", error); 
     164                dev_err(dev, "unable to register polled device, err=%d\n", 
     165                        error); 
    152166                goto err_free_gpio; 
    153167        } 
     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]); 
    154173 
    155174        return 0; 
     
    198217static int __init gpio_buttons_init(void) 
    199218{ 
    200         printk(KERN_INFO DRV_NAME " driver version " DRV_VERSION "\n"); 
    201219        return platform_driver_register(&gpio_buttons_driver); 
    202220} 
     
    210228module_exit(gpio_buttons_exit); 
    211229 
    212 MODULE_LICENSE("GPL"); 
    213 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>"); 
    214 MODULE_VERSION(DRV_VERSION); 
    215 MODULE_DESCRIPTION("Polled buttons driver for CPU GPIOs"); 
    216  
     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.