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