1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * SMBus driver for ACPI Embedded Controller (v0.1) |
4 | * |
5 | * Copyright (c) 2007 Alexey Starikovskiy |
6 | */ |
7 | |
8 | #define pr_fmt(fmt) "ACPI: " fmt |
9 | |
10 | #include <linux/acpi.h> |
11 | #include <linux/wait.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/delay.h> |
14 | #include <linux/module.h> |
15 | #include <linux/interrupt.h> |
16 | #include "sbshc.h" |
17 | |
18 | #define ACPI_SMB_HC_CLASS "smbus_host_ctl" |
19 | #define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC" |
20 | |
21 | struct acpi_smb_hc { |
22 | struct acpi_ec *ec; |
23 | struct mutex lock; |
24 | wait_queue_head_t wait; |
25 | u8 offset; |
26 | u8 query_bit; |
27 | smbus_alarm_callback callback; |
28 | void *context; |
29 | bool done; |
30 | }; |
31 | |
32 | static int acpi_smbus_hc_add(struct acpi_device *device); |
33 | static void acpi_smbus_hc_remove(struct acpi_device *device); |
34 | |
35 | static const struct acpi_device_id sbs_device_ids[] = { |
36 | {"ACPI0001" , 0}, |
37 | {"ACPI0005" , 0}, |
38 | {"" , 0}, |
39 | }; |
40 | |
41 | MODULE_DEVICE_TABLE(acpi, sbs_device_ids); |
42 | |
43 | static struct acpi_driver acpi_smb_hc_driver = { |
44 | .name = "smbus_hc" , |
45 | .class = ACPI_SMB_HC_CLASS, |
46 | .ids = sbs_device_ids, |
47 | .ops = { |
48 | .add = acpi_smbus_hc_add, |
49 | .remove = acpi_smbus_hc_remove, |
50 | }, |
51 | }; |
52 | |
53 | union acpi_smb_status { |
54 | u8 raw; |
55 | struct { |
56 | u8 status:5; |
57 | u8 reserved:1; |
58 | u8 alarm:1; |
59 | u8 done:1; |
60 | } fields; |
61 | }; |
62 | |
63 | enum acpi_smb_status_codes { |
64 | SMBUS_OK = 0, |
65 | SMBUS_UNKNOWN_FAILURE = 0x07, |
66 | SMBUS_DEVICE_ADDRESS_NACK = 0x10, |
67 | SMBUS_DEVICE_ERROR = 0x11, |
68 | SMBUS_DEVICE_COMMAND_ACCESS_DENIED = 0x12, |
69 | SMBUS_UNKNOWN_ERROR = 0x13, |
70 | SMBUS_DEVICE_ACCESS_DENIED = 0x17, |
71 | SMBUS_TIMEOUT = 0x18, |
72 | SMBUS_HOST_UNSUPPORTED_PROTOCOL = 0x19, |
73 | SMBUS_BUSY = 0x1a, |
74 | SMBUS_PEC_ERROR = 0x1f, |
75 | }; |
76 | |
77 | enum acpi_smb_offset { |
78 | ACPI_SMB_PROTOCOL = 0, /* protocol, PEC */ |
79 | ACPI_SMB_STATUS = 1, /* status */ |
80 | ACPI_SMB_ADDRESS = 2, /* address */ |
81 | ACPI_SMB_COMMAND = 3, /* command */ |
82 | ACPI_SMB_DATA = 4, /* 32 data registers */ |
83 | ACPI_SMB_BLOCK_COUNT = 0x24, /* number of data bytes */ |
84 | ACPI_SMB_ALARM_ADDRESS = 0x25, /* alarm address */ |
85 | ACPI_SMB_ALARM_DATA = 0x26, /* 2 bytes alarm data */ |
86 | }; |
87 | |
88 | static inline int smb_hc_read(struct acpi_smb_hc *hc, u8 address, u8 *data) |
89 | { |
90 | return ec_read(addr: hc->offset + address, val: data); |
91 | } |
92 | |
93 | static inline int smb_hc_write(struct acpi_smb_hc *hc, u8 address, u8 data) |
94 | { |
95 | return ec_write(addr: hc->offset + address, val: data); |
96 | } |
97 | |
98 | static int wait_transaction_complete(struct acpi_smb_hc *hc, int timeout) |
99 | { |
100 | if (wait_event_timeout(hc->wait, hc->done, msecs_to_jiffies(timeout))) |
101 | return 0; |
102 | return -ETIME; |
103 | } |
104 | |
105 | static int acpi_smbus_transaction(struct acpi_smb_hc *hc, u8 protocol, |
106 | u8 address, u8 command, u8 *data, u8 length) |
107 | { |
108 | int ret = -EFAULT, i; |
109 | u8 temp, sz = 0; |
110 | |
111 | if (!hc) { |
112 | pr_err("host controller is not configured\n" ); |
113 | return ret; |
114 | } |
115 | |
116 | mutex_lock(&hc->lock); |
117 | hc->done = false; |
118 | if (smb_hc_read(hc, address: ACPI_SMB_PROTOCOL, data: &temp)) |
119 | goto end; |
120 | if (temp) { |
121 | ret = -EBUSY; |
122 | goto end; |
123 | } |
124 | smb_hc_write(hc, address: ACPI_SMB_COMMAND, data: command); |
125 | if (!(protocol & 0x01)) { |
126 | smb_hc_write(hc, address: ACPI_SMB_BLOCK_COUNT, data: length); |
127 | for (i = 0; i < length; ++i) |
128 | smb_hc_write(hc, address: ACPI_SMB_DATA + i, data: data[i]); |
129 | } |
130 | smb_hc_write(hc, address: ACPI_SMB_ADDRESS, data: address << 1); |
131 | smb_hc_write(hc, address: ACPI_SMB_PROTOCOL, data: protocol); |
132 | /* |
133 | * Wait for completion. Save the status code, data size, |
134 | * and data into the return package (if required by the protocol). |
135 | */ |
136 | ret = wait_transaction_complete(hc, timeout: 1000); |
137 | if (ret || !(protocol & 0x01)) |
138 | goto end; |
139 | switch (protocol) { |
140 | case SMBUS_RECEIVE_BYTE: |
141 | case SMBUS_READ_BYTE: |
142 | sz = 1; |
143 | break; |
144 | case SMBUS_READ_WORD: |
145 | sz = 2; |
146 | break; |
147 | case SMBUS_READ_BLOCK: |
148 | if (smb_hc_read(hc, address: ACPI_SMB_BLOCK_COUNT, data: &sz)) { |
149 | ret = -EFAULT; |
150 | goto end; |
151 | } |
152 | sz &= 0x1f; |
153 | break; |
154 | } |
155 | for (i = 0; i < sz; ++i) |
156 | smb_hc_read(hc, address: ACPI_SMB_DATA + i, data: &data[i]); |
157 | end: |
158 | mutex_unlock(lock: &hc->lock); |
159 | return ret; |
160 | } |
161 | |
162 | int acpi_smbus_read(struct acpi_smb_hc *hc, u8 protocol, u8 address, |
163 | u8 command, u8 *data) |
164 | { |
165 | return acpi_smbus_transaction(hc, protocol, address, command, data, length: 0); |
166 | } |
167 | |
168 | EXPORT_SYMBOL_GPL(acpi_smbus_read); |
169 | |
170 | int acpi_smbus_write(struct acpi_smb_hc *hc, u8 protocol, u8 address, |
171 | u8 command, u8 *data, u8 length) |
172 | { |
173 | return acpi_smbus_transaction(hc, protocol, address, command, data, length); |
174 | } |
175 | |
176 | EXPORT_SYMBOL_GPL(acpi_smbus_write); |
177 | |
178 | int acpi_smbus_register_callback(struct acpi_smb_hc *hc, |
179 | smbus_alarm_callback callback, void *context) |
180 | { |
181 | mutex_lock(&hc->lock); |
182 | hc->callback = callback; |
183 | hc->context = context; |
184 | mutex_unlock(lock: &hc->lock); |
185 | return 0; |
186 | } |
187 | |
188 | EXPORT_SYMBOL_GPL(acpi_smbus_register_callback); |
189 | |
190 | int acpi_smbus_unregister_callback(struct acpi_smb_hc *hc) |
191 | { |
192 | mutex_lock(&hc->lock); |
193 | hc->callback = NULL; |
194 | hc->context = NULL; |
195 | mutex_unlock(lock: &hc->lock); |
196 | acpi_os_wait_events_complete(); |
197 | return 0; |
198 | } |
199 | |
200 | EXPORT_SYMBOL_GPL(acpi_smbus_unregister_callback); |
201 | |
202 | static inline void acpi_smbus_callback(void *context) |
203 | { |
204 | struct acpi_smb_hc *hc = context; |
205 | if (hc->callback) |
206 | hc->callback(hc->context); |
207 | } |
208 | |
209 | static int smbus_alarm(void *context) |
210 | { |
211 | struct acpi_smb_hc *hc = context; |
212 | union acpi_smb_status status; |
213 | u8 address; |
214 | if (smb_hc_read(hc, address: ACPI_SMB_STATUS, data: &status.raw)) |
215 | return 0; |
216 | /* Check if it is only a completion notify */ |
217 | if (status.fields.done && status.fields.status == SMBUS_OK) { |
218 | hc->done = true; |
219 | wake_up(&hc->wait); |
220 | } |
221 | if (!status.fields.alarm) |
222 | return 0; |
223 | mutex_lock(&hc->lock); |
224 | smb_hc_read(hc, address: ACPI_SMB_ALARM_ADDRESS, data: &address); |
225 | status.fields.alarm = 0; |
226 | smb_hc_write(hc, address: ACPI_SMB_STATUS, data: status.raw); |
227 | /* We are only interested in events coming from known devices */ |
228 | switch (address >> 1) { |
229 | case ACPI_SBS_CHARGER: |
230 | case ACPI_SBS_MANAGER: |
231 | case ACPI_SBS_BATTERY: |
232 | acpi_os_execute(type: OSL_NOTIFY_HANDLER, |
233 | function: acpi_smbus_callback, context: hc); |
234 | } |
235 | mutex_unlock(lock: &hc->lock); |
236 | return 0; |
237 | } |
238 | |
239 | typedef int (*acpi_ec_query_func) (void *data); |
240 | |
241 | extern int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, |
242 | acpi_handle handle, acpi_ec_query_func func, |
243 | void *data); |
244 | |
245 | static int acpi_smbus_hc_add(struct acpi_device *device) |
246 | { |
247 | int status; |
248 | unsigned long long val; |
249 | struct acpi_smb_hc *hc; |
250 | |
251 | if (!device) |
252 | return -EINVAL; |
253 | |
254 | status = acpi_evaluate_integer(handle: device->handle, pathname: "_EC" , NULL, data: &val); |
255 | if (ACPI_FAILURE(status)) { |
256 | pr_err("error obtaining _EC.\n" ); |
257 | return -EIO; |
258 | } |
259 | |
260 | strcpy(acpi_device_name(device), ACPI_SMB_HC_DEVICE_NAME); |
261 | strcpy(acpi_device_class(device), ACPI_SMB_HC_CLASS); |
262 | |
263 | hc = kzalloc(size: sizeof(struct acpi_smb_hc), GFP_KERNEL); |
264 | if (!hc) |
265 | return -ENOMEM; |
266 | mutex_init(&hc->lock); |
267 | init_waitqueue_head(&hc->wait); |
268 | |
269 | hc->ec = acpi_driver_data(d: acpi_dev_parent(adev: device)); |
270 | hc->offset = (val >> 8) & 0xff; |
271 | hc->query_bit = val & 0xff; |
272 | device->driver_data = hc; |
273 | |
274 | acpi_ec_add_query_handler(ec: hc->ec, query_bit: hc->query_bit, NULL, func: smbus_alarm, data: hc); |
275 | dev_info(&device->dev, "SBS HC: offset = 0x%0x, query_bit = 0x%0x\n" , |
276 | hc->offset, hc->query_bit); |
277 | |
278 | return 0; |
279 | } |
280 | |
281 | extern void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit); |
282 | |
283 | static void acpi_smbus_hc_remove(struct acpi_device *device) |
284 | { |
285 | struct acpi_smb_hc *hc; |
286 | |
287 | if (!device) |
288 | return; |
289 | |
290 | hc = acpi_driver_data(d: device); |
291 | acpi_ec_remove_query_handler(ec: hc->ec, query_bit: hc->query_bit); |
292 | acpi_os_wait_events_complete(); |
293 | kfree(objp: hc); |
294 | device->driver_data = NULL; |
295 | } |
296 | |
297 | module_acpi_driver(acpi_smb_hc_driver); |
298 | |
299 | MODULE_LICENSE("GPL" ); |
300 | MODULE_AUTHOR("Alexey Starikovskiy" ); |
301 | MODULE_DESCRIPTION("ACPI SMBus HC driver" ); |
302 | |