2 * Sensortek STK3310/STK3311 Ambient Light and Proximity Sensor
4 * Copyright (c) 2015, Intel Corporation.
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
10 * IIO driver for STK3310/STK3311. 7-bit I2C address: 0x48.
13 #include <linux/acpi.h>
14 #include <linux/i2c.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/regmap.h>
19 #include <linux/gpio/consumer.h>
20 #include <linux/iio/events.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
24 #define STK3310_REG_STATE 0x00
25 #define STK3310_REG_PSCTRL 0x01
26 #define STK3310_REG_ALSCTRL 0x02
27 #define STK3310_REG_INT 0x04
28 #define STK3310_REG_THDH_PS 0x06
29 #define STK3310_REG_THDL_PS 0x08
30 #define STK3310_REG_FLAG 0x10
31 #define STK3310_REG_PS_DATA_MSB 0x11
32 #define STK3310_REG_PS_DATA_LSB 0x12
33 #define STK3310_REG_ALS_DATA_MSB 0x13
34 #define STK3310_REG_ALS_DATA_LSB 0x14
35 #define STK3310_REG_ID 0x3E
36 #define STK3310_MAX_REG 0x80
38 #define STK3310_STATE_EN_PS BIT(0)
39 #define STK3310_STATE_EN_ALS BIT(1)
40 #define STK3310_STATE_STANDBY 0x00
42 #define STK3310_CHIP_ID_VAL 0x13
43 #define STK3311_CHIP_ID_VAL 0x1D
44 #define STK3310_PSINT_EN 0x01
45 #define STK3310_PS_MAX_VAL 0xFFFF
47 #define STK3310_DRIVER_NAME "stk3310"
48 #define STK3310_REGMAP_NAME "stk3310_regmap"
49 #define STK3310_EVENT "stk3310_event"
50 #define STK3310_GPIO "stk3310_gpio"
52 #define STK3310_SCALE_AVAILABLE "6.4 1.6 0.4 0.1"
54 #define STK3310_IT_AVAILABLE \
55 "0.000185 0.000370 0.000741 0.001480 0.002960 0.005920 0.011840 " \
56 "0.023680 0.047360 0.094720 0.189440 0.378880 0.757760 1.515520 " \
59 #define STK3310_REGFIELD(name) \
62 devm_regmap_field_alloc(&client->dev, regmap, \
63 stk3310_reg_field_##name); \
64 if (IS_ERR(data->reg_##name)) { \
65 dev_err(&client->dev, "reg field alloc failed.\n"); \
66 return PTR_ERR(data->reg_##name); \
70 static const struct reg_field stk3310_reg_field_state
=
71 REG_FIELD(STK3310_REG_STATE
, 0, 2);
72 static const struct reg_field stk3310_reg_field_als_gain
=
73 REG_FIELD(STK3310_REG_ALSCTRL
, 4, 5);
74 static const struct reg_field stk3310_reg_field_ps_gain
=
75 REG_FIELD(STK3310_REG_PSCTRL
, 4, 5);
76 static const struct reg_field stk3310_reg_field_als_it
=
77 REG_FIELD(STK3310_REG_ALSCTRL
, 0, 3);
78 static const struct reg_field stk3310_reg_field_ps_it
=
79 REG_FIELD(STK3310_REG_PSCTRL
, 0, 3);
80 static const struct reg_field stk3310_reg_field_int_ps
=
81 REG_FIELD(STK3310_REG_INT
, 0, 2);
82 static const struct reg_field stk3310_reg_field_flag_psint
=
83 REG_FIELD(STK3310_REG_FLAG
, 4, 4);
84 static const struct reg_field stk3310_reg_field_flag_nf
=
85 REG_FIELD(STK3310_REG_FLAG
, 0, 0);
87 /* Estimate maximum proximity values with regard to measurement scale. */
88 static const int stk3310_ps_max
[4] = {
89 STK3310_PS_MAX_VAL
/ 640,
90 STK3310_PS_MAX_VAL
/ 160,
91 STK3310_PS_MAX_VAL
/ 40,
92 STK3310_PS_MAX_VAL
/ 10
95 static const int stk3310_scale_table
[][2] = {
96 {6, 400000}, {1, 600000}, {0, 400000}, {0, 100000}
99 /* Integration time in seconds, microseconds */
100 static const int stk3310_it_table
[][2] = {
101 {0, 185}, {0, 370}, {0, 741}, {0, 1480},
102 {0, 2960}, {0, 5920}, {0, 11840}, {0, 23680},
103 {0, 47360}, {0, 94720}, {0, 189440}, {0, 378880},
104 {0, 757760}, {1, 515520}, {3, 31040}, {6, 62080},
107 struct stk3310_data
{
108 struct i2c_client
*client
;
113 struct regmap
*regmap
;
114 struct regmap_field
*reg_state
;
115 struct regmap_field
*reg_als_gain
;
116 struct regmap_field
*reg_ps_gain
;
117 struct regmap_field
*reg_als_it
;
118 struct regmap_field
*reg_ps_it
;
119 struct regmap_field
*reg_int_ps
;
120 struct regmap_field
*reg_flag_psint
;
121 struct regmap_field
*reg_flag_nf
;
124 static const struct iio_event_spec stk3310_events
[] = {
125 /* Proximity event */
127 .type
= IIO_EV_TYPE_THRESH
,
128 .dir
= IIO_EV_DIR_RISING
,
129 .mask_separate
= BIT(IIO_EV_INFO_VALUE
) |
130 BIT(IIO_EV_INFO_ENABLE
),
132 /* Out-of-proximity event */
134 .type
= IIO_EV_TYPE_THRESH
,
135 .dir
= IIO_EV_DIR_FALLING
,
136 .mask_separate
= BIT(IIO_EV_INFO_VALUE
) |
137 BIT(IIO_EV_INFO_ENABLE
),
141 static const struct iio_chan_spec stk3310_channels
[] = {
144 .info_mask_separate
=
145 BIT(IIO_CHAN_INFO_RAW
) |
146 BIT(IIO_CHAN_INFO_SCALE
) |
147 BIT(IIO_CHAN_INFO_INT_TIME
),
150 .type
= IIO_PROXIMITY
,
151 .info_mask_separate
=
152 BIT(IIO_CHAN_INFO_RAW
) |
153 BIT(IIO_CHAN_INFO_SCALE
) |
154 BIT(IIO_CHAN_INFO_INT_TIME
),
155 .event_spec
= stk3310_events
,
156 .num_event_specs
= ARRAY_SIZE(stk3310_events
),
160 static IIO_CONST_ATTR(in_illuminance_scale_available
, STK3310_SCALE_AVAILABLE
);
162 static IIO_CONST_ATTR(in_proximity_scale_available
, STK3310_SCALE_AVAILABLE
);
164 static IIO_CONST_ATTR(in_illuminance_integration_time_available
,
165 STK3310_IT_AVAILABLE
);
167 static IIO_CONST_ATTR(in_proximity_integration_time_available
,
168 STK3310_IT_AVAILABLE
);
170 static struct attribute
*stk3310_attributes
[] = {
171 &iio_const_attr_in_illuminance_scale_available
.dev_attr
.attr
,
172 &iio_const_attr_in_proximity_scale_available
.dev_attr
.attr
,
173 &iio_const_attr_in_illuminance_integration_time_available
.dev_attr
.attr
,
174 &iio_const_attr_in_proximity_integration_time_available
.dev_attr
.attr
,
178 static const struct attribute_group stk3310_attribute_group
= {
179 .attrs
= stk3310_attributes
182 static int stk3310_get_index(const int table
[][2], int table_size
,
187 for (i
= 0; i
< table_size
; i
++) {
188 if (val
== table
[i
][0] && val2
== table
[i
][1])
195 static int stk3310_read_event(struct iio_dev
*indio_dev
,
196 const struct iio_chan_spec
*chan
,
197 enum iio_event_type type
,
198 enum iio_event_direction dir
,
199 enum iio_event_info info
,
205 struct stk3310_data
*data
= iio_priv(indio_dev
);
207 if (info
!= IIO_EV_INFO_VALUE
)
210 /* Only proximity interrupts are implemented at the moment. */
211 if (dir
== IIO_EV_DIR_RISING
)
212 reg
= STK3310_REG_THDH_PS
;
213 else if (dir
== IIO_EV_DIR_FALLING
)
214 reg
= STK3310_REG_THDL_PS
;
218 mutex_lock(&data
->lock
);
219 ret
= regmap_bulk_read(data
->regmap
, reg
, &buf
, 2);
220 mutex_unlock(&data
->lock
);
222 dev_err(&data
->client
->dev
, "register read failed\n");
225 *val
= be16_to_cpu(buf
);
230 static int stk3310_write_event(struct iio_dev
*indio_dev
,
231 const struct iio_chan_spec
*chan
,
232 enum iio_event_type type
,
233 enum iio_event_direction dir
,
234 enum iio_event_info info
,
241 struct stk3310_data
*data
= iio_priv(indio_dev
);
242 struct i2c_client
*client
= data
->client
;
244 ret
= regmap_field_read(data
->reg_ps_gain
, &index
);
248 if (val
< 0 || val
> stk3310_ps_max
[index
])
251 if (dir
== IIO_EV_DIR_RISING
)
252 reg
= STK3310_REG_THDH_PS
;
253 else if (dir
== IIO_EV_DIR_FALLING
)
254 reg
= STK3310_REG_THDL_PS
;
258 buf
= cpu_to_be16(val
);
259 ret
= regmap_bulk_write(data
->regmap
, reg
, &buf
, 2);
261 dev_err(&client
->dev
, "failed to set PS threshold!\n");
266 static int stk3310_read_event_config(struct iio_dev
*indio_dev
,
267 const struct iio_chan_spec
*chan
,
268 enum iio_event_type type
,
269 enum iio_event_direction dir
)
271 unsigned int event_val
;
273 struct stk3310_data
*data
= iio_priv(indio_dev
);
275 ret
= regmap_field_read(data
->reg_int_ps
, &event_val
);
282 static int stk3310_write_event_config(struct iio_dev
*indio_dev
,
283 const struct iio_chan_spec
*chan
,
284 enum iio_event_type type
,
285 enum iio_event_direction dir
,
289 struct stk3310_data
*data
= iio_priv(indio_dev
);
290 struct i2c_client
*client
= data
->client
;
292 if (state
< 0 || state
> 7)
295 /* Set INT_PS value */
296 mutex_lock(&data
->lock
);
297 ret
= regmap_field_write(data
->reg_int_ps
, state
);
299 dev_err(&client
->dev
, "failed to set interrupt mode\n");
300 mutex_unlock(&data
->lock
);
305 static int stk3310_read_raw(struct iio_dev
*indio_dev
,
306 struct iio_chan_spec
const *chan
,
307 int *val
, int *val2
, long mask
)
313 struct stk3310_data
*data
= iio_priv(indio_dev
);
314 struct i2c_client
*client
= data
->client
;
316 if (chan
->type
!= IIO_LIGHT
&& chan
->type
!= IIO_PROXIMITY
)
320 case IIO_CHAN_INFO_RAW
:
321 if (chan
->type
== IIO_LIGHT
)
322 reg
= STK3310_REG_ALS_DATA_MSB
;
324 reg
= STK3310_REG_PS_DATA_MSB
;
326 mutex_lock(&data
->lock
);
327 ret
= regmap_bulk_read(data
->regmap
, reg
, &buf
, 2);
329 dev_err(&client
->dev
, "register read failed\n");
330 mutex_unlock(&data
->lock
);
333 *val
= be16_to_cpu(buf
);
334 mutex_unlock(&data
->lock
);
336 case IIO_CHAN_INFO_INT_TIME
:
337 if (chan
->type
== IIO_LIGHT
)
338 ret
= regmap_field_read(data
->reg_als_it
, &index
);
340 ret
= regmap_field_read(data
->reg_ps_it
, &index
);
344 *val
= stk3310_it_table
[index
][0];
345 *val2
= stk3310_it_table
[index
][1];
346 return IIO_VAL_INT_PLUS_MICRO
;
347 case IIO_CHAN_INFO_SCALE
:
348 if (chan
->type
== IIO_LIGHT
)
349 ret
= regmap_field_read(data
->reg_als_gain
, &index
);
351 ret
= regmap_field_read(data
->reg_ps_gain
, &index
);
355 *val
= stk3310_scale_table
[index
][0];
356 *val2
= stk3310_scale_table
[index
][1];
357 return IIO_VAL_INT_PLUS_MICRO
;
363 static int stk3310_write_raw(struct iio_dev
*indio_dev
,
364 struct iio_chan_spec
const *chan
,
365 int val
, int val2
, long mask
)
369 struct stk3310_data
*data
= iio_priv(indio_dev
);
371 if (chan
->type
!= IIO_LIGHT
&& chan
->type
!= IIO_PROXIMITY
)
375 case IIO_CHAN_INFO_INT_TIME
:
376 index
= stk3310_get_index(stk3310_it_table
,
377 ARRAY_SIZE(stk3310_it_table
),
381 mutex_lock(&data
->lock
);
382 if (chan
->type
== IIO_LIGHT
)
383 ret
= regmap_field_write(data
->reg_als_it
, index
);
385 ret
= regmap_field_write(data
->reg_ps_it
, index
);
387 dev_err(&data
->client
->dev
,
388 "sensor configuration failed\n");
389 mutex_unlock(&data
->lock
);
392 case IIO_CHAN_INFO_SCALE
:
393 index
= stk3310_get_index(stk3310_scale_table
,
394 ARRAY_SIZE(stk3310_scale_table
),
398 mutex_lock(&data
->lock
);
399 if (chan
->type
== IIO_LIGHT
)
400 ret
= regmap_field_write(data
->reg_als_gain
, index
);
402 ret
= regmap_field_write(data
->reg_ps_gain
, index
);
404 dev_err(&data
->client
->dev
,
405 "sensor configuration failed\n");
406 mutex_unlock(&data
->lock
);
413 static const struct iio_info stk3310_info
= {
414 .driver_module
= THIS_MODULE
,
415 .read_raw
= stk3310_read_raw
,
416 .write_raw
= stk3310_write_raw
,
417 .attrs
= &stk3310_attribute_group
,
418 .read_event_value
= stk3310_read_event
,
419 .write_event_value
= stk3310_write_event
,
420 .read_event_config
= stk3310_read_event_config
,
421 .write_event_config
= stk3310_write_event_config
,
424 static int stk3310_set_state(struct stk3310_data
*data
, u8 state
)
427 struct i2c_client
*client
= data
->client
;
429 /* 3-bit state; 0b100 is not supported. */
430 if (state
> 7 || state
== 4)
433 mutex_lock(&data
->lock
);
434 ret
= regmap_field_write(data
->reg_state
, state
);
436 dev_err(&client
->dev
, "failed to change sensor state\n");
437 } else if (state
!= STK3310_STATE_STANDBY
) {
438 /* Don't reset the 'enabled' flags if we're going in standby */
439 data
->ps_enabled
= !!(state
& STK3310_STATE_EN_PS
);
440 data
->als_enabled
= !!(state
& STK3310_STATE_EN_ALS
);
442 mutex_unlock(&data
->lock
);
447 static int stk3310_init(struct iio_dev
*indio_dev
)
452 struct stk3310_data
*data
= iio_priv(indio_dev
);
453 struct i2c_client
*client
= data
->client
;
455 ret
= regmap_read(data
->regmap
, STK3310_REG_ID
, &chipid
);
459 if (chipid
!= STK3310_CHIP_ID_VAL
&&
460 chipid
!= STK3311_CHIP_ID_VAL
) {
461 dev_err(&client
->dev
, "invalid chip id: 0x%x\n", chipid
);
465 state
= STK3310_STATE_EN_ALS
| STK3310_STATE_EN_PS
;
466 ret
= stk3310_set_state(data
, state
);
468 dev_err(&client
->dev
, "failed to enable sensor");
472 /* Enable PS interrupts */
473 ret
= regmap_field_write(data
->reg_int_ps
, STK3310_PSINT_EN
);
475 dev_err(&client
->dev
, "failed to enable interrupts!\n");
480 static int stk3310_gpio_probe(struct i2c_client
*client
)
483 struct gpio_desc
*gpio
;
491 /* gpio interrupt pin */
492 gpio
= devm_gpiod_get_index(dev
, STK3310_GPIO
, 0);
494 dev_err(dev
, "acpi gpio get index failed\n");
495 return PTR_ERR(gpio
);
498 ret
= gpiod_direction_input(gpio
);
502 ret
= gpiod_to_irq(gpio
);
503 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
508 static bool stk3310_is_volatile_reg(struct device
*dev
, unsigned int reg
)
511 case STK3310_REG_ALS_DATA_MSB
:
512 case STK3310_REG_ALS_DATA_LSB
:
513 case STK3310_REG_PS_DATA_LSB
:
514 case STK3310_REG_PS_DATA_MSB
:
515 case STK3310_REG_FLAG
:
522 static struct regmap_config stk3310_regmap_config
= {
523 .name
= STK3310_REGMAP_NAME
,
526 .max_register
= STK3310_MAX_REG
,
527 .cache_type
= REGCACHE_RBTREE
,
528 .volatile_reg
= stk3310_is_volatile_reg
,
531 static int stk3310_regmap_init(struct stk3310_data
*data
)
533 struct regmap
*regmap
;
534 struct i2c_client
*client
;
536 client
= data
->client
;
537 regmap
= devm_regmap_init_i2c(client
, &stk3310_regmap_config
);
538 if (IS_ERR(regmap
)) {
539 dev_err(&client
->dev
, "regmap initialization failed.\n");
540 return PTR_ERR(regmap
);
542 data
->regmap
= regmap
;
544 STK3310_REGFIELD(state
);
545 STK3310_REGFIELD(als_gain
);
546 STK3310_REGFIELD(ps_gain
);
547 STK3310_REGFIELD(als_it
);
548 STK3310_REGFIELD(ps_it
);
549 STK3310_REGFIELD(int_ps
);
550 STK3310_REGFIELD(flag_psint
);
551 STK3310_REGFIELD(flag_nf
);
556 static irqreturn_t
stk3310_irq_handler(int irq
, void *private)
558 struct iio_dev
*indio_dev
= private;
559 struct stk3310_data
*data
= iio_priv(indio_dev
);
561 data
->timestamp
= iio_get_time_ns();
563 return IRQ_WAKE_THREAD
;
566 static irqreturn_t
stk3310_irq_event_handler(int irq
, void *private)
572 struct iio_dev
*indio_dev
= private;
573 struct stk3310_data
*data
= iio_priv(indio_dev
);
575 /* Read FLAG_NF to figure out what threshold has been met. */
576 mutex_lock(&data
->lock
);
577 ret
= regmap_field_read(data
->reg_flag_nf
, &dir
);
579 dev_err(&data
->client
->dev
, "register read failed\n");
580 mutex_unlock(&data
->lock
);
583 event
= IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY
, 1,
585 (dir
? IIO_EV_DIR_FALLING
:
587 iio_push_event(indio_dev
, event
, data
->timestamp
);
589 /* Reset the interrupt flag */
590 ret
= regmap_field_write(data
->reg_flag_psint
, 0);
592 dev_err(&data
->client
->dev
, "failed to reset interrupts\n");
593 mutex_unlock(&data
->lock
);
598 static int stk3310_probe(struct i2c_client
*client
,
599 const struct i2c_device_id
*id
)
602 struct iio_dev
*indio_dev
;
603 struct stk3310_data
*data
;
605 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
607 dev_err(&client
->dev
, "iio allocation failed!\n");
611 data
= iio_priv(indio_dev
);
612 data
->client
= client
;
613 i2c_set_clientdata(client
, indio_dev
);
614 mutex_init(&data
->lock
);
616 ret
= stk3310_regmap_init(data
);
620 indio_dev
->dev
.parent
= &client
->dev
;
621 indio_dev
->info
= &stk3310_info
;
622 indio_dev
->name
= STK3310_DRIVER_NAME
;
623 indio_dev
->modes
= INDIO_DIRECT_MODE
;
624 indio_dev
->channels
= stk3310_channels
;
625 indio_dev
->num_channels
= ARRAY_SIZE(stk3310_channels
);
627 ret
= stk3310_init(indio_dev
);
631 if (client
->irq
< 0) {
632 client
->irq
= stk3310_gpio_probe(client
);
633 if (client
->irq
< 0) {
639 if (client
->irq
>= 0) {
640 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
642 stk3310_irq_event_handler
,
643 IRQF_TRIGGER_FALLING
|
645 STK3310_EVENT
, indio_dev
);
647 dev_err(&client
->dev
, "request irq %d failed\n",
653 ret
= iio_device_register(indio_dev
);
655 dev_err(&client
->dev
, "device_register failed\n");
662 stk3310_set_state(data
, STK3310_STATE_STANDBY
);
666 static int stk3310_remove(struct i2c_client
*client
)
668 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
670 iio_device_unregister(indio_dev
);
671 return stk3310_set_state(iio_priv(indio_dev
), STK3310_STATE_STANDBY
);
674 #ifdef CONFIG_PM_SLEEP
675 static int stk3310_suspend(struct device
*dev
)
677 struct stk3310_data
*data
;
679 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
681 return stk3310_set_state(data
, STK3310_STATE_STANDBY
);
684 static int stk3310_resume(struct device
*dev
)
687 struct stk3310_data
*data
;
689 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
690 if (data
->ps_enabled
)
691 state
|= STK3310_STATE_EN_PS
;
692 if (data
->als_enabled
)
693 state
|= STK3310_STATE_EN_ALS
;
695 return stk3310_set_state(data
, state
);
698 static SIMPLE_DEV_PM_OPS(stk3310_pm_ops
, stk3310_suspend
, stk3310_resume
);
700 #define STK3310_PM_OPS (&stk3310_pm_ops)
702 #define STK3310_PM_OPS NULL
705 static const struct i2c_device_id stk3310_i2c_id
[] = {
710 MODULE_DEVICE_TABLE(i2c
, stk3310_i2c_id
);
712 static const struct acpi_device_id stk3310_acpi_id
[] = {
718 MODULE_DEVICE_TABLE(acpi
, stk3310_acpi_id
);
720 static struct i2c_driver stk3310_driver
= {
723 .pm
= STK3310_PM_OPS
,
724 .acpi_match_table
= ACPI_PTR(stk3310_acpi_id
),
726 .probe
= stk3310_probe
,
727 .remove
= stk3310_remove
,
728 .id_table
= stk3310_i2c_id
,
731 module_i2c_driver(stk3310_driver
);
733 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
734 MODULE_DESCRIPTION("STK3310 Ambient Light and Proximity Sensor driver");
735 MODULE_LICENSE("GPL v2");