drivers/platform/surface/surface_acpi_notify.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for the Surface ACPI Notify (SAN) interface/shim.
   4  *
   5  * Translates communication from ACPI to Surface System Aggregator Module
   6  * (SSAM/SAM) requests and back, specifically SAM-over-SSH. Translates SSAM
   7  * events back to ACPI notifications. Allows handling of discrete GPU
   8  * notifications sent from ACPI via the SAN interface by providing them to any
   9  * registered external driver.
  10  *
  11  * Copyright (C) 2019-2020 Maximilian Luz <luzmaximilian@gmail.com>
  12  */
  13
  14 #include <asm/unaligned.h>
  15 #include <linux/acpi.h>
  16 #include <linux/delay.h>
  17 #include <linux/jiffies.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/notifier.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/rwsem.h>
  23
  24 #include <linux/surface_aggregator/controller.h>
  25 #include <linux/surface_acpi_notify.h>
  26
  27 struct san_data {
  28         struct device *dev;
  29         struct ssam_controller *ctrl;
  30
  31         struct acpi_connection_info info;
  32
  33         struct ssam_event_notifier nf_bat;
  34         struct ssam_event_notifier nf_tmp;
  35 };
  36
  37 #define to_san_data(ptr, member) \
  38         container_of(ptr, struct san_data, member)
  39
  40
  41 /* -- dGPU notifier interface. ---------------------------------------------- */
  42
  43 struct san_rqsg_if {
  44         struct rw_semaphore lock;
  45         struct device *dev;
  46         struct blocking_notifier_head nh;
  47 };
  48
  49 static struct san_rqsg_if san_rqsg_if = {
  50         .lock = __RWSEM_INITIALIZER(san_rqsg_if.lock),
  51         .dev = NULL,
  52         .nh = BLOCKING_NOTIFIER_INIT(san_rqsg_if.nh),
  53 };
  54
  55 static int san_set_rqsg_interface_device(struct device *dev)
  56 {
  57         int status = 0;
  58
  59         down_write(&san_rqsg_if.lock);
  60         if (!san_rqsg_if.dev && dev)
  61                 san_rqsg_if.dev = dev;
  62         else
  63                 status = -EBUSY;
  64         up_write(&san_rqsg_if.lock);
  65
  66         return status;
  67 }
  68
  69 /**
  70  * san_client_link() - Link client as consumer to SAN device.
  71  * @client: The client to link.
  72  *
  73  * Sets up a device link between the provided client device as consumer and
  74  * the SAN device as provider. This function can be used to ensure that the
  75  * SAN interface has been set up and will be set up for as long as the driver
  76  * of the client device is bound. This guarantees that, during that time, all
  77  * dGPU events will be received by any registered notifier.
  78  *
  79  * The link will be automatically removed once the client device's driver is
  80  * unbound.
  81  *
  82  * Return: Returns zero on success, %-ENXIO if the SAN interface has not been
  83  * set up yet, and %-ENOMEM if device link creation failed.
  84  */
  85 int san_client_link(struct device *client)
  86 {
  87         const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER;
  88         struct device_link *link;
  89
  90         down_read(&san_rqsg_if.lock);
  91
  92         if (!san_rqsg_if.dev) {
  93                 up_read(&san_rqsg_if.lock);
  94                 return -ENXIO;
  95         }
  96
  97         link = device_link_add(client, san_rqsg_if.dev, flags);
  98         if (!link) {
  99                 up_read(&san_rqsg_if.lock);
 100                 return -ENOMEM;
 101         }
 102
 103         if (READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) {
 104                 up_read(&san_rqsg_if.lock);
 105                 return -ENXIO;
 106         }
 107
 108         up_read(&san_rqsg_if.lock);
 109         return 0;
 110 }
 111 EXPORT_SYMBOL_GPL(san_client_link);
 112
 113 /**
 114  * san_dgpu_notifier_register() - Register a SAN dGPU notifier.
 115  * @nb: The notifier-block to register.
 116  *
 117  * Registers a SAN dGPU notifier, receiving any new SAN dGPU events sent from
 118  * ACPI. The registered notifier will be called with &struct san_dgpu_event
 119  * as notifier data and the command ID of that event as notifier action.
 120  */
 121 int san_dgpu_notifier_register(struct notifier_block *nb)
 122 {
 123         return blocking_notifier_chain_register(&san_rqsg_if.nh, nb);
 124 }
 125 EXPORT_SYMBOL_GPL(san_dgpu_notifier_register);
 126
 127 /**
 128  * san_dgpu_notifier_unregister() - Unregister a SAN dGPU notifier.
 129  * @nb: The notifier-block to unregister.
 130  */
 131 int san_dgpu_notifier_unregister(struct notifier_block *nb)
 132 {
 133         return blocking_notifier_chain_unregister(&san_rqsg_if.nh, nb);
 134 }
 135 EXPORT_SYMBOL_GPL(san_dgpu_notifier_unregister);
 136
 137 static int san_dgpu_notifier_call(struct san_dgpu_event *evt)
 138 {
 139         int ret;
 140
 141         ret = blocking_notifier_call_chain(&san_rqsg_if.nh, evt->command, evt);
 142         return notifier_to_errno(ret);
 143 }
 144
 145
 146 /* -- ACPI _DSM event relay. ------------------------------------------------ */
 147
 148 #define SAN_DSM_REVISION        0
 149
 150 /* 93b666c5-70c6-469f-a215-3d487c91ab3c */
 151 static const guid_t SAN_DSM_UUID =
 152         GUID_INIT(0x93b666c5, 0x70c6, 0x469f, 0xa2, 0x15, 0x3d,
 153                   0x48, 0x7c, 0x91, 0xab, 0x3c);
 154
 155 enum san_dsm_event_fn {
 156         SAN_DSM_EVENT_FN_BAT1_STAT = 0x03,
 157         SAN_DSM_EVENT_FN_BAT1_INFO = 0x04,
 158         SAN_DSM_EVENT_FN_ADP1_STAT = 0x05,
 159         SAN_DSM_EVENT_FN_ADP1_INFO = 0x06,
 160         SAN_DSM_EVENT_FN_BAT2_STAT = 0x07,
 161         SAN_DSM_EVENT_FN_BAT2_INFO = 0x08,
 162         SAN_DSM_EVENT_FN_THERMAL   = 0x09,
 163         SAN_DSM_EVENT_FN_DPTF      = 0x0a,
 164 };
 165
 166 enum sam_event_cid_bat {
 167         SAM_EVENT_CID_BAT_BIX  = 0x15,
 168         SAM_EVENT_CID_BAT_BST  = 0x16,
 169         SAM_EVENT_CID_BAT_ADP  = 0x17,
 170         SAM_EVENT_CID_BAT_PROT = 0x18,
 171         SAM_EVENT_CID_BAT_DPTF = 0x4f,
 172 };
 173
 174 enum sam_event_cid_tmp {
 175         SAM_EVENT_CID_TMP_TRIP = 0x0b,
 176 };
 177
 178 struct san_event_work {
 179         struct delayed_work work;
 180         struct device *dev;
 181         struct ssam_event event;        /* must be last */
 182 };
 183
 184 static int san_acpi_notify_event(struct device *dev, u64 func,
 185                                  union acpi_object *param)
 186 {
 187         acpi_handle san = ACPI_HANDLE(dev);
 188         union acpi_object *obj;
 189         int status = 0;
 190
 191         if (!acpi_check_dsm(san, &SAN_DSM_UUID, SAN_DSM_REVISION, BIT_ULL(func)))
 192                 return 0;
 193
 194         dev_dbg(dev, "notify event %#04llx\n", func);
 195
 196         obj = acpi_evaluate_dsm_typed(san, &SAN_DSM_UUID, SAN_DSM_REVISION,
 197                                       func, param, ACPI_TYPE_BUFFER);
 198         if (!obj)
 199                 return -EFAULT;
 200
 201         if (obj->buffer.length != 1 || obj->buffer.pointer[0] != 0) {
 202                 dev_err(dev, "got unexpected result from _DSM\n");
 203                 status = -EPROTO;
 204         }
 205
 206         ACPI_FREE(obj);
 207         return status;
 208 }
 209
 210 static int san_evt_bat_adp(struct device *dev, const struct ssam_event *event)
 211 {
 212         int status;
 213
 214         status = san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_ADP1_STAT, NULL);
 215         if (status)
 216                 return status;
 217
 218         /*
 219          * Ensure that the battery states get updated correctly. When the
 220          * battery is fully charged and an adapter is plugged in, it sometimes
 221          * is not updated correctly, instead showing it as charging.
 222          * Explicitly trigger battery updates to fix this.
 223          */
 224
 225         status = san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_BAT1_STAT, NULL);
 226         if (status)
 227                 return status;
 228
 229         return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_BAT2_STAT, NULL);
 230 }
 231
 232 static int san_evt_bat_bix(struct device *dev, const struct ssam_event *event)
 233 {
 234         enum san_dsm_event_fn fn;
 235
 236         if (event->instance_id == 0x02)
 237                 fn = SAN_DSM_EVENT_FN_BAT2_INFO;
 238         else
 239                 fn = SAN_DSM_EVENT_FN_BAT1_INFO;
 240
 241         return san_acpi_notify_event(dev, fn, NULL);
 242 }
 243
 244 static int san_evt_bat_bst(struct device *dev, const struct ssam_event *event)
 245 {
 246         enum san_dsm_event_fn fn;
 247
 248         if (event->instance_id == 0x02)
 249                 fn = SAN_DSM_EVENT_FN_BAT2_STAT;
 250         else
 251                 fn = SAN_DSM_EVENT_FN_BAT1_STAT;
 252
 253         return san_acpi_notify_event(dev, fn, NULL);
 254 }
 255
 256 static int san_evt_bat_dptf(struct device *dev, const struct ssam_event *event)
 257 {
 258         union acpi_object payload;
 259
 260         /*
 261          * The Surface ACPI expects a buffer and not a package. It specifically
 262          * checks for ObjectType (Arg3) == 0x03. This will cause a warning in
 263          * acpica/nsarguments.c, but that warning can be safely ignored.
 264          */
 265         payload.type = ACPI_TYPE_BUFFER;
 266         payload.buffer.length = event->length;
 267         payload.buffer.pointer = (u8 *)&event->data[0];
 268
 269         return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_DPTF, &payload);
 270 }
 271
 272 static unsigned long san_evt_bat_delay(u8 cid)
 273 {
 274         switch (cid) {
 275         case SAM_EVENT_CID_BAT_ADP:
 276                 /*
 277                  * Wait for battery state to update before signaling adapter
 278                  * change.
 279                  */
 280                 return msecs_to_jiffies(5000);
 281
 282         case SAM_EVENT_CID_BAT_BST:
 283                 /* Ensure we do not miss anything important due to caching. */
 284                 return msecs_to_jiffies(2000);
 285
 286         default:
 287                 return 0;
 288         }
 289 }
 290
 291 static bool san_evt_bat(const struct ssam_event *event, struct device *dev)
 292 {
 293         int status;
 294
 295         switch (event->command_id) {
 296         case SAM_EVENT_CID_BAT_BIX:
 297                 status = san_evt_bat_bix(dev, event);
 298                 break;
 299
 300         case SAM_EVENT_CID_BAT_BST:
 301                 status = san_evt_bat_bst(dev, event);
 302                 break;
 303
 304         case SAM_EVENT_CID_BAT_ADP:
 305                 status = san_evt_bat_adp(dev, event);
 306                 break;
 307
 308         case SAM_EVENT_CID_BAT_PROT:
 309                 /*
 310                  * TODO: Implement support for battery protection status change
 311                  *       event.
 312                  */
 313                 return true;
 314
 315         case SAM_EVENT_CID_BAT_DPTF:
 316                 status = san_evt_bat_dptf(dev, event);
 317                 break;
 318
 319         default:
 320                 return false;
 321         }
 322
 323         if (status) {
 324                 dev_err(dev, "error handling power event (cid = %#04x)\n",
 325                         event->command_id);
 326         }
 327
 328         return true;
 329 }
 330
 331 static void san_evt_bat_workfn(struct work_struct *work)
 332 {
 333         struct san_event_work *ev;
 334
 335         ev = container_of(work, struct san_event_work, work.work);
 336         san_evt_bat(&ev->event, ev->dev);
 337         kfree(ev);
 338 }
 339
 340 static u32 san_evt_bat_nf(struct ssam_event_notifier *nf,
 341                           const struct ssam_event *event)
 342 {
 343         struct san_data *d = to_san_data(nf, nf_bat);
 344         struct san_event_work *work;
 345         unsigned long delay = san_evt_bat_delay(event->command_id);
 346
 347         if (delay == 0)
 348                 return san_evt_bat(event, d->dev) ? SSAM_NOTIF_HANDLED : 0;
 349
 350         work = kzalloc(sizeof(*work) + event->length, GFP_KERNEL);
 351         if (!work)
 352                 return ssam_notifier_from_errno(-ENOMEM);
 353
 354         INIT_DELAYED_WORK(&work->work, san_evt_bat_workfn);
 355         work->dev = d->dev;
 356
 357         memcpy(&work->event, event, sizeof(struct ssam_event) + event->length);
 358
 359         schedule_delayed_work(&work->work, delay);
 360         return SSAM_NOTIF_HANDLED;
 361 }
 362
 363 static int san_evt_tmp_trip(struct device *dev, const struct ssam_event *event)
 364 {
 365         union acpi_object param;
 366
 367         /*
 368          * The Surface ACPI expects an integer and not a package. This will
 369          * cause a warning in acpica/nsarguments.c, but that warning can be
 370          * safely ignored.
 371          */
 372         param.type = ACPI_TYPE_INTEGER;
 373         param.integer.value = event->instance_id;
 374
 375         return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_THERMAL, &param);
 376 }
 377
 378 static bool san_evt_tmp(const struct ssam_event *event, struct device *dev)
 379 {
 380         int status;
 381
 382         switch (event->command_id) {
 383         case SAM_EVENT_CID_TMP_TRIP:
 384                 status = san_evt_tmp_trip(dev, event);
 385                 break;
 386
 387         default:
 388                 return false;
 389         }
 390
 391         if (status) {
 392                 dev_err(dev, "error handling thermal event (cid = %#04x)\n",
 393                         event->command_id);
 394         }
 395
 396         return true;
 397 }
 398
 399 static u32 san_evt_tmp_nf(struct ssam_event_notifier *nf,
 400                           const struct ssam_event *event)
 401 {
 402         struct san_data *d = to_san_data(nf, nf_tmp);
 403
 404         return san_evt_tmp(event, d->dev) ? SSAM_NOTIF_HANDLED : 0;
 405 }
 406
 407
 408 /* -- ACPI GSB OperationRegion handler -------------------------------------- */
 409
 410 struct gsb_data_in {
 411         u8 cv;
 412 } __packed;
 413
 414 struct gsb_data_rqsx {
 415         u8 cv;                          /* Command value (san_gsb_request_cv). */
 416         u8 tc;                          /* Target category. */
 417         u8 tid;                         /* Target ID. */
 418         u8 iid;                         /* Instance ID. */
 419         u8 snc;                         /* Expect-response-flag. */
 420         u8 cid;                         /* Command ID. */
 421         u16 cdl;                        /* Payload length. */
 422         u8 pld[];                       /* Payload. */
 423 } __packed;
 424
 425 struct gsb_data_etwl {
 426         u8 cv;                          /* Command value (should be 0x02). */
 427         u8 etw3;                        /* Unknown. */
 428         u8 etw4;                        /* Unknown. */
 429         u8 msg[];                       /* Error message (ASCIIZ). */
 430 } __packed;
 431
 432 struct gsb_data_out {
 433         u8 status;                      /* _SSH communication status. */
 434         u8 len;                         /* _SSH payload length. */
 435         u8 pld[];                       /* _SSH payload. */
 436 } __packed;
 437
 438 union gsb_buffer_data {
 439         struct gsb_data_in   in;        /* Common input. */
 440         struct gsb_data_rqsx rqsx;      /* RQSX input. */
 441         struct gsb_data_etwl etwl;      /* ETWL input. */
 442         struct gsb_data_out  out;       /* Output. */
 443 };
 444
 445 struct gsb_buffer {
 446         u8 status;                      /* GSB AttribRawProcess status. */
 447         u8 len;                         /* GSB AttribRawProcess length. */
 448         union gsb_buffer_data data;
 449 } __packed;
 450
 451 #define SAN_GSB_MAX_RQSX_PAYLOAD  (U8_MAX - 2 - sizeof(struct gsb_data_rqsx))
 452 #define SAN_GSB_MAX_RESPONSE      (U8_MAX - 2 - sizeof(struct gsb_data_out))
 453
 454 #define SAN_GSB_COMMAND         0
 455
 456 enum san_gsb_request_cv {
 457         SAN_GSB_REQUEST_CV_RQST = 0x01,
 458         SAN_GSB_REQUEST_CV_ETWL = 0x02,
 459         SAN_GSB_REQUEST_CV_RQSG = 0x03,
 460 };
 461
 462 #define SAN_REQUEST_NUM_TRIES   5
 463
 464 static acpi_status san_etwl(struct san_data *d, struct gsb_buffer *b)
 465 {
 466         struct gsb_data_etwl *etwl = &b->data.etwl;
 467
 468         if (b->len < sizeof(struct gsb_data_etwl)) {
 469                 dev_err(d->dev, "invalid ETWL package (len = %d)\n", b->len);
 470                 return AE_OK;
 471         }
 472
 473         dev_err(d->dev, "ETWL(%#04x, %#04x): %.*s\n", etwl->etw3, etwl->etw4,
 474                 (unsigned int)(b->len - sizeof(struct gsb_data_etwl)),
 475                 (char *)etwl->msg);
 476
 477         /* Indicate success. */
 478         b->status = 0x00;
 479         b->len = 0x00;
 480
 481         return AE_OK;
 482 }
 483
 484 static
 485 struct gsb_data_rqsx *san_validate_rqsx(struct device *dev, const char *type,
 486                                         struct gsb_buffer *b)
 487 {
 488         struct gsb_data_rqsx *rqsx = &b->data.rqsx;
 489
 490         if (b->len < sizeof(struct gsb_data_rqsx)) {
 491                 dev_err(dev, "invalid %s package (len = %d)\n", type, b->len);
 492                 return NULL;
 493         }
 494
 495         if (get_unaligned(&rqsx->cdl) != b->len - sizeof(struct gsb_data_rqsx)) {
 496                 dev_err(dev, "bogus %s package (len = %d, cdl = %d)\n",
 497                         type, b->len, get_unaligned(&rqsx->cdl));
 498                 return NULL;
 499         }
 500
 501         if (get_unaligned(&rqsx->cdl) > SAN_GSB_MAX_RQSX_PAYLOAD) {
 502                 dev_err(dev, "payload for %s package too large (cdl = %d)\n",
 503                         type, get_unaligned(&rqsx->cdl));
 504                 return NULL;
 505         }
 506
 507         return rqsx;
 508 }
 509
 510 static void gsb_rqsx_response_error(struct gsb_buffer *gsb, int status)
 511 {
 512         gsb->status = 0x00;
 513         gsb->len = 0x02;
 514         gsb->data.out.status = (u8)(-status);
 515         gsb->data.out.len = 0x00;
 516 }
 517
 518 static void gsb_rqsx_response_success(struct gsb_buffer *gsb, u8 *ptr, size_t len)
 519 {
 520         gsb->status = 0x00;
 521         gsb->len = len + 2;
 522         gsb->data.out.status = 0x00;
 523         gsb->data.out.len = len;
 524
 525         if (len)
 526                 memcpy(&gsb->data.out.pld[0], ptr, len);
 527 }
 528
 529 static acpi_status san_rqst_fixup_suspended(struct san_data *d,
 530                                             struct ssam_request *rqst,
 531                                             struct gsb_buffer *gsb)
 532 {
 533         if (rqst->target_category == SSAM_SSH_TC_BAS && rqst->command_id == 0x0D) {
 534                 u8 base_state = 1;
 535
 536                 /* Base state quirk:
 537                  * The base state may be queried from ACPI when the EC is still
 538                  * suspended. In this case it will return '-EPERM'. This query
 539                  * will only be triggered from the ACPI lid GPE interrupt, thus
 540                  * we are either in laptop or studio mode (base status 0x01 or
 541                  * 0x02). Furthermore, we will only get here if the device (and
 542                  * EC) have been suspended.
 543                  *
 544                  * We now assume that the device is in laptop mode (0x01). This
 545                  * has the drawback that it will wake the device when unfolding
 546                  * it in studio mode, but it also allows us to avoid actively
 547                  * waiting for the EC to wake up, which may incur a notable
 548                  * delay.
 549                  */
 550
 551                 dev_dbg(d->dev, "rqst: fixup: base-state quirk\n");
 552
 553                 gsb_rqsx_response_success(gsb, &base_state, sizeof(base_state));
 554                 return AE_OK;
 555         }
 556
 557         gsb_rqsx_response_error(gsb, -ENXIO);
 558         return AE_OK;
 559 }
 560
 561 static acpi_status san_rqst(struct san_data *d, struct gsb_buffer *buffer)
 562 {
 563         u8 rspbuf[SAN_GSB_MAX_RESPONSE];
 564         struct gsb_data_rqsx *gsb_rqst;
 565         struct ssam_request rqst;
 566         struct ssam_response rsp;
 567         int status = 0;
 568
 569         gsb_rqst = san_validate_rqsx(d->dev, "RQST", buffer);
 570         if (!gsb_rqst)
 571                 return AE_OK;
 572
 573         rqst.target_category = gsb_rqst->tc;
 574         rqst.target_id = gsb_rqst->tid;
 575         rqst.command_id = gsb_rqst->cid;
 576         rqst.instance_id = gsb_rqst->iid;
 577         rqst.flags = gsb_rqst->snc ? SSAM_REQUEST_HAS_RESPONSE : 0;
 578         rqst.length = get_unaligned(&gsb_rqst->cdl);
 579         rqst.payload = &gsb_rqst->pld[0];
 580
 581         rsp.capacity = ARRAY_SIZE(rspbuf);
 582         rsp.length = 0;
 583         rsp.pointer = &rspbuf[0];
 584
 585         /* Handle suspended device. */
 586         if (d->dev->power.is_suspended) {
 587                 dev_warn(d->dev, "rqst: device is suspended, not executing\n");
 588                 return san_rqst_fixup_suspended(d, &rqst, buffer);
 589         }
 590
 591         status = __ssam_retry(ssam_request_sync_onstack, SAN_REQUEST_NUM_TRIES,
 592                               d->ctrl, &rqst, &rsp, SAN_GSB_MAX_RQSX_PAYLOAD);
 593
 594         if (!status) {
 595                 gsb_rqsx_response_success(buffer, rsp.pointer, rsp.length);
 596         } else {
 597                 dev_err(d->dev, "rqst: failed with error %d\n", status);
 598                 gsb_rqsx_response_error(buffer, status);
 599         }
 600
 601         return AE_OK;
 602 }
 603
 604 static acpi_status san_rqsg(struct san_data *d, struct gsb_buffer *buffer)
 605 {
 606         struct gsb_data_rqsx *gsb_rqsg;
 607         struct san_dgpu_event evt;
 608         int status;
 609
 610         gsb_rqsg = san_validate_rqsx(d->dev, "RQSG", buffer);
 611         if (!gsb_rqsg)
 612                 return AE_OK;
 613
 614         evt.category = gsb_rqsg->tc;
 615         evt.target = gsb_rqsg->tid;
 616         evt.command = gsb_rqsg->cid;
 617         evt.instance = gsb_rqsg->iid;
 618         evt.length = get_unaligned(&gsb_rqsg->cdl);
 619         evt.payload = &gsb_rqsg->pld[0];
 620
 621         status = san_dgpu_notifier_call(&evt);
 622         if (!status) {
 623                 gsb_rqsx_response_success(buffer, NULL, 0);
 624         } else {
 625                 dev_err(d->dev, "rqsg: failed with error %d\n", status);
 626                 gsb_rqsx_response_error(buffer, status);
 627         }
 628
 629         return AE_OK;
 630 }
 631
 632 static acpi_status san_opreg_handler(u32 function, acpi_physical_address command,
 633                                      u32 bits, u64 *value64, void *opreg_context,
 634                                      void *region_context)
 635 {
 636         struct san_data *d = to_san_data(opreg_context, info);
 637         struct gsb_buffer *buffer = (struct gsb_buffer *)value64;
 638         int accessor_type = (function & 0xFFFF0000) >> 16;
 639
 640         if (command != SAN_GSB_COMMAND) {
 641                 dev_warn(d->dev, "unsupported command: %#04llx\n", command);
 642                 return AE_OK;
 643         }
 644
 645         if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) {
 646                 dev_err(d->dev, "invalid access type: %#04x\n", accessor_type);
 647                 return AE_OK;
 648         }
 649
 650         /* Buffer must have at least contain the command-value. */
 651         if (buffer->len == 0) {
 652                 dev_err(d->dev, "request-package too small\n");
 653                 return AE_OK;
 654         }
 655
 656         switch (buffer->data.in.cv) {
 657         case SAN_GSB_REQUEST_CV_RQST:
 658                 return san_rqst(d, buffer);
 659
 660         case SAN_GSB_REQUEST_CV_ETWL:
 661                 return san_etwl(d, buffer);
 662
 663         case SAN_GSB_REQUEST_CV_RQSG:
 664                 return san_rqsg(d, buffer);
 665
 666         default:
 667                 dev_warn(d->dev, "unsupported SAN0 request (cv: %#04x)\n",
 668                          buffer->data.in.cv);
 669                 return AE_OK;
 670         }
 671 }
 672
 673
 674 /* -- Driver setup. --------------------------------------------------------- */
 675
 676 static int san_events_register(struct platform_device *pdev)
 677 {
 678         struct san_data *d = platform_get_drvdata(pdev);
 679         int status;
 680
 681         d->nf_bat.base.priority = 1;
 682         d->nf_bat.base.fn = san_evt_bat_nf;
 683         d->nf_bat.event.reg = SSAM_EVENT_REGISTRY_SAM;
 684         d->nf_bat.event.id.target_category = SSAM_SSH_TC_BAT;
 685         d->nf_bat.event.id.instance = 0;
 686         d->nf_bat.event.mask = SSAM_EVENT_MASK_TARGET;
 687         d->nf_bat.event.flags = SSAM_EVENT_SEQUENCED;
 688
 689         d->nf_tmp.base.priority = 1;
 690         d->nf_tmp.base.fn = san_evt_tmp_nf;
 691         d->nf_tmp.event.reg = SSAM_EVENT_REGISTRY_SAM;
 692         d->nf_tmp.event.id.target_category = SSAM_SSH_TC_TMP;
 693         d->nf_tmp.event.id.instance = 0;
 694         d->nf_tmp.event.mask = SSAM_EVENT_MASK_TARGET;
 695         d->nf_tmp.event.flags = SSAM_EVENT_SEQUENCED;
 696
 697         status = ssam_notifier_register(d->ctrl, &d->nf_bat);
 698         if (status)
 699                 return status;
 700
 701         status = ssam_notifier_register(d->ctrl, &d->nf_tmp);
 702         if (status)
 703                 ssam_notifier_unregister(d->ctrl, &d->nf_bat);
 704
 705         return status;
 706 }
 707
 708 static void san_events_unregister(struct platform_device *pdev)
 709 {
 710         struct san_data *d = platform_get_drvdata(pdev);
 711
 712         ssam_notifier_unregister(d->ctrl, &d->nf_bat);
 713         ssam_notifier_unregister(d->ctrl, &d->nf_tmp);
 714 }
 715
 716 #define san_consumer_printk(level, dev, handle, fmt, ...)                       \
 717 do {                                                                            \
 718         char *path = "<error getting consumer path>";                           \
 719         struct acpi_buffer buffer = {                                           \
 720                 .length = ACPI_ALLOCATE_BUFFER,                                 \
 721                 .pointer = NULL,                                                \
 722         };                                                                      \
 723                                                                                 \
 724         if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))   \
 725                 path = buffer.pointer;                                          \
 726                                                                                 \
 727         dev_##level(dev, "[%s]: " fmt, path, ##__VA_ARGS__);                    \
 728         kfree(buffer.pointer);                                                  \
 729 } while (0)
 730
 731 #define san_consumer_dbg(dev, handle, fmt, ...) \
 732         san_consumer_printk(dbg, dev, handle, fmt, ##__VA_ARGS__)
 733
 734 #define san_consumer_warn(dev, handle, fmt, ...) \
 735         san_consumer_printk(warn, dev, handle, fmt, ##__VA_ARGS__)
 736
 737 static bool is_san_consumer(struct platform_device *pdev, acpi_handle handle)
 738 {
 739         struct acpi_handle_list dep_devices;
 740         acpi_handle supplier = ACPI_HANDLE(&pdev->dev);
 741         acpi_status status;
 742         int i;
 743
 744         if (!acpi_has_method(handle, "_DEP"))
 745                 return false;
 746
 747         status = acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices);
 748         if (ACPI_FAILURE(status)) {
 749                 san_consumer_dbg(&pdev->dev, handle, "failed to evaluate _DEP\n");
 750                 return false;
 751         }
 752
 753         for (i = 0; i < dep_devices.count; i++) {
 754                 if (dep_devices.handles[i] == supplier)
 755                         return true;
 756         }
 757
 758         return false;
 759 }
 760
 761 static acpi_status san_consumer_setup(acpi_handle handle, u32 lvl,
 762                                       void *context, void **rv)
 763 {
 764         const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER;
 765         struct platform_device *pdev = context;
 766         struct acpi_device *adev;
 767         struct device_link *link;
 768
 769         if (!is_san_consumer(pdev, handle))
 770                 return AE_OK;
 771
 772         /* Ignore ACPI devices that are not present. */
 773         if (acpi_bus_get_device(handle, &adev) != 0)
 774                 return AE_OK;
 775
 776         san_consumer_dbg(&pdev->dev, handle, "creating device link\n");
 777
 778         /* Try to set up device links, ignore but log errors. */
 779         link = device_link_add(&adev->dev, &pdev->dev, flags);
 780         if (!link) {
 781                 san_consumer_warn(&pdev->dev, handle, "failed to create device link\n");
 782                 return AE_OK;
 783         }
 784
 785         return AE_OK;
 786 }
 787
 788 static int san_consumer_links_setup(struct platform_device *pdev)
 789 {
 790         acpi_status status;
 791
 792         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
 793                                      ACPI_UINT32_MAX, san_consumer_setup, NULL,
 794                                      pdev, NULL);
 795
 796         return status ? -EFAULT : 0;
 797 }
 798
 799 static int san_probe(struct platform_device *pdev)
 800 {
 801         acpi_handle san = ACPI_HANDLE(&pdev->dev);
 802         struct ssam_controller *ctrl;
 803         struct san_data *data;
 804         acpi_status astatus;
 805         int status;
 806
 807         ctrl = ssam_client_bind(&pdev->dev);
 808         if (IS_ERR(ctrl))
 809                 return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
 810
 811         status = san_consumer_links_setup(pdev);
 812         if (status)
 813                 return status;
 814
 815         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 816         if (!data)
 817                 return -ENOMEM;
 818
 819         data->dev = &pdev->dev;
 820         data->ctrl = ctrl;
 821
 822         platform_set_drvdata(pdev, data);
 823
 824         astatus = acpi_install_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
 825                                                      &san_opreg_handler, NULL,
 826                                                      &data->info);
 827         if (ACPI_FAILURE(astatus))
 828                 return -ENXIO;
 829
 830         status = san_events_register(pdev);
 831         if (status)
 832                 goto err_enable_events;
 833
 834         status = san_set_rqsg_interface_device(&pdev->dev);
 835         if (status)
 836                 goto err_install_dev;
 837
 838         acpi_walk_dep_device_list(san);
 839         return 0;
 840
 841 err_install_dev:
 842         san_events_unregister(pdev);
 843 err_enable_events:
 844         acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
 845                                           &san_opreg_handler);
 846         return status;
 847 }
 848
 849 static int san_remove(struct platform_device *pdev)
 850 {
 851         acpi_handle san = ACPI_HANDLE(&pdev->dev);
 852
 853         san_set_rqsg_interface_device(NULL);
 854         acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
 855                                           &san_opreg_handler);
 856         san_events_unregister(pdev);
 857
 858         /*
 859          * We have unregistered our event sources. Now we need to ensure that
 860          * all delayed works they may have spawned are run to completion.
 861          */
 862         flush_scheduled_work();
 863
 864         return 0;
 865 }
 866
 867 static const struct acpi_device_id san_match[] = {
 868         { "MSHW0091" },
 869         { },
 870 };
 871 MODULE_DEVICE_TABLE(acpi, san_match);
 872
 873 static struct platform_driver surface_acpi_notify = {
 874         .probe = san_probe,
 875         .remove = san_remove,
 876         .driver = {
 877                 .name = "surface_acpi_notify",
 878                 .acpi_match_table = san_match,
 879                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 880         },
 881 };
 882 module_platform_driver(surface_acpi_notify);
 883
 884 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
 885 MODULE_DESCRIPTION("Surface ACPI Notify driver for Surface System Aggregator Module");
 886 MODULE_LICENSE("GPL");