1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2018 Google LLC. 4 * 5 * Driver for Semtech's SX9310/SX9311 capacitive proximity/button solution. 6 * Based on SX9500 driver and Semtech driver using the input framework 7 * <https://my.syncplicity.com/share/teouwsim8niiaud/ 8 * linux-driver-SX9310_NoSmartHSensing>. 9 * Reworked in April 2019 by Evan Green <evgreen@chromium.org> 10 * and in January 2020 by Daniel Campello <campello@chromium.org>. 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/bitfield.h> 15 #include <linux/delay.h> 16 #include <linux/i2c.h> 17 #include <linux/irq.h> 18 #include <linux/kernel.h> 19 #include <linux/log2.h> 20 #include <linux/mod_devicetable.h> 21 #include <linux/module.h> 22 #include <linux/pm.h> 23 #include <linux/regmap.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/slab.h> 26 27 #include <linux/iio/buffer.h> 28 #include <linux/iio/events.h> 29 #include <linux/iio/iio.h> 30 #include <linux/iio/sysfs.h> 31 #include <linux/iio/trigger.h> 32 #include <linux/iio/triggered_buffer.h> 33 #include <linux/iio/trigger_consumer.h> 34 35 /* Register definitions. */ 36 #define SX9310_REG_IRQ_SRC 0x00 37 #define SX9310_REG_STAT0 0x01 38 #define SX9310_REG_STAT1 0x02 39 #define SX9310_REG_STAT1_COMPSTAT_MASK GENMASK(3, 0) 40 #define SX9310_REG_IRQ_MSK 0x03 41 #define SX9310_CONVDONE_IRQ BIT(3) 42 #define SX9310_FAR_IRQ BIT(5) 43 #define SX9310_CLOSE_IRQ BIT(6) 44 #define SX9310_REG_IRQ_FUNC 0x04 45 46 #define SX9310_REG_PROX_CTRL0 0x10 47 #define SX9310_REG_PROX_CTRL0_SENSOREN_MASK GENMASK(3, 0) 48 #define SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK GENMASK(7, 4) 49 #define SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS 0x01 50 #define SX9310_REG_PROX_CTRL1 0x11 51 #define SX9310_REG_PROX_CTRL2 0x12 52 #define SX9310_REG_PROX_CTRL2_COMBMODE_MASK GENMASK(7, 6) 53 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3 (0x03 << 6) 54 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2 (0x02 << 6) 55 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1 (0x01 << 6) 56 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS3 (0x00 << 6) 57 #define SX9310_REG_PROX_CTRL2_SHIELDEN_MASK GENMASK(3, 2) 58 #define SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC (0x01 << 2) 59 #define SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND (0x02 << 2) 60 #define SX9310_REG_PROX_CTRL3 0x13 61 #define SX9310_REG_PROX_CTRL3_GAIN0_MASK GENMASK(3, 2) 62 #define SX9310_REG_PROX_CTRL3_GAIN0_X8 (0x03 << 2) 63 #define SX9310_REG_PROX_CTRL3_GAIN12_MASK GENMASK(1, 0) 64 #define SX9310_REG_PROX_CTRL3_GAIN12_X4 0x02 65 #define SX9310_REG_PROX_CTRL4 0x14 66 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MASK GENMASK(2, 0) 67 #define SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST 0x07 68 #define SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE 0x06 69 #define SX9310_REG_PROX_CTRL4_RESOLUTION_FINE 0x05 70 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM 0x04 71 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE 0x03 72 #define SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE 0x02 73 #define SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE 0x01 74 #define SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST 0x00 75 #define SX9310_REG_PROX_CTRL5 0x15 76 #define SX9310_REG_PROX_CTRL5_RANGE_SMALL (0x03 << 6) 77 #define SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK GENMASK(3, 2) 78 #define SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 (0x01 << 2) 79 #define SX9310_REG_PROX_CTRL5_RAWFILT_MASK GENMASK(1, 0) 80 #define SX9310_REG_PROX_CTRL5_RAWFILT_SHIFT 0 81 #define SX9310_REG_PROX_CTRL5_RAWFILT_1P25 0x02 82 #define SX9310_REG_PROX_CTRL6 0x16 83 #define SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT 0x20 84 #define SX9310_REG_PROX_CTRL7 0x17 85 #define SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 (0x01 << 3) 86 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK GENMASK(2, 0) 87 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_SHIFT 0 88 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_512 0x05 89 #define SX9310_REG_PROX_CTRL8 0x18 90 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK GENMASK(7, 3) 91 #define SX9310_REG_PROX_CTRL9 0x19 92 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_28 (0x08 << 3) 93 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_96 (0x11 << 3) 94 #define SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900 0x03 95 #define SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500 0x05 96 #define SX9310_REG_PROX_CTRL10 0x1a 97 #define SX9310_REG_PROX_CTRL10_HYST_MASK GENMASK(5, 4) 98 #define SX9310_REG_PROX_CTRL10_HYST_6PCT (0x01 << 4) 99 #define SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK GENMASK(3, 2) 100 #define SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK GENMASK(1, 0) 101 #define SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2 0x01 102 #define SX9310_REG_PROX_CTRL11 0x1b 103 #define SX9310_REG_PROX_CTRL12 0x1c 104 #define SX9310_REG_PROX_CTRL13 0x1d 105 #define SX9310_REG_PROX_CTRL14 0x1e 106 #define SX9310_REG_PROX_CTRL15 0x1f 107 #define SX9310_REG_PROX_CTRL16 0x20 108 #define SX9310_REG_PROX_CTRL17 0x21 109 #define SX9310_REG_PROX_CTRL18 0x22 110 #define SX9310_REG_PROX_CTRL19 0x23 111 #define SX9310_REG_SAR_CTRL0 0x2a 112 #define SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES (0x02 << 5) 113 #define SX9310_REG_SAR_CTRL0_SARHYST_8 (0x02 << 3) 114 #define SX9310_REG_SAR_CTRL1 0x2b 115 /* Each increment of the slope register is 0.0078125. */ 116 #define SX9310_REG_SAR_CTRL1_SLOPE(_hnslope) (_hnslope / 78125) 117 #define SX9310_REG_SAR_CTRL2 0x2c 118 #define SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT 0x3c 119 120 #define SX9310_REG_SENSOR_SEL 0x30 121 #define SX9310_REG_USE_MSB 0x31 122 #define SX9310_REG_USE_LSB 0x32 123 #define SX9310_REG_AVG_MSB 0x33 124 #define SX9310_REG_AVG_LSB 0x34 125 #define SX9310_REG_DIFF_MSB 0x35 126 #define SX9310_REG_DIFF_LSB 0x36 127 #define SX9310_REG_OFFSET_MSB 0x37 128 #define SX9310_REG_OFFSET_LSB 0x38 129 #define SX9310_REG_SAR_MSB 0x39 130 #define SX9310_REG_SAR_LSB 0x3a 131 #define SX9310_REG_I2C_ADDR 0x40 132 #define SX9310_REG_PAUSE 0x41 133 #define SX9310_REG_WHOAMI 0x42 134 #define SX9310_WHOAMI_VALUE 0x01 135 #define SX9311_WHOAMI_VALUE 0x02 136 #define SX9310_REG_RESET 0x7f 137 #define SX9310_SOFT_RESET 0xde 138 139 140 /* 4 hardware channels, as defined in STAT0: COMB, CS2, CS1 and CS0. */ 141 #define SX9310_NUM_CHANNELS 4 142 static_assert(SX9310_NUM_CHANNELS < BITS_PER_LONG); 143 144 struct sx9310_data { 145 /* Serialize access to registers and channel configuration */ 146 struct mutex mutex; 147 struct i2c_client *client; 148 struct iio_trigger *trig; 149 struct regmap *regmap; 150 struct regulator_bulk_data supplies[2]; 151 /* 152 * Last reading of the proximity status for each channel. 153 * We only send an event to user space when this changes. 154 */ 155 unsigned long chan_prox_stat; 156 bool trigger_enabled; 157 /* Ensure correct alignment of timestamp when present. */ 158 struct { 159 __be16 channels[SX9310_NUM_CHANNELS]; 160 s64 ts __aligned(8); 161 } buffer; 162 /* Remember enabled channels and sample rate during suspend. */ 163 unsigned int suspend_ctrl0; 164 struct completion completion; 165 unsigned long chan_read; 166 unsigned long chan_event; 167 unsigned int whoami; 168 }; 169 170 static const struct iio_event_spec sx9310_events[] = { 171 { 172 .type = IIO_EV_TYPE_THRESH, 173 .dir = IIO_EV_DIR_RISING, 174 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD), 175 }, 176 { 177 .type = IIO_EV_TYPE_THRESH, 178 .dir = IIO_EV_DIR_FALLING, 179 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD), 180 }, 181 { 182 .type = IIO_EV_TYPE_THRESH, 183 .dir = IIO_EV_DIR_EITHER, 184 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | 185 BIT(IIO_EV_INFO_HYSTERESIS) | 186 BIT(IIO_EV_INFO_VALUE), 187 }, 188 }; 189 190 #define SX9310_NAMED_CHANNEL(idx, name) \ 191 { \ 192 .type = IIO_PROXIMITY, \ 193 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 194 BIT(IIO_CHAN_INFO_HARDWAREGAIN), \ 195 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 196 .info_mask_separate_available = \ 197 BIT(IIO_CHAN_INFO_HARDWAREGAIN), \ 198 .indexed = 1, \ 199 .channel = idx, \ 200 .extend_name = name, \ 201 .address = SX9310_REG_DIFF_MSB, \ 202 .event_spec = sx9310_events, \ 203 .num_event_specs = ARRAY_SIZE(sx9310_events), \ 204 .scan_index = idx, \ 205 .scan_type = { \ 206 .sign = 's', \ 207 .realbits = 12, \ 208 .storagebits = 16, \ 209 .endianness = IIO_BE, \ 210 }, \ 211 } 212 #define SX9310_CHANNEL(idx) SX9310_NAMED_CHANNEL(idx, NULL) 213 214 static const struct iio_chan_spec sx9310_channels[] = { 215 SX9310_CHANNEL(0), /* CS0 */ 216 SX9310_CHANNEL(1), /* CS1 */ 217 SX9310_CHANNEL(2), /* CS2 */ 218 SX9310_NAMED_CHANNEL(3, "comb"), /* COMB */ 219 220 IIO_CHAN_SOFT_TIMESTAMP(4), 221 }; 222 223 /* 224 * Each entry contains the integer part (val) and the fractional part, in micro 225 * seconds. It conforms to the IIO output IIO_VAL_INT_PLUS_MICRO. 226 */ 227 static const struct { 228 int val; 229 int val2; 230 } sx9310_samp_freq_table[] = { 231 { 500, 0 }, /* 0000: Min (no idle time) */ 232 { 66, 666666 }, /* 0001: 15 ms */ 233 { 33, 333333 }, /* 0010: 30 ms (Typ.) */ 234 { 22, 222222 }, /* 0011: 45 ms */ 235 { 16, 666666 }, /* 0100: 60 ms */ 236 { 11, 111111 }, /* 0101: 90 ms */ 237 { 8, 333333 }, /* 0110: 120 ms */ 238 { 5, 0 }, /* 0111: 200 ms */ 239 { 2, 500000 }, /* 1000: 400 ms */ 240 { 1, 666666 }, /* 1001: 600 ms */ 241 { 1, 250000 }, /* 1010: 800 ms */ 242 { 1, 0 }, /* 1011: 1 s */ 243 { 0, 500000 }, /* 1100: 2 s */ 244 { 0, 333333 }, /* 1101: 3 s */ 245 { 0, 250000 }, /* 1110: 4 s */ 246 { 0, 200000 }, /* 1111: 5 s */ 247 }; 248 static const unsigned int sx9310_scan_period_table[] = { 249 2, 15, 30, 45, 60, 90, 120, 200, 250 400, 600, 800, 1000, 2000, 3000, 4000, 5000, 251 }; 252 253 static ssize_t sx9310_show_samp_freq_avail(struct device *dev, 254 struct device_attribute *attr, 255 char *buf) 256 { 257 size_t len = 0; 258 int i; 259 260 for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++) 261 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%d ", 262 sx9310_samp_freq_table[i].val, 263 sx9310_samp_freq_table[i].val2); 264 buf[len - 1] = '\n'; 265 return len; 266 } 267 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sx9310_show_samp_freq_avail); 268 269 static const struct regmap_range sx9310_writable_reg_ranges[] = { 270 regmap_reg_range(SX9310_REG_IRQ_MSK, SX9310_REG_IRQ_FUNC), 271 regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19), 272 regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2), 273 regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SENSOR_SEL), 274 regmap_reg_range(SX9310_REG_OFFSET_MSB, SX9310_REG_OFFSET_LSB), 275 regmap_reg_range(SX9310_REG_PAUSE, SX9310_REG_PAUSE), 276 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET), 277 }; 278 279 static const struct regmap_access_table sx9310_writeable_regs = { 280 .yes_ranges = sx9310_writable_reg_ranges, 281 .n_yes_ranges = ARRAY_SIZE(sx9310_writable_reg_ranges), 282 }; 283 284 static const struct regmap_range sx9310_readable_reg_ranges[] = { 285 regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_IRQ_FUNC), 286 regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19), 287 regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2), 288 regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SAR_LSB), 289 regmap_reg_range(SX9310_REG_I2C_ADDR, SX9310_REG_WHOAMI), 290 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET), 291 }; 292 293 static const struct regmap_access_table sx9310_readable_regs = { 294 .yes_ranges = sx9310_readable_reg_ranges, 295 .n_yes_ranges = ARRAY_SIZE(sx9310_readable_reg_ranges), 296 }; 297 298 static const struct regmap_range sx9310_volatile_reg_ranges[] = { 299 regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_STAT1), 300 regmap_reg_range(SX9310_REG_USE_MSB, SX9310_REG_DIFF_LSB), 301 regmap_reg_range(SX9310_REG_SAR_MSB, SX9310_REG_SAR_LSB), 302 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET), 303 }; 304 305 static const struct regmap_access_table sx9310_volatile_regs = { 306 .yes_ranges = sx9310_volatile_reg_ranges, 307 .n_yes_ranges = ARRAY_SIZE(sx9310_volatile_reg_ranges), 308 }; 309 310 static const struct regmap_config sx9310_regmap_config = { 311 .reg_bits = 8, 312 .val_bits = 8, 313 314 .max_register = SX9310_REG_RESET, 315 .cache_type = REGCACHE_RBTREE, 316 317 .wr_table = &sx9310_writeable_regs, 318 .rd_table = &sx9310_readable_regs, 319 .volatile_table = &sx9310_volatile_regs, 320 }; 321 322 static int sx9310_update_chan_en(struct sx9310_data *data, 323 unsigned long chan_read, 324 unsigned long chan_event) 325 { 326 int ret; 327 unsigned long channels = chan_read | chan_event; 328 329 if ((data->chan_read | data->chan_event) != channels) { 330 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL0, 331 SX9310_REG_PROX_CTRL0_SENSOREN_MASK, 332 channels); 333 if (ret) 334 return ret; 335 } 336 data->chan_read = chan_read; 337 data->chan_event = chan_event; 338 return 0; 339 } 340 341 static int sx9310_get_read_channel(struct sx9310_data *data, int channel) 342 { 343 return sx9310_update_chan_en(data, data->chan_read | BIT(channel), 344 data->chan_event); 345 } 346 347 static int sx9310_put_read_channel(struct sx9310_data *data, int channel) 348 { 349 return sx9310_update_chan_en(data, data->chan_read & ~BIT(channel), 350 data->chan_event); 351 } 352 353 static int sx9310_get_event_channel(struct sx9310_data *data, int channel) 354 { 355 return sx9310_update_chan_en(data, data->chan_read, 356 data->chan_event | BIT(channel)); 357 } 358 359 static int sx9310_put_event_channel(struct sx9310_data *data, int channel) 360 { 361 return sx9310_update_chan_en(data, data->chan_read, 362 data->chan_event & ~BIT(channel)); 363 } 364 365 static int sx9310_enable_irq(struct sx9310_data *data, unsigned int irq) 366 { 367 if (!data->client->irq) 368 return 0; 369 return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, irq); 370 } 371 372 static int sx9310_disable_irq(struct sx9310_data *data, unsigned int irq) 373 { 374 if (!data->client->irq) 375 return 0; 376 return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, 0); 377 } 378 379 static int sx9310_read_prox_data(struct sx9310_data *data, 380 const struct iio_chan_spec *chan, __be16 *val) 381 { 382 int ret; 383 384 ret = regmap_write(data->regmap, SX9310_REG_SENSOR_SEL, chan->channel); 385 if (ret) 386 return ret; 387 388 return regmap_bulk_read(data->regmap, chan->address, val, sizeof(*val)); 389 } 390 391 /* 392 * If we have no interrupt support, we have to wait for a scan period 393 * after enabling a channel to get a result. 394 */ 395 static int sx9310_wait_for_sample(struct sx9310_data *data) 396 { 397 int ret; 398 unsigned int val; 399 400 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &val); 401 if (ret) 402 return ret; 403 404 val = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, val); 405 406 msleep(sx9310_scan_period_table[val]); 407 408 return 0; 409 } 410 411 static int sx9310_read_proximity(struct sx9310_data *data, 412 const struct iio_chan_spec *chan, int *val) 413 { 414 int ret; 415 __be16 rawval; 416 417 mutex_lock(&data->mutex); 418 419 ret = sx9310_get_read_channel(data, chan->channel); 420 if (ret) 421 goto out; 422 423 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ); 424 if (ret) 425 goto out_put_channel; 426 427 mutex_unlock(&data->mutex); 428 429 if (data->client->irq) { 430 ret = wait_for_completion_interruptible(&data->completion); 431 reinit_completion(&data->completion); 432 } else { 433 ret = sx9310_wait_for_sample(data); 434 } 435 436 mutex_lock(&data->mutex); 437 438 if (ret) 439 goto out_disable_irq; 440 441 ret = sx9310_read_prox_data(data, chan, &rawval); 442 if (ret) 443 goto out_disable_irq; 444 445 *val = sign_extend32(be16_to_cpu(rawval), 446 chan->address == SX9310_REG_DIFF_MSB ? 11 : 15); 447 448 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ); 449 if (ret) 450 goto out_put_channel; 451 452 ret = sx9310_put_read_channel(data, chan->channel); 453 if (ret) 454 goto out; 455 456 mutex_unlock(&data->mutex); 457 458 return IIO_VAL_INT; 459 460 out_disable_irq: 461 sx9310_disable_irq(data, SX9310_CONVDONE_IRQ); 462 out_put_channel: 463 sx9310_put_read_channel(data, chan->channel); 464 out: 465 mutex_unlock(&data->mutex); 466 467 return ret; 468 } 469 470 static int sx9310_read_gain(struct sx9310_data *data, 471 const struct iio_chan_spec *chan, int *val) 472 { 473 unsigned int regval, gain; 474 int ret; 475 476 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL3, ®val); 477 if (ret) 478 return ret; 479 480 switch (chan->channel) { 481 case 0: 482 case 3: 483 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN0_MASK, regval); 484 break; 485 case 1: 486 case 2: 487 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN12_MASK, regval); 488 break; 489 default: 490 return -EINVAL; 491 } 492 493 *val = 1 << gain; 494 495 return IIO_VAL_INT; 496 } 497 498 static int sx9310_read_samp_freq(struct sx9310_data *data, int *val, int *val2) 499 { 500 unsigned int regval; 501 int ret; 502 503 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, ®val); 504 if (ret) 505 return ret; 506 507 regval = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, regval); 508 *val = sx9310_samp_freq_table[regval].val; 509 *val2 = sx9310_samp_freq_table[regval].val2; 510 511 return IIO_VAL_INT_PLUS_MICRO; 512 } 513 514 static int sx9310_read_raw(struct iio_dev *indio_dev, 515 const struct iio_chan_spec *chan, int *val, 516 int *val2, long mask) 517 { 518 struct sx9310_data *data = iio_priv(indio_dev); 519 int ret; 520 521 if (chan->type != IIO_PROXIMITY) 522 return -EINVAL; 523 524 switch (mask) { 525 case IIO_CHAN_INFO_RAW: 526 ret = iio_device_claim_direct_mode(indio_dev); 527 if (ret) 528 return ret; 529 530 ret = sx9310_read_proximity(data, chan, val); 531 iio_device_release_direct_mode(indio_dev); 532 return ret; 533 case IIO_CHAN_INFO_HARDWAREGAIN: 534 ret = iio_device_claim_direct_mode(indio_dev); 535 if (ret) 536 return ret; 537 538 ret = sx9310_read_gain(data, chan, val); 539 iio_device_release_direct_mode(indio_dev); 540 return ret; 541 case IIO_CHAN_INFO_SAMP_FREQ: 542 return sx9310_read_samp_freq(data, val, val2); 543 default: 544 return -EINVAL; 545 } 546 } 547 548 static const int sx9310_gain_vals[] = { 1, 2, 4, 8 }; 549 550 static int sx9310_read_avail(struct iio_dev *indio_dev, 551 struct iio_chan_spec const *chan, 552 const int **vals, int *type, int *length, 553 long mask) 554 { 555 if (chan->type != IIO_PROXIMITY) 556 return -EINVAL; 557 558 switch (mask) { 559 case IIO_CHAN_INFO_HARDWAREGAIN: 560 *type = IIO_VAL_INT; 561 *length = ARRAY_SIZE(sx9310_gain_vals); 562 *vals = sx9310_gain_vals; 563 return IIO_AVAIL_LIST; 564 } 565 566 return -EINVAL; 567 } 568 569 static const unsigned int sx9310_pthresh_codes[] = { 570 2, 4, 6, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112, 571 128, 144, 160, 192, 224, 256, 320, 384, 512, 640, 768, 1024, 1536 572 }; 573 574 static int sx9310_get_thresh_reg(unsigned int channel) 575 { 576 switch (channel) { 577 case 0: 578 case 3: 579 return SX9310_REG_PROX_CTRL8; 580 case 1: 581 case 2: 582 return SX9310_REG_PROX_CTRL9; 583 } 584 585 return -EINVAL; 586 } 587 588 static int sx9310_read_thresh(struct sx9310_data *data, 589 const struct iio_chan_spec *chan, int *val) 590 { 591 unsigned int reg; 592 unsigned int regval; 593 int ret; 594 595 reg = ret = sx9310_get_thresh_reg(chan->channel); 596 if (ret < 0) 597 return ret; 598 599 ret = regmap_read(data->regmap, reg, ®val); 600 if (ret) 601 return ret; 602 603 regval = FIELD_GET(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval); 604 if (regval > ARRAY_SIZE(sx9310_pthresh_codes)) 605 return -EINVAL; 606 607 *val = sx9310_pthresh_codes[regval]; 608 return IIO_VAL_INT; 609 } 610 611 static int sx9310_read_hysteresis(struct sx9310_data *data, 612 const struct iio_chan_spec *chan, int *val) 613 { 614 unsigned int regval, pthresh; 615 int ret; 616 617 ret = sx9310_read_thresh(data, chan, &pthresh); 618 if (ret < 0) 619 return ret; 620 621 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val); 622 if (ret) 623 return ret; 624 625 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_HYST_MASK, regval); 626 if (!regval) 627 regval = 5; 628 629 /* regval is at most 5 */ 630 *val = pthresh >> (5 - regval); 631 632 return IIO_VAL_INT; 633 } 634 635 static int sx9310_read_far_debounce(struct sx9310_data *data, int *val) 636 { 637 unsigned int regval; 638 int ret; 639 640 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val); 641 if (ret) 642 return ret; 643 644 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, regval); 645 if (regval) 646 *val = 1 << regval; 647 else 648 *val = 0; 649 650 return IIO_VAL_INT; 651 } 652 653 static int sx9310_read_close_debounce(struct sx9310_data *data, int *val) 654 { 655 unsigned int regval; 656 int ret; 657 658 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val); 659 if (ret) 660 return ret; 661 662 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, regval); 663 if (regval) 664 *val = 1 << regval; 665 else 666 *val = 0; 667 668 return IIO_VAL_INT; 669 } 670 671 static int sx9310_read_event_val(struct iio_dev *indio_dev, 672 const struct iio_chan_spec *chan, 673 enum iio_event_type type, 674 enum iio_event_direction dir, 675 enum iio_event_info info, int *val, int *val2) 676 { 677 struct sx9310_data *data = iio_priv(indio_dev); 678 679 if (chan->type != IIO_PROXIMITY) 680 return -EINVAL; 681 682 switch (info) { 683 case IIO_EV_INFO_VALUE: 684 return sx9310_read_thresh(data, chan, val); 685 case IIO_EV_INFO_PERIOD: 686 switch (dir) { 687 case IIO_EV_DIR_RISING: 688 return sx9310_read_far_debounce(data, val); 689 case IIO_EV_DIR_FALLING: 690 return sx9310_read_close_debounce(data, val); 691 default: 692 return -EINVAL; 693 } 694 case IIO_EV_INFO_HYSTERESIS: 695 return sx9310_read_hysteresis(data, chan, val); 696 default: 697 return -EINVAL; 698 } 699 } 700 701 static int sx9310_write_thresh(struct sx9310_data *data, 702 const struct iio_chan_spec *chan, int val) 703 { 704 unsigned int reg; 705 unsigned int regval; 706 int ret, i; 707 708 reg = ret = sx9310_get_thresh_reg(chan->channel); 709 if (ret < 0) 710 return ret; 711 712 for (i = 0; i < ARRAY_SIZE(sx9310_pthresh_codes); i++) { 713 if (sx9310_pthresh_codes[i] == val) { 714 regval = i; 715 break; 716 } 717 } 718 719 if (i == ARRAY_SIZE(sx9310_pthresh_codes)) 720 return -EINVAL; 721 722 regval = FIELD_PREP(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval); 723 mutex_lock(&data->mutex); 724 ret = regmap_update_bits(data->regmap, reg, 725 SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval); 726 mutex_unlock(&data->mutex); 727 728 return ret; 729 } 730 731 static int sx9310_write_hysteresis(struct sx9310_data *data, 732 const struct iio_chan_spec *chan, int _val) 733 { 734 unsigned int hyst, val = _val; 735 int ret, pthresh; 736 737 ret = sx9310_read_thresh(data, chan, &pthresh); 738 if (ret < 0) 739 return ret; 740 741 if (val == 0) 742 hyst = 0; 743 else if (val == pthresh >> 2) 744 hyst = 3; 745 else if (val == pthresh >> 3) 746 hyst = 2; 747 else if (val == pthresh >> 4) 748 hyst = 1; 749 else 750 return -EINVAL; 751 752 hyst = FIELD_PREP(SX9310_REG_PROX_CTRL10_HYST_MASK, hyst); 753 mutex_lock(&data->mutex); 754 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10, 755 SX9310_REG_PROX_CTRL10_HYST_MASK, hyst); 756 mutex_unlock(&data->mutex); 757 758 return ret; 759 } 760 761 static int sx9310_write_far_debounce(struct sx9310_data *data, int val) 762 { 763 int ret; 764 unsigned int regval; 765 766 val = ilog2(val); 767 regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, val); 768 769 mutex_lock(&data->mutex); 770 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10, 771 SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, 772 regval); 773 mutex_unlock(&data->mutex); 774 775 return ret; 776 } 777 778 static int sx9310_write_close_debounce(struct sx9310_data *data, int val) 779 { 780 int ret; 781 unsigned int regval; 782 783 val = ilog2(val); 784 regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, val); 785 786 mutex_lock(&data->mutex); 787 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10, 788 SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, 789 regval); 790 mutex_unlock(&data->mutex); 791 792 return ret; 793 } 794 795 static int sx9310_write_event_val(struct iio_dev *indio_dev, 796 const struct iio_chan_spec *chan, 797 enum iio_event_type type, 798 enum iio_event_direction dir, 799 enum iio_event_info info, int val, int val2) 800 { 801 struct sx9310_data *data = iio_priv(indio_dev); 802 803 if (chan->type != IIO_PROXIMITY) 804 return -EINVAL; 805 806 switch (info) { 807 case IIO_EV_INFO_VALUE: 808 return sx9310_write_thresh(data, chan, val); 809 case IIO_EV_INFO_PERIOD: 810 switch (dir) { 811 case IIO_EV_DIR_RISING: 812 return sx9310_write_far_debounce(data, val); 813 case IIO_EV_DIR_FALLING: 814 return sx9310_write_close_debounce(data, val); 815 default: 816 return -EINVAL; 817 } 818 case IIO_EV_INFO_HYSTERESIS: 819 return sx9310_write_hysteresis(data, chan, val); 820 default: 821 return -EINVAL; 822 } 823 } 824 825 static int sx9310_set_samp_freq(struct sx9310_data *data, int val, int val2) 826 { 827 int i, ret; 828 829 for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++) 830 if (val == sx9310_samp_freq_table[i].val && 831 val2 == sx9310_samp_freq_table[i].val2) 832 break; 833 834 if (i == ARRAY_SIZE(sx9310_samp_freq_table)) 835 return -EINVAL; 836 837 mutex_lock(&data->mutex); 838 839 ret = regmap_update_bits( 840 data->regmap, SX9310_REG_PROX_CTRL0, 841 SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, 842 FIELD_PREP(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, i)); 843 844 mutex_unlock(&data->mutex); 845 846 return ret; 847 } 848 849 static int sx9310_write_gain(struct sx9310_data *data, 850 const struct iio_chan_spec *chan, int val) 851 { 852 unsigned int gain, mask; 853 int ret; 854 855 gain = ilog2(val); 856 857 switch (chan->channel) { 858 case 0: 859 case 3: 860 mask = SX9310_REG_PROX_CTRL3_GAIN0_MASK; 861 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN0_MASK, gain); 862 break; 863 case 1: 864 case 2: 865 mask = SX9310_REG_PROX_CTRL3_GAIN12_MASK; 866 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN12_MASK, gain); 867 break; 868 default: 869 return -EINVAL; 870 } 871 872 mutex_lock(&data->mutex); 873 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL3, mask, 874 gain); 875 mutex_unlock(&data->mutex); 876 877 return ret; 878 } 879 880 static int sx9310_write_raw(struct iio_dev *indio_dev, 881 const struct iio_chan_spec *chan, int val, int val2, 882 long mask) 883 { 884 struct sx9310_data *data = iio_priv(indio_dev); 885 886 if (chan->type != IIO_PROXIMITY) 887 return -EINVAL; 888 889 switch (mask) { 890 case IIO_CHAN_INFO_SAMP_FREQ: 891 return sx9310_set_samp_freq(data, val, val2); 892 case IIO_CHAN_INFO_HARDWAREGAIN: 893 return sx9310_write_gain(data, chan, val); 894 } 895 896 return -EINVAL; 897 } 898 899 static irqreturn_t sx9310_irq_handler(int irq, void *private) 900 { 901 struct iio_dev *indio_dev = private; 902 struct sx9310_data *data = iio_priv(indio_dev); 903 904 if (data->trigger_enabled) 905 iio_trigger_poll(data->trig); 906 907 /* 908 * Even if no event is enabled, we need to wake the thread to clear the 909 * interrupt state by reading SX9310_REG_IRQ_SRC. 910 * It is not possible to do that here because regmap_read takes a mutex. 911 */ 912 return IRQ_WAKE_THREAD; 913 } 914 915 static void sx9310_push_events(struct iio_dev *indio_dev) 916 { 917 int ret; 918 unsigned int val, chan; 919 struct sx9310_data *data = iio_priv(indio_dev); 920 s64 timestamp = iio_get_time_ns(indio_dev); 921 unsigned long prox_changed; 922 923 /* Read proximity state on all channels */ 924 ret = regmap_read(data->regmap, SX9310_REG_STAT0, &val); 925 if (ret) { 926 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 927 return; 928 } 929 930 /* 931 * Only iterate over channels with changes on proximity status that have 932 * events enabled. 933 */ 934 prox_changed = (data->chan_prox_stat ^ val) & data->chan_event; 935 936 for_each_set_bit(chan, &prox_changed, SX9310_NUM_CHANNELS) { 937 int dir; 938 u64 ev; 939 940 dir = (val & BIT(chan)) ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING; 941 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan, 942 IIO_EV_TYPE_THRESH, dir); 943 944 iio_push_event(indio_dev, ev, timestamp); 945 } 946 data->chan_prox_stat = val; 947 } 948 949 static irqreturn_t sx9310_irq_thread_handler(int irq, void *private) 950 { 951 struct iio_dev *indio_dev = private; 952 struct sx9310_data *data = iio_priv(indio_dev); 953 int ret; 954 unsigned int val; 955 956 mutex_lock(&data->mutex); 957 958 ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val); 959 if (ret) { 960 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 961 goto out; 962 } 963 964 if (val & (SX9310_FAR_IRQ | SX9310_CLOSE_IRQ)) 965 sx9310_push_events(indio_dev); 966 967 if (val & SX9310_CONVDONE_IRQ) 968 complete(&data->completion); 969 970 out: 971 mutex_unlock(&data->mutex); 972 973 return IRQ_HANDLED; 974 } 975 976 static int sx9310_read_event_config(struct iio_dev *indio_dev, 977 const struct iio_chan_spec *chan, 978 enum iio_event_type type, 979 enum iio_event_direction dir) 980 { 981 struct sx9310_data *data = iio_priv(indio_dev); 982 983 return !!(data->chan_event & BIT(chan->channel)); 984 } 985 986 static int sx9310_write_event_config(struct iio_dev *indio_dev, 987 const struct iio_chan_spec *chan, 988 enum iio_event_type type, 989 enum iio_event_direction dir, int state) 990 { 991 struct sx9310_data *data = iio_priv(indio_dev); 992 unsigned int eventirq = SX9310_FAR_IRQ | SX9310_CLOSE_IRQ; 993 int ret; 994 995 /* If the state hasn't changed, there's nothing to do. */ 996 if (!!(data->chan_event & BIT(chan->channel)) == state) 997 return 0; 998 999 mutex_lock(&data->mutex); 1000 if (state) { 1001 ret = sx9310_get_event_channel(data, chan->channel); 1002 if (ret) 1003 goto out_unlock; 1004 if (!(data->chan_event & ~BIT(chan->channel))) { 1005 ret = sx9310_enable_irq(data, eventirq); 1006 if (ret) 1007 sx9310_put_event_channel(data, chan->channel); 1008 } 1009 } else { 1010 ret = sx9310_put_event_channel(data, chan->channel); 1011 if (ret) 1012 goto out_unlock; 1013 if (!data->chan_event) { 1014 ret = sx9310_disable_irq(data, eventirq); 1015 if (ret) 1016 sx9310_get_event_channel(data, chan->channel); 1017 } 1018 } 1019 1020 out_unlock: 1021 mutex_unlock(&data->mutex); 1022 return ret; 1023 } 1024 1025 static struct attribute *sx9310_attributes[] = { 1026 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 1027 NULL 1028 }; 1029 1030 static const struct attribute_group sx9310_attribute_group = { 1031 .attrs = sx9310_attributes, 1032 }; 1033 1034 static const struct iio_info sx9310_info = { 1035 .attrs = &sx9310_attribute_group, 1036 .read_raw = sx9310_read_raw, 1037 .read_avail = sx9310_read_avail, 1038 .read_event_value = sx9310_read_event_val, 1039 .write_event_value = sx9310_write_event_val, 1040 .write_raw = sx9310_write_raw, 1041 .read_event_config = sx9310_read_event_config, 1042 .write_event_config = sx9310_write_event_config, 1043 }; 1044 1045 static int sx9310_set_trigger_state(struct iio_trigger *trig, bool state) 1046 { 1047 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1048 struct sx9310_data *data = iio_priv(indio_dev); 1049 int ret = 0; 1050 1051 mutex_lock(&data->mutex); 1052 1053 if (state) 1054 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ); 1055 else if (!data->chan_read) 1056 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ); 1057 if (ret) 1058 goto out; 1059 1060 data->trigger_enabled = state; 1061 1062 out: 1063 mutex_unlock(&data->mutex); 1064 1065 return ret; 1066 } 1067 1068 static const struct iio_trigger_ops sx9310_trigger_ops = { 1069 .set_trigger_state = sx9310_set_trigger_state, 1070 }; 1071 1072 static irqreturn_t sx9310_trigger_handler(int irq, void *private) 1073 { 1074 struct iio_poll_func *pf = private; 1075 struct iio_dev *indio_dev = pf->indio_dev; 1076 struct sx9310_data *data = iio_priv(indio_dev); 1077 __be16 val; 1078 int bit, ret, i = 0; 1079 1080 mutex_lock(&data->mutex); 1081 1082 for_each_set_bit(bit, indio_dev->active_scan_mask, 1083 indio_dev->masklength) { 1084 ret = sx9310_read_prox_data(data, &indio_dev->channels[bit], 1085 &val); 1086 if (ret) 1087 goto out; 1088 1089 data->buffer.channels[i++] = val; 1090 } 1091 1092 iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer, 1093 pf->timestamp); 1094 1095 out: 1096 mutex_unlock(&data->mutex); 1097 1098 iio_trigger_notify_done(indio_dev->trig); 1099 1100 return IRQ_HANDLED; 1101 } 1102 1103 static int sx9310_buffer_preenable(struct iio_dev *indio_dev) 1104 { 1105 struct sx9310_data *data = iio_priv(indio_dev); 1106 unsigned long channels = 0; 1107 int bit, ret; 1108 1109 mutex_lock(&data->mutex); 1110 for_each_set_bit(bit, indio_dev->active_scan_mask, 1111 indio_dev->masklength) 1112 __set_bit(indio_dev->channels[bit].channel, &channels); 1113 1114 ret = sx9310_update_chan_en(data, channels, data->chan_event); 1115 mutex_unlock(&data->mutex); 1116 return ret; 1117 } 1118 1119 static int sx9310_buffer_postdisable(struct iio_dev *indio_dev) 1120 { 1121 struct sx9310_data *data = iio_priv(indio_dev); 1122 int ret; 1123 1124 mutex_lock(&data->mutex); 1125 ret = sx9310_update_chan_en(data, 0, data->chan_event); 1126 mutex_unlock(&data->mutex); 1127 return ret; 1128 } 1129 1130 static const struct iio_buffer_setup_ops sx9310_buffer_setup_ops = { 1131 .preenable = sx9310_buffer_preenable, 1132 .postdisable = sx9310_buffer_postdisable, 1133 }; 1134 1135 struct sx9310_reg_default { 1136 u8 reg; 1137 u8 def; 1138 }; 1139 1140 static const struct sx9310_reg_default sx9310_default_regs[] = { 1141 { SX9310_REG_IRQ_MSK, 0x00 }, 1142 { SX9310_REG_IRQ_FUNC, 0x00 }, 1143 /* 1144 * The lower 4 bits should not be set as it enable sensors measurements. 1145 * Turning the detection on before the configuration values are set to 1146 * good values can cause the device to return erroneous readings. 1147 */ 1148 { SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS }, 1149 { SX9310_REG_PROX_CTRL1, 0x00 }, 1150 { SX9310_REG_PROX_CTRL2, SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2 | 1151 SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC }, 1152 { SX9310_REG_PROX_CTRL3, SX9310_REG_PROX_CTRL3_GAIN0_X8 | 1153 SX9310_REG_PROX_CTRL3_GAIN12_X4 }, 1154 { SX9310_REG_PROX_CTRL4, SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST }, 1155 { SX9310_REG_PROX_CTRL5, SX9310_REG_PROX_CTRL5_RANGE_SMALL | 1156 SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 | 1157 SX9310_REG_PROX_CTRL5_RAWFILT_1P25 }, 1158 { SX9310_REG_PROX_CTRL6, SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT }, 1159 { SX9310_REG_PROX_CTRL7, SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 | 1160 SX9310_REG_PROX_CTRL7_AVGPOSFILT_512 }, 1161 { SX9310_REG_PROX_CTRL8, SX9310_REG_PROX_CTRL8_9_PTHRESH_96 | 1162 SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500 }, 1163 { SX9310_REG_PROX_CTRL9, SX9310_REG_PROX_CTRL8_9_PTHRESH_28 | 1164 SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900 }, 1165 { SX9310_REG_PROX_CTRL10, SX9310_REG_PROX_CTRL10_HYST_6PCT | 1166 SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2 }, 1167 { SX9310_REG_PROX_CTRL11, 0x00 }, 1168 { SX9310_REG_PROX_CTRL12, 0x00 }, 1169 { SX9310_REG_PROX_CTRL13, 0x00 }, 1170 { SX9310_REG_PROX_CTRL14, 0x00 }, 1171 { SX9310_REG_PROX_CTRL15, 0x00 }, 1172 { SX9310_REG_PROX_CTRL16, 0x00 }, 1173 { SX9310_REG_PROX_CTRL17, 0x00 }, 1174 { SX9310_REG_PROX_CTRL18, 0x00 }, 1175 { SX9310_REG_PROX_CTRL19, 0x00 }, 1176 { SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES | 1177 SX9310_REG_SAR_CTRL0_SARHYST_8 }, 1178 { SX9310_REG_SAR_CTRL1, SX9310_REG_SAR_CTRL1_SLOPE(10781250) }, 1179 { SX9310_REG_SAR_CTRL2, SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT }, 1180 }; 1181 1182 /* Activate all channels and perform an initial compensation. */ 1183 static int sx9310_init_compensation(struct iio_dev *indio_dev) 1184 { 1185 struct sx9310_data *data = iio_priv(indio_dev); 1186 int ret; 1187 unsigned int val; 1188 unsigned int ctrl0; 1189 1190 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &ctrl0); 1191 if (ret) 1192 return ret; 1193 1194 /* run the compensation phase on all channels */ 1195 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, 1196 ctrl0 | SX9310_REG_PROX_CTRL0_SENSOREN_MASK); 1197 if (ret) 1198 return ret; 1199 1200 ret = regmap_read_poll_timeout(data->regmap, SX9310_REG_STAT1, val, 1201 !(val & SX9310_REG_STAT1_COMPSTAT_MASK), 1202 20000, 2000000); 1203 if (ret) { 1204 if (ret == -ETIMEDOUT) 1205 dev_err(&data->client->dev, 1206 "initial compensation timed out: 0x%02x\n", 1207 val); 1208 return ret; 1209 } 1210 1211 regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0); 1212 return ret; 1213 } 1214 1215 static const struct sx9310_reg_default * 1216 sx9310_get_default_reg(struct sx9310_data *data, int i, 1217 struct sx9310_reg_default *reg_def) 1218 { 1219 int ret; 1220 const struct device_node *np = data->client->dev.of_node; 1221 u32 combined[SX9310_NUM_CHANNELS] = { 4, 4, 4, 4 }; 1222 unsigned long comb_mask = 0; 1223 const char *res; 1224 u32 start = 0, raw = 0, pos = 0; 1225 1226 memcpy(reg_def, &sx9310_default_regs[i], sizeof(*reg_def)); 1227 if (!np) 1228 return reg_def; 1229 1230 switch (reg_def->reg) { 1231 case SX9310_REG_PROX_CTRL2: 1232 if (of_property_read_bool(np, "semtech,cs0-ground")) { 1233 reg_def->def &= ~SX9310_REG_PROX_CTRL2_SHIELDEN_MASK; 1234 reg_def->def |= SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND; 1235 } 1236 1237 reg_def->def &= ~SX9310_REG_PROX_CTRL2_COMBMODE_MASK; 1238 of_property_read_u32_array(np, "semtech,combined-sensors", 1239 combined, ARRAY_SIZE(combined)); 1240 for (i = 0; i < ARRAY_SIZE(combined); i++) { 1241 if (combined[i] <= SX9310_NUM_CHANNELS) 1242 comb_mask |= BIT(combined[i]); 1243 } 1244 1245 comb_mask &= 0xf; 1246 if (comb_mask == (BIT(3) | BIT(2) | BIT(1) | BIT(0))) 1247 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3; 1248 else if (comb_mask == (BIT(1) | BIT(2))) 1249 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2; 1250 else if (comb_mask == (BIT(0) | BIT(1))) 1251 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1; 1252 else if (comb_mask == BIT(3)) 1253 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS3; 1254 1255 break; 1256 case SX9310_REG_PROX_CTRL4: 1257 ret = of_property_read_string(np, "semtech,resolution", &res); 1258 if (ret) 1259 break; 1260 1261 reg_def->def &= ~SX9310_REG_PROX_CTRL4_RESOLUTION_MASK; 1262 if (!strcmp(res, "coarsest")) 1263 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST; 1264 else if (!strcmp(res, "very-coarse")) 1265 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE; 1266 else if (!strcmp(res, "coarse")) 1267 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE; 1268 else if (!strcmp(res, "medium-coarse")) 1269 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE; 1270 else if (!strcmp(res, "medium")) 1271 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM; 1272 else if (!strcmp(res, "fine")) 1273 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINE; 1274 else if (!strcmp(res, "very-fine")) 1275 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE; 1276 else if (!strcmp(res, "finest")) 1277 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST; 1278 1279 break; 1280 case SX9310_REG_PROX_CTRL5: 1281 ret = of_property_read_u32(np, "semtech,startup-sensor", &start); 1282 if (ret) { 1283 start = FIELD_GET(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK, 1284 reg_def->def); 1285 } 1286 1287 reg_def->def &= ~SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK; 1288 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK, 1289 start); 1290 1291 ret = of_property_read_u32(np, "semtech,proxraw-strength", &raw); 1292 if (ret) { 1293 raw = FIELD_GET(SX9310_REG_PROX_CTRL5_RAWFILT_MASK, 1294 reg_def->def); 1295 } else { 1296 raw = ilog2(raw); 1297 } 1298 1299 reg_def->def &= ~SX9310_REG_PROX_CTRL5_RAWFILT_MASK; 1300 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_RAWFILT_MASK, 1301 raw); 1302 break; 1303 case SX9310_REG_PROX_CTRL7: 1304 ret = of_property_read_u32(np, "semtech,avg-pos-strength", &pos); 1305 if (ret) 1306 break; 1307 1308 pos = min(max(ilog2(pos), 3), 10) - 3; 1309 reg_def->def &= ~SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK; 1310 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK, 1311 pos); 1312 break; 1313 } 1314 1315 return reg_def; 1316 } 1317 1318 static int sx9310_init_device(struct iio_dev *indio_dev) 1319 { 1320 struct sx9310_data *data = iio_priv(indio_dev); 1321 struct sx9310_reg_default tmp; 1322 const struct sx9310_reg_default *initval; 1323 int ret; 1324 unsigned int i, val; 1325 1326 ret = regmap_write(data->regmap, SX9310_REG_RESET, SX9310_SOFT_RESET); 1327 if (ret) 1328 return ret; 1329 1330 usleep_range(1000, 2000); /* power-up time is ~1ms. */ 1331 1332 /* Clear reset interrupt state by reading SX9310_REG_IRQ_SRC. */ 1333 ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val); 1334 if (ret) 1335 return ret; 1336 1337 /* Program some sane defaults. */ 1338 for (i = 0; i < ARRAY_SIZE(sx9310_default_regs); i++) { 1339 initval = sx9310_get_default_reg(data, i, &tmp); 1340 ret = regmap_write(data->regmap, initval->reg, initval->def); 1341 if (ret) 1342 return ret; 1343 } 1344 1345 return sx9310_init_compensation(indio_dev); 1346 } 1347 1348 static int sx9310_set_indio_dev_name(struct device *dev, 1349 struct iio_dev *indio_dev, 1350 unsigned int whoami) 1351 { 1352 unsigned int long ddata; 1353 1354 ddata = (uintptr_t)device_get_match_data(dev); 1355 if (ddata != whoami) { 1356 dev_err(dev, "WHOAMI does not match device data: %u\n", whoami); 1357 return -ENODEV; 1358 } 1359 1360 switch (whoami) { 1361 case SX9310_WHOAMI_VALUE: 1362 indio_dev->name = "sx9310"; 1363 break; 1364 case SX9311_WHOAMI_VALUE: 1365 indio_dev->name = "sx9311"; 1366 break; 1367 default: 1368 dev_err(dev, "unexpected WHOAMI response: %u\n", whoami); 1369 return -ENODEV; 1370 } 1371 1372 return 0; 1373 } 1374 1375 static void sx9310_regulator_disable(void *_data) 1376 { 1377 struct sx9310_data *data = _data; 1378 1379 regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies); 1380 } 1381 1382 static int sx9310_probe(struct i2c_client *client) 1383 { 1384 int ret; 1385 struct device *dev = &client->dev; 1386 struct iio_dev *indio_dev; 1387 struct sx9310_data *data; 1388 1389 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 1390 if (!indio_dev) 1391 return -ENOMEM; 1392 1393 data = iio_priv(indio_dev); 1394 data->client = client; 1395 data->supplies[0].supply = "vdd"; 1396 data->supplies[1].supply = "svdd"; 1397 mutex_init(&data->mutex); 1398 init_completion(&data->completion); 1399 1400 data->regmap = devm_regmap_init_i2c(client, &sx9310_regmap_config); 1401 if (IS_ERR(data->regmap)) 1402 return PTR_ERR(data->regmap); 1403 1404 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), 1405 data->supplies); 1406 if (ret) 1407 return ret; 1408 1409 ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies); 1410 if (ret) 1411 return ret; 1412 /* Must wait for Tpor time after initial power up */ 1413 usleep_range(1000, 1100); 1414 1415 ret = devm_add_action_or_reset(dev, sx9310_regulator_disable, data); 1416 if (ret) 1417 return ret; 1418 1419 ret = regmap_read(data->regmap, SX9310_REG_WHOAMI, &data->whoami); 1420 if (ret) { 1421 dev_err(dev, "error in reading WHOAMI register: %d", ret); 1422 return ret; 1423 } 1424 1425 ret = sx9310_set_indio_dev_name(dev, indio_dev, data->whoami); 1426 if (ret) 1427 return ret; 1428 1429 ACPI_COMPANION_SET(&indio_dev->dev, ACPI_COMPANION(dev)); 1430 indio_dev->channels = sx9310_channels; 1431 indio_dev->num_channels = ARRAY_SIZE(sx9310_channels); 1432 indio_dev->info = &sx9310_info; 1433 indio_dev->modes = INDIO_DIRECT_MODE; 1434 i2c_set_clientdata(client, indio_dev); 1435 1436 ret = sx9310_init_device(indio_dev); 1437 if (ret) 1438 return ret; 1439 1440 if (client->irq) { 1441 ret = devm_request_threaded_irq(dev, client->irq, 1442 sx9310_irq_handler, 1443 sx9310_irq_thread_handler, 1444 IRQF_ONESHOT, 1445 "sx9310_event", indio_dev); 1446 if (ret) 1447 return ret; 1448 1449 data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", 1450 indio_dev->name, 1451 indio_dev->id); 1452 if (!data->trig) 1453 return -ENOMEM; 1454 1455 data->trig->dev.parent = dev; 1456 data->trig->ops = &sx9310_trigger_ops; 1457 iio_trigger_set_drvdata(data->trig, indio_dev); 1458 1459 ret = devm_iio_trigger_register(dev, data->trig); 1460 if (ret) 1461 return ret; 1462 } 1463 1464 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 1465 iio_pollfunc_store_time, 1466 sx9310_trigger_handler, 1467 &sx9310_buffer_setup_ops); 1468 if (ret) 1469 return ret; 1470 1471 return devm_iio_device_register(dev, indio_dev); 1472 } 1473 1474 static int __maybe_unused sx9310_suspend(struct device *dev) 1475 { 1476 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1477 struct sx9310_data *data = iio_priv(indio_dev); 1478 u8 ctrl0; 1479 int ret; 1480 1481 disable_irq_nosync(data->client->irq); 1482 1483 mutex_lock(&data->mutex); 1484 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, 1485 &data->suspend_ctrl0); 1486 if (ret) 1487 goto out; 1488 1489 ctrl0 = data->suspend_ctrl0 & ~SX9310_REG_PROX_CTRL0_SENSOREN_MASK; 1490 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0); 1491 if (ret) 1492 goto out; 1493 1494 ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 0); 1495 1496 out: 1497 mutex_unlock(&data->mutex); 1498 return ret; 1499 } 1500 1501 static int __maybe_unused sx9310_resume(struct device *dev) 1502 { 1503 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1504 struct sx9310_data *data = iio_priv(indio_dev); 1505 int ret; 1506 1507 mutex_lock(&data->mutex); 1508 ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 1); 1509 if (ret) 1510 goto out; 1511 1512 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, 1513 data->suspend_ctrl0); 1514 1515 out: 1516 mutex_unlock(&data->mutex); 1517 if (ret) 1518 return ret; 1519 1520 enable_irq(data->client->irq); 1521 return 0; 1522 } 1523 1524 static const struct dev_pm_ops sx9310_pm_ops = { 1525 SET_SYSTEM_SLEEP_PM_OPS(sx9310_suspend, sx9310_resume) 1526 }; 1527 1528 static const struct acpi_device_id sx9310_acpi_match[] = { 1529 { "STH9310", SX9310_WHOAMI_VALUE }, 1530 { "STH9311", SX9311_WHOAMI_VALUE }, 1531 {} 1532 }; 1533 MODULE_DEVICE_TABLE(acpi, sx9310_acpi_match); 1534 1535 static const struct of_device_id sx9310_of_match[] = { 1536 { .compatible = "semtech,sx9310", (void *)SX9310_WHOAMI_VALUE }, 1537 { .compatible = "semtech,sx9311", (void *)SX9311_WHOAMI_VALUE }, 1538 {} 1539 }; 1540 MODULE_DEVICE_TABLE(of, sx9310_of_match); 1541 1542 static const struct i2c_device_id sx9310_id[] = { 1543 { "sx9310", SX9310_WHOAMI_VALUE }, 1544 { "sx9311", SX9311_WHOAMI_VALUE }, 1545 {} 1546 }; 1547 MODULE_DEVICE_TABLE(i2c, sx9310_id); 1548 1549 static struct i2c_driver sx9310_driver = { 1550 .driver = { 1551 .name = "sx9310", 1552 .acpi_match_table = sx9310_acpi_match, 1553 .of_match_table = sx9310_of_match, 1554 .pm = &sx9310_pm_ops, 1555 1556 /* 1557 * Lots of i2c transfers in probe + over 200 ms waiting in 1558 * sx9310_init_compensation() mean a slow probe; prefer async 1559 * so we don't delay boot if we're builtin to the kernel. 1560 */ 1561 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1562 }, 1563 .probe_new = sx9310_probe, 1564 .id_table = sx9310_id, 1565 }; 1566 module_i2c_driver(sx9310_driver); 1567 1568 MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>"); 1569 MODULE_AUTHOR("Daniel Campello <campello@chromium.org>"); 1570 MODULE_DESCRIPTION("Driver for Semtech SX9310/SX9311 proximity sensor"); 1571 MODULE_LICENSE("GPL v2"); 1572