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
bh1780_write(struct bh1780_data * bh1780,u8 reg,u8 val)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
bh1780_read(struct bh1780_data * bh1780,u8 reg)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
bh1780_read_word(struct bh1780_data * bh1780,u8 reg)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
bh1780_debugfs_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)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
bh1780_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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 pm_runtime_put_autosuspend(&bh1780->client->dev);
113 if (value < 0)
114 return value;
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
bh1780_probe(struct i2c_client * client)143 static int bh1780_probe(struct i2c_client *client)
144 {
145 int ret;
146 struct bh1780_data *bh1780;
147 struct i2c_adapter *adapter = client->adapter;
148 struct iio_dev *indio_dev;
149
150 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
151 return -EIO;
152
153 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*bh1780));
154 if (!indio_dev)
155 return -ENOMEM;
156
157 bh1780 = iio_priv(indio_dev);
158 bh1780->client = client;
159 i2c_set_clientdata(client, indio_dev);
160
161 /* Power up the device */
162 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
163 if (ret < 0)
164 return ret;
165 msleep(BH1780_PON_DELAY);
166 pm_runtime_get_noresume(&client->dev);
167 pm_runtime_set_active(&client->dev);
168 pm_runtime_enable(&client->dev);
169
170 ret = bh1780_read(bh1780, BH1780_REG_PARTID);
171 if (ret < 0)
172 goto out_disable_pm;
173 dev_info(&client->dev,
174 "Ambient Light Sensor, Rev : %lu\n",
175 (ret & BH1780_REVMASK));
176
177 /*
178 * As the device takes 250 ms to even come up with a fresh
179 * measurement after power-on, do not shut it down unnecessarily.
180 * Set autosuspend to a five seconds.
181 */
182 pm_runtime_set_autosuspend_delay(&client->dev, 5000);
183 pm_runtime_use_autosuspend(&client->dev);
184 pm_runtime_put(&client->dev);
185
186 indio_dev->info = &bh1780_info;
187 indio_dev->name = "bh1780";
188 indio_dev->channels = bh1780_channels;
189 indio_dev->num_channels = ARRAY_SIZE(bh1780_channels);
190 indio_dev->modes = INDIO_DIRECT_MODE;
191
192 ret = iio_device_register(indio_dev);
193 if (ret)
194 goto out_disable_pm;
195 return 0;
196
197 out_disable_pm:
198 pm_runtime_put_noidle(&client->dev);
199 pm_runtime_disable(&client->dev);
200 return ret;
201 }
202
bh1780_remove(struct i2c_client * client)203 static void bh1780_remove(struct i2c_client *client)
204 {
205 struct iio_dev *indio_dev = i2c_get_clientdata(client);
206 struct bh1780_data *bh1780 = iio_priv(indio_dev);
207 int ret;
208
209 iio_device_unregister(indio_dev);
210 pm_runtime_get_sync(&client->dev);
211 pm_runtime_put_noidle(&client->dev);
212 pm_runtime_disable(&client->dev);
213 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
214 if (ret < 0)
215 dev_err(&client->dev, "failed to power off (%pe)\n",
216 ERR_PTR(ret));
217 }
218
bh1780_runtime_suspend(struct device * dev)219 static int bh1780_runtime_suspend(struct device *dev)
220 {
221 struct i2c_client *client = to_i2c_client(dev);
222 struct iio_dev *indio_dev = i2c_get_clientdata(client);
223 struct bh1780_data *bh1780 = iio_priv(indio_dev);
224 int ret;
225
226 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
227 if (ret < 0) {
228 dev_err(dev, "failed to runtime suspend\n");
229 return ret;
230 }
231
232 return 0;
233 }
234
bh1780_runtime_resume(struct device * dev)235 static int bh1780_runtime_resume(struct device *dev)
236 {
237 struct i2c_client *client = to_i2c_client(dev);
238 struct iio_dev *indio_dev = i2c_get_clientdata(client);
239 struct bh1780_data *bh1780 = iio_priv(indio_dev);
240 int ret;
241
242 ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
243 if (ret < 0) {
244 dev_err(dev, "failed to runtime resume\n");
245 return ret;
246 }
247
248 /* Wait for power on, then for a value to be available */
249 msleep(BH1780_PON_DELAY + BH1780_INTERVAL);
250
251 return 0;
252 }
253
254 static DEFINE_RUNTIME_DEV_PM_OPS(bh1780_dev_pm_ops, bh1780_runtime_suspend,
255 bh1780_runtime_resume, NULL);
256
257 static const struct i2c_device_id bh1780_id[] = {
258 { "bh1780" },
259 { }
260 };
261
262 MODULE_DEVICE_TABLE(i2c, bh1780_id);
263
264 static const struct of_device_id of_bh1780_match[] = {
265 { .compatible = "rohm,bh1780gli", },
266 { }
267 };
268 MODULE_DEVICE_TABLE(of, of_bh1780_match);
269
270 static struct i2c_driver bh1780_driver = {
271 .probe = bh1780_probe,
272 .remove = bh1780_remove,
273 .id_table = bh1780_id,
274 .driver = {
275 .name = "bh1780",
276 .pm = pm_ptr(&bh1780_dev_pm_ops),
277 .of_match_table = of_bh1780_match,
278 },
279 };
280
281 module_i2c_driver(bh1780_driver);
282
283 MODULE_DESCRIPTION("ROHM BH1780GLI Ambient Light Sensor Driver");
284 MODULE_LICENSE("GPL");
285 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
286