rom/hidds/acpi/button/acpibutton_init.c

   1 /*
   2     Copyright (C) 2017-2018, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <stddef.h>
  10 #include <exec/types.h>
  11
  12 #include <proto/exec.h>
  13 #include <proto/oop.h>
  14
  15 #include <aros/symbolsets.h>
  16 #include <hidd/hidd.h>
  17 #include <hidd/system.h>
  18
  19 #include <limits.h>
  20
  21 #include "acpibutton_intern.h"
  22
  23 #include LC_LIBDEFS_FILE
  24
  25 AROS_UFH3(IPTR, ACPIButton_PowerEventHandle,
  26     AROS_UFHA(struct Hook *, hook, A0),
  27     AROS_UFHA(APTR, object, A2),
  28     AROS_UFHA(APTR, message, A1)
  29 )
  30 {
  31     AROS_USERFUNC_INIT
  32
  33     struct Task *sigTask = NULL;
  34     OOP_Class   *cl;
  35     IPTR        powerSig = 0;
  36
  37 //    ACPI_HANDLE device = (ACPI_HANDLE)message;
  38
  39     D(bug("[HWACPIButton] %s()\n", __func__));
  40
  41     cl = OOP_OCLASS(object);
  42     OOP_GetAttr(object, aHW_ACPIButton_ServiceTask, (IPTR *)&sigTask);
  43     OOP_GetAttr(object, aHW_ACPIButton_ServiceSigPower, &powerSig);
  44
  45     if (sigTask)
  46     {
  47         D(bug("[HWACPIButton] %s: Signalling service task to handle Power Button event..\n", __func__));
  48         Signal(sigTask, (1 << powerSig));
  49     }
  50
  51     return 0;
  52
  53     AROS_USERFUNC_EXIT
  54 }
  55
  56 AROS_UFH3(IPTR, ACPIButton_SleepEventHandle,
  57     AROS_UFHA(struct Hook *, hook, A0),
  58     AROS_UFHA(APTR, object, A2),
  59     AROS_UFHA(APTR, message, A1)
  60 )
  61 {
  62     AROS_USERFUNC_INIT
  63
  64 //    ACPI_HANDLE device = (ACPI_HANDLE)message;
  65
  66     D(
  67         bug("[HWACPIButton] %s()\n", __func__);
  68         bug("[HWACPIButton] %s: Unhandled\n", __func__);
  69     )
  70
  71     return 0;
  72
  73     AROS_USERFUNC_EXIT
  74 }
  75
  76 AROS_UFH3(IPTR, ACPIButton_LidEventHandle,
  77     AROS_UFHA(struct Hook *, hook, A0),
  78     AROS_UFHA(APTR, object, A2),
  79     AROS_UFHA(APTR, message, A1)
  80 )
  81 {
  82     AROS_USERFUNC_INIT
  83
  84 //    ACPI_HANDLE device = (ACPI_HANDLE)message;
  85
  86     D(
  87         bug("[HWACPIButton] %s()\n", __func__);
  88         bug("[HWACPIButton] %s: Unhandled\n", __func__);
  89     )
  90
  91     return 0;
  92
  93     AROS_USERFUNC_EXIT
  94 }
  95
  96 BOOL ACPIButton_MatchDeviceID(ACPI_DEVICE_INFO *acpiDevInfo, char *deviceID)
  97 {
  98     ACPI_PNP_DEVICE_ID_LIST *cIdList;
  99     ACPI_PNP_DEVICE_ID *hwId;
 100     int cmptid;
 101
 102     hwId = AcpiGetInfoHardwareId(acpiDevInfo);
 103     if (hwId && !(strcmp(hwId->String, deviceID)))
 104         return TRUE;
 105     cIdList = AcpiGetInfoCompatIdList(acpiDevInfo);
 106     if (cIdList) {
 107         for (cmptid = 0; cmptid < cIdList->Count; cmptid++) {
 108             if (!(strcmp(cIdList->Ids[cmptid].String, deviceID)))
 109                 return TRUE;
 110         }
 111     }
 112     return FALSE;
 113 }
 114
 115 #undef _csd
 116
 117 static ACPI_STATUS ACPIButton_DeviceQuery(ACPI_HANDLE handle,
 118                                 UINT32 level,
 119                                 void *context,
 120                                 void **retval)
 121 {
 122     struct acpibuttonclass_staticdata    *_csd = (struct acpibuttonclass_staticdata *)context;
 123     ACPI_DEVICE_INFO            *acpiDevInfo = NULL;
 124     ACPI_STATUS                 acpiStatus;
 125
 126     D(bug("[HWACPIButton] %s(0x%p)\n", __func__, handle));
 127
 128     acpiStatus = AcpiGetObjectInfo(handle, &acpiDevInfo);
 129     if (ACPI_FAILURE(acpiStatus)) {
 130         if (acpiDevInfo) {
 131             FreeVec(acpiDevInfo);
 132         }
 133         return acpiStatus;
 134     }
 135
 136     if (ACPIButton_MatchDeviceID(acpiDevInfo, "PNP0C0C"))
 137     {
 138         D(bug("[HWACPIButton] %s: Power Button Device Found\n", __func__));
 139         if ((!_csd->powerButtonObj) && (!_csd->acpiPowerBHandle))
 140         {
 141             _csd->acpiPowerBHandle = handle;
 142             _csd->acpiPowerBType = vHW_ACPIButton_Power;
 143         }
 144     }
 145     else if (ACPIButton_MatchDeviceID(acpiDevInfo, "ACPI_FPB"))
 146     {
 147         D(bug("[HWACPIButton] %s: Fixed Power Button Device Found\n", __func__));
 148         if ((!_csd->powerButtonObj) && (!_csd->acpiPowerBHandle))
 149         {
 150             _csd->acpiPowerBHandle = handle;
 151             _csd->acpiPowerBType = vHW_ACPIButton_PowerF;
 152         }
 153     }
 154     else if (ACPIButton_MatchDeviceID(acpiDevInfo, "PNP0C0E"))
 155     {
 156         D(bug("[HWACPIButton] %s: Sleep Button Device Found\n", __func__));
 157         if ((!_csd->sleepButtonObj) && (!_csd->acpiSleepBHandle))
 158         {
 159             _csd->acpiSleepBHandle = handle;
 160             _csd->acpiSleepBType = vHW_ACPIButton_Sleep;
 161         }
 162     }
 163     else if (ACPIButton_MatchDeviceID(acpiDevInfo, "ACPI_FSB"))
 164     {
 165         D(bug("[HWACPIButton] %s: Fixed Sleep Button Device Found\n", __func__));
 166         if ((!_csd->sleepButtonObj) && (!_csd->acpiSleepBHandle))
 167         {
 168             _csd->acpiSleepBHandle = handle;
 169             _csd->acpiSleepBType = vHW_ACPIButton_SleepF;
 170         }
 171     }
 172     else if (ACPIButton_MatchDeviceID(acpiDevInfo, "PNP0C0D"))
 173     {
 174         D(bug("[HWACPIButton] %s: Lid Button Device Found\n", __func__));
 175         if ((!_csd->lidButtonObj) && (!_csd->acpibLidBHandle))
 176         {
 177             _csd->acpibLidBHandle = handle;
 178         }
 179     }
 180
 181     FreeVec(acpiDevInfo);
 182
 183     return AE_OK;
 184 }
 185
 186 static int ACPIButton_Init(LIBBASETYPEPTR LIBBASE)
 187 {
 188     struct acpibuttonclass_staticdata    *_csd = &LIBBASE->hsi_csd;
 189     OOP_Object                  *root;
 190     int                         buttonCount = 0;
 191     int                         retVal = FALSE;
 192     __unused ACPI_STATUS        acpiStatus;
 193
 194     D(bug("[HWACPIButton] %s()\n", __func__));
 195     D(bug("[HWACPIButton] %s: OOPBase @ 0x%p\n", __func__, OOPBase));
 196
 197     _csd->cs_ACPICABase = OpenLibrary("acpica.library", 0);
 198     if (!_csd->cs_ACPICABase)
 199         return FALSE;
 200
 201     _csd->cs_UtilityBase = OpenLibrary("utility.library", 36);
 202     if (!_csd->cs_UtilityBase)
 203     {
 204         CloseLibrary(_csd->cs_ACPICABase);
 205         return FALSE;
 206     }
 207
 208     root = OOP_NewObject(NULL, CLID_Hidd_System, NULL);
 209     if (!root)
 210         root = OOP_NewObject(NULL, CLID_HW_Root, NULL);
 211
 212     _csd->hwAB = OOP_ObtainAttrBase(IID_HW);
 213     _csd->hiddAB = OOP_ObtainAttrBase(IID_Hidd);
 214     _csd->hwACPIButtonAB = OOP_ObtainAttrBase(IID_HW_ACPIButton);
 215
 216     {
 217         struct TagItem instanceTags[] =
 218         {
 219             { _csd->hwACPIButtonAB + aoHW_ACPIButton_Type,      0},
 220             { _csd->hwACPIButtonAB + aoHW_ACPIButton_Handle,    0},
 221             { _csd->hwACPIButtonAB + aoHW_ACPIButton_Hook,      0},
 222             { TAG_DONE,                                         0}
 223         };
 224         ACPI_TABLE_FADT *fadt;
 225         struct Hook *buttonHook;
 226
 227         /* check for fixed feature buttons .. */
 228         if (AcpiGetTable(ACPI_SIG_FADT, 1, (ACPI_TABLE_HEADER **)&fadt) == AE_OK)
 229         {
 230             if ((!(fadt->Flags & ACPI_FADT_POWER_BUTTON)) && (!_csd->powerButtonObj))
 231             {
 232                 D(bug("[HWACPIButton] %s: Fixed Power-Button Enabled in FADT\n", __func__));
 233                 AcpiEnableEvent(ACPI_EVENT_POWER_BUTTON, 0);
 234                 AcpiClearEvent(ACPI_EVENT_POWER_BUTTON);
 235                 _csd->acpiPowerBType = vHW_ACPIButton_PowerF;
 236                 instanceTags[0].ti_Data = (IPTR)_csd->acpiPowerBType;
 237                 instanceTags[1].ti_Data = 0;
 238
 239                 buttonHook = AllocMem(sizeof(struct Hook), MEMF_CLEAR);
 240                 buttonHook->h_Entry = (HOOKFUNC)ACPIButton_PowerEventHandle;
 241                 buttonHook->h_Data = 0;
 242                 instanceTags[2].ti_Data = (IPTR)buttonHook;
 243
 244                 if (HW_AddDriver(root, _csd->oopclass, instanceTags))
 245                 {
 246                     D(bug("[HWACPIButton] %s: Fixed Power-Button initialised\n", __func__));
 247                     buttonCount++;
 248                 }
 249                 else
 250                     FreeMem(buttonHook, sizeof(struct Hook));
 251             }
 252             if ((!(fadt->Flags & ACPI_FADT_SLEEP_BUTTON)) && (!_csd->sleepButtonObj))
 253             {
 254                 D(bug("[HWACPIButton] %s: Fixed Sleep-Button Enabled in FADT\n", __func__));
 255                 AcpiEnableEvent(ACPI_EVENT_SLEEP_BUTTON, 0);
 256                 AcpiClearEvent(ACPI_EVENT_SLEEP_BUTTON);
 257                 _csd->acpiSleepBType = vHW_ACPIButton_SleepF;
 258                 instanceTags[0].ti_Data = (IPTR)_csd->acpiSleepBType;
 259                 instanceTags[1].ti_Data = 0;
 260
 261                 buttonHook = AllocMem(sizeof(struct Hook), MEMF_CLEAR);
 262                 buttonHook->h_Entry = (HOOKFUNC)ACPIButton_SleepEventHandle;
 263                 buttonHook->h_Data = 0;
 264                 instanceTags[2].ti_Data = (IPTR)buttonHook;
 265
 266                 if (HW_AddDriver(root, _csd->oopclass, instanceTags))
 267                 {
 268                     D(bug("[HWACPIButton] %s: Fixed Sleep-Button initialised\n", __func__));
 269                     buttonCount++;
 270                 }
 271                 else
 272                     FreeMem(buttonHook, sizeof(struct Hook));
 273             }
 274         }
 275
 276         /* check for button devices .. */
 277         acpiStatus = AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, INT_MAX, ACPIButton_DeviceQuery, NULL, _csd, NULL);
 278         if (acpiStatus == AE_OK)
 279         {
 280             if ((_csd->acpiPowerBHandle != NULL) && (!_csd->powerButtonObj))
 281             {
 282                 instanceTags[0].ti_Data = (IPTR)_csd->acpiPowerBType;
 283                 instanceTags[1].ti_Data = (IPTR)_csd->acpiPowerBHandle;
 284
 285                 buttonHook = AllocMem(sizeof(struct Hook), MEMF_CLEAR);
 286                 buttonHook->h_Entry = (HOOKFUNC)ACPIButton_PowerEventHandle;
 287                 buttonHook->h_Data = 0;
 288                 instanceTags[2].ti_Data = (IPTR)buttonHook;
 289
 290                 if (HW_AddDriver(root, _csd->oopclass, instanceTags))
 291                 {
 292                     D(bug("[HWACPIButton] %s: Power-Button initialised\n", __func__));
 293                     buttonCount++;
 294                 }
 295                 else
 296                     FreeMem(buttonHook, sizeof(struct Hook));
 297             }
 298
 299             if ((_csd->acpiSleepBHandle != NULL) && (!_csd->sleepButtonObj))
 300             {
 301                 instanceTags[0].ti_Data = (IPTR)_csd->acpiSleepBType;
 302                 instanceTags[1].ti_Data = (IPTR)_csd->acpiSleepBHandle;
 303
 304                 buttonHook = AllocMem(sizeof(struct Hook), MEMF_CLEAR);
 305                 buttonHook->h_Entry = (HOOKFUNC)ACPIButton_SleepEventHandle;
 306                 buttonHook->h_Data = 0;
 307                 instanceTags[2].ti_Data = (IPTR)buttonHook;
 308
 309                 if (HW_AddDriver(root, _csd->oopclass, instanceTags))
 310                 {
 311                     D(bug("[HWACPIButton] %s: Sleep-Button initialised\n", __func__));
 312                     buttonCount++;
 313                 }
 314                 else
 315                     FreeMem(buttonHook, sizeof(struct Hook));
 316             }
 317
 318             if ((_csd->acpibLidBHandle != NULL) && (!_csd->lidButtonObj))
 319             {
 320                 instanceTags[0].ti_Data = vHW_ACPIButton_Lid;
 321                 instanceTags[1].ti_Data = (IPTR)_csd->acpibLidBHandle;
 322
 323                 buttonHook = AllocMem(sizeof(struct Hook), MEMF_CLEAR);
 324                 buttonHook->h_Entry = (HOOKFUNC)ACPIButton_LidEventHandle;
 325                 buttonHook->h_Data = 0;
 326                 instanceTags[2].ti_Data = (IPTR)buttonHook;
 327
 328                 if (HW_AddDriver(root, _csd->oopclass, instanceTags))
 329                 {
 330                     D(bug("[HWACPIButton] %s: Lid-Button initialised\n", __func__));
 331                     buttonCount++;
 332                 }
 333                 else
 334                     FreeMem(buttonHook, sizeof(struct Hook));
 335             }
 336         }
 337     }
 338
 339     if (buttonCount > 0)
 340         retVal = TRUE;
 341     else
 342     {
 343         CloseLibrary(_csd->cs_UtilityBase);
 344         CloseLibrary(_csd->cs_ACPICABase);
 345     }
 346
 347     D(bug("[HWACPIButton] %s: Finished\n", __func__));
 348
 349     return retVal;
 350 }
 351
 352 static int ACPIButton_Expunge(LIBBASETYPEPTR LIBBASE)
 353 {
 354     D(struct acpibuttonclass_staticdata *_csd = &LIBBASE->hsi_csd;)
 355
 356     D(
 357         bug("[HWACPIButton] %s()\n", __func__);
 358         bug("[HWACPIButton] %s: csd @ %p\n", __func__, _csd);
 359     )
 360
 361     return TRUE;
 362 }
 363
 364 ADD2INITLIB(ACPIButton_Init, -2)
 365 ADD2EXPUNGELIB(ACPIButton_Expunge, -2)