1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * JSA1212 Ambient Light & Proximity Sensor Driver 4 * 5 * Copyright (c) 2014, Intel Corporation. 6 * 7 * JSA1212 I2C slave address: 0x44(ADDR tied to GND), 0x45(ADDR tied to VDD) 8 * 9 * TODO: Interrupt support, thresholds, range support. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/slab.h> 14 #include <linux/module.h> 15 #include <linux/mod_devicetable.h> 16 #include <linux/delay.h> 17 #include <linux/i2c.h> 18 #include <linux/mutex.h> 19 #include <linux/regmap.h> 20 #include <linux/iio/iio.h> 21 #include <linux/iio/sysfs.h> 22 23 /* JSA1212 reg address */ 24 #define JSA1212_CONF_REG 0x01 25 #define JSA1212_INT_REG 0x02 26 #define JSA1212_PXS_LT_REG 0x03 27 #define JSA1212_PXS_HT_REG 0x04 28 #define JSA1212_ALS_TH1_REG 0x05 29 #define JSA1212_ALS_TH2_REG 0x06 30 #define JSA1212_ALS_TH3_REG 0x07 31 #define JSA1212_PXS_DATA_REG 0x08 32 #define JSA1212_ALS_DT1_REG 0x09 33 #define JSA1212_ALS_DT2_REG 0x0A 34 #define JSA1212_ALS_RNG_REG 0x0B 35 #define JSA1212_MAX_REG 0x0C 36 37 /* JSA1212 reg masks */ 38 #define JSA1212_CONF_MASK 0xFF 39 #define JSA1212_INT_MASK 0xFF 40 #define JSA1212_PXS_LT_MASK 0xFF 41 #define JSA1212_PXS_HT_MASK 0xFF 42 #define JSA1212_ALS_TH1_MASK 0xFF 43 #define JSA1212_ALS_TH2_LT_MASK 0x0F 44 #define JSA1212_ALS_TH2_HT_MASK 0xF0 45 #define JSA1212_ALS_TH3_MASK 0xFF 46 #define JSA1212_PXS_DATA_MASK 0xFF 47 #define JSA1212_ALS_DATA_MASK 0x0FFF 48 #define JSA1212_ALS_DT1_MASK 0xFF 49 #define JSA1212_ALS_DT2_MASK 0x0F 50 #define JSA1212_ALS_RNG_MASK 0x07 51 52 /* JSA1212 CONF REG bits */ 53 #define JSA1212_CONF_PXS_MASK 0x80 54 #define JSA1212_CONF_PXS_ENABLE 0x80 55 #define JSA1212_CONF_PXS_DISABLE 0x00 56 #define JSA1212_CONF_ALS_MASK 0x04 57 #define JSA1212_CONF_ALS_ENABLE 0x04 58 #define JSA1212_CONF_ALS_DISABLE 0x00 59 #define JSA1212_CONF_IRDR_MASK 0x08 60 /* Proxmity sensing IRDR current sink settings */ 61 #define JSA1212_CONF_IRDR_200MA 0x08 62 #define JSA1212_CONF_IRDR_100MA 0x00 63 #define JSA1212_CONF_PXS_SLP_MASK 0x70 64 #define JSA1212_CONF_PXS_SLP_0MS 0x70 65 #define JSA1212_CONF_PXS_SLP_12MS 0x60 66 #define JSA1212_CONF_PXS_SLP_50MS 0x50 67 #define JSA1212_CONF_PXS_SLP_75MS 0x40 68 #define JSA1212_CONF_PXS_SLP_100MS 0x30 69 #define JSA1212_CONF_PXS_SLP_200MS 0x20 70 #define JSA1212_CONF_PXS_SLP_400MS 0x10 71 #define JSA1212_CONF_PXS_SLP_800MS 0x00 72 73 /* JSA1212 INT REG bits */ 74 #define JSA1212_INT_CTRL_MASK 0x01 75 #define JSA1212_INT_CTRL_EITHER 0x00 76 #define JSA1212_INT_CTRL_BOTH 0x01 77 #define JSA1212_INT_ALS_PRST_MASK 0x06 78 #define JSA1212_INT_ALS_PRST_1CONV 0x00 79 #define JSA1212_INT_ALS_PRST_4CONV 0x02 80 #define JSA1212_INT_ALS_PRST_8CONV 0x04 81 #define JSA1212_INT_ALS_PRST_16CONV 0x06 82 #define JSA1212_INT_ALS_FLAG_MASK 0x08 83 #define JSA1212_INT_ALS_FLAG_CLR 0x00 84 #define JSA1212_INT_PXS_PRST_MASK 0x60 85 #define JSA1212_INT_PXS_PRST_1CONV 0x00 86 #define JSA1212_INT_PXS_PRST_4CONV 0x20 87 #define JSA1212_INT_PXS_PRST_8CONV 0x40 88 #define JSA1212_INT_PXS_PRST_16CONV 0x60 89 #define JSA1212_INT_PXS_FLAG_MASK 0x80 90 #define JSA1212_INT_PXS_FLAG_CLR 0x00 91 92 /* JSA1212 ALS RNG REG bits */ 93 #define JSA1212_ALS_RNG_0_2048 0x00 94 #define JSA1212_ALS_RNG_0_1024 0x01 95 #define JSA1212_ALS_RNG_0_512 0x02 96 #define JSA1212_ALS_RNG_0_256 0x03 97 #define JSA1212_ALS_RNG_0_128 0x04 98 99 /* JSA1212 INT threshold range */ 100 #define JSA1212_ALS_TH_MIN 0x0000 101 #define JSA1212_ALS_TH_MAX 0x0FFF 102 #define JSA1212_PXS_TH_MIN 0x00 103 #define JSA1212_PXS_TH_MAX 0xFF 104 105 #define JSA1212_ALS_DELAY_MS 200 106 #define JSA1212_PXS_DELAY_MS 100 107 108 #define JSA1212_DRIVER_NAME "jsa1212" 109 110 enum jsa1212_op_mode { 111 JSA1212_OPMODE_ALS_EN, 112 JSA1212_OPMODE_PXS_EN, 113 }; 114 115 struct jsa1212_data { 116 struct i2c_client *client; 117 struct mutex lock; 118 u8 als_rng_idx; 119 bool als_en; /* ALS enable status */ 120 bool pxs_en; /* proximity enable status */ 121 struct regmap *regmap; 122 }; 123 124 /* ALS range idx to val mapping */ 125 static const int jsa1212_als_range_val[] = {2048, 1024, 512, 256, 128, 126 128, 128, 128}; 127 128 /* Enables or disables ALS function based on status */ 129 static int jsa1212_als_enable(struct jsa1212_data *data, u8 status) 130 { 131 int ret; 132 133 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, 134 JSA1212_CONF_ALS_MASK, 135 status); 136 if (ret < 0) 137 return ret; 138 139 data->als_en = !!status; 140 141 return 0; 142 } 143 144 /* Enables or disables PXS function based on status */ 145 static int jsa1212_pxs_enable(struct jsa1212_data *data, u8 status) 146 { 147 int ret; 148 149 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, 150 JSA1212_CONF_PXS_MASK, 151 status); 152 if (ret < 0) 153 return ret; 154 155 data->pxs_en = !!status; 156 157 return 0; 158 } 159 160 static int jsa1212_read_als_data(struct jsa1212_data *data, 161 unsigned int *val) 162 { 163 int ret; 164 __le16 als_data; 165 166 ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE); 167 if (ret < 0) 168 return ret; 169 170 /* Delay for data output */ 171 msleep(JSA1212_ALS_DELAY_MS); 172 173 /* Read 12 bit data */ 174 ret = regmap_bulk_read(data->regmap, JSA1212_ALS_DT1_REG, &als_data, 2); 175 if (ret < 0) { 176 dev_err(&data->client->dev, "als data read err\n"); 177 goto als_data_read_err; 178 } 179 180 *val = le16_to_cpu(als_data); 181 182 als_data_read_err: 183 return jsa1212_als_enable(data, JSA1212_CONF_ALS_DISABLE); 184 } 185 186 static int jsa1212_read_pxs_data(struct jsa1212_data *data, 187 unsigned int *val) 188 { 189 int ret; 190 unsigned int pxs_data; 191 192 ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE); 193 if (ret < 0) 194 return ret; 195 196 /* Delay for data output */ 197 msleep(JSA1212_PXS_DELAY_MS); 198 199 /* Read out all data */ 200 ret = regmap_read(data->regmap, JSA1212_PXS_DATA_REG, &pxs_data); 201 if (ret < 0) { 202 dev_err(&data->client->dev, "pxs data read err\n"); 203 goto pxs_data_read_err; 204 } 205 206 *val = pxs_data & JSA1212_PXS_DATA_MASK; 207 208 pxs_data_read_err: 209 return jsa1212_pxs_enable(data, JSA1212_CONF_PXS_DISABLE); 210 } 211 212 static int jsa1212_read_raw(struct iio_dev *indio_dev, 213 struct iio_chan_spec const *chan, 214 int *val, int *val2, long mask) 215 { 216 int ret; 217 struct jsa1212_data *data = iio_priv(indio_dev); 218 219 switch (mask) { 220 case IIO_CHAN_INFO_RAW: 221 mutex_lock(&data->lock); 222 switch (chan->type) { 223 case IIO_LIGHT: 224 ret = jsa1212_read_als_data(data, val); 225 break; 226 case IIO_PROXIMITY: 227 ret = jsa1212_read_pxs_data(data, val); 228 break; 229 default: 230 ret = -EINVAL; 231 break; 232 } 233 mutex_unlock(&data->lock); 234 return ret < 0 ? ret : IIO_VAL_INT; 235 case IIO_CHAN_INFO_SCALE: 236 switch (chan->type) { 237 case IIO_LIGHT: 238 *val = jsa1212_als_range_val[data->als_rng_idx]; 239 *val2 = BIT(12); /* Max 12 bit value */ 240 return IIO_VAL_FRACTIONAL; 241 default: 242 break; 243 } 244 break; 245 default: 246 break; 247 } 248 249 return -EINVAL; 250 } 251 252 static const struct iio_chan_spec jsa1212_channels[] = { 253 { 254 .type = IIO_LIGHT, 255 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 256 BIT(IIO_CHAN_INFO_SCALE), 257 }, 258 { 259 .type = IIO_PROXIMITY, 260 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 261 } 262 }; 263 264 static const struct iio_info jsa1212_info = { 265 .read_raw = &jsa1212_read_raw, 266 }; 267 268 static int jsa1212_chip_init(struct jsa1212_data *data) 269 { 270 int ret; 271 272 ret = regmap_write(data->regmap, JSA1212_CONF_REG, 273 (JSA1212_CONF_PXS_SLP_50MS | 274 JSA1212_CONF_IRDR_200MA)); 275 if (ret < 0) 276 return ret; 277 278 ret = regmap_write(data->regmap, JSA1212_INT_REG, 279 JSA1212_INT_ALS_PRST_4CONV); 280 if (ret < 0) 281 return ret; 282 283 data->als_rng_idx = JSA1212_ALS_RNG_0_2048; 284 285 return 0; 286 } 287 288 static bool jsa1212_is_volatile_reg(struct device *dev, unsigned int reg) 289 { 290 switch (reg) { 291 case JSA1212_PXS_DATA_REG: 292 case JSA1212_ALS_DT1_REG: 293 case JSA1212_ALS_DT2_REG: 294 case JSA1212_INT_REG: 295 return true; 296 default: 297 return false; 298 } 299 } 300 301 static const struct regmap_config jsa1212_regmap_config = { 302 .name = "jsa1212_regmap", 303 .reg_bits = 8, 304 .val_bits = 8, 305 .max_register = JSA1212_MAX_REG, 306 .cache_type = REGCACHE_RBTREE, 307 .volatile_reg = jsa1212_is_volatile_reg, 308 }; 309 310 static int jsa1212_probe(struct i2c_client *client) 311 { 312 struct jsa1212_data *data; 313 struct iio_dev *indio_dev; 314 struct regmap *regmap; 315 int ret; 316 317 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 318 if (!indio_dev) 319 return -ENOMEM; 320 321 regmap = devm_regmap_init_i2c(client, &jsa1212_regmap_config); 322 if (IS_ERR(regmap)) { 323 dev_err(&client->dev, "Regmap initialization failed.\n"); 324 return PTR_ERR(regmap); 325 } 326 327 data = iio_priv(indio_dev); 328 329 i2c_set_clientdata(client, indio_dev); 330 data->client = client; 331 data->regmap = regmap; 332 333 mutex_init(&data->lock); 334 335 ret = jsa1212_chip_init(data); 336 if (ret < 0) 337 return ret; 338 339 indio_dev->channels = jsa1212_channels; 340 indio_dev->num_channels = ARRAY_SIZE(jsa1212_channels); 341 indio_dev->name = JSA1212_DRIVER_NAME; 342 indio_dev->modes = INDIO_DIRECT_MODE; 343 344 indio_dev->info = &jsa1212_info; 345 346 ret = iio_device_register(indio_dev); 347 if (ret < 0) 348 dev_err(&client->dev, "%s: register device failed\n", __func__); 349 350 return ret; 351 } 352 353 /* power off the device */ 354 static int jsa1212_power_off(struct jsa1212_data *data) 355 { 356 int ret; 357 358 mutex_lock(&data->lock); 359 360 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, 361 JSA1212_CONF_ALS_MASK | 362 JSA1212_CONF_PXS_MASK, 363 JSA1212_CONF_ALS_DISABLE | 364 JSA1212_CONF_PXS_DISABLE); 365 366 if (ret < 0) 367 dev_err(&data->client->dev, "power off cmd failed\n"); 368 369 mutex_unlock(&data->lock); 370 371 return ret; 372 } 373 374 static void jsa1212_remove(struct i2c_client *client) 375 { 376 struct iio_dev *indio_dev = i2c_get_clientdata(client); 377 struct jsa1212_data *data = iio_priv(indio_dev); 378 379 iio_device_unregister(indio_dev); 380 381 jsa1212_power_off(data); 382 } 383 384 static int jsa1212_suspend(struct device *dev) 385 { 386 struct jsa1212_data *data; 387 388 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 389 390 return jsa1212_power_off(data); 391 } 392 393 static int jsa1212_resume(struct device *dev) 394 { 395 int ret = 0; 396 struct jsa1212_data *data; 397 398 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 399 400 mutex_lock(&data->lock); 401 402 if (data->als_en) { 403 ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE); 404 if (ret < 0) { 405 dev_err(dev, "als resume failed\n"); 406 goto unlock_and_ret; 407 } 408 } 409 410 if (data->pxs_en) { 411 ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE); 412 if (ret < 0) 413 dev_err(dev, "pxs resume failed\n"); 414 } 415 416 unlock_and_ret: 417 mutex_unlock(&data->lock); 418 return ret; 419 } 420 421 static DEFINE_SIMPLE_DEV_PM_OPS(jsa1212_pm_ops, jsa1212_suspend, 422 jsa1212_resume); 423 424 static const struct acpi_device_id jsa1212_acpi_match[] = { 425 {"JSA1212", 0}, 426 { } 427 }; 428 MODULE_DEVICE_TABLE(acpi, jsa1212_acpi_match); 429 430 static const struct i2c_device_id jsa1212_id[] = { 431 { JSA1212_DRIVER_NAME }, 432 { } 433 }; 434 MODULE_DEVICE_TABLE(i2c, jsa1212_id); 435 436 static struct i2c_driver jsa1212_driver = { 437 .driver = { 438 .name = JSA1212_DRIVER_NAME, 439 .pm = pm_sleep_ptr(&jsa1212_pm_ops), 440 .acpi_match_table = jsa1212_acpi_match, 441 }, 442 .probe = jsa1212_probe, 443 .remove = jsa1212_remove, 444 .id_table = jsa1212_id, 445 }; 446 module_i2c_driver(jsa1212_driver); 447 448 MODULE_AUTHOR("Sathya Kuppuswamy <sathyanarayanan.kuppuswamy@linux.intel.com>"); 449 MODULE_DESCRIPTION("JSA1212 proximity/ambient light sensor driver"); 450 MODULE_LICENSE("GPL v2"); 451