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/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("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("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, 0, &state, 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(ebook_switch_idev, SW_TABLET_MODE, state);
 86	input_sync(ebook_switch_idev);
 87	pm_wakeup_event(&ebook_switch_idev->dev, 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(lid_switch_idev, SW_LID, !lid_open);
130	input_sync(lid_switch_idev);
131	pm_wakeup_event(&lid_switch_idev->dev, 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, "%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(mode, buf, 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(&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(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(acpi_base + CS5536_PM1_STS);
219	outl(sts | 0xffff, acpi_base + CS5536_PM1_STS);
220
221	gpe = inl(acpi_base + CS5536_PM_GPE0_STS);
222	outl(0xffffffff, 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(power_button_idev, KEY_POWER, 1);
232			input_sync(power_button_idev);
233			input_report_key(power_button_idev, KEY_POWER, 0);
234			input_sync(power_button_idev);
235		}
236		/* Report the wakeup event in all cases. */
237		pm_wakeup_event(&power_button_idev->dev, 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			&platform_bus_type, NULL, "rtc_cmos");
246		if (rtc) {
247			pm_wakeup_event(rtc, 0);
248			put_device(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(&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(&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(&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(&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(0x51400020, 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(lo, CS5536_PIC_INT_SEL1);
336	} else {
337		lo = inb(CS5536_PIC_INT_SEL2);
338		lo |= 1 << (sci_irq - 8);
339		outb(lo, CS5536_PIC_INT_SEL2);
340	}
341
342	/* Enable interesting SCI events, and clear pending interrupts */
343	sts = inl(acpi_base + CS5536_PM1_STS);
344	outl(((CS5536_PM_PWRBTN | CS5536_PM_RTC) << 16) | 0xffff,
345	     acpi_base + CS5536_PM1_STS);
346
347	r = request_irq(sci_irq, xo1_sci_intr, 0, DRV_NAME, 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, "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, 7, 1);
386
387	/* And have group 7 also fire the SCI interrupt */
388	cs5535_pic_unreqz_select_high(7, 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, "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, 6, 1);
420
421	/* Set PME group 6 to fire the SCI interrupt */
422	cs5535_gpio_set_irq(6, 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, power_button_idev->evbit);
446	set_bit(KEY_POWER, power_button_idev->keybit);
447
448	power_button_idev->dev.parent = &pdev->dev;
449	device_init_wakeup(&power_button_idev->dev, 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(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, ebook_switch_idev->evbit);
476	set_bit(SW_TABLET_MODE, ebook_switch_idev->swbit);
477
478	ebook_switch_idev->dev.parent = &pdev->dev;
479	device_set_wakeup_capable(&ebook_switch_idev->dev, 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(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, lid_switch_idev->evbit);
506	set_bit(SW_LID, lid_switch_idev->swbit);
507
508	lid_switch_idev->dev.parent = &pdev->dev;
509	device_set_wakeup_capable(&lid_switch_idev->dev, 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(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		acpi_base + CS5536_PM_GPE0_EN);
568
569	/* Clear pending events */
570	outl(0xffffffff, acpi_base + CS5536_PM_GPE0_STS);
571	process_sci_queue(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(&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);