2 * SMBus driver for ACPI Embedded Controller (v0.1)
4 * Copyright (c) 2007 Alexey Starikovskiy
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.
11 #include <linux/acpi.h>
12 #include <linux/wait.h>
13 #include <linux/slab.h>
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/dmi.h>
20 #define PREFIX "ACPI: "
22 #define ACPI_SMB_HC_CLASS "smbus_host_ctl"
23 #define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC"
28 wait_queue_head_t wait
;
31 smbus_alarm_callback callback
;
36 static int acpi_smbus_hc_add(struct acpi_device
*device
);
37 static int acpi_smbus_hc_remove(struct acpi_device
*device
);
39 static const struct acpi_device_id sbs_device_ids
[] = {
45 MODULE_DEVICE_TABLE(acpi
, sbs_device_ids
);
47 static struct acpi_driver acpi_smb_hc_driver
= {
49 .class = ACPI_SMB_HC_CLASS
,
50 .ids
= sbs_device_ids
,
52 .add
= acpi_smbus_hc_add
,
53 .remove
= acpi_smbus_hc_remove
,
57 union acpi_smb_status
{
67 enum acpi_smb_status_codes
{
69 SMBUS_UNKNOWN_FAILURE
= 0x07,
70 SMBUS_DEVICE_ADDRESS_NACK
= 0x10,
71 SMBUS_DEVICE_ERROR
= 0x11,
72 SMBUS_DEVICE_COMMAND_ACCESS_DENIED
= 0x12,
73 SMBUS_UNKNOWN_ERROR
= 0x13,
74 SMBUS_DEVICE_ACCESS_DENIED
= 0x17,
76 SMBUS_HOST_UNSUPPORTED_PROTOCOL
= 0x19,
78 SMBUS_PEC_ERROR
= 0x1f,
81 enum acpi_smb_offset
{
82 ACPI_SMB_PROTOCOL
= 0, /* protocol, PEC */
83 ACPI_SMB_STATUS
= 1, /* status */
84 ACPI_SMB_ADDRESS
= 2, /* address */
85 ACPI_SMB_COMMAND
= 3, /* command */
86 ACPI_SMB_DATA
= 4, /* 32 data registers */
87 ACPI_SMB_BLOCK_COUNT
= 0x24, /* number of data bytes */
88 ACPI_SMB_ALARM_ADDRESS
= 0x25, /* alarm address */
89 ACPI_SMB_ALARM_DATA
= 0x26, /* 2 bytes alarm data */
94 static inline int smb_hc_read(struct acpi_smb_hc
*hc
, u8 address
, u8
*data
)
96 return ec_read(hc
->offset
+ address
, data
);
99 static inline int smb_hc_write(struct acpi_smb_hc
*hc
, u8 address
, u8 data
)
101 return ec_write(hc
->offset
+ address
, data
);
104 static int wait_transaction_complete(struct acpi_smb_hc
*hc
, int timeout
)
106 if (wait_event_timeout(hc
->wait
, hc
->done
, msecs_to_jiffies(timeout
)))
111 static int acpi_smbus_transaction(struct acpi_smb_hc
*hc
, u8 protocol
,
112 u8 address
, u8 command
, u8
*data
, u8 length
)
114 int ret
= -EFAULT
, i
;
118 printk(KERN_ERR PREFIX
"host controller is not configured\n");
122 mutex_lock(&hc
->lock
);
126 if (smb_hc_read(hc
, ACPI_SMB_PROTOCOL
, &temp
))
132 smb_hc_write(hc
, ACPI_SMB_COMMAND
, command
);
133 if (!(protocol
& 0x01)) {
134 smb_hc_write(hc
, ACPI_SMB_BLOCK_COUNT
, length
);
135 for (i
= 0; i
< length
; ++i
)
136 smb_hc_write(hc
, ACPI_SMB_DATA
+ i
, data
[i
]);
138 smb_hc_write(hc
, ACPI_SMB_ADDRESS
, address
<< 1);
139 smb_hc_write(hc
, ACPI_SMB_PROTOCOL
, protocol
);
141 * Wait for completion. Save the status code, data size,
142 * and data into the return package (if required by the protocol).
144 ret
= wait_transaction_complete(hc
, 1000);
145 if (ret
|| !(protocol
& 0x01))
148 case SMBUS_RECEIVE_BYTE
:
149 case SMBUS_READ_BYTE
:
152 case SMBUS_READ_WORD
:
155 case SMBUS_READ_BLOCK
:
156 if (smb_hc_read(hc
, ACPI_SMB_BLOCK_COUNT
, &sz
)) {
163 for (i
= 0; i
< sz
; ++i
)
164 smb_hc_read(hc
, ACPI_SMB_DATA
+ i
, &data
[i
]);
166 mutex_unlock(&hc
->lock
);
170 int acpi_smbus_read(struct acpi_smb_hc
*hc
, u8 protocol
, u8 address
,
171 u8 command
, u8
*data
)
173 return acpi_smbus_transaction(hc
, protocol
, address
, command
, data
, 0);
176 EXPORT_SYMBOL_GPL(acpi_smbus_read
);
178 int acpi_smbus_write(struct acpi_smb_hc
*hc
, u8 protocol
, u8 address
,
179 u8 command
, u8
*data
, u8 length
)
181 return acpi_smbus_transaction(hc
, protocol
, address
, command
, data
, length
);
184 EXPORT_SYMBOL_GPL(acpi_smbus_write
);
186 int acpi_smbus_register_callback(struct acpi_smb_hc
*hc
,
187 smbus_alarm_callback callback
, void *context
)
189 mutex_lock(&hc
->lock
);
190 hc
->callback
= callback
;
191 hc
->context
= context
;
192 mutex_unlock(&hc
->lock
);
196 EXPORT_SYMBOL_GPL(acpi_smbus_register_callback
);
198 int acpi_smbus_unregister_callback(struct acpi_smb_hc
*hc
)
200 mutex_lock(&hc
->lock
);
203 mutex_unlock(&hc
->lock
);
207 EXPORT_SYMBOL_GPL(acpi_smbus_unregister_callback
);
209 static inline void acpi_smbus_callback(void *context
)
211 struct acpi_smb_hc
*hc
= context
;
213 hc
->callback(hc
->context
);
216 static int smbus_alarm(void *context
)
218 struct acpi_smb_hc
*hc
= context
;
219 union acpi_smb_status status
;
221 if (smb_hc_read(hc
, ACPI_SMB_STATUS
, &status
.raw
))
223 /* Check if it is only a completion notify */
224 if (status
.fields
.done
&& status
.fields
.status
== SMBUS_OK
) {
228 if (!status
.fields
.alarm
)
230 mutex_lock(&hc
->lock
);
231 smb_hc_read(hc
, ACPI_SMB_ALARM_ADDRESS
, &address
);
232 status
.fields
.alarm
= 0;
233 smb_hc_write(hc
, ACPI_SMB_STATUS
, status
.raw
);
234 /* We are only interested in events coming from known devices */
235 switch (address
>> 1) {
236 case ACPI_SBS_CHARGER
:
237 case ACPI_SBS_MANAGER
:
238 case ACPI_SBS_BATTERY
:
239 acpi_os_execute(OSL_NOTIFY_HANDLER
,
240 acpi_smbus_callback
, hc
);
243 mutex_unlock(&hc
->lock
);
247 typedef int (*acpi_ec_query_func
) (void *data
);
249 extern int acpi_ec_add_query_handler(struct acpi_ec
*ec
, u8 query_bit
,
250 acpi_handle handle
, acpi_ec_query_func func
,
253 static int macbook_dmi_match(const struct dmi_system_id
*d
)
255 pr_debug("Detected MacBook, enabling workaround\n");
260 static struct dmi_system_id acpi_smbus_dmi_table
[] = {
261 { macbook_dmi_match
, "Apple MacBook", {
262 DMI_MATCH(DMI_BOARD_VENDOR
, "Apple"),
263 DMI_MATCH(DMI_PRODUCT_NAME
, "MacBook") },
268 static int acpi_smbus_hc_add(struct acpi_device
*device
)
271 unsigned long long val
;
272 struct acpi_smb_hc
*hc
;
274 dmi_check_system(acpi_smbus_dmi_table
);
279 status
= acpi_evaluate_integer(device
->handle
, "_EC", NULL
, &val
);
280 if (ACPI_FAILURE(status
)) {
281 printk(KERN_ERR PREFIX
"error obtaining _EC.\n");
285 strcpy(acpi_device_name(device
), ACPI_SMB_HC_DEVICE_NAME
);
286 strcpy(acpi_device_class(device
), ACPI_SMB_HC_CLASS
);
288 hc
= kzalloc(sizeof(struct acpi_smb_hc
), GFP_KERNEL
);
291 mutex_init(&hc
->lock
);
292 init_waitqueue_head(&hc
->wait
);
294 hc
->ec
= acpi_driver_data(device
->parent
);
295 hc
->offset
= (val
>> 8) & 0xff;
296 hc
->query_bit
= val
& 0xff;
297 device
->driver_data
= hc
;
299 acpi_ec_add_query_handler(hc
->ec
, hc
->query_bit
, NULL
, smbus_alarm
, hc
);
300 printk(KERN_INFO PREFIX
"SBS HC: EC = 0x%p, offset = 0x%0x, query_bit = 0x%0x\n",
301 hc
->ec
, hc
->offset
, hc
->query_bit
);
306 extern void acpi_ec_remove_query_handler(struct acpi_ec
*ec
, u8 query_bit
);
308 static int acpi_smbus_hc_remove(struct acpi_device
*device
)
310 struct acpi_smb_hc
*hc
;
315 hc
= acpi_driver_data(device
);
316 acpi_ec_remove_query_handler(hc
->ec
, hc
->query_bit
);
318 device
->driver_data
= NULL
;
322 module_acpi_driver(acpi_smb_hc_driver
);
324 MODULE_LICENSE("GPL");
325 MODULE_AUTHOR("Alexey Starikovskiy");
326 MODULE_DESCRIPTION("ACPI SMBus HC driver");