drivers/iio/light/al3320a.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AL3320A - Dyna Image Ambient Light Sensor
   4  *
   5  * Copyright (c) 2014, Intel Corporation.
   6  *
   7  * IIO driver for AL3320A (7-bit I2C slave address 0x1C).
   8  *
   9  * TODO: interrupt support, thresholds
  10  * When the driver will get support for interrupt handling, then interrupt
  11  * will need to be disabled before turning sensor OFF in order to avoid
  12  * potential races with the interrupt handling.
  13  */
  14
  15 #include <linux/bitfield.h>
  16 #include <linux/i2c.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/mod_devicetable.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23
  24 #define AL3320A_DRV_NAME "al3320a"
  25
  26 #define AL3320A_REG_CONFIG              0x00
  27 #define AL3320A_REG_STATUS              0x01
  28 #define AL3320A_REG_INT                 0x02
  29 #define AL3320A_REG_WAIT                0x06
  30 #define AL3320A_REG_CONFIG_RANGE        0x07
  31 #define AL3320A_REG_PERSIST             0x08
  32 #define AL3320A_REG_MEAN_TIME           0x09
  33 #define AL3320A_REG_ADUMMY              0x0A
  34 #define AL3320A_REG_DATA_LOW            0x22
  35
  36 #define AL3320A_REG_LOW_THRESH_LOW      0x30
  37 #define AL3320A_REG_LOW_THRESH_HIGH     0x31
  38 #define AL3320A_REG_HIGH_THRESH_LOW     0x32
  39 #define AL3320A_REG_HIGH_THRESH_HIGH    0x33
  40
  41 #define AL3320A_CONFIG_DISABLE          0x00
  42 #define AL3320A_CONFIG_ENABLE           0x01
  43
  44 #define AL3320A_GAIN_MASK               GENMASK(2, 1)
  45
  46 /* chip params default values */
  47 #define AL3320A_DEFAULT_MEAN_TIME       4
  48 #define AL3320A_DEFAULT_WAIT_TIME       0 /* no waiting */
  49
  50 #define AL3320A_SCALE_AVAILABLE "0.512 0.128 0.032 0.01"
  51
  52 enum al3320a_range {
  53         AL3320A_RANGE_1, /* 33.28 Klx */
  54         AL3320A_RANGE_2, /* 8.32 Klx  */
  55         AL3320A_RANGE_3, /* 2.08 Klx  */
  56         AL3320A_RANGE_4  /* 0.65 Klx  */
  57 };
  58
  59 static const int al3320a_scales[][2] = {
  60         {0, 512000}, {0, 128000}, {0, 32000}, {0, 10000}
  61 };
  62
  63 struct al3320a_data {
  64         struct i2c_client *client;
  65 };
  66
  67 static const struct iio_chan_spec al3320a_channels[] = {
  68         {
  69                 .type   = IIO_LIGHT,
  70                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  71                                       BIT(IIO_CHAN_INFO_SCALE),
  72         }
  73 };
  74
  75 static IIO_CONST_ATTR(in_illuminance_scale_available, AL3320A_SCALE_AVAILABLE);
  76
  77 static struct attribute *al3320a_attributes[] = {
  78         &iio_const_attr_in_illuminance_scale_available.dev_attr.attr,
  79         NULL,
  80 };
  81
  82 static const struct attribute_group al3320a_attribute_group = {
  83         .attrs = al3320a_attributes,
  84 };
  85
  86 static int al3320a_set_pwr(struct i2c_client *client, bool pwr)
  87 {
  88         u8 val = pwr ? AL3320A_CONFIG_ENABLE : AL3320A_CONFIG_DISABLE;
  89         return i2c_smbus_write_byte_data(client, AL3320A_REG_CONFIG, val);
  90 }
  91
  92 static void al3320a_set_pwr_off(void *_data)
  93 {
  94         struct al3320a_data *data = _data;
  95
  96         al3320a_set_pwr(data->client, false);
  97 }
  98
  99 static int al3320a_init(struct al3320a_data *data)
 100 {
 101         int ret;
 102
 103         ret = al3320a_set_pwr(data->client, true);
 104
 105         if (ret < 0)
 106                 return ret;
 107
 108         ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_CONFIG_RANGE,
 109                                         FIELD_PREP(AL3320A_GAIN_MASK,
 110                                                    AL3320A_RANGE_3));
 111         if (ret < 0)
 112                 return ret;
 113
 114         ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_MEAN_TIME,
 115                                         AL3320A_DEFAULT_MEAN_TIME);
 116         if (ret < 0)
 117                 return ret;
 118
 119         ret = i2c_smbus_write_byte_data(data->client, AL3320A_REG_WAIT,
 120                                         AL3320A_DEFAULT_WAIT_TIME);
 121         if (ret < 0)
 122                 return ret;
 123
 124         return 0;
 125 }
 126
 127 static int al3320a_read_raw(struct iio_dev *indio_dev,
 128                             struct iio_chan_spec const *chan, int *val,
 129                             int *val2, long mask)
 130 {
 131         struct al3320a_data *data = iio_priv(indio_dev);
 132         int ret;
 133
 134         switch (mask) {
 135         case IIO_CHAN_INFO_RAW:
 136                 /*
 137                  * ALS ADC value is stored in two adjacent registers:
 138                  * - low byte of output is stored at AL3320A_REG_DATA_LOW
 139                  * - high byte of output is stored at AL3320A_REG_DATA_LOW + 1
 140                  */
 141                 ret = i2c_smbus_read_word_data(data->client,
 142                                                AL3320A_REG_DATA_LOW);
 143                 if (ret < 0)
 144                         return ret;
 145                 *val = ret;
 146                 return IIO_VAL_INT;
 147         case IIO_CHAN_INFO_SCALE:
 148                 ret = i2c_smbus_read_byte_data(data->client,
 149                                                AL3320A_REG_CONFIG_RANGE);
 150                 if (ret < 0)
 151                         return ret;
 152
 153                 ret = FIELD_GET(AL3320A_GAIN_MASK, ret);
 154                 *val = al3320a_scales[ret][0];
 155                 *val2 = al3320a_scales[ret][1];
 156
 157                 return IIO_VAL_INT_PLUS_MICRO;
 158         }
 159         return -EINVAL;
 160 }
 161
 162 static int al3320a_write_raw(struct iio_dev *indio_dev,
 163                              struct iio_chan_spec const *chan, int val,
 164                              int val2, long mask)
 165 {
 166         struct al3320a_data *data = iio_priv(indio_dev);
 167         int i;
 168
 169         switch (mask) {
 170         case IIO_CHAN_INFO_SCALE:
 171                 for (i = 0; i < ARRAY_SIZE(al3320a_scales); i++) {
 172                         if (val != al3320a_scales[i][0] ||
 173                             val2 != al3320a_scales[i][1])
 174                                 continue;
 175
 176                         return i2c_smbus_write_byte_data(data->client,
 177                                         AL3320A_REG_CONFIG_RANGE,
 178                                         FIELD_PREP(AL3320A_GAIN_MASK, i));
 179                 }
 180                 break;
 181         }
 182         return -EINVAL;
 183 }
 184
 185 static const struct iio_info al3320a_info = {
 186         .read_raw       = al3320a_read_raw,
 187         .write_raw      = al3320a_write_raw,
 188         .attrs          = &al3320a_attribute_group,
 189 };
 190
 191 static int al3320a_probe(struct i2c_client *client)
 192 {
 193         struct al3320a_data *data;
 194         struct iio_dev *indio_dev;
 195         int ret;
 196
 197         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 198         if (!indio_dev)
 199                 return -ENOMEM;
 200
 201         data = iio_priv(indio_dev);
 202         i2c_set_clientdata(client, indio_dev);
 203         data->client = client;
 204
 205         indio_dev->info = &al3320a_info;
 206         indio_dev->name = AL3320A_DRV_NAME;
 207         indio_dev->channels = al3320a_channels;
 208         indio_dev->num_channels = ARRAY_SIZE(al3320a_channels);
 209         indio_dev->modes = INDIO_DIRECT_MODE;
 210
 211         ret = al3320a_init(data);
 212         if (ret < 0) {
 213                 dev_err(&client->dev, "al3320a chip init failed\n");
 214                 return ret;
 215         }
 216
 217         ret = devm_add_action_or_reset(&client->dev,
 218                                         al3320a_set_pwr_off,
 219                                         data);
 220         if (ret < 0)
 221                 return ret;
 222
 223         return devm_iio_device_register(&client->dev, indio_dev);
 224 }
 225
 226 static int al3320a_suspend(struct device *dev)
 227 {
 228         return al3320a_set_pwr(to_i2c_client(dev), false);
 229 }
 230
 231 static int al3320a_resume(struct device *dev)
 232 {
 233         return al3320a_set_pwr(to_i2c_client(dev), true);
 234 }
 235
 236 static DEFINE_SIMPLE_DEV_PM_OPS(al3320a_pm_ops, al3320a_suspend,
 237                                 al3320a_resume);
 238
 239 static const struct i2c_device_id al3320a_id[] = {
 240         {"al3320a", 0},
 241         {}
 242 };
 243 MODULE_DEVICE_TABLE(i2c, al3320a_id);
 244
 245 static const struct of_device_id al3320a_of_match[] = {
 246         { .compatible = "dynaimage,al3320a", },
 247         {},
 248 };
 249 MODULE_DEVICE_TABLE(of, al3320a_of_match);
 250
 251 static const struct acpi_device_id al3320a_acpi_match[] = {
 252         {"CALS0001"},
 253         { },
 254 };
 255 MODULE_DEVICE_TABLE(acpi, al3320a_acpi_match);
 256
 257 static struct i2c_driver al3320a_driver = {
 258         .driver = {
 259                 .name = AL3320A_DRV_NAME,
 260                 .of_match_table = al3320a_of_match,
 261                 .pm = pm_sleep_ptr(&al3320a_pm_ops),
 262                 .acpi_match_table = al3320a_acpi_match,
 263         },
 264         .probe          = al3320a_probe,
 265         .id_table       = al3320a_id,
 266 };
 267
 268 module_i2c_driver(al3320a_driver);
 269
 270 MODULE_AUTHOR("Daniel Baluta <[email protected]>");
 271 MODULE_DESCRIPTION("AL3320A Ambient Light Sensor driver");
 272 MODULE_LICENSE("GPL v2");