1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Support for ON Semiconductor NOA1305 ambient light sensor 4 * 5 * Copyright (C) 2016 Emcraft Systems 6 * Copyright (C) 2019 Collabora Ltd. 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/err.h> 11 #include <linux/i2c.h> 12 #include <linux/iio/iio.h> 13 #include <linux/iio/sysfs.h> 14 #include <linux/module.h> 15 #include <linux/regmap.h> 16 #include <linux/regulator/consumer.h> 17 18 #define NOA1305_REG_POWER_CONTROL 0x0 19 #define NOA1305_POWER_CONTROL_DOWN 0x00 20 #define NOA1305_POWER_CONTROL_ON 0x08 21 #define NOA1305_REG_RESET 0x1 22 #define NOA1305_RESET_RESET 0x10 23 #define NOA1305_REG_INTEGRATION_TIME 0x2 24 #define NOA1305_INTEGR_TIME_800MS 0x00 25 #define NOA1305_INTEGR_TIME_400MS 0x01 26 #define NOA1305_INTEGR_TIME_200MS 0x02 27 #define NOA1305_INTEGR_TIME_100MS 0x03 28 #define NOA1305_INTEGR_TIME_50MS 0x04 29 #define NOA1305_INTEGR_TIME_25MS 0x05 30 #define NOA1305_INTEGR_TIME_12_5MS 0x06 31 #define NOA1305_INTEGR_TIME_6_25MS 0x07 32 #define NOA1305_INTEGR_TIME_MASK 0x07 33 #define NOA1305_REG_INT_SELECT 0x3 34 #define NOA1305_INT_SEL_ACTIVE_HIGH 0x01 35 #define NOA1305_INT_SEL_ACTIVE_LOW 0x02 36 #define NOA1305_INT_SEL_INACTIVE 0x03 37 #define NOA1305_REG_INT_THRESH_LSB 0x4 38 #define NOA1305_REG_INT_THRESH_MSB 0x5 39 #define NOA1305_REG_ALS_DATA_LSB 0x6 40 #define NOA1305_REG_ALS_DATA_MSB 0x7 41 #define NOA1305_REG_DEVICE_ID_LSB 0x8 42 #define NOA1305_REG_DEVICE_ID_MSB 0x9 43 44 #define NOA1305_DEVICE_ID 0x0519 45 #define NOA1305_DRIVER_NAME "noa1305" 46 47 static int noa1305_scale_available[] = { 48 100, 8 * 77, /* 800 ms */ 49 100, 4 * 77, /* 400 ms */ 50 100, 2 * 77, /* 200 ms */ 51 100, 1 * 77, /* 100 ms */ 52 1000, 5 * 77, /* 50 ms */ 53 10000, 25 * 77, /* 25 ms */ 54 100000, 125 * 77, /* 12.5 ms */ 55 1000000, 625 * 77, /* 6.25 ms */ 56 }; 57 58 static int noa1305_int_time_available[] = { 59 0, 800000, /* 800 ms */ 60 0, 400000, /* 400 ms */ 61 0, 200000, /* 200 ms */ 62 0, 100000, /* 100 ms */ 63 0, 50000, /* 50 ms */ 64 0, 25000, /* 25 ms */ 65 0, 12500, /* 12.5 ms */ 66 0, 6250, /* 6.25 ms */ 67 }; 68 69 struct noa1305_priv { 70 struct i2c_client *client; 71 struct regmap *regmap; 72 }; 73 74 static int noa1305_measure(struct noa1305_priv *priv, int *val) 75 { 76 __le16 data; 77 int ret; 78 79 ret = regmap_bulk_read(priv->regmap, NOA1305_REG_ALS_DATA_LSB, &data, 80 2); 81 if (ret < 0) 82 return ret; 83 84 *val = le16_to_cpu(data); 85 86 return IIO_VAL_INT; 87 } 88 89 static int noa1305_scale(struct noa1305_priv *priv, int *val, int *val2) 90 { 91 int data; 92 int ret; 93 94 ret = regmap_read(priv->regmap, NOA1305_REG_INTEGRATION_TIME, &data); 95 if (ret < 0) 96 return ret; 97 98 /* 99 * Lux = count / (<Integration Constant> * <Integration Time>) 100 * 101 * Integration Constant = 7.7 102 * Integration Time in Seconds 103 */ 104 data &= NOA1305_INTEGR_TIME_MASK; 105 *val = noa1305_scale_available[2 * data + 0]; 106 *val2 = noa1305_scale_available[2 * data + 1]; 107 108 return IIO_VAL_FRACTIONAL; 109 } 110 111 static int noa1305_int_time(struct noa1305_priv *priv, int *val, int *val2) 112 { 113 int data; 114 int ret; 115 116 ret = regmap_read(priv->regmap, NOA1305_REG_INTEGRATION_TIME, &data); 117 if (ret < 0) 118 return ret; 119 120 data &= NOA1305_INTEGR_TIME_MASK; 121 *val = noa1305_int_time_available[2 * data + 0]; 122 *val2 = noa1305_int_time_available[2 * data + 1]; 123 124 return IIO_VAL_INT_PLUS_MICRO; 125 } 126 127 static const struct iio_chan_spec noa1305_channels[] = { 128 { 129 .type = IIO_LIGHT, 130 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 131 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 132 .info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE), 133 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), 134 .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME), 135 } 136 }; 137 138 static int noa1305_read_avail(struct iio_dev *indio_dev, 139 struct iio_chan_spec const *chan, 140 const int **vals, int *type, 141 int *length, long mask) 142 { 143 if (chan->type != IIO_LIGHT) 144 return -EINVAL; 145 146 switch (mask) { 147 case IIO_CHAN_INFO_SCALE: 148 *vals = noa1305_scale_available; 149 *length = ARRAY_SIZE(noa1305_scale_available); 150 *type = IIO_VAL_FRACTIONAL; 151 return IIO_AVAIL_LIST; 152 case IIO_CHAN_INFO_INT_TIME: 153 *vals = noa1305_int_time_available; 154 *length = ARRAY_SIZE(noa1305_int_time_available); 155 *type = IIO_VAL_INT_PLUS_MICRO; 156 return IIO_AVAIL_LIST; 157 default: 158 return -EINVAL; 159 } 160 } 161 162 static int noa1305_read_raw(struct iio_dev *indio_dev, 163 struct iio_chan_spec const *chan, 164 int *val, int *val2, long mask) 165 { 166 struct noa1305_priv *priv = iio_priv(indio_dev); 167 168 if (chan->type != IIO_LIGHT) 169 return -EINVAL; 170 171 switch (mask) { 172 case IIO_CHAN_INFO_RAW: 173 return noa1305_measure(priv, val); 174 case IIO_CHAN_INFO_SCALE: 175 return noa1305_scale(priv, val, val2); 176 case IIO_CHAN_INFO_INT_TIME: 177 return noa1305_int_time(priv, val, val2); 178 default: 179 return -EINVAL; 180 } 181 } 182 183 static int noa1305_write_raw(struct iio_dev *indio_dev, 184 struct iio_chan_spec const *chan, 185 int val, int val2, long mask) 186 { 187 struct noa1305_priv *priv = iio_priv(indio_dev); 188 int i; 189 190 if (chan->type != IIO_LIGHT) 191 return -EINVAL; 192 193 if (mask != IIO_CHAN_INFO_INT_TIME) 194 return -EINVAL; 195 196 if (val) /* >= 1s integration time not supported */ 197 return -EINVAL; 198 199 /* Look up integration time register settings and write it if found. */ 200 for (i = 0; i < ARRAY_SIZE(noa1305_int_time_available) / 2; i++) 201 if (noa1305_int_time_available[2 * i + 1] == val2) 202 return regmap_write(priv->regmap, NOA1305_REG_INTEGRATION_TIME, i); 203 204 return -EINVAL; 205 } 206 207 static const struct iio_info noa1305_info = { 208 .read_avail = noa1305_read_avail, 209 .read_raw = noa1305_read_raw, 210 .write_raw = noa1305_write_raw, 211 }; 212 213 static bool noa1305_writable_reg(struct device *dev, unsigned int reg) 214 { 215 switch (reg) { 216 case NOA1305_REG_POWER_CONTROL: 217 case NOA1305_REG_RESET: 218 case NOA1305_REG_INTEGRATION_TIME: 219 case NOA1305_REG_INT_SELECT: 220 case NOA1305_REG_INT_THRESH_LSB: 221 case NOA1305_REG_INT_THRESH_MSB: 222 return true; 223 default: 224 return false; 225 } 226 } 227 228 static const struct regmap_config noa1305_regmap_config = { 229 .name = NOA1305_DRIVER_NAME, 230 .reg_bits = 8, 231 .val_bits = 8, 232 .max_register = NOA1305_REG_DEVICE_ID_MSB, 233 .writeable_reg = noa1305_writable_reg, 234 }; 235 236 static int noa1305_probe(struct i2c_client *client) 237 { 238 struct noa1305_priv *priv; 239 struct iio_dev *indio_dev; 240 struct regmap *regmap; 241 __le16 data; 242 unsigned int dev_id; 243 int ret; 244 245 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*priv)); 246 if (!indio_dev) 247 return -ENOMEM; 248 249 regmap = devm_regmap_init_i2c(client, &noa1305_regmap_config); 250 if (IS_ERR(regmap)) { 251 dev_err(&client->dev, "Regmap initialization failed.\n"); 252 return PTR_ERR(regmap); 253 } 254 255 priv = iio_priv(indio_dev); 256 257 ret = devm_regulator_get_enable(&client->dev, "vin"); 258 if (ret) 259 return dev_err_probe(&client->dev, ret, 260 "get regulator vin failed\n"); 261 262 i2c_set_clientdata(client, indio_dev); 263 priv->client = client; 264 priv->regmap = regmap; 265 266 ret = regmap_bulk_read(regmap, NOA1305_REG_DEVICE_ID_LSB, &data, 2); 267 if (ret < 0) { 268 dev_err(&client->dev, "ID reading failed: %d\n", ret); 269 return ret; 270 } 271 272 dev_id = le16_to_cpu(data); 273 if (dev_id != NOA1305_DEVICE_ID) { 274 dev_err(&client->dev, "Unknown device ID: 0x%x\n", dev_id); 275 return -ENODEV; 276 } 277 278 ret = regmap_write(regmap, NOA1305_REG_POWER_CONTROL, 279 NOA1305_POWER_CONTROL_ON); 280 if (ret < 0) { 281 dev_err(&client->dev, "Enabling power control failed\n"); 282 return ret; 283 } 284 285 ret = regmap_write(regmap, NOA1305_REG_RESET, NOA1305_RESET_RESET); 286 if (ret < 0) { 287 dev_err(&client->dev, "Device reset failed\n"); 288 return ret; 289 } 290 291 ret = regmap_write(regmap, NOA1305_REG_INTEGRATION_TIME, 292 NOA1305_INTEGR_TIME_800MS); 293 if (ret < 0) { 294 dev_err(&client->dev, "Setting integration time failed\n"); 295 return ret; 296 } 297 298 indio_dev->info = &noa1305_info; 299 indio_dev->channels = noa1305_channels; 300 indio_dev->num_channels = ARRAY_SIZE(noa1305_channels); 301 indio_dev->name = NOA1305_DRIVER_NAME; 302 indio_dev->modes = INDIO_DIRECT_MODE; 303 304 ret = devm_iio_device_register(&client->dev, indio_dev); 305 if (ret) 306 dev_err(&client->dev, "registering device failed\n"); 307 308 return ret; 309 } 310 311 static const struct of_device_id noa1305_of_match[] = { 312 { .compatible = "onnn,noa1305" }, 313 { } 314 }; 315 MODULE_DEVICE_TABLE(of, noa1305_of_match); 316 317 static const struct i2c_device_id noa1305_ids[] = { 318 { "noa1305" }, 319 { } 320 }; 321 MODULE_DEVICE_TABLE(i2c, noa1305_ids); 322 323 static struct i2c_driver noa1305_driver = { 324 .driver = { 325 .name = NOA1305_DRIVER_NAME, 326 .of_match_table = noa1305_of_match, 327 }, 328 .probe = noa1305_probe, 329 .id_table = noa1305_ids, 330 }; 331 332 module_i2c_driver(noa1305_driver); 333 334 MODULE_AUTHOR("Sergei Miroshnichenko <sergeimir@emcraft.com>"); 335 MODULE_AUTHOR("Martyn Welch <martyn.welch@collabora.com"); 336 MODULE_DESCRIPTION("ON Semiconductor NOA1305 ambient light sensor"); 337 MODULE_LICENSE("GPL"); 338