drivers/acpi/acpi

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
acpi_tad_set_real_time
acpi_tad_get_real_time
acpi_tad_rt_next_field
time_store
time_show
acpi_tad_wake_set
acpi_tad_wake_write
acpi_tad_wake_read
acpi_tad_alarm_write
acpi_tad_alarm_read
acpi_tad_policy_write
acpi_tad_policy_read
acpi_tad_clear_status
acpi_tad_status_write
acpi_tad_status_read
caps_show
ac_alarm_store
ac_alarm_show
ac_policy_store
ac_policy_show
ac_status_store
ac_status_show
dc_alarm_store
dc_alarm_show
dc_policy_store
dc_policy_show
dc_status_store
dc_status_show
acpi_tad_disable_timer
acpi_tad_remove
acpi_tad_probe
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ACPI Time and Alarm (TAD) Device Driver
   4  *
   5  * Copyright (C) 2018 Intel Corporation
   6  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   7  *
   8  * This driver is based on Section 9.18 of the ACPI 6.2 specification revision.
   9  *
  10  * It only supports the system wakeup capabilities of the TAD.
  11  *
  12  * Provided are sysfs attributes, available under the TAD platform device,
  13  * allowing user space to manage the AC and DC wakeup timers of the TAD:
  14  * set and read their values, set and check their expire timer wake policies,
  15  * check and clear their status and check the capabilities of the TAD reported
  16  * by AML.  The DC timer attributes are only present if the TAD supports a
  17  * separate DC alarm timer.
  18  *
  19  * The wakeup events handling and power management of the TAD is expected to
  20  * be taken care of by the ACPI PM domain attached to its platform device.
  21  */
  22 
  23 #include <linux/acpi.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/pm_runtime.h>
  28 #include <linux/suspend.h>
  29 
  30 MODULE_LICENSE("GPL v2");
  31 MODULE_AUTHOR("Rafael J. Wysocki");
  32 
  33 /* ACPI TAD capability flags (ACPI 6.2, Section 9.18.2) */
  34 #define ACPI_TAD_AC_WAKE        BIT(0)
  35 #define ACPI_TAD_DC_WAKE        BIT(1)
  36 #define ACPI_TAD_RT             BIT(2)
  37 #define ACPI_TAD_RT_IN_MS       BIT(3)
  38 #define ACPI_TAD_S4_S5__GWS     BIT(4)
  39 #define ACPI_TAD_AC_S4_WAKE     BIT(5)
  40 #define ACPI_TAD_AC_S5_WAKE     BIT(6)
  41 #define ACPI_TAD_DC_S4_WAKE     BIT(7)
  42 #define ACPI_TAD_DC_S5_WAKE     BIT(8)
  43 
  44 /* ACPI TAD alarm timer selection */
  45 #define ACPI_TAD_AC_TIMER       (u32)0
  46 #define ACPI_TAD_DC_TIMER       (u32)1
  47 
  48 /* Special value for disabled timer or expired timer wake policy. */
  49 #define ACPI_TAD_WAKE_DISABLED  (~(u32)0)
  50 
  51 struct acpi_tad_driver_data {
  52         u32 capabilities;
  53 };
  54 
  55 struct acpi_tad_rt {
  56         u16 year;  /* 1900 - 9999 */
  57         u8 month;  /* 1 - 12 */
  58         u8 day;    /* 1 - 31 */
  59         u8 hour;   /* 0 - 23 */
  60         u8 minute; /* 0 - 59 */
  61         u8 second; /* 0 - 59 */
  62         u8 valid;  /* 0 (failed) or 1 (success) for reads, 0 for writes */
  63         u16 msec;  /* 1 - 1000 */
  64         s16 tz;    /* -1440 to 1440 or 2047 (unspecified) */
  65         u8 daylight;
  66         u8 padding[3]; /* must be 0 */
  67 } __packed;
  68 
  69 static int acpi_tad_set_real_time(struct device *dev, struct acpi_tad_rt *rt)
  70 {
  71         acpi_handle handle = ACPI_HANDLE(dev);
  72         union acpi_object args[] = {
  73                 { .type = ACPI_TYPE_BUFFER, },
  74         };
  75         struct acpi_object_list arg_list = {
  76                 .pointer = args,
  77                 .count = ARRAY_SIZE(args),
  78         };
  79         unsigned long long retval;
  80         acpi_status status;
  81 
  82         if (rt->year < 1900 || rt->year > 9999 ||
  83             rt->month < 1 || rt->month > 12 ||
  84             rt->hour > 23 || rt->minute > 59 || rt->second > 59 ||
  85             rt->tz < -1440 || (rt->tz > 1440 && rt->tz != 2047) ||
  86             rt->daylight > 3)
  87                 return -ERANGE;
  88 
  89         args[0].buffer.pointer = (u8 *)rt;
  90         args[0].buffer.length = sizeof(*rt);
  91 
  92         pm_runtime_get_sync(dev);
  93 
  94         status = acpi_evaluate_integer(handle, "_SRT", &arg_list, &retval);
  95 
  96         pm_runtime_put_sync(dev);
  97 
  98         if (ACPI_FAILURE(status) || retval)
  99                 return -EIO;
 100 
 101         return 0;
 102 }
 103 
 104 static int acpi_tad_get_real_time(struct device *dev, struct acpi_tad_rt *rt)
 105 {
 106         acpi_handle handle = ACPI_HANDLE(dev);
 107         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER };
 108         union acpi_object *out_obj;
 109         struct acpi_tad_rt *data;
 110         acpi_status status;
 111         int ret = -EIO;
 112 
 113         pm_runtime_get_sync(dev);
 114 
 115         status = acpi_evaluate_object(handle, "_GRT", NULL, &output);
 116 
 117         pm_runtime_put_sync(dev);
 118 
 119         if (ACPI_FAILURE(status))
 120                 goto out_free;
 121 
 122         out_obj = output.pointer;
 123         if (out_obj->type != ACPI_TYPE_BUFFER)
 124                 goto out_free;
 125 
 126         if (out_obj->buffer.length != sizeof(*rt))
 127                 goto out_free;
 128 
 129         data = (struct acpi_tad_rt *)(out_obj->buffer.pointer);
 130         if (!data->valid)
 131                 goto out_free;
 132 
 133         memcpy(rt, data, sizeof(*rt));
 134         ret = 0;
 135 
 136 out_free:
 137         ACPI_FREE(output.pointer);
 138         return ret;
 139 }
 140 
 141 static char *acpi_tad_rt_next_field(char *s, int *val)
 142 {
 143         char *p;
 144 
 145         p = strchr(s, ':');
 146         if (!p)
 147                 return NULL;
 148 
 149         *p = '\0';
 150         if (kstrtoint(s, 10, val))
 151                 return NULL;
 152 
 153         return p + 1;
 154 }
 155 
 156 static ssize_t time_store(struct device *dev, struct device_attribute *attr,
 157                           const char *buf, size_t count)
 158 {
 159         struct acpi_tad_rt rt;
 160         char *str, *s;
 161         int val, ret = -ENODATA;
 162 
 163         str = kmemdup_nul(buf, count, GFP_KERNEL);
 164         if (!str)
 165                 return -ENOMEM;
 166 
 167         s = acpi_tad_rt_next_field(str, &val);
 168         if (!s)
 169                 goto out_free;
 170 
 171         rt.year = val;
 172 
 173         s = acpi_tad_rt_next_field(s, &val);
 174         if (!s)
 175                 goto out_free;
 176 
 177         rt.month = val;
 178 
 179         s = acpi_tad_rt_next_field(s, &val);
 180         if (!s)
 181                 goto out_free;
 182 
 183         rt.day = val;
 184 
 185         s = acpi_tad_rt_next_field(s, &val);
 186         if (!s)
 187                 goto out_free;
 188 
 189         rt.hour = val;
 190 
 191         s = acpi_tad_rt_next_field(s, &val);
 192         if (!s)
 193                 goto out_free;
 194 
 195         rt.minute = val;
 196 
 197         s = acpi_tad_rt_next_field(s, &val);
 198         if (!s)
 199                 goto out_free;
 200 
 201         rt.second = val;
 202 
 203         s = acpi_tad_rt_next_field(s, &val);
 204         if (!s)
 205                 goto out_free;
 206 
 207         rt.tz = val;
 208 
 209         if (kstrtoint(s, 10, &val))
 210                 goto out_free;
 211 
 212         rt.daylight = val;
 213 
 214         rt.valid = 0;
 215         rt.msec = 0;
 216         memset(rt.padding, 0, 3);
 217 
 218         ret = acpi_tad_set_real_time(dev, &rt);
 219 
 220 out_free:
 221         kfree(str);
 222         return ret ? ret : count;
 223 }
 224 
 225 static ssize_t time_show(struct device *dev, struct device_attribute *attr,
 226                          char *buf)
 227 {
 228         struct acpi_tad_rt rt;
 229         int ret;
 230 
 231         ret = acpi_tad_get_real_time(dev, &rt);
 232         if (ret)
 233                 return ret;
 234 
 235         return sprintf(buf, "%u:%u:%u:%u:%u:%u:%d:%u\n",
 236                        rt.year, rt.month, rt.day, rt.hour, rt.minute, rt.second,
 237                        rt.tz, rt.daylight);
 238 }
 239 
 240 static DEVICE_ATTR(time, S_IRUSR | S_IWUSR, time_show, time_store);
 241 
 242 static struct attribute *acpi_tad_time_attrs[] = {
 243         &dev_attr_time.attr,
 244         NULL,
 245 };
 246 static const struct attribute_group acpi_tad_time_attr_group = {
 247         .attrs  = acpi_tad_time_attrs,
 248 };
 249 
 250 static int acpi_tad_wake_set(struct device *dev, char *method, u32 timer_id,
 251                              u32 value)
 252 {
 253         acpi_handle handle = ACPI_HANDLE(dev);
 254         union acpi_object args[] = {
 255                 { .type = ACPI_TYPE_INTEGER, },
 256                 { .type = ACPI_TYPE_INTEGER, },
 257         };
 258         struct acpi_object_list arg_list = {
 259                 .pointer = args,
 260                 .count = ARRAY_SIZE(args),
 261         };
 262         unsigned long long retval;
 263         acpi_status status;
 264 
 265         args[0].integer.value = timer_id;
 266         args[1].integer.value = value;
 267 
 268         pm_runtime_get_sync(dev);
 269 
 270         status = acpi_evaluate_integer(handle, method, &arg_list, &retval);
 271 
 272         pm_runtime_put_sync(dev);
 273 
 274         if (ACPI_FAILURE(status) || retval)
 275                 return -EIO;
 276 
 277         return 0;
 278 }
 279 
 280 static int acpi_tad_wake_write(struct device *dev, const char *buf, char *method,
 281                                u32 timer_id, const char *specval)
 282 {
 283         u32 value;
 284 
 285         if (sysfs_streq(buf, specval)) {
 286                 value = ACPI_TAD_WAKE_DISABLED;
 287         } else {
 288                 int ret = kstrtou32(buf, 0, &value);
 289 
 290                 if (ret)
 291                         return ret;
 292 
 293                 if (value == ACPI_TAD_WAKE_DISABLED)
 294                         return -EINVAL;
 295         }
 296 
 297         return acpi_tad_wake_set(dev, method, timer_id, value);
 298 }
 299 
 300 static ssize_t acpi_tad_wake_read(struct device *dev, char *buf, char *method,
 301                                   u32 timer_id, const char *specval)
 302 {
 303         acpi_handle handle = ACPI_HANDLE(dev);
 304         union acpi_object args[] = {
 305                 { .type = ACPI_TYPE_INTEGER, },
 306         };
 307         struct acpi_object_list arg_list = {
 308                 .pointer = args,
 309                 .count = ARRAY_SIZE(args),
 310         };
 311         unsigned long long retval;
 312         acpi_status status;
 313 
 314         args[0].integer.value = timer_id;
 315 
 316         pm_runtime_get_sync(dev);
 317 
 318         status = acpi_evaluate_integer(handle, method, &arg_list, &retval);
 319 
 320         pm_runtime_put_sync(dev);
 321 
 322         if (ACPI_FAILURE(status))
 323                 return -EIO;
 324 
 325         if ((u32)retval == ACPI_TAD_WAKE_DISABLED)
 326                 return sprintf(buf, "%s\n", specval);
 327 
 328         return sprintf(buf, "%u\n", (u32)retval);
 329 }
 330 
 331 static const char *alarm_specval = "disabled";
 332 
 333 static int acpi_tad_alarm_write(struct device *dev, const char *buf,
 334                                 u32 timer_id)
 335 {
 336         return acpi_tad_wake_write(dev, buf, "_STV", timer_id, alarm_specval);
 337 }
 338 
 339 static ssize_t acpi_tad_alarm_read(struct device *dev, char *buf, u32 timer_id)
 340 {
 341         return acpi_tad_wake_read(dev, buf, "_TIV", timer_id, alarm_specval);
 342 }
 343 
 344 static const char *policy_specval = "never";
 345 
 346 static int acpi_tad_policy_write(struct device *dev, const char *buf,
 347                                  u32 timer_id)
 348 {
 349         return acpi_tad_wake_write(dev, buf, "_STP", timer_id, policy_specval);
 350 }
 351 
 352 static ssize_t acpi_tad_policy_read(struct device *dev, char *buf, u32 timer_id)
 353 {
 354         return acpi_tad_wake_read(dev, buf, "_TIP", timer_id, policy_specval);
 355 }
 356 
 357 static int acpi_tad_clear_status(struct device *dev, u32 timer_id)
 358 {
 359         acpi_handle handle = ACPI_HANDLE(dev);
 360         union acpi_object args[] = {
 361                 { .type = ACPI_TYPE_INTEGER, },
 362         };
 363         struct acpi_object_list arg_list = {
 364                 .pointer = args,
 365                 .count = ARRAY_SIZE(args),
 366         };
 367         unsigned long long retval;
 368         acpi_status status;
 369 
 370         args[0].integer.value = timer_id;
 371 
 372         pm_runtime_get_sync(dev);
 373 
 374         status = acpi_evaluate_integer(handle, "_CWS", &arg_list, &retval);
 375 
 376         pm_runtime_put_sync(dev);
 377 
 378         if (ACPI_FAILURE(status) || retval)
 379                 return -EIO;
 380 
 381         return 0;
 382 }
 383 
 384 static int acpi_tad_status_write(struct device *dev, const char *buf, u32 timer_id)
 385 {
 386         int ret, value;
 387 
 388         ret = kstrtoint(buf, 0, &value);
 389         if (ret)
 390                 return ret;
 391 
 392         if (value)
 393                 return -EINVAL;
 394 
 395         return acpi_tad_clear_status(dev, timer_id);
 396 }
 397 
 398 static ssize_t acpi_tad_status_read(struct device *dev, char *buf, u32 timer_id)
 399 {
 400         acpi_handle handle = ACPI_HANDLE(dev);
 401         union acpi_object args[] = {
 402                 { .type = ACPI_TYPE_INTEGER, },
 403         };
 404         struct acpi_object_list arg_list = {
 405                 .pointer = args,
 406                 .count = ARRAY_SIZE(args),
 407         };
 408         unsigned long long retval;
 409         acpi_status status;
 410 
 411         args[0].integer.value = timer_id;
 412 
 413         pm_runtime_get_sync(dev);
 414 
 415         status = acpi_evaluate_integer(handle, "_GWS", &arg_list, &retval);
 416 
 417         pm_runtime_put_sync(dev);
 418 
 419         if (ACPI_FAILURE(status))
 420                 return -EIO;
 421 
 422         return sprintf(buf, "0x%02X\n", (u32)retval);
 423 }
 424 
 425 static ssize_t caps_show(struct device *dev, struct device_attribute *attr,
 426                          char *buf)
 427 {
 428         struct acpi_tad_driver_data *dd = dev_get_drvdata(dev);
 429 
 430         return sprintf(buf, "0x%02X\n", dd->capabilities);
 431 }
 432 
 433 static DEVICE_ATTR_RO(caps);
 434 
 435 static ssize_t ac_alarm_store(struct device *dev, struct device_attribute *attr,
 436                               const char *buf, size_t count)
 437 {
 438         int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_AC_TIMER);
 439 
 440         return ret ? ret : count;
 441 }
 442 
 443 static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr,
 444                              char *buf)
 445 {
 446         return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER);
 447 }
 448 
 449 static DEVICE_ATTR(ac_alarm, S_IRUSR | S_IWUSR, ac_alarm_show, ac_alarm_store);
 450 
 451 static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr,
 452                                const char *buf, size_t count)
 453 {
 454         int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_AC_TIMER);
 455 
 456         return ret ? ret : count;
 457 }
 458 
 459 static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr,
 460                               char *buf)
 461 {
 462         return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER);
 463 }
 464 
 465 static DEVICE_ATTR(ac_policy, S_IRUSR | S_IWUSR, ac_policy_show, ac_policy_store);
 466 
 467 static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr,
 468                                const char *buf, size_t count)
 469 {
 470         int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_AC_TIMER);
 471 
 472         return ret ? ret : count;
 473 }
 474 
 475 static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr,
 476                               char *buf)
 477 {
 478         return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER);
 479 }
 480 
 481 static DEVICE_ATTR(ac_status, S_IRUSR | S_IWUSR, ac_status_show, ac_status_store);
 482 
 483 static struct attribute *acpi_tad_attrs[] = {
 484         &dev_attr_caps.attr,
 485         &dev_attr_ac_alarm.attr,
 486         &dev_attr_ac_policy.attr,
 487         &dev_attr_ac_status.attr,
 488         NULL,
 489 };
 490 static const struct attribute_group acpi_tad_attr_group = {
 491         .attrs  = acpi_tad_attrs,
 492 };
 493 
 494 static ssize_t dc_alarm_store(struct device *dev, struct device_attribute *attr,
 495                               const char *buf, size_t count)
 496 {
 497         int ret = acpi_tad_alarm_write(dev, buf, ACPI_TAD_DC_TIMER);
 498 
 499         return ret ? ret : count;
 500 }
 501 
 502 static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr,
 503                              char *buf)
 504 {
 505         return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER);
 506 }
 507 
 508 static DEVICE_ATTR(dc_alarm, S_IRUSR | S_IWUSR, dc_alarm_show, dc_alarm_store);
 509 
 510 static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr,
 511                                const char *buf, size_t count)
 512 {
 513         int ret = acpi_tad_policy_write(dev, buf, ACPI_TAD_DC_TIMER);
 514 
 515         return ret ? ret : count;
 516 }
 517 
 518 static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr,
 519                               char *buf)
 520 {
 521         return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER);
 522 }
 523 
 524 static DEVICE_ATTR(dc_policy, S_IRUSR | S_IWUSR, dc_policy_show, dc_policy_store);
 525 
 526 static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr,
 527                                const char *buf, size_t count)
 528 {
 529         int ret = acpi_tad_status_write(dev, buf, ACPI_TAD_DC_TIMER);
 530 
 531         return ret ? ret : count;
 532 }
 533 
 534 static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr,
 535                               char *buf)
 536 {
 537         return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER);
 538 }
 539 
 540 static DEVICE_ATTR(dc_status, S_IRUSR | S_IWUSR, dc_status_show, dc_status_store);
 541 
 542 static struct attribute *acpi_tad_dc_attrs[] = {
 543         &dev_attr_dc_alarm.attr,
 544         &dev_attr_dc_policy.attr,
 545         &dev_attr_dc_status.attr,
 546         NULL,
 547 };
 548 static const struct attribute_group acpi_tad_dc_attr_group = {
 549         .attrs  = acpi_tad_dc_attrs,
 550 };
 551 
 552 static int acpi_tad_disable_timer(struct device *dev, u32 timer_id)
 553 {
 554         return acpi_tad_wake_set(dev, "_STV", timer_id, ACPI_TAD_WAKE_DISABLED);
 555 }
 556 
 557 static int acpi_tad_remove(struct platform_device *pdev)
 558 {
 559         struct device *dev = &pdev->dev;
 560         struct acpi_tad_driver_data *dd = dev_get_drvdata(dev);
 561 
 562         device_init_wakeup(dev, false);
 563 
 564         pm_runtime_get_sync(dev);
 565 
 566         if (dd->capabilities & ACPI_TAD_DC_WAKE)
 567                 sysfs_remove_group(&dev->kobj, &acpi_tad_dc_attr_group);
 568 
 569         sysfs_remove_group(&dev->kobj, &acpi_tad_attr_group);
 570 
 571         acpi_tad_disable_timer(dev, ACPI_TAD_AC_TIMER);
 572         acpi_tad_clear_status(dev, ACPI_TAD_AC_TIMER);
 573         if (dd->capabilities & ACPI_TAD_DC_WAKE) {
 574                 acpi_tad_disable_timer(dev, ACPI_TAD_DC_TIMER);
 575                 acpi_tad_clear_status(dev, ACPI_TAD_DC_TIMER);
 576         }
 577 
 578         pm_runtime_put_sync(dev);
 579         pm_runtime_disable(dev);
 580         return 0;
 581 }
 582 
 583 static int acpi_tad_probe(struct platform_device *pdev)
 584 {
 585         struct device *dev = &pdev->dev;
 586         acpi_handle handle = ACPI_HANDLE(dev);
 587         struct acpi_tad_driver_data *dd;
 588         acpi_status status;
 589         unsigned long long caps;
 590         int ret;
 591 
 592         /*
 593          * Initialization failure messages are mostly about firmware issues, so
 594          * print them at the "info" level.
 595          */
 596         status = acpi_evaluate_integer(handle, "_GCP", NULL, &caps);
 597         if (ACPI_FAILURE(status)) {
 598                 dev_info(dev, "Unable to get capabilities\n");
 599                 return -ENODEV;
 600         }
 601 
 602         if (!(caps & ACPI_TAD_AC_WAKE)) {
 603                 dev_info(dev, "Unsupported capabilities\n");
 604                 return -ENODEV;
 605         }
 606 
 607         if (!acpi_has_method(handle, "_PRW")) {
 608                 dev_info(dev, "Missing _PRW\n");
 609                 return -ENODEV;
 610         }
 611 
 612         dd = devm_kzalloc(dev, sizeof(*dd), GFP_KERNEL);
 613         if (!dd)
 614                 return -ENOMEM;
 615 
 616         dd->capabilities = caps;
 617         dev_set_drvdata(dev, dd);
 618 
 619         /*
 620          * Assume that the ACPI PM domain has been attached to the device and
 621          * simply enable system wakeup and runtime PM and put the device into
 622          * runtime suspend.  Everything else should be taken care of by the ACPI
 623          * PM domain callbacks.
 624          */
 625         device_init_wakeup(dev, true);
 626         dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND |
 627                                      DPM_FLAG_LEAVE_SUSPENDED);
 628         /*
 629          * The platform bus type layer tells the ACPI PM domain powers up the
 630          * device, so set the runtime PM status of it to "active".
 631          */
 632         pm_runtime_set_active(dev);
 633         pm_runtime_enable(dev);
 634         pm_runtime_suspend(dev);
 635 
 636         ret = sysfs_create_group(&dev->kobj, &acpi_tad_attr_group);
 637         if (ret)
 638                 goto fail;
 639 
 640         if (caps & ACPI_TAD_DC_WAKE) {
 641                 ret = sysfs_create_group(&dev->kobj, &acpi_tad_dc_attr_group);
 642                 if (ret)
 643                         goto fail;
 644         }
 645 
 646         if (caps & ACPI_TAD_RT) {
 647                 ret = sysfs_create_group(&dev->kobj, &acpi_tad_time_attr_group);
 648                 if (ret)
 649                         goto fail;
 650         }
 651 
 652         return 0;
 653 
 654 fail:
 655         acpi_tad_remove(pdev);
 656         return ret;
 657 }
 658 
 659 static const struct acpi_device_id acpi_tad_ids[] = {
 660         {"ACPI000E", 0},
 661         {}
 662 };
 663 
 664 static struct platform_driver acpi_tad_driver = {
 665         .driver = {
 666                 .name = "acpi-tad",
 667                 .acpi_match_table = acpi_tad_ids,
 668         },
 669         .probe = acpi_tad_probe,
 670         .remove = acpi_tad_remove,
 671 };
 672 MODULE_DEVICE_TABLE(acpi, acpi_tad_ids);
 673 
 674 module_platform_driver(acpi_tad_driver);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/acpi/acpi_tad.c

DEFINITIONS
