1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Device driver for the PMU in Apple PowerBooks and PowerMacs.
4  *
5  * The VIA (versatile interface adapter) interfaces to the PMU,
6  * a 6805 microprocessor core whose primary function is to control
7  * battery charging and system power on the PowerBook 3400 and 2400.
8  * The PMU also controls the ADB (Apple Desktop Bus) which connects
9  * to the keyboard and mouse, as well as the non-volatile RAM
10  * and the RTC (real time clock) chip.
11  *
12  * Copyright (C) 1998 Paul Mackerras and Fabio Riccardi.
13  * Copyright (C) 2001-2002 Benjamin Herrenschmidt
14  * Copyright (C) 2006-2007 Johannes Berg
15  *
16  * THIS DRIVER IS BECOMING A TOTAL MESS !
17  *  - Cleanup atomically disabling reply to PMU events after
18  *    a sleep or a freq. switch
19  *
20  */
21 #include <linux/stdarg.h>
22 #include <linux/mutex.h>
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/kernel.h>
26 #include <linux/delay.h>
27 #include <linux/sched/signal.h>
28 #include <linux/miscdevice.h>
29 #include <linux/blkdev.h>
30 #include <linux/pci.h>
31 #include <linux/slab.h>
32 #include <linux/poll.h>
33 #include <linux/adb.h>
34 #include <linux/pmu.h>
35 #include <linux/cuda.h>
36 #include <linux/module.h>
37 #include <linux/spinlock.h>
38 #include <linux/pm.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
41 #include <linux/init.h>
42 #include <linux/interrupt.h>
43 #include <linux/device.h>
44 #include <linux/syscore_ops.h>
45 #include <linux/freezer.h>
46 #include <linux/syscalls.h>
47 #include <linux/suspend.h>
48 #include <linux/cpu.h>
49 #include <linux/compat.h>
50 #include <linux/of_address.h>
51 #include <linux/of_irq.h>
52 #include <linux/uaccess.h>
53 #include <linux/pgtable.h>
54 #include <asm/machdep.h>
55 #include <asm/io.h>
56 #include <asm/sections.h>
57 #include <asm/irq.h>
58 #ifdef CONFIG_PPC_PMAC
59 #include <asm/pmac_feature.h>
60 #include <asm/pmac_pfunc.h>
61 #include <asm/pmac_low_i2c.h>
62 #include <asm/mmu_context.h>
63 #include <asm/cputable.h>
64 #include <asm/time.h>
65 #include <asm/backlight.h>
66 #else
67 #include <asm/macintosh.h>
68 #include <asm/macints.h>
69 #include <asm/mac_via.h>
70 #endif
71 
72 #include "via-pmu-event.h"
73 
74 /* Some compile options */
75 #undef DEBUG_SLEEP
76 
77 /* How many iterations between battery polls */
78 #define BATTERY_POLLING_COUNT	2
79 
80 static DEFINE_MUTEX(pmu_info_proc_mutex);
81 
82 /* VIA registers - spaced 0x200 bytes apart */
83 #define RS		0x200		/* skip between registers */
84 #define B		0		/* B-side data */
85 #define A		RS		/* A-side data */
86 #define DIRB		(2*RS)		/* B-side direction (1=output) */
87 #define DIRA		(3*RS)		/* A-side direction (1=output) */
88 #define T1CL		(4*RS)		/* Timer 1 ctr/latch (low 8 bits) */
89 #define T1CH		(5*RS)		/* Timer 1 counter (high 8 bits) */
90 #define T1LL		(6*RS)		/* Timer 1 latch (low 8 bits) */
91 #define T1LH		(7*RS)		/* Timer 1 latch (high 8 bits) */
92 #define T2CL		(8*RS)		/* Timer 2 ctr/latch (low 8 bits) */
93 #define T2CH		(9*RS)		/* Timer 2 counter (high 8 bits) */
94 #define SR		(10*RS)		/* Shift register */
95 #define ACR		(11*RS)		/* Auxiliary control register */
96 #define PCR		(12*RS)		/* Peripheral control register */
97 #define IFR		(13*RS)		/* Interrupt flag register */
98 #define IER		(14*RS)		/* Interrupt enable register */
99 #define ANH		(15*RS)		/* A-side data, no handshake */
100 
101 /* Bits in B data register: both active low */
102 #ifdef CONFIG_PPC_PMAC
103 #define TACK		0x08		/* Transfer acknowledge (input) */
104 #define TREQ		0x10		/* Transfer request (output) */
105 #else
106 #define TACK		0x02
107 #define TREQ		0x04
108 #endif
109 
110 /* Bits in ACR */
111 #define SR_CTRL		0x1c		/* Shift register control bits */
112 #define SR_EXT		0x0c		/* Shift on external clock */
113 #define SR_OUT		0x10		/* Shift out if 1 */
114 
115 /* Bits in IFR and IER */
116 #define IER_SET		0x80		/* set bits in IER */
117 #define IER_CLR		0		/* clear bits in IER */
118 #define SR_INT		0x04		/* Shift register full/empty */
119 #define CB2_INT		0x08
120 #define CB1_INT		0x10		/* transition on CB1 input */
121 
122 static volatile enum pmu_state {
123 	uninitialized = 0,
124 	idle,
125 	sending,
126 	intack,
127 	reading,
128 	reading_intr,
129 	locked,
130 } pmu_state;
131 
132 static volatile enum int_data_state {
133 	int_data_empty,
134 	int_data_fill,
135 	int_data_ready,
136 	int_data_flush
137 } int_data_state[2] = { int_data_empty, int_data_empty };
138 
139 static struct adb_request *current_req;
140 static struct adb_request *last_req;
141 static struct adb_request *req_awaiting_reply;
142 static unsigned char interrupt_data[2][32];
143 static int interrupt_data_len[2];
144 static int int_data_last;
145 static unsigned char *reply_ptr;
146 static int data_index;
147 static int data_len;
148 static volatile int adb_int_pending;
149 static volatile int disable_poll;
150 static int pmu_kind = PMU_UNKNOWN;
151 static int pmu_fully_inited;
152 static int pmu_has_adb;
153 #ifdef CONFIG_PPC_PMAC
154 static volatile unsigned char __iomem *via1;
155 static volatile unsigned char __iomem *via2;
156 static struct device_node *vias;
157 static struct device_node *gpio_node;
158 #endif
159 static unsigned char __iomem *gpio_reg;
160 static int gpio_irq = 0;
161 static int gpio_irq_enabled = -1;
162 static volatile int pmu_suspended;
163 static DEFINE_SPINLOCK(pmu_lock);
164 static u8 pmu_intr_mask;
165 static int pmu_version;
166 static int drop_interrupts;
167 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
168 static int option_lid_wakeup = 1;
169 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
170 static unsigned long async_req_locks;
171 
172 #define NUM_IRQ_STATS 13
173 static unsigned int pmu_irq_stats[NUM_IRQ_STATS];
174 
175 static struct proc_dir_entry *proc_pmu_root;
176 static struct proc_dir_entry *proc_pmu_info;
177 static struct proc_dir_entry *proc_pmu_irqstats;
178 static struct proc_dir_entry *proc_pmu_options;
179 static int option_server_mode;
180 
181 int pmu_battery_count;
182 static int pmu_cur_battery;
183 unsigned int pmu_power_flags = PMU_PWR_AC_PRESENT;
184 struct pmu_battery_info pmu_batteries[PMU_MAX_BATTERIES];
185 static int query_batt_timer = BATTERY_POLLING_COUNT;
186 static struct adb_request batt_req;
187 static struct proc_dir_entry *proc_pmu_batt[PMU_MAX_BATTERIES];
188 
189 int asleep;
190 
191 #ifdef CONFIG_ADB
192 static int adb_dev_map;
193 static int pmu_adb_flags;
194 
195 static int pmu_probe(void);
196 static int pmu_init(void);
197 static int pmu_send_request(struct adb_request *req, int sync);
198 static int pmu_adb_autopoll(int devs);
199 static int pmu_adb_reset_bus(void);
200 #endif /* CONFIG_ADB */
201 
202 static int init_pmu(void);
203 static void pmu_start(void);
204 static irqreturn_t via_pmu_interrupt(int irq, void *arg);
205 static irqreturn_t gpio1_interrupt(int irq, void *arg);
206 static int pmu_info_proc_show(struct seq_file *m, void *v);
207 static int pmu_irqstats_proc_show(struct seq_file *m, void *v);
208 static int pmu_battery_proc_show(struct seq_file *m, void *v);
209 static void pmu_pass_intr(unsigned char *data, int len);
210 static const struct proc_ops pmu_options_proc_ops;
211 
212 #ifdef CONFIG_ADB
213 const struct adb_driver via_pmu_driver = {
214 	.name         = "PMU",
215 	.probe        = pmu_probe,
216 	.init         = pmu_init,
217 	.send_request = pmu_send_request,
218 	.autopoll     = pmu_adb_autopoll,
219 	.poll         = pmu_poll_adb,
220 	.reset_bus    = pmu_adb_reset_bus,
221 };
222 #endif /* CONFIG_ADB */
223 
224 extern void low_sleep_handler(void);
225 extern void enable_kernel_altivec(void);
226 extern void enable_kernel_fp(void);
227 
228 #ifdef DEBUG_SLEEP
229 int pmu_polled_request(struct adb_request *req);
230 void pmu_blink(int n);
231 #endif
232 
233 /*
234  * This table indicates for each PMU opcode:
235  * - the number of data bytes to be sent with the command, or -1
236  *   if a length byte should be sent,
237  * - the number of response bytes which the PMU will return, or
238  *   -1 if it will send a length byte.
239  */
240 static const s8 pmu_data_len[256][2] = {
241 /*	   0	   1	   2	   3	   4	   5	   6	   7  */
242 /*00*/	{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
243 /*08*/	{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
244 /*10*/	{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
245 /*18*/	{ 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0, 0},
246 /*20*/	{-1, 0},{ 0, 0},{ 2, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},
247 /*28*/	{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0,-1},
248 /*30*/	{ 4, 0},{20, 0},{-1, 0},{ 3, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
249 /*38*/	{ 0, 4},{ 0,20},{ 2,-1},{ 2, 1},{ 3,-1},{-1,-1},{-1,-1},{ 4, 0},
250 /*40*/	{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
251 /*48*/	{ 0, 1},{ 0, 1},{-1,-1},{ 1, 0},{ 1, 0},{-1,-1},{-1,-1},{-1,-1},
252 /*50*/	{ 1, 0},{ 0, 0},{ 2, 0},{ 2, 0},{-1, 0},{ 1, 0},{ 3, 0},{ 1, 0},
253 /*58*/	{ 0, 1},{ 1, 0},{ 0, 2},{ 0, 2},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},
254 /*60*/	{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
255 /*68*/	{ 0, 3},{ 0, 3},{ 0, 2},{ 0, 8},{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},
256 /*70*/	{ 1, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
257 /*78*/	{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{ 5, 1},{ 4, 1},{ 4, 1},
258 /*80*/	{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
259 /*88*/	{ 0, 5},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
260 /*90*/	{ 1, 0},{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
261 /*98*/	{ 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
262 /*a0*/	{ 2, 0},{ 2, 0},{ 2, 0},{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},
263 /*a8*/	{ 1, 1},{ 1, 0},{ 3, 0},{ 2, 0},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
264 /*b0*/	{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
265 /*b8*/	{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
266 /*c0*/	{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
267 /*c8*/	{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
268 /*d0*/	{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
269 /*d8*/	{ 1, 1},{ 1, 1},{-1,-1},{-1,-1},{ 0, 1},{ 0,-1},{-1,-1},{-1,-1},
270 /*e0*/	{-1, 0},{ 4, 0},{ 0, 1},{-1, 0},{-1, 0},{ 4, 0},{-1, 0},{-1, 0},
271 /*e8*/	{ 3,-1},{-1,-1},{ 0, 1},{-1,-1},{ 0,-1},{-1,-1},{-1,-1},{ 0, 0},
272 /*f0*/	{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
273 /*f8*/	{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
274 };
275 
276 static char *pbook_type[] = {
277 	"Unknown PowerBook",
278 	"PowerBook 2400/3400/3500(G3)",
279 	"PowerBook G3 Series",
280 	"1999 PowerBook G3",
281 	"Core99"
282 };
283 
find_via_pmu(void)284 int __init find_via_pmu(void)
285 {
286 #ifdef CONFIG_PPC_PMAC
287 	u64 taddr;
288 	const u32 *reg;
289 
290 	if (pmu_state != uninitialized)
291 		return 1;
292 	vias = of_find_node_by_name(NULL, "via-pmu");
293 	if (vias == NULL)
294 		return 0;
295 
296 	reg = of_get_property(vias, "reg", NULL);
297 	if (reg == NULL) {
298 		printk(KERN_ERR "via-pmu: No \"reg\" property !\n");
299 		goto fail;
300 	}
301 	taddr = of_translate_address(vias, reg);
302 	if (taddr == OF_BAD_ADDR) {
303 		printk(KERN_ERR "via-pmu: Can't translate address !\n");
304 		goto fail;
305 	}
306 
307 	pmu_has_adb = 1;
308 
309 	pmu_intr_mask =	PMU_INT_PCEJECT |
310 			PMU_INT_SNDBRT |
311 			PMU_INT_ADB |
312 			PMU_INT_TICK;
313 
314 	if (of_node_name_eq(vias->parent, "ohare") ||
315 	    of_device_is_compatible(vias->parent, "ohare"))
316 		pmu_kind = PMU_OHARE_BASED;
317 	else if (of_device_is_compatible(vias->parent, "paddington"))
318 		pmu_kind = PMU_PADDINGTON_BASED;
319 	else if (of_device_is_compatible(vias->parent, "heathrow"))
320 		pmu_kind = PMU_HEATHROW_BASED;
321 	else if (of_device_is_compatible(vias->parent, "Keylargo")
322 		 || of_device_is_compatible(vias->parent, "K2-Keylargo")) {
323 		struct device_node *gpiop;
324 		struct device_node *adbp;
325 		u64 gaddr = OF_BAD_ADDR;
326 
327 		pmu_kind = PMU_KEYLARGO_BASED;
328 		adbp = of_find_node_by_type(NULL, "adb");
329 		pmu_has_adb = (adbp != NULL);
330 		of_node_put(adbp);
331 		pmu_intr_mask =	PMU_INT_PCEJECT |
332 				PMU_INT_SNDBRT |
333 				PMU_INT_ADB |
334 				PMU_INT_TICK |
335 				PMU_INT_ENVIRONMENT;
336 
337 		gpiop = of_find_node_by_name(NULL, "gpio");
338 		if (gpiop) {
339 			reg = of_get_property(gpiop, "reg", NULL);
340 			if (reg)
341 				gaddr = of_translate_address(gpiop, reg);
342 			if (gaddr != OF_BAD_ADDR)
343 				gpio_reg = ioremap(gaddr, 0x10);
344 			of_node_put(gpiop);
345 		}
346 		if (gpio_reg == NULL) {
347 			printk(KERN_ERR "via-pmu: Can't find GPIO reg !\n");
348 			goto fail;
349 		}
350 	} else
351 		pmu_kind = PMU_UNKNOWN;
352 
353 	via1 = via2 = ioremap(taddr, 0x2000);
354 	if (via1 == NULL) {
355 		printk(KERN_ERR "via-pmu: Can't map address !\n");
356 		goto fail_via_remap;
357 	}
358 
359 	out_8(&via1[IER], IER_CLR | 0x7f);	/* disable all intrs */
360 	out_8(&via1[IFR], 0x7f);			/* clear IFR */
361 
362 	pmu_state = idle;
363 
364 	if (!init_pmu())
365 		goto fail_init;
366 
367 	sys_ctrler = SYS_CTRLER_PMU;
368 
369 	return 1;
370 
371  fail_init:
372 	iounmap(via1);
373 	via1 = via2 = NULL;
374  fail_via_remap:
375 	iounmap(gpio_reg);
376 	gpio_reg = NULL;
377  fail:
378 	of_node_put(vias);
379 	vias = NULL;
380 	pmu_state = uninitialized;
381 	return 0;
382 #else
383 	if (macintosh_config->adb_type != MAC_ADB_PB2)
384 		return 0;
385 
386 	pmu_kind = PMU_UNKNOWN;
387 
388 	pmu_has_adb = 1;
389 
390 	pmu_intr_mask =	PMU_INT_PCEJECT |
391 			PMU_INT_SNDBRT |
392 			PMU_INT_ADB |
393 			PMU_INT_TICK;
394 
395 	pmu_state = idle;
396 
397 	if (!init_pmu()) {
398 		pmu_state = uninitialized;
399 		return 0;
400 	}
401 
402 	return 1;
403 #endif /* !CONFIG_PPC_PMAC */
404 }
405 
406 #ifdef CONFIG_ADB
pmu_probe(void)407 static int pmu_probe(void)
408 {
409 	return pmu_state == uninitialized ? -ENODEV : 0;
410 }
411 
pmu_init(void)412 static int pmu_init(void)
413 {
414 	return pmu_state == uninitialized ? -ENODEV : 0;
415 }
416 #endif /* CONFIG_ADB */
417 
418 /*
419  * We can't wait until pmu_init gets called, that happens too late.
420  * It happens after IDE and SCSI initialization, which can take a few
421  * seconds, and by that time the PMU could have given up on us and
422  * turned us off.
423  * Thus this is called with arch_initcall rather than device_initcall.
424  */
via_pmu_start(void)425 static int __init via_pmu_start(void)
426 {
427 	unsigned int __maybe_unused irq;
428 
429 	if (pmu_state == uninitialized)
430 		return -ENODEV;
431 
432 	batt_req.complete = 1;
433 
434 #ifdef CONFIG_PPC_PMAC
435 	irq = irq_of_parse_and_map(vias, 0);
436 	if (!irq) {
437 		printk(KERN_ERR "via-pmu: can't map interrupt\n");
438 		return -ENODEV;
439 	}
440 	/* We set IRQF_NO_SUSPEND because we don't want the interrupt
441 	 * to be disabled between the 2 passes of driver suspend, we
442 	 * control our own disabling for that one
443 	 */
444 	if (request_irq(irq, via_pmu_interrupt, IRQF_NO_SUSPEND,
445 			"VIA-PMU", (void *)0)) {
446 		printk(KERN_ERR "via-pmu: can't request irq %d\n", irq);
447 		return -ENODEV;
448 	}
449 
450 	if (pmu_kind == PMU_KEYLARGO_BASED) {
451 		gpio_node = of_find_node_by_name(NULL, "extint-gpio1");
452 		if (gpio_node == NULL)
453 			gpio_node = of_find_node_by_name(NULL,
454 							 "pmu-interrupt");
455 		if (gpio_node)
456 			gpio_irq = irq_of_parse_and_map(gpio_node, 0);
457 
458 		if (gpio_irq) {
459 			if (request_irq(gpio_irq, gpio1_interrupt,
460 					IRQF_NO_SUSPEND, "GPIO1 ADB",
461 					(void *)0))
462 				printk(KERN_ERR "pmu: can't get irq %d"
463 				       " (GPIO1)\n", gpio_irq);
464 			else
465 				gpio_irq_enabled = 1;
466 		}
467 	}
468 
469 	/* Enable interrupts */
470 	out_8(&via1[IER], IER_SET | SR_INT | CB1_INT);
471 #else
472 	if (request_irq(IRQ_MAC_ADB_SR, via_pmu_interrupt, IRQF_NO_SUSPEND,
473 			"VIA-PMU-SR", NULL)) {
474 		pr_err("%s: couldn't get SR irq\n", __func__);
475 		return -ENODEV;
476 	}
477 	if (request_irq(IRQ_MAC_ADB_CL, via_pmu_interrupt, IRQF_NO_SUSPEND,
478 			"VIA-PMU-CL", NULL)) {
479 		pr_err("%s: couldn't get CL irq\n", __func__);
480 		free_irq(IRQ_MAC_ADB_SR, NULL);
481 		return -ENODEV;
482 	}
483 #endif /* !CONFIG_PPC_PMAC */
484 
485 	pmu_fully_inited = 1;
486 
487 	/* Make sure PMU settle down before continuing. This is _very_ important
488 	 * since the IDE probe may shut interrupts down for quite a bit of time. If
489 	 * a PMU communication is pending while this happens, the PMU may timeout
490 	 * Not that on Core99 machines, the PMU keeps sending us environement
491 	 * messages, we should find a way to either fix IDE or make it call
492 	 * pmu_suspend() before masking interrupts. This can also happens while
493 	 * scolling with some fbdevs.
494 	 */
495 	do {
496 		pmu_poll();
497 	} while (pmu_state != idle);
498 
499 	return 0;
500 }
501 
502 arch_initcall(via_pmu_start);
503 
504 /*
505  * This has to be done after pci_init, which is a subsys_initcall.
506  */
via_pmu_dev_init(void)507 static int __init via_pmu_dev_init(void)
508 {
509 	if (pmu_state == uninitialized)
510 		return -ENODEV;
511 
512 #ifdef CONFIG_PMAC_BACKLIGHT
513 	/* Initialize backlight */
514 	pmu_backlight_init();
515 #endif
516 
517 #ifdef CONFIG_PPC32
518   	if (of_machine_is_compatible("AAPL,3400/2400") ||
519   		of_machine_is_compatible("AAPL,3500")) {
520 		int mb = pmac_call_feature(PMAC_FTR_GET_MB_INFO,
521 			NULL, PMAC_MB_INFO_MODEL, 0);
522 		pmu_battery_count = 1;
523 		if (mb == PMAC_TYPE_COMET)
524 			pmu_batteries[0].flags |= PMU_BATT_TYPE_COMET;
525 		else
526 			pmu_batteries[0].flags |= PMU_BATT_TYPE_HOOPER;
527 	} else if (of_machine_is_compatible("AAPL,PowerBook1998") ||
528 		of_machine_is_compatible("PowerBook1,1")) {
529 		pmu_battery_count = 2;
530 		pmu_batteries[0].flags |= PMU_BATT_TYPE_SMART;
531 		pmu_batteries[1].flags |= PMU_BATT_TYPE_SMART;
532 	} else {
533 		struct device_node* prim =
534 			of_find_node_by_name(NULL, "power-mgt");
535 		const u32 *prim_info = NULL;
536 		if (prim)
537 			prim_info = of_get_property(prim, "prim-info", NULL);
538 		if (prim_info) {
539 			/* Other stuffs here yet unknown */
540 			pmu_battery_count = (prim_info[6] >> 16) & 0xff;
541 			pmu_batteries[0].flags |= PMU_BATT_TYPE_SMART;
542 			if (pmu_battery_count > 1)
543 				pmu_batteries[1].flags |= PMU_BATT_TYPE_SMART;
544 		}
545 		of_node_put(prim);
546 	}
547 #endif /* CONFIG_PPC32 */
548 
549 	/* Create /proc/pmu */
550 	proc_pmu_root = proc_mkdir("pmu", NULL);
551 	if (proc_pmu_root) {
552 		long i;
553 
554 		for (i=0; i<pmu_battery_count; i++) {
555 			char title[16];
556 			sprintf(title, "battery_%ld", i);
557 			proc_pmu_batt[i] = proc_create_single_data(title, 0,
558 					proc_pmu_root, pmu_battery_proc_show,
559 					(void *)i);
560 		}
561 
562 		proc_pmu_info = proc_create_single("info", 0, proc_pmu_root,
563 				pmu_info_proc_show);
564 		proc_pmu_irqstats = proc_create_single("interrupts", 0,
565 				proc_pmu_root, pmu_irqstats_proc_show);
566 		proc_pmu_options = proc_create("options", 0600, proc_pmu_root,
567 						&pmu_options_proc_ops);
568 	}
569 	return 0;
570 }
571 
572 device_initcall(via_pmu_dev_init);
573 
574 static int
init_pmu(void)575 init_pmu(void)
576 {
577 	int timeout;
578 	struct adb_request req;
579 
580 	/* Negate TREQ. Set TACK to input and TREQ to output. */
581 	out_8(&via2[B], in_8(&via2[B]) | TREQ);
582 	out_8(&via2[DIRB], (in_8(&via2[DIRB]) | TREQ) & ~TACK);
583 
584 	pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
585 	timeout =  100000;
586 	while (!req.complete) {
587 		if (--timeout < 0) {
588 			printk(KERN_ERR "init_pmu: no response from PMU\n");
589 			return 0;
590 		}
591 		udelay(10);
592 		pmu_poll();
593 	}
594 
595 	/* ack all pending interrupts */
596 	timeout = 100000;
597 	interrupt_data[0][0] = 1;
598 	while (interrupt_data[0][0] || pmu_state != idle) {
599 		if (--timeout < 0) {
600 			printk(KERN_ERR "init_pmu: timed out acking intrs\n");
601 			return 0;
602 		}
603 		if (pmu_state == idle)
604 			adb_int_pending = 1;
605 		via_pmu_interrupt(0, NULL);
606 		udelay(10);
607 	}
608 
609 	/* Tell PMU we are ready.  */
610 	if (pmu_kind == PMU_KEYLARGO_BASED) {
611 		pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
612 		while (!req.complete)
613 			pmu_poll();
614 	}
615 
616 	/* Read PMU version */
617 	pmu_request(&req, NULL, 1, PMU_GET_VERSION);
618 	pmu_wait_complete(&req);
619 	if (req.reply_len > 0)
620 		pmu_version = req.reply[0];
621 
622 	/* Read server mode setting */
623 	if (pmu_kind == PMU_KEYLARGO_BASED) {
624 		pmu_request(&req, NULL, 2, PMU_POWER_EVENTS,
625 			    PMU_PWR_GET_POWERUP_EVENTS);
626 		pmu_wait_complete(&req);
627 		if (req.reply_len == 2) {
628 			if (req.reply[1] & PMU_PWR_WAKEUP_AC_INSERT)
629 				option_server_mode = 1;
630 			printk(KERN_INFO "via-pmu: Server Mode is %s\n",
631 			       option_server_mode ? "enabled" : "disabled");
632 		}
633 	}
634 
635 	printk(KERN_INFO "PMU driver v%d initialized for %s, firmware: %02x\n",
636 	       PMU_DRIVER_VERSION, pbook_type[pmu_kind], pmu_version);
637 
638 	return 1;
639 }
640 
641 int
pmu_get_model(void)642 pmu_get_model(void)
643 {
644 	return pmu_kind;
645 }
646 
pmu_set_server_mode(int server_mode)647 static void pmu_set_server_mode(int server_mode)
648 {
649 	struct adb_request req;
650 
651 	if (pmu_kind != PMU_KEYLARGO_BASED)
652 		return;
653 
654 	option_server_mode = server_mode;
655 	pmu_request(&req, NULL, 2, PMU_POWER_EVENTS, PMU_PWR_GET_POWERUP_EVENTS);
656 	pmu_wait_complete(&req);
657 	if (req.reply_len < 2)
658 		return;
659 	if (server_mode)
660 		pmu_request(&req, NULL, 4, PMU_POWER_EVENTS,
661 			    PMU_PWR_SET_POWERUP_EVENTS,
662 			    req.reply[0], PMU_PWR_WAKEUP_AC_INSERT);
663 	else
664 		pmu_request(&req, NULL, 4, PMU_POWER_EVENTS,
665 			    PMU_PWR_CLR_POWERUP_EVENTS,
666 			    req.reply[0], PMU_PWR_WAKEUP_AC_INSERT);
667 	pmu_wait_complete(&req);
668 }
669 
670 /* This new version of the code for 2400/3400/3500 powerbooks
671  * is inspired from the implementation in gkrellm-pmu
672  */
673 static void
done_battery_state_ohare(struct adb_request * req)674 done_battery_state_ohare(struct adb_request* req)
675 {
676 #ifdef CONFIG_PPC_PMAC
677 	/* format:
678 	 *  [0]    :  flags
679 	 *    0x01 :  AC indicator
680 	 *    0x02 :  charging
681 	 *    0x04 :  battery exist
682 	 *    0x08 :
683 	 *    0x10 :
684 	 *    0x20 :  full charged
685 	 *    0x40 :  pcharge reset
686 	 *    0x80 :  battery exist
687 	 *
688 	 *  [1][2] :  battery voltage
689 	 *  [3]    :  CPU temperature
690 	 *  [4]    :  battery temperature
691 	 *  [5]    :  current
692 	 *  [6][7] :  pcharge
693 	 *              --tkoba
694 	 */
695 	unsigned int bat_flags = PMU_BATT_TYPE_HOOPER;
696 	long pcharge, charge, vb, vmax, lmax;
697 	long vmax_charging, vmax_charged;
698 	long amperage, voltage, time, max;
699 	int mb = pmac_call_feature(PMAC_FTR_GET_MB_INFO,
700 			NULL, PMAC_MB_INFO_MODEL, 0);
701 
702 	if (req->reply[0] & 0x01)
703 		pmu_power_flags |= PMU_PWR_AC_PRESENT;
704 	else
705 		pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
706 
707 	if (mb == PMAC_TYPE_COMET) {
708 		vmax_charged = 189;
709 		vmax_charging = 213;
710 		lmax = 6500;
711 	} else {
712 		vmax_charged = 330;
713 		vmax_charging = 330;
714 		lmax = 6500;
715 	}
716 	vmax = vmax_charged;
717 
718 	/* If battery installed */
719 	if (req->reply[0] & 0x04) {
720 		bat_flags |= PMU_BATT_PRESENT;
721 		if (req->reply[0] & 0x02)
722 			bat_flags |= PMU_BATT_CHARGING;
723 		vb = (req->reply[1] << 8) | req->reply[2];
724 		voltage = (vb * 265 + 72665) / 10;
725 		amperage = req->reply[5];
726 		if ((req->reply[0] & 0x01) == 0) {
727 			if (amperage > 200)
728 				vb += ((amperage - 200) * 15)/100;
729 		} else if (req->reply[0] & 0x02) {
730 			vb = (vb * 97) / 100;
731 			vmax = vmax_charging;
732 		}
733 		charge = (100 * vb) / vmax;
734 		if (req->reply[0] & 0x40) {
735 			pcharge = (req->reply[6] << 8) + req->reply[7];
736 			if (pcharge > lmax)
737 				pcharge = lmax;
738 			pcharge *= 100;
739 			pcharge = 100 - pcharge / lmax;
740 			if (pcharge < charge)
741 				charge = pcharge;
742 		}
743 		if (amperage > 0)
744 			time = (charge * 16440) / amperage;
745 		else
746 			time = 0;
747 		max = 100;
748 		amperage = -amperage;
749 	} else
750 		charge = max = amperage = voltage = time = 0;
751 
752 	pmu_batteries[pmu_cur_battery].flags = bat_flags;
753 	pmu_batteries[pmu_cur_battery].charge = charge;
754 	pmu_batteries[pmu_cur_battery].max_charge = max;
755 	pmu_batteries[pmu_cur_battery].amperage = amperage;
756 	pmu_batteries[pmu_cur_battery].voltage = voltage;
757 	pmu_batteries[pmu_cur_battery].time_remaining = time;
758 #endif /* CONFIG_PPC_PMAC */
759 
760 	clear_bit(0, &async_req_locks);
761 }
762 
763 static void
done_battery_state_smart(struct adb_request * req)764 done_battery_state_smart(struct adb_request* req)
765 {
766 	/* format:
767 	 *  [0] : format of this structure (known: 3,4,5)
768 	 *  [1] : flags
769 	 *
770 	 *  format 3 & 4:
771 	 *
772 	 *  [2] : charge
773 	 *  [3] : max charge
774 	 *  [4] : current
775 	 *  [5] : voltage
776 	 *
777 	 *  format 5:
778 	 *
779 	 *  [2][3] : charge
780 	 *  [4][5] : max charge
781 	 *  [6][7] : current
782 	 *  [8][9] : voltage
783 	 */
784 
785 	unsigned int bat_flags = PMU_BATT_TYPE_SMART;
786 	int amperage;
787 	unsigned int capa, max, voltage;
788 
789 	if (req->reply[1] & 0x01)
790 		pmu_power_flags |= PMU_PWR_AC_PRESENT;
791 	else
792 		pmu_power_flags &= ~PMU_PWR_AC_PRESENT;
793 
794 
795 	capa = max = amperage = voltage = 0;
796 
797 	if (req->reply[1] & 0x04) {
798 		bat_flags |= PMU_BATT_PRESENT;
799 		switch(req->reply[0]) {
800 			case 3:
801 			case 4: capa = req->reply[2];
802 				max = req->reply[3];
803 				amperage = *((signed char *)&req->reply[4]);
804 				voltage = req->reply[5];
805 				break;
806 			case 5: capa = (req->reply[2] << 8) | req->reply[3];
807 				max = (req->reply[4] << 8) | req->reply[5];
808 				amperage = *((signed short *)&req->reply[6]);
809 				voltage = (req->reply[8] << 8) | req->reply[9];
810 				break;
811 			default:
812 				pr_warn("pmu.c: unrecognized battery info, "
813 					"len: %d, %4ph\n", req->reply_len,
814 							   req->reply);
815 				break;
816 		}
817 	}
818 
819 	if ((req->reply[1] & 0x01) && (amperage > 0))
820 		bat_flags |= PMU_BATT_CHARGING;
821 
822 	pmu_batteries[pmu_cur_battery].flags = bat_flags;
823 	pmu_batteries[pmu_cur_battery].charge = capa;
824 	pmu_batteries[pmu_cur_battery].max_charge = max;
825 	pmu_batteries[pmu_cur_battery].amperage = amperage;
826 	pmu_batteries[pmu_cur_battery].voltage = voltage;
827 	if (amperage) {
828 		if ((req->reply[1] & 0x01) && (amperage > 0))
829 			pmu_batteries[pmu_cur_battery].time_remaining
830 				= ((max-capa) * 3600) / amperage;
831 		else
832 			pmu_batteries[pmu_cur_battery].time_remaining
833 				= (capa * 3600) / (-amperage);
834 	} else
835 		pmu_batteries[pmu_cur_battery].time_remaining = 0;
836 
837 	pmu_cur_battery = (pmu_cur_battery + 1) % pmu_battery_count;
838 
839 	clear_bit(0, &async_req_locks);
840 }
841 
842 static void
query_battery_state(void)843 query_battery_state(void)
844 {
845 	if (test_and_set_bit(0, &async_req_locks))
846 		return;
847 	if (pmu_kind == PMU_OHARE_BASED)
848 		pmu_request(&batt_req, done_battery_state_ohare,
849 			1, PMU_BATTERY_STATE);
850 	else
851 		pmu_request(&batt_req, done_battery_state_smart,
852 			2, PMU_SMART_BATTERY_STATE, pmu_cur_battery+1);
853 }
854 
pmu_info_proc_show(struct seq_file * m,void * v)855 static int pmu_info_proc_show(struct seq_file *m, void *v)
856 {
857 	seq_printf(m, "PMU driver version     : %d\n", PMU_DRIVER_VERSION);
858 	seq_printf(m, "PMU firmware version   : %02x\n", pmu_version);
859 	seq_printf(m, "AC Power               : %d\n",
860 		((pmu_power_flags & PMU_PWR_AC_PRESENT) != 0) || pmu_battery_count == 0);
861 	seq_printf(m, "Battery count          : %d\n", pmu_battery_count);
862 
863 	return 0;
864 }
865 
pmu_irqstats_proc_show(struct seq_file * m,void * v)866 static int pmu_irqstats_proc_show(struct seq_file *m, void *v)
867 {
868 	int i;
869 	static const char *irq_names[NUM_IRQ_STATS] = {
870 		"Unknown interrupt (type 0)",
871 		"Unknown interrupt (type 1)",
872 		"PC-Card eject button",
873 		"Sound/Brightness button",
874 		"ADB message",
875 		"Battery state change",
876 		"Environment interrupt",
877 		"Tick timer",
878 		"Ghost interrupt (zero len)",
879 		"Empty interrupt (empty mask)",
880 		"Max irqs in a row",
881 		"Total CB1 triggered events",
882 		"Total GPIO1 triggered events",
883         };
884 
885 	for (i = 0; i < NUM_IRQ_STATS; i++) {
886 		seq_printf(m, " %2u: %10u (%s)\n",
887 			     i, pmu_irq_stats[i], irq_names[i]);
888 	}
889 	return 0;
890 }
891 
pmu_battery_proc_show(struct seq_file * m,void * v)892 static int pmu_battery_proc_show(struct seq_file *m, void *v)
893 {
894 	long batnum = (long)m->private;
895 
896 	seq_putc(m, '\n');
897 	seq_printf(m, "flags      : %08x\n", pmu_batteries[batnum].flags);
898 	seq_printf(m, "charge     : %d\n", pmu_batteries[batnum].charge);
899 	seq_printf(m, "max_charge : %d\n", pmu_batteries[batnum].max_charge);
900 	seq_printf(m, "current    : %d\n", pmu_batteries[batnum].amperage);
901 	seq_printf(m, "voltage    : %d\n", pmu_batteries[batnum].voltage);
902 	seq_printf(m, "time rem.  : %d\n", pmu_batteries[batnum].time_remaining);
903 	return 0;
904 }
905 
pmu_options_proc_show(struct seq_file * m,void * v)906 static int pmu_options_proc_show(struct seq_file *m, void *v)
907 {
908 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
909 	if (pmu_kind == PMU_KEYLARGO_BASED &&
910 	    pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,-1) >= 0)
911 		seq_printf(m, "lid_wakeup=%d\n", option_lid_wakeup);
912 #endif
913 	if (pmu_kind == PMU_KEYLARGO_BASED)
914 		seq_printf(m, "server_mode=%d\n", option_server_mode);
915 
916 	return 0;
917 }
918 
pmu_options_proc_open(struct inode * inode,struct file * file)919 static int pmu_options_proc_open(struct inode *inode, struct file *file)
920 {
921 	return single_open(file, pmu_options_proc_show, NULL);
922 }
923 
pmu_options_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos)924 static ssize_t pmu_options_proc_write(struct file *file,
925 		const char __user *buffer, size_t count, loff_t *pos)
926 {
927 	char tmp[33];
928 	char *label, *val;
929 	size_t fcount = count;
930 
931 	if (!count)
932 		return -EINVAL;
933 	if (count > 32)
934 		count = 32;
935 	if (copy_from_user(tmp, buffer, count))
936 		return -EFAULT;
937 	tmp[count] = 0;
938 
939 	label = tmp;
940 	while(*label == ' ')
941 		label++;
942 	val = label;
943 	while(*val && (*val != '=')) {
944 		if (*val == ' ')
945 			*val = 0;
946 		val++;
947 	}
948 	if ((*val) == 0)
949 		return -EINVAL;
950 	*(val++) = 0;
951 	while(*val == ' ')
952 		val++;
953 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
954 	if (pmu_kind == PMU_KEYLARGO_BASED &&
955 	    pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,-1) >= 0)
956 		if (!strcmp(label, "lid_wakeup"))
957 			option_lid_wakeup = ((*val) == '1');
958 #endif
959 	if (pmu_kind == PMU_KEYLARGO_BASED && !strcmp(label, "server_mode")) {
960 		int new_value;
961 		new_value = ((*val) == '1');
962 		if (new_value != option_server_mode)
963 			pmu_set_server_mode(new_value);
964 	}
965 	return fcount;
966 }
967 
968 static const struct proc_ops pmu_options_proc_ops = {
969 	.proc_open	= pmu_options_proc_open,
970 	.proc_read	= seq_read,
971 	.proc_lseek	= seq_lseek,
972 	.proc_release	= single_release,
973 	.proc_write	= pmu_options_proc_write,
974 };
975 
976 #ifdef CONFIG_ADB
977 /* Send an ADB command */
pmu_send_request(struct adb_request * req,int sync)978 static int pmu_send_request(struct adb_request *req, int sync)
979 {
980 	int i, ret;
981 
982 	if (pmu_state == uninitialized || !pmu_fully_inited) {
983 		req->complete = 1;
984 		return -ENXIO;
985 	}
986 
987 	ret = -EINVAL;
988 
989 	switch (req->data[0]) {
990 	case PMU_PACKET:
991 		for (i = 0; i < req->nbytes - 1; ++i)
992 			req->data[i] = req->data[i+1];
993 		--req->nbytes;
994 		if (pmu_data_len[req->data[0]][1] != 0) {
995 			req->reply[0] = ADB_RET_OK;
996 			req->reply_len = 1;
997 		} else
998 			req->reply_len = 0;
999 		ret = pmu_queue_request(req);
1000 		break;
1001 	case CUDA_PACKET:
1002 		switch (req->data[1]) {
1003 		case CUDA_GET_TIME:
1004 			if (req->nbytes != 2)
1005 				break;
1006 			req->data[0] = PMU_READ_RTC;
1007 			req->nbytes = 1;
1008 			req->reply_len = 3;
1009 			req->reply[0] = CUDA_PACKET;
1010 			req->reply[1] = 0;
1011 			req->reply[2] = CUDA_GET_TIME;
1012 			ret = pmu_queue_request(req);
1013 			break;
1014 		case CUDA_SET_TIME:
1015 			if (req->nbytes != 6)
1016 				break;
1017 			req->data[0] = PMU_SET_RTC;
1018 			req->nbytes = 5;
1019 			for (i = 1; i <= 4; ++i)
1020 				req->data[i] = req->data[i+1];
1021 			req->reply_len = 3;
1022 			req->reply[0] = CUDA_PACKET;
1023 			req->reply[1] = 0;
1024 			req->reply[2] = CUDA_SET_TIME;
1025 			ret = pmu_queue_request(req);
1026 			break;
1027 		}
1028 		break;
1029 	case ADB_PACKET:
1030 	    	if (!pmu_has_adb)
1031     			return -ENXIO;
1032 		for (i = req->nbytes - 1; i > 1; --i)
1033 			req->data[i+2] = req->data[i];
1034 		req->data[3] = req->nbytes - 2;
1035 		req->data[2] = pmu_adb_flags;
1036 		/*req->data[1] = req->data[1];*/
1037 		req->data[0] = PMU_ADB_CMD;
1038 		req->nbytes += 2;
1039 		req->reply_expected = 1;
1040 		req->reply_len = 0;
1041 		ret = pmu_queue_request(req);
1042 		break;
1043 	}
1044 	if (ret) {
1045 		req->complete = 1;
1046 		return ret;
1047 	}
1048 
1049 	if (sync)
1050 		while (!req->complete)
1051 			pmu_poll();
1052 
1053 	return 0;
1054 }
1055 
1056 /* Enable/disable autopolling */
__pmu_adb_autopoll(int devs)1057 static int __pmu_adb_autopoll(int devs)
1058 {
1059 	struct adb_request req;
1060 
1061 	if (devs) {
1062 		pmu_request(&req, NULL, 5, PMU_ADB_CMD, 0, 0x86,
1063 			    adb_dev_map >> 8, adb_dev_map);
1064 		pmu_adb_flags = 2;
1065 	} else {
1066 		pmu_request(&req, NULL, 1, PMU_ADB_POLL_OFF);
1067 		pmu_adb_flags = 0;
1068 	}
1069 	while (!req.complete)
1070 		pmu_poll();
1071 	return 0;
1072 }
1073 
pmu_adb_autopoll(int devs)1074 static int pmu_adb_autopoll(int devs)
1075 {
1076 	if (pmu_state == uninitialized || !pmu_fully_inited || !pmu_has_adb)
1077 		return -ENXIO;
1078 
1079 	adb_dev_map = devs;
1080 	return __pmu_adb_autopoll(devs);
1081 }
1082 
1083 /* Reset the ADB bus */
pmu_adb_reset_bus(void)1084 static int pmu_adb_reset_bus(void)
1085 {
1086 	struct adb_request req;
1087 	int save_autopoll = adb_dev_map;
1088 
1089 	if (pmu_state == uninitialized || !pmu_fully_inited || !pmu_has_adb)
1090 		return -ENXIO;
1091 
1092 	/* anyone got a better idea?? */
1093 	__pmu_adb_autopoll(0);
1094 
1095 	req.nbytes = 4;
1096 	req.done = NULL;
1097 	req.data[0] = PMU_ADB_CMD;
1098 	req.data[1] = ADB_BUSRESET;
1099 	req.data[2] = 0;
1100 	req.data[3] = 0;
1101 	req.data[4] = 0;
1102 	req.reply_len = 0;
1103 	req.reply_expected = 1;
1104 	if (pmu_queue_request(&req) != 0) {
1105 		printk(KERN_ERR "pmu_adb_reset_bus: pmu_queue_request failed\n");
1106 		return -EIO;
1107 	}
1108 	pmu_wait_complete(&req);
1109 
1110 	if (save_autopoll != 0)
1111 		__pmu_adb_autopoll(save_autopoll);
1112 
1113 	return 0;
1114 }
1115 #endif /* CONFIG_ADB */
1116 
1117 /* Construct and send a pmu request */
1118 int
pmu_request(struct adb_request * req,void (* done)(struct adb_request *),int nbytes,...)1119 pmu_request(struct adb_request *req, void (*done)(struct adb_request *),
1120 	    int nbytes, ...)
1121 {
1122 	va_list list;
1123 	int i;
1124 
1125 	if (pmu_state == uninitialized)
1126 		return -ENXIO;
1127 
1128 	if (nbytes < 0 || nbytes > 32) {
1129 		printk(KERN_ERR "pmu_request: bad nbytes (%d)\n", nbytes);
1130 		req->complete = 1;
1131 		return -EINVAL;
1132 	}
1133 	req->nbytes = nbytes;
1134 	req->done = done;
1135 	va_start(list, nbytes);
1136 	for (i = 0; i < nbytes; ++i)
1137 		req->data[i] = va_arg(list, int);
1138 	va_end(list);
1139 	req->reply_len = 0;
1140 	req->reply_expected = 0;
1141 	return pmu_queue_request(req);
1142 }
1143 
1144 int
pmu_queue_request(struct adb_request * req)1145 pmu_queue_request(struct adb_request *req)
1146 {
1147 	unsigned long flags;
1148 	int nsend;
1149 
1150 	if (pmu_state == uninitialized) {
1151 		req->complete = 1;
1152 		return -ENXIO;
1153 	}
1154 	if (req->nbytes <= 0) {
1155 		req->complete = 1;
1156 		return 0;
1157 	}
1158 	nsend = pmu_data_len[req->data[0]][0];
1159 	if (nsend >= 0 && req->nbytes != nsend + 1) {
1160 		req->complete = 1;
1161 		return -EINVAL;
1162 	}
1163 
1164 	req->next = NULL;
1165 	req->sent = 0;
1166 	req->complete = 0;
1167 
1168 	spin_lock_irqsave(&pmu_lock, flags);
1169 	if (current_req) {
1170 		last_req->next = req;
1171 		last_req = req;
1172 	} else {
1173 		current_req = req;
1174 		last_req = req;
1175 		if (pmu_state == idle)
1176 			pmu_start();
1177 	}
1178 	spin_unlock_irqrestore(&pmu_lock, flags);
1179 
1180 	return 0;
1181 }
1182 
1183 static inline void
wait_for_ack(void)1184 wait_for_ack(void)
1185 {
1186 	/* Sightly increased the delay, I had one occurrence of the message
1187 	 * reported
1188 	 */
1189 	int timeout = 4000;
1190 	while ((in_8(&via2[B]) & TACK) == 0) {
1191 		if (--timeout < 0) {
1192 			printk(KERN_ERR "PMU not responding (!ack)\n");
1193 			return;
1194 		}
1195 		udelay(10);
1196 	}
1197 }
1198 
1199 /* New PMU seems to be very sensitive to those timings, so we make sure
1200  * PCI is flushed immediately */
1201 static inline void
send_byte(int x)1202 send_byte(int x)
1203 {
1204 	out_8(&via1[ACR], in_8(&via1[ACR]) | SR_OUT | SR_EXT);
1205 	out_8(&via1[SR], x);
1206 	out_8(&via2[B], in_8(&via2[B]) & ~TREQ);	/* assert TREQ */
1207 	(void)in_8(&via2[B]);
1208 }
1209 
1210 static inline void
recv_byte(void)1211 recv_byte(void)
1212 {
1213 	out_8(&via1[ACR], (in_8(&via1[ACR]) & ~SR_OUT) | SR_EXT);
1214 	in_8(&via1[SR]);		/* resets SR */
1215 	out_8(&via2[B], in_8(&via2[B]) & ~TREQ);
1216 	(void)in_8(&via2[B]);
1217 }
1218 
1219 static inline void
pmu_done(struct adb_request * req)1220 pmu_done(struct adb_request *req)
1221 {
1222 	void (*done)(struct adb_request *) = req->done;
1223 	mb();
1224 	req->complete = 1;
1225     	/* Here, we assume that if the request has a done member, the
1226     	 * struct request will survive to setting req->complete to 1
1227     	 */
1228 	if (done)
1229 		(*done)(req);
1230 }
1231 
1232 static void
pmu_start(void)1233 pmu_start(void)
1234 {
1235 	struct adb_request *req;
1236 
1237 	/* assert pmu_state == idle */
1238 	/* get the packet to send */
1239 	req = current_req;
1240 	if (!req || pmu_state != idle
1241 	    || (/*req->reply_expected && */req_awaiting_reply))
1242 		return;
1243 
1244 	pmu_state = sending;
1245 	data_index = 1;
1246 	data_len = pmu_data_len[req->data[0]][0];
1247 
1248 	/* Sounds safer to make sure ACK is high before writing. This helped
1249 	 * kill a problem with ADB and some iBooks
1250 	 */
1251 	wait_for_ack();
1252 	/* set the shift register to shift out and send a byte */
1253 	send_byte(req->data[0]);
1254 }
1255 
1256 void
pmu_poll(void)1257 pmu_poll(void)
1258 {
1259 	if (pmu_state == uninitialized)
1260 		return;
1261 	if (disable_poll)
1262 		return;
1263 	via_pmu_interrupt(0, NULL);
1264 }
1265 
1266 void
pmu_poll_adb(void)1267 pmu_poll_adb(void)
1268 {
1269 	if (pmu_state == uninitialized)
1270 		return;
1271 	if (disable_poll)
1272 		return;
1273 	/* Kicks ADB read when PMU is suspended */
1274 	adb_int_pending = 1;
1275 	do {
1276 		via_pmu_interrupt(0, NULL);
1277 	} while (pmu_suspended && (adb_int_pending || pmu_state != idle
1278 		|| req_awaiting_reply));
1279 }
1280 
1281 void
pmu_wait_complete(struct adb_request * req)1282 pmu_wait_complete(struct adb_request *req)
1283 {
1284 	if (pmu_state == uninitialized)
1285 		return;
1286 	while((pmu_state != idle && pmu_state != locked) || !req->complete)
1287 		via_pmu_interrupt(0, NULL);
1288 }
1289 
1290 /* This function loops until the PMU is idle and prevents it from
1291  * anwsering to ADB interrupts. pmu_request can still be called.
1292  * This is done to avoid spurrious shutdowns when we know we'll have
1293  * interrupts switched off for a long time
1294  */
1295 void
pmu_suspend(void)1296 pmu_suspend(void)
1297 {
1298 	unsigned long flags;
1299 
1300 	if (pmu_state == uninitialized)
1301 		return;
1302 
1303 	spin_lock_irqsave(&pmu_lock, flags);
1304 	pmu_suspended++;
1305 	if (pmu_suspended > 1) {
1306 		spin_unlock_irqrestore(&pmu_lock, flags);
1307 		return;
1308 	}
1309 
1310 	do {
1311 		spin_unlock_irqrestore(&pmu_lock, flags);
1312 		if (req_awaiting_reply)
1313 			adb_int_pending = 1;
1314 		via_pmu_interrupt(0, NULL);
1315 		spin_lock_irqsave(&pmu_lock, flags);
1316 		if (!adb_int_pending && pmu_state == idle && !req_awaiting_reply) {
1317 			if (gpio_irq >= 0)
1318 				disable_irq_nosync(gpio_irq);
1319 			out_8(&via1[IER], CB1_INT | IER_CLR);
1320 			spin_unlock_irqrestore(&pmu_lock, flags);
1321 			break;
1322 		}
1323 	} while (1);
1324 }
1325 
1326 void
pmu_resume(void)1327 pmu_resume(void)
1328 {
1329 	unsigned long flags;
1330 
1331 	if (pmu_state == uninitialized || pmu_suspended < 1)
1332 		return;
1333 
1334 	spin_lock_irqsave(&pmu_lock, flags);
1335 	pmu_suspended--;
1336 	if (pmu_suspended > 0) {
1337 		spin_unlock_irqrestore(&pmu_lock, flags);
1338 		return;
1339 	}
1340 	adb_int_pending = 1;
1341 	if (gpio_irq >= 0)
1342 		enable_irq(gpio_irq);
1343 	out_8(&via1[IER], CB1_INT | IER_SET);
1344 	spin_unlock_irqrestore(&pmu_lock, flags);
1345 	pmu_poll();
1346 }
1347 
1348 /* Interrupt data could be the result data from an ADB cmd */
1349 static void
pmu_handle_data(unsigned char * data,int len)1350 pmu_handle_data(unsigned char *data, int len)
1351 {
1352 	unsigned char ints;
1353 	int idx;
1354 	int i = 0;
1355 
1356 	asleep = 0;
1357 	if (drop_interrupts || len < 1) {
1358 		adb_int_pending = 0;
1359 		pmu_irq_stats[8]++;
1360 		return;
1361 	}
1362 
1363 	/* Get PMU interrupt mask */
1364 	ints = data[0];
1365 
1366 	/* Record zero interrupts for stats */
1367 	if (ints == 0)
1368 		pmu_irq_stats[9]++;
1369 
1370 	/* Hack to deal with ADB autopoll flag */
1371 	if (ints & PMU_INT_ADB)
1372 		ints &= ~(PMU_INT_ADB_AUTO | PMU_INT_AUTO_SRQ_POLL);
1373 
1374 next:
1375 	if (ints == 0) {
1376 		if (i > pmu_irq_stats[10])
1377 			pmu_irq_stats[10] = i;
1378 		return;
1379 	}
1380 	i++;
1381 
1382 	idx = ffs(ints) - 1;
1383 	ints &= ~BIT(idx);
1384 
1385 	pmu_irq_stats[idx]++;
1386 
1387 	/* Note: for some reason, we get an interrupt with len=1,
1388 	 * data[0]==0 after each normal ADB interrupt, at least
1389 	 * on the Pismo. Still investigating...  --BenH
1390 	 */
1391 	switch (BIT(idx)) {
1392 	case PMU_INT_ADB:
1393 		if ((data[0] & PMU_INT_ADB_AUTO) == 0) {
1394 			struct adb_request *req = req_awaiting_reply;
1395 			if (!req) {
1396 				printk(KERN_ERR "PMU: extra ADB reply\n");
1397 				return;
1398 			}
1399 			req_awaiting_reply = NULL;
1400 			if (len <= 2)
1401 				req->reply_len = 0;
1402 			else {
1403 				memcpy(req->reply, data + 1, len - 1);
1404 				req->reply_len = len - 1;
1405 			}
1406 			pmu_done(req);
1407 		} else {
1408 #ifdef CONFIG_XMON
1409 			if (len == 4 && data[1] == 0x2c) {
1410 				extern int xmon_wants_key, xmon_adb_keycode;
1411 				if (xmon_wants_key) {
1412 					xmon_adb_keycode = data[2];
1413 					return;
1414 				}
1415 			}
1416 #endif /* CONFIG_XMON */
1417 #ifdef CONFIG_ADB
1418 			/*
1419 			 * XXX On the [23]400 the PMU gives us an up
1420 			 * event for keycodes 0x74 or 0x75 when the PC
1421 			 * card eject buttons are released, so we
1422 			 * ignore those events.
1423 			 */
1424 			if (!(pmu_kind == PMU_OHARE_BASED && len == 4
1425 			      && data[1] == 0x2c && data[3] == 0xff
1426 			      && (data[2] & ~1) == 0xf4))
1427 				adb_input(data+1, len-1, 1);
1428 #endif /* CONFIG_ADB */
1429 		}
1430 		break;
1431 
1432 	/* Sound/brightness button pressed */
1433 	case PMU_INT_SNDBRT:
1434 #ifdef CONFIG_PMAC_BACKLIGHT
1435 		if (len == 3)
1436 			pmac_backlight_set_legacy_brightness_pmu(data[1] >> 4);
1437 #endif
1438 		break;
1439 
1440 	/* Tick interrupt */
1441 	case PMU_INT_TICK:
1442 		/* Environment or tick interrupt, query batteries */
1443 		if (pmu_battery_count) {
1444 			if ((--query_batt_timer) == 0) {
1445 				query_battery_state();
1446 				query_batt_timer = BATTERY_POLLING_COUNT;
1447 			}
1448 		}
1449 		break;
1450 
1451 	case PMU_INT_ENVIRONMENT:
1452 		if (pmu_battery_count)
1453 			query_battery_state();
1454 		pmu_pass_intr(data, len);
1455 		/* len == 6 is probably a bad check. But how do I
1456 		 * know what PMU versions send what events here? */
1457 		if (IS_ENABLED(CONFIG_ADB_PMU_EVENT) && len == 6) {
1458 			via_pmu_event(PMU_EVT_POWER, !!(data[1]&8));
1459 			via_pmu_event(PMU_EVT_LID, data[1]&1);
1460 		}
1461 		break;
1462 
1463 	default:
1464 	       pmu_pass_intr(data, len);
1465 	}
1466 	goto next;
1467 }
1468 
1469 static struct adb_request*
pmu_sr_intr(void)1470 pmu_sr_intr(void)
1471 {
1472 	struct adb_request *req;
1473 	int bite = 0;
1474 
1475 	if (in_8(&via2[B]) & TREQ) {
1476 		printk(KERN_ERR "PMU: spurious SR intr (%x)\n", in_8(&via2[B]));
1477 		return NULL;
1478 	}
1479 	/* The ack may not yet be low when we get the interrupt */
1480 	while ((in_8(&via2[B]) & TACK) != 0)
1481 			;
1482 
1483 	/* if reading grab the byte, and reset the interrupt */
1484 	if (pmu_state == reading || pmu_state == reading_intr)
1485 		bite = in_8(&via1[SR]);
1486 
1487 	/* reset TREQ and wait for TACK to go high */
1488 	out_8(&via2[B], in_8(&via2[B]) | TREQ);
1489 	wait_for_ack();
1490 
1491 	switch (pmu_state) {
1492 	case sending:
1493 		req = current_req;
1494 		if (data_len < 0) {
1495 			data_len = req->nbytes - 1;
1496 			send_byte(data_len);
1497 			break;
1498 		}
1499 		if (data_index <= data_len) {
1500 			send_byte(req->data[data_index++]);
1501 			break;
1502 		}
1503 		req->sent = 1;
1504 		data_len = pmu_data_len[req->data[0]][1];
1505 		if (data_len == 0) {
1506 			pmu_state = idle;
1507 			current_req = req->next;
1508 			if (req->reply_expected)
1509 				req_awaiting_reply = req;
1510 			else
1511 				return req;
1512 		} else {
1513 			pmu_state = reading;
1514 			data_index = 0;
1515 			reply_ptr = req->reply + req->reply_len;
1516 			recv_byte();
1517 		}
1518 		break;
1519 
1520 	case intack:
1521 		data_index = 0;
1522 		data_len = -1;
1523 		pmu_state = reading_intr;
1524 		reply_ptr = interrupt_data[int_data_last];
1525 		recv_byte();
1526 		if (gpio_irq >= 0 && !gpio_irq_enabled) {
1527 			enable_irq(gpio_irq);
1528 			gpio_irq_enabled = 1;
1529 		}
1530 		break;
1531 
1532 	case reading:
1533 	case reading_intr:
1534 		if (data_len == -1) {
1535 			data_len = bite;
1536 			if (bite > 32)
1537 				printk(KERN_ERR "PMU: bad reply len %d\n", bite);
1538 		} else if (data_index < 32) {
1539 			reply_ptr[data_index++] = bite;
1540 		}
1541 		if (data_index < data_len) {
1542 			recv_byte();
1543 			break;
1544 		}
1545 
1546 		if (pmu_state == reading_intr) {
1547 			pmu_state = idle;
1548 			int_data_state[int_data_last] = int_data_ready;
1549 			interrupt_data_len[int_data_last] = data_len;
1550 		} else {
1551 			req = current_req;
1552 			/*
1553 			 * For PMU sleep and freq change requests, we lock the
1554 			 * PMU until it's explicitly unlocked. This avoids any
1555 			 * spurrious event polling getting in
1556 			 */
1557 			current_req = req->next;
1558 			req->reply_len += data_index;
1559 			if (req->data[0] == PMU_SLEEP || req->data[0] == PMU_CPU_SPEED)
1560 				pmu_state = locked;
1561 			else
1562 				pmu_state = idle;
1563 			return req;
1564 		}
1565 		break;
1566 
1567 	default:
1568 		printk(KERN_ERR "via_pmu_interrupt: unknown state %d?\n",
1569 		       pmu_state);
1570 	}
1571 	return NULL;
1572 }
1573 
1574 static irqreturn_t
via_pmu_interrupt(int irq,void * arg)1575 via_pmu_interrupt(int irq, void *arg)
1576 {
1577 	unsigned long flags;
1578 	int intr;
1579 	int nloop = 0;
1580 	int int_data = -1;
1581 	struct adb_request *req = NULL;
1582 	int handled = 0;
1583 
1584 	/* This is a bit brutal, we can probably do better */
1585 	spin_lock_irqsave(&pmu_lock, flags);
1586 	++disable_poll;
1587 
1588 	for (;;) {
1589 		/* On 68k Macs, VIA interrupts are dispatched individually.
1590 		 * Unless we are polling, the relevant IRQ flag has already
1591 		 * been cleared.
1592 		 */
1593 		intr = 0;
1594 		if (IS_ENABLED(CONFIG_PPC_PMAC) || !irq) {
1595 			intr = in_8(&via1[IFR]) & (SR_INT | CB1_INT);
1596 			out_8(&via1[IFR], intr);
1597 		}
1598 #ifndef CONFIG_PPC_PMAC
1599 		switch (irq) {
1600 		case IRQ_MAC_ADB_CL:
1601 			intr = CB1_INT;
1602 			break;
1603 		case IRQ_MAC_ADB_SR:
1604 			intr = SR_INT;
1605 			break;
1606 		}
1607 #endif
1608 		if (intr == 0)
1609 			break;
1610 		handled = 1;
1611 		if (++nloop > 1000) {
1612 			printk(KERN_DEBUG "PMU: stuck in intr loop, "
1613 			       "intr=%x, ier=%x pmu_state=%d\n",
1614 			       intr, in_8(&via1[IER]), pmu_state);
1615 			break;
1616 		}
1617 		if (intr & CB1_INT) {
1618 			adb_int_pending = 1;
1619 			pmu_irq_stats[11]++;
1620 		}
1621 		if (intr & SR_INT) {
1622 			req = pmu_sr_intr();
1623 			if (req)
1624 				break;
1625 		}
1626 #ifndef CONFIG_PPC_PMAC
1627 		break;
1628 #endif
1629 	}
1630 
1631 recheck:
1632 	if (pmu_state == idle) {
1633 		if (adb_int_pending) {
1634 			if (int_data_state[0] == int_data_empty)
1635 				int_data_last = 0;
1636 			else if (int_data_state[1] == int_data_empty)
1637 				int_data_last = 1;
1638 			else
1639 				goto no_free_slot;
1640 			pmu_state = intack;
1641 			int_data_state[int_data_last] = int_data_fill;
1642 			/* Sounds safer to make sure ACK is high before writing.
1643 			 * This helped kill a problem with ADB and some iBooks
1644 			 */
1645 			wait_for_ack();
1646 			send_byte(PMU_INT_ACK);
1647 			adb_int_pending = 0;
1648 		} else if (current_req)
1649 			pmu_start();
1650 	}
1651 no_free_slot:
1652 	/* Mark the oldest buffer for flushing */
1653 	if (int_data_state[!int_data_last] == int_data_ready) {
1654 		int_data_state[!int_data_last] = int_data_flush;
1655 		int_data = !int_data_last;
1656 	} else if (int_data_state[int_data_last] == int_data_ready) {
1657 		int_data_state[int_data_last] = int_data_flush;
1658 		int_data = int_data_last;
1659 	}
1660 	--disable_poll;
1661 	spin_unlock_irqrestore(&pmu_lock, flags);
1662 
1663 	/* Deal with completed PMU requests outside of the lock */
1664 	if (req) {
1665 		pmu_done(req);
1666 		req = NULL;
1667 	}
1668 
1669 	/* Deal with interrupt datas outside of the lock */
1670 	if (int_data >= 0) {
1671 		pmu_handle_data(interrupt_data[int_data], interrupt_data_len[int_data]);
1672 		spin_lock_irqsave(&pmu_lock, flags);
1673 		++disable_poll;
1674 		int_data_state[int_data] = int_data_empty;
1675 		int_data = -1;
1676 		goto recheck;
1677 	}
1678 
1679 	return IRQ_RETVAL(handled);
1680 }
1681 
1682 void
pmu_unlock(void)1683 pmu_unlock(void)
1684 {
1685 	unsigned long flags;
1686 
1687 	spin_lock_irqsave(&pmu_lock, flags);
1688 	if (pmu_state == locked)
1689 		pmu_state = idle;
1690 	adb_int_pending = 1;
1691 	spin_unlock_irqrestore(&pmu_lock, flags);
1692 }
1693 
1694 
1695 static __maybe_unused irqreturn_t
gpio1_interrupt(int irq,void * arg)1696 gpio1_interrupt(int irq, void *arg)
1697 {
1698 	unsigned long flags;
1699 
1700 	if ((in_8(gpio_reg + 0x9) & 0x02) == 0) {
1701 		spin_lock_irqsave(&pmu_lock, flags);
1702 		if (gpio_irq_enabled > 0) {
1703 			disable_irq_nosync(gpio_irq);
1704 			gpio_irq_enabled = 0;
1705 		}
1706 		pmu_irq_stats[12]++;
1707 		adb_int_pending = 1;
1708 		spin_unlock_irqrestore(&pmu_lock, flags);
1709 		via_pmu_interrupt(0, NULL);
1710 		return IRQ_HANDLED;
1711 	}
1712 	return IRQ_NONE;
1713 }
1714 
1715 void
pmu_enable_irled(int on)1716 pmu_enable_irled(int on)
1717 {
1718 	struct adb_request req;
1719 
1720 	if (pmu_state == uninitialized)
1721 		return ;
1722 	if (pmu_kind == PMU_KEYLARGO_BASED)
1723 		return ;
1724 
1725 	pmu_request(&req, NULL, 2, PMU_POWER_CTRL, PMU_POW_IRLED |
1726 	    (on ? PMU_POW_ON : PMU_POW_OFF));
1727 	pmu_wait_complete(&req);
1728 }
1729 
1730 /* Offset between Unix time (1970-based) and Mac time (1904-based) */
1731 #define RTC_OFFSET	2082844800
1732 
pmu_get_time(void)1733 time64_t pmu_get_time(void)
1734 {
1735 	struct adb_request req;
1736 	u32 now;
1737 
1738 	if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
1739 		return 0;
1740 	pmu_wait_complete(&req);
1741 	if (req.reply_len != 4)
1742 		pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
1743 	now = (req.reply[0] << 24) + (req.reply[1] << 16) +
1744 	      (req.reply[2] << 8) + req.reply[3];
1745 	return (time64_t)now - RTC_OFFSET;
1746 }
1747 
pmu_set_rtc_time(struct rtc_time * tm)1748 int pmu_set_rtc_time(struct rtc_time *tm)
1749 {
1750 	u32 now;
1751 	struct adb_request req;
1752 
1753 	now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
1754 	if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
1755 	                now >> 24, now >> 16, now >> 8, now) < 0)
1756 		return -ENXIO;
1757 	pmu_wait_complete(&req);
1758 	if (req.reply_len != 0)
1759 		pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
1760 	return 0;
1761 }
1762 
1763 void
pmu_restart(void)1764 pmu_restart(void)
1765 {
1766 	struct adb_request req;
1767 
1768 	if (pmu_state == uninitialized)
1769 		return;
1770 
1771 	local_irq_disable();
1772 
1773 	drop_interrupts = 1;
1774 
1775 	if (pmu_kind != PMU_KEYLARGO_BASED) {
1776 		pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
1777 						PMU_INT_TICK );
1778 		while(!req.complete)
1779 			pmu_poll();
1780 	}
1781 
1782 	pmu_request(&req, NULL, 1, PMU_RESET);
1783 	pmu_wait_complete(&req);
1784 	for (;;)
1785 		;
1786 }
1787 
1788 void
pmu_shutdown(void)1789 pmu_shutdown(void)
1790 {
1791 	struct adb_request req;
1792 
1793 	if (pmu_state == uninitialized)
1794 		return;
1795 
1796 	local_irq_disable();
1797 
1798 	drop_interrupts = 1;
1799 
1800 	if (pmu_kind != PMU_KEYLARGO_BASED) {
1801 		pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, PMU_INT_ADB |
1802 						PMU_INT_TICK );
1803 		pmu_wait_complete(&req);
1804 	} else {
1805 		/* Disable server mode on shutdown or we'll just
1806 		 * wake up again
1807 		 */
1808 		pmu_set_server_mode(0);
1809 	}
1810 
1811 	pmu_request(&req, NULL, 5, PMU_SHUTDOWN,
1812 		    'M', 'A', 'T', 'T');
1813 	pmu_wait_complete(&req);
1814 	for (;;)
1815 		;
1816 }
1817 
1818 int
pmu_present(void)1819 pmu_present(void)
1820 {
1821 	return pmu_state != uninitialized;
1822 }
1823 
1824 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
1825 /*
1826  * Put the powerbook to sleep.
1827  */
1828 
1829 static u32 save_via[8];
1830 static int __fake_sleep;
1831 
1832 static void
save_via_state(void)1833 save_via_state(void)
1834 {
1835 	save_via[0] = in_8(&via1[ANH]);
1836 	save_via[1] = in_8(&via1[DIRA]);
1837 	save_via[2] = in_8(&via1[B]);
1838 	save_via[3] = in_8(&via1[DIRB]);
1839 	save_via[4] = in_8(&via1[PCR]);
1840 	save_via[5] = in_8(&via1[ACR]);
1841 	save_via[6] = in_8(&via1[T1CL]);
1842 	save_via[7] = in_8(&via1[T1CH]);
1843 }
1844 static void
restore_via_state(void)1845 restore_via_state(void)
1846 {
1847 	out_8(&via1[ANH],  save_via[0]);
1848 	out_8(&via1[DIRA], save_via[1]);
1849 	out_8(&via1[B],    save_via[2]);
1850 	out_8(&via1[DIRB], save_via[3]);
1851 	out_8(&via1[PCR],  save_via[4]);
1852 	out_8(&via1[ACR],  save_via[5]);
1853 	out_8(&via1[T1CL], save_via[6]);
1854 	out_8(&via1[T1CH], save_via[7]);
1855 	out_8(&via1[IER], IER_CLR | 0x7f);	/* disable all intrs */
1856 	out_8(&via1[IFR], 0x7f);			/* clear IFR */
1857 	out_8(&via1[IER], IER_SET | SR_INT | CB1_INT);
1858 }
1859 
1860 #define	GRACKLE_PM	(1<<7)
1861 #define GRACKLE_DOZE	(1<<5)
1862 #define	GRACKLE_NAP	(1<<4)
1863 #define	GRACKLE_SLEEP	(1<<3)
1864 
powerbook_sleep_grackle(void)1865 static int powerbook_sleep_grackle(void)
1866 {
1867 	unsigned long save_l2cr;
1868 	unsigned short pmcr1;
1869 	struct adb_request req;
1870 	struct pci_dev *grackle;
1871 
1872 	grackle = pci_get_domain_bus_and_slot(0, 0, 0);
1873 	if (!grackle)
1874 		return -ENODEV;
1875 
1876 	/* Turn off various things. Darwin does some retry tests here... */
1877 	pmu_request(&req, NULL, 2, PMU_POWER_CTRL0, PMU_POW0_OFF|PMU_POW0_HARD_DRIVE);
1878 	pmu_wait_complete(&req);
1879 	pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
1880 		PMU_POW_OFF|PMU_POW_BACKLIGHT|PMU_POW_IRLED|PMU_POW_MEDIABAY);
1881 	pmu_wait_complete(&req);
1882 
1883 	/* For 750, save backside cache setting and disable it */
1884 	save_l2cr = _get_L2CR();	/* (returns -1 if not available) */
1885 
1886 	if (!__fake_sleep) {
1887 		/* Ask the PMU to put us to sleep */
1888 		pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
1889 		pmu_wait_complete(&req);
1890 	}
1891 
1892 	/* The VIA is supposed not to be restored correctly*/
1893 	save_via_state();
1894 	/* We shut down some HW */
1895 	pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,1);
1896 
1897 	pci_read_config_word(grackle, 0x70, &pmcr1);
1898 	/* Apparently, MacOS uses NAP mode for Grackle ??? */
1899 	pmcr1 &= ~(GRACKLE_DOZE|GRACKLE_SLEEP);
1900 	pmcr1 |= GRACKLE_PM|GRACKLE_NAP;
1901 	pci_write_config_word(grackle, 0x70, pmcr1);
1902 
1903 	/* Call low-level ASM sleep handler */
1904 	if (__fake_sleep)
1905 		mdelay(5000);
1906 	else
1907 		low_sleep_handler();
1908 
1909 	/* We're awake again, stop grackle PM */
1910 	pci_read_config_word(grackle, 0x70, &pmcr1);
1911 	pmcr1 &= ~(GRACKLE_PM|GRACKLE_DOZE|GRACKLE_SLEEP|GRACKLE_NAP);
1912 	pci_write_config_word(grackle, 0x70, pmcr1);
1913 
1914 	pci_dev_put(grackle);
1915 
1916 	/* Make sure the PMU is idle */
1917 	pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,0);
1918 	restore_via_state();
1919 
1920 	/* Restore L2 cache */
1921 	if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
1922  		_set_L2CR(save_l2cr);
1923 
1924 	/* Restore userland MMU context */
1925 	switch_mmu_context(NULL, current->active_mm, NULL);
1926 
1927 	/* Power things up */
1928 	pmu_unlock();
1929 	pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
1930 	pmu_wait_complete(&req);
1931 	pmu_request(&req, NULL, 2, PMU_POWER_CTRL0,
1932 			PMU_POW0_ON|PMU_POW0_HARD_DRIVE);
1933 	pmu_wait_complete(&req);
1934 	pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
1935 			PMU_POW_ON|PMU_POW_BACKLIGHT|PMU_POW_CHARGER|PMU_POW_IRLED|PMU_POW_MEDIABAY);
1936 	pmu_wait_complete(&req);
1937 
1938 	return 0;
1939 }
1940 
1941 static int
powerbook_sleep_Core99(void)1942 powerbook_sleep_Core99(void)
1943 {
1944 	unsigned long save_l2cr;
1945 	unsigned long save_l3cr;
1946 	struct adb_request req;
1947 
1948 	if (pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,0,-1) < 0) {
1949 		printk(KERN_ERR "Sleep mode not supported on this machine\n");
1950 		return -ENOSYS;
1951 	}
1952 
1953 	if (num_online_cpus() > 1 || cpu_is_offline(0))
1954 		return -EAGAIN;
1955 
1956 	/* Stop environment and ADB interrupts */
1957 	pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, 0);
1958 	pmu_wait_complete(&req);
1959 
1960 	/* Tell PMU what events will wake us up */
1961 	pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_CLR_WAKEUP_EVENTS,
1962 		0xff, 0xff);
1963 	pmu_wait_complete(&req);
1964 	pmu_request(&req, NULL, 4, PMU_POWER_EVENTS, PMU_PWR_SET_WAKEUP_EVENTS,
1965 		0, PMU_PWR_WAKEUP_KEY |
1966 		(option_lid_wakeup ? PMU_PWR_WAKEUP_LID_OPEN : 0));
1967 	pmu_wait_complete(&req);
1968 
1969 	/* Save the state of the L2 and L3 caches */
1970 	save_l3cr = _get_L3CR();	/* (returns -1 if not available) */
1971 	save_l2cr = _get_L2CR();	/* (returns -1 if not available) */
1972 
1973 	if (!__fake_sleep) {
1974 		/* Ask the PMU to put us to sleep */
1975 		pmu_request(&req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
1976 		pmu_wait_complete(&req);
1977 	}
1978 
1979 	/* The VIA is supposed not to be restored correctly*/
1980 	save_via_state();
1981 
1982 	/* Shut down various ASICs. There's a chance that we can no longer
1983 	 * talk to the PMU after this, so I moved it to _after_ sending the
1984 	 * sleep command to it. Still need to be checked.
1985 	 */
1986 	pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 1);
1987 
1988 	/* Call low-level ASM sleep handler */
1989 	if (__fake_sleep)
1990 		mdelay(5000);
1991 	else
1992 		low_sleep_handler();
1993 
1994 	/* Restore Apple core ASICs state */
1995 	pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 0);
1996 
1997 	/* Restore VIA */
1998 	restore_via_state();
1999 
2000 	/* tweak LPJ before cpufreq is there */
2001 	loops_per_jiffy *= 2;
2002 
2003 	/* Restore video */
2004 	pmac_call_early_video_resume();
2005 
2006 	/* Restore L2 cache */
2007 	if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
2008  		_set_L2CR(save_l2cr);
2009 	/* Restore L3 cache */
2010 	if (save_l3cr != 0xffffffff && (save_l3cr & L3CR_L3E) != 0)
2011  		_set_L3CR(save_l3cr);
2012 
2013 	/* Restore userland MMU context */
2014 	switch_mmu_context(NULL, current->active_mm, NULL);
2015 
2016 	/* Tell PMU we are ready */
2017 	pmu_unlock();
2018 	pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
2019 	pmu_wait_complete(&req);
2020 	pmu_request(&req, NULL, 2, PMU_SET_INTR_MASK, pmu_intr_mask);
2021 	pmu_wait_complete(&req);
2022 
2023 	/* Restore LPJ, cpufreq will adjust the cpu frequency */
2024 	loops_per_jiffy /= 2;
2025 
2026 	return 0;
2027 }
2028 
2029 #define PB3400_MEM_CTRL		0xf8000000
2030 #define PB3400_MEM_CTRL_SLEEP	0x70
2031 
2032 static void __iomem *pb3400_mem_ctrl;
2033 
powerbook_sleep_init_3400(void)2034 static void powerbook_sleep_init_3400(void)
2035 {
2036 	/* map in the memory controller registers */
2037 	pb3400_mem_ctrl = ioremap(PB3400_MEM_CTRL, 0x100);
2038 	if (pb3400_mem_ctrl == NULL)
2039 		printk(KERN_WARNING "ioremap failed: sleep won't be possible");
2040 }
2041 
powerbook_sleep_3400(void)2042 static int powerbook_sleep_3400(void)
2043 {
2044 	int i, x;
2045 	unsigned int hid0;
2046 	unsigned long msr;
2047 	struct adb_request sleep_req;
2048 	unsigned int __iomem *mem_ctrl_sleep;
2049 
2050 	if (pb3400_mem_ctrl == NULL)
2051 		return -ENOMEM;
2052 	mem_ctrl_sleep = pb3400_mem_ctrl + PB3400_MEM_CTRL_SLEEP;
2053 
2054 	/* Set the memory controller to keep the memory refreshed
2055 	   while we're asleep */
2056 	for (i = 0x403f; i >= 0x4000; --i) {
2057 		out_be32(mem_ctrl_sleep, i);
2058 		do {
2059 			x = (in_be32(mem_ctrl_sleep) >> 16) & 0x3ff;
2060 		} while (x == 0);
2061 		if (x >= 0x100)
2062 			break;
2063 	}
2064 
2065 	/* Ask the PMU to put us to sleep */
2066 	pmu_request(&sleep_req, NULL, 5, PMU_SLEEP, 'M', 'A', 'T', 'T');
2067 	pmu_wait_complete(&sleep_req);
2068 	pmu_unlock();
2069 
2070 	pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 1);
2071 
2072 	asleep = 1;
2073 
2074 	/* Put the CPU into sleep mode */
2075 	hid0 = mfspr(SPRN_HID0);
2076 	hid0 = (hid0 & ~(HID0_NAP | HID0_DOZE)) | HID0_SLEEP;
2077 	mtspr(SPRN_HID0, hid0);
2078 	local_irq_enable();
2079 	msr = mfmsr() | MSR_POW;
2080 	while (asleep) {
2081 		mb();
2082 		mtmsr(msr);
2083 		isync();
2084 	}
2085 	local_irq_disable();
2086 
2087 	/* OK, we're awake again, start restoring things */
2088 	out_be32(mem_ctrl_sleep, 0x3f);
2089 	pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, 0);
2090 
2091 	return 0;
2092 }
2093 
2094 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
2095 
2096 /*
2097  * Support for /dev/pmu device
2098  */
2099 #define RB_SIZE		0x10
2100 struct pmu_private {
2101 	struct list_head list;
2102 	int	rb_get;
2103 	int	rb_put;
2104 	struct rb_entry {
2105 		unsigned short len;
2106 		unsigned char data[16];
2107 	}	rb_buf[RB_SIZE];
2108 	wait_queue_head_t wait;
2109 	spinlock_t lock;
2110 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2111 	int	backlight_locker;
2112 #endif
2113 };
2114 
2115 static LIST_HEAD(all_pmu_pvt);
2116 static DEFINE_SPINLOCK(all_pvt_lock);
2117 
2118 static void
pmu_pass_intr(unsigned char * data,int len)2119 pmu_pass_intr(unsigned char *data, int len)
2120 {
2121 	struct pmu_private *pp;
2122 	struct list_head *list;
2123 	int i;
2124 	unsigned long flags;
2125 
2126 	if (len > sizeof(pp->rb_buf[0].data))
2127 		len = sizeof(pp->rb_buf[0].data);
2128 	spin_lock_irqsave(&all_pvt_lock, flags);
2129 	for (list = &all_pmu_pvt; (list = list->next) != &all_pmu_pvt; ) {
2130 		pp = list_entry(list, struct pmu_private, list);
2131 		spin_lock(&pp->lock);
2132 		i = pp->rb_put + 1;
2133 		if (i >= RB_SIZE)
2134 			i = 0;
2135 		if (i != pp->rb_get) {
2136 			struct rb_entry *rp = &pp->rb_buf[pp->rb_put];
2137 			rp->len = len;
2138 			memcpy(rp->data, data, len);
2139 			pp->rb_put = i;
2140 			wake_up_interruptible(&pp->wait);
2141 		}
2142 		spin_unlock(&pp->lock);
2143 	}
2144 	spin_unlock_irqrestore(&all_pvt_lock, flags);
2145 }
2146 
2147 static int
pmu_open(struct inode * inode,struct file * file)2148 pmu_open(struct inode *inode, struct file *file)
2149 {
2150 	struct pmu_private *pp;
2151 	unsigned long flags;
2152 
2153 	pp = kmalloc(sizeof(struct pmu_private), GFP_KERNEL);
2154 	if (!pp)
2155 		return -ENOMEM;
2156 	pp->rb_get = pp->rb_put = 0;
2157 	spin_lock_init(&pp->lock);
2158 	init_waitqueue_head(&pp->wait);
2159 	mutex_lock(&pmu_info_proc_mutex);
2160 	spin_lock_irqsave(&all_pvt_lock, flags);
2161 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2162 	pp->backlight_locker = 0;
2163 #endif
2164 	list_add(&pp->list, &all_pmu_pvt);
2165 	spin_unlock_irqrestore(&all_pvt_lock, flags);
2166 	file->private_data = pp;
2167 	mutex_unlock(&pmu_info_proc_mutex);
2168 	return 0;
2169 }
2170 
2171 static ssize_t
pmu_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)2172 pmu_read(struct file *file, char __user *buf,
2173 			size_t count, loff_t *ppos)
2174 {
2175 	struct pmu_private *pp = file->private_data;
2176 	DECLARE_WAITQUEUE(wait, current);
2177 	unsigned long flags;
2178 	int ret = 0;
2179 
2180 	if (count < 1 || !pp)
2181 		return -EINVAL;
2182 
2183 	spin_lock_irqsave(&pp->lock, flags);
2184 	add_wait_queue(&pp->wait, &wait);
2185 	set_current_state(TASK_INTERRUPTIBLE);
2186 
2187 	for (;;) {
2188 		ret = -EAGAIN;
2189 		if (pp->rb_get != pp->rb_put) {
2190 			int i = pp->rb_get;
2191 			struct rb_entry *rp = &pp->rb_buf[i];
2192 			ret = rp->len;
2193 			spin_unlock_irqrestore(&pp->lock, flags);
2194 			if (ret > count)
2195 				ret = count;
2196 			if (ret > 0 && copy_to_user(buf, rp->data, ret))
2197 				ret = -EFAULT;
2198 			if (++i >= RB_SIZE)
2199 				i = 0;
2200 			spin_lock_irqsave(&pp->lock, flags);
2201 			pp->rb_get = i;
2202 		}
2203 		if (ret >= 0)
2204 			break;
2205 		if (file->f_flags & O_NONBLOCK)
2206 			break;
2207 		ret = -ERESTARTSYS;
2208 		if (signal_pending(current))
2209 			break;
2210 		spin_unlock_irqrestore(&pp->lock, flags);
2211 		schedule();
2212 		spin_lock_irqsave(&pp->lock, flags);
2213 	}
2214 	__set_current_state(TASK_RUNNING);
2215 	remove_wait_queue(&pp->wait, &wait);
2216 	spin_unlock_irqrestore(&pp->lock, flags);
2217 
2218 	return ret;
2219 }
2220 
2221 static ssize_t
pmu_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)2222 pmu_write(struct file *file, const char __user *buf,
2223 			 size_t count, loff_t *ppos)
2224 {
2225 	return 0;
2226 }
2227 
2228 static __poll_t
pmu_fpoll(struct file * filp,poll_table * wait)2229 pmu_fpoll(struct file *filp, poll_table *wait)
2230 {
2231 	struct pmu_private *pp = filp->private_data;
2232 	__poll_t mask = 0;
2233 	unsigned long flags;
2234 
2235 	if (!pp)
2236 		return 0;
2237 	poll_wait(filp, &pp->wait, wait);
2238 	spin_lock_irqsave(&pp->lock, flags);
2239 	if (pp->rb_get != pp->rb_put)
2240 		mask |= EPOLLIN;
2241 	spin_unlock_irqrestore(&pp->lock, flags);
2242 	return mask;
2243 }
2244 
2245 static int
pmu_release(struct inode * inode,struct file * file)2246 pmu_release(struct inode *inode, struct file *file)
2247 {
2248 	struct pmu_private *pp = file->private_data;
2249 	unsigned long flags;
2250 
2251 	if (pp) {
2252 		file->private_data = NULL;
2253 		spin_lock_irqsave(&all_pvt_lock, flags);
2254 		list_del(&pp->list);
2255 		spin_unlock_irqrestore(&all_pvt_lock, flags);
2256 
2257 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2258 		if (pp->backlight_locker)
2259 			pmac_backlight_enable();
2260 #endif
2261 
2262 		kfree(pp);
2263 	}
2264 	return 0;
2265 }
2266 
2267 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
pmac_suspend_disable_irqs(void)2268 static void pmac_suspend_disable_irqs(void)
2269 {
2270 	/* Call platform functions marked "on sleep" */
2271 	pmac_pfunc_i2c_suspend();
2272 	pmac_pfunc_base_suspend();
2273 }
2274 
powerbook_sleep(suspend_state_t state)2275 static int powerbook_sleep(suspend_state_t state)
2276 {
2277 	int error = 0;
2278 
2279 	/* Wait for completion of async requests */
2280 	while (!batt_req.complete)
2281 		pmu_poll();
2282 
2283 	/* Giveup the lazy FPU & vec so we don't have to back them
2284 	 * up from the low level code
2285 	 */
2286 	enable_kernel_fp();
2287 
2288 #ifdef CONFIG_ALTIVEC
2289 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
2290 		enable_kernel_altivec();
2291 #endif /* CONFIG_ALTIVEC */
2292 
2293 	switch (pmu_kind) {
2294 	case PMU_OHARE_BASED:
2295 		error = powerbook_sleep_3400();
2296 		break;
2297 	case PMU_HEATHROW_BASED:
2298 	case PMU_PADDINGTON_BASED:
2299 		error = powerbook_sleep_grackle();
2300 		break;
2301 	case PMU_KEYLARGO_BASED:
2302 		error = powerbook_sleep_Core99();
2303 		break;
2304 	default:
2305 		return -ENOSYS;
2306 	}
2307 
2308 	if (error)
2309 		return error;
2310 
2311 	mdelay(100);
2312 
2313 	return 0;
2314 }
2315 
pmac_suspend_enable_irqs(void)2316 static void pmac_suspend_enable_irqs(void)
2317 {
2318 	/* Force a poll of ADB interrupts */
2319 	adb_int_pending = 1;
2320 	via_pmu_interrupt(0, NULL);
2321 
2322 	mdelay(10);
2323 
2324 	/* Call platform functions marked "on wake" */
2325 	pmac_pfunc_base_resume();
2326 	pmac_pfunc_i2c_resume();
2327 }
2328 
pmu_sleep_valid(suspend_state_t state)2329 static int pmu_sleep_valid(suspend_state_t state)
2330 {
2331 	return state == PM_SUSPEND_MEM
2332 		&& (pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, -1) >= 0);
2333 }
2334 
2335 static const struct platform_suspend_ops pmu_pm_ops = {
2336 	.enter = powerbook_sleep,
2337 	.valid = pmu_sleep_valid,
2338 };
2339 
register_pmu_pm_ops(void)2340 static int register_pmu_pm_ops(void)
2341 {
2342 	if (pmu_kind == PMU_OHARE_BASED)
2343 		powerbook_sleep_init_3400();
2344 	ppc_md.suspend_disable_irqs = pmac_suspend_disable_irqs;
2345 	ppc_md.suspend_enable_irqs = pmac_suspend_enable_irqs;
2346 	suspend_set_ops(&pmu_pm_ops);
2347 
2348 	return 0;
2349 }
2350 
2351 device_initcall(register_pmu_pm_ops);
2352 #endif
2353 
pmu_ioctl(struct file * filp,u_int cmd,u_long arg)2354 static int pmu_ioctl(struct file *filp,
2355 		     u_int cmd, u_long arg)
2356 {
2357 	__u32 __user *argp = (__u32 __user *)arg;
2358 	int error = -EINVAL;
2359 
2360 	switch (cmd) {
2361 #ifdef CONFIG_PPC_PMAC
2362 	case PMU_IOC_SLEEP:
2363 		if (!capable(CAP_SYS_ADMIN))
2364 			return -EACCES;
2365 		return pm_suspend(PM_SUSPEND_MEM);
2366 	case PMU_IOC_CAN_SLEEP:
2367 		if (pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, -1) < 0)
2368 			return put_user(0, argp);
2369 		else
2370 			return put_user(1, argp);
2371 #endif
2372 
2373 #ifdef CONFIG_PMAC_BACKLIGHT_LEGACY
2374 	/* Compatibility ioctl's for backlight */
2375 	case PMU_IOC_GET_BACKLIGHT:
2376 	{
2377 		int brightness;
2378 
2379 		brightness = pmac_backlight_get_legacy_brightness();
2380 		if (brightness < 0)
2381 			return brightness;
2382 		else
2383 			return put_user(brightness, argp);
2384 
2385 	}
2386 	case PMU_IOC_SET_BACKLIGHT:
2387 	{
2388 		int brightness;
2389 
2390 		error = get_user(brightness, argp);
2391 		if (error)
2392 			return error;
2393 
2394 		return pmac_backlight_set_legacy_brightness(brightness);
2395 	}
2396 #ifdef CONFIG_INPUT_ADBHID
2397 	case PMU_IOC_GRAB_BACKLIGHT: {
2398 		struct pmu_private *pp = filp->private_data;
2399 
2400 		if (pp->backlight_locker)
2401 			return 0;
2402 
2403 		pp->backlight_locker = 1;
2404 		pmac_backlight_disable();
2405 
2406 		return 0;
2407 	}
2408 #endif /* CONFIG_INPUT_ADBHID */
2409 #endif /* CONFIG_PMAC_BACKLIGHT_LEGACY */
2410 
2411 	case PMU_IOC_GET_MODEL:
2412 	    	return put_user(pmu_kind, argp);
2413 	case PMU_IOC_HAS_ADB:
2414 		return put_user(pmu_has_adb, argp);
2415 	}
2416 	return error;
2417 }
2418 
pmu_unlocked_ioctl(struct file * filp,u_int cmd,u_long arg)2419 static long pmu_unlocked_ioctl(struct file *filp,
2420 			       u_int cmd, u_long arg)
2421 {
2422 	int ret;
2423 
2424 	mutex_lock(&pmu_info_proc_mutex);
2425 	ret = pmu_ioctl(filp, cmd, arg);
2426 	mutex_unlock(&pmu_info_proc_mutex);
2427 
2428 	return ret;
2429 }
2430 
2431 #ifdef CONFIG_COMPAT
2432 #define PMU_IOC_GET_BACKLIGHT32	_IOR('B', 1, compat_size_t)
2433 #define PMU_IOC_SET_BACKLIGHT32	_IOW('B', 2, compat_size_t)
2434 #define PMU_IOC_GET_MODEL32	_IOR('B', 3, compat_size_t)
2435 #define PMU_IOC_HAS_ADB32	_IOR('B', 4, compat_size_t)
2436 #define PMU_IOC_CAN_SLEEP32	_IOR('B', 5, compat_size_t)
2437 #define PMU_IOC_GRAB_BACKLIGHT32 _IOR('B', 6, compat_size_t)
2438 
compat_pmu_ioctl(struct file * filp,u_int cmd,u_long arg)2439 static long compat_pmu_ioctl (struct file *filp, u_int cmd, u_long arg)
2440 {
2441 	switch (cmd) {
2442 	case PMU_IOC_SLEEP:
2443 		break;
2444 	case PMU_IOC_GET_BACKLIGHT32:
2445 		cmd = PMU_IOC_GET_BACKLIGHT;
2446 		break;
2447 	case PMU_IOC_SET_BACKLIGHT32:
2448 		cmd = PMU_IOC_SET_BACKLIGHT;
2449 		break;
2450 	case PMU_IOC_GET_MODEL32:
2451 		cmd = PMU_IOC_GET_MODEL;
2452 		break;
2453 	case PMU_IOC_HAS_ADB32:
2454 		cmd = PMU_IOC_HAS_ADB;
2455 		break;
2456 	case PMU_IOC_CAN_SLEEP32:
2457 		cmd = PMU_IOC_CAN_SLEEP;
2458 		break;
2459 	case PMU_IOC_GRAB_BACKLIGHT32:
2460 		cmd = PMU_IOC_GRAB_BACKLIGHT;
2461 		break;
2462 	default:
2463 		return -ENOIOCTLCMD;
2464 	}
2465 	return pmu_unlocked_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
2466 }
2467 #endif
2468 
2469 static const struct file_operations pmu_device_fops = {
2470 	.read		= pmu_read,
2471 	.write		= pmu_write,
2472 	.poll		= pmu_fpoll,
2473 	.unlocked_ioctl	= pmu_unlocked_ioctl,
2474 #ifdef CONFIG_COMPAT
2475 	.compat_ioctl	= compat_pmu_ioctl,
2476 #endif
2477 	.open		= pmu_open,
2478 	.release	= pmu_release,
2479 	.llseek		= noop_llseek,
2480 };
2481 
2482 static struct miscdevice pmu_device = {
2483 	PMU_MINOR, "pmu", &pmu_device_fops
2484 };
2485 
pmu_device_init(void)2486 static int pmu_device_init(void)
2487 {
2488 	if (pmu_state == uninitialized)
2489 		return 0;
2490 	if (misc_register(&pmu_device) < 0)
2491 		printk(KERN_ERR "via-pmu: cannot register misc device.\n");
2492 	return 0;
2493 }
2494 device_initcall(pmu_device_init);
2495 
2496 
2497 #ifdef DEBUG_SLEEP
2498 static inline void
polled_handshake(void)2499 polled_handshake(void)
2500 {
2501 	via2[B] &= ~TREQ; eieio();
2502 	while ((via2[B] & TACK) != 0)
2503 		;
2504 	via2[B] |= TREQ; eieio();
2505 	while ((via2[B] & TACK) == 0)
2506 		;
2507 }
2508 
2509 static inline void
polled_send_byte(int x)2510 polled_send_byte(int x)
2511 {
2512 	via1[ACR] |= SR_OUT | SR_EXT; eieio();
2513 	via1[SR] = x; eieio();
2514 	polled_handshake();
2515 }
2516 
2517 static inline int
polled_recv_byte(void)2518 polled_recv_byte(void)
2519 {
2520 	int x;
2521 
2522 	via1[ACR] = (via1[ACR] & ~SR_OUT) | SR_EXT; eieio();
2523 	x = via1[SR]; eieio();
2524 	polled_handshake();
2525 	x = via1[SR]; eieio();
2526 	return x;
2527 }
2528 
2529 int
pmu_polled_request(struct adb_request * req)2530 pmu_polled_request(struct adb_request *req)
2531 {
2532 	unsigned long flags;
2533 	int i, l, c;
2534 
2535 	req->complete = 1;
2536 	c = req->data[0];
2537 	l = pmu_data_len[c][0];
2538 	if (l >= 0 && req->nbytes != l + 1)
2539 		return -EINVAL;
2540 
2541 	local_irq_save(flags);
2542 	while (pmu_state != idle)
2543 		pmu_poll();
2544 
2545 	while ((via2[B] & TACK) == 0)
2546 		;
2547 	polled_send_byte(c);
2548 	if (l < 0) {
2549 		l = req->nbytes - 1;
2550 		polled_send_byte(l);
2551 	}
2552 	for (i = 1; i <= l; ++i)
2553 		polled_send_byte(req->data[i]);
2554 
2555 	l = pmu_data_len[c][1];
2556 	if (l < 0)
2557 		l = polled_recv_byte();
2558 	for (i = 0; i < l; ++i)
2559 		req->reply[i + req->reply_len] = polled_recv_byte();
2560 
2561 	if (req->done)
2562 		(*req->done)(req);
2563 
2564 	local_irq_restore(flags);
2565 	return 0;
2566 }
2567 
2568 /* N.B. This doesn't work on the 3400 */
pmu_blink(int n)2569 void pmu_blink(int n)
2570 {
2571 	struct adb_request req;
2572 
2573 	memset(&req, 0, sizeof(req));
2574 
2575 	for (; n > 0; --n) {
2576 		req.nbytes = 4;
2577 		req.done = NULL;
2578 		req.data[0] = 0xee;
2579 		req.data[1] = 4;
2580 		req.data[2] = 0;
2581 		req.data[3] = 1;
2582 		req.reply[0] = ADB_RET_OK;
2583 		req.reply_len = 1;
2584 		req.reply_expected = 0;
2585 		pmu_polled_request(&req);
2586 		mdelay(50);
2587 		req.nbytes = 4;
2588 		req.done = NULL;
2589 		req.data[0] = 0xee;
2590 		req.data[1] = 4;
2591 		req.data[2] = 0;
2592 		req.data[3] = 0;
2593 		req.reply[0] = ADB_RET_OK;
2594 		req.reply_len = 1;
2595 		req.reply_expected = 0;
2596 		pmu_polled_request(&req);
2597 		mdelay(50);
2598 	}
2599 	mdelay(50);
2600 }
2601 #endif /* DEBUG_SLEEP */
2602 
2603 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
2604 int pmu_sys_suspended;
2605 
pmu_syscore_suspend(void)2606 static int pmu_syscore_suspend(void)
2607 {
2608 	/* Suspend PMU event interrupts */
2609 	pmu_suspend();
2610 	pmu_sys_suspended = 1;
2611 
2612 #ifdef CONFIG_PMAC_BACKLIGHT
2613 	/* Tell backlight code not to muck around with the chip anymore */
2614 	pmu_backlight_set_sleep(1);
2615 #endif
2616 
2617 	return 0;
2618 }
2619 
pmu_syscore_resume(void)2620 static void pmu_syscore_resume(void)
2621 {
2622 	struct adb_request req;
2623 
2624 	if (!pmu_sys_suspended)
2625 		return;
2626 
2627 	/* Tell PMU we are ready */
2628 	pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
2629 	pmu_wait_complete(&req);
2630 
2631 #ifdef CONFIG_PMAC_BACKLIGHT
2632 	/* Tell backlight code it can use the chip again */
2633 	pmu_backlight_set_sleep(0);
2634 #endif
2635 	/* Resume PMU event interrupts */
2636 	pmu_resume();
2637 	pmu_sys_suspended = 0;
2638 }
2639 
2640 static struct syscore_ops pmu_syscore_ops = {
2641 	.suspend = pmu_syscore_suspend,
2642 	.resume = pmu_syscore_resume,
2643 };
2644 
pmu_syscore_register(void)2645 static int pmu_syscore_register(void)
2646 {
2647 	register_syscore_ops(&pmu_syscore_ops);
2648 
2649 	return 0;
2650 }
2651 subsys_initcall(pmu_syscore_register);
2652 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
2653 
2654 EXPORT_SYMBOL(pmu_request);
2655 EXPORT_SYMBOL(pmu_queue_request);
2656 EXPORT_SYMBOL(pmu_poll);
2657 EXPORT_SYMBOL(pmu_poll_adb);
2658 EXPORT_SYMBOL(pmu_wait_complete);
2659 EXPORT_SYMBOL(pmu_suspend);
2660 EXPORT_SYMBOL(pmu_resume);
2661 EXPORT_SYMBOL(pmu_unlock);
2662 #if defined(CONFIG_PPC32)
2663 EXPORT_SYMBOL(pmu_enable_irled);
2664 EXPORT_SYMBOL(pmu_battery_count);
2665 EXPORT_SYMBOL(pmu_batteries);
2666 EXPORT_SYMBOL(pmu_power_flags);
2667 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
2668 
2669