1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * HID Sensor Time Driver |
4 | * Copyright (c) 2012, Alexander Holler. |
5 | */ |
6 | #include <linux/device.h> |
7 | #include <linux/platform_device.h> |
8 | #include <linux/module.h> |
9 | #include <linux/hid-sensor-hub.h> |
10 | #include <linux/iio/iio.h> |
11 | #include <linux/rtc.h> |
12 | |
13 | enum hid_time_channel { |
14 | CHANNEL_SCAN_INDEX_YEAR, |
15 | CHANNEL_SCAN_INDEX_MONTH, |
16 | CHANNEL_SCAN_INDEX_DAY, |
17 | CHANNEL_SCAN_INDEX_HOUR, |
18 | CHANNEL_SCAN_INDEX_MINUTE, |
19 | CHANNEL_SCAN_INDEX_SECOND, |
20 | TIME_RTC_CHANNEL_MAX, |
21 | }; |
22 | |
23 | struct hid_time_state { |
24 | struct hid_sensor_hub_callbacks callbacks; |
25 | struct hid_sensor_common common_attributes; |
26 | struct hid_sensor_hub_attribute_info info[TIME_RTC_CHANNEL_MAX]; |
27 | struct rtc_time last_time; |
28 | spinlock_t lock_last_time; |
29 | struct completion comp_last_time; |
30 | struct rtc_time time_buf; |
31 | struct rtc_device *rtc; |
32 | }; |
33 | |
34 | static const u32 hid_time_addresses[TIME_RTC_CHANNEL_MAX] = { |
35 | HID_USAGE_SENSOR_TIME_YEAR, |
36 | HID_USAGE_SENSOR_TIME_MONTH, |
37 | HID_USAGE_SENSOR_TIME_DAY, |
38 | HID_USAGE_SENSOR_TIME_HOUR, |
39 | HID_USAGE_SENSOR_TIME_MINUTE, |
40 | HID_USAGE_SENSOR_TIME_SECOND, |
41 | }; |
42 | |
43 | /* Channel names for verbose error messages */ |
44 | static const char * const hid_time_channel_names[TIME_RTC_CHANNEL_MAX] = { |
45 | "year" , "month" , "day" , "hour" , "minute" , "second" , |
46 | }; |
47 | |
48 | /* Callback handler to send event after all samples are received and captured */ |
49 | static int hid_time_proc_event(struct hid_sensor_hub_device *hsdev, |
50 | unsigned usage_id, void *priv) |
51 | { |
52 | unsigned long flags; |
53 | struct hid_time_state *time_state = platform_get_drvdata(pdev: priv); |
54 | |
55 | spin_lock_irqsave(&time_state->lock_last_time, flags); |
56 | time_state->last_time = time_state->time_buf; |
57 | spin_unlock_irqrestore(lock: &time_state->lock_last_time, flags); |
58 | complete(&time_state->comp_last_time); |
59 | return 0; |
60 | } |
61 | |
62 | static u32 hid_time_value(size_t raw_len, char *raw_data) |
63 | { |
64 | switch (raw_len) { |
65 | case 1: |
66 | return *(u8 *)raw_data; |
67 | case 2: |
68 | return *(u16 *)raw_data; |
69 | case 4: |
70 | return *(u32 *)raw_data; |
71 | default: |
72 | return (u32)(~0U); /* 0xff... or -1 to denote an error */ |
73 | } |
74 | } |
75 | |
76 | static int hid_time_capture_sample(struct hid_sensor_hub_device *hsdev, |
77 | unsigned usage_id, size_t raw_len, |
78 | char *raw_data, void *priv) |
79 | { |
80 | struct hid_time_state *time_state = platform_get_drvdata(pdev: priv); |
81 | struct rtc_time *time_buf = &time_state->time_buf; |
82 | |
83 | switch (usage_id) { |
84 | case HID_USAGE_SENSOR_TIME_YEAR: |
85 | /* |
86 | * The draft for HID-sensors (HUTRR39) currently doesn't define |
87 | * the range for the year attribute. Therefor we support |
88 | * 8 bit (0-99) and 16 or 32 bits (full) as size for the year. |
89 | */ |
90 | if (raw_len == 1) { |
91 | time_buf->tm_year = *(u8 *)raw_data; |
92 | if (time_buf->tm_year < 70) |
93 | /* assume we are in 1970...2069 */ |
94 | time_buf->tm_year += 100; |
95 | } else |
96 | time_buf->tm_year = |
97 | (int)hid_time_value(raw_len, raw_data)-1900; |
98 | break; |
99 | case HID_USAGE_SENSOR_TIME_MONTH: |
100 | /* sensors are sending the month as 1-12, we need 0-11 */ |
101 | time_buf->tm_mon = (int)hid_time_value(raw_len, raw_data)-1; |
102 | break; |
103 | case HID_USAGE_SENSOR_TIME_DAY: |
104 | time_buf->tm_mday = (int)hid_time_value(raw_len, raw_data); |
105 | break; |
106 | case HID_USAGE_SENSOR_TIME_HOUR: |
107 | time_buf->tm_hour = (int)hid_time_value(raw_len, raw_data); |
108 | break; |
109 | case HID_USAGE_SENSOR_TIME_MINUTE: |
110 | time_buf->tm_min = (int)hid_time_value(raw_len, raw_data); |
111 | break; |
112 | case HID_USAGE_SENSOR_TIME_SECOND: |
113 | time_buf->tm_sec = (int)hid_time_value(raw_len, raw_data); |
114 | break; |
115 | default: |
116 | return -EINVAL; |
117 | } |
118 | return 0; |
119 | } |
120 | |
121 | /* small helper, haven't found any other way */ |
122 | static const char *hid_time_attrib_name(u32 attrib_id) |
123 | { |
124 | static const char unknown[] = "unknown" ; |
125 | unsigned i; |
126 | |
127 | for (i = 0; i < TIME_RTC_CHANNEL_MAX; ++i) { |
128 | if (hid_time_addresses[i] == attrib_id) |
129 | return hid_time_channel_names[i]; |
130 | } |
131 | return unknown; /* should never happen */ |
132 | } |
133 | |
134 | static int hid_time_parse_report(struct platform_device *pdev, |
135 | struct hid_sensor_hub_device *hsdev, |
136 | unsigned usage_id, |
137 | struct hid_time_state *time_state) |
138 | { |
139 | int report_id, i; |
140 | |
141 | for (i = 0; i < TIME_RTC_CHANNEL_MAX; ++i) |
142 | if (sensor_hub_input_get_attribute_info(hsdev, |
143 | type: HID_INPUT_REPORT, usage_id, |
144 | attr_usage_id: hid_time_addresses[i], |
145 | info: &time_state->info[i]) < 0) |
146 | return -EINVAL; |
147 | /* Check the (needed) attributes for sanity */ |
148 | report_id = time_state->info[0].report_id; |
149 | if (report_id < 0) { |
150 | dev_err(&pdev->dev, "bad report ID!\n" ); |
151 | return -EINVAL; |
152 | } |
153 | for (i = 0; i < TIME_RTC_CHANNEL_MAX; ++i) { |
154 | if (time_state->info[i].report_id != report_id) { |
155 | dev_err(&pdev->dev, |
156 | "not all needed attributes inside the same report!\n" ); |
157 | return -EINVAL; |
158 | } |
159 | if (time_state->info[i].size == 3 || |
160 | time_state->info[i].size > 4) { |
161 | dev_err(&pdev->dev, |
162 | "attribute '%s' not 8, 16 or 32 bits wide!\n" , |
163 | hid_time_attrib_name( |
164 | time_state->info[i].attrib_id)); |
165 | return -EINVAL; |
166 | } |
167 | if (time_state->info[i].units != |
168 | HID_USAGE_SENSOR_UNITS_NOT_SPECIFIED && |
169 | /* allow attribute seconds with unit seconds */ |
170 | !(time_state->info[i].attrib_id == |
171 | HID_USAGE_SENSOR_TIME_SECOND && |
172 | time_state->info[i].units == |
173 | HID_USAGE_SENSOR_UNITS_SECOND)) { |
174 | dev_err(&pdev->dev, |
175 | "attribute '%s' hasn't a unit of type 'none'!\n" , |
176 | hid_time_attrib_name( |
177 | time_state->info[i].attrib_id)); |
178 | return -EINVAL; |
179 | } |
180 | if (time_state->info[i].unit_expo) { |
181 | dev_err(&pdev->dev, |
182 | "attribute '%s' hasn't a unit exponent of 1!\n" , |
183 | hid_time_attrib_name( |
184 | time_state->info[i].attrib_id)); |
185 | return -EINVAL; |
186 | } |
187 | } |
188 | |
189 | return 0; |
190 | } |
191 | |
192 | static int hid_rtc_read_time(struct device *dev, struct rtc_time *tm) |
193 | { |
194 | unsigned long flags; |
195 | struct hid_time_state *time_state = dev_get_drvdata(dev); |
196 | int ret; |
197 | |
198 | reinit_completion(x: &time_state->comp_last_time); |
199 | /* get a report with all values through requesting one value */ |
200 | sensor_hub_input_attr_get_raw_value(hsdev: time_state->common_attributes.hsdev, |
201 | HID_USAGE_SENSOR_TIME, attr_usage_id: hid_time_addresses[0], |
202 | report_id: time_state->info[0].report_id, flag: SENSOR_HUB_SYNC, is_signed: false); |
203 | /* wait for all values (event) */ |
204 | ret = wait_for_completion_killable_timeout( |
205 | x: &time_state->comp_last_time, HZ*6); |
206 | if (ret > 0) { |
207 | /* no error */ |
208 | spin_lock_irqsave(&time_state->lock_last_time, flags); |
209 | *tm = time_state->last_time; |
210 | spin_unlock_irqrestore(lock: &time_state->lock_last_time, flags); |
211 | return 0; |
212 | } |
213 | if (!ret) |
214 | return -EIO; /* timeouted */ |
215 | return ret; /* killed (-ERESTARTSYS) */ |
216 | } |
217 | |
218 | static const struct rtc_class_ops hid_time_rtc_ops = { |
219 | .read_time = hid_rtc_read_time, |
220 | }; |
221 | |
222 | static int hid_time_probe(struct platform_device *pdev) |
223 | { |
224 | int ret = 0; |
225 | struct hid_sensor_hub_device *hsdev = dev_get_platdata(dev: &pdev->dev); |
226 | struct hid_time_state *time_state = devm_kzalloc(dev: &pdev->dev, |
227 | size: sizeof(struct hid_time_state), GFP_KERNEL); |
228 | |
229 | if (time_state == NULL) |
230 | return -ENOMEM; |
231 | |
232 | platform_set_drvdata(pdev, data: time_state); |
233 | |
234 | spin_lock_init(&time_state->lock_last_time); |
235 | init_completion(x: &time_state->comp_last_time); |
236 | time_state->common_attributes.hsdev = hsdev; |
237 | time_state->common_attributes.pdev = pdev; |
238 | |
239 | ret = hid_sensor_parse_common_attributes(hsdev, |
240 | HID_USAGE_SENSOR_TIME, |
241 | st: &time_state->common_attributes, |
242 | NULL, |
243 | sensitivity_addresses_len: 0); |
244 | if (ret) { |
245 | dev_err(&pdev->dev, "failed to setup common attributes!\n" ); |
246 | return ret; |
247 | } |
248 | |
249 | ret = hid_time_parse_report(pdev, hsdev, HID_USAGE_SENSOR_TIME, |
250 | time_state); |
251 | if (ret) { |
252 | dev_err(&pdev->dev, "failed to setup attributes!\n" ); |
253 | return ret; |
254 | } |
255 | |
256 | time_state->callbacks.send_event = hid_time_proc_event; |
257 | time_state->callbacks.capture_sample = hid_time_capture_sample; |
258 | time_state->callbacks.pdev = pdev; |
259 | ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_TIME, |
260 | usage_callback: &time_state->callbacks); |
261 | if (ret < 0) { |
262 | dev_err(&pdev->dev, "register callback failed!\n" ); |
263 | return ret; |
264 | } |
265 | |
266 | ret = sensor_hub_device_open(hsdev); |
267 | if (ret) { |
268 | dev_err(&pdev->dev, "failed to open sensor hub device!\n" ); |
269 | goto err_open; |
270 | } |
271 | |
272 | /* |
273 | * Enable HID input processing early in order to be able to read the |
274 | * clock already in devm_rtc_device_register(). |
275 | */ |
276 | hid_device_io_start(hid: hsdev->hdev); |
277 | |
278 | time_state->rtc = devm_rtc_device_register(dev: &pdev->dev, |
279 | name: "hid-sensor-time" , ops: &hid_time_rtc_ops, |
280 | THIS_MODULE); |
281 | |
282 | if (IS_ERR(ptr: time_state->rtc)) { |
283 | hid_device_io_stop(hid: hsdev->hdev); |
284 | ret = PTR_ERR(ptr: time_state->rtc); |
285 | time_state->rtc = NULL; |
286 | dev_err(&pdev->dev, "rtc device register failed!\n" ); |
287 | goto err_rtc; |
288 | } |
289 | |
290 | return ret; |
291 | |
292 | err_rtc: |
293 | sensor_hub_device_close(hsdev); |
294 | err_open: |
295 | sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME); |
296 | return ret; |
297 | } |
298 | |
299 | static void hid_time_remove(struct platform_device *pdev) |
300 | { |
301 | struct hid_sensor_hub_device *hsdev = dev_get_platdata(dev: &pdev->dev); |
302 | |
303 | sensor_hub_device_close(hsdev); |
304 | sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME); |
305 | } |
306 | |
307 | static const struct platform_device_id hid_time_ids[] = { |
308 | { |
309 | /* Format: HID-SENSOR-usage_id_in_hex_lowercase */ |
310 | .name = "HID-SENSOR-2000a0" , |
311 | }, |
312 | { /* sentinel */ } |
313 | }; |
314 | MODULE_DEVICE_TABLE(platform, hid_time_ids); |
315 | |
316 | static struct platform_driver hid_time_platform_driver = { |
317 | .id_table = hid_time_ids, |
318 | .driver = { |
319 | .name = KBUILD_MODNAME, |
320 | }, |
321 | .probe = hid_time_probe, |
322 | .remove_new = hid_time_remove, |
323 | }; |
324 | module_platform_driver(hid_time_platform_driver); |
325 | |
326 | MODULE_DESCRIPTION("HID Sensor Time" ); |
327 | MODULE_AUTHOR("Alexander Holler <holler@ahsoftware.de>" ); |
328 | MODULE_LICENSE("GPL" ); |
329 | MODULE_IMPORT_NS(IIO_HID); |
330 | |