1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2015 Intel Corporation 4 * 5 * Driver for TXC PA12203001 Proximity and Ambient Light Sensor. 6 * 7 * To do: Interrupt support. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/acpi.h> 13 #include <linux/delay.h> 14 #include <linux/i2c.h> 15 #include <linux/iio/iio.h> 16 #include <linux/iio/sysfs.h> 17 #include <linux/mutex.h> 18 #include <linux/pm.h> 19 #include <linux/pm_runtime.h> 20 #include <linux/regmap.h> 21 22 #define PA12203001_DRIVER_NAME "pa12203001" 23 24 #define PA12203001_REG_CFG0 0x00 25 #define PA12203001_REG_CFG1 0x01 26 #define PA12203001_REG_CFG2 0x02 27 #define PA12203001_REG_CFG3 0x03 28 29 #define PA12203001_REG_ADL 0x0b 30 #define PA12203001_REG_PDH 0x0e 31 32 #define PA12203001_REG_POFS 0x10 33 #define PA12203001_REG_PSET 0x11 34 35 #define PA12203001_ALS_EN_MASK BIT(0) 36 #define PA12203001_PX_EN_MASK BIT(1) 37 #define PA12203001_PX_NORMAL_MODE_MASK GENMASK(7, 6) 38 #define PA12203001_AFSR_MASK GENMASK(5, 4) 39 #define PA12203001_AFSR_SHIFT 4 40 41 #define PA12203001_PSCAN 0x03 42 43 /* als range 31000, ps, als disabled */ 44 #define PA12203001_REG_CFG0_DEFAULT 0x30 45 46 /* led current: 100 mA */ 47 #define PA12203001_REG_CFG1_DEFAULT 0x20 48 49 /* ps mode: normal, interrupts not active */ 50 #define PA12203001_REG_CFG2_DEFAULT 0xcc 51 52 #define PA12203001_REG_CFG3_DEFAULT 0x00 53 54 #define PA12203001_SLEEP_DELAY_MS 3000 55 56 #define PA12203001_CHIP_ENABLE 0xff 57 #define PA12203001_CHIP_DISABLE 0x00 58 59 /* available scales: corresponding to [500, 4000, 7000, 31000] lux */ 60 static const int pa12203001_scales[] = { 7629, 61036, 106813, 473029}; 61 62 struct pa12203001_data { 63 struct i2c_client *client; 64 65 /* protect device states */ 66 struct mutex lock; 67 68 bool als_enabled; 69 bool px_enabled; 70 bool als_needs_enable; 71 bool px_needs_enable; 72 73 struct regmap *map; 74 }; 75 76 static const struct { 77 u8 reg; 78 u8 val; 79 } regvals[] = { 80 {PA12203001_REG_CFG0, PA12203001_REG_CFG0_DEFAULT}, 81 {PA12203001_REG_CFG1, PA12203001_REG_CFG1_DEFAULT}, 82 {PA12203001_REG_CFG2, PA12203001_REG_CFG2_DEFAULT}, 83 {PA12203001_REG_CFG3, PA12203001_REG_CFG3_DEFAULT}, 84 {PA12203001_REG_PSET, PA12203001_PSCAN}, 85 }; 86 87 static IIO_CONST_ATTR(in_illuminance_scale_available, 88 "0.007629 0.061036 0.106813 0.473029"); 89 90 static struct attribute *pa12203001_attrs[] = { 91 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr, 92 NULL 93 }; 94 95 static const struct attribute_group pa12203001_attr_group = { 96 .attrs = pa12203001_attrs, 97 }; 98 99 static const struct iio_chan_spec pa12203001_channels[] = { 100 { 101 .type = IIO_LIGHT, 102 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 103 BIT(IIO_CHAN_INFO_SCALE), 104 }, 105 { 106 .type = IIO_PROXIMITY, 107 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 108 } 109 }; 110 111 static const struct regmap_range pa12203001_volatile_regs_ranges[] = { 112 regmap_reg_range(PA12203001_REG_ADL, PA12203001_REG_ADL + 1), 113 regmap_reg_range(PA12203001_REG_PDH, PA12203001_REG_PDH), 114 }; 115 116 static const struct regmap_access_table pa12203001_volatile_regs = { 117 .yes_ranges = pa12203001_volatile_regs_ranges, 118 .n_yes_ranges = ARRAY_SIZE(pa12203001_volatile_regs_ranges), 119 }; 120 121 static const struct regmap_config pa12203001_regmap_config = { 122 .reg_bits = 8, 123 .val_bits = 8, 124 .max_register = PA12203001_REG_PSET, 125 .cache_type = REGCACHE_RBTREE, 126 .volatile_table = &pa12203001_volatile_regs, 127 }; 128 129 static inline int pa12203001_als_enable(struct pa12203001_data *data, u8 enable) 130 { 131 int ret; 132 133 ret = regmap_update_bits(data->map, PA12203001_REG_CFG0, 134 PA12203001_ALS_EN_MASK, enable); 135 if (ret < 0) 136 return ret; 137 138 data->als_enabled = !!enable; 139 140 return 0; 141 } 142 143 static inline int pa12203001_px_enable(struct pa12203001_data *data, u8 enable) 144 { 145 int ret; 146 147 ret = regmap_update_bits(data->map, PA12203001_REG_CFG0, 148 PA12203001_PX_EN_MASK, enable); 149 if (ret < 0) 150 return ret; 151 152 data->px_enabled = !!enable; 153 154 return 0; 155 } 156 157 static int pa12203001_set_power_state(struct pa12203001_data *data, bool on, 158 u8 mask) 159 { 160 #ifdef CONFIG_PM 161 int ret; 162 163 if (on && (mask & PA12203001_ALS_EN_MASK)) { 164 mutex_lock(&data->lock); 165 if (data->px_enabled) { 166 ret = pa12203001_als_enable(data, 167 PA12203001_ALS_EN_MASK); 168 if (ret < 0) 169 goto err; 170 } else { 171 data->als_needs_enable = true; 172 } 173 mutex_unlock(&data->lock); 174 } 175 176 if (on && (mask & PA12203001_PX_EN_MASK)) { 177 mutex_lock(&data->lock); 178 if (data->als_enabled) { 179 ret = pa12203001_px_enable(data, PA12203001_PX_EN_MASK); 180 if (ret < 0) 181 goto err; 182 } else { 183 data->px_needs_enable = true; 184 } 185 mutex_unlock(&data->lock); 186 } 187 188 if (on) 189 return pm_runtime_resume_and_get(&data->client->dev); 190 191 return pm_runtime_put_autosuspend(&data->client->dev); 192 193 err: 194 mutex_unlock(&data->lock); 195 return ret; 196 197 #endif 198 return 0; 199 } 200 201 static int pa12203001_read_raw(struct iio_dev *indio_dev, 202 struct iio_chan_spec const *chan, int *val, 203 int *val2, long mask) 204 { 205 struct pa12203001_data *data = iio_priv(indio_dev); 206 int ret; 207 u8 dev_mask; 208 unsigned int reg_byte; 209 __le16 reg_word; 210 211 switch (mask) { 212 case IIO_CHAN_INFO_RAW: 213 switch (chan->type) { 214 case IIO_LIGHT: 215 dev_mask = PA12203001_ALS_EN_MASK; 216 ret = pa12203001_set_power_state(data, true, dev_mask); 217 if (ret < 0) 218 return ret; 219 /* 220 * ALS ADC value is stored in registers 221 * PA12203001_REG_ADL and in PA12203001_REG_ADL + 1. 222 */ 223 ret = regmap_bulk_read(data->map, PA12203001_REG_ADL, 224 ®_word, 2); 225 if (ret < 0) 226 goto reg_err; 227 228 *val = le16_to_cpu(reg_word); 229 ret = pa12203001_set_power_state(data, false, dev_mask); 230 if (ret < 0) 231 return ret; 232 break; 233 case IIO_PROXIMITY: 234 dev_mask = PA12203001_PX_EN_MASK; 235 ret = pa12203001_set_power_state(data, true, dev_mask); 236 if (ret < 0) 237 return ret; 238 ret = regmap_read(data->map, PA12203001_REG_PDH, 239 ®_byte); 240 if (ret < 0) 241 goto reg_err; 242 243 *val = reg_byte; 244 ret = pa12203001_set_power_state(data, false, dev_mask); 245 if (ret < 0) 246 return ret; 247 break; 248 default: 249 return -EINVAL; 250 } 251 return IIO_VAL_INT; 252 case IIO_CHAN_INFO_SCALE: 253 ret = regmap_read(data->map, PA12203001_REG_CFG0, ®_byte); 254 if (ret < 0) 255 return ret; 256 *val = 0; 257 reg_byte = (reg_byte & PA12203001_AFSR_MASK); 258 *val2 = pa12203001_scales[reg_byte >> 4]; 259 return IIO_VAL_INT_PLUS_MICRO; 260 default: 261 return -EINVAL; 262 } 263 264 reg_err: 265 pa12203001_set_power_state(data, false, dev_mask); 266 return ret; 267 } 268 269 static int pa12203001_write_raw(struct iio_dev *indio_dev, 270 struct iio_chan_spec const *chan, int val, 271 int val2, long mask) 272 { 273 struct pa12203001_data *data = iio_priv(indio_dev); 274 int i, ret, new_val; 275 unsigned int reg_byte; 276 277 switch (mask) { 278 case IIO_CHAN_INFO_SCALE: 279 ret = regmap_read(data->map, PA12203001_REG_CFG0, ®_byte); 280 if (val != 0 || ret < 0) 281 return -EINVAL; 282 for (i = 0; i < ARRAY_SIZE(pa12203001_scales); i++) { 283 if (val2 == pa12203001_scales[i]) { 284 new_val = i << PA12203001_AFSR_SHIFT; 285 return regmap_update_bits(data->map, 286 PA12203001_REG_CFG0, 287 PA12203001_AFSR_MASK, 288 new_val); 289 } 290 } 291 break; 292 default: 293 break; 294 } 295 296 return -EINVAL; 297 } 298 299 static const struct iio_info pa12203001_info = { 300 .read_raw = pa12203001_read_raw, 301 .write_raw = pa12203001_write_raw, 302 .attrs = &pa12203001_attr_group, 303 }; 304 305 static int pa12203001_init(struct iio_dev *indio_dev) 306 { 307 struct pa12203001_data *data = iio_priv(indio_dev); 308 int i, ret; 309 310 for (i = 0; i < ARRAY_SIZE(regvals); i++) { 311 ret = regmap_write(data->map, regvals[i].reg, regvals[i].val); 312 if (ret < 0) 313 return ret; 314 } 315 316 return 0; 317 } 318 319 static int pa12203001_power_chip(struct iio_dev *indio_dev, u8 state) 320 { 321 struct pa12203001_data *data = iio_priv(indio_dev); 322 int ret; 323 324 mutex_lock(&data->lock); 325 ret = pa12203001_als_enable(data, state); 326 if (ret < 0) 327 goto out; 328 329 ret = pa12203001_px_enable(data, state); 330 331 out: 332 mutex_unlock(&data->lock); 333 return ret; 334 } 335 336 static int pa12203001_probe(struct i2c_client *client) 337 { 338 struct pa12203001_data *data; 339 struct iio_dev *indio_dev; 340 int ret; 341 342 indio_dev = devm_iio_device_alloc(&client->dev, 343 sizeof(struct pa12203001_data)); 344 if (!indio_dev) 345 return -ENOMEM; 346 347 data = iio_priv(indio_dev); 348 i2c_set_clientdata(client, indio_dev); 349 data->client = client; 350 351 data->map = devm_regmap_init_i2c(client, &pa12203001_regmap_config); 352 if (IS_ERR(data->map)) 353 return PTR_ERR(data->map); 354 355 mutex_init(&data->lock); 356 357 indio_dev->info = &pa12203001_info; 358 indio_dev->name = PA12203001_DRIVER_NAME; 359 indio_dev->channels = pa12203001_channels; 360 indio_dev->num_channels = ARRAY_SIZE(pa12203001_channels); 361 indio_dev->modes = INDIO_DIRECT_MODE; 362 363 ret = pa12203001_init(indio_dev); 364 if (ret < 0) 365 return ret; 366 367 ret = pa12203001_power_chip(indio_dev, PA12203001_CHIP_ENABLE); 368 if (ret < 0) 369 return ret; 370 371 ret = pm_runtime_set_active(&client->dev); 372 if (ret < 0) 373 goto out_err; 374 375 pm_runtime_enable(&client->dev); 376 pm_runtime_set_autosuspend_delay(&client->dev, 377 PA12203001_SLEEP_DELAY_MS); 378 pm_runtime_use_autosuspend(&client->dev); 379 380 ret = iio_device_register(indio_dev); 381 if (ret < 0) 382 goto out_err; 383 384 return 0; 385 386 out_err: 387 pa12203001_power_chip(indio_dev, PA12203001_CHIP_DISABLE); 388 return ret; 389 } 390 391 static void pa12203001_remove(struct i2c_client *client) 392 { 393 struct iio_dev *indio_dev = i2c_get_clientdata(client); 394 int ret; 395 396 iio_device_unregister(indio_dev); 397 398 pm_runtime_disable(&client->dev); 399 pm_runtime_set_suspended(&client->dev); 400 401 ret = pa12203001_power_chip(indio_dev, PA12203001_CHIP_DISABLE); 402 if (ret) 403 dev_warn(&client->dev, "Failed to power down (%pe)\n", 404 ERR_PTR(ret)); 405 } 406 407 #if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM) 408 static int pa12203001_suspend(struct device *dev) 409 { 410 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 411 412 return pa12203001_power_chip(indio_dev, PA12203001_CHIP_DISABLE); 413 } 414 #endif 415 416 #ifdef CONFIG_PM_SLEEP 417 static int pa12203001_resume(struct device *dev) 418 { 419 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 420 421 return pa12203001_power_chip(indio_dev, PA12203001_CHIP_ENABLE); 422 } 423 #endif 424 425 #ifdef CONFIG_PM 426 static int pa12203001_runtime_resume(struct device *dev) 427 { 428 struct pa12203001_data *data; 429 430 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 431 432 mutex_lock(&data->lock); 433 if (data->als_needs_enable) { 434 pa12203001_als_enable(data, PA12203001_ALS_EN_MASK); 435 data->als_needs_enable = false; 436 } 437 if (data->px_needs_enable) { 438 pa12203001_px_enable(data, PA12203001_PX_EN_MASK); 439 data->px_needs_enable = false; 440 } 441 mutex_unlock(&data->lock); 442 443 return 0; 444 } 445 #endif 446 447 static const struct dev_pm_ops pa12203001_pm_ops = { 448 SET_SYSTEM_SLEEP_PM_OPS(pa12203001_suspend, pa12203001_resume) 449 SET_RUNTIME_PM_OPS(pa12203001_suspend, pa12203001_runtime_resume, NULL) 450 }; 451 452 static const struct acpi_device_id pa12203001_acpi_match[] = { 453 { "TXCPA122", 0 }, 454 { } 455 }; 456 457 MODULE_DEVICE_TABLE(acpi, pa12203001_acpi_match); 458 459 static const struct i2c_device_id pa12203001_id[] = { 460 { "txcpa122" }, 461 { } 462 }; 463 464 MODULE_DEVICE_TABLE(i2c, pa12203001_id); 465 466 static struct i2c_driver pa12203001_driver = { 467 .driver = { 468 .name = PA12203001_DRIVER_NAME, 469 .pm = &pa12203001_pm_ops, 470 .acpi_match_table = pa12203001_acpi_match, 471 }, 472 .probe = pa12203001_probe, 473 .remove = pa12203001_remove, 474 .id_table = pa12203001_id, 475 476 }; 477 module_i2c_driver(pa12203001_driver); 478 479 MODULE_AUTHOR("Adriana Reus <adriana.reus@intel.com>"); 480 MODULE_DESCRIPTION("Driver for TXC PA12203001 Proximity and Light Sensor"); 481 MODULE_LICENSE("GPL v2"); 482