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