1 /* 2 * apds9300.c - IIO driver for Avago APDS9300 ambient light sensor 3 * 4 * Copyright 2013 Oleksandr Kravchenko <o.v.kravchenko@globallogic.com> 5 * 6 * This file is subject to the terms and conditions of version 2 of 7 * the GNU General Public License. See the file COPYING in the main 8 * directory of this archive for more details. 9 */ 10 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/pm.h> 14 #include <linux/i2c.h> 15 #include <linux/err.h> 16 #include <linux/mutex.h> 17 #include <linux/interrupt.h> 18 #include <linux/iio/iio.h> 19 #include <linux/iio/sysfs.h> 20 #include <linux/iio/events.h> 21 22 #define APDS9300_DRV_NAME "apds9300" 23 #define APDS9300_IRQ_NAME "apds9300_event" 24 25 /* Command register bits */ 26 #define APDS9300_CMD BIT(7) /* Select command register. Must write as 1 */ 27 #define APDS9300_WORD BIT(5) /* I2C write/read: if 1 word, if 0 byte */ 28 #define APDS9300_CLEAR BIT(6) /* Interrupt clear. Clears pending interrupt */ 29 30 /* Register set */ 31 #define APDS9300_CONTROL 0x00 /* Control of basic functions */ 32 #define APDS9300_THRESHLOWLOW 0x02 /* Low byte of low interrupt threshold */ 33 #define APDS9300_THRESHHIGHLOW 0x04 /* Low byte of high interrupt threshold */ 34 #define APDS9300_INTERRUPT 0x06 /* Interrupt control */ 35 #define APDS9300_DATA0LOW 0x0c /* Low byte of ADC channel 0 */ 36 #define APDS9300_DATA1LOW 0x0e /* Low byte of ADC channel 1 */ 37 38 /* Power on/off value for APDS9300_CONTROL register */ 39 #define APDS9300_POWER_ON 0x03 40 #define APDS9300_POWER_OFF 0x00 41 42 /* Interrupts */ 43 #define APDS9300_INTR_ENABLE 0x10 44 /* Interrupt Persist Function: Any value outside of threshold range */ 45 #define APDS9300_THRESH_INTR 0x01 46 47 #define APDS9300_THRESH_MAX 0xffff /* Max threshold value */ 48 49 struct apds9300_data { 50 struct i2c_client *client; 51 struct mutex mutex; 52 int power_state; 53 int thresh_low; 54 int thresh_hi; 55 int intr_en; 56 }; 57 58 /* Lux calculation */ 59 60 /* Calculated values 1000 * (CH1/CH0)^1.4 for CH1/CH0 from 0 to 0.52 */ 61 static const u16 apds9300_lux_ratio[] = { 62 0, 2, 4, 7, 11, 15, 19, 24, 29, 34, 40, 45, 51, 57, 64, 70, 77, 84, 91, 63 98, 105, 112, 120, 128, 136, 144, 152, 160, 168, 177, 185, 194, 203, 64 212, 221, 230, 239, 249, 258, 268, 277, 287, 297, 307, 317, 327, 337, 65 347, 358, 368, 379, 390, 400, 66 }; 67 68 static unsigned long apds9300_calculate_lux(u16 ch0, u16 ch1) 69 { 70 unsigned long lux, tmp; 71 72 /* avoid division by zero */ 73 if (ch0 == 0) 74 return 0; 75 76 tmp = DIV_ROUND_UP(ch1 * 100, ch0); 77 if (tmp <= 52) { 78 lux = 3150 * ch0 - (unsigned long)DIV_ROUND_UP_ULL(ch0 79 * apds9300_lux_ratio[tmp] * 5930ull, 1000); 80 } else if (tmp <= 65) { 81 lux = 2290 * ch0 - 2910 * ch1; 82 } else if (tmp <= 80) { 83 lux = 1570 * ch0 - 1800 * ch1; 84 } else if (tmp <= 130) { 85 lux = 338 * ch0 - 260 * ch1; 86 } else { 87 lux = 0; 88 } 89 90 return lux / 100000; 91 } 92 93 static int apds9300_get_adc_val(struct apds9300_data *data, int adc_number) 94 { 95 int ret; 96 u8 flags = APDS9300_CMD | APDS9300_WORD; 97 98 if (!data->power_state) 99 return -EBUSY; 100 101 /* Select ADC0 or ADC1 data register */ 102 flags |= adc_number ? APDS9300_DATA1LOW : APDS9300_DATA0LOW; 103 104 ret = i2c_smbus_read_word_data(data->client, flags); 105 if (ret < 0) 106 dev_err(&data->client->dev, 107 "failed to read ADC%d value\n", adc_number); 108 109 return ret; 110 } 111 112 static int apds9300_set_thresh_low(struct apds9300_data *data, int value) 113 { 114 int ret; 115 116 if (!data->power_state) 117 return -EBUSY; 118 119 if (value > APDS9300_THRESH_MAX) 120 return -EINVAL; 121 122 ret = i2c_smbus_write_word_data(data->client, APDS9300_THRESHLOWLOW 123 | APDS9300_CMD | APDS9300_WORD, value); 124 if (ret) { 125 dev_err(&data->client->dev, "failed to set thresh_low\n"); 126 return ret; 127 } 128 data->thresh_low = value; 129 130 return 0; 131 } 132 133 static int apds9300_set_thresh_hi(struct apds9300_data *data, int value) 134 { 135 int ret; 136 137 if (!data->power_state) 138 return -EBUSY; 139 140 if (value > APDS9300_THRESH_MAX) 141 return -EINVAL; 142 143 ret = i2c_smbus_write_word_data(data->client, APDS9300_THRESHHIGHLOW 144 | APDS9300_CMD | APDS9300_WORD, value); 145 if (ret) { 146 dev_err(&data->client->dev, "failed to set thresh_hi\n"); 147 return ret; 148 } 149 data->thresh_hi = value; 150 151 return 0; 152 } 153 154 static int apds9300_set_intr_state(struct apds9300_data *data, int state) 155 { 156 int ret; 157 u8 cmd; 158 159 if (!data->power_state) 160 return -EBUSY; 161 162 cmd = state ? APDS9300_INTR_ENABLE | APDS9300_THRESH_INTR : 0x00; 163 ret = i2c_smbus_write_byte_data(data->client, 164 APDS9300_INTERRUPT | APDS9300_CMD, cmd); 165 if (ret) { 166 dev_err(&data->client->dev, 167 "failed to set interrupt state %d\n", state); 168 return ret; 169 } 170 data->intr_en = state; 171 172 return 0; 173 } 174 175 static int apds9300_set_power_state(struct apds9300_data *data, int state) 176 { 177 int ret; 178 u8 cmd; 179 180 cmd = state ? APDS9300_POWER_ON : APDS9300_POWER_OFF; 181 ret = i2c_smbus_write_byte_data(data->client, 182 APDS9300_CONTROL | APDS9300_CMD, cmd); 183 if (ret) { 184 dev_err(&data->client->dev, 185 "failed to set power state %d\n", state); 186 return ret; 187 } 188 data->power_state = state; 189 190 return 0; 191 } 192 193 static void apds9300_clear_intr(struct apds9300_data *data) 194 { 195 int ret; 196 197 ret = i2c_smbus_write_byte(data->client, APDS9300_CLEAR | APDS9300_CMD); 198 if (ret < 0) 199 dev_err(&data->client->dev, "failed to clear interrupt\n"); 200 } 201 202 static int apds9300_chip_init(struct apds9300_data *data) 203 { 204 int ret; 205 206 /* Need to set power off to ensure that the chip is off */ 207 ret = apds9300_set_power_state(data, 0); 208 if (ret < 0) 209 goto err; 210 /* 211 * Probe the chip. To do so we try to power up the device and then to 212 * read back the 0x03 code 213 */ 214 ret = apds9300_set_power_state(data, 1); 215 if (ret < 0) 216 goto err; 217 ret = i2c_smbus_read_byte_data(data->client, 218 APDS9300_CONTROL | APDS9300_CMD); 219 if (ret != APDS9300_POWER_ON) { 220 ret = -ENODEV; 221 goto err; 222 } 223 /* 224 * Disable interrupt to ensure thai it is doesn't enable 225 * i.e. after device soft reset 226 */ 227 ret = apds9300_set_intr_state(data, 0); 228 if (ret < 0) 229 goto err; 230 231 return 0; 232 233 err: 234 dev_err(&data->client->dev, "failed to init the chip\n"); 235 return ret; 236 } 237 238 static int apds9300_read_raw(struct iio_dev *indio_dev, 239 struct iio_chan_spec const *chan, int *val, int *val2, 240 long mask) 241 { 242 int ch0, ch1, ret = -EINVAL; 243 struct apds9300_data *data = iio_priv(indio_dev); 244 245 mutex_lock(&data->mutex); 246 switch (chan->type) { 247 case IIO_LIGHT: 248 ch0 = apds9300_get_adc_val(data, 0); 249 if (ch0 < 0) { 250 ret = ch0; 251 break; 252 } 253 ch1 = apds9300_get_adc_val(data, 1); 254 if (ch1 < 0) { 255 ret = ch1; 256 break; 257 } 258 *val = apds9300_calculate_lux(ch0, ch1); 259 ret = IIO_VAL_INT; 260 break; 261 case IIO_INTENSITY: 262 ret = apds9300_get_adc_val(data, chan->channel); 263 if (ret < 0) 264 break; 265 *val = ret; 266 ret = IIO_VAL_INT; 267 break; 268 default: 269 break; 270 } 271 mutex_unlock(&data->mutex); 272 273 return ret; 274 } 275 276 static int apds9300_read_thresh(struct iio_dev *indio_dev, u64 event_code, 277 int *val) 278 { 279 struct apds9300_data *data = iio_priv(indio_dev); 280 281 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) { 282 case IIO_EV_DIR_RISING: 283 *val = data->thresh_hi; 284 break; 285 case IIO_EV_DIR_FALLING: 286 *val = data->thresh_low; 287 break; 288 default: 289 return -EINVAL; 290 } 291 292 return 0; 293 } 294 295 static int apds9300_write_thresh(struct iio_dev *indio_dev, u64 event_code, 296 int val) 297 { 298 struct apds9300_data *data = iio_priv(indio_dev); 299 int ret; 300 301 mutex_lock(&data->mutex); 302 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_RISING) 303 ret = apds9300_set_thresh_hi(data, val); 304 else 305 ret = apds9300_set_thresh_low(data, val); 306 mutex_unlock(&data->mutex); 307 308 return ret; 309 } 310 311 static int apds9300_read_interrupt_config(struct iio_dev *indio_dev, 312 u64 event_code) 313 { 314 struct apds9300_data *data = iio_priv(indio_dev); 315 316 return data->intr_en; 317 } 318 319 static int apds9300_write_interrupt_config(struct iio_dev *indio_dev, 320 u64 event_code, int state) 321 { 322 struct apds9300_data *data = iio_priv(indio_dev); 323 int ret; 324 325 mutex_lock(&data->mutex); 326 ret = apds9300_set_intr_state(data, state); 327 mutex_unlock(&data->mutex); 328 329 return ret; 330 } 331 332 static const struct iio_info apds9300_info_no_irq = { 333 .driver_module = THIS_MODULE, 334 .read_raw = apds9300_read_raw, 335 }; 336 337 static const struct iio_info apds9300_info = { 338 .driver_module = THIS_MODULE, 339 .read_raw = apds9300_read_raw, 340 .read_event_value = apds9300_read_thresh, 341 .write_event_value = apds9300_write_thresh, 342 .read_event_config = apds9300_read_interrupt_config, 343 .write_event_config = apds9300_write_interrupt_config, 344 }; 345 346 static const struct iio_chan_spec apds9300_channels[] = { 347 { 348 .type = IIO_LIGHT, 349 .channel = 0, 350 .indexed = true, 351 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 352 }, { 353 .type = IIO_INTENSITY, 354 .channel = 0, 355 .channel2 = IIO_MOD_LIGHT_BOTH, 356 .indexed = true, 357 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 358 .event_mask = (IIO_EV_BIT(IIO_EV_TYPE_THRESH, 359 IIO_EV_DIR_RISING) | 360 IIO_EV_BIT(IIO_EV_TYPE_THRESH, 361 IIO_EV_DIR_FALLING)), 362 }, { 363 .type = IIO_INTENSITY, 364 .channel = 1, 365 .channel2 = IIO_MOD_LIGHT_IR, 366 .indexed = true, 367 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 368 }, 369 }; 370 371 static irqreturn_t apds9300_interrupt_handler(int irq, void *private) 372 { 373 struct iio_dev *dev_info = private; 374 struct apds9300_data *data = iio_priv(dev_info); 375 376 iio_push_event(dev_info, 377 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0, 378 IIO_EV_TYPE_THRESH, 379 IIO_EV_DIR_EITHER), 380 iio_get_time_ns()); 381 382 apds9300_clear_intr(data); 383 384 return IRQ_HANDLED; 385 } 386 387 static int apds9300_probe(struct i2c_client *client, 388 const struct i2c_device_id *id) 389 { 390 struct apds9300_data *data; 391 struct iio_dev *indio_dev; 392 int ret; 393 394 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 395 if (!indio_dev) 396 return -ENOMEM; 397 398 data = iio_priv(indio_dev); 399 i2c_set_clientdata(client, indio_dev); 400 data->client = client; 401 402 ret = apds9300_chip_init(data); 403 if (ret < 0) 404 goto err; 405 406 mutex_init(&data->mutex); 407 408 indio_dev->dev.parent = &client->dev; 409 indio_dev->channels = apds9300_channels; 410 indio_dev->num_channels = ARRAY_SIZE(apds9300_channels); 411 indio_dev->name = APDS9300_DRV_NAME; 412 indio_dev->modes = INDIO_DIRECT_MODE; 413 414 if (client->irq) 415 indio_dev->info = &apds9300_info; 416 else 417 indio_dev->info = &apds9300_info_no_irq; 418 419 if (client->irq) { 420 ret = devm_request_threaded_irq(&client->dev, client->irq, 421 NULL, apds9300_interrupt_handler, 422 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 423 APDS9300_IRQ_NAME, indio_dev); 424 if (ret) { 425 dev_err(&client->dev, "irq request error %d\n", -ret); 426 goto err; 427 } 428 } 429 430 ret = iio_device_register(indio_dev); 431 if (ret < 0) 432 goto err; 433 434 return 0; 435 436 err: 437 /* Ensure that power off in case of error */ 438 apds9300_set_power_state(data, 0); 439 return ret; 440 } 441 442 static int apds9300_remove(struct i2c_client *client) 443 { 444 struct iio_dev *indio_dev = i2c_get_clientdata(client); 445 struct apds9300_data *data = iio_priv(indio_dev); 446 447 iio_device_unregister(indio_dev); 448 449 /* Ensure that power off and interrupts are disabled */ 450 apds9300_set_intr_state(data, 0); 451 apds9300_set_power_state(data, 0); 452 453 return 0; 454 } 455 456 #ifdef CONFIG_PM_SLEEP 457 static int apds9300_suspend(struct device *dev) 458 { 459 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 460 struct apds9300_data *data = iio_priv(indio_dev); 461 int ret; 462 463 mutex_lock(&data->mutex); 464 ret = apds9300_set_power_state(data, 0); 465 mutex_unlock(&data->mutex); 466 467 return ret; 468 } 469 470 static int apds9300_resume(struct device *dev) 471 { 472 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 473 struct apds9300_data *data = iio_priv(indio_dev); 474 int ret; 475 476 mutex_lock(&data->mutex); 477 ret = apds9300_set_power_state(data, 1); 478 mutex_unlock(&data->mutex); 479 480 return ret; 481 } 482 483 static SIMPLE_DEV_PM_OPS(apds9300_pm_ops, apds9300_suspend, apds9300_resume); 484 #define APDS9300_PM_OPS (&apds9300_pm_ops) 485 #else 486 #define APDS9300_PM_OPS NULL 487 #endif 488 489 static struct i2c_device_id apds9300_id[] = { 490 { APDS9300_DRV_NAME, 0 }, 491 { } 492 }; 493 494 MODULE_DEVICE_TABLE(i2c, apds9300_id); 495 496 static struct i2c_driver apds9300_driver = { 497 .driver = { 498 .name = APDS9300_DRV_NAME, 499 .owner = THIS_MODULE, 500 .pm = APDS9300_PM_OPS, 501 }, 502 .probe = apds9300_probe, 503 .remove = apds9300_remove, 504 .id_table = apds9300_id, 505 }; 506 507 module_i2c_driver(apds9300_driver); 508 509 MODULE_AUTHOR("Kravchenko Oleksandr <o.v.kravchenko@globallogic.com>"); 510 MODULE_AUTHOR("GlobalLogic inc."); 511 MODULE_DESCRIPTION("APDS9300 ambient light photo sensor driver"); 512 MODULE_LICENSE("GPL"); 513