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 0x01
39 #define STK3310_STATE_EN_ALS 0x02
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 regmap_field_read(data
->reg_ps_gain
, &index
);
245 if (val
> stk3310_ps_max
[index
])
248 if (dir
== IIO_EV_DIR_RISING
)
249 reg
= STK3310_REG_THDH_PS
;
250 else if (dir
== IIO_EV_DIR_FALLING
)
251 reg
= STK3310_REG_THDL_PS
;
255 buf
= cpu_to_be16(val
);
256 ret
= regmap_bulk_write(data
->regmap
, reg
, &buf
, 2);
258 dev_err(&client
->dev
, "failed to set PS threshold!\n");
263 static int stk3310_read_event_config(struct iio_dev
*indio_dev
,
264 const struct iio_chan_spec
*chan
,
265 enum iio_event_type type
,
266 enum iio_event_direction dir
)
268 unsigned int event_val
;
269 struct stk3310_data
*data
= iio_priv(indio_dev
);
271 regmap_field_read(data
->reg_int_ps
, &event_val
);
276 static int stk3310_write_event_config(struct iio_dev
*indio_dev
,
277 const struct iio_chan_spec
*chan
,
278 enum iio_event_type type
,
279 enum iio_event_direction dir
,
283 struct stk3310_data
*data
= iio_priv(indio_dev
);
284 struct i2c_client
*client
= data
->client
;
286 if (state
< 0 || state
> 7)
289 /* Set INT_PS value */
290 mutex_lock(&data
->lock
);
291 ret
= regmap_field_write(data
->reg_int_ps
, state
);
293 dev_err(&client
->dev
, "failed to set interrupt mode\n");
294 mutex_unlock(&data
->lock
);
299 static int stk3310_read_raw(struct iio_dev
*indio_dev
,
300 struct iio_chan_spec
const *chan
,
301 int *val
, int *val2
, long mask
)
307 struct stk3310_data
*data
= iio_priv(indio_dev
);
308 struct i2c_client
*client
= data
->client
;
311 case IIO_CHAN_INFO_RAW
:
312 if (chan
->type
== IIO_LIGHT
)
313 reg
= STK3310_REG_ALS_DATA_MSB
;
314 else if (chan
->type
== IIO_PROXIMITY
)
315 reg
= STK3310_REG_PS_DATA_MSB
;
318 mutex_lock(&data
->lock
);
319 ret
= regmap_bulk_read(data
->regmap
, reg
, &buf
, 2);
321 dev_err(&client
->dev
, "register read failed\n");
322 mutex_unlock(&data
->lock
);
325 *val
= be16_to_cpu(buf
);
326 mutex_unlock(&data
->lock
);
328 case IIO_CHAN_INFO_INT_TIME
:
329 if (chan
->type
== IIO_LIGHT
)
330 regmap_field_read(data
->reg_als_it
, &index
);
332 regmap_field_read(data
->reg_ps_it
, &index
);
333 *val
= stk3310_it_table
[index
][0];
334 *val2
= stk3310_it_table
[index
][1];
335 return IIO_VAL_INT_PLUS_MICRO
;
336 case IIO_CHAN_INFO_SCALE
:
337 if (chan
->type
== IIO_LIGHT
)
338 regmap_field_read(data
->reg_als_gain
, &index
);
340 regmap_field_read(data
->reg_ps_gain
, &index
);
341 *val
= stk3310_scale_table
[index
][0];
342 *val2
= stk3310_scale_table
[index
][1];
343 return IIO_VAL_INT_PLUS_MICRO
;
349 static int stk3310_write_raw(struct iio_dev
*indio_dev
,
350 struct iio_chan_spec
const *chan
,
351 int val
, int val2
, long mask
)
355 struct stk3310_data
*data
= iio_priv(indio_dev
);
358 case IIO_CHAN_INFO_INT_TIME
:
359 index
= stk3310_get_index(stk3310_it_table
,
360 ARRAY_SIZE(stk3310_it_table
),
364 mutex_lock(&data
->lock
);
365 if (chan
->type
== IIO_LIGHT
)
366 ret
= regmap_field_write(data
->reg_als_it
, index
);
368 ret
= regmap_field_write(data
->reg_ps_it
, index
);
370 dev_err(&data
->client
->dev
,
371 "sensor configuration failed\n");
372 mutex_unlock(&data
->lock
);
375 case IIO_CHAN_INFO_SCALE
:
376 index
= stk3310_get_index(stk3310_scale_table
,
377 ARRAY_SIZE(stk3310_scale_table
),
381 mutex_lock(&data
->lock
);
382 if (chan
->type
== IIO_LIGHT
)
383 ret
= regmap_field_write(data
->reg_als_gain
, index
);
385 ret
= regmap_field_write(data
->reg_ps_gain
, index
);
387 dev_err(&data
->client
->dev
,
388 "sensor configuration failed\n");
389 mutex_unlock(&data
->lock
);
396 static const struct iio_info stk3310_info
= {
397 .driver_module
= THIS_MODULE
,
398 .read_raw
= stk3310_read_raw
,
399 .write_raw
= stk3310_write_raw
,
400 .attrs
= &stk3310_attribute_group
,
401 .read_event_value
= stk3310_read_event
,
402 .write_event_value
= stk3310_write_event
,
403 .read_event_config
= stk3310_read_event_config
,
404 .write_event_config
= stk3310_write_event_config
,
407 static int stk3310_set_state(struct stk3310_data
*data
, u8 state
)
410 struct i2c_client
*client
= data
->client
;
412 /* 3-bit state; 0b100 is not supported. */
413 if (state
> 7 || state
== 4)
416 mutex_lock(&data
->lock
);
417 ret
= regmap_field_write(data
->reg_state
, state
);
419 dev_err(&client
->dev
, "failed to change sensor state\n");
420 } else if (state
!= STK3310_STATE_STANDBY
) {
421 /* Don't reset the 'enabled' flags if we're going in standby */
422 data
->ps_enabled
= !!(state
& 0x01);
423 data
->als_enabled
= !!(state
& 0x02);
425 mutex_unlock(&data
->lock
);
430 static int stk3310_init(struct iio_dev
*indio_dev
)
435 struct stk3310_data
*data
= iio_priv(indio_dev
);
436 struct i2c_client
*client
= data
->client
;
438 regmap_read(data
->regmap
, STK3310_REG_ID
, &chipid
);
439 if (chipid
!= STK3310_CHIP_ID_VAL
&&
440 chipid
!= STK3311_CHIP_ID_VAL
) {
441 dev_err(&client
->dev
, "invalid chip id: 0x%x\n", chipid
);
445 state
= STK3310_STATE_EN_ALS
| STK3310_STATE_EN_PS
;
446 ret
= stk3310_set_state(data
, state
);
448 dev_err(&client
->dev
, "failed to enable sensor");
452 /* Enable PS interrupts */
453 ret
= regmap_field_write(data
->reg_int_ps
, STK3310_PSINT_EN
);
455 dev_err(&client
->dev
, "failed to enable interrupts!\n");
460 static int stk3310_gpio_probe(struct i2c_client
*client
)
463 struct gpio_desc
*gpio
;
471 /* gpio interrupt pin */
472 gpio
= devm_gpiod_get_index(dev
, STK3310_GPIO
, 0, GPIOD_IN
);
474 dev_err(dev
, "acpi gpio get index failed\n");
475 return PTR_ERR(gpio
);
478 ret
= gpiod_to_irq(gpio
);
479 dev_dbg(dev
, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio
), ret
);
484 static bool stk3310_is_volatile_reg(struct device
*dev
, unsigned int reg
)
487 case STK3310_REG_ALS_DATA_MSB
:
488 case STK3310_REG_ALS_DATA_LSB
:
489 case STK3310_REG_PS_DATA_LSB
:
490 case STK3310_REG_PS_DATA_MSB
:
491 case STK3310_REG_FLAG
:
498 static struct regmap_config stk3310_regmap_config
= {
499 .name
= STK3310_REGMAP_NAME
,
502 .max_register
= STK3310_MAX_REG
,
503 .cache_type
= REGCACHE_RBTREE
,
504 .volatile_reg
= stk3310_is_volatile_reg
,
507 static int stk3310_regmap_init(struct stk3310_data
*data
)
509 struct regmap
*regmap
;
510 struct i2c_client
*client
;
512 client
= data
->client
;
513 regmap
= devm_regmap_init_i2c(client
, &stk3310_regmap_config
);
514 if (IS_ERR(regmap
)) {
515 dev_err(&client
->dev
, "regmap initialization failed.\n");
516 return PTR_ERR(regmap
);
518 data
->regmap
= regmap
;
520 STK3310_REGFIELD(state
);
521 STK3310_REGFIELD(als_gain
);
522 STK3310_REGFIELD(ps_gain
);
523 STK3310_REGFIELD(als_it
);
524 STK3310_REGFIELD(ps_it
);
525 STK3310_REGFIELD(int_ps
);
526 STK3310_REGFIELD(flag_psint
);
527 STK3310_REGFIELD(flag_nf
);
532 static irqreturn_t
stk3310_irq_handler(int irq
, void *private)
534 struct iio_dev
*indio_dev
= private;
535 struct stk3310_data
*data
= iio_priv(indio_dev
);
537 data
->timestamp
= iio_get_time_ns();
539 return IRQ_WAKE_THREAD
;
542 static irqreturn_t
stk3310_irq_event_handler(int irq
, void *private)
548 struct iio_dev
*indio_dev
= private;
549 struct stk3310_data
*data
= iio_priv(indio_dev
);
551 /* Read FLAG_NF to figure out what threshold has been met. */
552 mutex_lock(&data
->lock
);
553 ret
= regmap_field_read(data
->reg_flag_nf
, &dir
);
555 dev_err(&data
->client
->dev
, "register read failed\n");
556 mutex_unlock(&data
->lock
);
559 event
= IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY
, 1,
561 (dir
? IIO_EV_DIR_FALLING
:
563 iio_push_event(indio_dev
, event
, data
->timestamp
);
565 /* Reset the interrupt flag */
566 ret
= regmap_field_write(data
->reg_flag_psint
, 0);
568 dev_err(&data
->client
->dev
, "failed to reset interrupts\n");
569 mutex_unlock(&data
->lock
);
574 static int stk3310_probe(struct i2c_client
*client
,
575 const struct i2c_device_id
*id
)
578 struct iio_dev
*indio_dev
;
579 struct stk3310_data
*data
;
581 indio_dev
= devm_iio_device_alloc(&client
->dev
, sizeof(*data
));
583 dev_err(&client
->dev
, "iio allocation failed!\n");
587 data
= iio_priv(indio_dev
);
588 data
->client
= client
;
589 i2c_set_clientdata(client
, indio_dev
);
590 mutex_init(&data
->lock
);
592 ret
= stk3310_regmap_init(data
);
596 indio_dev
->dev
.parent
= &client
->dev
;
597 indio_dev
->info
= &stk3310_info
;
598 indio_dev
->name
= STK3310_DRIVER_NAME
;
599 indio_dev
->modes
= INDIO_DIRECT_MODE
;
600 indio_dev
->channels
= stk3310_channels
;
601 indio_dev
->num_channels
= ARRAY_SIZE(stk3310_channels
);
603 ret
= stk3310_init(indio_dev
);
608 client
->irq
= stk3310_gpio_probe(client
);
610 if (client
->irq
>= 0) {
611 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
613 stk3310_irq_event_handler
,
614 IRQF_TRIGGER_FALLING
|
616 STK3310_EVENT
, indio_dev
);
618 dev_err(&client
->dev
, "request irq %d failed\n",
622 ret
= iio_device_register(indio_dev
);
624 dev_err(&client
->dev
, "device_register failed\n");
625 stk3310_set_state(data
, STK3310_STATE_STANDBY
);
631 static int stk3310_remove(struct i2c_client
*client
)
633 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
635 iio_device_unregister(indio_dev
);
636 return stk3310_set_state(iio_priv(indio_dev
), STK3310_STATE_STANDBY
);
639 #ifdef CONFIG_PM_SLEEP
640 static int stk3310_suspend(struct device
*dev
)
642 struct stk3310_data
*data
;
644 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
646 return stk3310_set_state(data
, STK3310_STATE_STANDBY
);
649 static int stk3310_resume(struct device
*dev
)
652 struct stk3310_data
*data
;
654 data
= iio_priv(i2c_get_clientdata(to_i2c_client(dev
)));
655 if (data
->ps_enabled
)
656 state
|= STK3310_STATE_EN_PS
;
657 if (data
->als_enabled
)
658 state
|= STK3310_STATE_EN_ALS
;
660 return stk3310_set_state(data
, state
);
663 static SIMPLE_DEV_PM_OPS(stk3310_pm_ops
, stk3310_suspend
, stk3310_resume
);
665 #define STK3310_PM_OPS (&stk3310_pm_ops)
667 #define STK3310_PM_OPS NULL
670 static const struct i2c_device_id stk3310_i2c_id
[] = {
675 MODULE_DEVICE_TABLE(i2c
, stk3310_i2c_id
);
677 static const struct acpi_device_id stk3310_acpi_id
[] = {
683 MODULE_DEVICE_TABLE(acpi
, stk3310_acpi_id
);
685 static struct i2c_driver stk3310_driver
= {
688 .pm
= STK3310_PM_OPS
,
689 .acpi_match_table
= ACPI_PTR(stk3310_acpi_id
),
691 .probe
= stk3310_probe
,
692 .remove
= stk3310_remove
,
693 .id_table
= stk3310_i2c_id
,
696 module_i2c_driver(stk3310_driver
);
698 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
699 MODULE_DESCRIPTION("STK3310 Ambient Light and Proximity Sensor driver");
700 MODULE_LICENSE("GPL v2");