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