drivers/iio/light/bh1780.c

   1 /*
   2  * ROHM 1780GLI Ambient Light Sensor Driver
   3  *
   4  * Copyright (C) 2016 Linaro Ltd.
   5  * Author: Linus Walleij <linus.walleij@linaro.org>
   6  * Loosely based on the previous BH1780 ALS misc driver
   7  * Copyright (C) 2010 Texas Instruments
   8  * Author: Hemanth V <hemanthv@ti.com>
   9  */
  10 #include <linux/i2c.h>
  11 #include <linux/slab.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/delay.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19 #include <linux/bitops.h>
  20
  21 #define BH1780_CMD_BIT          BIT(7)
  22 #define BH1780_REG_CONTROL      0x00
  23 #define BH1780_REG_PARTID       0x0A
  24 #define BH1780_REG_MANFID       0x0B
  25 #define BH1780_REG_DLOW         0x0C
  26 #define BH1780_REG_DHIGH        0x0D
  27
  28 #define BH1780_REVMASK          GENMASK(3,0)
  29 #define BH1780_POWMASK          GENMASK(1,0)
  30 #define BH1780_POFF             (0x0)
  31 #define BH1780_PON              (0x3)
  32
  33 /* power on settling time in ms */
  34 #define BH1780_PON_DELAY        2
  35 /* max time before value available in ms */
  36 #define BH1780_INTERVAL         250
  37
  38 struct bh1780_data {
  39         struct i2c_client *client;
  40 };
  41
  42 static int bh1780_write(struct bh1780_data *bh1780, u8 reg, u8 val)
  43 {
  44         int ret = i2c_smbus_write_byte_data(bh1780->client,
  45                                             BH1780_CMD_BIT | reg,
  46                                             val);
  47         if (ret < 0)
  48                 dev_err(&bh1780->client->dev,
  49                         "i2c_smbus_write_byte_data failed error "
  50                         "%d, register %01x\n",
  51                         ret, reg);
  52         return ret;
  53 }
  54
  55 static int bh1780_read(struct bh1780_data *bh1780, u8 reg)
  56 {
  57         int ret = i2c_smbus_read_byte_data(bh1780->client,
  58                                            BH1780_CMD_BIT | reg);
  59         if (ret < 0)
  60                 dev_err(&bh1780->client->dev,
  61                         "i2c_smbus_read_byte_data failed error "
  62                         "%d, register %01x\n",
  63                         ret, reg);
  64         return ret;
  65 }
  66
  67 static int bh1780_read_word(struct bh1780_data *bh1780, u8 reg)
  68 {
  69         int ret = i2c_smbus_read_word_data(bh1780->client,
  70                                            BH1780_CMD_BIT | reg);
  71         if (ret < 0)
  72                 dev_err(&bh1780->client->dev,
  73                         "i2c_smbus_read_word_data failed error "
  74                         "%d, register %01x\n",
  75                         ret, reg);
  76         return ret;
  77 }
  78
  79 static int bh1780_debugfs_reg_access(struct iio_dev *indio_dev,
  80                               unsigned int reg, unsigned int writeval,
  81                               unsigned int *readval)
  82 {
  83         struct bh1780_data *bh1780 = iio_priv(indio_dev);
  84         int ret;
  85
  86         if (!readval)
  87                 return bh1780_write(bh1780, (u8)reg, (u8)writeval);
  88
  89         ret = bh1780_read(bh1780, (u8)reg);
  90         if (ret < 0)
  91                 return ret;
  92
  93         *readval = ret;
  94
  95         return 0;
  96 }
  97
  98 static int bh1780_read_raw(struct iio_dev *indio_dev,
  99                            struct iio_chan_spec const *chan,
 100                            int *val, int *val2, long mask)
 101 {
 102         struct bh1780_data *bh1780 = iio_priv(indio_dev);
 103         int value;
 104
 105         switch (mask) {
 106         case IIO_CHAN_INFO_RAW:
 107                 switch (chan->type) {
 108                 case IIO_LIGHT:
 109                         pm_runtime_get_sync(&bh1780->client->dev);
 110                         value = bh1780_read_word(bh1780, BH1780_REG_DLOW);
 111                         if (value < 0)
 112                                 return value;
 113                         pm_runtime_mark_last_busy(&bh1780->client->dev);
 114                         pm_runtime_put_autosuspend(&bh1780->client->dev);
 115                         *val = value;
 116
 117                         return IIO_VAL_INT;
 118                 default:
 119                         return -EINVAL;
 120                 }
 121         case IIO_CHAN_INFO_INT_TIME:
 122                 *val = 0;
 123                 *val2 = BH1780_INTERVAL * 1000;
 124                 return IIO_VAL_INT_PLUS_MICRO;
 125         default:
 126                 return -EINVAL;
 127         }
 128 }
 129
 130 static const struct iio_info bh1780_info = {
 131         .read_raw = bh1780_read_raw,
 132         .debugfs_reg_access = bh1780_debugfs_reg_access,
 133 };
 134
 135 static const struct iio_chan_spec bh1780_channels[] = {
 136         {
 137                 .type = IIO_LIGHT,
 138                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 139                                       BIT(IIO_CHAN_INFO_INT_TIME)
 140         }
 141 };
 142
 143 static int bh1780_probe(struct i2c_client *client,
 144                         const struct i2c_device_id *id)
 145 {
 146         int ret;
 147         struct bh1780_data *bh1780;
 148         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 149         struct iio_dev *indio_dev;
 150
 151         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 152                 return -EIO;
 153
 154         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*bh1780));
 155         if (!indio_dev)
 156                 return -ENOMEM;
 157
 158         bh1780 = iio_priv(indio_dev);
 159         bh1780->client = client;
 160         i2c_set_clientdata(client, indio_dev);
 161
 162         /* Power up the device */
 163         ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
 164         if (ret < 0)
 165                 return ret;
 166         msleep(BH1780_PON_DELAY);
 167         pm_runtime_get_noresume(&client->dev);
 168         pm_runtime_set_active(&client->dev);
 169         pm_runtime_enable(&client->dev);
 170
 171         ret = bh1780_read(bh1780, BH1780_REG_PARTID);
 172         if (ret < 0)
 173                 goto out_disable_pm;
 174         dev_info(&client->dev,
 175                  "Ambient Light Sensor, Rev : %lu\n",
 176                  (ret & BH1780_REVMASK));
 177
 178         /*
 179          * As the device takes 250 ms to even come up with a fresh
 180          * measurement after power-on, do not shut it down unnecessarily.
 181          * Set autosuspend to a five seconds.
 182          */
 183         pm_runtime_set_autosuspend_delay(&client->dev, 5000);
 184         pm_runtime_use_autosuspend(&client->dev);
 185         pm_runtime_put(&client->dev);
 186
 187         indio_dev->dev.parent = &client->dev;
 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 #ifdef CONFIG_OF
 276 static const struct of_device_id of_bh1780_match[] = {
 277         { .compatible = "rohm,bh1780gli", },
 278         {},
 279 };
 280 MODULE_DEVICE_TABLE(of, of_bh1780_match);
 281 #endif
 282
 283 static struct i2c_driver bh1780_driver = {
 284         .probe          = bh1780_probe,
 285         .remove         = bh1780_remove,
 286         .id_table       = bh1780_id,
 287         .driver = {
 288                 .name = "bh1780",
 289                 .pm = &bh1780_dev_pm_ops,
 290                 .of_match_table = of_match_ptr(of_bh1780_match),
 291         },
 292 };
 293
 294 module_i2c_driver(bh1780_driver);
 295
 296 MODULE_DESCRIPTION("ROHM BH1780GLI Ambient Light Sensor Driver");
 297 MODULE_LICENSE("GPL");
 298 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");