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

source code of linux/arch/x86/platform/olpc/olpc-xo1-sci.c