src/add-ons/kernel/drivers/power/acpi_lid/acpi_lid.cpp

   1 /*
   2  * Copyright 2008-2013, Jérôme Duval, korli@users.berlios.de.
   3  *
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7
   8 #include <ACPI.h>
   9
  10 #include <fs/select_sync_pool.h>
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16
  17 #define ACPI_LID_MODULE_NAME "drivers/power/acpi_lid/driver_v1"
  18
  19 #define ACPI_LID_DEVICE_MODULE_NAME "drivers/power/acpi_lid/device_v1"
  20
  21 #define ACPI_NOTIFY_STATUS_CHANGED              0x80
  22
  23 /* Base Namespace devices are published to */
  24 #define ACPI_LID_BASENAME "power/acpi_lid/%d"
  25
  26 // name of pnp generator of path ids
  27 #define ACPI_LID_PATHID_GENERATOR "acpi_lid/path_id"
  28
  29 //#define TRACE_LID
  30 #ifdef TRACE_LID
  31 #       define TRACE(x...) dprintf("acpi_lid: "x)
  32 #else
  33 #       define TRACE(x...)
  34 #endif
  35 #define ERROR(x...)     dprintf("acpi_lid: "x)
  36
  37
  38 static device_manager_info *sDeviceManager;
  39
  40
  41 typedef struct acpi_ns_device_info {
  42         device_node *node;
  43         acpi_device_module_info *acpi;
  44         acpi_device acpi_cookie;
  45         uint8 last_status;
  46         bool updated;
  47         select_sync_pool* select_pool;
  48 } acpi_lid_device_info;
  49
  50
  51 static void
  52 acpi_lid_read_status(acpi_lid_device_info *device)
  53 {
  54         acpi_data buf;
  55         buf.pointer = NULL;
  56         buf.length = ACPI_ALLOCATE_BUFFER;
  57         if (device->acpi->evaluate_method(device->acpi_cookie, "_LID", NULL,
  58                         &buf) != B_OK
  59                 || buf.pointer == NULL
  60                 || ((acpi_object_type*)buf.pointer)->object_type != ACPI_TYPE_INTEGER) {
  61                 ERROR("couldn't get status\n");
  62         } else {
  63                 acpi_object_type* object = (acpi_object_type*)buf.pointer;
  64                 device->last_status = object->integer.integer;
  65                 device->updated = true;
  66                 free(buf.pointer);
  67                 TRACE("status %d\n", device->last_status);
  68         }
  69 }
  70
  71
  72 static void
  73 acpi_lid_notify_handler(acpi_handle _device, uint32 value, void *context)
  74 {
  75         acpi_lid_device_info *device = (acpi_lid_device_info *)context;
  76         if (value == ACPI_NOTIFY_STATUS_CHANGED) {
  77                 TRACE("status changed\n");
  78                 acpi_lid_read_status(device);
  79                 if (device->select_pool != NULL)
  80                         notify_select_event_pool(device->select_pool, B_SELECT_READ);
  81         } else {
  82                 ERROR("unknown notification\n");
  83         }
  84
  85 }
  86
  87
  88 //      #pragma mark - device module API
  89
  90
  91 static status_t
  92 acpi_lid_init_device(void *driverCookie, void **cookie)
  93 {
  94         *cookie = driverCookie;
  95         return B_OK;
  96 }
  97
  98
  99 static void
 100 acpi_lid_uninit_device(void *_cookie)
 101 {
 102
 103 }
 104
 105
 106 static status_t
 107 acpi_lid_open(void *_cookie, const char *path, int flags, void** cookie)
 108 {
 109         acpi_lid_device_info *device = (acpi_lid_device_info *)_cookie;
 110         *cookie = device;
 111         return B_OK;
 112 }
 113
 114
 115 static status_t
 116 acpi_lid_read(void* _cookie, off_t position, void *buf, size_t* num_bytes)
 117 {
 118         acpi_lid_device_info* device = (acpi_lid_device_info*)_cookie;
 119         if (*num_bytes < 1)
 120                 return B_IO_ERROR;
 121
 122         *((uint8 *)(buf)) = device->last_status;
 123         *num_bytes = 1;
 124         device->updated = false;
 125         return B_OK;
 126 }
 127
 128
 129 static status_t
 130 acpi_lid_write(void* cookie, off_t position, const void* buffer, size_t* num_bytes)
 131 {
 132         return B_ERROR;
 133 }
 134
 135
 136 static status_t
 137 acpi_lid_control(void* _cookie, uint32 op, void* arg, size_t len)
 138 {
 139         return B_ERROR;
 140 }
 141
 142
 143 static status_t
 144 acpi_lid_select(void *_cookie, uint8 event, selectsync *sync)
 145 {
 146         acpi_lid_device_info* device = (acpi_lid_device_info*)_cookie;
 147
 148         if (event != B_SELECT_READ)
 149                 return B_BAD_VALUE;
 150
 151         // add the event to the pool
 152         status_t error = add_select_sync_pool_entry(&device->select_pool, sync,
 153                 event);
 154         if (error != B_OK) {
 155                 ERROR("add_select_sync_pool_entry() failed: %#lx\n", error);
 156                 return error;
 157         }
 158
 159         if (device->updated)
 160                 notify_select_event(sync, event);
 161
 162         return B_OK;
 163 }
 164
 165
 166 static status_t
 167 acpi_lid_deselect(void *_cookie, uint8 event, selectsync *sync)
 168 {
 169         acpi_lid_device_info* device = (acpi_lid_device_info*)_cookie;
 170
 171         if (event != B_SELECT_READ)
 172                 return B_BAD_VALUE;
 173
 174         return remove_select_sync_pool_entry(&device->select_pool, sync, event);
 175 }
 176
 177
 178 static status_t
 179 acpi_lid_close (void* cookie)
 180 {
 181         return B_OK;
 182 }
 183
 184
 185 static status_t
 186 acpi_lid_free (void* cookie)
 187 {
 188         return B_OK;
 189 }
 190
 191
 192 //      #pragma mark - driver module API
 193
 194
 195 static float
 196 acpi_lid_support(device_node *parent)
 197 {
 198         const char *bus;
 199         uint32 device_type;
 200         const char *hid;
 201
 202         // make sure parent is really the ACPI bus manager
 203         if (sDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
 204                 return -1;
 205
 206         if (strcmp(bus, "acpi"))
 207                 return 0.0;
 208
 209         // check whether it's really a device
 210         if (sDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM,
 211                         &device_type, false) != B_OK
 212                 || device_type != ACPI_TYPE_DEVICE) {
 213                 return 0.0;
 214         }
 215
 216         // check whether it's a lid device
 217         if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &hid,
 218                 false) != B_OK || strcmp(hid, "PNP0C0D")) {
 219                 return 0.0;
 220         }
 221
 222         dprintf("acpi_lid_support lid device found\n");
 223
 224         return 0.6;
 225 }
 226
 227
 228 static status_t
 229 acpi_lid_register_device(device_node *node)
 230 {
 231         device_attr attrs[] = {
 232                 { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Lid" }},
 233                 { NULL }
 234         };
 235
 236         return sDeviceManager->register_node(node, ACPI_LID_MODULE_NAME, attrs,
 237                 NULL, NULL);
 238 }
 239
 240
 241 static status_t
 242 acpi_lid_init_driver(device_node *node, void **_driverCookie)
 243 {
 244         acpi_lid_device_info *device;
 245         device_node *parent;
 246         status_t status;
 247
 248         device = (acpi_lid_device_info *)calloc(1, sizeof(*device));
 249         if (device == NULL)
 250                 return B_NO_MEMORY;
 251
 252         device->node = node;
 253
 254         parent = sDeviceManager->get_parent_node(node);
 255         sDeviceManager->get_driver(parent, (driver_module_info **)&device->acpi,
 256                 (void **)&device->acpi_cookie);
 257         sDeviceManager->put_node(parent);
 258
 259         status = device->acpi->install_notify_handler(device->acpi_cookie, ACPI_DEVICE_NOTIFY,
 260                 acpi_lid_notify_handler, device);
 261         if (status != B_OK) {
 262                 ERROR("can't install notify handler\n");
 263         }
 264
 265         device->last_status = 0;
 266         device->updated = false;
 267         device->select_pool = NULL;
 268
 269         *_driverCookie = device;
 270         return B_OK;
 271 }
 272
 273
 274 static void
 275 acpi_lid_uninit_driver(void *driverCookie)
 276 {
 277         acpi_lid_device_info *device = (acpi_lid_device_info *)driverCookie;
 278
 279         device->acpi->remove_notify_handler(device->acpi_cookie, ACPI_DEVICE_NOTIFY,
 280                 acpi_lid_notify_handler);
 281
 282         free(device);
 283 }
 284
 285
 286 static status_t
 287 acpi_lid_register_child_devices(void *_cookie)
 288 {
 289         acpi_lid_device_info *device = (acpi_lid_device_info *)_cookie;
 290         int path_id;
 291         char name[128];
 292
 293         path_id = sDeviceManager->create_id(ACPI_LID_PATHID_GENERATOR);
 294         if (path_id < 0) {
 295                 ERROR("register_child_devices: couldn't create a path_id\n");
 296                 return B_ERROR;
 297         }
 298
 299         snprintf(name, sizeof(name), ACPI_LID_BASENAME, path_id);
 300
 301         return sDeviceManager->publish_device(device->node, name,
 302                 ACPI_LID_DEVICE_MODULE_NAME);
 303 }
 304
 305
 306 module_dependency module_dependencies[] = {
 307         { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
 308         {}
 309 };
 310
 311
 312 driver_module_info acpi_lid_driver_module = {
 313         {
 314                 ACPI_LID_MODULE_NAME,
 315                 0,
 316                 NULL
 317         },
 318
 319         acpi_lid_support,
 320         acpi_lid_register_device,
 321         acpi_lid_init_driver,
 322         acpi_lid_uninit_driver,
 323         acpi_lid_register_child_devices,
 324         NULL,   // rescan
 325         NULL,   // removed
 326 };
 327
 328
 329 struct device_module_info acpi_lid_device_module = {
 330         {
 331                 ACPI_LID_DEVICE_MODULE_NAME,
 332                 0,
 333                 NULL
 334         },
 335
 336         acpi_lid_init_device,
 337         acpi_lid_uninit_device,
 338         NULL,
 339
 340         acpi_lid_open,
 341         acpi_lid_close,
 342         acpi_lid_free,
 343         acpi_lid_read,
 344         acpi_lid_write,
 345         NULL,
 346         acpi_lid_control,
 347         acpi_lid_select,
 348         acpi_lid_deselect
 349 };
 350
 351 module_info *modules[] = {
 352         (module_info *)&acpi_lid_driver_module,
 353         (module_info *)&acpi_lid_device_module,
 354         NULL
 355 };