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, 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, NULL, NULL);
 323                 }
 324                 aibs_sensor_added(sc, *so, name, *s_idx, sensor, descr);
 325                 *s_idx += 1;
 326         }
 327
 328         AcpiOsFree(buf.Pointer);
 329         return (0);
 330 }
 331
 332 static int
 333 aibs_attach_sif(struct aibs_softc *sc, int st)
 334 {
 335         char                    name[] = "?SIF";
 336         ACPI_STATUS             s;
 337         ACPI_BUFFER             b;
 338         ACPI_OBJECT             *bp, *o;
 339         const char              *node;
 340         struct aibs_sensor      *as;
 341         struct sysctl_oid       **so;
 342         int                     i, n;
 343         int err;
 344
 345         switch (st) {
 346         case AIBS_SENS_TYPE_VOLT:
 347                 node = "volt";
 348                 name[0] = 'V';
 349                 so = &sc->sc_volt_sysctl;
 350                 break;
 351         case AIBS_SENS_TYPE_TEMP:
 352                 node = "temp";
 353                 name[0] = 'T';
 354                 so = &sc->sc_temp_sysctl;
 355                 break;
 356         case AIBS_SENS_TYPE_FAN:
 357                 node = "fan";
 358                 name[0] = 'F';
 359                 so = &sc->sc_fan_sysctl;
 360                 break;
 361         default:
 362                 panic("Unsupported sensor type %d", st);
 363         }
 364
 365         b.Length = ACPI_ALLOCATE_BUFFER;
 366         s = AcpiEvaluateObjectTyped(sc->sc_ah, name, NULL, &b,
 367             ACPI_TYPE_PACKAGE);
 368         if (ACPI_FAILURE(s)) {
 369                 device_printf(sc->sc_dev, "%s not found\n", name);
 370                 return (ENXIO);
 371         }
 372
 373         bp = b.Pointer;
 374         o = bp->Package.Elements;
 375         if (o[0].Type != ACPI_TYPE_INTEGER) {
 376                 device_printf(sc->sc_dev, "%s[0]: invalid type\n", name);
 377                 AcpiOsFree(b.Pointer);
 378                 return (ENXIO);
 379         }
 380
 381         n = o[0].Integer.Value;
 382         if (bp->Package.Count - 1 < n) {
 383                 device_printf(sc->sc_dev, "%s: invalid package\n", name);
 384                 AcpiOsFree(b.Pointer);
 385                 return (ENXIO);
 386         } else if (bp->Package.Count - 1 > n) {
 387                 int on = n;
 388
 389 #ifdef AIBS_MORE_SENSORS
 390                 n = bp->Package.Count - 1;
 391 #endif
 392                 device_printf(sc->sc_dev, "%s: malformed package: %i/%i"
 393                     ", assume %i\n", name, on, bp->Package.Count - 1, n);
 394         }
 395         if (n < 1) {
 396                 device_printf(sc->sc_dev, "%s: no members in the package\n",
 397                     name);
 398                 AcpiOsFree(b.Pointer);
 399                 return (ENXIO);
 400         }
 401
 402         as = malloc(sizeof(*as) * n, M_DEVBUF, M_WAITOK | M_ZERO);
 403         switch (st) {
 404         case AIBS_SENS_TYPE_VOLT:
 405                 sc->sc_asens_volt = as;
 406                 break;
 407         case AIBS_SENS_TYPE_TEMP:
 408                 sc->sc_asens_temp = as;
 409                 break;
 410         case AIBS_SENS_TYPE_FAN:
 411                 sc->sc_asens_fan = as;
 412                 break;
 413         }
 414
 415         /* sysctl subtree for sensors of this type */
 416         *so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
 417             SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)), st,
 418             node, CTLFLAG_RD, NULL, NULL);
 419
 420         for (i = 0, o++; i < n; i++, o++) {
 421                 const char      *descr;
 422
 423                 err = aibs_add_sensor(sc, o, &as[i], &descr);
 424                 if (err == 0)
 425                         aibs_sensor_added(sc, *so, node, i, &as[i], descr);
 426         }
 427
 428         AcpiOsFree(b.Pointer);
 429         return (0);
 430 }
 431
 432 static int
 433 aibs_detach(device_t dev)
 434 {
 435         struct aibs_softc       *sc = device_get_softc(dev);
 436
 437         if (sc->sc_asens_volt != NULL)
 438                 free(sc->sc_asens_volt, M_DEVBUF);
 439         if (sc->sc_asens_temp != NULL)
 440                 free(sc->sc_asens_temp, M_DEVBUF);
 441         if (sc->sc_asens_fan != NULL)
 442                 free(sc->sc_asens_fan, M_DEVBUF);
 443         if (sc->sc_asens_all != NULL)
 444                 free(sc->sc_asens_all, M_DEVBUF);
 445         return (0);
 446 }
 447
 448 #ifdef AIBS_VERBOSE
 449 #define ddevice_printf(x...) device_printf(x)
 450 #else
 451 #define ddevice_printf(x...)
 452 #endif
 453
 454 static int
 455 aibs_sysctl(SYSCTL_HANDLER_ARGS)
 456 {
 457         struct aibs_softc       *sc = arg1;
 458         struct aibs_sensor      *sensor = (void *)(intptr_t)arg2;
 459         int                     i = oidp->oid_number;
 460         ACPI_STATUS             rs;
 461         ACPI_OBJECT             p, *bp;
 462         ACPI_OBJECT_LIST        mp;
 463         ACPI_BUFFER             b;
 464         char                    *name;
 465         ACPI_INTEGER            v, l, h;
 466         int                     so[3];
 467
 468         switch (sensor->t) {
 469         case AIBS_SENS_TYPE_VOLT:
 470                 name = "RVLT";
 471                 break;
 472         case AIBS_SENS_TYPE_TEMP:
 473                 name = "RTMP";
 474                 break;
 475         case AIBS_SENS_TYPE_FAN:
 476                 name = "RFAN";
 477                 break;
 478         default:
 479                 return (ENOENT);
 480         }
 481         l = sensor->l;
 482         h = sensor->h;
 483         p.Type = ACPI_TYPE_INTEGER;
 484         p.Integer.Value = sensor->i;
 485         mp.Count = 1;
 486         mp.Pointer = &p;
 487         b.Length = ACPI_ALLOCATE_BUFFER;
 488         ACPI_SERIAL_BEGIN(aibs);
 489         rs = AcpiEvaluateObjectTyped(sc->sc_ah, name, &mp, &b,
 490             ACPI_TYPE_INTEGER);
 491         if (ACPI_FAILURE(rs)) {
 492                 ddevice_printf(sc->sc_dev,
 493                     "%s: %i: evaluation failed\n",
 494                     name, i);
 495                 ACPI_SERIAL_END(aibs);
 496                 return (EIO);
 497         }
 498         bp = b.Pointer;
 499         v = bp->Integer.Value;
 500         AcpiOsFree(b.Pointer);
 501         ACPI_SERIAL_END(aibs);
 502
 503         switch (sensor->t) {
 504         case AIBS_SENS_TYPE_VOLT:
 505                 break;
 506         case AIBS_SENS_TYPE_TEMP:
 507                 v += 2731;
 508                 l += 2731;
 509                 h += 2731;
 510                 break;
 511         case AIBS_SENS_TYPE_FAN:
 512                 break;
 513         }
 514         so[0] = v;
 515         so[1] = l;
 516         so[2] = h;
 517         return (sysctl_handle_opaque(oidp, &so, sizeof(so), req));
 518 }
 519
 520 static int
 521 aibs_sysctl_ggrp(SYSCTL_HANDLER_ARGS)
 522 {
 523         struct aibs_softc       *sc = arg1;
 524         struct aibs_sensor      *sensor = (void *)(intptr_t)arg2;
 525         ACPI_STATUS             rs;
 526         ACPI_OBJECT             p, *bp;
 527         ACPI_OBJECT_LIST        arg;
 528         ACPI_BUFFER             buf;
 529         ACPI_INTEGER            v, l, h;
 530         int                     so[3];
 531         uint32_t                *ret;
 532         uint32_t                cmd[3];
 533
 534         cmd[0] = sensor->i;
 535         cmd[1] = 0;
 536         cmd[2] = 0;
 537         p.Type = ACPI_TYPE_BUFFER;
 538         p.Buffer.Pointer = (void *)cmd;
 539         p.Buffer.Length = sizeof(cmd);
 540         arg.Count = 1;
 541         arg.Pointer = &p;
 542         buf.Pointer = NULL;
 543         buf.Length = ACPI_ALLOCATE_BUFFER;
 544         ACPI_SERIAL_BEGIN(aibs);
 545         rs = AcpiEvaluateObjectTyped(sc->sc_ah, "GITM", &arg, &buf,
 546             ACPI_TYPE_BUFFER);
 547         ACPI_SERIAL_END(aibs);
 548         if (ACPI_FAILURE(rs)) {
 549                 device_printf(sc->sc_dev, "GITM evaluation failed\n");
 550                 return (EIO);
 551         }
 552         bp = buf.Pointer;
 553         if (bp->Buffer.Length < 8) {
 554                 device_printf(sc->sc_dev, "GITM returned short buffer\n");
 555                 return (EIO);
 556         }
 557         ret = (uint32_t *)bp->Buffer.Pointer;
 558         if (ret[0] == 0) {
 559                 device_printf(sc->sc_dev, "GITM returned error status\n");
 560                 return (EINVAL);
 561         }
 562         v = ret[1];
 563         AcpiOsFree(buf.Pointer);
 564
 565         l = sensor->l;
 566         h = sensor->h;
 567
 568         switch (sensor->t) {
 569         case AIBS_SENS_TYPE_VOLT:
 570                 break;
 571         case AIBS_SENS_TYPE_TEMP:
 572                 v += 2731;
 573                 l += 2731;
 574                 h += 2731;
 575                 break;
 576         case AIBS_SENS_TYPE_FAN:
 577                 break;
 578         }
 579         so[0] = v;
 580         so[1] = l;
 581         so[2] = h;
 582         return (sysctl_handle_opaque(oidp, &so, sizeof(so), req));
 583 }