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 { 146 int ret; 147 struct bh1780_data *bh1780; 148 struct i2c_adapter *adapter = client->adapter; 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->info = &bh1780_info; 188 indio_dev->name = "bh1780"; 189 indio_dev->channels = bh1780_channels; 190 indio_dev->num_channels = ARRAY_SIZE(bh1780_channels); 191 indio_dev->modes = INDIO_DIRECT_MODE; 192 193 ret = iio_device_register(indio_dev); 194 if (ret) 195 goto out_disable_pm; 196 return 0; 197 198 out_disable_pm: 199 pm_runtime_put_noidle(&client->dev); 200 pm_runtime_disable(&client->dev); 201 return ret; 202 } 203 204 static void bh1780_remove(struct i2c_client *client) 205 { 206 struct iio_dev *indio_dev = i2c_get_clientdata(client); 207 struct bh1780_data *bh1780 = iio_priv(indio_dev); 208 int ret; 209 210 iio_device_unregister(indio_dev); 211 pm_runtime_get_sync(&client->dev); 212 pm_runtime_put_noidle(&client->dev); 213 pm_runtime_disable(&client->dev); 214 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF); 215 if (ret < 0) 216 dev_err(&client->dev, "failed to power off (%pe)\n", 217 ERR_PTR(ret)); 218 } 219 220 static int bh1780_runtime_suspend(struct device *dev) 221 { 222 struct i2c_client *client = to_i2c_client(dev); 223 struct iio_dev *indio_dev = i2c_get_clientdata(client); 224 struct bh1780_data *bh1780 = iio_priv(indio_dev); 225 int ret; 226 227 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF); 228 if (ret < 0) { 229 dev_err(dev, "failed to runtime suspend\n"); 230 return ret; 231 } 232 233 return 0; 234 } 235 236 static int bh1780_runtime_resume(struct device *dev) 237 { 238 struct i2c_client *client = to_i2c_client(dev); 239 struct iio_dev *indio_dev = i2c_get_clientdata(client); 240 struct bh1780_data *bh1780 = iio_priv(indio_dev); 241 int ret; 242 243 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON); 244 if (ret < 0) { 245 dev_err(dev, "failed to runtime resume\n"); 246 return ret; 247 } 248 249 /* Wait for power on, then for a value to be available */ 250 msleep(BH1780_PON_DELAY + BH1780_INTERVAL); 251 252 return 0; 253 } 254 255 static DEFINE_RUNTIME_DEV_PM_OPS(bh1780_dev_pm_ops, bh1780_runtime_suspend, 256 bh1780_runtime_resume, NULL); 257 258 static const struct i2c_device_id bh1780_id[] = { 259 { "bh1780", 0 }, 260 { }, 261 }; 262 263 MODULE_DEVICE_TABLE(i2c, bh1780_id); 264 265 static const struct of_device_id of_bh1780_match[] = { 266 { .compatible = "rohm,bh1780gli", }, 267 {}, 268 }; 269 MODULE_DEVICE_TABLE(of, of_bh1780_match); 270 271 static struct i2c_driver bh1780_driver = { 272 .probe_new = bh1780_probe, 273 .remove = bh1780_remove, 274 .id_table = bh1780_id, 275 .driver = { 276 .name = "bh1780", 277 .pm = pm_ptr(&bh1780_dev_pm_ops), 278 .of_match_table = of_bh1780_match, 279 }, 280 }; 281 282 module_i2c_driver(bh1780_driver); 283 284 MODULE_DESCRIPTION("ROHM BH1780GLI Ambient Light Sensor Driver"); 285 MODULE_LICENSE("GPL"); 286 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>"); 287