1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This file is part of the ROHM BH1770GLC / OSRAM SFH7770 sensor driver.
4  * Chip is combined proximity and ambient light sensor.
5  *
6  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
7  *
8  * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
9  */
10 
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/i2c.h>
14 #include <linux/interrupt.h>
15 #include <linux/mutex.h>
16 #include <linux/platform_data/bh1770glc.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/workqueue.h>
20 #include <linux/delay.h>
21 #include <linux/wait.h>
22 #include <linux/slab.h>
23 
24 #define BH1770_ALS_CONTROL	0x80 /* ALS operation mode control */
25 #define BH1770_PS_CONTROL	0x81 /* PS operation mode control */
26 #define BH1770_I_LED		0x82 /* active LED and LED1, LED2 current */
27 #define BH1770_I_LED3		0x83 /* LED3 current setting */
28 #define BH1770_ALS_PS_MEAS	0x84 /* Forced mode trigger */
29 #define BH1770_PS_MEAS_RATE	0x85 /* PS meas. rate at stand alone mode */
30 #define BH1770_ALS_MEAS_RATE	0x86 /* ALS meas. rate at stand alone mode */
31 #define BH1770_PART_ID		0x8a /* Part number and revision ID */
32 #define BH1770_MANUFACT_ID	0x8b /* Manufacturerer ID */
33 #define BH1770_ALS_DATA_0	0x8c /* ALS DATA low byte */
34 #define BH1770_ALS_DATA_1	0x8d /* ALS DATA high byte */
35 #define BH1770_ALS_PS_STATUS	0x8e /* Measurement data and int status */
36 #define BH1770_PS_DATA_LED1	0x8f /* PS data from LED1 */
37 #define BH1770_PS_DATA_LED2	0x90 /* PS data from LED2 */
38 #define BH1770_PS_DATA_LED3	0x91 /* PS data from LED3 */
39 #define BH1770_INTERRUPT	0x92 /* Interrupt setting */
40 #define BH1770_PS_TH_LED1	0x93 /* PS interrupt threshold for LED1 */
41 #define BH1770_PS_TH_LED2	0x94 /* PS interrupt threshold for LED2 */
42 #define BH1770_PS_TH_LED3	0x95 /* PS interrupt threshold for LED3 */
43 #define BH1770_ALS_TH_UP_0	0x96 /* ALS upper threshold low byte */
44 #define BH1770_ALS_TH_UP_1	0x97 /* ALS upper threshold high byte */
45 #define BH1770_ALS_TH_LOW_0	0x98 /* ALS lower threshold low byte */
46 #define BH1770_ALS_TH_LOW_1	0x99 /* ALS lower threshold high byte */
47 
48 /* MANUFACT_ID */
49 #define BH1770_MANUFACT_ROHM	0x01
50 #define BH1770_MANUFACT_OSRAM	0x03
51 
52 /* PART_ID */
53 #define BH1770_PART		0x90
54 #define BH1770_PART_MASK	0xf0
55 #define BH1770_REV_MASK		0x0f
56 #define BH1770_REV_SHIFT	0
57 #define BH1770_REV_0		0x00
58 #define BH1770_REV_1		0x01
59 
60 /* Operating modes for both */
61 #define BH1770_STANDBY		0x00
62 #define BH1770_FORCED		0x02
63 #define BH1770_STANDALONE	0x03
64 #define BH1770_SWRESET		(0x01 << 2)
65 
66 #define BH1770_PS_TRIG_MEAS	(1 << 0)
67 #define BH1770_ALS_TRIG_MEAS	(1 << 1)
68 
69 /* Interrupt control */
70 #define BH1770_INT_OUTPUT_MODE	(1 << 3) /* 0 = latched */
71 #define BH1770_INT_POLARITY	(1 << 2) /* 1 = active high */
72 #define BH1770_INT_ALS_ENA	(1 << 1)
73 #define BH1770_INT_PS_ENA	(1 << 0)
74 
75 /* Interrupt status */
76 #define BH1770_INT_LED1_DATA	(1 << 0)
77 #define BH1770_INT_LED1_INT	(1 << 1)
78 #define BH1770_INT_LED2_DATA	(1 << 2)
79 #define BH1770_INT_LED2_INT	(1 << 3)
80 #define BH1770_INT_LED3_DATA	(1 << 4)
81 #define BH1770_INT_LED3_INT	(1 << 5)
82 #define BH1770_INT_LEDS_INT	((1 << 1) | (1 << 3) | (1 << 5))
83 #define BH1770_INT_ALS_DATA	(1 << 6)
84 #define BH1770_INT_ALS_INT	(1 << 7)
85 
86 /* Led channels */
87 #define BH1770_LED1		0x00
88 
89 #define BH1770_DISABLE		0
90 #define BH1770_ENABLE		1
91 #define BH1770_PROX_CHANNELS	1
92 
93 #define BH1770_LUX_DEFAULT_RATE	1 /* Index to lux rate table */
94 #define BH1770_PROX_DEFAULT_RATE 1 /* Direct HW value =~ 50Hz */
95 #define BH1770_PROX_DEF_RATE_THRESH 6 /* Direct HW value =~ 5 Hz */
96 #define BH1770_STARTUP_DELAY	50
97 #define BH1770_RESET_TIME	10
98 #define BH1770_TIMEOUT		2100 /* Timeout in 2.1 seconds */
99 
100 #define BH1770_LUX_RANGE	65535
101 #define BH1770_PROX_RANGE	255
102 #define BH1770_COEF_SCALER	1024
103 #define BH1770_CALIB_SCALER	8192
104 #define BH1770_LUX_NEUTRAL_CALIB_VALUE (1 * BH1770_CALIB_SCALER)
105 #define BH1770_LUX_DEF_THRES	1000
106 #define BH1770_PROX_DEF_THRES	70
107 #define BH1770_PROX_DEF_ABS_THRES   100
108 #define BH1770_DEFAULT_PERSISTENCE  10
109 #define BH1770_PROX_MAX_PERSISTENCE 50
110 #define BH1770_LUX_GA_SCALE	16384
111 #define BH1770_LUX_CF_SCALE	2048 /* CF ChipFactor */
112 #define BH1770_NEUTRAL_CF	BH1770_LUX_CF_SCALE
113 #define BH1770_LUX_CORR_SCALE	4096
114 
115 #define PROX_ABOVE_THRESHOLD	1
116 #define PROX_BELOW_THRESHOLD	0
117 
118 #define PROX_IGNORE_LUX_LIMIT	500
119 
120 struct bh1770_chip {
121 	struct bh1770_platform_data	*pdata;
122 	char				chipname[10];
123 	u8				revision;
124 	struct i2c_client		*client;
125 	struct regulator_bulk_data	regs[2];
126 	struct mutex			mutex; /* avoid parallel access */
127 	wait_queue_head_t		wait;
128 
129 	bool			int_mode_prox;
130 	bool			int_mode_lux;
131 	struct delayed_work	prox_work;
132 	u32	lux_cf; /* Chip specific factor */
133 	u32	lux_ga;
134 	u32	lux_calib;
135 	int	lux_rate_index;
136 	u32	lux_corr;
137 	u16	lux_data_raw;
138 	u16	lux_threshold_hi;
139 	u16	lux_threshold_lo;
140 	u16	lux_thres_hi_onchip;
141 	u16	lux_thres_lo_onchip;
142 	bool	lux_wait_result;
143 
144 	int	prox_enable_count;
145 	u16	prox_coef;
146 	u16	prox_const;
147 	int	prox_rate;
148 	int	prox_rate_threshold;
149 	u8	prox_persistence;
150 	u8	prox_persistence_counter;
151 	u8	prox_data;
152 	u8	prox_threshold;
153 	u8	prox_threshold_hw;
154 	bool	prox_force_update;
155 	u8	prox_abs_thres;
156 	u8	prox_led;
157 };
158 
159 static const char reg_vcc[] = "Vcc";
160 static const char reg_vleds[] = "Vleds";
161 
162 /*
163  * Supported stand alone rates in ms from chip data sheet
164  * {10, 20, 30, 40, 70, 100, 200, 500, 1000, 2000};
165  */
166 static const s16 prox_rates_hz[] = {100, 50, 33, 25, 14, 10, 5, 2};
167 static const s16 prox_rates_ms[] = {10, 20, 30, 40, 70, 100, 200, 500};
168 
169 /*
170  * Supported stand alone rates in ms from chip data sheet
171  * {100, 200, 500, 1000, 2000};
172  */
173 static const s16 lux_rates_hz[] = {10, 5, 2, 1, 0};
174 
175 /*
176  * interrupt control functions are called while keeping chip->mutex
177  * excluding module probe / remove
178  */
bh1770_lux_interrupt_control(struct bh1770_chip * chip,int lux)179 static inline int bh1770_lux_interrupt_control(struct bh1770_chip *chip,
180 					int lux)
181 {
182 	chip->int_mode_lux = lux;
183 	/* Set interrupt modes, interrupt active low, latched */
184 	return i2c_smbus_write_byte_data(chip->client,
185 					BH1770_INTERRUPT,
186 					(lux << 1) | chip->int_mode_prox);
187 }
188 
bh1770_prox_interrupt_control(struct bh1770_chip * chip,int ps)189 static inline int bh1770_prox_interrupt_control(struct bh1770_chip *chip,
190 					int ps)
191 {
192 	chip->int_mode_prox = ps;
193 	return i2c_smbus_write_byte_data(chip->client,
194 					BH1770_INTERRUPT,
195 					(chip->int_mode_lux << 1) | (ps << 0));
196 }
197 
198 /* chip->mutex is always kept here */
bh1770_lux_rate(struct bh1770_chip * chip,int rate_index)199 static int bh1770_lux_rate(struct bh1770_chip *chip, int rate_index)
200 {
201 	/* sysfs may call this when the chip is powered off */
202 	if (pm_runtime_suspended(&chip->client->dev))
203 		return 0;
204 
205 	/* Proper proximity response needs fastest lux rate (100ms) */
206 	if (chip->prox_enable_count)
207 		rate_index = 0;
208 
209 	return i2c_smbus_write_byte_data(chip->client,
210 					BH1770_ALS_MEAS_RATE,
211 					rate_index);
212 }
213 
bh1770_prox_rate(struct bh1770_chip * chip,int mode)214 static int bh1770_prox_rate(struct bh1770_chip *chip, int mode)
215 {
216 	int rate;
217 
218 	rate = (mode == PROX_ABOVE_THRESHOLD) ?
219 		chip->prox_rate_threshold : chip->prox_rate;
220 
221 	return i2c_smbus_write_byte_data(chip->client,
222 					BH1770_PS_MEAS_RATE,
223 					rate);
224 }
225 
226 /* InfraredLED is controlled by the chip during proximity scanning */
bh1770_led_cfg(struct bh1770_chip * chip)227 static inline int bh1770_led_cfg(struct bh1770_chip *chip)
228 {
229 	/* LED cfg, current for leds 1 and 2 */
230 	return i2c_smbus_write_byte_data(chip->client,
231 					BH1770_I_LED,
232 					(BH1770_LED1 << 6) |
233 					(BH1770_LED_5mA << 3) |
234 					chip->prox_led);
235 }
236 
237 /*
238  * Following two functions converts raw ps values from HW to normalized
239  * values. Purpose is to compensate differences between different sensor
240  * versions and variants so that result means about the same between
241  * versions.
242  */
bh1770_psraw_to_adjusted(struct bh1770_chip * chip,u8 psraw)243 static inline u8 bh1770_psraw_to_adjusted(struct bh1770_chip *chip, u8 psraw)
244 {
245 	u16 adjusted;
246 	adjusted = (u16)(((u32)(psraw + chip->prox_const) * chip->prox_coef) /
247 		BH1770_COEF_SCALER);
248 	if (adjusted > BH1770_PROX_RANGE)
249 		adjusted = BH1770_PROX_RANGE;
250 	return adjusted;
251 }
252 
bh1770_psadjusted_to_raw(struct bh1770_chip * chip,u8 ps)253 static inline u8 bh1770_psadjusted_to_raw(struct bh1770_chip *chip, u8 ps)
254 {
255 	u16 raw;
256 
257 	raw = (((u32)ps * BH1770_COEF_SCALER) / chip->prox_coef);
258 	if (raw > chip->prox_const)
259 		raw = raw - chip->prox_const;
260 	else
261 		raw = 0;
262 	return raw;
263 }
264 
265 /*
266  * Following two functions converts raw lux values from HW to normalized
267  * values. Purpose is to compensate differences between different sensor
268  * versions and variants so that result means about the same between
269  * versions. Chip->mutex is kept when this is called.
270  */
bh1770_prox_set_threshold(struct bh1770_chip * chip)271 static int bh1770_prox_set_threshold(struct bh1770_chip *chip)
272 {
273 	u8 tmp = 0;
274 
275 	/* sysfs may call this when the chip is powered off */
276 	if (pm_runtime_suspended(&chip->client->dev))
277 		return 0;
278 
279 	tmp = bh1770_psadjusted_to_raw(chip, chip->prox_threshold);
280 	chip->prox_threshold_hw = tmp;
281 
282 	return	i2c_smbus_write_byte_data(chip->client, BH1770_PS_TH_LED1,
283 					tmp);
284 }
285 
bh1770_lux_raw_to_adjusted(struct bh1770_chip * chip,u16 raw)286 static inline u16 bh1770_lux_raw_to_adjusted(struct bh1770_chip *chip, u16 raw)
287 {
288 	u32 lux;
289 	lux = ((u32)raw * chip->lux_corr) / BH1770_LUX_CORR_SCALE;
290 	return min(lux, (u32)BH1770_LUX_RANGE);
291 }
292 
bh1770_lux_adjusted_to_raw(struct bh1770_chip * chip,u16 adjusted)293 static inline u16 bh1770_lux_adjusted_to_raw(struct bh1770_chip *chip,
294 					u16 adjusted)
295 {
296 	return (u32)adjusted * BH1770_LUX_CORR_SCALE / chip->lux_corr;
297 }
298 
299 /* chip->mutex is kept when this is called */
bh1770_lux_update_thresholds(struct bh1770_chip * chip,u16 threshold_hi,u16 threshold_lo)300 static int bh1770_lux_update_thresholds(struct bh1770_chip *chip,
301 					u16 threshold_hi, u16 threshold_lo)
302 {
303 	u8 data[4];
304 	int ret;
305 
306 	/* sysfs may call this when the chip is powered off */
307 	if (pm_runtime_suspended(&chip->client->dev))
308 		return 0;
309 
310 	/*
311 	 * Compensate threshold values with the correction factors if not
312 	 * set to minimum or maximum.
313 	 * Min & max values disables interrupts.
314 	 */
315 	if (threshold_hi != BH1770_LUX_RANGE && threshold_hi != 0)
316 		threshold_hi = bh1770_lux_adjusted_to_raw(chip, threshold_hi);
317 
318 	if (threshold_lo != BH1770_LUX_RANGE && threshold_lo != 0)
319 		threshold_lo = bh1770_lux_adjusted_to_raw(chip, threshold_lo);
320 
321 	if (chip->lux_thres_hi_onchip == threshold_hi &&
322 	    chip->lux_thres_lo_onchip == threshold_lo)
323 		return 0;
324 
325 	chip->lux_thres_hi_onchip = threshold_hi;
326 	chip->lux_thres_lo_onchip = threshold_lo;
327 
328 	data[0] = threshold_hi;
329 	data[1] = threshold_hi >> 8;
330 	data[2] = threshold_lo;
331 	data[3] = threshold_lo >> 8;
332 
333 	ret = i2c_smbus_write_i2c_block_data(chip->client,
334 					BH1770_ALS_TH_UP_0,
335 					ARRAY_SIZE(data),
336 					data);
337 	return ret;
338 }
339 
bh1770_lux_get_result(struct bh1770_chip * chip)340 static int bh1770_lux_get_result(struct bh1770_chip *chip)
341 {
342 	u16 data;
343 	int ret;
344 
345 	ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_0);
346 	if (ret < 0)
347 		return ret;
348 
349 	data = ret & 0xff;
350 	ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_1);
351 	if (ret < 0)
352 		return ret;
353 
354 	chip->lux_data_raw = data | ((ret & 0xff) << 8);
355 
356 	return 0;
357 }
358 
359 /* Calculate correction value which contains chip and device specific parts */
bh1770_get_corr_value(struct bh1770_chip * chip)360 static u32 bh1770_get_corr_value(struct bh1770_chip *chip)
361 {
362 	u32 tmp;
363 	/* Impact of glass attenuation correction */
364 	tmp = (BH1770_LUX_CORR_SCALE * chip->lux_ga) / BH1770_LUX_GA_SCALE;
365 	/* Impact of chip factor correction */
366 	tmp = (tmp * chip->lux_cf) / BH1770_LUX_CF_SCALE;
367 	/* Impact of Device specific calibration correction */
368 	tmp = (tmp * chip->lux_calib) / BH1770_CALIB_SCALER;
369 	return tmp;
370 }
371 
bh1770_lux_read_result(struct bh1770_chip * chip)372 static int bh1770_lux_read_result(struct bh1770_chip *chip)
373 {
374 	bh1770_lux_get_result(chip);
375 	return bh1770_lux_raw_to_adjusted(chip, chip->lux_data_raw);
376 }
377 
378 /*
379  * Chip on / off functions are called while keeping mutex except probe
380  * or remove phase
381  */
bh1770_chip_on(struct bh1770_chip * chip)382 static int bh1770_chip_on(struct bh1770_chip *chip)
383 {
384 	int ret = regulator_bulk_enable(ARRAY_SIZE(chip->regs),
385 					chip->regs);
386 	if (ret < 0)
387 		return ret;
388 
389 	usleep_range(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2);
390 
391 	/* Reset the chip */
392 	i2c_smbus_write_byte_data(chip->client, BH1770_ALS_CONTROL,
393 				BH1770_SWRESET);
394 	usleep_range(BH1770_RESET_TIME, BH1770_RESET_TIME * 2);
395 
396 	/*
397 	 * ALS is started always since proximity needs als results
398 	 * for realibility estimation.
399 	 * Let's assume dark until the first ALS measurement is ready.
400 	 */
401 	chip->lux_data_raw = 0;
402 	chip->prox_data = 0;
403 	ret = i2c_smbus_write_byte_data(chip->client,
404 					BH1770_ALS_CONTROL, BH1770_STANDALONE);
405 
406 	/* Assume reset defaults */
407 	chip->lux_thres_hi_onchip = BH1770_LUX_RANGE;
408 	chip->lux_thres_lo_onchip = 0;
409 
410 	return ret;
411 }
412 
bh1770_chip_off(struct bh1770_chip * chip)413 static void bh1770_chip_off(struct bh1770_chip *chip)
414 {
415 	i2c_smbus_write_byte_data(chip->client,
416 					BH1770_INTERRUPT, BH1770_DISABLE);
417 	i2c_smbus_write_byte_data(chip->client,
418 				BH1770_ALS_CONTROL, BH1770_STANDBY);
419 	i2c_smbus_write_byte_data(chip->client,
420 				BH1770_PS_CONTROL, BH1770_STANDBY);
421 	regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);
422 }
423 
424 /* chip->mutex is kept when this is called */
bh1770_prox_mode_control(struct bh1770_chip * chip)425 static int bh1770_prox_mode_control(struct bh1770_chip *chip)
426 {
427 	if (chip->prox_enable_count) {
428 		chip->prox_force_update = true; /* Force immediate update */
429 
430 		bh1770_lux_rate(chip, chip->lux_rate_index);
431 		bh1770_prox_set_threshold(chip);
432 		bh1770_led_cfg(chip);
433 		bh1770_prox_rate(chip, PROX_BELOW_THRESHOLD);
434 		bh1770_prox_interrupt_control(chip, BH1770_ENABLE);
435 		i2c_smbus_write_byte_data(chip->client,
436 					BH1770_PS_CONTROL, BH1770_STANDALONE);
437 	} else {
438 		chip->prox_data = 0;
439 		bh1770_lux_rate(chip, chip->lux_rate_index);
440 		bh1770_prox_interrupt_control(chip, BH1770_DISABLE);
441 		i2c_smbus_write_byte_data(chip->client,
442 					BH1770_PS_CONTROL, BH1770_STANDBY);
443 	}
444 	return 0;
445 }
446 
447 /* chip->mutex is kept when this is called */
bh1770_prox_read_result(struct bh1770_chip * chip)448 static int bh1770_prox_read_result(struct bh1770_chip *chip)
449 {
450 	int ret;
451 	bool above;
452 	u8 mode;
453 
454 	ret = i2c_smbus_read_byte_data(chip->client, BH1770_PS_DATA_LED1);
455 	if (ret < 0)
456 		goto out;
457 
458 	if (ret > chip->prox_threshold_hw)
459 		above = true;
460 	else
461 		above = false;
462 
463 	/*
464 	 * when ALS levels goes above limit, proximity result may be
465 	 * false proximity. Thus ignore the result. With real proximity
466 	 * there is a shadow causing low als levels.
467 	 */
468 	if (chip->lux_data_raw > PROX_IGNORE_LUX_LIMIT)
469 		ret = 0;
470 
471 	chip->prox_data = bh1770_psraw_to_adjusted(chip, ret);
472 
473 	/* Strong proximity level or force mode requires immediate response */
474 	if (chip->prox_data >= chip->prox_abs_thres ||
475 	    chip->prox_force_update)
476 		chip->prox_persistence_counter = chip->prox_persistence;
477 
478 	chip->prox_force_update = false;
479 
480 	/* Persistence filttering to reduce false proximity events */
481 	if (likely(above)) {
482 		if (chip->prox_persistence_counter < chip->prox_persistence) {
483 			chip->prox_persistence_counter++;
484 			ret = -ENODATA;
485 		} else {
486 			mode = PROX_ABOVE_THRESHOLD;
487 			ret = 0;
488 		}
489 	} else {
490 		chip->prox_persistence_counter = 0;
491 		mode = PROX_BELOW_THRESHOLD;
492 		chip->prox_data = 0;
493 		ret = 0;
494 	}
495 
496 	/* Set proximity detection rate based on above or below value */
497 	if (ret == 0) {
498 		bh1770_prox_rate(chip, mode);
499 		sysfs_notify(&chip->client->dev.kobj, NULL, "prox0_raw");
500 	}
501 out:
502 	return ret;
503 }
504 
bh1770_detect(struct bh1770_chip * chip)505 static int bh1770_detect(struct bh1770_chip *chip)
506 {
507 	struct i2c_client *client = chip->client;
508 	s32 ret;
509 	u8 manu, part;
510 
511 	ret = i2c_smbus_read_byte_data(client, BH1770_MANUFACT_ID);
512 	if (ret < 0)
513 		goto error;
514 	manu = (u8)ret;
515 
516 	ret = i2c_smbus_read_byte_data(client, BH1770_PART_ID);
517 	if (ret < 0)
518 		goto error;
519 	part = (u8)ret;
520 
521 	chip->revision = (part & BH1770_REV_MASK) >> BH1770_REV_SHIFT;
522 	chip->prox_coef = BH1770_COEF_SCALER;
523 	chip->prox_const = 0;
524 	chip->lux_cf = BH1770_NEUTRAL_CF;
525 
526 	if ((manu == BH1770_MANUFACT_ROHM) &&
527 	    ((part & BH1770_PART_MASK) == BH1770_PART)) {
528 		snprintf(chip->chipname, sizeof(chip->chipname), "BH1770GLC");
529 		return 0;
530 	}
531 
532 	if ((manu == BH1770_MANUFACT_OSRAM) &&
533 	    ((part & BH1770_PART_MASK) == BH1770_PART)) {
534 		snprintf(chip->chipname, sizeof(chip->chipname), "SFH7770");
535 		/* Values selected by comparing different versions */
536 		chip->prox_coef = 819; /* 0.8 * BH1770_COEF_SCALER */
537 		chip->prox_const = 40;
538 		return 0;
539 	}
540 
541 	ret = -ENODEV;
542 error:
543 	dev_dbg(&client->dev, "BH1770 or SFH7770 not found\n");
544 
545 	return ret;
546 }
547 
548 /*
549  * This work is re-scheduled at every proximity interrupt.
550  * If this work is running, it means that there hasn't been any
551  * proximity interrupt in time. Situation is handled as no-proximity.
552  * It would be nice to have low-threshold interrupt or interrupt
553  * when measurement and hi-threshold are both 0. But neither of those exists.
554  * This is a workaroud for missing HW feature.
555  */
556 
bh1770_prox_work(struct work_struct * work)557 static void bh1770_prox_work(struct work_struct *work)
558 {
559 	struct bh1770_chip *chip =
560 		container_of(work, struct bh1770_chip, prox_work.work);
561 
562 	mutex_lock(&chip->mutex);
563 	bh1770_prox_read_result(chip);
564 	mutex_unlock(&chip->mutex);
565 }
566 
567 /* This is threaded irq handler */
bh1770_irq(int irq,void * data)568 static irqreturn_t bh1770_irq(int irq, void *data)
569 {
570 	struct bh1770_chip *chip = data;
571 	int status;
572 	int rate = 0;
573 
574 	mutex_lock(&chip->mutex);
575 	status = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_PS_STATUS);
576 
577 	/* Acknowledge interrupt by reading this register */
578 	i2c_smbus_read_byte_data(chip->client, BH1770_INTERRUPT);
579 
580 	/*
581 	 * Check if there is fresh data available for als.
582 	 * If this is the very first data, update thresholds after that.
583 	 */
584 	if (status & BH1770_INT_ALS_DATA) {
585 		bh1770_lux_get_result(chip);
586 		if (unlikely(chip->lux_wait_result)) {
587 			chip->lux_wait_result = false;
588 			wake_up(&chip->wait);
589 			bh1770_lux_update_thresholds(chip,
590 						chip->lux_threshold_hi,
591 						chip->lux_threshold_lo);
592 		}
593 	}
594 
595 	/* Disable interrupt logic to guarantee acknowledgement */
596 	i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT,
597 				  (0 << 1) | (0 << 0));
598 
599 	if ((status & BH1770_INT_ALS_INT))
600 		sysfs_notify(&chip->client->dev.kobj, NULL, "lux0_input");
601 
602 	if (chip->int_mode_prox && (status & BH1770_INT_LEDS_INT)) {
603 		rate = prox_rates_ms[chip->prox_rate_threshold];
604 		bh1770_prox_read_result(chip);
605 	}
606 
607 	/* Re-enable interrupt logic */
608 	i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT,
609 				  (chip->int_mode_lux << 1) |
610 				  (chip->int_mode_prox << 0));
611 	mutex_unlock(&chip->mutex);
612 
613 	/*
614 	 * Can't cancel work while keeping mutex since the work uses the
615 	 * same mutex.
616 	 */
617 	if (rate) {
618 		/*
619 		 * Simulate missing no-proximity interrupt 50ms after the
620 		 * next expected interrupt time.
621 		 */
622 		cancel_delayed_work_sync(&chip->prox_work);
623 		schedule_delayed_work(&chip->prox_work,
624 				msecs_to_jiffies(rate + 50));
625 	}
626 	return IRQ_HANDLED;
627 }
628 
bh1770_power_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)629 static ssize_t bh1770_power_state_store(struct device *dev,
630 				      struct device_attribute *attr,
631 				      const char *buf, size_t count)
632 {
633 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
634 	unsigned long value;
635 	ssize_t ret;
636 
637 	ret = kstrtoul(buf, 0, &value);
638 	if (ret)
639 		return ret;
640 
641 	mutex_lock(&chip->mutex);
642 	if (value) {
643 		pm_runtime_get_sync(dev);
644 
645 		ret = bh1770_lux_rate(chip, chip->lux_rate_index);
646 		if (ret < 0) {
647 			pm_runtime_put(dev);
648 			goto leave;
649 		}
650 
651 		ret = bh1770_lux_interrupt_control(chip, BH1770_ENABLE);
652 		if (ret < 0) {
653 			pm_runtime_put(dev);
654 			goto leave;
655 		}
656 
657 		/* This causes interrupt after the next measurement cycle */
658 		bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES,
659 					BH1770_LUX_DEF_THRES);
660 		/* Inform that we are waiting for a result from ALS */
661 		chip->lux_wait_result = true;
662 		bh1770_prox_mode_control(chip);
663 	} else if (!pm_runtime_suspended(dev)) {
664 		pm_runtime_put(dev);
665 	}
666 	ret = count;
667 leave:
668 	mutex_unlock(&chip->mutex);
669 	return ret;
670 }
671 
bh1770_power_state_show(struct device * dev,struct device_attribute * attr,char * buf)672 static ssize_t bh1770_power_state_show(struct device *dev,
673 				   struct device_attribute *attr, char *buf)
674 {
675 	return sprintf(buf, "%d\n", !pm_runtime_suspended(dev));
676 }
677 
bh1770_lux_result_show(struct device * dev,struct device_attribute * attr,char * buf)678 static ssize_t bh1770_lux_result_show(struct device *dev,
679 				   struct device_attribute *attr, char *buf)
680 {
681 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
682 	ssize_t ret;
683 	long timeout;
684 
685 	if (pm_runtime_suspended(dev))
686 		return -EIO; /* Chip is not enabled at all */
687 
688 	timeout = wait_event_interruptible_timeout(chip->wait,
689 					!chip->lux_wait_result,
690 					msecs_to_jiffies(BH1770_TIMEOUT));
691 	if (!timeout)
692 		return -EIO;
693 
694 	mutex_lock(&chip->mutex);
695 	ret = sprintf(buf, "%d\n", bh1770_lux_read_result(chip));
696 	mutex_unlock(&chip->mutex);
697 
698 	return ret;
699 }
700 
bh1770_lux_range_show(struct device * dev,struct device_attribute * attr,char * buf)701 static ssize_t bh1770_lux_range_show(struct device *dev,
702 				   struct device_attribute *attr, char *buf)
703 {
704 	return sprintf(buf, "%d\n", BH1770_LUX_RANGE);
705 }
706 
bh1770_prox_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)707 static ssize_t bh1770_prox_enable_store(struct device *dev,
708 				      struct device_attribute *attr,
709 				      const char *buf, size_t count)
710 {
711 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
712 	unsigned long value;
713 	int ret;
714 
715 	ret = kstrtoul(buf, 0, &value);
716 	if (ret)
717 		return ret;
718 
719 	mutex_lock(&chip->mutex);
720 	/* Assume no proximity. Sensor will tell real state soon */
721 	if (!chip->prox_enable_count)
722 		chip->prox_data = 0;
723 
724 	if (value)
725 		chip->prox_enable_count++;
726 	else if (chip->prox_enable_count > 0)
727 		chip->prox_enable_count--;
728 	else
729 		goto leave;
730 
731 	/* Run control only when chip is powered on */
732 	if (!pm_runtime_suspended(dev))
733 		bh1770_prox_mode_control(chip);
734 leave:
735 	mutex_unlock(&chip->mutex);
736 	return count;
737 }
738 
bh1770_prox_enable_show(struct device * dev,struct device_attribute * attr,char * buf)739 static ssize_t bh1770_prox_enable_show(struct device *dev,
740 				   struct device_attribute *attr, char *buf)
741 {
742 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
743 	ssize_t len;
744 
745 	mutex_lock(&chip->mutex);
746 	len = sprintf(buf, "%d\n", chip->prox_enable_count);
747 	mutex_unlock(&chip->mutex);
748 	return len;
749 }
750 
bh1770_prox_result_show(struct device * dev,struct device_attribute * attr,char * buf)751 static ssize_t bh1770_prox_result_show(struct device *dev,
752 				   struct device_attribute *attr, char *buf)
753 {
754 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
755 	ssize_t ret;
756 
757 	mutex_lock(&chip->mutex);
758 	if (chip->prox_enable_count && !pm_runtime_suspended(dev))
759 		ret = sprintf(buf, "%d\n", chip->prox_data);
760 	else
761 		ret = -EIO;
762 	mutex_unlock(&chip->mutex);
763 	return ret;
764 }
765 
bh1770_prox_range_show(struct device * dev,struct device_attribute * attr,char * buf)766 static ssize_t bh1770_prox_range_show(struct device *dev,
767 				   struct device_attribute *attr, char *buf)
768 {
769 	return sprintf(buf, "%d\n", BH1770_PROX_RANGE);
770 }
771 
bh1770_get_prox_rate_avail(struct device * dev,struct device_attribute * attr,char * buf)772 static ssize_t bh1770_get_prox_rate_avail(struct device *dev,
773 				   struct device_attribute *attr, char *buf)
774 {
775 	int i;
776 	int pos = 0;
777 	for (i = 0; i < ARRAY_SIZE(prox_rates_hz); i++)
778 		pos += sprintf(buf + pos, "%d ", prox_rates_hz[i]);
779 	sprintf(buf + pos - 1, "\n");
780 	return pos;
781 }
782 
bh1770_get_prox_rate_above(struct device * dev,struct device_attribute * attr,char * buf)783 static ssize_t bh1770_get_prox_rate_above(struct device *dev,
784 				   struct device_attribute *attr, char *buf)
785 {
786 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
787 	return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate_threshold]);
788 }
789 
bh1770_get_prox_rate_below(struct device * dev,struct device_attribute * attr,char * buf)790 static ssize_t bh1770_get_prox_rate_below(struct device *dev,
791 				   struct device_attribute *attr, char *buf)
792 {
793 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
794 	return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate]);
795 }
796 
bh1770_prox_rate_validate(int rate)797 static int bh1770_prox_rate_validate(int rate)
798 {
799 	int i;
800 
801 	for (i = 0; i < ARRAY_SIZE(prox_rates_hz) - 1; i++)
802 		if (rate >= prox_rates_hz[i])
803 			break;
804 	return i;
805 }
806 
bh1770_set_prox_rate_above(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)807 static ssize_t bh1770_set_prox_rate_above(struct device *dev,
808 					struct device_attribute *attr,
809 					const char *buf, size_t count)
810 {
811 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
812 	unsigned long value;
813 	int ret;
814 
815 	ret = kstrtoul(buf, 0, &value);
816 	if (ret)
817 		return ret;
818 
819 	mutex_lock(&chip->mutex);
820 	chip->prox_rate_threshold = bh1770_prox_rate_validate(value);
821 	mutex_unlock(&chip->mutex);
822 	return count;
823 }
824 
bh1770_set_prox_rate_below(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)825 static ssize_t bh1770_set_prox_rate_below(struct device *dev,
826 					struct device_attribute *attr,
827 					const char *buf, size_t count)
828 {
829 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
830 	unsigned long value;
831 	int ret;
832 
833 	ret = kstrtoul(buf, 0, &value);
834 	if (ret)
835 		return ret;
836 
837 	mutex_lock(&chip->mutex);
838 	chip->prox_rate = bh1770_prox_rate_validate(value);
839 	mutex_unlock(&chip->mutex);
840 	return count;
841 }
842 
bh1770_get_prox_thres(struct device * dev,struct device_attribute * attr,char * buf)843 static ssize_t bh1770_get_prox_thres(struct device *dev,
844 				   struct device_attribute *attr, char *buf)
845 {
846 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
847 	return sprintf(buf, "%d\n", chip->prox_threshold);
848 }
849 
bh1770_set_prox_thres(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)850 static ssize_t bh1770_set_prox_thres(struct device *dev,
851 				      struct device_attribute *attr,
852 				      const char *buf, size_t count)
853 {
854 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
855 	unsigned long value;
856 	int ret;
857 
858 	ret = kstrtoul(buf, 0, &value);
859 	if (ret)
860 		return ret;
861 
862 	if (value > BH1770_PROX_RANGE)
863 		return -EINVAL;
864 
865 	mutex_lock(&chip->mutex);
866 	chip->prox_threshold = value;
867 	ret = bh1770_prox_set_threshold(chip);
868 	mutex_unlock(&chip->mutex);
869 	if (ret < 0)
870 		return ret;
871 	return count;
872 }
873 
bh1770_prox_persistence_show(struct device * dev,struct device_attribute * attr,char * buf)874 static ssize_t bh1770_prox_persistence_show(struct device *dev,
875 				 struct device_attribute *attr, char *buf)
876 {
877 	struct bh1770_chip *chip = dev_get_drvdata(dev);
878 
879 	return sprintf(buf, "%u\n", chip->prox_persistence);
880 }
881 
bh1770_prox_persistence_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)882 static ssize_t bh1770_prox_persistence_store(struct device *dev,
883 				struct device_attribute *attr,
884 				const char *buf, size_t len)
885 {
886 	struct bh1770_chip *chip = dev_get_drvdata(dev);
887 	unsigned long value;
888 	int ret;
889 
890 	ret = kstrtoul(buf, 0, &value);
891 	if (ret)
892 		return ret;
893 
894 	if (value > BH1770_PROX_MAX_PERSISTENCE)
895 		return -EINVAL;
896 
897 	chip->prox_persistence = value;
898 
899 	return len;
900 }
901 
bh1770_prox_abs_thres_show(struct device * dev,struct device_attribute * attr,char * buf)902 static ssize_t bh1770_prox_abs_thres_show(struct device *dev,
903 				 struct device_attribute *attr, char *buf)
904 {
905 	struct bh1770_chip *chip = dev_get_drvdata(dev);
906 	return sprintf(buf, "%u\n", chip->prox_abs_thres);
907 }
908 
bh1770_prox_abs_thres_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)909 static ssize_t bh1770_prox_abs_thres_store(struct device *dev,
910 				struct device_attribute *attr,
911 				const char *buf, size_t len)
912 {
913 	struct bh1770_chip *chip = dev_get_drvdata(dev);
914 	unsigned long value;
915 	int ret;
916 
917 	ret = kstrtoul(buf, 0, &value);
918 	if (ret)
919 		return ret;
920 
921 	if (value > BH1770_PROX_RANGE)
922 		return -EINVAL;
923 
924 	chip->prox_abs_thres = value;
925 
926 	return len;
927 }
928 
bh1770_chip_id_show(struct device * dev,struct device_attribute * attr,char * buf)929 static ssize_t bh1770_chip_id_show(struct device *dev,
930 				   struct device_attribute *attr, char *buf)
931 {
932 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
933 	return sprintf(buf, "%s rev %d\n", chip->chipname, chip->revision);
934 }
935 
bh1770_lux_calib_default_show(struct device * dev,struct device_attribute * attr,char * buf)936 static ssize_t bh1770_lux_calib_default_show(struct device *dev,
937 				 struct device_attribute *attr, char *buf)
938 {
939 	return sprintf(buf, "%u\n", BH1770_CALIB_SCALER);
940 }
941 
bh1770_lux_calib_show(struct device * dev,struct device_attribute * attr,char * buf)942 static ssize_t bh1770_lux_calib_show(struct device *dev,
943 				 struct device_attribute *attr, char *buf)
944 {
945 	struct bh1770_chip *chip = dev_get_drvdata(dev);
946 	ssize_t len;
947 
948 	mutex_lock(&chip->mutex);
949 	len = sprintf(buf, "%u\n", chip->lux_calib);
950 	mutex_unlock(&chip->mutex);
951 	return len;
952 }
953 
bh1770_lux_calib_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)954 static ssize_t bh1770_lux_calib_store(struct device *dev,
955 				  struct device_attribute *attr,
956 				  const char *buf, size_t len)
957 {
958 	struct bh1770_chip *chip = dev_get_drvdata(dev);
959 	unsigned long value;
960 	u32 old_calib;
961 	u32 new_corr;
962 	int ret;
963 
964 	ret = kstrtoul(buf, 0, &value);
965 	if (ret)
966 		return ret;
967 
968 	mutex_lock(&chip->mutex);
969 	old_calib = chip->lux_calib;
970 	chip->lux_calib = value;
971 	new_corr = bh1770_get_corr_value(chip);
972 	if (new_corr == 0) {
973 		chip->lux_calib = old_calib;
974 		mutex_unlock(&chip->mutex);
975 		return -EINVAL;
976 	}
977 	chip->lux_corr = new_corr;
978 	/* Refresh thresholds on HW after changing correction value */
979 	bh1770_lux_update_thresholds(chip, chip->lux_threshold_hi,
980 				chip->lux_threshold_lo);
981 
982 	mutex_unlock(&chip->mutex);
983 
984 	return len;
985 }
986 
bh1770_get_lux_rate_avail(struct device * dev,struct device_attribute * attr,char * buf)987 static ssize_t bh1770_get_lux_rate_avail(struct device *dev,
988 				   struct device_attribute *attr, char *buf)
989 {
990 	int i;
991 	int pos = 0;
992 	for (i = 0; i < ARRAY_SIZE(lux_rates_hz); i++)
993 		pos += sprintf(buf + pos, "%d ", lux_rates_hz[i]);
994 	sprintf(buf + pos - 1, "\n");
995 	return pos;
996 }
997 
bh1770_get_lux_rate(struct device * dev,struct device_attribute * attr,char * buf)998 static ssize_t bh1770_get_lux_rate(struct device *dev,
999 				   struct device_attribute *attr, char *buf)
1000 {
1001 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1002 	return sprintf(buf, "%d\n", lux_rates_hz[chip->lux_rate_index]);
1003 }
1004 
bh1770_set_lux_rate(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1005 static ssize_t bh1770_set_lux_rate(struct device *dev,
1006 				      struct device_attribute *attr,
1007 				      const char *buf, size_t count)
1008 {
1009 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1010 	unsigned long rate_hz;
1011 	int ret, i;
1012 
1013 	ret = kstrtoul(buf, 0, &rate_hz);
1014 	if (ret)
1015 		return ret;
1016 
1017 	for (i = 0; i < ARRAY_SIZE(lux_rates_hz) - 1; i++)
1018 		if (rate_hz >= lux_rates_hz[i])
1019 			break;
1020 
1021 	mutex_lock(&chip->mutex);
1022 	chip->lux_rate_index = i;
1023 	ret = bh1770_lux_rate(chip, i);
1024 	mutex_unlock(&chip->mutex);
1025 
1026 	if (ret < 0)
1027 		return ret;
1028 
1029 	return count;
1030 }
1031 
bh1770_get_lux_thresh_above(struct device * dev,struct device_attribute * attr,char * buf)1032 static ssize_t bh1770_get_lux_thresh_above(struct device *dev,
1033 				   struct device_attribute *attr, char *buf)
1034 {
1035 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1036 	return sprintf(buf, "%d\n", chip->lux_threshold_hi);
1037 }
1038 
bh1770_get_lux_thresh_below(struct device * dev,struct device_attribute * attr,char * buf)1039 static ssize_t bh1770_get_lux_thresh_below(struct device *dev,
1040 				   struct device_attribute *attr, char *buf)
1041 {
1042 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1043 	return sprintf(buf, "%d\n", chip->lux_threshold_lo);
1044 }
1045 
bh1770_set_lux_thresh(struct bh1770_chip * chip,u16 * target,const char * buf)1046 static ssize_t bh1770_set_lux_thresh(struct bh1770_chip *chip, u16 *target,
1047 				const char *buf)
1048 {
1049 	unsigned long thresh;
1050 	int ret;
1051 
1052 	ret = kstrtoul(buf, 0, &thresh);
1053 	if (ret)
1054 		return ret;
1055 
1056 	if (thresh > BH1770_LUX_RANGE)
1057 		return -EINVAL;
1058 
1059 	mutex_lock(&chip->mutex);
1060 	*target = thresh;
1061 	/*
1062 	 * Don't update values in HW if we are still waiting for
1063 	 * first interrupt to come after device handle open call.
1064 	 */
1065 	if (!chip->lux_wait_result)
1066 		ret = bh1770_lux_update_thresholds(chip,
1067 						chip->lux_threshold_hi,
1068 						chip->lux_threshold_lo);
1069 	mutex_unlock(&chip->mutex);
1070 	return ret;
1071 
1072 }
1073 
bh1770_set_lux_thresh_above(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1074 static ssize_t bh1770_set_lux_thresh_above(struct device *dev,
1075 				  struct device_attribute *attr,
1076 				  const char *buf, size_t len)
1077 {
1078 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1079 	int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_hi, buf);
1080 	if (ret < 0)
1081 		return ret;
1082 	return len;
1083 }
1084 
bh1770_set_lux_thresh_below(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)1085 static ssize_t bh1770_set_lux_thresh_below(struct device *dev,
1086 				  struct device_attribute *attr,
1087 				  const char *buf, size_t len)
1088 {
1089 	struct bh1770_chip *chip =  dev_get_drvdata(dev);
1090 	int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_lo, buf);
1091 	if (ret < 0)
1092 		return ret;
1093 	return len;
1094 }
1095 
1096 static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, bh1770_prox_enable_show,
1097 						bh1770_prox_enable_store);
1098 static DEVICE_ATTR(prox0_thresh_above1_value, S_IRUGO | S_IWUSR,
1099 						bh1770_prox_abs_thres_show,
1100 						bh1770_prox_abs_thres_store);
1101 static DEVICE_ATTR(prox0_thresh_above0_value, S_IRUGO | S_IWUSR,
1102 						bh1770_get_prox_thres,
1103 						bh1770_set_prox_thres);
1104 static DEVICE_ATTR(prox0_raw, S_IRUGO, bh1770_prox_result_show, NULL);
1105 static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, bh1770_prox_range_show, NULL);
1106 static DEVICE_ATTR(prox0_thresh_above_count, S_IRUGO | S_IWUSR,
1107 						bh1770_prox_persistence_show,
1108 						bh1770_prox_persistence_store);
1109 static DEVICE_ATTR(prox0_rate_above, S_IRUGO | S_IWUSR,
1110 						bh1770_get_prox_rate_above,
1111 						bh1770_set_prox_rate_above);
1112 static DEVICE_ATTR(prox0_rate_below, S_IRUGO | S_IWUSR,
1113 						bh1770_get_prox_rate_below,
1114 						bh1770_set_prox_rate_below);
1115 static DEVICE_ATTR(prox0_rate_avail, S_IRUGO, bh1770_get_prox_rate_avail, NULL);
1116 
1117 static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, bh1770_lux_calib_show,
1118 						bh1770_lux_calib_store);
1119 static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO,
1120 						bh1770_lux_calib_default_show,
1121 						NULL);
1122 static DEVICE_ATTR(lux0_input, S_IRUGO, bh1770_lux_result_show, NULL);
1123 static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, bh1770_lux_range_show, NULL);
1124 static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, bh1770_get_lux_rate,
1125 						bh1770_set_lux_rate);
1126 static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, bh1770_get_lux_rate_avail, NULL);
1127 static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR,
1128 						bh1770_get_lux_thresh_above,
1129 						bh1770_set_lux_thresh_above);
1130 static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR,
1131 						bh1770_get_lux_thresh_below,
1132 						bh1770_set_lux_thresh_below);
1133 static DEVICE_ATTR(chip_id, S_IRUGO, bh1770_chip_id_show, NULL);
1134 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, bh1770_power_state_show,
1135 						 bh1770_power_state_store);
1136 
1137 
1138 static struct attribute *sysfs_attrs[] = {
1139 	&dev_attr_lux0_calibscale.attr,
1140 	&dev_attr_lux0_calibscale_default.attr,
1141 	&dev_attr_lux0_input.attr,
1142 	&dev_attr_lux0_sensor_range.attr,
1143 	&dev_attr_lux0_rate.attr,
1144 	&dev_attr_lux0_rate_avail.attr,
1145 	&dev_attr_lux0_thresh_above_value.attr,
1146 	&dev_attr_lux0_thresh_below_value.attr,
1147 	&dev_attr_prox0_raw.attr,
1148 	&dev_attr_prox0_sensor_range.attr,
1149 	&dev_attr_prox0_raw_en.attr,
1150 	&dev_attr_prox0_thresh_above_count.attr,
1151 	&dev_attr_prox0_rate_above.attr,
1152 	&dev_attr_prox0_rate_below.attr,
1153 	&dev_attr_prox0_rate_avail.attr,
1154 	&dev_attr_prox0_thresh_above0_value.attr,
1155 	&dev_attr_prox0_thresh_above1_value.attr,
1156 	&dev_attr_chip_id.attr,
1157 	&dev_attr_power_state.attr,
1158 	NULL
1159 };
1160 
1161 static const struct attribute_group bh1770_attribute_group = {
1162 	.attrs = sysfs_attrs
1163 };
1164 
bh1770_probe(struct i2c_client * client,const struct i2c_device_id * id)1165 static int bh1770_probe(struct i2c_client *client,
1166 				const struct i2c_device_id *id)
1167 {
1168 	struct bh1770_chip *chip;
1169 	int err;
1170 
1171 	chip = devm_kzalloc(&client->dev, sizeof *chip, GFP_KERNEL);
1172 	if (!chip)
1173 		return -ENOMEM;
1174 
1175 	i2c_set_clientdata(client, chip);
1176 	chip->client  = client;
1177 
1178 	mutex_init(&chip->mutex);
1179 	init_waitqueue_head(&chip->wait);
1180 	INIT_DELAYED_WORK(&chip->prox_work, bh1770_prox_work);
1181 
1182 	if (client->dev.platform_data == NULL) {
1183 		dev_err(&client->dev, "platform data is mandatory\n");
1184 		return -EINVAL;
1185 	}
1186 
1187 	chip->pdata		= client->dev.platform_data;
1188 	chip->lux_calib		= BH1770_LUX_NEUTRAL_CALIB_VALUE;
1189 	chip->lux_rate_index	= BH1770_LUX_DEFAULT_RATE;
1190 	chip->lux_threshold_lo	= BH1770_LUX_DEF_THRES;
1191 	chip->lux_threshold_hi	= BH1770_LUX_DEF_THRES;
1192 
1193 	if (chip->pdata->glass_attenuation == 0)
1194 		chip->lux_ga = BH1770_NEUTRAL_GA;
1195 	else
1196 		chip->lux_ga = chip->pdata->glass_attenuation;
1197 
1198 	chip->prox_threshold	= BH1770_PROX_DEF_THRES;
1199 	chip->prox_led		= chip->pdata->led_def_curr;
1200 	chip->prox_abs_thres	= BH1770_PROX_DEF_ABS_THRES;
1201 	chip->prox_persistence	= BH1770_DEFAULT_PERSISTENCE;
1202 	chip->prox_rate_threshold = BH1770_PROX_DEF_RATE_THRESH;
1203 	chip->prox_rate		= BH1770_PROX_DEFAULT_RATE;
1204 	chip->prox_data		= 0;
1205 
1206 	chip->regs[0].supply = reg_vcc;
1207 	chip->regs[1].supply = reg_vleds;
1208 
1209 	err = devm_regulator_bulk_get(&client->dev,
1210 				      ARRAY_SIZE(chip->regs), chip->regs);
1211 	if (err < 0) {
1212 		dev_err(&client->dev, "Cannot get regulators\n");
1213 		return err;
1214 	}
1215 
1216 	err = regulator_bulk_enable(ARRAY_SIZE(chip->regs),
1217 				chip->regs);
1218 	if (err < 0) {
1219 		dev_err(&client->dev, "Cannot enable regulators\n");
1220 		return err;
1221 	}
1222 
1223 	usleep_range(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2);
1224 	err = bh1770_detect(chip);
1225 	if (err < 0)
1226 		goto fail0;
1227 
1228 	/* Start chip */
1229 	bh1770_chip_on(chip);
1230 	pm_runtime_set_active(&client->dev);
1231 	pm_runtime_enable(&client->dev);
1232 
1233 	chip->lux_corr = bh1770_get_corr_value(chip);
1234 	if (chip->lux_corr == 0) {
1235 		dev_err(&client->dev, "Improper correction values\n");
1236 		err = -EINVAL;
1237 		goto fail0;
1238 	}
1239 
1240 	if (chip->pdata->setup_resources) {
1241 		err = chip->pdata->setup_resources();
1242 		if (err) {
1243 			err = -EINVAL;
1244 			goto fail0;
1245 		}
1246 	}
1247 
1248 	err = sysfs_create_group(&chip->client->dev.kobj,
1249 				&bh1770_attribute_group);
1250 	if (err < 0) {
1251 		dev_err(&chip->client->dev, "Sysfs registration failed\n");
1252 		goto fail1;
1253 	}
1254 
1255 	/*
1256 	 * Chip needs level triggered interrupt to work. However,
1257 	 * level triggering doesn't work always correctly with power
1258 	 * management. Select both
1259 	 */
1260 	err = request_threaded_irq(client->irq, NULL,
1261 				bh1770_irq,
1262 				IRQF_TRIGGER_FALLING | IRQF_ONESHOT |
1263 				IRQF_TRIGGER_LOW,
1264 				"bh1770", chip);
1265 	if (err) {
1266 		dev_err(&client->dev, "could not get IRQ %d\n",
1267 			client->irq);
1268 		goto fail2;
1269 	}
1270 	regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);
1271 	return err;
1272 fail2:
1273 	sysfs_remove_group(&chip->client->dev.kobj,
1274 			&bh1770_attribute_group);
1275 fail1:
1276 	if (chip->pdata->release_resources)
1277 		chip->pdata->release_resources();
1278 fail0:
1279 	regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);
1280 	return err;
1281 }
1282 
bh1770_remove(struct i2c_client * client)1283 static void bh1770_remove(struct i2c_client *client)
1284 {
1285 	struct bh1770_chip *chip = i2c_get_clientdata(client);
1286 
1287 	free_irq(client->irq, chip);
1288 
1289 	sysfs_remove_group(&chip->client->dev.kobj,
1290 			&bh1770_attribute_group);
1291 
1292 	if (chip->pdata->release_resources)
1293 		chip->pdata->release_resources();
1294 
1295 	cancel_delayed_work_sync(&chip->prox_work);
1296 
1297 	if (!pm_runtime_suspended(&client->dev))
1298 		bh1770_chip_off(chip);
1299 
1300 	pm_runtime_disable(&client->dev);
1301 	pm_runtime_set_suspended(&client->dev);
1302 }
1303 
1304 #ifdef CONFIG_PM_SLEEP
bh1770_suspend(struct device * dev)1305 static int bh1770_suspend(struct device *dev)
1306 {
1307 	struct i2c_client *client = to_i2c_client(dev);
1308 	struct bh1770_chip *chip = i2c_get_clientdata(client);
1309 
1310 	bh1770_chip_off(chip);
1311 
1312 	return 0;
1313 }
1314 
bh1770_resume(struct device * dev)1315 static int bh1770_resume(struct device *dev)
1316 {
1317 	struct i2c_client *client = to_i2c_client(dev);
1318 	struct bh1770_chip *chip = i2c_get_clientdata(client);
1319 	int ret = 0;
1320 
1321 	bh1770_chip_on(chip);
1322 
1323 	if (!pm_runtime_suspended(dev)) {
1324 		/*
1325 		 * If we were enabled at suspend time, it is expected
1326 		 * everything works nice and smoothly
1327 		 */
1328 		ret = bh1770_lux_rate(chip, chip->lux_rate_index);
1329 		ret |= bh1770_lux_interrupt_control(chip, BH1770_ENABLE);
1330 
1331 		/* This causes interrupt after the next measurement cycle */
1332 		bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES,
1333 					BH1770_LUX_DEF_THRES);
1334 		/* Inform that we are waiting for a result from ALS */
1335 		chip->lux_wait_result = true;
1336 		bh1770_prox_mode_control(chip);
1337 	}
1338 	return ret;
1339 }
1340 #endif
1341 
1342 #ifdef CONFIG_PM
bh1770_runtime_suspend(struct device * dev)1343 static int bh1770_runtime_suspend(struct device *dev)
1344 {
1345 	struct i2c_client *client = to_i2c_client(dev);
1346 	struct bh1770_chip *chip = i2c_get_clientdata(client);
1347 
1348 	bh1770_chip_off(chip);
1349 
1350 	return 0;
1351 }
1352 
bh1770_runtime_resume(struct device * dev)1353 static int bh1770_runtime_resume(struct device *dev)
1354 {
1355 	struct i2c_client *client = to_i2c_client(dev);
1356 	struct bh1770_chip *chip = i2c_get_clientdata(client);
1357 
1358 	bh1770_chip_on(chip);
1359 
1360 	return 0;
1361 }
1362 #endif
1363 
1364 static const struct i2c_device_id bh1770_id[] = {
1365 	{"bh1770glc", 0 },
1366 	{"sfh7770", 0 },
1367 	{}
1368 };
1369 
1370 MODULE_DEVICE_TABLE(i2c, bh1770_id);
1371 
1372 static const struct dev_pm_ops bh1770_pm_ops = {
1373 	SET_SYSTEM_SLEEP_PM_OPS(bh1770_suspend, bh1770_resume)
1374 	SET_RUNTIME_PM_OPS(bh1770_runtime_suspend, bh1770_runtime_resume, NULL)
1375 };
1376 
1377 static struct i2c_driver bh1770_driver = {
1378 	.driver	 = {
1379 		.name	= "bh1770glc",
1380 		.pm	= &bh1770_pm_ops,
1381 	},
1382 	.probe	  = bh1770_probe,
1383 	.remove	  = bh1770_remove,
1384 	.id_table = bh1770_id,
1385 };
1386 
1387 module_i2c_driver(bh1770_driver);
1388 
1389 MODULE_DESCRIPTION("BH1770GLC / SFH7770 combined ALS and proximity sensor");
1390 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
1391 MODULE_LICENSE("GPL v2");
1392