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