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 <acpi/acpi_bus.h>
12 #include <acpi/acpi_drivers.h>
13 #include <acpi/actypes.h>
14 #include <linux/wait.h>
15 #include <linux/delay.h>
16 #include <linux/interrupt.h>
19 #define ACPI_SMB_HC_CLASS "smbus_host_controller"
20 #define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC"
25 wait_queue_head_t wait
;
28 smbus_alarm_callback callback
;
32 static int acpi_smbus_hc_add(struct acpi_device
*device
);
33 static int acpi_smbus_hc_remove(struct acpi_device
*device
, int type
);
35 static const struct acpi_device_id sbs_device_ids
[] = {
41 MODULE_DEVICE_TABLE(acpi
, sbs_device_ids
);
43 static struct acpi_driver acpi_smb_hc_driver
= {
45 .class = ACPI_SMB_HC_CLASS
,
46 .ids
= sbs_device_ids
,
48 .add
= acpi_smbus_hc_add
,
49 .remove
= acpi_smbus_hc_remove
,
53 union acpi_smb_status
{
63 enum acpi_smb_status_codes
{
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,
72 SMBUS_HOST_UNSUPPORTED_PROTOCOL
= 0x19,
74 SMBUS_PEC_ERROR
= 0x1f,
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 */
88 static inline int smb_hc_read(struct acpi_smb_hc
*hc
, u8 address
, u8
*data
)
90 return ec_read(hc
->offset
+ address
, data
);
93 static inline int smb_hc_write(struct acpi_smb_hc
*hc
, u8 address
, u8 data
)
95 return ec_write(hc
->offset
+ address
, data
);
98 static inline int smb_check_done(struct acpi_smb_hc
*hc
)
100 union acpi_smb_status status
= {.raw
= 0};
101 smb_hc_read(hc
, ACPI_SMB_STATUS
, &status
.raw
);
102 return status
.fields
.done
&& (status
.fields
.status
== SMBUS_OK
);
105 static int wait_transaction_complete(struct acpi_smb_hc
*hc
, int timeout
)
107 if (wait_event_timeout(hc
->wait
, smb_check_done(hc
),
108 msecs_to_jiffies(timeout
)))
111 * After the timeout happens, OS will try to check the status of SMbus.
112 * If the status is what OS expected, it will be regarded as the bogus
115 if (smb_check_done(hc
))
121 static int acpi_smbus_transaction(struct acpi_smb_hc
*hc
, u8 protocol
,
122 u8 address
, u8 command
, u8
*data
, u8 length
)
124 int ret
= -EFAULT
, i
;
128 printk(KERN_ERR PREFIX
"host controller is not configured\n");
132 mutex_lock(&hc
->lock
);
133 if (smb_hc_read(hc
, ACPI_SMB_PROTOCOL
, &temp
))
139 smb_hc_write(hc
, ACPI_SMB_COMMAND
, command
);
140 if (!(protocol
& 0x01)) {
141 smb_hc_write(hc
, ACPI_SMB_BLOCK_COUNT
, length
);
142 for (i
= 0; i
< length
; ++i
)
143 smb_hc_write(hc
, ACPI_SMB_DATA
+ i
, data
[i
]);
145 smb_hc_write(hc
, ACPI_SMB_ADDRESS
, address
<< 1);
146 smb_hc_write(hc
, ACPI_SMB_PROTOCOL
, protocol
);
148 * Wait for completion. Save the status code, data size,
149 * and data into the return package (if required by the protocol).
151 ret
= wait_transaction_complete(hc
, 1000);
152 if (ret
|| !(protocol
& 0x01))
155 case SMBUS_RECEIVE_BYTE
:
156 case SMBUS_READ_BYTE
:
159 case SMBUS_READ_WORD
:
162 case SMBUS_READ_BLOCK
:
163 if (smb_hc_read(hc
, ACPI_SMB_BLOCK_COUNT
, &sz
)) {
170 for (i
= 0; i
< sz
; ++i
)
171 smb_hc_read(hc
, ACPI_SMB_DATA
+ i
, &data
[i
]);
173 mutex_unlock(&hc
->lock
);
177 int acpi_smbus_read(struct acpi_smb_hc
*hc
, u8 protocol
, u8 address
,
178 u8 command
, u8
*data
)
180 return acpi_smbus_transaction(hc
, protocol
, address
, command
, data
, 0);
183 EXPORT_SYMBOL_GPL(acpi_smbus_read
);
185 int acpi_smbus_write(struct acpi_smb_hc
*hc
, u8 protocol
, u8 address
,
186 u8 command
, u8
*data
, u8 length
)
188 return acpi_smbus_transaction(hc
, protocol
, address
, command
, data
, length
);
191 EXPORT_SYMBOL_GPL(acpi_smbus_write
);
193 int acpi_smbus_register_callback(struct acpi_smb_hc
*hc
,
194 smbus_alarm_callback callback
, void *context
)
196 mutex_lock(&hc
->lock
);
197 hc
->callback
= callback
;
198 hc
->context
= context
;
199 mutex_unlock(&hc
->lock
);
203 EXPORT_SYMBOL_GPL(acpi_smbus_register_callback
);
205 int acpi_smbus_unregister_callback(struct acpi_smb_hc
*hc
)
207 mutex_lock(&hc
->lock
);
210 mutex_unlock(&hc
->lock
);
214 EXPORT_SYMBOL_GPL(acpi_smbus_unregister_callback
);
216 static inline void acpi_smbus_callback(void *context
)
218 struct acpi_smb_hc
*hc
= context
;
220 hc
->callback(hc
->context
);
223 static int smbus_alarm(void *context
)
225 struct acpi_smb_hc
*hc
= context
;
226 union acpi_smb_status status
;
228 if (smb_hc_read(hc
, ACPI_SMB_STATUS
, &status
.raw
))
230 /* Check if it is only a completion notify */
231 if (status
.fields
.done
)
233 if (!status
.fields
.alarm
)
235 mutex_lock(&hc
->lock
);
236 smb_hc_read(hc
, ACPI_SMB_ALARM_ADDRESS
, &address
);
237 status
.fields
.alarm
= 0;
238 smb_hc_write(hc
, ACPI_SMB_STATUS
, status
.raw
);
239 /* We are only interested in events coming from known devices */
240 switch (address
>> 1) {
241 case ACPI_SBS_CHARGER
:
242 case ACPI_SBS_MANAGER
:
243 case ACPI_SBS_BATTERY
:
244 acpi_os_execute(OSL_GPE_HANDLER
,
245 acpi_smbus_callback
, hc
);
248 mutex_unlock(&hc
->lock
);
252 typedef int (*acpi_ec_query_func
) (void *data
);
254 extern int acpi_ec_add_query_handler(struct acpi_ec
*ec
, u8 query_bit
,
255 acpi_handle handle
, acpi_ec_query_func func
,
258 static int acpi_smbus_hc_add(struct acpi_device
*device
)
262 struct acpi_smb_hc
*hc
;
267 status
= acpi_evaluate_integer(device
->handle
, "_EC", NULL
, &val
);
268 if (ACPI_FAILURE(status
)) {
269 printk(KERN_ERR PREFIX
"error obtaining _EC.\n");
273 strcpy(acpi_device_name(device
), ACPI_SMB_HC_DEVICE_NAME
);
274 strcpy(acpi_device_class(device
), ACPI_SMB_HC_CLASS
);
276 hc
= kzalloc(sizeof(struct acpi_smb_hc
), GFP_KERNEL
);
279 mutex_init(&hc
->lock
);
280 init_waitqueue_head(&hc
->wait
);
282 hc
->ec
= acpi_driver_data(device
->parent
);
283 hc
->offset
= (val
>> 8) & 0xff;
284 hc
->query_bit
= val
& 0xff;
285 acpi_driver_data(device
) = hc
;
287 acpi_ec_add_query_handler(hc
->ec
, hc
->query_bit
, NULL
, smbus_alarm
, hc
);
288 printk(KERN_INFO PREFIX
"SBS HC: EC = 0x%p, offset = 0x%0x, query_bit = 0x%0x\n",
289 hc
->ec
, hc
->offset
, hc
->query_bit
);
294 extern void acpi_ec_remove_query_handler(struct acpi_ec
*ec
, u8 query_bit
);
296 static int acpi_smbus_hc_remove(struct acpi_device
*device
, int type
)
298 struct acpi_smb_hc
*hc
;
303 hc
= acpi_driver_data(device
);
304 acpi_ec_remove_query_handler(hc
->ec
, hc
->query_bit
);
306 acpi_driver_data(device
) = NULL
;
310 static int __init
acpi_smb_hc_init(void)
314 result
= acpi_bus_register_driver(&acpi_smb_hc_driver
);
320 static void __exit
acpi_smb_hc_exit(void)
322 acpi_bus_unregister_driver(&acpi_smb_hc_driver
);
325 module_init(acpi_smb_hc_init
);
326 module_exit(acpi_smb_hc_exit
);
328 MODULE_LICENSE("GPL");
329 MODULE_AUTHOR("Alexey Starikovskiy");
330 MODULE_DESCRIPTION("ACPI SMBus HC driver");