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>"); 299