arch/x86/platform/olpc/olpc-xo1-sci.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Support for OLPC XO-1 System Control Interrupts (SCI)
   4  *
   5  * Copyright (C) 2010 One Laptop per Child
   6  * Copyright (C) 2006 Red Hat, Inc.
   7  * Copyright (C) 2006 Advanced Micro Devices, Inc.
   8  */
   9
  10 #include <linux/cs5535.h>
  11 #include <linux/device.h>
  12 #include <linux/gpio.h>
  13 #include <linux/input.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/pm.h>
  17 #include <linux/pm_wakeup.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/power_supply.h>
  20 #include <linux/suspend.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/olpc-ec.h>
  23
  24 #include <asm/io.h>
  25 #include <asm/msr.h>
  26 #include <asm/olpc.h>
  27
  28 #define DRV_NAME        "olpc-xo1-sci"
  29 #define PFX             DRV_NAME ": "
  30
  31 static unsigned long acpi_base;
  32 static struct input_dev *power_button_idev;
  33 static struct input_dev *ebook_switch_idev;
  34 static struct input_dev *lid_switch_idev;
  35
  36 static int sci_irq;
  37
  38 static bool lid_open;
  39 static bool lid_inverted;
  40 static int lid_wake_mode;
  41
  42 enum lid_wake_modes {
  43         LID_WAKE_ALWAYS,
  44         LID_WAKE_OPEN,
  45         LID_WAKE_CLOSE,
  46 };
  47
  48 static const char * const lid_wake_mode_names[] = {
  49         [LID_WAKE_ALWAYS] = "always",
  50         [LID_WAKE_OPEN] = "open",
  51         [LID_WAKE_CLOSE] = "close",
  52 };
  53
  54 static void battery_status_changed(void)
  55 {
  56         struct power_supply *psy = power_supply_get_by_name("olpc-battery");
  57
  58         if (psy) {
  59                 power_supply_changed(psy);
  60                 power_supply_put(psy);
  61         }
  62 }
  63
  64 static void ac_status_changed(void)
  65 {
  66         struct power_supply *psy = power_supply_get_by_name("olpc-ac");
  67
  68         if (psy) {
  69                 power_supply_changed(psy);
  70                 power_supply_put(psy);
  71         }
  72 }
  73
  74 /* Report current ebook switch state through input layer */
  75 static void send_ebook_state(void)
  76 {
  77         unsigned char state;
  78
  79         if (olpc_ec_cmd(EC_READ_EB_MODE, NULL, 0, &state, 1)) {
  80                 pr_err(PFX "failed to get ebook state\n");
  81                 return;
  82         }
  83
  84         if (!!test_bit(SW_TABLET_MODE, ebook_switch_idev->sw) == state)
  85                 return; /* Nothing new to report. */
  86
  87         input_report_switch(ebook_switch_idev, SW_TABLET_MODE, state);
  88         input_sync(ebook_switch_idev);
  89         pm_wakeup_event(&ebook_switch_idev->dev, 0);
  90 }
  91
  92 static void flip_lid_inverter(void)
  93 {
  94         /* gpio is high; invert so we'll get l->h event interrupt */
  95         if (lid_inverted)
  96                 cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_INPUT_INVERT);
  97         else
  98                 cs5535_gpio_set(OLPC_GPIO_LID, GPIO_INPUT_INVERT);
  99         lid_inverted = !lid_inverted;
 100 }
 101
 102 static void detect_lid_state(void)
 103 {
 104         /*
 105          * the edge detector hookup on the gpio inputs on the geode is
 106          * odd, to say the least.  See http://dev.laptop.org/ticket/5703
 107          * for details, but in a nutshell:  we don't use the edge
 108          * detectors.  instead, we make use of an anomaly:  with the both
 109          * edge detectors turned off, we still get an edge event on a
 110          * positive edge transition.  to take advantage of this, we use the
 111          * front-end inverter to ensure that that's the edge we're always
 112          * going to see next.
 113          */
 114
 115         int state;
 116
 117         state = cs5535_gpio_isset(OLPC_GPIO_LID, GPIO_READ_BACK);
 118         lid_open = !state ^ !lid_inverted; /* x ^^ y */
 119         if (!state)
 120                 return;
 121
 122         flip_lid_inverter();
 123 }
 124
 125 /* Report current lid switch state through input layer */
 126 static void send_lid_state(void)
 127 {
 128         if (!!test_bit(SW_LID, lid_switch_idev->sw) == !lid_open)
 129                 return; /* Nothing new to report. */
 130
 131         input_report_switch(lid_switch_idev, SW_LID, !lid_open);
 132         input_sync(lid_switch_idev);
 133         pm_wakeup_event(&lid_switch_idev->dev, 0);
 134 }
 135
 136 static ssize_t lid_wake_mode_show(struct device *dev,
 137                                   struct device_attribute *attr, char *buf)
 138 {
 139         const char *mode = lid_wake_mode_names[lid_wake_mode];
 140         return sprintf(buf, "%s\n", mode);
 141 }
 142 static ssize_t lid_wake_mode_set(struct device *dev,
 143                                  struct device_attribute *attr,
 144                                  const char *buf, size_t count)
 145 {
 146         int i;
 147         for (i = 0; i < ARRAY_SIZE(lid_wake_mode_names); i++) {
 148                 const char *mode = lid_wake_mode_names[i];
 149                 if (strlen(mode) != count || strncasecmp(mode, buf, count))
 150                         continue;
 151
 152                 lid_wake_mode = i;
 153                 return count;
 154         }
 155         return -EINVAL;
 156 }
 157 static DEVICE_ATTR(lid_wake_mode, S_IWUSR | S_IRUGO, lid_wake_mode_show,
 158                    lid_wake_mode_set);
 159
 160 /*
 161  * Process all items in the EC's SCI queue.
 162  *
 163  * This is handled in a workqueue because olpc_ec_cmd can be slow (and
 164  * can even timeout).
 165  *
 166  * If propagate_events is false, the queue is drained without events being
 167  * generated for the interrupts.
 168  */
 169 static void process_sci_queue(bool propagate_events)
 170 {
 171         int r;
 172         u16 data;
 173
 174         do {
 175                 r = olpc_ec_sci_query(&data);
 176                 if (r || !data)
 177                         break;
 178
 179                 pr_debug(PFX "SCI 0x%x received\n", data);
 180
 181                 switch (data) {
 182                 case EC_SCI_SRC_BATERR:
 183                 case EC_SCI_SRC_BATSOC:
 184                 case EC_SCI_SRC_BATTERY:
 185                 case EC_SCI_SRC_BATCRIT:
 186                         battery_status_changed();
 187                         break;
 188                 case EC_SCI_SRC_ACPWR:
 189                         ac_status_changed();
 190                         break;
 191                 }
 192
 193                 if (data == EC_SCI_SRC_EBOOK && propagate_events)
 194                         send_ebook_state();
 195         } while (data);
 196
 197         if (r)
 198                 pr_err(PFX "Failed to clear SCI queue");
 199 }
 200
 201 static void process_sci_queue_work(struct work_struct *work)
 202 {
 203         process_sci_queue(true);
 204 }
 205
 206 static DECLARE_WORK(sci_work, process_sci_queue_work);
 207
 208 static irqreturn_t xo1_sci_intr(int irq, void *dev_id)
 209 {
 210         struct platform_device *pdev = dev_id;
 211         u32 sts;
 212         u32 gpe;
 213
 214         sts = inl(acpi_base + CS5536_PM1_STS);
 215         outl(sts | 0xffff, acpi_base + CS5536_PM1_STS);
 216
 217         gpe = inl(acpi_base + CS5536_PM_GPE0_STS);
 218         outl(0xffffffff, acpi_base + CS5536_PM_GPE0_STS);
 219
 220         dev_dbg(&pdev->dev, "sts %x gpe %x\n", sts, gpe);
 221
 222         if (sts & CS5536_PWRBTN_FLAG) {
 223                 if (!(sts & CS5536_WAK_FLAG)) {
 224                         /* Only report power button input when it was pressed
 225                          * during regular operation (as opposed to when it
 226                          * was used to wake the system). */
 227                         input_report_key(power_button_idev, KEY_POWER, 1);
 228                         input_sync(power_button_idev);
 229                         input_report_key(power_button_idev, KEY_POWER, 0);
 230                         input_sync(power_button_idev);
 231                 }
 232                 /* Report the wakeup event in all cases. */
 233                 pm_wakeup_event(&power_button_idev->dev, 0);
 234         }
 235
 236         if ((sts & (CS5536_RTC_FLAG | CS5536_WAK_FLAG)) ==
 237                         (CS5536_RTC_FLAG | CS5536_WAK_FLAG)) {
 238                 /* When the system is woken by the RTC alarm, report the
 239                  * event on the rtc device. */
 240                 struct device *rtc = bus_find_device_by_name(
 241                         &platform_bus_type, NULL, "rtc_cmos");
 242                 if (rtc) {
 243                         pm_wakeup_event(rtc, 0);
 244                         put_device(rtc);
 245                 }
 246         }
 247
 248         if (gpe & CS5536_GPIOM7_PME_FLAG) { /* EC GPIO */
 249                 cs5535_gpio_set(OLPC_GPIO_ECSCI, GPIO_NEGATIVE_EDGE_STS);
 250                 schedule_work(&sci_work);
 251         }
 252
 253         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_STS);
 254         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_STS);
 255         detect_lid_state();
 256         send_lid_state();
 257
 258         return IRQ_HANDLED;
 259 }
 260
 261 static int xo1_sci_suspend(struct platform_device *pdev, pm_message_t state)
 262 {
 263         if (device_may_wakeup(&power_button_idev->dev))
 264                 olpc_xo1_pm_wakeup_set(CS5536_PM_PWRBTN);
 265         else
 266                 olpc_xo1_pm_wakeup_clear(CS5536_PM_PWRBTN);
 267
 268         if (device_may_wakeup(&ebook_switch_idev->dev))
 269                 olpc_ec_wakeup_set(EC_SCI_SRC_EBOOK);
 270         else
 271                 olpc_ec_wakeup_clear(EC_SCI_SRC_EBOOK);
 272
 273         if (!device_may_wakeup(&lid_switch_idev->dev)) {
 274                 cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
 275         } else if ((lid_open && lid_wake_mode == LID_WAKE_OPEN) ||
 276                    (!lid_open && lid_wake_mode == LID_WAKE_CLOSE)) {
 277                 flip_lid_inverter();
 278
 279                 /* we may have just caused an event */
 280                 cs5535_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_STS);
 281                 cs5535_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_STS);
 282
 283                 cs5535_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
 284         }
 285
 286         return 0;
 287 }
 288
 289 static int xo1_sci_resume(struct platform_device *pdev)
 290 {
 291         /*
 292          * We don't know what may have happened while we were asleep.
 293          * Reestablish our lid setup so we're sure to catch all transitions.
 294          */
 295         detect_lid_state();
 296         send_lid_state();
 297         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
 298
 299         /* Enable all EC events */
 300         olpc_ec_mask_write(EC_SCI_SRC_ALL);
 301
 302         /* Power/battery status might have changed too */
 303         battery_status_changed();
 304         ac_status_changed();
 305         return 0;
 306 }
 307
 308 static int setup_sci_interrupt(struct platform_device *pdev)
 309 {
 310         u32 lo, hi;
 311         u32 sts;
 312         int r;
 313
 314         rdmsr(0x51400020, lo, hi);
 315         sci_irq = (lo >> 20) & 15;
 316
 317         if (sci_irq) {
 318                 dev_info(&pdev->dev, "SCI is mapped to IRQ %d\n", sci_irq);
 319         } else {
 320                 /* Zero means masked */
 321                 dev_info(&pdev->dev, "SCI unmapped. Mapping to IRQ 3\n");
 322                 sci_irq = 3;
 323                 lo |= 0x00300000;
 324                 wrmsrl(0x51400020, lo);
 325         }
 326
 327         /* Select level triggered in PIC */
 328         if (sci_irq < 8) {
 329                 lo = inb(CS5536_PIC_INT_SEL1);
 330                 lo |= 1 << sci_irq;
 331                 outb(lo, CS5536_PIC_INT_SEL1);
 332         } else {
 333                 lo = inb(CS5536_PIC_INT_SEL2);
 334                 lo |= 1 << (sci_irq - 8);
 335                 outb(lo, CS5536_PIC_INT_SEL2);
 336         }
 337
 338         /* Enable interesting SCI events, and clear pending interrupts */
 339         sts = inl(acpi_base + CS5536_PM1_STS);
 340         outl(((CS5536_PM_PWRBTN | CS5536_PM_RTC) << 16) | 0xffff,
 341              acpi_base + CS5536_PM1_STS);
 342
 343         r = request_irq(sci_irq, xo1_sci_intr, 0, DRV_NAME, pdev);
 344         if (r)
 345                 dev_err(&pdev->dev, "can't request interrupt\n");
 346
 347         return r;
 348 }
 349
 350 static int setup_ec_sci(void)
 351 {
 352         int r;
 353
 354         r = gpio_request(OLPC_GPIO_ECSCI, "OLPC-ECSCI");
 355         if (r)
 356                 return r;
 357
 358         gpio_direction_input(OLPC_GPIO_ECSCI);
 359
 360         /* Clear pending EC SCI events */
 361         cs5535_gpio_set(OLPC_GPIO_ECSCI, GPIO_NEGATIVE_EDGE_STS);
 362         cs5535_gpio_set(OLPC_GPIO_ECSCI, GPIO_POSITIVE_EDGE_STS);
 363
 364         /*
 365          * Enable EC SCI events, and map them to both a PME and the SCI
 366          * interrupt.
 367          *
 368          * Ordinarily, in addition to functioning as GPIOs, Geode GPIOs can
 369          * be mapped to regular interrupts *or* Geode-specific Power
 370          * Management Events (PMEs) - events that bring the system out of
 371          * suspend. In this case, we want both of those things - the system
 372          * wakeup, *and* the ability to get an interrupt when an event occurs.
 373          *
 374          * To achieve this, we map the GPIO to a PME, and then we use one
 375          * of the many generic knobs on the CS5535 PIC to additionally map the
 376          * PME to the regular SCI interrupt line.
 377          */
 378         cs5535_gpio_set(OLPC_GPIO_ECSCI, GPIO_EVENTS_ENABLE);
 379
 380         /* Set the SCI to cause a PME event on group 7 */
 381         cs5535_gpio_setup_event(OLPC_GPIO_ECSCI, 7, 1);
 382
 383         /* And have group 7 also fire the SCI interrupt */
 384         cs5535_pic_unreqz_select_high(7, sci_irq);
 385
 386         return 0;
 387 }
 388
 389 static void free_ec_sci(void)
 390 {
 391         gpio_free(OLPC_GPIO_ECSCI);
 392 }
 393
 394 static int setup_lid_events(void)
 395 {
 396         int r;
 397
 398         r = gpio_request(OLPC_GPIO_LID, "OLPC-LID");
 399         if (r)
 400                 return r;
 401
 402         gpio_direction_input(OLPC_GPIO_LID);
 403
 404         cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_INPUT_INVERT);
 405         lid_inverted = 0;
 406
 407         /* Clear edge detection and event enable for now */
 408         cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
 409         cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_EN);
 410         cs5535_gpio_clear(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_EN);
 411         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_NEGATIVE_EDGE_STS);
 412         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_POSITIVE_EDGE_STS);
 413
 414         /* Set the LID to cause an PME event on group 6 */
 415         cs5535_gpio_setup_event(OLPC_GPIO_LID, 6, 1);
 416
 417         /* Set PME group 6 to fire the SCI interrupt */
 418         cs5535_gpio_set_irq(6, sci_irq);
 419
 420         /* Enable the event */
 421         cs5535_gpio_set(OLPC_GPIO_LID, GPIO_EVENTS_ENABLE);
 422
 423         return 0;
 424 }
 425
 426 static void free_lid_events(void)
 427 {
 428         gpio_free(OLPC_GPIO_LID);
 429 }
 430
 431 static int setup_power_button(struct platform_device *pdev)
 432 {
 433         int r;
 434
 435         power_button_idev = input_allocate_device();
 436         if (!power_button_idev)
 437                 return -ENOMEM;
 438
 439         power_button_idev->name = "Power Button";
 440         power_button_idev->phys = DRV_NAME "/input0";
 441         set_bit(EV_KEY, power_button_idev->evbit);
 442         set_bit(KEY_POWER, power_button_idev->keybit);
 443
 444         power_button_idev->dev.parent = &pdev->dev;
 445         device_init_wakeup(&power_button_idev->dev, 1);
 446
 447         r = input_register_device(power_button_idev);
 448         if (r) {
 449                 dev_err(&pdev->dev, "failed to register power button: %d\n", r);
 450                 input_free_device(power_button_idev);
 451         }
 452
 453         return r;
 454 }
 455
 456 static void free_power_button(void)
 457 {
 458         input_unregister_device(power_button_idev);
 459 }
 460
 461 static int setup_ebook_switch(struct platform_device *pdev)
 462 {
 463         int r;
 464
 465         ebook_switch_idev = input_allocate_device();
 466         if (!ebook_switch_idev)
 467                 return -ENOMEM;
 468
 469         ebook_switch_idev->name = "EBook Switch";
 470         ebook_switch_idev->phys = DRV_NAME "/input1";
 471         set_bit(EV_SW, ebook_switch_idev->evbit);
 472         set_bit(SW_TABLET_MODE, ebook_switch_idev->swbit);
 473
 474         ebook_switch_idev->dev.parent = &pdev->dev;
 475         device_set_wakeup_capable(&ebook_switch_idev->dev, true);
 476
 477         r = input_register_device(ebook_switch_idev);
 478         if (r) {
 479                 dev_err(&pdev->dev, "failed to register ebook switch: %d\n", r);
 480                 input_free_device(ebook_switch_idev);
 481         }
 482
 483         return r;
 484 }
 485
 486 static void free_ebook_switch(void)
 487 {
 488         input_unregister_device(ebook_switch_idev);
 489 }
 490
 491 static int setup_lid_switch(struct platform_device *pdev)
 492 {
 493         int r;
 494
 495         lid_switch_idev = input_allocate_device();
 496         if (!lid_switch_idev)
 497                 return -ENOMEM;
 498
 499         lid_switch_idev->name = "Lid Switch";
 500         lid_switch_idev->phys = DRV_NAME "/input2";
 501         set_bit(EV_SW, lid_switch_idev->evbit);
 502         set_bit(SW_LID, lid_switch_idev->swbit);
 503
 504         lid_switch_idev->dev.parent = &pdev->dev;
 505         device_set_wakeup_capable(&lid_switch_idev->dev, true);
 506
 507         r = input_register_device(lid_switch_idev);
 508         if (r) {
 509                 dev_err(&pdev->dev, "failed to register lid switch: %d\n", r);
 510                 goto err_register;
 511         }
 512
 513         r = device_create_file(&lid_switch_idev->dev, &dev_attr_lid_wake_mode);
 514         if (r) {
 515                 dev_err(&pdev->dev, "failed to create wake mode attr: %d\n", r);
 516                 goto err_create_attr;
 517         }
 518
 519         return 0;
 520
 521 err_create_attr:
 522         input_unregister_device(lid_switch_idev);
 523         lid_switch_idev = NULL;
 524 err_register:
 525         input_free_device(lid_switch_idev);
 526         return r;
 527 }
 528
 529 static void free_lid_switch(void)
 530 {
 531         device_remove_file(&lid_switch_idev->dev, &dev_attr_lid_wake_mode);
 532         input_unregister_device(lid_switch_idev);
 533 }
 534
 535 static int xo1_sci_probe(struct platform_device *pdev)
 536 {
 537         struct resource *res;
 538         int r;
 539
 540         /* don't run on non-XOs */
 541         if (!machine_is_olpc())
 542                 return -ENODEV;
 543
 544         r = mfd_cell_enable(pdev);
 545         if (r)
 546                 return r;
 547
 548         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 549         if (!res) {
 550                 dev_err(&pdev->dev, "can't fetch device resource info\n");
 551                 return -EIO;
 552         }
 553         acpi_base = res->start;
 554
 555         r = setup_power_button(pdev);
 556         if (r)
 557                 return r;
 558
 559         r = setup_ebook_switch(pdev);
 560         if (r)
 561                 goto err_ebook;
 562
 563         r = setup_lid_switch(pdev);
 564         if (r)
 565                 goto err_lid;
 566
 567         r = setup_lid_events();
 568         if (r)
 569                 goto err_lidevt;
 570
 571         r = setup_ec_sci();
 572         if (r)
 573                 goto err_ecsci;
 574
 575         /* Enable PME generation for EC-generated events */
 576         outl(CS5536_GPIOM6_PME_EN | CS5536_GPIOM7_PME_EN,
 577                 acpi_base + CS5536_PM_GPE0_EN);
 578
 579         /* Clear pending events */
 580         outl(0xffffffff, acpi_base + CS5536_PM_GPE0_STS);
 581         process_sci_queue(false);
 582
 583         /* Initial sync */
 584         send_ebook_state();
 585         detect_lid_state();
 586         send_lid_state();
 587
 588         r = setup_sci_interrupt(pdev);
 589         if (r)
 590                 goto err_sci;
 591
 592         /* Enable all EC events */
 593         olpc_ec_mask_write(EC_SCI_SRC_ALL);
 594
 595         return r;
 596
 597 err_sci:
 598         free_ec_sci();
 599 err_ecsci:
 600         free_lid_events();
 601 err_lidevt:
 602         free_lid_switch();
 603 err_lid:
 604         free_ebook_switch();
 605 err_ebook:
 606         free_power_button();
 607         return r;
 608 }
 609
 610 static int xo1_sci_remove(struct platform_device *pdev)
 611 {
 612         mfd_cell_disable(pdev);
 613         free_irq(sci_irq, pdev);
 614         cancel_work_sync(&sci_work);
 615         free_ec_sci();
 616         free_lid_events();
 617         free_lid_switch();
 618         free_ebook_switch();
 619         free_power_button();
 620         acpi_base = 0;
 621         return 0;
 622 }
 623
 624 static struct platform_driver xo1_sci_driver = {
 625         .driver = {
 626                 .name = "olpc-xo1-sci-acpi",
 627         },
 628         .probe = xo1_sci_probe,
 629         .remove = xo1_sci_remove,
 630         .suspend = xo1_sci_suspend,
 631         .resume = xo1_sci_resume,
 632 };
 633
 634 static int __init xo1_sci_init(void)
 635 {
 636         return platform_driver_register(&xo1_sci_driver);
 637 }
 638 arch_initcall(xo1_sci_init);