iio/light/jsa1212.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * JSA1212 Ambient Light & Proximity Sensor Driver
0004  *
0005  * Copyright (c) 2014, Intel Corporation.
0006  *
0007  * JSA1212 I2C slave address: 0x44(ADDR tied to GND), 0x45(ADDR tied to VDD)
0008  *
0009  * TODO: Interrupt support, thresholds, range support.
0010  */
0011
0012 #include <linux/kernel.h>
0013 #include <linux/slab.h>
0014 #include <linux/module.h>
0015 #include <linux/delay.h>
0016 #include <linux/i2c.h>
0017 #include <linux/mutex.h>
0018 #include <linux/acpi.h>
0019 #include <linux/regmap.h>
0020 #include <linux/iio/iio.h>
0021 #include <linux/iio/sysfs.h>
0022
0023 /* JSA1212 reg address */
0024 #define JSA1212_CONF_REG        0x01
0025 #define JSA1212_INT_REG         0x02
0026 #define JSA1212_PXS_LT_REG      0x03
0027 #define JSA1212_PXS_HT_REG      0x04
0028 #define JSA1212_ALS_TH1_REG     0x05
0029 #define JSA1212_ALS_TH2_REG     0x06
0030 #define JSA1212_ALS_TH3_REG     0x07
0031 #define JSA1212_PXS_DATA_REG        0x08
0032 #define JSA1212_ALS_DT1_REG     0x09
0033 #define JSA1212_ALS_DT2_REG     0x0A
0034 #define JSA1212_ALS_RNG_REG     0x0B
0035 #define JSA1212_MAX_REG         0x0C
0036
0037 /* JSA1212 reg masks */
0038 #define JSA1212_CONF_MASK       0xFF
0039 #define JSA1212_INT_MASK        0xFF
0040 #define JSA1212_PXS_LT_MASK     0xFF
0041 #define JSA1212_PXS_HT_MASK     0xFF
0042 #define JSA1212_ALS_TH1_MASK        0xFF
0043 #define JSA1212_ALS_TH2_LT_MASK     0x0F
0044 #define JSA1212_ALS_TH2_HT_MASK     0xF0
0045 #define JSA1212_ALS_TH3_MASK        0xFF
0046 #define JSA1212_PXS_DATA_MASK       0xFF
0047 #define JSA1212_ALS_DATA_MASK       0x0FFF
0048 #define JSA1212_ALS_DT1_MASK        0xFF
0049 #define JSA1212_ALS_DT2_MASK        0x0F
0050 #define JSA1212_ALS_RNG_MASK        0x07
0051
0052 /* JSA1212 CONF REG bits */
0053 #define JSA1212_CONF_PXS_MASK       0x80
0054 #define JSA1212_CONF_PXS_ENABLE     0x80
0055 #define JSA1212_CONF_PXS_DISABLE    0x00
0056 #define JSA1212_CONF_ALS_MASK       0x04
0057 #define JSA1212_CONF_ALS_ENABLE     0x04
0058 #define JSA1212_CONF_ALS_DISABLE    0x00
0059 #define JSA1212_CONF_IRDR_MASK      0x08
0060 /* Proxmity sensing IRDR current sink settings */
0061 #define JSA1212_CONF_IRDR_200MA     0x08
0062 #define JSA1212_CONF_IRDR_100MA     0x00
0063 #define JSA1212_CONF_PXS_SLP_MASK   0x70
0064 #define JSA1212_CONF_PXS_SLP_0MS    0x70
0065 #define JSA1212_CONF_PXS_SLP_12MS   0x60
0066 #define JSA1212_CONF_PXS_SLP_50MS   0x50
0067 #define JSA1212_CONF_PXS_SLP_75MS   0x40
0068 #define JSA1212_CONF_PXS_SLP_100MS  0x30
0069 #define JSA1212_CONF_PXS_SLP_200MS  0x20
0070 #define JSA1212_CONF_PXS_SLP_400MS  0x10
0071 #define JSA1212_CONF_PXS_SLP_800MS  0x00
0072
0073 /* JSA1212 INT REG bits */
0074 #define JSA1212_INT_CTRL_MASK       0x01
0075 #define JSA1212_INT_CTRL_EITHER     0x00
0076 #define JSA1212_INT_CTRL_BOTH       0x01
0077 #define JSA1212_INT_ALS_PRST_MASK   0x06
0078 #define JSA1212_INT_ALS_PRST_1CONV  0x00
0079 #define JSA1212_INT_ALS_PRST_4CONV  0x02
0080 #define JSA1212_INT_ALS_PRST_8CONV  0x04
0081 #define JSA1212_INT_ALS_PRST_16CONV 0x06
0082 #define JSA1212_INT_ALS_FLAG_MASK   0x08
0083 #define JSA1212_INT_ALS_FLAG_CLR    0x00
0084 #define JSA1212_INT_PXS_PRST_MASK   0x60
0085 #define JSA1212_INT_PXS_PRST_1CONV  0x00
0086 #define JSA1212_INT_PXS_PRST_4CONV  0x20
0087 #define JSA1212_INT_PXS_PRST_8CONV  0x40
0088 #define JSA1212_INT_PXS_PRST_16CONV 0x60
0089 #define JSA1212_INT_PXS_FLAG_MASK   0x80
0090 #define JSA1212_INT_PXS_FLAG_CLR    0x00
0091
0092 /* JSA1212 ALS RNG REG bits */
0093 #define JSA1212_ALS_RNG_0_2048      0x00
0094 #define JSA1212_ALS_RNG_0_1024      0x01
0095 #define JSA1212_ALS_RNG_0_512       0x02
0096 #define JSA1212_ALS_RNG_0_256       0x03
0097 #define JSA1212_ALS_RNG_0_128       0x04
0098
0099 /* JSA1212 INT threshold range */
0100 #define JSA1212_ALS_TH_MIN  0x0000
0101 #define JSA1212_ALS_TH_MAX  0x0FFF
0102 #define JSA1212_PXS_TH_MIN  0x00
0103 #define JSA1212_PXS_TH_MAX  0xFF
0104
0105 #define JSA1212_ALS_DELAY_MS    200
0106 #define JSA1212_PXS_DELAY_MS    100
0107
0108 #define JSA1212_DRIVER_NAME "jsa1212"
0109 #define JSA1212_REGMAP_NAME "jsa1212_regmap"
0110
0111 enum jsa1212_op_mode {
0112     JSA1212_OPMODE_ALS_EN,
0113     JSA1212_OPMODE_PXS_EN,
0114 };
0115
0116 struct jsa1212_data {
0117     struct i2c_client *client;
0118     struct mutex lock;
0119     u8 als_rng_idx;
0120     bool als_en; /* ALS enable status */
0121     bool pxs_en; /* proximity enable status */
0122     struct regmap *regmap;
0123 };
0124
0125 /* ALS range idx to val mapping */
0126 static const int jsa1212_als_range_val[] = {2048, 1024, 512, 256, 128,
0127                         128, 128, 128};
0128
0129 /* Enables or disables ALS function based on status */
0130 static int jsa1212_als_enable(struct jsa1212_data *data, u8 status)
0131 {
0132     int ret;
0133
0134     ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
0135                 JSA1212_CONF_ALS_MASK,
0136                 status);
0137     if (ret < 0)
0138         return ret;
0139
0140     data->als_en = !!status;
0141
0142     return 0;
0143 }
0144
0145 /* Enables or disables PXS function based on status */
0146 static int jsa1212_pxs_enable(struct jsa1212_data *data, u8 status)
0147 {
0148     int ret;
0149
0150     ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
0151                 JSA1212_CONF_PXS_MASK,
0152                 status);
0153     if (ret < 0)
0154         return ret;
0155
0156     data->pxs_en = !!status;
0157
0158     return 0;
0159 }
0160
0161 static int jsa1212_read_als_data(struct jsa1212_data *data,
0162                 unsigned int *val)
0163 {
0164     int ret;
0165     __le16 als_data;
0166
0167     ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE);
0168     if (ret < 0)
0169         return ret;
0170
0171     /* Delay for data output */
0172     msleep(JSA1212_ALS_DELAY_MS);
0173
0174     /* Read 12 bit data */
0175     ret = regmap_bulk_read(data->regmap, JSA1212_ALS_DT1_REG, &als_data, 2);
0176     if (ret < 0) {
0177         dev_err(&data->client->dev, "als data read err\n");
0178         goto als_data_read_err;
0179     }
0180
0181     *val = le16_to_cpu(als_data);
0182
0183 als_data_read_err:
0184     return jsa1212_als_enable(data, JSA1212_CONF_ALS_DISABLE);
0185 }
0186
0187 static int jsa1212_read_pxs_data(struct jsa1212_data *data,
0188                 unsigned int *val)
0189 {
0190     int ret;
0191     unsigned int pxs_data;
0192
0193     ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE);
0194     if (ret < 0)
0195         return ret;
0196
0197     /* Delay for data output */
0198     msleep(JSA1212_PXS_DELAY_MS);
0199
0200     /* Read out all data */
0201     ret = regmap_read(data->regmap, JSA1212_PXS_DATA_REG, &pxs_data);
0202     if (ret < 0) {
0203         dev_err(&data->client->dev, "pxs data read err\n");
0204         goto pxs_data_read_err;
0205     }
0206
0207     *val = pxs_data & JSA1212_PXS_DATA_MASK;
0208
0209 pxs_data_read_err:
0210     return jsa1212_pxs_enable(data, JSA1212_CONF_PXS_DISABLE);
0211 }
0212
0213 static int jsa1212_read_raw(struct iio_dev *indio_dev,
0214                 struct iio_chan_spec const *chan,
0215                 int *val, int *val2, long mask)
0216 {
0217     int ret;
0218     struct jsa1212_data *data = iio_priv(indio_dev);
0219
0220     switch (mask) {
0221     case IIO_CHAN_INFO_RAW:
0222         mutex_lock(&data->lock);
0223         switch (chan->type) {
0224         case IIO_LIGHT:
0225             ret = jsa1212_read_als_data(data, val);
0226             break;
0227         case IIO_PROXIMITY:
0228             ret = jsa1212_read_pxs_data(data, val);
0229             break;
0230         default:
0231             ret = -EINVAL;
0232             break;
0233         }
0234         mutex_unlock(&data->lock);
0235         return ret < 0 ? ret : IIO_VAL_INT;
0236     case IIO_CHAN_INFO_SCALE:
0237         switch (chan->type) {
0238         case IIO_LIGHT:
0239             *val = jsa1212_als_range_val[data->als_rng_idx];
0240             *val2 = BIT(12); /* Max 12 bit value */
0241             return IIO_VAL_FRACTIONAL;
0242         default:
0243             break;
0244         }
0245         break;
0246     default:
0247         break;
0248     }
0249
0250     return -EINVAL;
0251 }
0252
0253 static const struct iio_chan_spec jsa1212_channels[] = {
0254     {
0255         .type = IIO_LIGHT,
0256         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
0257             BIT(IIO_CHAN_INFO_SCALE),
0258     },
0259     {
0260         .type = IIO_PROXIMITY,
0261         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0262     }
0263 };
0264
0265 static const struct iio_info jsa1212_info = {
0266     .read_raw       = &jsa1212_read_raw,
0267 };
0268
0269 static int jsa1212_chip_init(struct jsa1212_data *data)
0270 {
0271     int ret;
0272
0273     ret = regmap_write(data->regmap, JSA1212_CONF_REG,
0274                 (JSA1212_CONF_PXS_SLP_50MS |
0275                 JSA1212_CONF_IRDR_200MA));
0276     if (ret < 0)
0277         return ret;
0278
0279     ret = regmap_write(data->regmap, JSA1212_INT_REG,
0280                 JSA1212_INT_ALS_PRST_4CONV);
0281     if (ret < 0)
0282         return ret;
0283
0284     data->als_rng_idx = JSA1212_ALS_RNG_0_2048;
0285
0286     return 0;
0287 }
0288
0289 static bool jsa1212_is_volatile_reg(struct device *dev, unsigned int reg)
0290 {
0291     switch (reg) {
0292     case JSA1212_PXS_DATA_REG:
0293     case JSA1212_ALS_DT1_REG:
0294     case JSA1212_ALS_DT2_REG:
0295     case JSA1212_INT_REG:
0296         return true;
0297     default:
0298         return false;
0299     }
0300 }
0301
0302 static const struct regmap_config jsa1212_regmap_config = {
0303     .name =  JSA1212_REGMAP_NAME,
0304     .reg_bits = 8,
0305     .val_bits = 8,
0306     .max_register = JSA1212_MAX_REG,
0307     .cache_type = REGCACHE_RBTREE,
0308     .volatile_reg = jsa1212_is_volatile_reg,
0309 };
0310
0311 static int jsa1212_probe(struct i2c_client *client,
0312              const struct i2c_device_id *id)
0313 {
0314     struct jsa1212_data *data;
0315     struct iio_dev *indio_dev;
0316     struct regmap *regmap;
0317     int ret;
0318
0319     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0320     if (!indio_dev)
0321         return -ENOMEM;
0322
0323     regmap = devm_regmap_init_i2c(client, &jsa1212_regmap_config);
0324     if (IS_ERR(regmap)) {
0325         dev_err(&client->dev, "Regmap initialization failed.\n");
0326         return PTR_ERR(regmap);
0327     }
0328
0329     data = iio_priv(indio_dev);
0330
0331     i2c_set_clientdata(client, indio_dev);
0332     data->client = client;
0333     data->regmap = regmap;
0334
0335     mutex_init(&data->lock);
0336
0337     ret = jsa1212_chip_init(data);
0338     if (ret < 0)
0339         return ret;
0340
0341     indio_dev->channels = jsa1212_channels;
0342     indio_dev->num_channels = ARRAY_SIZE(jsa1212_channels);
0343     indio_dev->name = JSA1212_DRIVER_NAME;
0344     indio_dev->modes = INDIO_DIRECT_MODE;
0345
0346     indio_dev->info = &jsa1212_info;
0347
0348     ret = iio_device_register(indio_dev);
0349     if (ret < 0)
0350         dev_err(&client->dev, "%s: register device failed\n", __func__);
0351
0352     return ret;
0353 }
0354
0355  /* power off the device */
0356 static int jsa1212_power_off(struct jsa1212_data *data)
0357 {
0358     int ret;
0359
0360     mutex_lock(&data->lock);
0361
0362     ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG,
0363                 JSA1212_CONF_ALS_MASK |
0364                 JSA1212_CONF_PXS_MASK,
0365                 JSA1212_CONF_ALS_DISABLE |
0366                 JSA1212_CONF_PXS_DISABLE);
0367
0368     if (ret < 0)
0369         dev_err(&data->client->dev, "power off cmd failed\n");
0370
0371     mutex_unlock(&data->lock);
0372
0373     return ret;
0374 }
0375
0376 static int jsa1212_remove(struct i2c_client *client)
0377 {
0378     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0379     struct jsa1212_data *data = iio_priv(indio_dev);
0380
0381     iio_device_unregister(indio_dev);
0382
0383     jsa1212_power_off(data);
0384
0385     return 0;
0386 }
0387
0388 static int jsa1212_suspend(struct device *dev)
0389 {
0390     struct jsa1212_data *data;
0391
0392     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0393
0394     return jsa1212_power_off(data);
0395 }
0396
0397 static int jsa1212_resume(struct device *dev)
0398 {
0399     int ret = 0;
0400     struct jsa1212_data *data;
0401
0402     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0403
0404     mutex_lock(&data->lock);
0405
0406     if (data->als_en) {
0407         ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE);
0408         if (ret < 0) {
0409             dev_err(dev, "als resume failed\n");
0410             goto unlock_and_ret;
0411         }
0412     }
0413
0414     if (data->pxs_en) {
0415         ret = jsa1212_pxs_enable(data, JSA1212_CONF_PXS_ENABLE);
0416         if (ret < 0)
0417             dev_err(dev, "pxs resume failed\n");
0418     }
0419
0420 unlock_and_ret:
0421     mutex_unlock(&data->lock);
0422     return ret;
0423 }
0424
0425 static DEFINE_SIMPLE_DEV_PM_OPS(jsa1212_pm_ops, jsa1212_suspend,
0426                 jsa1212_resume);
0427
0428 static const struct acpi_device_id jsa1212_acpi_match[] = {
0429     {"JSA1212", 0},
0430     { },
0431 };
0432 MODULE_DEVICE_TABLE(acpi, jsa1212_acpi_match);
0433
0434 static const struct i2c_device_id jsa1212_id[] = {
0435     { JSA1212_DRIVER_NAME, 0 },
0436     { }
0437 };
0438 MODULE_DEVICE_TABLE(i2c, jsa1212_id);
0439
0440 static struct i2c_driver jsa1212_driver = {
0441     .driver = {
0442         .name   = JSA1212_DRIVER_NAME,
0443         .pm = pm_sleep_ptr(&jsa1212_pm_ops),
0444         .acpi_match_table = ACPI_PTR(jsa1212_acpi_match),
0445     },
0446     .probe      = jsa1212_probe,
0447     .remove     = jsa1212_remove,
0448     .id_table   = jsa1212_id,
0449 };
0450 module_i2c_driver(jsa1212_driver);
0451
0452 MODULE_AUTHOR("Sathya Kuppuswamy <sathyanarayanan.kuppuswamy@linux.intel.com>");
0453 MODULE_DESCRIPTION("JSA1212 proximity/ambient light sensor driver");
0454 MODULE_LICENSE("GPL v2");