Merge tag '5.2-rc5-smb3-fixes' of git://git.samba.org/sfrench/cifs-2.6
[linux-2.6-microblaze.git] / drivers / input / keyboard / cap11xx.c
1 /*
2  * Input driver for Microchip CAP11xx based capacitive touch sensors
3  *
4  * (c) 2014 Daniel Mack <linux@zonque.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/interrupt.h>
14 #include <linux/input.h>
15 #include <linux/leds.h>
16 #include <linux/of_irq.h>
17 #include <linux/regmap.h>
18 #include <linux/i2c.h>
19 #include <linux/gpio/consumer.h>
20
21 #define CAP11XX_REG_MAIN_CONTROL        0x00
22 #define CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT     (6)
23 #define CAP11XX_REG_MAIN_CONTROL_GAIN_MASK      (0xc0)
24 #define CAP11XX_REG_MAIN_CONTROL_DLSEEP         BIT(4)
25 #define CAP11XX_REG_GENERAL_STATUS      0x02
26 #define CAP11XX_REG_SENSOR_INPUT        0x03
27 #define CAP11XX_REG_NOISE_FLAG_STATUS   0x0a
28 #define CAP11XX_REG_SENOR_DELTA(X)      (0x10 + (X))
29 #define CAP11XX_REG_SENSITIVITY_CONTROL 0x1f
30 #define CAP11XX_REG_CONFIG              0x20
31 #define CAP11XX_REG_SENSOR_ENABLE       0x21
32 #define CAP11XX_REG_SENSOR_CONFIG       0x22
33 #define CAP11XX_REG_SENSOR_CONFIG2      0x23
34 #define CAP11XX_REG_SAMPLING_CONFIG     0x24
35 #define CAP11XX_REG_CALIBRATION         0x26
36 #define CAP11XX_REG_INT_ENABLE          0x27
37 #define CAP11XX_REG_REPEAT_RATE         0x28
38 #define CAP11XX_REG_MT_CONFIG           0x2a
39 #define CAP11XX_REG_MT_PATTERN_CONFIG   0x2b
40 #define CAP11XX_REG_MT_PATTERN          0x2d
41 #define CAP11XX_REG_RECALIB_CONFIG      0x2f
42 #define CAP11XX_REG_SENSOR_THRESH(X)    (0x30 + (X))
43 #define CAP11XX_REG_SENSOR_NOISE_THRESH 0x38
44 #define CAP11XX_REG_STANDBY_CHANNEL     0x40
45 #define CAP11XX_REG_STANDBY_CONFIG      0x41
46 #define CAP11XX_REG_STANDBY_SENSITIVITY 0x42
47 #define CAP11XX_REG_STANDBY_THRESH      0x43
48 #define CAP11XX_REG_CONFIG2             0x44
49 #define CAP11XX_REG_CONFIG2_ALT_POL     BIT(6)
50 #define CAP11XX_REG_SENSOR_BASE_CNT(X)  (0x50 + (X))
51 #define CAP11XX_REG_LED_POLARITY        0x73
52 #define CAP11XX_REG_LED_OUTPUT_CONTROL  0x74
53
54 #define CAP11XX_REG_LED_DUTY_CYCLE_1    0x90
55 #define CAP11XX_REG_LED_DUTY_CYCLE_2    0x91
56 #define CAP11XX_REG_LED_DUTY_CYCLE_3    0x92
57 #define CAP11XX_REG_LED_DUTY_CYCLE_4    0x93
58
59 #define CAP11XX_REG_LED_DUTY_MIN_MASK   (0x0f)
60 #define CAP11XX_REG_LED_DUTY_MIN_MASK_SHIFT     (0)
61 #define CAP11XX_REG_LED_DUTY_MAX_MASK   (0xf0)
62 #define CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT     (4)
63 #define CAP11XX_REG_LED_DUTY_MAX_VALUE  (15)
64
65 #define CAP11XX_REG_SENSOR_CALIB        (0xb1 + (X))
66 #define CAP11XX_REG_SENSOR_CALIB_LSB1   0xb9
67 #define CAP11XX_REG_SENSOR_CALIB_LSB2   0xba
68 #define CAP11XX_REG_PRODUCT_ID          0xfd
69 #define CAP11XX_REG_MANUFACTURER_ID     0xfe
70 #define CAP11XX_REG_REVISION            0xff
71
72 #define CAP11XX_MANUFACTURER_ID 0x5d
73
74 #ifdef CONFIG_LEDS_CLASS
75 struct cap11xx_led {
76         struct cap11xx_priv *priv;
77         struct led_classdev cdev;
78         u32 reg;
79 };
80 #endif
81
82 struct cap11xx_priv {
83         struct regmap *regmap;
84         struct input_dev *idev;
85
86         struct cap11xx_led *leds;
87         int num_leds;
88
89         /* config */
90         u32 keycodes[];
91 };
92
93 struct cap11xx_hw_model {
94         u8 product_id;
95         unsigned int num_channels;
96         unsigned int num_leds;
97 };
98
99 enum {
100         CAP1106,
101         CAP1126,
102         CAP1188,
103 };
104
105 static const struct cap11xx_hw_model cap11xx_devices[] = {
106         [CAP1106] = { .product_id = 0x55, .num_channels = 6, .num_leds = 0 },
107         [CAP1126] = { .product_id = 0x53, .num_channels = 6, .num_leds = 2 },
108         [CAP1188] = { .product_id = 0x50, .num_channels = 8, .num_leds = 8 },
109 };
110
111 static const struct reg_default cap11xx_reg_defaults[] = {
112         { CAP11XX_REG_MAIN_CONTROL,             0x00 },
113         { CAP11XX_REG_GENERAL_STATUS,           0x00 },
114         { CAP11XX_REG_SENSOR_INPUT,             0x00 },
115         { CAP11XX_REG_NOISE_FLAG_STATUS,        0x00 },
116         { CAP11XX_REG_SENSITIVITY_CONTROL,      0x2f },
117         { CAP11XX_REG_CONFIG,                   0x20 },
118         { CAP11XX_REG_SENSOR_ENABLE,            0x3f },
119         { CAP11XX_REG_SENSOR_CONFIG,            0xa4 },
120         { CAP11XX_REG_SENSOR_CONFIG2,           0x07 },
121         { CAP11XX_REG_SAMPLING_CONFIG,          0x39 },
122         { CAP11XX_REG_CALIBRATION,              0x00 },
123         { CAP11XX_REG_INT_ENABLE,               0x3f },
124         { CAP11XX_REG_REPEAT_RATE,              0x3f },
125         { CAP11XX_REG_MT_CONFIG,                0x80 },
126         { CAP11XX_REG_MT_PATTERN_CONFIG,        0x00 },
127         { CAP11XX_REG_MT_PATTERN,               0x3f },
128         { CAP11XX_REG_RECALIB_CONFIG,           0x8a },
129         { CAP11XX_REG_SENSOR_THRESH(0),         0x40 },
130         { CAP11XX_REG_SENSOR_THRESH(1),         0x40 },
131         { CAP11XX_REG_SENSOR_THRESH(2),         0x40 },
132         { CAP11XX_REG_SENSOR_THRESH(3),         0x40 },
133         { CAP11XX_REG_SENSOR_THRESH(4),         0x40 },
134         { CAP11XX_REG_SENSOR_THRESH(5),         0x40 },
135         { CAP11XX_REG_SENSOR_NOISE_THRESH,      0x01 },
136         { CAP11XX_REG_STANDBY_CHANNEL,          0x00 },
137         { CAP11XX_REG_STANDBY_CONFIG,           0x39 },
138         { CAP11XX_REG_STANDBY_SENSITIVITY,      0x02 },
139         { CAP11XX_REG_STANDBY_THRESH,           0x40 },
140         { CAP11XX_REG_CONFIG2,                  0x40 },
141         { CAP11XX_REG_LED_POLARITY,             0x00 },
142         { CAP11XX_REG_SENSOR_CALIB_LSB1,        0x00 },
143         { CAP11XX_REG_SENSOR_CALIB_LSB2,        0x00 },
144 };
145
146 static bool cap11xx_volatile_reg(struct device *dev, unsigned int reg)
147 {
148         switch (reg) {
149         case CAP11XX_REG_MAIN_CONTROL:
150         case CAP11XX_REG_SENSOR_INPUT:
151         case CAP11XX_REG_SENOR_DELTA(0):
152         case CAP11XX_REG_SENOR_DELTA(1):
153         case CAP11XX_REG_SENOR_DELTA(2):
154         case CAP11XX_REG_SENOR_DELTA(3):
155         case CAP11XX_REG_SENOR_DELTA(4):
156         case CAP11XX_REG_SENOR_DELTA(5):
157         case CAP11XX_REG_PRODUCT_ID:
158         case CAP11XX_REG_MANUFACTURER_ID:
159         case CAP11XX_REG_REVISION:
160                 return true;
161         }
162
163         return false;
164 }
165
166 static const struct regmap_config cap11xx_regmap_config = {
167         .reg_bits = 8,
168         .val_bits = 8,
169
170         .max_register = CAP11XX_REG_REVISION,
171         .reg_defaults = cap11xx_reg_defaults,
172
173         .num_reg_defaults = ARRAY_SIZE(cap11xx_reg_defaults),
174         .cache_type = REGCACHE_RBTREE,
175         .volatile_reg = cap11xx_volatile_reg,
176 };
177
178 static irqreturn_t cap11xx_thread_func(int irq_num, void *data)
179 {
180         struct cap11xx_priv *priv = data;
181         unsigned int status;
182         int ret, i;
183
184         /*
185          * Deassert interrupt. This needs to be done before reading the status
186          * registers, which will not carry valid values otherwise.
187          */
188         ret = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, 1, 0);
189         if (ret < 0)
190                 goto out;
191
192         ret = regmap_read(priv->regmap, CAP11XX_REG_SENSOR_INPUT, &status);
193         if (ret < 0)
194                 goto out;
195
196         for (i = 0; i < priv->idev->keycodemax; i++)
197                 input_report_key(priv->idev, priv->keycodes[i],
198                                  status & (1 << i));
199
200         input_sync(priv->idev);
201
202 out:
203         return IRQ_HANDLED;
204 }
205
206 static int cap11xx_set_sleep(struct cap11xx_priv *priv, bool sleep)
207 {
208         /*
209          * DLSEEP mode will turn off all LEDS, prevent this
210          */
211         if (IS_ENABLED(CONFIG_LEDS_CLASS) && priv->num_leds)
212                 return 0;
213
214         return regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL,
215                                   CAP11XX_REG_MAIN_CONTROL_DLSEEP,
216                                   sleep ? CAP11XX_REG_MAIN_CONTROL_DLSEEP : 0);
217 }
218
219 static int cap11xx_input_open(struct input_dev *idev)
220 {
221         struct cap11xx_priv *priv = input_get_drvdata(idev);
222
223         return cap11xx_set_sleep(priv, false);
224 }
225
226 static void cap11xx_input_close(struct input_dev *idev)
227 {
228         struct cap11xx_priv *priv = input_get_drvdata(idev);
229
230         cap11xx_set_sleep(priv, true);
231 }
232
233 #ifdef CONFIG_LEDS_CLASS
234 static int cap11xx_led_set(struct led_classdev *cdev,
235                             enum led_brightness value)
236 {
237         struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
238         struct cap11xx_priv *priv = led->priv;
239
240         /*
241          * All LEDs share the same duty cycle as this is a HW
242          * limitation. Brightness levels per LED are either
243          * 0 (OFF) and 1 (ON).
244          */
245         return regmap_update_bits(priv->regmap,
246                                   CAP11XX_REG_LED_OUTPUT_CONTROL,
247                                   BIT(led->reg),
248                                   value ? BIT(led->reg) : 0);
249 }
250
251 static int cap11xx_init_leds(struct device *dev,
252                              struct cap11xx_priv *priv, int num_leds)
253 {
254         struct device_node *node = dev->of_node, *child;
255         struct cap11xx_led *led;
256         int cnt = of_get_child_count(node);
257         int error;
258
259         if (!num_leds || !cnt)
260                 return 0;
261
262         if (cnt > num_leds)
263                 return -EINVAL;
264
265         led = devm_kcalloc(dev, cnt, sizeof(struct cap11xx_led), GFP_KERNEL);
266         if (!led)
267                 return -ENOMEM;
268
269         priv->leds = led;
270
271         error = regmap_update_bits(priv->regmap,
272                                 CAP11XX_REG_LED_OUTPUT_CONTROL, 0xff, 0);
273         if (error)
274                 return error;
275
276         error = regmap_update_bits(priv->regmap, CAP11XX_REG_LED_DUTY_CYCLE_4,
277                                 CAP11XX_REG_LED_DUTY_MAX_MASK,
278                                 CAP11XX_REG_LED_DUTY_MAX_VALUE <<
279                                 CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT);
280         if (error)
281                 return error;
282
283         for_each_child_of_node(node, child) {
284                 u32 reg;
285
286                 led->cdev.name =
287                         of_get_property(child, "label", NULL) ? : child->name;
288                 led->cdev.default_trigger =
289                         of_get_property(child, "linux,default-trigger", NULL);
290                 led->cdev.flags = 0;
291                 led->cdev.brightness_set_blocking = cap11xx_led_set;
292                 led->cdev.max_brightness = 1;
293                 led->cdev.brightness = LED_OFF;
294
295                 error = of_property_read_u32(child, "reg", &reg);
296                 if (error != 0 || reg >= num_leds) {
297                         of_node_put(child);
298                         return -EINVAL;
299                 }
300
301                 led->reg = reg;
302                 led->priv = priv;
303
304                 error = devm_led_classdev_register(dev, &led->cdev);
305                 if (error) {
306                         of_node_put(child);
307                         return error;
308                 }
309
310                 priv->num_leds++;
311                 led++;
312         }
313
314         return 0;
315 }
316 #else
317 static int cap11xx_init_leds(struct device *dev,
318                              struct cap11xx_priv *priv, int num_leds)
319 {
320         return 0;
321 }
322 #endif
323
324 static int cap11xx_i2c_probe(struct i2c_client *i2c_client,
325                              const struct i2c_device_id *id)
326 {
327         struct device *dev = &i2c_client->dev;
328         struct cap11xx_priv *priv;
329         struct device_node *node;
330         const struct cap11xx_hw_model *cap;
331         int i, error, irq, gain = 0;
332         unsigned int val, rev;
333         u32 gain32;
334
335         if (id->driver_data >= ARRAY_SIZE(cap11xx_devices)) {
336                 dev_err(dev, "Invalid device ID %lu\n", id->driver_data);
337                 return -EINVAL;
338         }
339
340         cap = &cap11xx_devices[id->driver_data];
341         if (!cap || !cap->num_channels) {
342                 dev_err(dev, "Invalid device configuration\n");
343                 return -EINVAL;
344         }
345
346         priv = devm_kzalloc(dev,
347                             struct_size(priv, keycodes, cap->num_channels),
348                             GFP_KERNEL);
349         if (!priv)
350                 return -ENOMEM;
351
352         priv->regmap = devm_regmap_init_i2c(i2c_client, &cap11xx_regmap_config);
353         if (IS_ERR(priv->regmap))
354                 return PTR_ERR(priv->regmap);
355
356         error = regmap_read(priv->regmap, CAP11XX_REG_PRODUCT_ID, &val);
357         if (error)
358                 return error;
359
360         if (val != cap->product_id) {
361                 dev_err(dev, "Product ID: Got 0x%02x, expected 0x%02x\n",
362                         val, cap->product_id);
363                 return -ENXIO;
364         }
365
366         error = regmap_read(priv->regmap, CAP11XX_REG_MANUFACTURER_ID, &val);
367         if (error)
368                 return error;
369
370         if (val != CAP11XX_MANUFACTURER_ID) {
371                 dev_err(dev, "Manufacturer ID: Got 0x%02x, expected 0x%02x\n",
372                         val, CAP11XX_MANUFACTURER_ID);
373                 return -ENXIO;
374         }
375
376         error = regmap_read(priv->regmap, CAP11XX_REG_REVISION, &rev);
377         if (error < 0)
378                 return error;
379
380         dev_info(dev, "CAP11XX detected, revision 0x%02x\n", rev);
381         node = dev->of_node;
382
383         if (!of_property_read_u32(node, "microchip,sensor-gain", &gain32)) {
384                 if (is_power_of_2(gain32) && gain32 <= 8)
385                         gain = ilog2(gain32);
386                 else
387                         dev_err(dev, "Invalid sensor-gain value %d\n", gain32);
388         }
389
390         if (of_property_read_bool(node, "microchip,irq-active-high")) {
391                 error = regmap_update_bits(priv->regmap, CAP11XX_REG_CONFIG2,
392                                            CAP11XX_REG_CONFIG2_ALT_POL, 0);
393                 if (error)
394                         return error;
395         }
396
397         /* Provide some useful defaults */
398         for (i = 0; i < cap->num_channels; i++)
399                 priv->keycodes[i] = KEY_A + i;
400
401         of_property_read_u32_array(node, "linux,keycodes",
402                                    priv->keycodes, cap->num_channels);
403
404         error = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL,
405                                    CAP11XX_REG_MAIN_CONTROL_GAIN_MASK,
406                                    gain << CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT);
407         if (error)
408                 return error;
409
410         /* Disable autorepeat. The Linux input system has its own handling. */
411         error = regmap_write(priv->regmap, CAP11XX_REG_REPEAT_RATE, 0);
412         if (error)
413                 return error;
414
415         priv->idev = devm_input_allocate_device(dev);
416         if (!priv->idev)
417                 return -ENOMEM;
418
419         priv->idev->name = "CAP11XX capacitive touch sensor";
420         priv->idev->id.bustype = BUS_I2C;
421         priv->idev->evbit[0] = BIT_MASK(EV_KEY);
422
423         if (of_property_read_bool(node, "autorepeat"))
424                 __set_bit(EV_REP, priv->idev->evbit);
425
426         for (i = 0; i < cap->num_channels; i++)
427                 __set_bit(priv->keycodes[i], priv->idev->keybit);
428
429         __clear_bit(KEY_RESERVED, priv->idev->keybit);
430
431         priv->idev->keycode = priv->keycodes;
432         priv->idev->keycodesize = sizeof(priv->keycodes[0]);
433         priv->idev->keycodemax = cap->num_channels;
434
435         priv->idev->id.vendor = CAP11XX_MANUFACTURER_ID;
436         priv->idev->id.product = cap->product_id;
437         priv->idev->id.version = rev;
438
439         priv->idev->open = cap11xx_input_open;
440         priv->idev->close = cap11xx_input_close;
441
442         error = cap11xx_init_leds(dev, priv, cap->num_leds);
443         if (error)
444                 return error;
445
446         input_set_drvdata(priv->idev, priv);
447
448         /*
449          * Put the device in deep sleep mode for now.
450          * ->open() will bring it back once the it is actually needed.
451          */
452         cap11xx_set_sleep(priv, true);
453
454         error = input_register_device(priv->idev);
455         if (error)
456                 return error;
457
458         irq = irq_of_parse_and_map(node, 0);
459         if (!irq) {
460                 dev_err(dev, "Unable to parse or map IRQ\n");
461                 return -ENXIO;
462         }
463
464         error = devm_request_threaded_irq(dev, irq, NULL, cap11xx_thread_func,
465                                           IRQF_ONESHOT, dev_name(dev), priv);
466         if (error)
467                 return error;
468
469         return 0;
470 }
471
472 static const struct of_device_id cap11xx_dt_ids[] = {
473         { .compatible = "microchip,cap1106", },
474         { .compatible = "microchip,cap1126", },
475         { .compatible = "microchip,cap1188", },
476         {}
477 };
478 MODULE_DEVICE_TABLE(of, cap11xx_dt_ids);
479
480 static const struct i2c_device_id cap11xx_i2c_ids[] = {
481         { "cap1106", CAP1106 },
482         { "cap1126", CAP1126 },
483         { "cap1188", CAP1188 },
484         {}
485 };
486 MODULE_DEVICE_TABLE(i2c, cap11xx_i2c_ids);
487
488 static struct i2c_driver cap11xx_i2c_driver = {
489         .driver = {
490                 .name   = "cap11xx",
491                 .of_match_table = cap11xx_dt_ids,
492         },
493         .id_table       = cap11xx_i2c_ids,
494         .probe          = cap11xx_i2c_probe,
495 };
496
497 module_i2c_driver(cap11xx_i2c_driver);
498
499 MODULE_DESCRIPTION("Microchip CAP11XX driver");
500 MODULE_AUTHOR("Daniel Mack <linux@zonque.org>");
501 MODULE_LICENSE("GPL v2");