History

Input: rotary-encoder - support more than 2 gpios as input

This changes how the used gpios are stored (i.e. a struct gpio_descs instead of two struct gpio_desc) and as with >2 gpios the states are numbered differently the function rotary_encoder_get_state returns unencoded numbers instead of grey encoded numbers before. The latter has some implications on how the returned value is used and so the change is bigger than one might expect at first.

Uwe Kleine-König committed 10 years ago

Commit 7dde4e71 parent a9e340d2 files · +65 −93Browse files

Unified · Split

2 files
  1. Documentation/devicetree/bindings/input/rotary-encoder.txt +1 −1
  2. drivers/input/misc/rotary_encoder.c +64 −92
Documentation/devicetree/bindings/input/rotary-encoder.txt+1−1
@@ -1,7 +1,7 @@
1Rotary encoder DT bindings1Rotary encoder DT bindings
2 2
3Required properties:3Required properties:
4- gpios: a spec for two GPIOs to be used4- gpios: a spec for at least two GPIOs to be used, most significant first
5 5
6Optional properties:6Optional properties:
7- linux,axis: the input subsystem axis to map to this rotary encoder.7- linux,axis: the input subsystem axis to map to this rotary encoder.
drivers/input/misc/rotary_encoder.c+64−92
@@ -40,35 +40,42 @@ struct rotary_encoder { · 39 unmodified lines
40 40
41 unsigned int pos;41 unsigned int pos;
42 42
43 struct gpio_desc *gpio_a;43 struct gpio_descs *gpios;
44 struct gpio_desc *gpio_b;
45 44
46 unsigned int irq_a;45 unsigned int *irq;
47 unsigned int irq_b;
48 46
49 bool armed;47 bool armed;
50 unsigned char dir; /* 0 - clockwise, 1 - CCW */48 signed char dir; /* 1 - clockwise, -1 - CCW */
51 49
52 char last_stable;50 unsigned last_stable;
53};51};
54 52
55static int rotary_encoder_get_state(struct rotary_encoder *encoder)53static unsigned rotary_encoder_get_state(struct rotary_encoder *encoder)
56{54{
57 int a = !!gpiod_get_value_cansleep(encoder->gpio_a);55 int i;
58 int b = !!gpiod_get_value_cansleep(encoder->gpio_b);56 unsigned ret = 0;
59 57
60 return ((a << 1) | b);58 for (i = 0; i < encoder->gpios->ndescs; ++i) {
59 int val = gpiod_get_value_cansleep(encoder->gpios->desc[i]);
60 /* convert from gray encoding to normal */
61 if (ret & 1)
62 val = !val;
63
64 ret = ret << 1 | val;
65 }
66
67 return ret & 3;
61}68}
62 69
63static void rotary_encoder_report_event(struct rotary_encoder *encoder)70static void rotary_encoder_report_event(struct rotary_encoder *encoder)
64{71{
65 if (encoder->relative_axis) {72 if (encoder->relative_axis) {
66 input_report_rel(encoder->input,73 input_report_rel(encoder->input,
67 encoder->axis, encoder->dir ? -1 : 1);74 encoder->axis, encoder->dir);
68 } else {75 } else {
69 unsigned int pos = encoder->pos;76 unsigned int pos = encoder->pos;
70 77
71 if (encoder->dir) {78 if (encoder->dir < 0) {
72 /* turning counter-clockwise */79 /* turning counter-clockwise */
73 if (encoder->rollover)80 if (encoder->rollover)
74 pos += encoder->steps;81 pos += encoder->steps;
@@ -93,7 +100,7 @@ static void rotary_encoder_report_event(struct rotary_encoder *encoder) · 18 unmodified lines
93static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)100static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
94{101{
95 struct rotary_encoder *encoder = dev_id;102 struct rotary_encoder *encoder = dev_id;
96 int state;103 unsigned state;
97 104
98 mutex_lock(&encoder->access_mutex);105 mutex_lock(&encoder->access_mutex);
99 106
@@ -108,12 +115,12 @@ static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) · 8 unmodified lines
108 break;115 break;
109 116
110 case 0x1:117 case 0x1:
111 case 0x2:118 case 0x3:
112 if (encoder->armed)119 if (encoder->armed)
113 encoder->dir = state - 1;120 encoder->dir = 2 - state;
114 break;121 break;
115 122
116 case 0x3:123 case 0x2:
117 encoder->armed = true;124 encoder->armed = true;
118 break;125 break;
119 }126 }
@@ -126,25 +133,19 @@ static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) · 6 unmodified lines
126static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)133static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
127{134{
128 struct rotary_encoder *encoder = dev_id;135 struct rotary_encoder *encoder = dev_id;
129 int state;136 unsigned int state;
130 137
131 mutex_lock(&encoder->access_mutex);138 mutex_lock(&encoder->access_mutex);
132 139
133 state = rotary_encoder_get_state(encoder);140 state = rotary_encoder_get_state(encoder);
134 141
135 switch (state) {142 if (state & 1) {
136 case 0x00:143 encoder->dir = ((encoder->last_stable - state + 1) % 4) - 1;
137 case 0x03:144 } else {
138 if (state != encoder->last_stable) {145 if (state != encoder->last_stable) {
139 rotary_encoder_report_event(encoder);146 rotary_encoder_report_event(encoder);
140 encoder->last_stable = state;147 encoder->last_stable = state;
141 }148 }
142 break;
143
144 case 0x01:
145 case 0x02:
146 encoder->dir = (encoder->last_stable + state) & 0x01;
147 break;
148 }149 }
149 150
150 mutex_unlock(&encoder->access_mutex);151 mutex_unlock(&encoder->access_mutex);
@@ -155,46 +156,18 @@ static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id) · 4 unmodified lines
155static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id)156static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id)
156{157{
157 struct rotary_encoder *encoder = dev_id;158 struct rotary_encoder *encoder = dev_id;
158 unsigned char sum;159 unsigned int state;
159 int state;
160 160
161 mutex_lock(&encoder->access_mutex);161 mutex_lock(&encoder->access_mutex);
162 162
163 state = rotary_encoder_get_state(encoder);163 state = rotary_encoder_get_state(encoder);
164 164
165 /*165 if ((encoder->last_stable + 1) % 4 == state)
166 * We encode the previous and the current state using a byte.166 encoder->dir = 1;
167 * The previous state in the MSB nibble, the current state in the LSB167 else if (encoder->last_stable == (state + 1) % 4)
168 * nibble. Then use a table to decide the direction of the turn.168 encoder->dir = -1;
169 */169 else
170 sum = (encoder->last_stable << 4) + state;
171 switch (sum) {
172 case 0x31:
173 case 0x10:
174 case 0x02:
175 case 0x23:
176 encoder->dir = 0; /* clockwise */
177 break;
178
179 case 0x13:
180 case 0x01:
181 case 0x20:
182 case 0x32:
183 encoder->dir = 1; /* counter-clockwise */
184 break;
185
186 default:
187 /*
188 * Ignore all other values. This covers the case when the
189 * state didn't change (a spurious interrupt) and the
190 * cases where the state changed by two steps, making it
191 * impossible to tell the direction.
192 *
193 * In either case, don't report any event and save the
194 * state for later.
195 */
196 goto out;170 goto out;
197 }
198 171
199 rotary_encoder_report_event(encoder);172 rotary_encoder_report_event(encoder);
200 173
@@ -212,6 +185,7 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 11 unmodified lines
212 struct input_dev *input;185 struct input_dev *input;
213 irq_handler_t handler;186 irq_handler_t handler;
214 u32 steps_per_period;187 u32 steps_per_period;
188 unsigned int i;
215 int err;189 int err;
216 190
217 encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL);191 encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL);
@@ -243,24 +217,16 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 25 unmodified lines
243 encoder->relative_axis =217 encoder->relative_axis =
244 device_property_read_bool(dev, "rotary-encoder,relative-axis");218 device_property_read_bool(dev, "rotary-encoder,relative-axis");
245 219
246 encoder->gpio_a = devm_gpiod_get_index(dev, NULL, 0, GPIOD_IN);220 encoder->gpios = devm_gpiod_get_array(dev, NULL, GPIOD_IN);
247 if (IS_ERR(encoder->gpio_a)) {221 if (IS_ERR(encoder->gpios)) {
248 err = PTR_ERR(encoder->gpio_a);222 dev_err(dev, "unable to get gpios\n");
249 dev_err(dev, "unable to get GPIO at index 0: %d\n", err);223 return PTR_ERR(encoder->gpios);
250 return err;
251 }224 }
252 225 if (encoder->gpios->ndescs < 2) {
253 encoder->irq_a = gpiod_to_irq(encoder->gpio_a);226 dev_err(dev, "not enough gpios found\n");
254 227 return -EINVAL;
255 encoder->gpio_b = devm_gpiod_get_index(dev, NULL, 1, GPIOD_IN);
256 if (IS_ERR(encoder->gpio_b)) {
257 err = PTR_ERR(encoder->gpio_b);
258 dev_err(dev, "unable to get GPIO at index 1: %d\n", err);
259 return err;
260 }228 }
261 229
262 encoder->irq_b = gpiod_to_irq(encoder->gpio_b);
263
264 input = devm_input_allocate_device(dev);230 input = devm_input_allocate_device(dev);
265 if (!input)231 if (!input)
266 return -ENOMEM;232 return -ENOMEM;
@@ -277,7 +243,7 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 10 unmodified lines
277 input_set_abs_params(input,243 input_set_abs_params(input,
278 encoder->axis, 0, encoder->steps, 0, 1);244 encoder->axis, 0, encoder->steps, 0, 1);
279 245
280 switch (steps_per_period) {246 switch (steps_per_period >> (encoder->gpios->ndescs - 2)) {
281 case 4:247 case 4:
282 handler = &rotary_encoder_quarter_period_irq;248 handler = &rotary_encoder_quarter_period_irq;
283 encoder->last_stable = rotary_encoder_get_state(encoder);249 encoder->last_stable = rotary_encoder_get_state(encoder);
@@ -295,22 +261,26 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 11 unmodified lines
295 return -EINVAL;261 return -EINVAL;
296 }262 }
297 263
298 err = devm_request_threaded_irq(dev, encoder->irq_a, NULL, handler,264 encoder->irq =
299 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |265 devm_kzalloc(dev,
300 IRQF_ONESHOT,266 sizeof(*encoder->irq) * encoder->gpios->ndescs,
301 DRV_NAME, encoder);267 GFP_KERNEL);
302 if (err) {268 if (!encoder->irq)
303 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);269 return -ENOMEM;
304 return err;
305 }
306 270
307 err = devm_request_threaded_irq(dev, encoder->irq_b, NULL, handler,271 for (i = 0; i < encoder->gpios->ndescs; ++i) {
272 encoder->irq[i] = gpiod_to_irq(encoder->gpios->desc[i]);
273
274 err = devm_request_threaded_irq(dev, encoder->irq[i],
275 NULL, handler,
308 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |276 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
309 IRQF_ONESHOT,277 IRQF_ONESHOT,
310 DRV_NAME, encoder);278 DRV_NAME, encoder);
311 if (err) {279 if (err) {
312 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);280 dev_err(dev, "unable to request IRQ %d (gpio#%d)\n",
313 return err;281 encoder->irq[i], i);
282 return err;
283 }
314 }284 }
315 285
316 err = input_register_device(input);286 err = input_register_device(input);
@@ -330,10 +300,11 @@ static int rotary_encoder_probe(struct platform_device *pdev) · 13 unmodified lines
330static int __maybe_unused rotary_encoder_suspend(struct device *dev)300static int __maybe_unused rotary_encoder_suspend(struct device *dev)
331{301{
332 struct rotary_encoder *encoder = dev_get_drvdata(dev);302 struct rotary_encoder *encoder = dev_get_drvdata(dev);
303 unsigned int i;
333 304
334 if (device_may_wakeup(dev)) {305 if (device_may_wakeup(dev)) {
335 enable_irq_wake(encoder->irq_a);306 for (i = 0; i < encoder->gpios->ndescs; ++i)
336 enable_irq_wake(encoder->irq_b);307 enable_irq_wake(encoder->irq[i]);
337 }308 }
338 309
339 return 0;310 return 0;
@@ -342,10 +313,11 @@ static int __maybe_unused rotary_encoder_suspend(struct device *dev) · 2 unmodified lines
342static int __maybe_unused rotary_encoder_resume(struct device *dev)313static int __maybe_unused rotary_encoder_resume(struct device *dev)
343{314{
344 struct rotary_encoder *encoder = dev_get_drvdata(dev);315 struct rotary_encoder *encoder = dev_get_drvdata(dev);
316 unsigned int i;
345 317
346 if (device_may_wakeup(dev)) {318 if (device_may_wakeup(dev)) {
347 disable_irq_wake(encoder->irq_a);319 for (i = 0; i < encoder->gpios->ndescs; ++i)
348 disable_irq_wake(encoder->irq_b);320 disable_irq_wake(encoder->irq[i]);
349 }321 }
350 322
351 return 0;323 return 0;

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t