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.h> 14 #include <linux/regmap.h> 15 #include <linux/i2c.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/bitfield.h> 18 19 #define CAP11XX_REG_MAIN_CONTROL 0x00 20 #define CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT (6) 21 #define CAP11XX_REG_MAIN_CONTROL_GAIN_MASK (0xc0) 22 #define CAP11XX_REG_MAIN_CONTROL_DLSEEP BIT(4) 23 #define CAP11XX_REG_GENERAL_STATUS 0x02 24 #define CAP11XX_REG_SENSOR_INPUT 0x03 25 #define CAP11XX_REG_NOISE_FLAG_STATUS 0x0a 26 #define CAP11XX_REG_SENOR_DELTA(X) (0x10 + (X)) 27 #define CAP11XX_REG_SENSITIVITY_CONTROL 0x1f 28 #define CAP11XX_REG_SENSITIVITY_CONTROL_DELTA_SENSE_MASK 0x70 29 #define CAP11XX_REG_CONFIG 0x20 30 #define CAP11XX_REG_SENSOR_ENABLE 0x21 31 #define CAP11XX_REG_SENSOR_CONFIG 0x22 32 #define CAP11XX_REG_SENSOR_CONFIG2 0x23 33 #define CAP11XX_REG_SAMPLING_CONFIG 0x24 34 #define CAP11XX_REG_CALIBRATION 0x26 35 #define CAP11XX_REG_INT_ENABLE 0x27 36 #define CAP11XX_REG_REPEAT_RATE 0x28 37 #define CAP11XX_REG_SIGNAL_GUARD_ENABLE 0x29 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 #define CAP11XX_REG_CALIB_SENSITIVITY_CONFIG 0x80 54 #define CAP11XX_REG_CALIB_SENSITIVITY_CONFIG2 0x81 55 56 #define CAP11XX_REG_LED_DUTY_CYCLE_1 0x90 57 #define CAP11XX_REG_LED_DUTY_CYCLE_2 0x91 58 #define CAP11XX_REG_LED_DUTY_CYCLE_3 0x92 59 #define CAP11XX_REG_LED_DUTY_CYCLE_4 0x93 60 61 #define CAP11XX_REG_LED_DUTY_MIN_MASK (0x0f) 62 #define CAP11XX_REG_LED_DUTY_MIN_MASK_SHIFT (0) 63 #define CAP11XX_REG_LED_DUTY_MAX_MASK (0xf0) 64 #define CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT (4) 65 #define CAP11XX_REG_LED_DUTY_MAX_VALUE (15) 66 67 #define CAP11XX_REG_SENSOR_CALIB (0xb1 + (X)) 68 #define CAP11XX_REG_SENSOR_CALIB_LSB1 0xb9 69 #define CAP11XX_REG_SENSOR_CALIB_LSB2 0xba 70 #define CAP11XX_REG_PRODUCT_ID 0xfd 71 #define CAP11XX_REG_MANUFACTURER_ID 0xfe 72 #define CAP11XX_REG_REVISION 0xff 73 74 #define CAP11XX_MANUFACTURER_ID 0x5d 75 76 #ifdef CONFIG_LEDS_CLASS 77 struct cap11xx_led { 78 struct cap11xx_priv *priv; 79 struct led_classdev cdev; 80 u32 reg; 81 }; 82 #endif 83 84 struct cap11xx_priv { 85 struct regmap *regmap; 86 struct device *dev; 87 struct input_dev *idev; 88 const struct cap11xx_hw_model *model; 89 90 struct cap11xx_led *leds; 91 int num_leds; 92 93 /* config */ 94 u8 analog_gain; 95 u8 sensitivity_delta_sense; 96 u8 signal_guard_inputs_mask; 97 u32 thresholds[8]; 98 u32 calib_sensitivities[8]; 99 u32 keycodes[]; 100 }; 101 102 struct cap11xx_hw_model { 103 u8 product_id; 104 unsigned int num_channels; 105 unsigned int num_leds; 106 bool has_gain; 107 bool has_irq_config; 108 bool has_sensitivity_control; 109 bool has_signal_guard; 110 }; 111 112 static const struct reg_default cap11xx_reg_defaults[] = { 113 { CAP11XX_REG_MAIN_CONTROL, 0x00 }, 114 { CAP11XX_REG_GENERAL_STATUS, 0x00 }, 115 { CAP11XX_REG_SENSOR_INPUT, 0x00 }, 116 { CAP11XX_REG_NOISE_FLAG_STATUS, 0x00 }, 117 { CAP11XX_REG_SENSITIVITY_CONTROL, 0x2f }, 118 { CAP11XX_REG_CONFIG, 0x20 }, 119 { CAP11XX_REG_SENSOR_ENABLE, 0x3f }, 120 { CAP11XX_REG_SENSOR_CONFIG, 0xa4 }, 121 { CAP11XX_REG_SENSOR_CONFIG2, 0x07 }, 122 { CAP11XX_REG_SAMPLING_CONFIG, 0x39 }, 123 { CAP11XX_REG_CALIBRATION, 0x00 }, 124 { CAP11XX_REG_INT_ENABLE, 0x3f }, 125 { CAP11XX_REG_REPEAT_RATE, 0x3f }, 126 { CAP11XX_REG_MT_CONFIG, 0x80 }, 127 { CAP11XX_REG_MT_PATTERN_CONFIG, 0x00 }, 128 { CAP11XX_REG_MT_PATTERN, 0x3f }, 129 { CAP11XX_REG_RECALIB_CONFIG, 0x8a }, 130 { CAP11XX_REG_SENSOR_THRESH(0), 0x40 }, 131 { CAP11XX_REG_SENSOR_THRESH(1), 0x40 }, 132 { CAP11XX_REG_SENSOR_THRESH(2), 0x40 }, 133 { CAP11XX_REG_SENSOR_THRESH(3), 0x40 }, 134 { CAP11XX_REG_SENSOR_THRESH(4), 0x40 }, 135 { CAP11XX_REG_SENSOR_THRESH(5), 0x40 }, 136 { CAP11XX_REG_SENSOR_NOISE_THRESH, 0x01 }, 137 { CAP11XX_REG_STANDBY_CHANNEL, 0x00 }, 138 { CAP11XX_REG_STANDBY_CONFIG, 0x39 }, 139 { CAP11XX_REG_STANDBY_SENSITIVITY, 0x02 }, 140 { CAP11XX_REG_STANDBY_THRESH, 0x40 }, 141 { CAP11XX_REG_CONFIG2, 0x40 }, 142 { CAP11XX_REG_LED_POLARITY, 0x00 }, 143 { CAP11XX_REG_SENSOR_CALIB_LSB1, 0x00 }, 144 { CAP11XX_REG_SENSOR_CALIB_LSB2, 0x00 }, 145 }; 146 147 static bool cap11xx_volatile_reg(struct device *dev, unsigned int reg) 148 { 149 switch (reg) { 150 case CAP11XX_REG_MAIN_CONTROL: 151 case CAP11XX_REG_SENSOR_INPUT: 152 case CAP11XX_REG_SENOR_DELTA(0): 153 case CAP11XX_REG_SENOR_DELTA(1): 154 case CAP11XX_REG_SENOR_DELTA(2): 155 case CAP11XX_REG_SENOR_DELTA(3): 156 case CAP11XX_REG_SENOR_DELTA(4): 157 case CAP11XX_REG_SENOR_DELTA(5): 158 return true; 159 } 160 161 return false; 162 } 163 164 static const struct regmap_config cap11xx_regmap_config = { 165 .reg_bits = 8, 166 .val_bits = 8, 167 168 .max_register = CAP11XX_REG_REVISION, 169 .reg_defaults = cap11xx_reg_defaults, 170 171 .num_reg_defaults = ARRAY_SIZE(cap11xx_reg_defaults), 172 .cache_type = REGCACHE_MAPLE, 173 .volatile_reg = cap11xx_volatile_reg, 174 }; 175 176 static int cap11xx_write_calib_sens_config_1(struct cap11xx_priv *priv) 177 { 178 return regmap_write(priv->regmap, 179 CAP11XX_REG_CALIB_SENSITIVITY_CONFIG, 180 (priv->calib_sensitivities[3] << 6) | 181 (priv->calib_sensitivities[2] << 4) | 182 (priv->calib_sensitivities[1] << 2) | 183 priv->calib_sensitivities[0]); 184 } 185 186 static int cap11xx_write_calib_sens_config_2(struct cap11xx_priv *priv) 187 { 188 return regmap_write(priv->regmap, 189 CAP11XX_REG_CALIB_SENSITIVITY_CONFIG2, 190 (priv->calib_sensitivities[7] << 6) | 191 (priv->calib_sensitivities[6] << 4) | 192 (priv->calib_sensitivities[5] << 2) | 193 priv->calib_sensitivities[4]); 194 } 195 196 static int cap11xx_init_keys(struct cap11xx_priv *priv) 197 { 198 struct device_node *node = priv->dev->of_node; 199 struct device *dev = priv->dev; 200 int i, error; 201 u32 u32_val; 202 203 if (!node) { 204 dev_err(dev, "Corresponding DT entry is not available\n"); 205 return -ENODEV; 206 } 207 208 if (!of_property_read_u32(node, "microchip,sensor-gain", &u32_val)) { 209 if (!priv->model->has_gain) { 210 dev_warn(dev, 211 "This model doesn't support 'sensor-gain'\n"); 212 } else if (is_power_of_2(u32_val) && u32_val <= 8) { 213 priv->analog_gain = (u8)ilog2(u32_val); 214 215 error = regmap_update_bits(priv->regmap, 216 CAP11XX_REG_MAIN_CONTROL, 217 CAP11XX_REG_MAIN_CONTROL_GAIN_MASK, 218 priv->analog_gain << CAP11XX_REG_MAIN_CONTROL_GAIN_SHIFT); 219 if (error) 220 return error; 221 } else { 222 dev_err(dev, "Invalid sensor-gain value %u\n", u32_val); 223 return -EINVAL; 224 } 225 } 226 227 if (of_property_read_bool(node, "microchip,irq-active-high")) { 228 if (priv->model->has_irq_config) { 229 error = regmap_update_bits(priv->regmap, 230 CAP11XX_REG_CONFIG2, 231 CAP11XX_REG_CONFIG2_ALT_POL, 232 0); 233 if (error) 234 return error; 235 } else { 236 dev_warn(dev, 237 "This model doesn't support 'irq-active-high'\n"); 238 } 239 } 240 241 if (!of_property_read_u32(node, "microchip,sensitivity-delta-sense", &u32_val)) { 242 if (!is_power_of_2(u32_val) || u32_val > 128) { 243 dev_err(dev, "Invalid sensitivity-delta-sense value %u\n", u32_val); 244 return -EINVAL; 245 } 246 247 priv->sensitivity_delta_sense = (u8)ilog2(u32_val); 248 u32_val = ~(FIELD_PREP(CAP11XX_REG_SENSITIVITY_CONTROL_DELTA_SENSE_MASK, 249 priv->sensitivity_delta_sense)); 250 251 error = regmap_update_bits(priv->regmap, 252 CAP11XX_REG_SENSITIVITY_CONTROL, 253 CAP11XX_REG_SENSITIVITY_CONTROL_DELTA_SENSE_MASK, 254 u32_val); 255 if (error) 256 return error; 257 } 258 259 if (!of_property_read_u32_array(node, "microchip,input-threshold", 260 priv->thresholds, priv->model->num_channels)) { 261 for (i = 0; i < priv->model->num_channels; i++) { 262 if (priv->thresholds[i] > 127) { 263 dev_err(dev, "Invalid input-threshold value %u\n", 264 priv->thresholds[i]); 265 return -EINVAL; 266 } 267 268 error = regmap_write(priv->regmap, 269 CAP11XX_REG_SENSOR_THRESH(i), 270 priv->thresholds[i]); 271 if (error) 272 return error; 273 } 274 } 275 276 if (!of_property_read_u32_array(node, "microchip,calib-sensitivity", 277 priv->calib_sensitivities, 278 priv->model->num_channels)) { 279 if (priv->model->has_sensitivity_control) { 280 for (i = 0; i < priv->model->num_channels; i++) { 281 if (!is_power_of_2(priv->calib_sensitivities[i]) || 282 priv->calib_sensitivities[i] > 4) { 283 dev_err(dev, "Invalid calib-sensitivity value %u\n", 284 priv->calib_sensitivities[i]); 285 return -EINVAL; 286 } 287 priv->calib_sensitivities[i] = ilog2(priv->calib_sensitivities[i]); 288 } 289 290 error = cap11xx_write_calib_sens_config_1(priv); 291 if (error) 292 return error; 293 294 if (priv->model->num_channels > 4) { 295 error = cap11xx_write_calib_sens_config_2(priv); 296 if (error) 297 return error; 298 } 299 } else { 300 dev_warn(dev, 301 "This model doesn't support 'calib-sensitivity'\n"); 302 } 303 } 304 305 for (i = 0; i < priv->model->num_channels; i++) { 306 if (!of_property_read_u32_index(node, "microchip,signal-guard", 307 i, &u32_val)) { 308 if (u32_val > 1) 309 return -EINVAL; 310 if (u32_val) 311 priv->signal_guard_inputs_mask |= 0x01 << i; 312 } 313 } 314 315 if (priv->signal_guard_inputs_mask) { 316 if (priv->model->has_signal_guard) { 317 error = regmap_write(priv->regmap, 318 CAP11XX_REG_SIGNAL_GUARD_ENABLE, 319 priv->signal_guard_inputs_mask); 320 if (error) 321 return error; 322 } else { 323 dev_warn(dev, 324 "This model doesn't support 'signal-guard'\n"); 325 } 326 } 327 328 /* Provide some useful defaults */ 329 for (i = 0; i < priv->model->num_channels; i++) 330 priv->keycodes[i] = KEY_A + i; 331 332 of_property_read_u32_array(node, "linux,keycodes", 333 priv->keycodes, priv->model->num_channels); 334 335 /* Disable autorepeat. The Linux input system has its own handling. */ 336 error = regmap_write(priv->regmap, CAP11XX_REG_REPEAT_RATE, 0); 337 if (error) 338 return error; 339 340 return 0; 341 } 342 343 static irqreturn_t cap11xx_thread_func(int irq_num, void *data) 344 { 345 struct cap11xx_priv *priv = data; 346 unsigned int status; 347 int ret, i; 348 349 /* 350 * Deassert interrupt. This needs to be done before reading the status 351 * registers, which will not carry valid values otherwise. 352 */ 353 ret = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, 1, 0); 354 if (ret < 0) 355 goto out; 356 357 ret = regmap_read(priv->regmap, CAP11XX_REG_SENSOR_INPUT, &status); 358 if (ret < 0) 359 goto out; 360 361 for (i = 0; i < priv->idev->keycodemax; i++) 362 input_report_key(priv->idev, priv->keycodes[i], 363 status & (1 << i)); 364 365 input_sync(priv->idev); 366 367 out: 368 return IRQ_HANDLED; 369 } 370 371 static int cap11xx_set_sleep(struct cap11xx_priv *priv, bool sleep) 372 { 373 /* 374 * DLSEEP mode will turn off all LEDS, prevent this 375 */ 376 if (IS_ENABLED(CONFIG_LEDS_CLASS) && priv->num_leds) 377 return 0; 378 379 return regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, 380 CAP11XX_REG_MAIN_CONTROL_DLSEEP, 381 sleep ? CAP11XX_REG_MAIN_CONTROL_DLSEEP : 0); 382 } 383 384 static int cap11xx_input_open(struct input_dev *idev) 385 { 386 struct cap11xx_priv *priv = input_get_drvdata(idev); 387 388 return cap11xx_set_sleep(priv, false); 389 } 390 391 static void cap11xx_input_close(struct input_dev *idev) 392 { 393 struct cap11xx_priv *priv = input_get_drvdata(idev); 394 395 cap11xx_set_sleep(priv, true); 396 } 397 398 #ifdef CONFIG_LEDS_CLASS 399 static int cap11xx_led_set(struct led_classdev *cdev, 400 enum led_brightness value) 401 { 402 struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev); 403 struct cap11xx_priv *priv = led->priv; 404 405 /* 406 * All LEDs share the same duty cycle as this is a HW 407 * limitation. Brightness levels per LED are either 408 * 0 (OFF) and 1 (ON). 409 */ 410 return regmap_update_bits(priv->regmap, 411 CAP11XX_REG_LED_OUTPUT_CONTROL, 412 BIT(led->reg), 413 value ? BIT(led->reg) : 0); 414 } 415 416 static int cap11xx_init_leds(struct device *dev, 417 struct cap11xx_priv *priv, int num_leds) 418 { 419 struct device_node *node = dev->of_node, *child; 420 struct cap11xx_led *led; 421 int cnt = of_get_child_count(node); 422 int error; 423 424 if (!num_leds || !cnt) 425 return 0; 426 427 if (cnt > num_leds) 428 return -EINVAL; 429 430 led = devm_kcalloc(dev, cnt, sizeof(struct cap11xx_led), GFP_KERNEL); 431 if (!led) 432 return -ENOMEM; 433 434 priv->leds = led; 435 436 error = regmap_update_bits(priv->regmap, 437 CAP11XX_REG_LED_OUTPUT_CONTROL, 0xff, 0); 438 if (error) 439 return error; 440 441 error = regmap_update_bits(priv->regmap, CAP11XX_REG_LED_DUTY_CYCLE_4, 442 CAP11XX_REG_LED_DUTY_MAX_MASK, 443 CAP11XX_REG_LED_DUTY_MAX_VALUE << 444 CAP11XX_REG_LED_DUTY_MAX_MASK_SHIFT); 445 if (error) 446 return error; 447 448 for_each_child_of_node(node, child) { 449 u32 reg; 450 451 led->cdev.name = 452 of_get_property(child, "label", NULL) ? : child->name; 453 led->cdev.default_trigger = 454 of_get_property(child, "linux,default-trigger", NULL); 455 led->cdev.flags = 0; 456 led->cdev.brightness_set_blocking = cap11xx_led_set; 457 led->cdev.max_brightness = 1; 458 led->cdev.brightness = LED_OFF; 459 460 error = of_property_read_u32(child, "reg", ®); 461 if (error != 0 || reg >= num_leds) { 462 of_node_put(child); 463 return -EINVAL; 464 } 465 466 led->reg = reg; 467 led->priv = priv; 468 469 error = devm_led_classdev_register(dev, &led->cdev); 470 if (error) { 471 of_node_put(child); 472 return error; 473 } 474 475 priv->num_leds++; 476 led++; 477 } 478 479 return 0; 480 } 481 #else 482 static int cap11xx_init_leds(struct device *dev, 483 struct cap11xx_priv *priv, int num_leds) 484 { 485 return 0; 486 } 487 #endif 488 489 static int cap11xx_i2c_probe(struct i2c_client *i2c_client) 490 { 491 const struct i2c_device_id *id; 492 const struct cap11xx_hw_model *cap; 493 struct device *dev = &i2c_client->dev; 494 struct cap11xx_priv *priv; 495 int i, error; 496 unsigned int val, rev; 497 498 id = i2c_client_get_device_id(i2c_client); 499 cap = i2c_get_match_data(i2c_client); 500 if (!id || !cap || !cap->num_channels) { 501 dev_err(dev, "Invalid device configuration\n"); 502 return -EINVAL; 503 } 504 505 priv = devm_kzalloc(dev, 506 struct_size(priv, keycodes, cap->num_channels), 507 GFP_KERNEL); 508 if (!priv) 509 return -ENOMEM; 510 511 priv->dev = dev; 512 513 priv->regmap = devm_regmap_init_i2c(i2c_client, &cap11xx_regmap_config); 514 if (IS_ERR(priv->regmap)) 515 return PTR_ERR(priv->regmap); 516 517 error = regmap_read(priv->regmap, CAP11XX_REG_PRODUCT_ID, &val); 518 if (error) 519 return error; 520 521 if (val != cap->product_id) { 522 dev_err(dev, "Product ID: Got 0x%02x, expected 0x%02x\n", 523 val, cap->product_id); 524 return -ENXIO; 525 } 526 527 error = regmap_read(priv->regmap, CAP11XX_REG_MANUFACTURER_ID, &val); 528 if (error) 529 return error; 530 531 if (val != CAP11XX_MANUFACTURER_ID) { 532 dev_err(dev, "Manufacturer ID: Got 0x%02x, expected 0x%02x\n", 533 val, CAP11XX_MANUFACTURER_ID); 534 return -ENXIO; 535 } 536 537 error = regmap_read(priv->regmap, CAP11XX_REG_REVISION, &rev); 538 if (error < 0) 539 return error; 540 541 dev_info(dev, "CAP11XX detected, model %s, revision 0x%02x\n", 542 id->name, rev); 543 544 priv->model = cap; 545 546 dev_info(dev, "CAP11XX device detected, model %s, revision 0x%02x\n", 547 id->name, rev); 548 549 error = cap11xx_init_keys(priv); 550 if (error) 551 return error; 552 553 priv->idev = devm_input_allocate_device(dev); 554 if (!priv->idev) 555 return -ENOMEM; 556 557 priv->idev->name = "CAP11XX capacitive touch sensor"; 558 priv->idev->id.bustype = BUS_I2C; 559 priv->idev->evbit[0] = BIT_MASK(EV_KEY); 560 561 if (of_property_read_bool(dev->of_node, "autorepeat")) 562 __set_bit(EV_REP, priv->idev->evbit); 563 564 for (i = 0; i < cap->num_channels; i++) 565 __set_bit(priv->keycodes[i], priv->idev->keybit); 566 567 __clear_bit(KEY_RESERVED, priv->idev->keybit); 568 569 priv->idev->keycode = priv->keycodes; 570 priv->idev->keycodesize = sizeof(priv->keycodes[0]); 571 priv->idev->keycodemax = cap->num_channels; 572 573 priv->idev->id.vendor = CAP11XX_MANUFACTURER_ID; 574 priv->idev->id.product = cap->product_id; 575 priv->idev->id.version = rev; 576 577 priv->idev->open = cap11xx_input_open; 578 priv->idev->close = cap11xx_input_close; 579 580 error = cap11xx_init_leds(dev, priv, cap->num_leds); 581 if (error) 582 return error; 583 584 input_set_drvdata(priv->idev, priv); 585 586 /* 587 * Put the device in deep sleep mode for now. 588 * ->open() will bring it back once the it is actually needed. 589 */ 590 cap11xx_set_sleep(priv, true); 591 592 error = input_register_device(priv->idev); 593 if (error) 594 return error; 595 596 error = devm_request_threaded_irq(dev, i2c_client->irq, 597 NULL, cap11xx_thread_func, 598 IRQF_ONESHOT, dev_name(dev), priv); 599 if (error) 600 return error; 601 602 return 0; 603 } 604 605 static const struct cap11xx_hw_model cap1106_model = { 606 .product_id = 0x55, .num_channels = 6, .num_leds = 0, 607 .has_gain = true, 608 .has_irq_config = true, 609 }; 610 611 static const struct cap11xx_hw_model cap1126_model = { 612 .product_id = 0x53, .num_channels = 6, .num_leds = 2, 613 .has_gain = true, 614 .has_irq_config = true, 615 }; 616 617 static const struct cap11xx_hw_model cap1188_model = { 618 .product_id = 0x50, .num_channels = 8, .num_leds = 8, 619 .has_gain = true, 620 .has_irq_config = true, 621 }; 622 623 static const struct cap11xx_hw_model cap1203_model = { 624 .product_id = 0x6d, .num_channels = 3, .num_leds = 0, 625 }; 626 627 static const struct cap11xx_hw_model cap1206_model = { 628 .product_id = 0x67, .num_channels = 6, .num_leds = 0, 629 }; 630 631 static const struct cap11xx_hw_model cap1293_model = { 632 .product_id = 0x6f, .num_channels = 3, .num_leds = 0, 633 .has_gain = true, 634 .has_sensitivity_control = true, 635 .has_signal_guard = true, 636 }; 637 638 static const struct cap11xx_hw_model cap1298_model = { 639 .product_id = 0x71, .num_channels = 8, .num_leds = 0, 640 .has_gain = true, 641 .has_sensitivity_control = true, 642 .has_signal_guard = true, 643 }; 644 645 static const struct of_device_id cap11xx_dt_ids[] = { 646 { .compatible = "microchip,cap1106", .data = &cap1106_model }, 647 { .compatible = "microchip,cap1126", .data = &cap1126_model }, 648 { .compatible = "microchip,cap1188", .data = &cap1188_model }, 649 { .compatible = "microchip,cap1203", .data = &cap1203_model }, 650 { .compatible = "microchip,cap1206", .data = &cap1206_model }, 651 { .compatible = "microchip,cap1293", .data = &cap1293_model }, 652 { .compatible = "microchip,cap1298", .data = &cap1298_model }, 653 { } 654 }; 655 MODULE_DEVICE_TABLE(of, cap11xx_dt_ids); 656 657 static const struct i2c_device_id cap11xx_i2c_ids[] = { 658 { "cap1106", (kernel_ulong_t)&cap1106_model }, 659 { "cap1126", (kernel_ulong_t)&cap1126_model }, 660 { "cap1188", (kernel_ulong_t)&cap1188_model }, 661 { "cap1203", (kernel_ulong_t)&cap1203_model }, 662 { "cap1206", (kernel_ulong_t)&cap1206_model }, 663 { "cap1293", (kernel_ulong_t)&cap1293_model }, 664 { "cap1298", (kernel_ulong_t)&cap1298_model }, 665 { } 666 }; 667 MODULE_DEVICE_TABLE(i2c, cap11xx_i2c_ids); 668 669 static struct i2c_driver cap11xx_i2c_driver = { 670 .driver = { 671 .name = "cap11xx", 672 .of_match_table = cap11xx_dt_ids, 673 }, 674 .id_table = cap11xx_i2c_ids, 675 .probe = cap11xx_i2c_probe, 676 }; 677 678 module_i2c_driver(cap11xx_i2c_driver); 679 680 MODULE_DESCRIPTION("Microchip CAP11XX driver"); 681 MODULE_AUTHOR("Daniel Mack <linux@zonque.org>"); 682 MODULE_LICENSE("GPL v2"); 683