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"); 330