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
bh1780_write(struct bh1780_data * bh1780,u8 reg,u8 val)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
bh1780_read(struct bh1780_data * bh1780,u8 reg)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
bh1780_read_word(struct bh1780_data * bh1780,u8 reg)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
bh1780_debugfs_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)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
bh1780_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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
bh1780_probe(struct i2c_client * client,const struct i2c_device_id * id)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
bh1780_remove(struct i2c_client * client)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
bh1780_runtime_suspend(struct device * dev)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
bh1780_runtime_resume(struct device * dev)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