1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * ACPI Ambient Light Sensor Driver |
4 | * |
5 | * Based on ALS driver: |
6 | * Copyright (C) 2009 Zhang Rui <rui.zhang@intel.com> |
7 | * |
8 | * Rework for IIO subsystem: |
9 | * Copyright (C) 2012-2013 Martin Liska <marxin.liska@gmail.com> |
10 | * |
11 | * Final cleanup and debugging: |
12 | * Copyright (C) 2013-2014 Marek Vasut <marex@denx.de> |
13 | * Copyright (C) 2015 Gabriele Mazzotta <gabriele.mzt@gmail.com> |
14 | */ |
15 | |
16 | #include <linux/module.h> |
17 | #include <linux/acpi.h> |
18 | #include <linux/err.h> |
19 | #include <linux/irq.h> |
20 | #include <linux/mutex.h> |
21 | |
22 | #include <linux/iio/iio.h> |
23 | #include <linux/iio/buffer.h> |
24 | #include <linux/iio/trigger.h> |
25 | #include <linux/iio/triggered_buffer.h> |
26 | #include <linux/iio/trigger_consumer.h> |
27 | |
28 | #define ACPI_ALS_CLASS "als" |
29 | #define ACPI_ALS_DEVICE_NAME "acpi-als" |
30 | #define ACPI_ALS_NOTIFY_ILLUMINANCE 0x80 |
31 | |
32 | /* |
33 | * So far, there's only one channel in here, but the specification for |
34 | * ACPI0008 says there can be more to what the block can report. Like |
35 | * chromaticity and such. We are ready for incoming additions! |
36 | */ |
37 | static const struct iio_chan_spec acpi_als_channels[] = { |
38 | { |
39 | .type = IIO_LIGHT, |
40 | .scan_type = { |
41 | .sign = 's', |
42 | .realbits = 32, |
43 | .storagebits = 32, |
44 | }, |
45 | /* _RAW is here for backward ABI compatibility */ |
46 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | |
47 | BIT(IIO_CHAN_INFO_PROCESSED), |
48 | }, |
49 | IIO_CHAN_SOFT_TIMESTAMP(1), |
50 | }; |
51 | |
52 | /* |
53 | * The event buffer contains timestamp and all the data from |
54 | * the ACPI0008 block. There are multiple, but so far we only |
55 | * support _ALI (illuminance): One channel, padding and timestamp. |
56 | */ |
57 | #define ACPI_ALS_EVT_BUFFER_SIZE \ |
58 | (sizeof(s32) + sizeof(s32) + sizeof(s64)) |
59 | |
60 | struct acpi_als { |
61 | struct acpi_device *device; |
62 | struct mutex lock; |
63 | struct iio_trigger *trig; |
64 | |
65 | s32 evt_buffer[ACPI_ALS_EVT_BUFFER_SIZE / sizeof(s32)] __aligned(8); |
66 | }; |
67 | |
68 | /* |
69 | * All types of properties the ACPI0008 block can report. The ALI, ALC, ALT |
70 | * and ALP can all be handled by acpi_als_read_value() below, while the ALR is |
71 | * special. |
72 | * |
73 | * The _ALR property returns tables that can be used to fine-tune the values |
74 | * reported by the other props based on the particular hardware type and it's |
75 | * location (it contains tables for "rainy", "bright inhouse lighting" etc.). |
76 | * |
77 | * So far, we support only ALI (illuminance). |
78 | */ |
79 | #define ACPI_ALS_ILLUMINANCE "_ALI" |
80 | #define ACPI_ALS_CHROMATICITY "_ALC" |
81 | #define ACPI_ALS_COLOR_TEMP "_ALT" |
82 | #define ACPI_ALS_POLLING "_ALP" |
83 | #define ACPI_ALS_TABLES "_ALR" |
84 | |
85 | static int acpi_als_read_value(struct acpi_als *als, char *prop, s32 *val) |
86 | { |
87 | unsigned long long temp_val; |
88 | acpi_status status; |
89 | |
90 | status = acpi_evaluate_integer(handle: als->device->handle, pathname: prop, NULL, |
91 | data: &temp_val); |
92 | |
93 | if (ACPI_FAILURE(status)) { |
94 | acpi_evaluation_failure_warn(handle: als->device->handle, name: prop, status); |
95 | return -EIO; |
96 | } |
97 | |
98 | *val = temp_val; |
99 | |
100 | return 0; |
101 | } |
102 | |
103 | static void acpi_als_notify(struct acpi_device *device, u32 event) |
104 | { |
105 | struct iio_dev *indio_dev = acpi_driver_data(d: device); |
106 | struct acpi_als *als = iio_priv(indio_dev); |
107 | |
108 | if (iio_buffer_enabled(indio_dev) && iio_trigger_using_own(indio_dev)) { |
109 | switch (event) { |
110 | case ACPI_ALS_NOTIFY_ILLUMINANCE: |
111 | iio_trigger_poll_nested(trig: als->trig); |
112 | break; |
113 | default: |
114 | /* Unhandled event */ |
115 | dev_dbg(&device->dev, |
116 | "Unhandled ACPI ALS event (%08x)!\n" , |
117 | event); |
118 | } |
119 | } |
120 | } |
121 | |
122 | static int acpi_als_read_raw(struct iio_dev *indio_dev, |
123 | struct iio_chan_spec const *chan, int *val, |
124 | int *val2, long mask) |
125 | { |
126 | struct acpi_als *als = iio_priv(indio_dev); |
127 | s32 temp_val; |
128 | int ret; |
129 | |
130 | if ((mask != IIO_CHAN_INFO_PROCESSED) && (mask != IIO_CHAN_INFO_RAW)) |
131 | return -EINVAL; |
132 | |
133 | /* we support only illumination (_ALI) so far. */ |
134 | if (chan->type != IIO_LIGHT) |
135 | return -EINVAL; |
136 | |
137 | ret = acpi_als_read_value(als, ACPI_ALS_ILLUMINANCE, val: &temp_val); |
138 | if (ret < 0) |
139 | return ret; |
140 | |
141 | *val = temp_val; |
142 | |
143 | return IIO_VAL_INT; |
144 | } |
145 | |
146 | static const struct iio_info acpi_als_info = { |
147 | .read_raw = acpi_als_read_raw, |
148 | }; |
149 | |
150 | static irqreturn_t acpi_als_trigger_handler(int irq, void *p) |
151 | { |
152 | struct iio_poll_func *pf = p; |
153 | struct iio_dev *indio_dev = pf->indio_dev; |
154 | struct acpi_als *als = iio_priv(indio_dev); |
155 | s32 *buffer = als->evt_buffer; |
156 | s32 val; |
157 | int ret; |
158 | |
159 | mutex_lock(&als->lock); |
160 | |
161 | ret = acpi_als_read_value(als, ACPI_ALS_ILLUMINANCE, val: &val); |
162 | if (ret < 0) |
163 | goto out; |
164 | *buffer = val; |
165 | |
166 | /* |
167 | * When coming from own trigger via polls, set polling function |
168 | * timestamp here. Given ACPI notifier is already in a thread and call |
169 | * function directly, there is no need to set the timestamp in the |
170 | * notify function. |
171 | * |
172 | * If the timestamp was actually 0, the timestamp is set one more time. |
173 | */ |
174 | if (!pf->timestamp) |
175 | pf->timestamp = iio_get_time_ns(indio_dev); |
176 | |
177 | iio_push_to_buffers_with_timestamp(indio_dev, data: buffer, timestamp: pf->timestamp); |
178 | out: |
179 | mutex_unlock(lock: &als->lock); |
180 | iio_trigger_notify_done(trig: indio_dev->trig); |
181 | |
182 | return IRQ_HANDLED; |
183 | } |
184 | |
185 | static int acpi_als_add(struct acpi_device *device) |
186 | { |
187 | struct device *dev = &device->dev; |
188 | struct iio_dev *indio_dev; |
189 | struct acpi_als *als; |
190 | int ret; |
191 | |
192 | indio_dev = devm_iio_device_alloc(parent: dev, sizeof_priv: sizeof(*als)); |
193 | if (!indio_dev) |
194 | return -ENOMEM; |
195 | |
196 | als = iio_priv(indio_dev); |
197 | |
198 | device->driver_data = indio_dev; |
199 | als->device = device; |
200 | mutex_init(&als->lock); |
201 | |
202 | indio_dev->name = ACPI_ALS_DEVICE_NAME; |
203 | indio_dev->info = &acpi_als_info; |
204 | indio_dev->channels = acpi_als_channels; |
205 | indio_dev->num_channels = ARRAY_SIZE(acpi_als_channels); |
206 | |
207 | als->trig = devm_iio_trigger_alloc(dev, "%s-dev%d" , indio_dev->name, |
208 | iio_device_id(indio_dev)); |
209 | if (!als->trig) |
210 | return -ENOMEM; |
211 | |
212 | ret = devm_iio_trigger_register(dev, trig_info: als->trig); |
213 | if (ret) |
214 | return ret; |
215 | /* |
216 | * Set hardware trigger by default to let events flow when |
217 | * BIOS support notification. |
218 | */ |
219 | indio_dev->trig = iio_trigger_get(trig: als->trig); |
220 | |
221 | ret = devm_iio_triggered_buffer_setup(dev, indio_dev, |
222 | iio_pollfunc_store_time, |
223 | acpi_als_trigger_handler, |
224 | NULL); |
225 | if (ret) |
226 | return ret; |
227 | |
228 | return devm_iio_device_register(dev, indio_dev); |
229 | } |
230 | |
231 | static const struct acpi_device_id acpi_als_device_ids[] = { |
232 | {"ACPI0008" , 0}, |
233 | {}, |
234 | }; |
235 | |
236 | MODULE_DEVICE_TABLE(acpi, acpi_als_device_ids); |
237 | |
238 | static struct acpi_driver acpi_als_driver = { |
239 | .name = "acpi_als" , |
240 | .class = ACPI_ALS_CLASS, |
241 | .ids = acpi_als_device_ids, |
242 | .ops = { |
243 | .add = acpi_als_add, |
244 | .notify = acpi_als_notify, |
245 | }, |
246 | }; |
247 | |
248 | module_acpi_driver(acpi_als_driver); |
249 | |
250 | MODULE_AUTHOR("Zhang Rui <rui.zhang@intel.com>" ); |
251 | MODULE_AUTHOR("Martin Liska <marxin.liska@gmail.com>" ); |
252 | MODULE_AUTHOR("Marek Vasut <marex@denx.de>" ); |
253 | MODULE_DESCRIPTION("ACPI Ambient Light Sensor Driver" ); |
254 | MODULE_LICENSE("GPL" ); |
255 | |