1 /*- 2 * Copyright (c) 2005 Hans Petter Selasky 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include "opt_acpi.h" 31 #include <sys/param.h> 32 #include <sys/kernel.h> 33 #include <sys/module.h> 34 #include <sys/bus.h> 35 36 #include <contrib/dev/acpica/include/acpi.h> 37 38 #include <dev/acpica/acpivar.h> 39 #include <dev/acpica/acpiio.h> 40 #include <dev/acpica/acpi_smbus.h> 41 42 /* Transactions have failed after 500 ms. */ 43 #define SMBUS_TIMEOUT 50 44 45 struct acpi_smbat_softc { 46 uint8_t sb_base_addr; 47 device_t ec_dev; 48 49 struct acpi_bif bif; 50 struct acpi_bst bst; 51 struct timespec bif_lastupdated; 52 struct timespec bst_lastupdated; 53 }; 54 55 static int acpi_smbat_probe(device_t dev); 56 static int acpi_smbat_attach(device_t dev); 57 static int acpi_smbat_shutdown(device_t dev); 58 static int acpi_smbat_info_expired(struct timespec *lastupdated); 59 static void acpi_smbat_info_updated(struct timespec *lastupdated); 60 static int acpi_smbat_get_bif(device_t dev, struct acpi_bif *bif); 61 static int acpi_smbat_get_bst(device_t dev, struct acpi_bst *bst); 62 63 ACPI_SERIAL_DECL(smbat, "ACPI Smart Battery"); 64 65 SYSCTL_DECL(_debug_acpi); 66 SYSCTL_NODE(_debug_acpi, OID_AUTO, batt, CTLFLAG_RD, NULL, "Battery debugging"); 67 68 /* On some laptops with smart batteries, enabling battery monitoring 69 * software causes keystrokes from atkbd to be lost. This has also been 70 * reported on Linux, and is apparently due to the keyboard and I2C line 71 * for the battery being routed through the same chip. Whether that's 72 * accurate or not, adding extra sleeps to the status checking code 73 * causes the problem to go away. 74 * 75 * If you experience that problem, try a value of 10ms and move up 76 * from there. 77 */ 78 static int batt_sleep_ms; 79 SYSCTL_INT(_debug_acpi_batt, OID_AUTO, batt_sleep_ms, CTLFLAG_RW, &batt_sleep_ms, 0, 80 "Sleep during battery status updates to prevent keystroke loss."); 81 82 static device_method_t acpi_smbat_methods[] = { 83 /* device interface */ 84 DEVMETHOD(device_probe, acpi_smbat_probe), 85 DEVMETHOD(device_attach, acpi_smbat_attach), 86 DEVMETHOD(device_shutdown, acpi_smbat_shutdown), 87 88 /* ACPI battery interface */ 89 DEVMETHOD(acpi_batt_get_status, acpi_smbat_get_bst), 90 DEVMETHOD(acpi_batt_get_info, acpi_smbat_get_bif), 91 92 {0, 0} 93 }; 94 95 static driver_t acpi_smbat_driver = { 96 "battery", 97 acpi_smbat_methods, 98 sizeof(struct acpi_smbat_softc), 99 }; 100 101 static devclass_t acpi_smbat_devclass; 102 DRIVER_MODULE(acpi_smbat, acpi, acpi_smbat_driver, acpi_smbat_devclass, 0, 0); 103 MODULE_DEPEND(acpi_smbat, acpi, 1, 1, 1); 104 105 static int 106 acpi_smbat_probe(device_t dev) 107 { 108 static char *smbat_ids[] = {"ACPI0001", "ACPI0005", NULL}; 109 ACPI_STATUS status; 110 111 if (acpi_disabled("smbat") || 112 ACPI_ID_PROBE(device_get_parent(dev), dev, smbat_ids) == NULL) 113 return (ENXIO); 114 status = AcpiEvaluateObject(acpi_get_handle(dev), "_EC", NULL, NULL); 115 if (ACPI_FAILURE(status)) 116 return (ENXIO); 117 118 device_set_desc(dev, "ACPI Smart Battery"); 119 return (0); 120 } 121 122 static int 123 acpi_smbat_attach(device_t dev) 124 { 125 struct acpi_smbat_softc *sc; 126 uint32_t base; 127 128 sc = device_get_softc(dev); 129 if (ACPI_FAILURE(acpi_GetInteger(acpi_get_handle(dev), "_EC", &base))) { 130 device_printf(dev, "cannot get EC base address\n"); 131 return (ENXIO); 132 } 133 sc->sb_base_addr = (base >> 8) & 0xff; 134 135 /* XXX Only works with one EC, but nearly all systems only have one. */ 136 sc->ec_dev = devclass_get_device(devclass_find("acpi_ec"), 0); 137 if (sc->ec_dev == NULL) { 138 device_printf(dev, "cannot find EC device\n"); 139 return (ENXIO); 140 } 141 142 timespecclear(&sc->bif_lastupdated); 143 timespecclear(&sc->bst_lastupdated); 144 145 if (acpi_battery_register(dev) != 0) { 146 device_printf(dev, "cannot register battery\n"); 147 return (ENXIO); 148 } 149 return (0); 150 } 151 152 static int 153 acpi_smbat_shutdown(device_t dev) 154 { 155 156 acpi_battery_remove(dev); 157 return (0); 158 } 159 160 static int 161 acpi_smbat_info_expired(struct timespec *lastupdated) 162 { 163 struct timespec curtime; 164 165 ACPI_SERIAL_ASSERT(smbat); 166 167 if (lastupdated == NULL) 168 return (TRUE); 169 if (!timespecisset(lastupdated)) 170 return (TRUE); 171 172 getnanotime(&curtime); 173 timespecsub(&curtime, lastupdated); 174 return (curtime.tv_sec < 0 || 175 curtime.tv_sec > acpi_battery_get_info_expire()); 176 } 177 178 static void 179 acpi_smbat_info_updated(struct timespec *lastupdated) 180 { 181 182 ACPI_SERIAL_ASSERT(smbat); 183 184 if (lastupdated != NULL) 185 getnanotime(lastupdated); 186 } 187 188 static int 189 acpi_smbus_read_2(struct acpi_smbat_softc *sc, uint8_t addr, uint8_t cmd, 190 uint16_t *ptr) 191 { 192 int error, to; 193 UINT64 val; 194 195 ACPI_SERIAL_ASSERT(smbat); 196 197 if (batt_sleep_ms) 198 AcpiOsSleep(batt_sleep_ms); 199 200 val = addr; 201 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_ADDR, 202 val, 1); 203 if (error) 204 goto out; 205 206 val = cmd; 207 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_CMD, 208 val, 1); 209 if (error) 210 goto out; 211 212 val = 0x09; /* | 0x80 if PEC */ 213 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL, 214 val, 1); 215 if (error) 216 goto out; 217 218 if (batt_sleep_ms) 219 AcpiOsSleep(batt_sleep_ms); 220 221 for (to = SMBUS_TIMEOUT; to != 0; to--) { 222 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL, 223 &val, 1); 224 if (error) 225 goto out; 226 if (val == 0) 227 break; 228 AcpiOsSleep(10); 229 } 230 if (to == 0) { 231 error = ETIMEDOUT; 232 goto out; 233 } 234 235 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_STS, &val, 1); 236 if (error) 237 goto out; 238 if (val & SMBUS_STS_MASK) { 239 printf("%s: AE_ERROR 0x%x\n", 240 __FUNCTION__, (int)(val & SMBUS_STS_MASK)); 241 error = EIO; 242 goto out; 243 } 244 245 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_DATA, 246 &val, 2); 247 if (error) 248 goto out; 249 250 *ptr = val; 251 252 out: 253 return (error); 254 } 255 256 static int 257 acpi_smbus_read_multi_1(struct acpi_smbat_softc *sc, uint8_t addr, uint8_t cmd, 258 uint8_t *ptr, uint16_t len) 259 { 260 UINT64 val; 261 uint8_t to; 262 int error; 263 264 ACPI_SERIAL_ASSERT(smbat); 265 266 if (batt_sleep_ms) 267 AcpiOsSleep(batt_sleep_ms); 268 269 val = addr; 270 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_ADDR, 271 val, 1); 272 if (error) 273 goto out; 274 275 val = cmd; 276 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_CMD, 277 val, 1); 278 if (error) 279 goto out; 280 281 val = 0x0B /* | 0x80 if PEC */ ; 282 error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL, 283 val, 1); 284 if (error) 285 goto out; 286 287 if (batt_sleep_ms) 288 AcpiOsSleep(batt_sleep_ms); 289 290 for (to = SMBUS_TIMEOUT; to != 0; to--) { 291 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL, 292 &val, 1); 293 if (error) 294 goto out; 295 if (val == 0) 296 break; 297 AcpiOsSleep(10); 298 } 299 if (to == 0) { 300 error = ETIMEDOUT; 301 goto out; 302 } 303 304 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_STS, &val, 1); 305 if (error) 306 goto out; 307 if (val & SMBUS_STS_MASK) { 308 printf("%s: AE_ERROR 0x%x\n", 309 __FUNCTION__, (int)(val & SMBUS_STS_MASK)); 310 error = EIO; 311 goto out; 312 } 313 314 /* get length */ 315 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_BCNT, 316 &val, 1); 317 if (error) 318 goto out; 319 val = (val & 0x1f) + 1; 320 321 bzero(ptr, len); 322 if (len > val) 323 len = val; 324 325 if (batt_sleep_ms) 326 AcpiOsSleep(batt_sleep_ms); 327 328 while (len--) { 329 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_DATA 330 + len, &val, 1); 331 if (error) 332 goto out; 333 334 ptr[len] = val; 335 if (batt_sleep_ms) 336 AcpiOsSleep(batt_sleep_ms); 337 } 338 339 out: 340 return (error); 341 } 342 343 static int 344 acpi_smbat_get_bst(device_t dev, struct acpi_bst *bst) 345 { 346 struct acpi_smbat_softc *sc; 347 int error; 348 uint32_t cap_units, factor; 349 int16_t val; 350 uint8_t addr; 351 352 ACPI_SERIAL_BEGIN(smbat); 353 354 addr = SMBATT_ADDRESS; 355 error = ENXIO; 356 sc = device_get_softc(dev); 357 358 if (!acpi_smbat_info_expired(&sc->bst_lastupdated)) { 359 error = 0; 360 goto out; 361 } 362 363 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_MODE, &val)) 364 goto out; 365 if (val & SMBATT_BM_CAPACITY_MODE) { 366 factor = 10; 367 cap_units = ACPI_BIF_UNITS_MW; 368 } else { 369 factor = 1; 370 cap_units = ACPI_BIF_UNITS_MA; 371 } 372 373 /* get battery status */ 374 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_STATUS, &val)) 375 goto out; 376 377 sc->bst.state = 0; 378 if (val & SMBATT_BS_DISCHARGING) 379 sc->bst.state |= ACPI_BATT_STAT_DISCHARG; 380 381 if (val & SMBATT_BS_REMAINING_CAPACITY_ALARM) 382 sc->bst.state |= ACPI_BATT_STAT_CRITICAL; 383 384 /* 385 * If the rate is negative, it is discharging. Otherwise, 386 * it is charging. 387 */ 388 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_CURRENT, &val)) 389 goto out; 390 391 if (val > 0) { 392 sc->bst.rate = val * factor; 393 sc->bst.state |= ACPI_BATT_STAT_CHARGING; 394 } else if (val < 0) 395 sc->bst.rate = (-val) * factor; 396 else 397 sc->bst.rate = 0; 398 399 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_REMAINING_CAPACITY, &val)) 400 goto out; 401 sc->bst.cap = val * factor; 402 403 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_VOLTAGE, &val)) 404 goto out; 405 sc->bst.volt = val; 406 407 acpi_smbat_info_updated(&sc->bst_lastupdated); 408 error = 0; 409 410 out: 411 if (error == 0) 412 memcpy(bst, &sc->bst, sizeof(sc->bst)); 413 ACPI_SERIAL_END(smbat); 414 return (error); 415 } 416 417 static int 418 acpi_smbat_get_bif(device_t dev, struct acpi_bif *bif) 419 { 420 struct acpi_smbat_softc *sc; 421 int error; 422 uint32_t factor; 423 uint16_t val; 424 uint8_t addr; 425 426 ACPI_SERIAL_BEGIN(smbat); 427 428 addr = SMBATT_ADDRESS; 429 error = ENXIO; 430 sc = device_get_softc(dev); 431 432 if (!acpi_smbat_info_expired(&sc->bif_lastupdated)) { 433 error = 0; 434 goto out; 435 } 436 437 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_MODE, &val)) 438 goto out; 439 if (val & SMBATT_BM_CAPACITY_MODE) { 440 factor = 10; 441 sc->bif.units = ACPI_BIF_UNITS_MW; 442 } else { 443 factor = 1; 444 sc->bif.units = ACPI_BIF_UNITS_MA; 445 } 446 447 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_DESIGN_CAPACITY, &val)) 448 goto out; 449 sc->bif.dcap = val * factor; 450 451 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_FULL_CHARGE_CAPACITY, &val)) 452 goto out; 453 sc->bif.lfcap = val * factor; 454 sc->bif.btech = 1; /* secondary (rechargeable) */ 455 456 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_DESIGN_VOLTAGE, &val)) 457 goto out; 458 sc->bif.dvol = val; 459 460 sc->bif.wcap = sc->bif.dcap / 10; 461 sc->bif.lcap = sc->bif.dcap / 10; 462 463 sc->bif.gra1 = factor; /* not supported */ 464 sc->bif.gra2 = factor; /* not supported */ 465 466 if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_DEVICE_NAME, 467 sc->bif.model, sizeof(sc->bif.model))) 468 goto out; 469 470 if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_SERIAL_NUMBER, &val)) 471 goto out; 472 snprintf(sc->bif.serial, sizeof(sc->bif.serial), "0x%04x", val); 473 474 if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_DEVICE_CHEMISTRY, 475 sc->bif.type, sizeof(sc->bif.type))) 476 goto out; 477 478 if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_MANUFACTURER_DATA, 479 sc->bif.oeminfo, sizeof(sc->bif.oeminfo))) 480 goto out; 481 482 /* XXX check if device was replugged during read? */ 483 484 acpi_smbat_info_updated(&sc->bif_lastupdated); 485 error = 0; 486 487 out: 488 if (error == 0) 489 memcpy(bif, &sc->bif, sizeof(sc->bif)); 490 ACPI_SERIAL_END(smbat); 491 return (error); 492 } 493