drivers/iio/light/bh1780.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ROHM 1780GLI Ambient Light Sensor Driver
   4  *
   5  * Copyright (C) 2016 Linaro Ltd.
   6  * Author: Linus Walleij <linus.walleij@linaro.org>
   7  * Loosely based on the previous BH1780 ALS misc driver
   8  * Copyright (C) 2010 Texas Instruments
   9  * Author: Hemanth V <hemanthv@ti.com>
  10  */
  11 #include <linux/i2c.h>
  12 #include <linux/slab.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/delay.h>
  15 #include <linux/module.h>
  16 #include <linux/mod_devicetable.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20 #include <linux/bitops.h>
  21
  22 #define BH1780_CMD_BIT          BIT(7)
  23 #define BH1780_REG_CONTROL      0x00
  24 #define BH1780_REG_PARTID       0x0A
  25 #define BH1780_REG_MANFID       0x0B
  26 #define BH1780_REG_DLOW         0x0C
  27 #define BH1780_REG_DHIGH        0x0D
  28
  29 #define BH1780_REVMASK          GENMASK(3,0)
  30 #define BH1780_POWMASK          GENMASK(1,0)
  31 #define BH1780_POFF             (0x0)
  32 #define BH1780_PON              (0x3)
  33
  34 /* power on settling time in ms */
  35 #define BH1780_PON_DELAY        2
  36 /* max time before value available in ms */
  37 #define BH1780_INTERVAL         250
  38
  39 struct bh1780_data {
  40         struct i2c_client *client;
  41 };
  42
  43 static int bh1780_write(struct bh1780_data *bh1780, u8 reg, u8 val)
  44 {
  45         int ret = i2c_smbus_write_byte_data(bh1780->client,
  46                                             BH1780_CMD_BIT | reg,
  47                                             val);
  48         if (ret < 0)
  49                 dev_err(&bh1780->client->dev,
  50                         "i2c_smbus_write_byte_data failed error "
  51                         "%d, register %01x\n",
  52                         ret, reg);
  53         return ret;
  54 }
  55
  56 static int bh1780_read(struct bh1780_data *bh1780, u8 reg)
  57 {
  58         int ret = i2c_smbus_read_byte_data(bh1780->client,
  59                                            BH1780_CMD_BIT | reg);
  60         if (ret < 0)
  61                 dev_err(&bh1780->client->dev,
  62                         "i2c_smbus_read_byte_data failed error "
  63                         "%d, register %01x\n",
  64                         ret, reg);
  65         return ret;
  66 }
  67
  68 static int bh1780_read_word(struct bh1780_data *bh1780, u8 reg)
  69 {
  70         int ret = i2c_smbus_read_word_data(bh1780->client,
  71                                            BH1780_CMD_BIT | reg);
  72         if (ret < 0)
  73                 dev_err(&bh1780->client->dev,
  74                         "i2c_smbus_read_word_data failed error "
  75                         "%d, register %01x\n",
  76                         ret, reg);
  77         return ret;
  78 }
  79
  80 static int bh1780_debugfs_reg_access(struct iio_dev *indio_dev,
  81                               unsigned int reg, unsigned int writeval,
  82                               unsigned int *readval)
  83 {
  84         struct bh1780_data *bh1780 = iio_priv(indio_dev);
  85         int ret;
  86
  87         if (!readval)
  88                 return bh1780_write(bh1780, (u8)reg, (u8)writeval);
  89
  90         ret = bh1780_read(bh1780, (u8)reg);
  91         if (ret < 0)
  92                 return ret;
  93
  94         *readval = ret;
  95
  96         return 0;
  97 }
  98
  99 static int bh1780_read_raw(struct iio_dev *indio_dev,
 100                            struct iio_chan_spec const *chan,
 101                            int *val, int *val2, long mask)
 102 {
 103         struct bh1780_data *bh1780 = iio_priv(indio_dev);
 104         int value;
 105
 106         switch (mask) {
 107         case IIO_CHAN_INFO_RAW:
 108                 switch (chan->type) {
 109                 case IIO_LIGHT:
 110                         pm_runtime_get_sync(&bh1780->client->dev);
 111                         value = bh1780_read_word(bh1780, BH1780_REG_DLOW);
 112                         if (value < 0)
 113                                 return value;
 114                         pm_runtime_mark_last_busy(&bh1780->client->dev);
 115                         pm_runtime_put_autosuspend(&bh1780->client->dev);
 116                         *val = value;
 117
 118                         return IIO_VAL_INT;
 119                 default:
 120                         return -EINVAL;
 121                 }
 122         case IIO_CHAN_INFO_INT_TIME:
 123                 *val = 0;
 124                 *val2 = BH1780_INTERVAL * 1000;
 125                 return IIO_VAL_INT_PLUS_MICRO;
 126         default:
 127                 return -EINVAL;
 128         }
 129 }
 130
 131 static const struct iio_info bh1780_info = {
 132         .read_raw = bh1780_read_raw,
 133         .debugfs_reg_access = bh1780_debugfs_reg_access,
 134 };
 135
 136 static const struct iio_chan_spec bh1780_channels[] = {
 137         {
 138                 .type = IIO_LIGHT,
 139                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 140                                       BIT(IIO_CHAN_INFO_INT_TIME)
 141         }
 142 };
 143
 144 static int bh1780_probe(struct i2c_client *client,
 145                         const struct i2c_device_id *id)
 146 {
 147         int ret;
 148         struct bh1780_data *bh1780;
 149         struct i2c_adapter *adapter = client->adapter;
 150         struct iio_dev *indio_dev;
 151
 152         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 153                 return -EIO;
 154
 155         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*bh1780));
 156         if (!indio_dev)
 157                 return -ENOMEM;
 158
 159         bh1780 = iio_priv(indio_dev);
 160         bh1780->client = client;
 161         i2c_set_clientdata(client, indio_dev);
 162
 163         /* Power up the device */
 164         ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
 165         if (ret < 0)
 166                 return ret;
 167         msleep(BH1780_PON_DELAY);
 168         pm_runtime_get_noresume(&client->dev);
 169         pm_runtime_set_active(&client->dev);
 170         pm_runtime_enable(&client->dev);
 171
 172         ret = bh1780_read(bh1780, BH1780_REG_PARTID);
 173         if (ret < 0)
 174                 goto out_disable_pm;
 175         dev_info(&client->dev,
 176                  "Ambient Light Sensor, Rev : %lu\n",
 177                  (ret & BH1780_REVMASK));
 178
 179         /*
 180          * As the device takes 250 ms to even come up with a fresh
 181          * measurement after power-on, do not shut it down unnecessarily.
 182          * Set autosuspend to a five seconds.
 183          */
 184         pm_runtime_set_autosuspend_delay(&client->dev, 5000);
 185         pm_runtime_use_autosuspend(&client->dev);
 186         pm_runtime_put(&client->dev);
 187
 188         indio_dev->info = &bh1780_info;
 189         indio_dev->name = "bh1780";
 190         indio_dev->channels = bh1780_channels;
 191         indio_dev->num_channels = ARRAY_SIZE(bh1780_channels);
 192         indio_dev->modes = INDIO_DIRECT_MODE;
 193
 194         ret = iio_device_register(indio_dev);
 195         if (ret)
 196                 goto out_disable_pm;
 197         return 0;
 198
 199 out_disable_pm:
 200         pm_runtime_put_noidle(&client->dev);
 201         pm_runtime_disable(&client->dev);
 202         return ret;
 203 }
 204
 205 static int bh1780_remove(struct i2c_client *client)
 206 {
 207         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 208         struct bh1780_data *bh1780 = iio_priv(indio_dev);
 209         int ret;
 210
 211         iio_device_unregister(indio_dev);
 212         pm_runtime_get_sync(&client->dev);
 213         pm_runtime_put_noidle(&client->dev);
 214         pm_runtime_disable(&client->dev);
 215         ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
 216         if (ret < 0) {
 217                 dev_err(&client->dev, "failed to power off\n");
 218                 return ret;
 219         }
 220
 221         return 0;
 222 }
 223
 224 #ifdef CONFIG_PM
 225 static int bh1780_runtime_suspend(struct device *dev)
 226 {
 227         struct i2c_client *client = to_i2c_client(dev);
 228         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 229         struct bh1780_data *bh1780 = iio_priv(indio_dev);
 230         int ret;
 231
 232         ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
 233         if (ret < 0) {
 234                 dev_err(dev, "failed to runtime suspend\n");
 235                 return ret;
 236         }
 237
 238         return 0;
 239 }
 240
 241 static int bh1780_runtime_resume(struct device *dev)
 242 {
 243         struct i2c_client *client = to_i2c_client(dev);
 244         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 245         struct bh1780_data *bh1780 = iio_priv(indio_dev);
 246         int ret;
 247
 248         ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
 249         if (ret < 0) {
 250                 dev_err(dev, "failed to runtime resume\n");
 251                 return ret;
 252         }
 253
 254         /* Wait for power on, then for a value to be available */
 255         msleep(BH1780_PON_DELAY + BH1780_INTERVAL);
 256
 257         return 0;
 258 }
 259 #endif /* CONFIG_PM */
 260
 261 static const struct dev_pm_ops bh1780_dev_pm_ops = {
 262         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 263                                 pm_runtime_force_resume)
 264         SET_RUNTIME_PM_OPS(bh1780_runtime_suspend,
 265                            bh1780_runtime_resume, NULL)
 266 };
 267
 268 static const struct i2c_device_id bh1780_id[] = {
 269         { "bh1780", 0 },
 270         { },
 271 };
 272
 273 MODULE_DEVICE_TABLE(i2c, bh1780_id);
 274
 275 static const struct of_device_id of_bh1780_match[] = {
 276         { .compatible = "rohm,bh1780gli", },
 277         {},
 278 };
 279 MODULE_DEVICE_TABLE(of, of_bh1780_match);
 280
 281 static struct i2c_driver bh1780_driver = {
 282         .probe          = bh1780_probe,
 283         .remove         = bh1780_remove,
 284         .id_table       = bh1780_id,
 285         .driver = {
 286                 .name = "bh1780",
 287                 .pm = &bh1780_dev_pm_ops,
 288                 .of_match_table = of_bh1780_match,
 289         },
 290 };
 291
 292 module_i2c_driver(bh1780_driver);
 293
 294 MODULE_DESCRIPTION("ROHM BH1780GLI Ambient Light Sensor Driver");
 295 MODULE_LICENSE("GPL");
 296 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");