1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * These are the two Sharp GP2AP002 variants supported by this driver:
4 * GP2AP002A00F Ambient Light and Proximity Sensor
5 * GP2AP002S00F Proximity Sensor
6 *
7 * Copyright (C) 2020 Linaro Ltd.
8 * Author: Linus Walleij <linus.walleij@linaro.org>
9 *
10 * Based partly on the code in Sony Ericssons GP2AP00200F driver by
11 * Courtney Cavin and Oskar Andero in drivers/input/misc/gp2ap002a00f.c
12 * Based partly on a Samsung misc driver submitted by
13 * Donggeun Kim & Minkyu Kang in 2011:
14 * https://lore.kernel.org/lkml/1315556546-7445-1-git-send-email-dg77.kim@samsung.com/
15 * Based partly on a submission by
16 * Jonathan Bakker and Paweł Chmiel in january 2019:
17 * https://lore.kernel.org/linux-input/20190125175045.22576-1-pawel.mikolaj.chmiel@gmail.com/
18 * Based partly on code from the Samsung GT-S7710 by <mjchen@sta.samsung.com>
19 * Based partly on the code in LG Electronics GP2AP00200F driver by
20 * Kenobi Lee <sungyoung.lee@lge.com> and EunYoung Cho <ey.cho@lge.com>
21 */
22 #include <linux/module.h>
23 #include <linux/i2c.h>
24 #include <linux/regmap.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/sysfs.h>
27 #include <linux/iio/events.h>
28 #include <linux/iio/consumer.h> /* To get our ADC channel */
29 #include <linux/iio/types.h> /* To deal with our ADC channel */
30 #include <linux/init.h>
31 #include <linux/delay.h>
32 #include <linux/regulator/consumer.h>
33 #include <linux/pm_runtime.h>
34 #include <linux/interrupt.h>
35 #include <linux/bits.h>
36 #include <linux/math64.h>
37 #include <linux/pm.h>
38
39 #define GP2AP002_PROX_CHANNEL 0
40 #define GP2AP002_ALS_CHANNEL 1
41
42 /* ------------------------------------------------------------------------ */
43 /* ADDRESS SYMBOL DATA Init R/W */
44 /* D7 D6 D5 D4 D3 D2 D1 D0 */
45 /* ------------------------------------------------------------------------ */
46 /* 0 PROX X X X X X X X VO H'00 R */
47 /* 1 GAIN X X X X LED0 X X X H'00 W */
48 /* 2 HYS HYSD HYSC1 HYSC0 X HYSF3 HYSF2 HYSF1 HYSF0 H'00 W */
49 /* 3 CYCLE X X CYCL2 CYCL1 CYCL0 OSC2 X X H'00 W */
50 /* 4 OPMOD X X X ASD X X VCON SSD H'00 W */
51 /* 6 CON X X X OCON1 OCON0 X X X H'00 W */
52 /* ------------------------------------------------------------------------ */
53 /* VO :Proximity sensing result(0: no detection, 1: detection) */
54 /* LED0 :Select switch for LED driver's On-registence(0:2x higher, 1:normal)*/
55 /* HYSD/HYSF :Adjusts the receiver sensitivity */
56 /* OSC :Select switch internal clocl frequency hoppling(0:effective) */
57 /* CYCL :Determine the detection cycle(typically 8ms, up to 128x) */
58 /* SSD :Software Shutdown function(0:shutdown, 1:operating) */
59 /* VCON :VOUT output method control(0:normal, 1:interrupt) */
60 /* ASD :Select switch for analog sleep function(0:ineffective, 1:effective)*/
61 /* OCON :Select switch for enabling/disabling VOUT (00:enable, 11:disable) */
62
63 #define GP2AP002_PROX 0x00
64 #define GP2AP002_GAIN 0x01
65 #define GP2AP002_HYS 0x02
66 #define GP2AP002_CYCLE 0x03
67 #define GP2AP002_OPMOD 0x04
68 #define GP2AP002_CON 0x06
69
70 #define GP2AP002_PROX_VO_DETECT BIT(0)
71
72 /* Setting this bit to 0 means 2x higher LED resistance */
73 #define GP2AP002_GAIN_LED_NORMAL BIT(3)
74
75 /*
76 * These bits adjusts the proximity sensitivity, determining characteristics
77 * of the detection distance and its hysteresis.
78 */
79 #define GP2AP002_HYS_HYSD_SHIFT 7
80 #define GP2AP002_HYS_HYSD_MASK BIT(7)
81 #define GP2AP002_HYS_HYSC_SHIFT 5
82 #define GP2AP002_HYS_HYSC_MASK GENMASK(6, 5)
83 #define GP2AP002_HYS_HYSF_SHIFT 0
84 #define GP2AP002_HYS_HYSF_MASK GENMASK(3, 0)
85 #define GP2AP002_HYS_MASK (GP2AP002_HYS_HYSD_MASK | \
86 GP2AP002_HYS_HYSC_MASK | \
87 GP2AP002_HYS_HYSF_MASK)
88
89 /*
90 * These values determine the detection cycle response time
91 * 0: 8ms, 1: 16ms, 2: 32ms, 3: 64ms, 4: 128ms,
92 * 5: 256ms, 6: 512ms, 7: 1024ms
93 */
94 #define GP2AP002_CYCLE_CYCL_SHIFT 3
95 #define GP2AP002_CYCLE_CYCL_MASK GENMASK(5, 3)
96
97 /*
98 * Select switch for internal clock frequency hopping
99 * 0: effective,
100 * 1: ineffective
101 */
102 #define GP2AP002_CYCLE_OSC_EFFECTIVE 0
103 #define GP2AP002_CYCLE_OSC_INEFFECTIVE BIT(2)
104 #define GP2AP002_CYCLE_OSC_MASK BIT(2)
105
106 /* Analog sleep effective */
107 #define GP2AP002_OPMOD_ASD BIT(4)
108 /* Enable chip */
109 #define GP2AP002_OPMOD_SSD_OPERATING BIT(0)
110 /* IRQ mode */
111 #define GP2AP002_OPMOD_VCON_IRQ BIT(1)
112 #define GP2AP002_OPMOD_MASK (BIT(0) | BIT(1) | BIT(4))
113
114 /*
115 * Select switch for enabling/disabling Vout pin
116 * 0: enable
117 * 2: force to go Low
118 * 3: force to go High
119 */
120 #define GP2AP002_CON_OCON_SHIFT 3
121 #define GP2AP002_CON_OCON_ENABLE (0x0 << GP2AP002_CON_OCON_SHIFT)
122 #define GP2AP002_CON_OCON_LOW (0x2 << GP2AP002_CON_OCON_SHIFT)
123 #define GP2AP002_CON_OCON_HIGH (0x3 << GP2AP002_CON_OCON_SHIFT)
124 #define GP2AP002_CON_OCON_MASK (0x3 << GP2AP002_CON_OCON_SHIFT)
125
126 /**
127 * struct gp2ap002 - GP2AP002 state
128 * @map: regmap pointer for the i2c regmap
129 * @dev: pointer to parent device
130 * @vdd: regulator controlling VDD
131 * @vio: regulator controlling VIO
132 * @alsout: IIO ADC channel to convert the ALSOUT signal
133 * @hys_far: hysteresis control from device tree
134 * @hys_close: hysteresis control from device tree
135 * @is_gp2ap002s00f: this is the GP2AP002F variant of the chip
136 * @irq: the IRQ line used by this device
137 * @enabled: we cannot read the status of the hardware so we need to
138 * keep track of whether the event is enabled using this state variable
139 */
140 struct gp2ap002 {
141 struct regmap *map;
142 struct device *dev;
143 struct regulator *vdd;
144 struct regulator *vio;
145 struct iio_channel *alsout;
146 u8 hys_far;
147 u8 hys_close;
148 bool is_gp2ap002s00f;
149 int irq;
150 bool enabled;
151 };
152
gp2ap002_prox_irq(int irq,void * d)153 static irqreturn_t gp2ap002_prox_irq(int irq, void *d)
154 {
155 struct iio_dev *indio_dev = d;
156 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
157 u64 ev;
158 int val;
159 int ret;
160
161 if (!gp2ap002->enabled)
162 goto err_retrig;
163
164 ret = regmap_read(gp2ap002->map, GP2AP002_PROX, &val);
165 if (ret) {
166 dev_err(gp2ap002->dev, "error reading proximity\n");
167 goto err_retrig;
168 }
169
170 if (val & GP2AP002_PROX_VO_DETECT) {
171 /* Close */
172 dev_dbg(gp2ap002->dev, "close\n");
173 ret = regmap_write(gp2ap002->map, GP2AP002_HYS,
174 gp2ap002->hys_far);
175 if (ret)
176 dev_err(gp2ap002->dev,
177 "error setting up proximity hysteresis\n");
178 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, GP2AP002_PROX_CHANNEL,
179 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING);
180 } else {
181 /* Far */
182 dev_dbg(gp2ap002->dev, "far\n");
183 ret = regmap_write(gp2ap002->map, GP2AP002_HYS,
184 gp2ap002->hys_close);
185 if (ret)
186 dev_err(gp2ap002->dev,
187 "error setting up proximity hysteresis\n");
188 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, GP2AP002_PROX_CHANNEL,
189 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING);
190 }
191 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
192
193 /*
194 * After changing hysteresis, we need to wait for one detection
195 * cycle to see if anything changed, or we will just trigger the
196 * previous interrupt again. A detection cycle depends on the CYCLE
197 * register, we are hard-coding ~8 ms in probe() so wait some more
198 * than this, 20-30 ms.
199 */
200 usleep_range(20000, 30000);
201
202 err_retrig:
203 ret = regmap_write(gp2ap002->map, GP2AP002_CON,
204 GP2AP002_CON_OCON_ENABLE);
205 if (ret)
206 dev_err(gp2ap002->dev, "error setting up VOUT control\n");
207
208 return IRQ_HANDLED;
209 }
210
211 /*
212 * This array maps current and lux.
213 *
214 * Ambient light sensing range is 3 to 55000 lux.
215 *
216 * This mapping is based on the following formula.
217 * illuminance = 10 ^ (current[mA] / 10)
218 *
219 * When the ADC measures 0, return 0 lux.
220 */
221 static const u16 gp2ap002_illuminance_table[] = {
222 0, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 25, 32, 40, 50, 63, 79,
223 100, 126, 158, 200, 251, 316, 398, 501, 631, 794, 1000, 1259, 1585,
224 1995, 2512, 3162, 3981, 5012, 6310, 7943, 10000, 12589, 15849, 19953,
225 25119, 31623, 39811, 50119,
226 };
227
gp2ap002_get_lux(struct gp2ap002 * gp2ap002)228 static int gp2ap002_get_lux(struct gp2ap002 *gp2ap002)
229 {
230 int ret, res;
231 u16 lux;
232
233 ret = iio_read_channel_processed(gp2ap002->alsout, &res);
234 if (ret < 0)
235 return ret;
236
237 dev_dbg(gp2ap002->dev, "read %d mA from ADC\n", res);
238
239 /* ensure we don't under/overflow */
240 res = clamp(res, 0, (int)ARRAY_SIZE(gp2ap002_illuminance_table) - 1);
241 lux = gp2ap002_illuminance_table[res];
242
243 return (int)lux;
244 }
245
gp2ap002_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)246 static int gp2ap002_read_raw(struct iio_dev *indio_dev,
247 struct iio_chan_spec const *chan,
248 int *val, int *val2, long mask)
249 {
250 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
251 int ret;
252
253 pm_runtime_get_sync(gp2ap002->dev);
254
255 switch (mask) {
256 case IIO_CHAN_INFO_RAW:
257 switch (chan->type) {
258 case IIO_LIGHT:
259 ret = gp2ap002_get_lux(gp2ap002);
260 if (ret < 0)
261 return ret;
262 *val = ret;
263 ret = IIO_VAL_INT;
264 goto out;
265 default:
266 ret = -EINVAL;
267 goto out;
268 }
269 default:
270 ret = -EINVAL;
271 }
272
273 out:
274 pm_runtime_put_autosuspend(gp2ap002->dev);
275
276 return ret;
277 }
278
gp2ap002_init(struct gp2ap002 * gp2ap002)279 static int gp2ap002_init(struct gp2ap002 *gp2ap002)
280 {
281 int ret;
282
283 /* Set up the IR LED resistance */
284 ret = regmap_write(gp2ap002->map, GP2AP002_GAIN,
285 GP2AP002_GAIN_LED_NORMAL);
286 if (ret) {
287 dev_err(gp2ap002->dev, "error setting up LED gain\n");
288 return ret;
289 }
290 ret = regmap_write(gp2ap002->map, GP2AP002_HYS, gp2ap002->hys_far);
291 if (ret) {
292 dev_err(gp2ap002->dev,
293 "error setting up proximity hysteresis\n");
294 return ret;
295 }
296
297 /* Disable internal frequency hopping */
298 ret = regmap_write(gp2ap002->map, GP2AP002_CYCLE,
299 GP2AP002_CYCLE_OSC_INEFFECTIVE);
300 if (ret) {
301 dev_err(gp2ap002->dev,
302 "error setting up internal frequency hopping\n");
303 return ret;
304 }
305
306 /* Enable chip and IRQ, disable analog sleep */
307 ret = regmap_write(gp2ap002->map, GP2AP002_OPMOD,
308 GP2AP002_OPMOD_SSD_OPERATING |
309 GP2AP002_OPMOD_VCON_IRQ);
310 if (ret) {
311 dev_err(gp2ap002->dev, "error setting up operation mode\n");
312 return ret;
313 }
314
315 /* Interrupt on VOUT enabled */
316 ret = regmap_write(gp2ap002->map, GP2AP002_CON,
317 GP2AP002_CON_OCON_ENABLE);
318 if (ret)
319 dev_err(gp2ap002->dev, "error setting up VOUT control\n");
320
321 return ret;
322 }
323
gp2ap002_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)324 static int gp2ap002_read_event_config(struct iio_dev *indio_dev,
325 const struct iio_chan_spec *chan,
326 enum iio_event_type type,
327 enum iio_event_direction dir)
328 {
329 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
330
331 /*
332 * We just keep track of this internally, as it is not possible to
333 * query the hardware.
334 */
335 return gp2ap002->enabled;
336 }
337
gp2ap002_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)338 static int gp2ap002_write_event_config(struct iio_dev *indio_dev,
339 const struct iio_chan_spec *chan,
340 enum iio_event_type type,
341 enum iio_event_direction dir,
342 bool state)
343 {
344 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
345
346 if (state) {
347 /*
348 * This will bring the regulators up (unless they are on
349 * already) and reintialize the sensor by using runtime_pm
350 * callbacks.
351 */
352 pm_runtime_get_sync(gp2ap002->dev);
353 gp2ap002->enabled = true;
354 } else {
355 pm_runtime_put_autosuspend(gp2ap002->dev);
356 gp2ap002->enabled = false;
357 }
358
359 return 0;
360 }
361
362 static const struct iio_info gp2ap002_info = {
363 .read_raw = gp2ap002_read_raw,
364 .read_event_config = gp2ap002_read_event_config,
365 .write_event_config = gp2ap002_write_event_config,
366 };
367
368 static const struct iio_event_spec gp2ap002_events[] = {
369 {
370 .type = IIO_EV_TYPE_THRESH,
371 .dir = IIO_EV_DIR_EITHER,
372 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
373 },
374 };
375
376 static const struct iio_chan_spec gp2ap002_channels[] = {
377 {
378 .type = IIO_PROXIMITY,
379 .event_spec = gp2ap002_events,
380 .num_event_specs = ARRAY_SIZE(gp2ap002_events),
381 },
382 {
383 .type = IIO_LIGHT,
384 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
385 .channel = GP2AP002_ALS_CHANNEL,
386 },
387 };
388
389 /*
390 * We need a special regmap because this hardware expects to
391 * write single bytes to registers but read a 16bit word on some
392 * variants and discard the lower 8 bits so combine
393 * i2c_smbus_read_word_data() with i2c_smbus_write_byte_data()
394 * selectively like this.
395 */
gp2ap002_regmap_i2c_read(void * context,unsigned int reg,unsigned int * val)396 static int gp2ap002_regmap_i2c_read(void *context, unsigned int reg,
397 unsigned int *val)
398 {
399 struct device *dev = context;
400 struct i2c_client *i2c = to_i2c_client(dev);
401 int ret;
402
403 ret = i2c_smbus_read_word_data(i2c, reg);
404 if (ret < 0)
405 return ret;
406
407 *val = (ret >> 8) & 0xFF;
408
409 return 0;
410 }
411
gp2ap002_regmap_i2c_write(void * context,unsigned int reg,unsigned int val)412 static int gp2ap002_regmap_i2c_write(void *context, unsigned int reg,
413 unsigned int val)
414 {
415 struct device *dev = context;
416 struct i2c_client *i2c = to_i2c_client(dev);
417
418 return i2c_smbus_write_byte_data(i2c, reg, val);
419 }
420
421 static const struct regmap_bus gp2ap002_regmap_bus = {
422 .reg_read = gp2ap002_regmap_i2c_read,
423 .reg_write = gp2ap002_regmap_i2c_write,
424 };
425
gp2ap002_probe(struct i2c_client * client)426 static int gp2ap002_probe(struct i2c_client *client)
427 {
428 struct gp2ap002 *gp2ap002;
429 struct iio_dev *indio_dev;
430 struct device *dev = &client->dev;
431 enum iio_chan_type ch_type;
432 static const struct regmap_config config = {
433 .reg_bits = 8,
434 .val_bits = 8,
435 .max_register = GP2AP002_CON,
436 };
437 struct regmap *regmap;
438 int num_chan;
439 const char *compat;
440 u8 val;
441 int ret;
442
443 indio_dev = devm_iio_device_alloc(dev, sizeof(*gp2ap002));
444 if (!indio_dev)
445 return -ENOMEM;
446 i2c_set_clientdata(client, indio_dev);
447
448 gp2ap002 = iio_priv(indio_dev);
449 gp2ap002->dev = dev;
450
451 /*
452 * Check the device compatible like this makes it possible to use
453 * ACPI PRP0001 for registering the sensor using device tree
454 * properties.
455 */
456 ret = device_property_read_string(dev, "compatible", &compat);
457 if (ret) {
458 dev_err(dev, "cannot check compatible\n");
459 return ret;
460 }
461 gp2ap002->is_gp2ap002s00f = !strcmp(compat, "sharp,gp2ap002s00f");
462
463 regmap = devm_regmap_init(dev, &gp2ap002_regmap_bus, dev, &config);
464 if (IS_ERR(regmap)) {
465 dev_err(dev, "Failed to register i2c regmap %ld\n", PTR_ERR(regmap));
466 return PTR_ERR(regmap);
467 }
468 gp2ap002->map = regmap;
469
470 /*
471 * The hysteresis settings are coded into the device tree as values
472 * to be written into the hysteresis register. The datasheet defines
473 * modes "A", "B1" and "B2" with fixed values to be use but vendor
474 * code trees for actual devices are tweaking these values and refer to
475 * modes named things like "B1.5". To be able to support any devices,
476 * we allow passing an arbitrary hysteresis setting for "near" and
477 * "far".
478 */
479
480 /* Check the device tree for the IR LED hysteresis */
481 ret = device_property_read_u8(dev, "sharp,proximity-far-hysteresis",
482 &val);
483 if (ret) {
484 dev_err(dev, "failed to obtain proximity far setting\n");
485 return ret;
486 }
487 dev_dbg(dev, "proximity far setting %02x\n", val);
488 gp2ap002->hys_far = val;
489
490 ret = device_property_read_u8(dev, "sharp,proximity-close-hysteresis",
491 &val);
492 if (ret) {
493 dev_err(dev, "failed to obtain proximity close setting\n");
494 return ret;
495 }
496 dev_dbg(dev, "proximity close setting %02x\n", val);
497 gp2ap002->hys_close = val;
498
499 /* The GP2AP002A00F has a light sensor too */
500 if (!gp2ap002->is_gp2ap002s00f) {
501 gp2ap002->alsout = devm_iio_channel_get(dev, "alsout");
502 if (IS_ERR(gp2ap002->alsout)) {
503 ret = PTR_ERR(gp2ap002->alsout);
504 ret = (ret == -ENODEV) ? -EPROBE_DEFER : ret;
505 return dev_err_probe(dev, ret, "failed to get ALSOUT ADC channel\n");
506 }
507 ret = iio_get_channel_type(gp2ap002->alsout, &ch_type);
508 if (ret < 0)
509 return ret;
510 if (ch_type != IIO_CURRENT) {
511 dev_err(dev,
512 "wrong type of IIO channel specified for ALSOUT\n");
513 return -EINVAL;
514 }
515 }
516
517 gp2ap002->vdd = devm_regulator_get(dev, "vdd");
518 if (IS_ERR(gp2ap002->vdd))
519 return dev_err_probe(dev, PTR_ERR(gp2ap002->vdd),
520 "failed to get VDD regulator\n");
521
522 gp2ap002->vio = devm_regulator_get(dev, "vio");
523 if (IS_ERR(gp2ap002->vio))
524 return dev_err_probe(dev, PTR_ERR(gp2ap002->vio),
525 "failed to get VIO regulator\n");
526
527 /* Operating voltage 2.4V .. 3.6V according to datasheet */
528 ret = regulator_set_voltage(gp2ap002->vdd, 2400000, 3600000);
529 if (ret) {
530 dev_err(dev, "failed to sett VDD voltage\n");
531 return ret;
532 }
533
534 /* VIO should be between 1.65V and VDD */
535 ret = regulator_get_voltage(gp2ap002->vdd);
536 if (ret < 0) {
537 dev_err(dev, "failed to get VDD voltage\n");
538 return ret;
539 }
540 ret = regulator_set_voltage(gp2ap002->vio, 1650000, ret);
541 if (ret) {
542 dev_err(dev, "failed to set VIO voltage\n");
543 return ret;
544 }
545
546 ret = regulator_enable(gp2ap002->vdd);
547 if (ret) {
548 dev_err(dev, "failed to enable VDD regulator\n");
549 return ret;
550 }
551 ret = regulator_enable(gp2ap002->vio);
552 if (ret) {
553 dev_err(dev, "failed to enable VIO regulator\n");
554 goto out_disable_vdd;
555 }
556
557 msleep(20);
558
559 /*
560 * Initialize the device and signal to runtime PM that now we are
561 * definitely up and using power.
562 */
563 ret = gp2ap002_init(gp2ap002);
564 if (ret) {
565 dev_err(dev, "initialization failed\n");
566 goto out_disable_vio;
567 }
568 pm_runtime_get_noresume(dev);
569 pm_runtime_set_active(dev);
570 pm_runtime_enable(dev);
571 gp2ap002->enabled = false;
572
573 ret = devm_request_threaded_irq(dev, client->irq, NULL,
574 gp2ap002_prox_irq, IRQF_ONESHOT,
575 "gp2ap002", indio_dev);
576 if (ret) {
577 dev_err(dev, "unable to request IRQ\n");
578 goto out_put_pm;
579 }
580 gp2ap002->irq = client->irq;
581
582 /*
583 * As the device takes 20 ms + regulator delay to come up with a fresh
584 * measurement after power-on, do not shut it down unnecessarily.
585 * Set autosuspend to a one second.
586 */
587 pm_runtime_set_autosuspend_delay(dev, 1000);
588 pm_runtime_use_autosuspend(dev);
589 pm_runtime_put(dev);
590
591 indio_dev->info = &gp2ap002_info;
592 indio_dev->name = "gp2ap002";
593 indio_dev->channels = gp2ap002_channels;
594 /* Skip light channel for the proximity-only sensor */
595 num_chan = ARRAY_SIZE(gp2ap002_channels);
596 if (gp2ap002->is_gp2ap002s00f)
597 num_chan--;
598 indio_dev->num_channels = num_chan;
599 indio_dev->modes = INDIO_DIRECT_MODE;
600
601 ret = iio_device_register(indio_dev);
602 if (ret)
603 goto out_disable_pm;
604 dev_dbg(dev, "Sharp GP2AP002 probed successfully\n");
605
606 return 0;
607
608 out_put_pm:
609 pm_runtime_put_noidle(dev);
610 out_disable_pm:
611 pm_runtime_disable(dev);
612 out_disable_vio:
613 regulator_disable(gp2ap002->vio);
614 out_disable_vdd:
615 regulator_disable(gp2ap002->vdd);
616 return ret;
617 }
618
gp2ap002_remove(struct i2c_client * client)619 static void gp2ap002_remove(struct i2c_client *client)
620 {
621 struct iio_dev *indio_dev = i2c_get_clientdata(client);
622 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
623 struct device *dev = &client->dev;
624
625 pm_runtime_get_sync(dev);
626 pm_runtime_put_noidle(dev);
627 pm_runtime_disable(dev);
628 iio_device_unregister(indio_dev);
629 regulator_disable(gp2ap002->vio);
630 regulator_disable(gp2ap002->vdd);
631 }
632
gp2ap002_runtime_suspend(struct device * dev)633 static int gp2ap002_runtime_suspend(struct device *dev)
634 {
635 struct iio_dev *indio_dev = dev_get_drvdata(dev);
636 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
637 int ret;
638
639 /* Deactivate the IRQ */
640 disable_irq(gp2ap002->irq);
641
642 /* Disable chip and IRQ, everything off */
643 ret = regmap_write(gp2ap002->map, GP2AP002_OPMOD, 0x00);
644 if (ret) {
645 dev_err(gp2ap002->dev, "error setting up operation mode\n");
646 return ret;
647 }
648 /*
649 * As these regulators may be shared, at least we are now in
650 * sleep even if the regulators aren't really turned off.
651 */
652 regulator_disable(gp2ap002->vio);
653 regulator_disable(gp2ap002->vdd);
654
655 return 0;
656 }
657
gp2ap002_runtime_resume(struct device * dev)658 static int gp2ap002_runtime_resume(struct device *dev)
659 {
660 struct iio_dev *indio_dev = dev_get_drvdata(dev);
661 struct gp2ap002 *gp2ap002 = iio_priv(indio_dev);
662 int ret;
663
664 ret = regulator_enable(gp2ap002->vdd);
665 if (ret) {
666 dev_err(dev, "failed to enable VDD regulator in resume path\n");
667 return ret;
668 }
669 ret = regulator_enable(gp2ap002->vio);
670 if (ret) {
671 dev_err(dev, "failed to enable VIO regulator in resume path\n");
672 return ret;
673 }
674
675 msleep(20);
676
677 ret = gp2ap002_init(gp2ap002);
678 if (ret) {
679 dev_err(dev, "re-initialization failed\n");
680 return ret;
681 }
682
683 /* Re-activate the IRQ */
684 enable_irq(gp2ap002->irq);
685
686 return 0;
687 }
688
689 static DEFINE_RUNTIME_DEV_PM_OPS(gp2ap002_dev_pm_ops, gp2ap002_runtime_suspend,
690 gp2ap002_runtime_resume, NULL);
691
692 static const struct i2c_device_id gp2ap002_id_table[] = {
693 { "gp2ap002" },
694 { }
695 };
696 MODULE_DEVICE_TABLE(i2c, gp2ap002_id_table);
697
698 static const struct of_device_id gp2ap002_of_match[] = {
699 { .compatible = "sharp,gp2ap002a00f" },
700 { .compatible = "sharp,gp2ap002s00f" },
701 { }
702 };
703 MODULE_DEVICE_TABLE(of, gp2ap002_of_match);
704
705 static struct i2c_driver gp2ap002_driver = {
706 .driver = {
707 .name = "gp2ap002",
708 .of_match_table = gp2ap002_of_match,
709 .pm = pm_ptr(&gp2ap002_dev_pm_ops),
710 },
711 .probe = gp2ap002_probe,
712 .remove = gp2ap002_remove,
713 .id_table = gp2ap002_id_table,
714 };
715 module_i2c_driver(gp2ap002_driver);
716
717 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
718 MODULE_DESCRIPTION("GP2AP002 ambient light and proximity sensor driver");
719 MODULE_LICENSE("GPL v2");
720