1 /* 2 * rotary_encoder.c 3 * 4 * (c) 2009 Daniel Mack <daniel@caiaq.de> 5 * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com> 6 * 7 * state machine code inspired by code from Tim Ruetz 8 * 9 * A generic driver for rotary encoders connected to GPIO lines. 10 * See file:Documentation/input/rotary-encoder.txt for more information 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/init.h> 20 #include <linux/interrupt.h> 21 #include <linux/input.h> 22 #include <linux/device.h> 23 #include <linux/platform_device.h> 24 #include <linux/gpio.h> 25 #include <linux/rotary_encoder.h> 26 #include <linux/slab.h> 27 28 #define DRV_NAME "rotary-encoder" 29 30 struct rotary_encoder { 31 struct input_dev *input; 32 struct rotary_encoder_platform_data *pdata; 33 34 unsigned int axis; 35 unsigned int pos; 36 37 unsigned int irq_a; 38 unsigned int irq_b; 39 40 bool armed; 41 unsigned char dir; /* 0 - clockwise, 1 - CCW */ 42 43 char last_stable; 44 }; 45 46 static int rotary_encoder_get_state(struct rotary_encoder_platform_data *pdata) 47 { 48 int a = !!gpio_get_value(pdata->gpio_a); 49 int b = !!gpio_get_value(pdata->gpio_b); 50 51 a ^= pdata->inverted_a; 52 b ^= pdata->inverted_b; 53 54 return ((a << 1) | b); 55 } 56 57 static void rotary_encoder_report_event(struct rotary_encoder *encoder) 58 { 59 struct rotary_encoder_platform_data *pdata = encoder->pdata; 60 61 if (pdata->relative_axis) { 62 input_report_rel(encoder->input, 63 pdata->axis, encoder->dir ? -1 : 1); 64 } else { 65 unsigned int pos = encoder->pos; 66 67 if (encoder->dir) { 68 /* turning counter-clockwise */ 69 if (pdata->rollover) 70 pos += pdata->steps; 71 if (pos) 72 pos--; 73 } else { 74 /* turning clockwise */ 75 if (pdata->rollover || pos < pdata->steps) 76 pos++; 77 } 78 79 if (pdata->rollover) 80 pos %= pdata->steps; 81 82 encoder->pos = pos; 83 input_report_abs(encoder->input, pdata->axis, encoder->pos); 84 } 85 86 input_sync(encoder->input); 87 } 88 89 static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) 90 { 91 struct rotary_encoder *encoder = dev_id; 92 int state; 93 94 state = rotary_encoder_get_state(encoder->pdata); 95 96 switch (state) { 97 case 0x0: 98 if (encoder->armed) { 99 rotary_encoder_report_event(encoder); 100 encoder->armed = false; 101 } 102 break; 103 104 case 0x1: 105 case 0x2: 106 if (encoder->armed) 107 encoder->dir = state - 1; 108 break; 109 110 case 0x3: 111 encoder->armed = true; 112 break; 113 } 114 115 return IRQ_HANDLED; 116 } 117 118 static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id) 119 { 120 struct rotary_encoder *encoder = dev_id; 121 int state; 122 123 state = rotary_encoder_get_state(encoder->pdata); 124 125 switch (state) { 126 case 0x00: 127 case 0x03: 128 if (state != encoder->last_stable) { 129 rotary_encoder_report_event(encoder); 130 encoder->last_stable = state; 131 } 132 break; 133 134 case 0x01: 135 case 0x02: 136 encoder->dir = (encoder->last_stable + state) & 0x01; 137 break; 138 } 139 140 return IRQ_HANDLED; 141 } 142 143 static int __devinit rotary_encoder_probe(struct platform_device *pdev) 144 { 145 struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data; 146 struct rotary_encoder *encoder; 147 struct input_dev *input; 148 struct device *dev = &pdev->dev; 149 irq_handler_t handler; 150 int err; 151 152 if (!pdata) { 153 dev_err(&pdev->dev, "missing platform data\n"); 154 return -ENOENT; 155 } 156 157 encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL); 158 input = input_allocate_device(); 159 if (!encoder || !input) { 160 dev_err(&pdev->dev, "failed to allocate memory for device\n"); 161 err = -ENOMEM; 162 goto exit_free_mem; 163 } 164 165 encoder->input = input; 166 encoder->pdata = pdata; 167 168 /* create and register the input driver */ 169 input->name = pdev->name; 170 input->id.bustype = BUS_HOST; 171 input->dev.parent = &pdev->dev; 172 173 if (pdata->relative_axis) { 174 input->evbit[0] = BIT_MASK(EV_REL); 175 input->relbit[0] = BIT_MASK(pdata->axis); 176 } else { 177 input->evbit[0] = BIT_MASK(EV_ABS); 178 input_set_abs_params(encoder->input, 179 pdata->axis, 0, pdata->steps, 0, 1); 180 } 181 182 err = input_register_device(input); 183 if (err) { 184 dev_err(dev, "failed to register input device\n"); 185 goto exit_free_mem; 186 } 187 188 /* request the GPIOs */ 189 err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev)); 190 if (err) { 191 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a); 192 goto exit_unregister_input; 193 } 194 195 err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev)); 196 if (err) { 197 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b); 198 goto exit_free_gpio_a; 199 } 200 201 encoder->irq_a = gpio_to_irq(pdata->gpio_a); 202 encoder->irq_b = gpio_to_irq(pdata->gpio_b); 203 204 /* request the IRQs */ 205 if (pdata->half_period) { 206 handler = &rotary_encoder_half_period_irq; 207 encoder->last_stable = rotary_encoder_get_state(pdata); 208 } else { 209 handler = &rotary_encoder_irq; 210 } 211 212 err = request_irq(encoder->irq_a, handler, 213 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 214 DRV_NAME, encoder); 215 if (err) { 216 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a); 217 goto exit_free_gpio_b; 218 } 219 220 err = request_irq(encoder->irq_b, handler, 221 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 222 DRV_NAME, encoder); 223 if (err) { 224 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b); 225 goto exit_free_irq_a; 226 } 227 228 platform_set_drvdata(pdev, encoder); 229 230 return 0; 231 232 exit_free_irq_a: 233 free_irq(encoder->irq_a, encoder); 234 exit_free_gpio_b: 235 gpio_free(pdata->gpio_b); 236 exit_free_gpio_a: 237 gpio_free(pdata->gpio_a); 238 exit_unregister_input: 239 input_unregister_device(input); 240 input = NULL; /* so we don't try to free it */ 241 exit_free_mem: 242 input_free_device(input); 243 kfree(encoder); 244 return err; 245 } 246 247 static int __devexit rotary_encoder_remove(struct platform_device *pdev) 248 { 249 struct rotary_encoder *encoder = platform_get_drvdata(pdev); 250 struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data; 251 252 free_irq(encoder->irq_a, encoder); 253 free_irq(encoder->irq_b, encoder); 254 gpio_free(pdata->gpio_a); 255 gpio_free(pdata->gpio_b); 256 input_unregister_device(encoder->input); 257 platform_set_drvdata(pdev, NULL); 258 kfree(encoder); 259 260 return 0; 261 } 262 263 static struct platform_driver rotary_encoder_driver = { 264 .probe = rotary_encoder_probe, 265 .remove = __devexit_p(rotary_encoder_remove), 266 .driver = { 267 .name = DRV_NAME, 268 .owner = THIS_MODULE, 269 } 270 }; 271 module_platform_driver(rotary_encoder_driver); 272 273 MODULE_ALIAS("platform:" DRV_NAME); 274 MODULE_DESCRIPTION("GPIO rotary encoder driver"); 275 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold"); 276 MODULE_LICENSE("GPL v2"); 277