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 <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> 18 #include "sbshc.h" 19 20 #define PREFIX "ACPI: " 21 22 #define ACPI_SMB_HC_CLASS "smbus_host_ctl" 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); 36 static int acpi_smbus_hc_remove(struct acpi_device *device); 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 91 static bool macbook; 92 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; 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; 122 else 123 return -ETIME; 124 } 125 126 static int acpi_smbus_transaction(struct acpi_smb_hc *hc, u8 protocol, 127 u8 address, u8 command, u8 *data, u8 length) 128 { 129 int ret = -EFAULT, i; 130 u8 temp, sz = 0; 131 132 if (!hc) { 133 printk(KERN_ERR PREFIX "host controller is not configured\n"); 134 return ret; 135 } 136 137 mutex_lock(&hc->lock); 138 if (macbook) 139 udelay(5); 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); 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 223 static inline void acpi_smbus_callback(void *context) 224 { 225 struct acpi_smb_hc *hc = context; 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; 234 u8 address; 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); 243 smb_hc_read(hc, ACPI_SMB_ALARM_ADDRESS, &address); 244 status.fields.alarm = 0; 245 smb_hc_write(hc, ACPI_SMB_STATUS, status.raw); 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: 251 acpi_os_execute(OSL_NOTIFY_HANDLER, 252 acpi_smbus_callback, hc); 253 default:; 254 } 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 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 280 static int acpi_smbus_hc_add(struct acpi_device *device) 281 { 282 int status; 283 unsigned long long val; 284 struct acpi_smb_hc *hc; 285 286 dmi_check_system(acpi_smbus_dmi_table); 287 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; 309 device->driver_data = hc; 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 320 static int acpi_smbus_hc_remove(struct acpi_device *device) 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); 330 device->driver_data = NULL; 331 return 0; 332 } 333 334 module_acpi_driver(acpi_smb_hc_driver); 335 336 MODULE_LICENSE("GPL"); 337 MODULE_AUTHOR("Alexey Starikovskiy"); 338 MODULE_DESCRIPTION("ACPI SMBus HC driver"); 339