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 <acpi/actypes.h> 14 #include <linux/wait.h> 15 #include <linux/delay.h> 16 #include <linux/interrupt.h> 17 #include "sbshc.h" 18 19 #define ACPI_SMB_HC_CLASS "smbus_host_controller" 20 #define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC" 21 22 struct acpi_smb_hc { 23 struct acpi_ec *ec; 24 struct mutex lock; 25 wait_queue_head_t wait; 26 u8 offset; 27 u8 query_bit; 28 smbus_alarm_callback callback; 29 void *context; 30 }; 31 32 static int acpi_smbus_hc_add(struct acpi_device *device); 33 static int acpi_smbus_hc_remove(struct acpi_device *device, int type); 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(hc->offset + address, data); 91 } 92 93 static inline int smb_hc_write(struct acpi_smb_hc *hc, u8 address, u8 data) 94 { 95 return ec_write(hc->offset + address, data); 96 } 97 98 static inline int smb_check_done(struct acpi_smb_hc *hc) 99 { 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); 103 } 104 105 static int wait_transaction_complete(struct acpi_smb_hc *hc, int timeout) 106 { 107 if (wait_event_timeout(hc->wait, smb_check_done(hc), 108 msecs_to_jiffies(timeout))) 109 return 0; 110 /* 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 113 * timeout. 114 */ 115 if (smb_check_done(hc)) 116 return 0; 117 else 118 return -ETIME; 119 } 120 121 static int acpi_smbus_transaction(struct acpi_smb_hc *hc, u8 protocol, 122 u8 address, u8 command, u8 *data, u8 length) 123 { 124 int ret = -EFAULT, i; 125 u8 temp, sz = 0; 126 127 if (!hc) { 128 printk(KERN_ERR PREFIX "host controller is not configured\n"); 129 return ret; 130 } 131 132 mutex_lock(&hc->lock); 133 if (smb_hc_read(hc, ACPI_SMB_PROTOCOL, &temp)) 134 goto end; 135 if (temp) { 136 ret = -EBUSY; 137 goto end; 138 } 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]); 144 } 145 smb_hc_write(hc, ACPI_SMB_ADDRESS, address << 1); 146 smb_hc_write(hc, ACPI_SMB_PROTOCOL, protocol); 147 /* 148 * Wait for completion. Save the status code, data size, 149 * and data into the return package (if required by the protocol). 150 */ 151 ret = wait_transaction_complete(hc, 1000); 152 if (ret || !(protocol & 0x01)) 153 goto end; 154 switch (protocol) { 155 case SMBUS_RECEIVE_BYTE: 156 case SMBUS_READ_BYTE: 157 sz = 1; 158 break; 159 case SMBUS_READ_WORD: 160 sz = 2; 161 break; 162 case SMBUS_READ_BLOCK: 163 if (smb_hc_read(hc, ACPI_SMB_BLOCK_COUNT, &sz)) { 164 ret = -EFAULT; 165 goto end; 166 } 167 sz &= 0x1f; 168 break; 169 } 170 for (i = 0; i < sz; ++i) 171 smb_hc_read(hc, ACPI_SMB_DATA + i, &data[i]); 172 end: 173 mutex_unlock(&hc->lock); 174 return ret; 175 } 176 177 int acpi_smbus_read(struct acpi_smb_hc *hc, u8 protocol, u8 address, 178 u8 command, u8 *data) 179 { 180 return acpi_smbus_transaction(hc, protocol, address, command, data, 0); 181 } 182 183 EXPORT_SYMBOL_GPL(acpi_smbus_read); 184 185 int acpi_smbus_write(struct acpi_smb_hc *hc, u8 protocol, u8 address, 186 u8 command, u8 *data, u8 length) 187 { 188 return acpi_smbus_transaction(hc, protocol, address, command, data, length); 189 } 190 191 EXPORT_SYMBOL_GPL(acpi_smbus_write); 192 193 int acpi_smbus_register_callback(struct acpi_smb_hc *hc, 194 smbus_alarm_callback callback, void *context) 195 { 196 mutex_lock(&hc->lock); 197 hc->callback = callback; 198 hc->context = context; 199 mutex_unlock(&hc->lock); 200 return 0; 201 } 202 203 EXPORT_SYMBOL_GPL(acpi_smbus_register_callback); 204 205 int acpi_smbus_unregister_callback(struct acpi_smb_hc *hc) 206 { 207 mutex_lock(&hc->lock); 208 hc->callback = NULL; 209 hc->context = NULL; 210 mutex_unlock(&hc->lock); 211 return 0; 212 } 213 214 EXPORT_SYMBOL_GPL(acpi_smbus_unregister_callback); 215 216 static inline void acpi_smbus_callback(void *context) 217 { 218 struct acpi_smb_hc *hc = context; 219 if (hc->callback) 220 hc->callback(hc->context); 221 } 222 223 static int smbus_alarm(void *context) 224 { 225 struct acpi_smb_hc *hc = context; 226 union acpi_smb_status status; 227 u8 address; 228 if (smb_hc_read(hc, ACPI_SMB_STATUS, &status.raw)) 229 return 0; 230 /* Check if it is only a completion notify */ 231 if (status.fields.done) 232 wake_up(&hc->wait); 233 if (!status.fields.alarm) 234 return 0; 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); 246 default:; 247 } 248 mutex_unlock(&hc->lock); 249 return 0; 250 } 251 252 typedef int (*acpi_ec_query_func) (void *data); 253 254 extern int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit, 255 acpi_handle handle, acpi_ec_query_func func, 256 void *data); 257 258 static int acpi_smbus_hc_add(struct acpi_device *device) 259 { 260 int status; 261 unsigned long val; 262 struct acpi_smb_hc *hc; 263 264 if (!device) 265 return -EINVAL; 266 267 status = acpi_evaluate_integer(device->handle, "_EC", NULL, &val); 268 if (ACPI_FAILURE(status)) { 269 printk(KERN_ERR PREFIX "error obtaining _EC.\n"); 270 return -EIO; 271 } 272 273 strcpy(acpi_device_name(device), ACPI_SMB_HC_DEVICE_NAME); 274 strcpy(acpi_device_class(device), ACPI_SMB_HC_CLASS); 275 276 hc = kzalloc(sizeof(struct acpi_smb_hc), GFP_KERNEL); 277 if (!hc) 278 return -ENOMEM; 279 mutex_init(&hc->lock); 280 init_waitqueue_head(&hc->wait); 281 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; 286 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); 290 291 return 0; 292 } 293 294 extern void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit); 295 296 static int acpi_smbus_hc_remove(struct acpi_device *device, int type) 297 { 298 struct acpi_smb_hc *hc; 299 300 if (!device) 301 return -EINVAL; 302 303 hc = acpi_driver_data(device); 304 acpi_ec_remove_query_handler(hc->ec, hc->query_bit); 305 kfree(hc); 306 acpi_driver_data(device) = NULL; 307 return 0; 308 } 309 310 static int __init acpi_smb_hc_init(void) 311 { 312 int result; 313 314 result = acpi_bus_register_driver(&acpi_smb_hc_driver); 315 if (result < 0) 316 return -ENODEV; 317 return 0; 318 } 319 320 static void __exit acpi_smb_hc_exit(void) 321 { 322 acpi_bus_unregister_driver(&acpi_smb_hc_driver); 323 } 324 325 module_init(acpi_smb_hc_init); 326 module_exit(acpi_smb_hc_exit); 327 328 MODULE_LICENSE("GPL"); 329 MODULE_AUTHOR("Alexey Starikovskiy"); 330 MODULE_DESCRIPTION("ACPI SMBus HC driver"); 331