sys/dev/acpi_support/atk0110.c

   1 /*      $NetBSD: atk0110.c,v 1.4 2010/02/11 06:54:57 cnst Exp $ */
   2 /*      $OpenBSD: atk0110.c,v 1.1 2009/07/23 01:38:16 cnst Exp $        */
   3
   4 /*
   5  * Copyright (c) 2009, 2010 Constantine A. Murenin <cnst++@FreeBSD.org>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 #include <sys/cdefs.h>
  21 __FBSDID("$FreeBSD$");
  22
  23 #include <machine/_inttypes.h>
  24 #include <sys/param.h>
  25 #include <sys/systm.h>
  26 #include <sys/kernel.h>
  27 #include <sys/bus.h>
  28 #include <sys/module.h>
  29 #include <sys/malloc.h>
  30 #include <sys/sysctl.h>
  31 #include <sys/stdint.h>
  32
  33 #include <contrib/dev/acpica/include/acpi.h>
  34 #include <dev/acpica/acpivar.h>
  35
  36 /*
  37  * ASUSTeK AI Booster (ACPI ASOC ATK0110).
  38  *
  39  * This code was originally written for OpenBSD after the techniques
  40  * described in the Linux's asus_atk0110.c and FreeBSD's Takanori Watanabe's
  41  * acpi_aiboost.c were verified to be accurate on the actual hardware kindly
  42  * provided by Sam Fourman Jr.  It was subsequently ported from OpenBSD to
  43  * DragonFly BSD, to NetBSD's sysmon_envsys(9) and to FreeBSD's sysctl(9).
  44  *
  45  *                                -- Constantine A. Murenin <http://cnst.su/>
  46  */
  47
  48 #define _COMPONENT      ACPI_OEM
  49 ACPI_MODULE_NAME("aibs");
  50 ACPI_SERIAL_DECL(aibs, "aibs");
  51
  52 #define AIBS_MORE_SENSORS
  53 #define AIBS_VERBOSE
  54
  55 #define AIBS_GROUP_SENSORS      0x06
  56
  57 #define AIBS_SENS_TYPE(x)       (((x) >> 16) & 0xff)
  58 #define AIBS_SENS_TYPE_VOLT     2
  59 #define AIBS_SENS_TYPE_TEMP     3
  60 #define AIBS_SENS_TYPE_FAN      4
  61
  62 #define AIBS_SENS_TYPE_VOLT_NAME                "volt"
  63 #define AIBS_SENS_TYPE_VOLT_TEMP                "temp"
  64 #define AIBS_SENS_TYPE_VOLT_FAN         "fan"
  65
  66 struct aibs_sensor {
  67         ACPI_INTEGER    v;
  68         ACPI_INTEGER    i;
  69         ACPI_INTEGER    l;
  70         ACPI_INTEGER    h;
  71         int             t;
  72 };
  73
  74 struct aibs_softc {
  75         device_t                sc_dev;
  76         ACPI_HANDLE             sc_ah;
  77
  78         struct aibs_sensor      *sc_asens_volt;
  79         struct aibs_sensor      *sc_asens_temp;
  80         struct aibs_sensor      *sc_asens_fan;
  81         struct aibs_sensor      *sc_asens_all;
  82
  83         struct sysctl_oid       *sc_volt_sysctl;
  84         struct sysctl_oid       *sc_temp_sysctl;
  85         struct sysctl_oid       *sc_fan_sysctl;
  86
  87         bool                    sc_ggrp_method;
  88 };
  89
  90 static int aibs_probe(device_t);
  91 static int aibs_attach(device_t);
  92 static int aibs_detach(device_t);
  93 static int aibs_sysctl(SYSCTL_HANDLER_ARGS);
  94 static int aibs_sysctl_ggrp(SYSCTL_HANDLER_ARGS);
  95
  96 static int aibs_attach_ggrp(struct aibs_softc *);
  97 static int aibs_attach_sif(struct aibs_softc *, int);
  98
  99 static device_method_t aibs_methods[] = {
 100         DEVMETHOD(device_probe,         aibs_probe),
 101         DEVMETHOD(device_attach,        aibs_attach),
 102         DEVMETHOD(device_detach,        aibs_detach),
 103         { NULL, NULL }
 104 };
 105
 106 static driver_t aibs_driver = {
 107         "aibs",
 108         aibs_methods,
 109         sizeof(struct aibs_softc)
 110 };
 111
 112 static devclass_t aibs_devclass;
 113
 114 DRIVER_MODULE(aibs, acpi, aibs_driver, aibs_devclass, NULL, NULL);
 115 MODULE_DEPEND(aibs, acpi, 1, 1, 1);
 116
 117 static char* aibs_hids[] = {
 118         "ATK0110",
 119         NULL
 120 };
 121
 122 static int
 123 aibs_probe(device_t dev)
 124 {
 125         int rv;
 126
 127         if (acpi_disabled("aibs"))
 128                 return (ENXIO);
 129         rv = ACPI_ID_PROBE(device_get_parent(dev), dev, aibs_hids, NULL);
 130         if (rv <= 0 )
 131                 device_set_desc(dev, "ASUSTeK AI Booster (ACPI ASOC ATK0110)");
 132         return (rv);
 133 }
 134
 135 static int
 136 aibs_attach(device_t dev)
 137 {
 138         struct aibs_softc *sc = device_get_softc(dev);
 139         int err;
 140
 141         sc->sc_dev = dev;
 142         sc->sc_ah = acpi_get_handle(dev);
 143
 144         sc->sc_ggrp_method = false;
 145         err = aibs_attach_sif(sc, AIBS_SENS_TYPE_VOLT);
 146         if (err == 0)
 147                 err = aibs_attach_sif(sc, AIBS_SENS_TYPE_TEMP);
 148         if (err == 0)
 149                 err = aibs_attach_sif(sc, AIBS_SENS_TYPE_FAN);
 150
 151         if (err == 0)
 152                 return (0);
 153
 154         /* Clean up whatever was allocated earlier. */
 155         if (sc->sc_volt_sysctl != NULL)
 156                 sysctl_remove_oid(sc->sc_volt_sysctl, true, true);
 157         if (sc->sc_temp_sysctl != NULL)
 158                 sysctl_remove_oid(sc->sc_temp_sysctl, true, true);
 159         if (sc->sc_fan_sysctl != NULL)
 160                 sysctl_remove_oid(sc->sc_fan_sysctl, true, true);
 161         aibs_detach(dev);
 162
 163         sc->sc_ggrp_method = true;
 164         err = aibs_attach_ggrp(sc);
 165         return (err);
 166 }
 167
 168 static int
 169 aibs_add_sensor(struct aibs_softc *sc, ACPI_OBJECT *o,
 170     struct aibs_sensor* sensor, const char ** descr)
 171 {
 172         int             off;
 173
 174         /*
 175          * Packages for the old and new methods are quite
 176          * similar except that the new package has two
 177          * new (unknown / unused) fields after the name field.
 178          */
 179         if (sc->sc_ggrp_method)
 180                 off = 4;
 181         else
 182                 off = 2;
 183
 184         if (o->Type != ACPI_TYPE_PACKAGE) {
 185                 device_printf(sc->sc_dev,
 186                     "sensor object is not a package: %i type\n",
 187                      o->Type);
 188                 return (ENXIO);
 189         }
 190         if (o[0].Package.Count != (off + 3) ||
 191             o->Package.Elements[0].Type != ACPI_TYPE_INTEGER ||
 192             o->Package.Elements[1].Type != ACPI_TYPE_STRING ||
 193             o->Package.Elements[off].Type != ACPI_TYPE_INTEGER ||
 194             o->Package.Elements[off + 1].Type != ACPI_TYPE_INTEGER ||
 195             o->Package.Elements[off + 2].Type != ACPI_TYPE_INTEGER) {
 196                 device_printf(sc->sc_dev, "unexpected package content\n");
 197                 return (ENXIO);
 198         }
 199
 200         sensor->i = o->Package.Elements[0].Integer.Value;
 201         *descr = o->Package.Elements[1].String.Pointer;
 202         sensor->l = o->Package.Elements[off].Integer.Value;
 203         sensor->h = o->Package.Elements[off + 1].Integer.Value;
 204         /* For the new method the second value is a range size. */
 205         if (sc->sc_ggrp_method)
 206                 sensor->h += sensor->l;
 207         sensor->t = AIBS_SENS_TYPE(sensor->i);
 208
 209         switch (sensor->t) {
 210         case AIBS_SENS_TYPE_VOLT:
 211         case AIBS_SENS_TYPE_TEMP:
 212         case AIBS_SENS_TYPE_FAN:
 213                 return (0);
 214         default:
 215                 device_printf(sc->sc_dev, "unknown sensor type 0x%x",
 216                     sensor->t);
 217                 return (ENXIO);
 218         }
 219 }
 220
 221 static void
 222 aibs_sensor_added(struct aibs_softc *sc, struct sysctl_oid *so,
 223     const char *type_name, int idx, struct aibs_sensor *sensor,
 224     const char *descr)
 225 {
 226         char    sysctl_name[8];
 227
 228         snprintf(sysctl_name, sizeof(sysctl_name), "%i", idx);
 229 #ifdef AIBS_VERBOSE
 230         device_printf(sc->sc_dev, "%c%i: 0x%08jx %20s %5jd / %5jd\n",
 231             type_name[0], idx,
 232             (uintmax_t)sensor->i, descr, (intmax_t)sensor->l,
 233             (intmax_t)sensor->h);
 234 #endif
 235         SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->sc_dev),
 236             SYSCTL_CHILDREN(so), idx, sysctl_name,
 237             CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, (uintptr_t)sensor,
 238             sc->sc_ggrp_method ? aibs_sysctl_ggrp : aibs_sysctl,
 239             sensor->t == AIBS_SENS_TYPE_TEMP ? "IK" : "I", descr);
 240 }
 241
 242 static int
 243 aibs_attach_ggrp(struct aibs_softc *sc)
 244 {
 245         ACPI_STATUS             s;
 246         ACPI_BUFFER             buf;
 247         ACPI_HANDLE             h;
 248         ACPI_OBJECT             id;
 249         ACPI_OBJECT             *bp;
 250         ACPI_OBJECT_LIST        arg;
 251         int                     i;
 252         int                     t, v, f;
 253         int                     err;
 254         int                     *s_idx;
 255         const char              *name;
 256         const char              *descr;
 257         struct aibs_sensor      *sensor;
 258         struct sysctl_oid       **so;
 259
 260         /* First see if GITM is available. */
 261         s = AcpiGetHandle(sc->sc_ah, "GITM", &h);
 262         if (ACPI_FAILURE(s)) {
 263                 if (bootverbose)
 264                         device_printf(sc->sc_dev, "GITM not found\n");
 265                 return (ENXIO);
 266         }
 267
 268         /*
 269          * Now call GGRP with the appropriate argument to list sensors.
 270          * The method lists different groups of entities depending on
 271          * the argument.
 272          */
 273         id.Integer.Value = AIBS_GROUP_SENSORS;
 274         id.Type = ACPI_TYPE_INTEGER;
 275         arg.Count = 1;
 276         arg.Pointer = &id;
 277         buf.Length = ACPI_ALLOCATE_BUFFER;
 278         buf.Pointer = NULL;
 279         s = AcpiEvaluateObjectTyped(sc->sc_ah, "GGRP", &arg, &buf,
 280             ACPI_TYPE_PACKAGE);
 281         if (ACPI_FAILURE(s)) {
 282                 device_printf(sc->sc_dev, "GGRP not found\n");
 283                 return (ENXIO);
 284         }
 285
 286         bp = buf.Pointer;
 287         sc->sc_asens_all = malloc(sizeof(*sc->sc_asens_all) * bp->Package.Count,
 288             M_DEVBUF, M_WAITOK | M_ZERO);
 289         v = t = f = 0;
 290         for (i = 0; i < bp->Package.Count; i++) {
 291                 sensor = &sc->sc_asens_all[i];
 292                 err = aibs_add_sensor(sc, &bp->Package.Elements[i], sensor,
 293                     &descr);
 294                 if (err != 0)
 295                         continue;
 296
 297                 switch (sensor->t) {
 298                 case AIBS_SENS_TYPE_VOLT:
 299                         name = "volt";
 300                         so = &sc->sc_volt_sysctl;
 301                         s_idx = &v;
 302                         break;
 303                 case AIBS_SENS_TYPE_TEMP:
 304                         name = "temp";
 305                         so = &sc->sc_temp_sysctl;
 306                         s_idx = &t;
 307                         break;
 308                 case AIBS_SENS_TYPE_FAN:
 309                         name = "fan";
 310                         so = &sc->sc_fan_sysctl;
 311                         s_idx = &f;
 312                         break;
 313                 default:
 314                         panic("add_sensor succeeded for unknown sensor type %d",
 315                             sensor->t);
 316                 }
 317
 318                 if (*so == NULL) {
 319                         /* sysctl subtree for sensors of this type */
 320                         *so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
 321                             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)),
 322                             sensor->t, name, CTLFLAG_RD | CTLFLAG_MPSAFE,
 323                             NULL, NULL);
 324                 }
 325                 aibs_sensor_added(sc, *so, name, *s_idx, sensor, descr);
 326                 *s_idx += 1;
 327         }
 328
 329         AcpiOsFree(buf.Pointer);
 330         return (0);
 331 }
 332
 333 static int
 334 aibs_attach_sif(struct aibs_softc *sc, int st)
 335 {
 336         char                    name[] = "?SIF";
 337         ACPI_STATUS             s;
 338         ACPI_BUFFER             b;
 339         ACPI_OBJECT             *bp, *o;
 340         const char              *node;
 341         struct aibs_sensor      *as;
 342         struct sysctl_oid       **so;
 343         int                     i, n;
 344         int err;
 345
 346         switch (st) {
 347         case AIBS_SENS_TYPE_VOLT:
 348                 node = "volt";
 349                 name[0] = 'V';
 350                 so = &sc->sc_volt_sysctl;
 351                 break;
 352         case AIBS_SENS_TYPE_TEMP:
 353                 node = "temp";
 354                 name[0] = 'T';
 355                 so = &sc->sc_temp_sysctl;
 356                 break;
 357         case AIBS_SENS_TYPE_FAN:
 358                 node = "fan";
 359                 name[0] = 'F';
 360                 so = &sc->sc_fan_sysctl;
 361                 break;
 362         default:
 363                 panic("Unsupported sensor type %d", st);
 364         }
 365
 366         b.Length = ACPI_ALLOCATE_BUFFER;
 367         s = AcpiEvaluateObjectTyped(sc->sc_ah, name, NULL, &b,
 368             ACPI_TYPE_PACKAGE);
 369         if (ACPI_FAILURE(s)) {
 370                 device_printf(sc->sc_dev, "%s not found\n", name);
 371                 return (ENXIO);
 372         }
 373
 374         bp = b.Pointer;
 375         o = bp->Package.Elements;
 376         if (o[0].Type != ACPI_TYPE_INTEGER) {
 377                 device_printf(sc->sc_dev, "%s[0]: invalid type\n", name);
 378                 AcpiOsFree(b.Pointer);
 379                 return (ENXIO);
 380         }
 381
 382         n = o[0].Integer.Value;
 383         if (bp->Package.Count - 1 < n) {
 384                 device_printf(sc->sc_dev, "%s: invalid package\n", name);
 385                 AcpiOsFree(b.Pointer);
 386                 return (ENXIO);
 387         } else if (bp->Package.Count - 1 > n) {
 388                 int on = n;
 389
 390 #ifdef AIBS_MORE_SENSORS
 391                 n = bp->Package.Count - 1;
 392 #endif
 393                 device_printf(sc->sc_dev, "%s: malformed package: %i/%i"
 394                     ", assume %i\n", name, on, bp->Package.Count - 1, n);
 395         }
 396         if (n < 1) {
 397                 device_printf(sc->sc_dev, "%s: no members in the package\n",
 398                     name);
 399                 AcpiOsFree(b.Pointer);
 400                 return (ENXIO);
 401         }
 402
 403         as = malloc(sizeof(*as) * n, M_DEVBUF, M_WAITOK | M_ZERO);
 404         switch (st) {
 405         case AIBS_SENS_TYPE_VOLT:
 406                 sc->sc_asens_volt = as;
 407                 break;
 408         case AIBS_SENS_TYPE_TEMP:
 409                 sc->sc_asens_temp = as;
 410                 break;
 411         case AIBS_SENS_TYPE_FAN:
 412                 sc->sc_asens_fan = as;
 413                 break;
 414         }
 415
 416         /* sysctl subtree for sensors of this type */
 417         *so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
 418             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)), st,
 419             node, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, NULL);
 420
 421         for (i = 0, o++; i < n; i++, o++) {
 422                 const char      *descr;
 423
 424                 err = aibs_add_sensor(sc, o, &as[i], &descr);
 425                 if (err == 0)
 426                         aibs_sensor_added(sc, *so, node, i, &as[i], descr);
 427         }
 428
 429         AcpiOsFree(b.Pointer);
 430         return (0);
 431 }
 432
 433 static int
 434 aibs_detach(device_t dev)
 435 {
 436         struct aibs_softc       *sc = device_get_softc(dev);
 437
 438         if (sc->sc_asens_volt != NULL)
 439                 free(sc->sc_asens_volt, M_DEVBUF);
 440         if (sc->sc_asens_temp != NULL)
 441                 free(sc->sc_asens_temp, M_DEVBUF);
 442         if (sc->sc_asens_fan != NULL)
 443                 free(sc->sc_asens_fan, M_DEVBUF);
 444         if (sc->sc_asens_all != NULL)
 445                 free(sc->sc_asens_all, M_DEVBUF);
 446         return (0);
 447 }
 448
 449 #ifdef AIBS_VERBOSE
 450 #define ddevice_printf(x...) device_printf(x)
 451 #else
 452 #define ddevice_printf(x...)
 453 #endif
 454
 455 static int
 456 aibs_sysctl(SYSCTL_HANDLER_ARGS)
 457 {
 458         struct aibs_softc       *sc = arg1;
 459         struct aibs_sensor      *sensor = (void *)(intptr_t)arg2;
 460         int                     i = oidp->oid_number;
 461         ACPI_STATUS             rs;
 462         ACPI_OBJECT             p, *bp;
 463         ACPI_OBJECT_LIST        mp;
 464         ACPI_BUFFER             b;
 465         char                    *name;
 466         ACPI_INTEGER            v, l, h;
 467         int                     so[3];
 468
 469         switch (sensor->t) {
 470         case AIBS_SENS_TYPE_VOLT:
 471                 name = "RVLT";
 472                 break;
 473         case AIBS_SENS_TYPE_TEMP:
 474                 name = "RTMP";
 475                 break;
 476         case AIBS_SENS_TYPE_FAN:
 477                 name = "RFAN";
 478                 break;
 479         default:
 480                 return (ENOENT);
 481         }
 482         l = sensor->l;
 483         h = sensor->h;
 484         p.Type = ACPI_TYPE_INTEGER;
 485         p.Integer.Value = sensor->i;
 486         mp.Count = 1;
 487         mp.Pointer = &p;
 488         b.Length = ACPI_ALLOCATE_BUFFER;
 489         ACPI_SERIAL_BEGIN(aibs);
 490         rs = AcpiEvaluateObjectTyped(sc->sc_ah, name, &mp, &b,
 491             ACPI_TYPE_INTEGER);
 492         if (ACPI_FAILURE(rs)) {
 493                 ddevice_printf(sc->sc_dev,
 494                     "%s: %i: evaluation failed\n",
 495                     name, i);
 496                 ACPI_SERIAL_END(aibs);
 497                 return (EIO);
 498         }
 499         bp = b.Pointer;
 500         v = bp->Integer.Value;
 501         AcpiOsFree(b.Pointer);
 502         ACPI_SERIAL_END(aibs);
 503
 504         switch (sensor->t) {
 505         case AIBS_SENS_TYPE_VOLT:
 506                 break;
 507         case AIBS_SENS_TYPE_TEMP:
 508                 v += 2731;
 509                 l += 2731;
 510                 h += 2731;
 511                 break;
 512         case AIBS_SENS_TYPE_FAN:
 513                 break;
 514         }
 515         so[0] = v;
 516         so[1] = l;
 517         so[2] = h;
 518         return (sysctl_handle_opaque(oidp, &so, sizeof(so), req));
 519 }
 520
 521 static int
 522 aibs_sysctl_ggrp(SYSCTL_HANDLER_ARGS)
 523 {
 524         struct aibs_softc       *sc = arg1;
 525         struct aibs_sensor      *sensor = (void *)(intptr_t)arg2;
 526         ACPI_STATUS             rs;
 527         ACPI_OBJECT             p, *bp;
 528         ACPI_OBJECT_LIST        arg;
 529         ACPI_BUFFER             buf;
 530         ACPI_INTEGER            v, l, h;
 531         int                     so[3];
 532         uint32_t                *ret;
 533         uint32_t                cmd[3];
 534
 535         cmd[0] = sensor->i;
 536         cmd[1] = 0;
 537         cmd[2] = 0;
 538         p.Type = ACPI_TYPE_BUFFER;
 539         p.Buffer.Pointer = (void *)cmd;
 540         p.Buffer.Length = sizeof(cmd);
 541         arg.Count = 1;
 542         arg.Pointer = &p;
 543         buf.Pointer = NULL;
 544         buf.Length = ACPI_ALLOCATE_BUFFER;
 545         ACPI_SERIAL_BEGIN(aibs);
 546         rs = AcpiEvaluateObjectTyped(sc->sc_ah, "GITM", &arg, &buf,
 547             ACPI_TYPE_BUFFER);
 548         ACPI_SERIAL_END(aibs);
 549         if (ACPI_FAILURE(rs)) {
 550                 device_printf(sc->sc_dev, "GITM evaluation failed\n");
 551                 return (EIO);
 552         }
 553         bp = buf.Pointer;
 554         if (bp->Buffer.Length < 8) {
 555                 device_printf(sc->sc_dev, "GITM returned short buffer\n");
 556                 return (EIO);
 557         }
 558         ret = (uint32_t *)bp->Buffer.Pointer;
 559         if (ret[0] == 0) {
 560                 device_printf(sc->sc_dev, "GITM returned error status\n");
 561                 return (EINVAL);
 562         }
 563         v = ret[1];
 564         AcpiOsFree(buf.Pointer);
 565
 566         l = sensor->l;
 567         h = sensor->h;
 568
 569         switch (sensor->t) {
 570         case AIBS_SENS_TYPE_VOLT:
 571                 break;
 572         case AIBS_SENS_TYPE_TEMP:
 573                 v += 2731;
 574                 l += 2731;
 575                 h += 2731;
 576                 break;
 577         case AIBS_SENS_TYPE_FAN:
 578                 break;
 579         }
 580         so[0] = v;
 581         so[1] = l;
 582         so[2] = h;
 583         return (sysctl_handle_opaque(oidp, &so, sizeof(so), req));
 584 }