Commit | Line | Data |
---|---|---|
91087dfa AS |
1 | /* |
2 | * SMBus driver for ACPI Embedded Controller (v0.1) | |
3 | * | |
4 | * Copyright (c) 2007 Alexey Starikovskiy | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation version 2. | |
9 | */ | |
10 | ||
8b48463f | 11 | #include <linux/acpi.h> |
91087dfa | 12 | #include <linux/wait.h> |
5a0e3ad6 | 13 | #include <linux/slab.h> |
91087dfa | 14 | #include <linux/delay.h> |
cc4b859c | 15 | #include <linux/module.h> |
91087dfa | 16 | #include <linux/interrupt.h> |
3349fb64 | 17 | #include <linux/dmi.h> |
91087dfa AS |
18 | #include "sbshc.h" |
19 | ||
a192a958 LB |
20 | #define PREFIX "ACPI: " |
21 | ||
97c227cb | 22 | #define ACPI_SMB_HC_CLASS "smbus_host_ctl" |
91087dfa AS |
23 | #define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC" |
24 | ||
25 | struct acpi_smb_hc { | |
26 | struct acpi_ec *ec; | |
27 | struct mutex lock; | |
28 | wait_queue_head_t wait; | |
29 | u8 offset; | |
30 | u8 query_bit; | |
31 | smbus_alarm_callback callback; | |
32 | void *context; | |
33 | }; | |
34 | ||
35 | static int acpi_smbus_hc_add(struct acpi_device *device); | |
51fac838 | 36 | static int acpi_smbus_hc_remove(struct acpi_device *device); |
91087dfa AS |
37 | |
38 | static const struct acpi_device_id sbs_device_ids[] = { | |
39 | {"ACPI0001", 0}, | |
40 | {"ACPI0005", 0}, | |
41 | {"", 0}, | |
42 | }; | |
43 | ||
44 | MODULE_DEVICE_TABLE(acpi, sbs_device_ids); | |
45 | ||
46 | static struct acpi_driver acpi_smb_hc_driver = { | |
47 | .name = "smbus_hc", | |
48 | .class = ACPI_SMB_HC_CLASS, | |
49 | .ids = sbs_device_ids, | |
50 | .ops = { | |
51 | .add = acpi_smbus_hc_add, | |
52 | .remove = acpi_smbus_hc_remove, | |
53 | }, | |
54 | }; | |
55 | ||
56 | union acpi_smb_status { | |
57 | u8 raw; | |
58 | struct { | |
59 | u8 status:5; | |
60 | u8 reserved:1; | |
61 | u8 alarm:1; | |
62 | u8 done:1; | |
63 | } fields; | |
64 | }; | |
65 | ||
66 | enum acpi_smb_status_codes { | |
67 | SMBUS_OK = 0, | |
68 | SMBUS_UNKNOWN_FAILURE = 0x07, | |
69 | SMBUS_DEVICE_ADDRESS_NACK = 0x10, | |
70 | SMBUS_DEVICE_ERROR = 0x11, | |
71 | SMBUS_DEVICE_COMMAND_ACCESS_DENIED = 0x12, | |
72 | SMBUS_UNKNOWN_ERROR = 0x13, | |
73 | SMBUS_DEVICE_ACCESS_DENIED = 0x17, | |
74 | SMBUS_TIMEOUT = 0x18, | |
75 | SMBUS_HOST_UNSUPPORTED_PROTOCOL = 0x19, | |
76 | SMBUS_BUSY = 0x1a, | |
77 | SMBUS_PEC_ERROR = 0x1f, | |
78 | }; | |
79 | ||
80 | enum acpi_smb_offset { | |
81 | ACPI_SMB_PROTOCOL = 0, /* protocol, PEC */ | |
82 | ACPI_SMB_STATUS = 1, /* status */ | |
83 | ACPI_SMB_ADDRESS = 2, /* address */ | |
84 | ACPI_SMB_COMMAND = 3, /* command */ | |
85 | ACPI_SMB_DATA = 4, /* 32 data registers */ | |
86 | ACPI_SMB_BLOCK_COUNT = 0x24, /* number of data bytes */ | |
87 | ACPI_SMB_ALARM_ADDRESS = 0x25, /* alarm address */ | |
88 | ACPI_SMB_ALARM_DATA = 0x26, /* 2 bytes alarm data */ | |
89 | }; | |
90 | ||
3349fb64 CB |
91 | static bool macbook; |
92 | ||
91087dfa AS |
93 | static inline int smb_hc_read(struct acpi_smb_hc *hc, u8 address, u8 *data) |
94 | { | |
95 | return ec_read(hc->offset + address, data); | |
96 | } | |
97 | ||
98 | static inline int smb_hc_write(struct acpi_smb_hc *hc, u8 address, u8 data) | |
99 | { | |
100 | return ec_write(hc->offset + address, data); | |
101 | } | |
102 | ||
103 | static inline int smb_check_done(struct acpi_smb_hc *hc) | |
104 | { | |
105 | union acpi_smb_status status = {.raw = 0}; | |
106 | smb_hc_read(hc, ACPI_SMB_STATUS, &status.raw); | |
107 | return status.fields.done && (status.fields.status == SMBUS_OK); | |
108 | } | |
109 | ||
110 | static int wait_transaction_complete(struct acpi_smb_hc *hc, int timeout) | |
111 | { | |
112 | if (wait_event_timeout(hc->wait, smb_check_done(hc), | |
113 | msecs_to_jiffies(timeout))) | |
114 | return 0; | |
266feefe ZY |
115 | /* |
116 | * After the timeout happens, OS will try to check the status of SMbus. | |
117 | * If the status is what OS expected, it will be regarded as the bogus | |
118 | * timeout. | |
119 | */ | |
120 | if (smb_check_done(hc)) | |
121 | return 0; | |
91087dfa AS |
122 | else |
123 | return -ETIME; | |
124 | } | |
125 | ||
e5685b9d AB |
126 | static int acpi_smbus_transaction(struct acpi_smb_hc *hc, u8 protocol, |
127 | u8 address, u8 command, u8 *data, u8 length) | |
91087dfa AS |
128 | { |
129 | int ret = -EFAULT, i; | |
130 | u8 temp, sz = 0; | |
131 | ||
bbafbecb AS |
132 | if (!hc) { |
133 | printk(KERN_ERR PREFIX "host controller is not configured\n"); | |
134 | return ret; | |
135 | } | |
136 | ||
91087dfa | 137 | mutex_lock(&hc->lock); |
3349fb64 CB |
138 | if (macbook) |
139 | udelay(5); | |
91087dfa AS |
140 | if (smb_hc_read(hc, ACPI_SMB_PROTOCOL, &temp)) |
141 | goto end; | |
142 | if (temp) { | |
143 | ret = -EBUSY; | |
144 | goto end; | |
145 | } | |
146 | smb_hc_write(hc, ACPI_SMB_COMMAND, command); | |
91087dfa AS |
147 | if (!(protocol & 0x01)) { |
148 | smb_hc_write(hc, ACPI_SMB_BLOCK_COUNT, length); | |
149 | for (i = 0; i < length; ++i) | |
150 | smb_hc_write(hc, ACPI_SMB_DATA + i, data[i]); | |
151 | } | |
152 | smb_hc_write(hc, ACPI_SMB_ADDRESS, address << 1); | |
153 | smb_hc_write(hc, ACPI_SMB_PROTOCOL, protocol); | |
154 | /* | |
155 | * Wait for completion. Save the status code, data size, | |
156 | * and data into the return package (if required by the protocol). | |
157 | */ | |
158 | ret = wait_transaction_complete(hc, 1000); | |
159 | if (ret || !(protocol & 0x01)) | |
160 | goto end; | |
161 | switch (protocol) { | |
162 | case SMBUS_RECEIVE_BYTE: | |
163 | case SMBUS_READ_BYTE: | |
164 | sz = 1; | |
165 | break; | |
166 | case SMBUS_READ_WORD: | |
167 | sz = 2; | |
168 | break; | |
169 | case SMBUS_READ_BLOCK: | |
170 | if (smb_hc_read(hc, ACPI_SMB_BLOCK_COUNT, &sz)) { | |
171 | ret = -EFAULT; | |
172 | goto end; | |
173 | } | |
174 | sz &= 0x1f; | |
175 | break; | |
176 | } | |
177 | for (i = 0; i < sz; ++i) | |
178 | smb_hc_read(hc, ACPI_SMB_DATA + i, &data[i]); | |
179 | end: | |
180 | mutex_unlock(&hc->lock); | |
181 | return ret; | |
182 | } | |
183 | ||
184 | int acpi_smbus_read(struct acpi_smb_hc *hc, u8 protocol, u8 address, | |
185 | u8 command, u8 *data) | |
186 | { | |
187 | return acpi_smbus_transaction(hc, protocol, address, command, data, 0); | |
188 | } | |
189 | ||
190 | EXPORT_SYMBOL_GPL(acpi_smbus_read); | |
191 | ||
192 | int acpi_smbus_write(struct acpi_smb_hc *hc, u8 protocol, u8 address, | |
193 | u8 command, u8 *data, u8 length) | |
194 | { | |
195 | return acpi_smbus_transaction(hc, protocol, address, command, data, length); | |
196 | } | |
197 | ||
198 | EXPORT_SYMBOL_GPL(acpi_smbus_write); | |
199 | ||
200 | int acpi_smbus_register_callback(struct acpi_smb_hc *hc, | |
201 | smbus_alarm_callback callback, void *context) | |
202 | { | |
203 | mutex_lock(&hc->lock); | |
204 | hc->callback = callback; | |
205 | hc->context = context; | |
206 | mutex_unlock(&hc->lock); | |
207 | return 0; | |
208 | } | |
209 | ||
210 | EXPORT_SYMBOL_GPL(acpi_smbus_register_callback); | |
211 | ||
212 | int acpi_smbus_unregister_callback(struct acpi_smb_hc *hc) | |
213 | { | |
214 | mutex_lock(&hc->lock); | |
215 | hc->callback = NULL; | |
216 | hc->context = NULL; | |
217 | mutex_unlock(&hc->lock); | |
218 | return 0; | |
219 | } | |
220 | ||
221 | EXPORT_SYMBOL_GPL(acpi_smbus_unregister_callback); | |
222 | ||
c2d00f2d | 223 | static inline void acpi_smbus_callback(void *context) |
91087dfa AS |
224 | { |
225 | struct acpi_smb_hc *hc = context; | |
91087dfa AS |
226 | if (hc->callback) |
227 | hc->callback(hc->context); | |
228 | } | |
229 | ||
230 | static int smbus_alarm(void *context) | |
231 | { | |
232 | struct acpi_smb_hc *hc = context; | |
233 | union acpi_smb_status status; | |
c2d00f2d | 234 | u8 address; |
91087dfa AS |
235 | if (smb_hc_read(hc, ACPI_SMB_STATUS, &status.raw)) |
236 | return 0; | |
237 | /* Check if it is only a completion notify */ | |
238 | if (status.fields.done) | |
239 | wake_up(&hc->wait); | |
240 | if (!status.fields.alarm) | |
241 | return 0; | |
242 | mutex_lock(&hc->lock); | |
c2d00f2d | 243 | smb_hc_read(hc, ACPI_SMB_ALARM_ADDRESS, &address); |
09f1fb41 | 244 | status.fields.alarm = 0; |
91087dfa | 245 | smb_hc_write(hc, ACPI_SMB_STATUS, status.raw); |
c2d00f2d AS |
246 | /* We are only interested in events coming from known devices */ |
247 | switch (address >> 1) { | |
248 | case ACPI_SBS_CHARGER: | |
249 | case ACPI_SBS_MANAGER: | |
250 | case ACPI_SBS_BATTERY: | |
f5347867 | 251 | acpi_os_execute(OSL_NOTIFY_HANDLER, |
c2d00f2d AS |
252 | acpi_smbus_callback, hc); |
253 | default:; | |
254 | } | |
91087dfa AS |
255 | mutex_unlock(&hc->lock); |
256 | return 0; | |
257 | } | |
258 | ||
259 | typedef int (*acpi_ec_query_func) (void *data); | |
260 | ||
261 | extern int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, | |
262 | acpi_handle handle, acpi_ec_query_func func, | |
263 | void *data); | |
264 | ||
3349fb64 CB |
265 | static int macbook_dmi_match(const struct dmi_system_id *d) |
266 | { | |
267 | pr_debug("Detected MacBook, enabling workaround\n"); | |
268 | macbook = true; | |
269 | return 0; | |
270 | } | |
271 | ||
272 | static struct dmi_system_id acpi_smbus_dmi_table[] = { | |
273 | { macbook_dmi_match, "Apple MacBook", { | |
274 | DMI_MATCH(DMI_BOARD_VENDOR, "Apple"), | |
275 | DMI_MATCH(DMI_PRODUCT_NAME, "MacBook") }, | |
276 | }, | |
277 | { }, | |
278 | }; | |
279 | ||
91087dfa AS |
280 | static int acpi_smbus_hc_add(struct acpi_device *device) |
281 | { | |
282 | int status; | |
27663c58 | 283 | unsigned long long val; |
91087dfa AS |
284 | struct acpi_smb_hc *hc; |
285 | ||
3349fb64 CB |
286 | dmi_check_system(acpi_smbus_dmi_table); |
287 | ||
91087dfa AS |
288 | if (!device) |
289 | return -EINVAL; | |
290 | ||
291 | status = acpi_evaluate_integer(device->handle, "_EC", NULL, &val); | |
292 | if (ACPI_FAILURE(status)) { | |
293 | printk(KERN_ERR PREFIX "error obtaining _EC.\n"); | |
294 | return -EIO; | |
295 | } | |
296 | ||
297 | strcpy(acpi_device_name(device), ACPI_SMB_HC_DEVICE_NAME); | |
298 | strcpy(acpi_device_class(device), ACPI_SMB_HC_CLASS); | |
299 | ||
300 | hc = kzalloc(sizeof(struct acpi_smb_hc), GFP_KERNEL); | |
301 | if (!hc) | |
302 | return -ENOMEM; | |
303 | mutex_init(&hc->lock); | |
304 | init_waitqueue_head(&hc->wait); | |
305 | ||
306 | hc->ec = acpi_driver_data(device->parent); | |
307 | hc->offset = (val >> 8) & 0xff; | |
308 | hc->query_bit = val & 0xff; | |
db89b4f0 | 309 | device->driver_data = hc; |
91087dfa AS |
310 | |
311 | acpi_ec_add_query_handler(hc->ec, hc->query_bit, NULL, smbus_alarm, hc); | |
312 | printk(KERN_INFO PREFIX "SBS HC: EC = 0x%p, offset = 0x%0x, query_bit = 0x%0x\n", | |
313 | hc->ec, hc->offset, hc->query_bit); | |
314 | ||
315 | return 0; | |
316 | } | |
317 | ||
318 | extern void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit); | |
319 | ||
51fac838 | 320 | static int acpi_smbus_hc_remove(struct acpi_device *device) |
91087dfa AS |
321 | { |
322 | struct acpi_smb_hc *hc; | |
323 | ||
324 | if (!device) | |
325 | return -EINVAL; | |
326 | ||
327 | hc = acpi_driver_data(device); | |
328 | acpi_ec_remove_query_handler(hc->ec, hc->query_bit); | |
329 | kfree(hc); | |
db89b4f0 | 330 | device->driver_data = NULL; |
91087dfa AS |
331 | return 0; |
332 | } | |
333 | ||
e84a239e | 334 | module_acpi_driver(acpi_smb_hc_driver); |
91087dfa AS |
335 | |
336 | MODULE_LICENSE("GPL"); | |
337 | MODULE_AUTHOR("Alexey Starikovskiy"); | |
338 | MODULE_DESCRIPTION("ACPI SMBus HC driver"); |