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