1 // SPDX-License-Identifier: GPL-2.0
3 * Device driver for the PMU in Apple PowerBooks and PowerMacs.
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.
12 * Copyright (C) 1998 Paul Mackerras and Fabio Riccardi.
13 * Copyright (C) 2001-2002 Benjamin Herrenschmidt
14 * Copyright (C) 2006-2007 Johannes Berg
16 * THIS DRIVER IS BECOMING A TOTAL MESS !
17 * - Cleanup atomically disabling reply to PMU events after
18 * a sleep or a freq. switch
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>
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>
56 #include <asm/sections.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>
63 #include <asm/mmu_context.h>
64 #include <asm/cputable.h>
66 #include <asm/backlight.h>
68 #include <asm/macintosh.h>
69 #include <asm/macints.h>
70 #include <asm/mac_via.h>
73 #include "via-pmu-event.h"
75 /* Some compile options */
78 /* How many iterations between battery polls */
79 #define BATTERY_POLLING_COUNT 2
81 static DEFINE_MUTEX(pmu_info_proc_mutex
);
83 /* VIA registers - spaced 0x200 bytes apart */
84 #define RS 0x200 /* skip between registers */
85 #define B 0 /* B-side data */
86 #define A RS /* A-side data */
87 #define DIRB (2*RS) /* B-side direction (1=output) */
88 #define DIRA (3*RS) /* A-side direction (1=output) */
89 #define T1CL (4*RS) /* Timer 1 ctr/latch (low 8 bits) */
90 #define T1CH (5*RS) /* Timer 1 counter (high 8 bits) */
91 #define T1LL (6*RS) /* Timer 1 latch (low 8 bits) */
92 #define T1LH (7*RS) /* Timer 1 latch (high 8 bits) */
93 #define T2CL (8*RS) /* Timer 2 ctr/latch (low 8 bits) */
94 #define T2CH (9*RS) /* Timer 2 counter (high 8 bits) */
95 #define SR (10*RS) /* Shift register */
96 #define ACR (11*RS) /* Auxiliary control register */
97 #define PCR (12*RS) /* Peripheral control register */
98 #define IFR (13*RS) /* Interrupt flag register */
99 #define IER (14*RS) /* Interrupt enable register */
100 #define ANH (15*RS) /* A-side data, no handshake */
102 /* Bits in B data register: both active low */
103 #ifdef CONFIG_PPC_PMAC
104 #define TACK 0x08 /* Transfer acknowledge (input) */
105 #define TREQ 0x10 /* Transfer request (output) */
112 #define SR_CTRL 0x1c /* Shift register control bits */
113 #define SR_EXT 0x0c /* Shift on external clock */
114 #define SR_OUT 0x10 /* Shift out if 1 */
116 /* Bits in IFR and IER */
117 #define IER_SET 0x80 /* set bits in IER */
118 #define IER_CLR 0 /* clear bits in IER */
119 #define SR_INT 0x04 /* Shift register full/empty */
121 #define CB1_INT 0x10 /* transition on CB1 input */
123 static volatile enum pmu_state
{
133 static volatile enum int_data_state
{
138 } int_data_state
[2] = { int_data_empty
, int_data_empty
};
140 static struct adb_request
*current_req
;
141 static struct adb_request
*last_req
;
142 static struct adb_request
*req_awaiting_reply
;
143 static unsigned char interrupt_data
[2][32];
144 static int interrupt_data_len
[2];
145 static int int_data_last
;
146 static unsigned char *reply_ptr
;
147 static int data_index
;
149 static volatile int adb_int_pending
;
150 static volatile int disable_poll
;
151 static int pmu_kind
= PMU_UNKNOWN
;
152 static int pmu_fully_inited
;
153 static int pmu_has_adb
;
154 #ifdef CONFIG_PPC_PMAC
155 static volatile unsigned char __iomem
*via1
;
156 static volatile unsigned char __iomem
*via2
;
157 static struct device_node
*vias
;
158 static struct device_node
*gpio_node
;
160 static unsigned char __iomem
*gpio_reg
;
161 static int gpio_irq
= 0;
162 static int gpio_irq_enabled
= -1;
163 static volatile int pmu_suspended
;
164 static spinlock_t pmu_lock
;
165 static u8 pmu_intr_mask
;
166 static int pmu_version
;
167 static int drop_interrupts
;
168 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
169 static int option_lid_wakeup
= 1;
170 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
171 static unsigned long async_req_locks
;
173 #define NUM_IRQ_STATS 13
174 static unsigned int pmu_irq_stats
[NUM_IRQ_STATS
];
176 static struct proc_dir_entry
*proc_pmu_root
;
177 static struct proc_dir_entry
*proc_pmu_info
;
178 static struct proc_dir_entry
*proc_pmu_irqstats
;
179 static struct proc_dir_entry
*proc_pmu_options
;
180 static int option_server_mode
;
182 int pmu_battery_count
;
183 static int pmu_cur_battery
;
184 unsigned int pmu_power_flags
= PMU_PWR_AC_PRESENT
;
185 struct pmu_battery_info pmu_batteries
[PMU_MAX_BATTERIES
];
186 static int query_batt_timer
= BATTERY_POLLING_COUNT
;
187 static struct adb_request batt_req
;
188 static struct proc_dir_entry
*proc_pmu_batt
[PMU_MAX_BATTERIES
];
193 static int adb_dev_map
;
194 static int pmu_adb_flags
;
196 static int pmu_probe(void);
197 static int pmu_init(void);
198 static int pmu_send_request(struct adb_request
*req
, int sync
);
199 static int pmu_adb_autopoll(int devs
);
200 static int pmu_adb_reset_bus(void);
201 #endif /* CONFIG_ADB */
203 static int init_pmu(void);
204 static void pmu_start(void);
205 static irqreturn_t
via_pmu_interrupt(int irq
, void *arg
);
206 static irqreturn_t
gpio1_interrupt(int irq
, void *arg
);
207 static int pmu_info_proc_show(struct seq_file
*m
, void *v
);
208 static int pmu_irqstats_proc_show(struct seq_file
*m
, void *v
);
209 static int pmu_battery_proc_show(struct seq_file
*m
, void *v
);
210 static void pmu_pass_intr(unsigned char *data
, int len
);
211 static const struct proc_ops pmu_options_proc_ops
;
214 const struct adb_driver via_pmu_driver
= {
218 .send_request
= pmu_send_request
,
219 .autopoll
= pmu_adb_autopoll
,
220 .poll
= pmu_poll_adb
,
221 .reset_bus
= pmu_adb_reset_bus
,
223 #endif /* CONFIG_ADB */
225 extern void low_sleep_handler(void);
226 extern void enable_kernel_altivec(void);
227 extern void enable_kernel_fp(void);
230 int pmu_polled_request(struct adb_request
*req
);
231 void pmu_blink(int n
);
235 * This table indicates for each PMU opcode:
236 * - the number of data bytes to be sent with the command, or -1
237 * if a length byte should be sent,
238 * - the number of response bytes which the PMU will return, or
239 * -1 if it will send a length byte.
241 static const s8 pmu_data_len
[256][2] = {
242 /* 0 1 2 3 4 5 6 7 */
243 /*00*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
244 /*08*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
245 /*10*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
246 /*18*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0, 0},
247 /*20*/ {-1, 0},{ 0, 0},{ 2, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},
248 /*28*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0,-1},
249 /*30*/ { 4, 0},{20, 0},{-1, 0},{ 3, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
250 /*38*/ { 0, 4},{ 0,20},{ 2,-1},{ 2, 1},{ 3,-1},{-1,-1},{-1,-1},{ 4, 0},
251 /*40*/ { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
252 /*48*/ { 0, 1},{ 0, 1},{-1,-1},{ 1, 0},{ 1, 0},{-1,-1},{-1,-1},{-1,-1},
253 /*50*/ { 1, 0},{ 0, 0},{ 2, 0},{ 2, 0},{-1, 0},{ 1, 0},{ 3, 0},{ 1, 0},
254 /*58*/ { 0, 1},{ 1, 0},{ 0, 2},{ 0, 2},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},
255 /*60*/ { 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
256 /*68*/ { 0, 3},{ 0, 3},{ 0, 2},{ 0, 8},{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},
257 /*70*/ { 1, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
258 /*78*/ { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{ 5, 1},{ 4, 1},{ 4, 1},
259 /*80*/ { 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
260 /*88*/ { 0, 5},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
261 /*90*/ { 1, 0},{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
262 /*98*/ { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
263 /*a0*/ { 2, 0},{ 2, 0},{ 2, 0},{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},
264 /*a8*/ { 1, 1},{ 1, 0},{ 3, 0},{ 2, 0},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
265 /*b0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
266 /*b8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
267 /*c0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
268 /*c8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
269 /*d0*/ { 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
270 /*d8*/ { 1, 1},{ 1, 1},{-1,-1},{-1,-1},{ 0, 1},{ 0,-1},{-1,-1},{-1,-1},
271 /*e0*/ {-1, 0},{ 4, 0},{ 0, 1},{-1, 0},{-1, 0},{ 4, 0},{-1, 0},{-1, 0},
272 /*e8*/ { 3,-1},{-1,-1},{ 0, 1},{-1,-1},{ 0,-1},{-1,-1},{-1,-1},{ 0, 0},
273 /*f0*/ {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
274 /*f8*/ {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
277 static char *pbook_type
[] = {
279 "PowerBook 2400/3400/3500(G3)",
280 "PowerBook G3 Series",
285 int __init
find_via_pmu(void)
287 #ifdef CONFIG_PPC_PMAC
291 if (pmu_state
!= uninitialized
)
293 vias
= of_find_node_by_name(NULL
, "via-pmu");
297 reg
= of_get_property(vias
, "reg", NULL
);
299 printk(KERN_ERR
"via-pmu: No \"reg\" property !\n");
302 taddr
= of_translate_address(vias
, reg
);
303 if (taddr
== OF_BAD_ADDR
) {
304 printk(KERN_ERR
"via-pmu: Can't translate address !\n");
308 spin_lock_init(&pmu_lock
);
312 pmu_intr_mask
= PMU_INT_PCEJECT
|
317 if (of_node_name_eq(vias
->parent
, "ohare") ||
318 of_device_is_compatible(vias
->parent
, "ohare"))
319 pmu_kind
= PMU_OHARE_BASED
;
320 else if (of_device_is_compatible(vias
->parent
, "paddington"))
321 pmu_kind
= PMU_PADDINGTON_BASED
;
322 else if (of_device_is_compatible(vias
->parent
, "heathrow"))
323 pmu_kind
= PMU_HEATHROW_BASED
;
324 else if (of_device_is_compatible(vias
->parent
, "Keylargo")
325 || of_device_is_compatible(vias
->parent
, "K2-Keylargo")) {
326 struct device_node
*gpiop
;
327 struct device_node
*adbp
;
328 u64 gaddr
= OF_BAD_ADDR
;
330 pmu_kind
= PMU_KEYLARGO_BASED
;
331 adbp
= of_find_node_by_type(NULL
, "adb");
332 pmu_has_adb
= (adbp
!= NULL
);
334 pmu_intr_mask
= PMU_INT_PCEJECT
|
340 gpiop
= of_find_node_by_name(NULL
, "gpio");
342 reg
= of_get_property(gpiop
, "reg", NULL
);
344 gaddr
= of_translate_address(gpiop
, reg
);
345 if (gaddr
!= OF_BAD_ADDR
)
346 gpio_reg
= ioremap(gaddr
, 0x10);
349 if (gpio_reg
== NULL
) {
350 printk(KERN_ERR
"via-pmu: Can't find GPIO reg !\n");
354 pmu_kind
= PMU_UNKNOWN
;
356 via1
= via2
= ioremap(taddr
, 0x2000);
358 printk(KERN_ERR
"via-pmu: Can't map address !\n");
362 out_8(&via1
[IER
], IER_CLR
| 0x7f); /* disable all intrs */
363 out_8(&via1
[IFR
], 0x7f); /* clear IFR */
370 sys_ctrler
= SYS_CTRLER_PMU
;
383 pmu_state
= uninitialized
;
386 if (macintosh_config
->adb_type
!= MAC_ADB_PB2
)
389 pmu_kind
= PMU_UNKNOWN
;
391 spin_lock_init(&pmu_lock
);
395 pmu_intr_mask
= PMU_INT_PCEJECT
|
403 pmu_state
= uninitialized
;
408 #endif /* !CONFIG_PPC_PMAC */
412 static int pmu_probe(void)
414 return pmu_state
== uninitialized
? -ENODEV
: 0;
417 static int pmu_init(void)
419 return pmu_state
== uninitialized
? -ENODEV
: 0;
421 #endif /* CONFIG_ADB */
424 * We can't wait until pmu_init gets called, that happens too late.
425 * It happens after IDE and SCSI initialization, which can take a few
426 * seconds, and by that time the PMU could have given up on us and
428 * Thus this is called with arch_initcall rather than device_initcall.
430 static int __init
via_pmu_start(void)
432 unsigned int __maybe_unused irq
;
434 if (pmu_state
== uninitialized
)
437 batt_req
.complete
= 1;
439 #ifdef CONFIG_PPC_PMAC
440 irq
= irq_of_parse_and_map(vias
, 0);
442 printk(KERN_ERR
"via-pmu: can't map interrupt\n");
445 /* We set IRQF_NO_SUSPEND because we don't want the interrupt
446 * to be disabled between the 2 passes of driver suspend, we
447 * control our own disabling for that one
449 if (request_irq(irq
, via_pmu_interrupt
, IRQF_NO_SUSPEND
,
450 "VIA-PMU", (void *)0)) {
451 printk(KERN_ERR
"via-pmu: can't request irq %d\n", irq
);
455 if (pmu_kind
== PMU_KEYLARGO_BASED
) {
456 gpio_node
= of_find_node_by_name(NULL
, "extint-gpio1");
457 if (gpio_node
== NULL
)
458 gpio_node
= of_find_node_by_name(NULL
,
461 gpio_irq
= irq_of_parse_and_map(gpio_node
, 0);
464 if (request_irq(gpio_irq
, gpio1_interrupt
,
465 IRQF_NO_SUSPEND
, "GPIO1 ADB",
467 printk(KERN_ERR
"pmu: can't get irq %d"
468 " (GPIO1)\n", gpio_irq
);
470 gpio_irq_enabled
= 1;
474 /* Enable interrupts */
475 out_8(&via1
[IER
], IER_SET
| SR_INT
| CB1_INT
);
477 if (request_irq(IRQ_MAC_ADB_SR
, via_pmu_interrupt
, IRQF_NO_SUSPEND
,
478 "VIA-PMU-SR", NULL
)) {
479 pr_err("%s: couldn't get SR irq\n", __func__
);
482 if (request_irq(IRQ_MAC_ADB_CL
, via_pmu_interrupt
, IRQF_NO_SUSPEND
,
483 "VIA-PMU-CL", NULL
)) {
484 pr_err("%s: couldn't get CL irq\n", __func__
);
485 free_irq(IRQ_MAC_ADB_SR
, NULL
);
488 #endif /* !CONFIG_PPC_PMAC */
490 pmu_fully_inited
= 1;
492 /* Make sure PMU settle down before continuing. This is _very_ important
493 * since the IDE probe may shut interrupts down for quite a bit of time. If
494 * a PMU communication is pending while this happens, the PMU may timeout
495 * Not that on Core99 machines, the PMU keeps sending us environement
496 * messages, we should find a way to either fix IDE or make it call
497 * pmu_suspend() before masking interrupts. This can also happens while
498 * scolling with some fbdevs.
502 } while (pmu_state
!= idle
);
507 arch_initcall(via_pmu_start
);
510 * This has to be done after pci_init, which is a subsys_initcall.
512 static int __init
via_pmu_dev_init(void)
514 if (pmu_state
== uninitialized
)
517 #ifdef CONFIG_PMAC_BACKLIGHT
518 /* Initialize backlight */
519 pmu_backlight_init();
523 if (of_machine_is_compatible("AAPL,3400/2400") ||
524 of_machine_is_compatible("AAPL,3500")) {
525 int mb
= pmac_call_feature(PMAC_FTR_GET_MB_INFO
,
526 NULL
, PMAC_MB_INFO_MODEL
, 0);
527 pmu_battery_count
= 1;
528 if (mb
== PMAC_TYPE_COMET
)
529 pmu_batteries
[0].flags
|= PMU_BATT_TYPE_COMET
;
531 pmu_batteries
[0].flags
|= PMU_BATT_TYPE_HOOPER
;
532 } else if (of_machine_is_compatible("AAPL,PowerBook1998") ||
533 of_machine_is_compatible("PowerBook1,1")) {
534 pmu_battery_count
= 2;
535 pmu_batteries
[0].flags
|= PMU_BATT_TYPE_SMART
;
536 pmu_batteries
[1].flags
|= PMU_BATT_TYPE_SMART
;
538 struct device_node
* prim
=
539 of_find_node_by_name(NULL
, "power-mgt");
540 const u32
*prim_info
= NULL
;
542 prim_info
= of_get_property(prim
, "prim-info", NULL
);
544 /* Other stuffs here yet unknown */
545 pmu_battery_count
= (prim_info
[6] >> 16) & 0xff;
546 pmu_batteries
[0].flags
|= PMU_BATT_TYPE_SMART
;
547 if (pmu_battery_count
> 1)
548 pmu_batteries
[1].flags
|= PMU_BATT_TYPE_SMART
;
552 #endif /* CONFIG_PPC32 */
554 /* Create /proc/pmu */
555 proc_pmu_root
= proc_mkdir("pmu", NULL
);
559 for (i
=0; i
<pmu_battery_count
; i
++) {
561 sprintf(title
, "battery_%ld", i
);
562 proc_pmu_batt
[i
] = proc_create_single_data(title
, 0,
563 proc_pmu_root
, pmu_battery_proc_show
,
567 proc_pmu_info
= proc_create_single("info", 0, proc_pmu_root
,
569 proc_pmu_irqstats
= proc_create_single("interrupts", 0,
570 proc_pmu_root
, pmu_irqstats_proc_show
);
571 proc_pmu_options
= proc_create("options", 0600, proc_pmu_root
,
572 &pmu_options_proc_ops
);
577 device_initcall(via_pmu_dev_init
);
583 struct adb_request req
;
585 /* Negate TREQ. Set TACK to input and TREQ to output. */
586 out_8(&via2
[B
], in_8(&via2
[B
]) | TREQ
);
587 out_8(&via2
[DIRB
], (in_8(&via2
[DIRB
]) | TREQ
) & ~TACK
);
589 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, pmu_intr_mask
);
591 while (!req
.complete
) {
593 printk(KERN_ERR
"init_pmu: no response from PMU\n");
600 /* ack all pending interrupts */
602 interrupt_data
[0][0] = 1;
603 while (interrupt_data
[0][0] || pmu_state
!= idle
) {
605 printk(KERN_ERR
"init_pmu: timed out acking intrs\n");
608 if (pmu_state
== idle
)
610 via_pmu_interrupt(0, NULL
);
614 /* Tell PMU we are ready. */
615 if (pmu_kind
== PMU_KEYLARGO_BASED
) {
616 pmu_request(&req
, NULL
, 2, PMU_SYSTEM_READY
, 2);
617 while (!req
.complete
)
621 /* Read PMU version */
622 pmu_request(&req
, NULL
, 1, PMU_GET_VERSION
);
623 pmu_wait_complete(&req
);
624 if (req
.reply_len
> 0)
625 pmu_version
= req
.reply
[0];
627 /* Read server mode setting */
628 if (pmu_kind
== PMU_KEYLARGO_BASED
) {
629 pmu_request(&req
, NULL
, 2, PMU_POWER_EVENTS
,
630 PMU_PWR_GET_POWERUP_EVENTS
);
631 pmu_wait_complete(&req
);
632 if (req
.reply_len
== 2) {
633 if (req
.reply
[1] & PMU_PWR_WAKEUP_AC_INSERT
)
634 option_server_mode
= 1;
635 printk(KERN_INFO
"via-pmu: Server Mode is %s\n",
636 option_server_mode
? "enabled" : "disabled");
640 printk(KERN_INFO
"PMU driver v%d initialized for %s, firmware: %02x\n",
641 PMU_DRIVER_VERSION
, pbook_type
[pmu_kind
], pmu_version
);
652 static void pmu_set_server_mode(int server_mode
)
654 struct adb_request req
;
656 if (pmu_kind
!= PMU_KEYLARGO_BASED
)
659 option_server_mode
= server_mode
;
660 pmu_request(&req
, NULL
, 2, PMU_POWER_EVENTS
, PMU_PWR_GET_POWERUP_EVENTS
);
661 pmu_wait_complete(&req
);
662 if (req
.reply_len
< 2)
665 pmu_request(&req
, NULL
, 4, PMU_POWER_EVENTS
,
666 PMU_PWR_SET_POWERUP_EVENTS
,
667 req
.reply
[0], PMU_PWR_WAKEUP_AC_INSERT
);
669 pmu_request(&req
, NULL
, 4, PMU_POWER_EVENTS
,
670 PMU_PWR_CLR_POWERUP_EVENTS
,
671 req
.reply
[0], PMU_PWR_WAKEUP_AC_INSERT
);
672 pmu_wait_complete(&req
);
675 /* This new version of the code for 2400/3400/3500 powerbooks
676 * is inspired from the implementation in gkrellm-pmu
679 done_battery_state_ohare(struct adb_request
* req
)
681 #ifdef CONFIG_PPC_PMAC
684 * 0x01 : AC indicator
686 * 0x04 : battery exist
689 * 0x20 : full charged
690 * 0x40 : pcharge reset
691 * 0x80 : battery exist
693 * [1][2] : battery voltage
694 * [3] : CPU temperature
695 * [4] : battery temperature
700 unsigned int bat_flags
= PMU_BATT_TYPE_HOOPER
;
701 long pcharge
, charge
, vb
, vmax
, lmax
;
702 long vmax_charging
, vmax_charged
;
703 long amperage
, voltage
, time
, max
;
704 int mb
= pmac_call_feature(PMAC_FTR_GET_MB_INFO
,
705 NULL
, PMAC_MB_INFO_MODEL
, 0);
707 if (req
->reply
[0] & 0x01)
708 pmu_power_flags
|= PMU_PWR_AC_PRESENT
;
710 pmu_power_flags
&= ~PMU_PWR_AC_PRESENT
;
712 if (mb
== PMAC_TYPE_COMET
) {
723 /* If battery installed */
724 if (req
->reply
[0] & 0x04) {
725 bat_flags
|= PMU_BATT_PRESENT
;
726 if (req
->reply
[0] & 0x02)
727 bat_flags
|= PMU_BATT_CHARGING
;
728 vb
= (req
->reply
[1] << 8) | req
->reply
[2];
729 voltage
= (vb
* 265 + 72665) / 10;
730 amperage
= req
->reply
[5];
731 if ((req
->reply
[0] & 0x01) == 0) {
733 vb
+= ((amperage
- 200) * 15)/100;
734 } else if (req
->reply
[0] & 0x02) {
735 vb
= (vb
* 97) / 100;
736 vmax
= vmax_charging
;
738 charge
= (100 * vb
) / vmax
;
739 if (req
->reply
[0] & 0x40) {
740 pcharge
= (req
->reply
[6] << 8) + req
->reply
[7];
744 pcharge
= 100 - pcharge
/ lmax
;
745 if (pcharge
< charge
)
749 time
= (charge
* 16440) / amperage
;
753 amperage
= -amperage
;
755 charge
= max
= amperage
= voltage
= time
= 0;
757 pmu_batteries
[pmu_cur_battery
].flags
= bat_flags
;
758 pmu_batteries
[pmu_cur_battery
].charge
= charge
;
759 pmu_batteries
[pmu_cur_battery
].max_charge
= max
;
760 pmu_batteries
[pmu_cur_battery
].amperage
= amperage
;
761 pmu_batteries
[pmu_cur_battery
].voltage
= voltage
;
762 pmu_batteries
[pmu_cur_battery
].time_remaining
= time
;
763 #endif /* CONFIG_PPC_PMAC */
765 clear_bit(0, &async_req_locks
);
769 done_battery_state_smart(struct adb_request
* req
)
772 * [0] : format of this structure (known: 3,4,5)
785 * [4][5] : max charge
790 unsigned int bat_flags
= PMU_BATT_TYPE_SMART
;
792 unsigned int capa
, max
, voltage
;
794 if (req
->reply
[1] & 0x01)
795 pmu_power_flags
|= PMU_PWR_AC_PRESENT
;
797 pmu_power_flags
&= ~PMU_PWR_AC_PRESENT
;
800 capa
= max
= amperage
= voltage
= 0;
802 if (req
->reply
[1] & 0x04) {
803 bat_flags
|= PMU_BATT_PRESENT
;
804 switch(req
->reply
[0]) {
806 case 4: capa
= req
->reply
[2];
808 amperage
= *((signed char *)&req
->reply
[4]);
809 voltage
= req
->reply
[5];
811 case 5: capa
= (req
->reply
[2] << 8) | req
->reply
[3];
812 max
= (req
->reply
[4] << 8) | req
->reply
[5];
813 amperage
= *((signed short *)&req
->reply
[6]);
814 voltage
= (req
->reply
[8] << 8) | req
->reply
[9];
817 pr_warn("pmu.c: unrecognized battery info, "
818 "len: %d, %4ph\n", req
->reply_len
,
824 if ((req
->reply
[1] & 0x01) && (amperage
> 0))
825 bat_flags
|= PMU_BATT_CHARGING
;
827 pmu_batteries
[pmu_cur_battery
].flags
= bat_flags
;
828 pmu_batteries
[pmu_cur_battery
].charge
= capa
;
829 pmu_batteries
[pmu_cur_battery
].max_charge
= max
;
830 pmu_batteries
[pmu_cur_battery
].amperage
= amperage
;
831 pmu_batteries
[pmu_cur_battery
].voltage
= voltage
;
833 if ((req
->reply
[1] & 0x01) && (amperage
> 0))
834 pmu_batteries
[pmu_cur_battery
].time_remaining
835 = ((max
-capa
) * 3600) / amperage
;
837 pmu_batteries
[pmu_cur_battery
].time_remaining
838 = (capa
* 3600) / (-amperage
);
840 pmu_batteries
[pmu_cur_battery
].time_remaining
= 0;
842 pmu_cur_battery
= (pmu_cur_battery
+ 1) % pmu_battery_count
;
844 clear_bit(0, &async_req_locks
);
848 query_battery_state(void)
850 if (test_and_set_bit(0, &async_req_locks
))
852 if (pmu_kind
== PMU_OHARE_BASED
)
853 pmu_request(&batt_req
, done_battery_state_ohare
,
854 1, PMU_BATTERY_STATE
);
856 pmu_request(&batt_req
, done_battery_state_smart
,
857 2, PMU_SMART_BATTERY_STATE
, pmu_cur_battery
+1);
860 static int pmu_info_proc_show(struct seq_file
*m
, void *v
)
862 seq_printf(m
, "PMU driver version : %d\n", PMU_DRIVER_VERSION
);
863 seq_printf(m
, "PMU firmware version : %02x\n", pmu_version
);
864 seq_printf(m
, "AC Power : %d\n",
865 ((pmu_power_flags
& PMU_PWR_AC_PRESENT
) != 0) || pmu_battery_count
== 0);
866 seq_printf(m
, "Battery count : %d\n", pmu_battery_count
);
871 static int pmu_irqstats_proc_show(struct seq_file
*m
, void *v
)
874 static const char *irq_names
[NUM_IRQ_STATS
] = {
875 "Unknown interrupt (type 0)",
876 "Unknown interrupt (type 1)",
877 "PC-Card eject button",
878 "Sound/Brightness button",
880 "Battery state change",
881 "Environment interrupt",
883 "Ghost interrupt (zero len)",
884 "Empty interrupt (empty mask)",
886 "Total CB1 triggered events",
887 "Total GPIO1 triggered events",
890 for (i
= 0; i
< NUM_IRQ_STATS
; i
++) {
891 seq_printf(m
, " %2u: %10u (%s)\n",
892 i
, pmu_irq_stats
[i
], irq_names
[i
]);
897 static int pmu_battery_proc_show(struct seq_file
*m
, void *v
)
899 long batnum
= (long)m
->private;
902 seq_printf(m
, "flags : %08x\n", pmu_batteries
[batnum
].flags
);
903 seq_printf(m
, "charge : %d\n", pmu_batteries
[batnum
].charge
);
904 seq_printf(m
, "max_charge : %d\n", pmu_batteries
[batnum
].max_charge
);
905 seq_printf(m
, "current : %d\n", pmu_batteries
[batnum
].amperage
);
906 seq_printf(m
, "voltage : %d\n", pmu_batteries
[batnum
].voltage
);
907 seq_printf(m
, "time rem. : %d\n", pmu_batteries
[batnum
].time_remaining
);
911 static int pmu_options_proc_show(struct seq_file
*m
, void *v
)
913 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
914 if (pmu_kind
== PMU_KEYLARGO_BASED
&&
915 pmac_call_feature(PMAC_FTR_SLEEP_STATE
,NULL
,0,-1) >= 0)
916 seq_printf(m
, "lid_wakeup=%d\n", option_lid_wakeup
);
918 if (pmu_kind
== PMU_KEYLARGO_BASED
)
919 seq_printf(m
, "server_mode=%d\n", option_server_mode
);
924 static int pmu_options_proc_open(struct inode
*inode
, struct file
*file
)
926 return single_open(file
, pmu_options_proc_show
, NULL
);
929 static ssize_t
pmu_options_proc_write(struct file
*file
,
930 const char __user
*buffer
, size_t count
, loff_t
*pos
)
934 size_t fcount
= count
;
940 if (copy_from_user(tmp
, buffer
, count
))
948 while(*val
&& (*val
!= '=')) {
958 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
959 if (pmu_kind
== PMU_KEYLARGO_BASED
&&
960 pmac_call_feature(PMAC_FTR_SLEEP_STATE
,NULL
,0,-1) >= 0)
961 if (!strcmp(label
, "lid_wakeup"))
962 option_lid_wakeup
= ((*val
) == '1');
964 if (pmu_kind
== PMU_KEYLARGO_BASED
&& !strcmp(label
, "server_mode")) {
966 new_value
= ((*val
) == '1');
967 if (new_value
!= option_server_mode
)
968 pmu_set_server_mode(new_value
);
973 static const struct proc_ops pmu_options_proc_ops
= {
974 .proc_open
= pmu_options_proc_open
,
975 .proc_read
= seq_read
,
976 .proc_lseek
= seq_lseek
,
977 .proc_release
= single_release
,
978 .proc_write
= pmu_options_proc_write
,
982 /* Send an ADB command */
983 static int pmu_send_request(struct adb_request
*req
, int sync
)
987 if (pmu_state
== uninitialized
|| !pmu_fully_inited
) {
994 switch (req
->data
[0]) {
996 for (i
= 0; i
< req
->nbytes
- 1; ++i
)
997 req
->data
[i
] = req
->data
[i
+1];
999 if (pmu_data_len
[req
->data
[0]][1] != 0) {
1000 req
->reply
[0] = ADB_RET_OK
;
1004 ret
= pmu_queue_request(req
);
1007 switch (req
->data
[1]) {
1009 if (req
->nbytes
!= 2)
1011 req
->data
[0] = PMU_READ_RTC
;
1014 req
->reply
[0] = CUDA_PACKET
;
1016 req
->reply
[2] = CUDA_GET_TIME
;
1017 ret
= pmu_queue_request(req
);
1020 if (req
->nbytes
!= 6)
1022 req
->data
[0] = PMU_SET_RTC
;
1024 for (i
= 1; i
<= 4; ++i
)
1025 req
->data
[i
] = req
->data
[i
+1];
1027 req
->reply
[0] = CUDA_PACKET
;
1029 req
->reply
[2] = CUDA_SET_TIME
;
1030 ret
= pmu_queue_request(req
);
1037 for (i
= req
->nbytes
- 1; i
> 1; --i
)
1038 req
->data
[i
+2] = req
->data
[i
];
1039 req
->data
[3] = req
->nbytes
- 2;
1040 req
->data
[2] = pmu_adb_flags
;
1041 /*req->data[1] = req->data[1];*/
1042 req
->data
[0] = PMU_ADB_CMD
;
1044 req
->reply_expected
= 1;
1046 ret
= pmu_queue_request(req
);
1055 while (!req
->complete
)
1061 /* Enable/disable autopolling */
1062 static int __pmu_adb_autopoll(int devs
)
1064 struct adb_request req
;
1067 pmu_request(&req
, NULL
, 5, PMU_ADB_CMD
, 0, 0x86,
1068 adb_dev_map
>> 8, adb_dev_map
);
1071 pmu_request(&req
, NULL
, 1, PMU_ADB_POLL_OFF
);
1074 while (!req
.complete
)
1079 static int pmu_adb_autopoll(int devs
)
1081 if (pmu_state
== uninitialized
|| !pmu_fully_inited
|| !pmu_has_adb
)
1085 return __pmu_adb_autopoll(devs
);
1088 /* Reset the ADB bus */
1089 static int pmu_adb_reset_bus(void)
1091 struct adb_request req
;
1092 int save_autopoll
= adb_dev_map
;
1094 if (pmu_state
== uninitialized
|| !pmu_fully_inited
|| !pmu_has_adb
)
1097 /* anyone got a better idea?? */
1098 __pmu_adb_autopoll(0);
1102 req
.data
[0] = PMU_ADB_CMD
;
1103 req
.data
[1] = ADB_BUSRESET
;
1108 req
.reply_expected
= 1;
1109 if (pmu_queue_request(&req
) != 0) {
1110 printk(KERN_ERR
"pmu_adb_reset_bus: pmu_queue_request failed\n");
1113 pmu_wait_complete(&req
);
1115 if (save_autopoll
!= 0)
1116 __pmu_adb_autopoll(save_autopoll
);
1120 #endif /* CONFIG_ADB */
1122 /* Construct and send a pmu request */
1124 pmu_request(struct adb_request
*req
, void (*done
)(struct adb_request
*),
1130 if (pmu_state
== uninitialized
)
1133 if (nbytes
< 0 || nbytes
> 32) {
1134 printk(KERN_ERR
"pmu_request: bad nbytes (%d)\n", nbytes
);
1138 req
->nbytes
= nbytes
;
1140 va_start(list
, nbytes
);
1141 for (i
= 0; i
< nbytes
; ++i
)
1142 req
->data
[i
] = va_arg(list
, int);
1145 req
->reply_expected
= 0;
1146 return pmu_queue_request(req
);
1150 pmu_queue_request(struct adb_request
*req
)
1152 unsigned long flags
;
1155 if (pmu_state
== uninitialized
) {
1159 if (req
->nbytes
<= 0) {
1163 nsend
= pmu_data_len
[req
->data
[0]][0];
1164 if (nsend
>= 0 && req
->nbytes
!= nsend
+ 1) {
1173 spin_lock_irqsave(&pmu_lock
, flags
);
1175 last_req
->next
= req
;
1180 if (pmu_state
== idle
)
1183 spin_unlock_irqrestore(&pmu_lock
, flags
);
1191 /* Sightly increased the delay, I had one occurrence of the message
1195 while ((in_8(&via2
[B
]) & TACK
) == 0) {
1196 if (--timeout
< 0) {
1197 printk(KERN_ERR
"PMU not responding (!ack)\n");
1204 /* New PMU seems to be very sensitive to those timings, so we make sure
1205 * PCI is flushed immediately */
1209 out_8(&via1
[ACR
], in_8(&via1
[ACR
]) | SR_OUT
| SR_EXT
);
1210 out_8(&via1
[SR
], x
);
1211 out_8(&via2
[B
], in_8(&via2
[B
]) & ~TREQ
); /* assert TREQ */
1212 (void)in_8(&via2
[B
]);
1218 out_8(&via1
[ACR
], (in_8(&via1
[ACR
]) & ~SR_OUT
) | SR_EXT
);
1219 in_8(&via1
[SR
]); /* resets SR */
1220 out_8(&via2
[B
], in_8(&via2
[B
]) & ~TREQ
);
1221 (void)in_8(&via2
[B
]);
1225 pmu_done(struct adb_request
*req
)
1227 void (*done
)(struct adb_request
*) = req
->done
;
1230 /* Here, we assume that if the request has a done member, the
1231 * struct request will survive to setting req->complete to 1
1240 struct adb_request
*req
;
1242 /* assert pmu_state == idle */
1243 /* get the packet to send */
1245 if (!req
|| pmu_state
!= idle
1246 || (/*req->reply_expected && */req_awaiting_reply
))
1249 pmu_state
= sending
;
1251 data_len
= pmu_data_len
[req
->data
[0]][0];
1253 /* Sounds safer to make sure ACK is high before writing. This helped
1254 * kill a problem with ADB and some iBooks
1257 /* set the shift register to shift out and send a byte */
1258 send_byte(req
->data
[0]);
1264 if (pmu_state
== uninitialized
)
1268 via_pmu_interrupt(0, NULL
);
1274 if (pmu_state
== uninitialized
)
1278 /* Kicks ADB read when PMU is suspended */
1279 adb_int_pending
= 1;
1281 via_pmu_interrupt(0, NULL
);
1282 } while (pmu_suspended
&& (adb_int_pending
|| pmu_state
!= idle
1283 || req_awaiting_reply
));
1287 pmu_wait_complete(struct adb_request
*req
)
1289 if (pmu_state
== uninitialized
)
1291 while((pmu_state
!= idle
&& pmu_state
!= locked
) || !req
->complete
)
1292 via_pmu_interrupt(0, NULL
);
1295 /* This function loops until the PMU is idle and prevents it from
1296 * anwsering to ADB interrupts. pmu_request can still be called.
1297 * This is done to avoid spurrious shutdowns when we know we'll have
1298 * interrupts switched off for a long time
1303 unsigned long flags
;
1305 if (pmu_state
== uninitialized
)
1308 spin_lock_irqsave(&pmu_lock
, flags
);
1310 if (pmu_suspended
> 1) {
1311 spin_unlock_irqrestore(&pmu_lock
, flags
);
1316 spin_unlock_irqrestore(&pmu_lock
, flags
);
1317 if (req_awaiting_reply
)
1318 adb_int_pending
= 1;
1319 via_pmu_interrupt(0, NULL
);
1320 spin_lock_irqsave(&pmu_lock
, flags
);
1321 if (!adb_int_pending
&& pmu_state
== idle
&& !req_awaiting_reply
) {
1323 disable_irq_nosync(gpio_irq
);
1324 out_8(&via1
[IER
], CB1_INT
| IER_CLR
);
1325 spin_unlock_irqrestore(&pmu_lock
, flags
);
1334 unsigned long flags
;
1336 if (pmu_state
== uninitialized
|| pmu_suspended
< 1)
1339 spin_lock_irqsave(&pmu_lock
, flags
);
1341 if (pmu_suspended
> 0) {
1342 spin_unlock_irqrestore(&pmu_lock
, flags
);
1345 adb_int_pending
= 1;
1347 enable_irq(gpio_irq
);
1348 out_8(&via1
[IER
], CB1_INT
| IER_SET
);
1349 spin_unlock_irqrestore(&pmu_lock
, flags
);
1353 /* Interrupt data could be the result data from an ADB cmd */
1355 pmu_handle_data(unsigned char *data
, int len
)
1362 if (drop_interrupts
|| len
< 1) {
1363 adb_int_pending
= 0;
1368 /* Get PMU interrupt mask */
1371 /* Record zero interrupts for stats */
1375 /* Hack to deal with ADB autopoll flag */
1376 if (ints
& PMU_INT_ADB
)
1377 ints
&= ~(PMU_INT_ADB_AUTO
| PMU_INT_AUTO_SRQ_POLL
);
1381 if (i
> pmu_irq_stats
[10])
1382 pmu_irq_stats
[10] = i
;
1387 idx
= ffs(ints
) - 1;
1390 pmu_irq_stats
[idx
]++;
1392 /* Note: for some reason, we get an interrupt with len=1,
1393 * data[0]==0 after each normal ADB interrupt, at least
1394 * on the Pismo. Still investigating... --BenH
1398 if ((data
[0] & PMU_INT_ADB_AUTO
) == 0) {
1399 struct adb_request
*req
= req_awaiting_reply
;
1401 printk(KERN_ERR
"PMU: extra ADB reply\n");
1404 req_awaiting_reply
= NULL
;
1408 memcpy(req
->reply
, data
+ 1, len
- 1);
1409 req
->reply_len
= len
- 1;
1414 if (len
== 4 && data
[1] == 0x2c) {
1415 extern int xmon_wants_key
, xmon_adb_keycode
;
1416 if (xmon_wants_key
) {
1417 xmon_adb_keycode
= data
[2];
1421 #endif /* CONFIG_XMON */
1424 * XXX On the [23]400 the PMU gives us an up
1425 * event for keycodes 0x74 or 0x75 when the PC
1426 * card eject buttons are released, so we
1427 * ignore those events.
1429 if (!(pmu_kind
== PMU_OHARE_BASED
&& len
== 4
1430 && data
[1] == 0x2c && data
[3] == 0xff
1431 && (data
[2] & ~1) == 0xf4))
1432 adb_input(data
+1, len
-1, 1);
1433 #endif /* CONFIG_ADB */
1437 /* Sound/brightness button pressed */
1438 case PMU_INT_SNDBRT
:
1439 #ifdef CONFIG_PMAC_BACKLIGHT
1441 pmac_backlight_set_legacy_brightness_pmu(data
[1] >> 4);
1445 /* Tick interrupt */
1447 /* Environment or tick interrupt, query batteries */
1448 if (pmu_battery_count
) {
1449 if ((--query_batt_timer
) == 0) {
1450 query_battery_state();
1451 query_batt_timer
= BATTERY_POLLING_COUNT
;
1456 case PMU_INT_ENVIRONMENT
:
1457 if (pmu_battery_count
)
1458 query_battery_state();
1459 pmu_pass_intr(data
, len
);
1460 /* len == 6 is probably a bad check. But how do I
1461 * know what PMU versions send what events here? */
1463 via_pmu_event(PMU_EVT_POWER
, !!(data
[1]&8));
1464 via_pmu_event(PMU_EVT_LID
, data
[1]&1);
1469 pmu_pass_intr(data
, len
);
1474 static struct adb_request
*
1477 struct adb_request
*req
;
1480 if (in_8(&via2
[B
]) & TREQ
) {
1481 printk(KERN_ERR
"PMU: spurious SR intr (%x)\n", in_8(&via2
[B
]));
1484 /* The ack may not yet be low when we get the interrupt */
1485 while ((in_8(&via2
[B
]) & TACK
) != 0)
1488 /* if reading grab the byte, and reset the interrupt */
1489 if (pmu_state
== reading
|| pmu_state
== reading_intr
)
1490 bite
= in_8(&via1
[SR
]);
1492 /* reset TREQ and wait for TACK to go high */
1493 out_8(&via2
[B
], in_8(&via2
[B
]) | TREQ
);
1496 switch (pmu_state
) {
1500 data_len
= req
->nbytes
- 1;
1501 send_byte(data_len
);
1504 if (data_index
<= data_len
) {
1505 send_byte(req
->data
[data_index
++]);
1509 data_len
= pmu_data_len
[req
->data
[0]][1];
1510 if (data_len
== 0) {
1512 current_req
= req
->next
;
1513 if (req
->reply_expected
)
1514 req_awaiting_reply
= req
;
1518 pmu_state
= reading
;
1520 reply_ptr
= req
->reply
+ req
->reply_len
;
1528 pmu_state
= reading_intr
;
1529 reply_ptr
= interrupt_data
[int_data_last
];
1531 if (gpio_irq
>= 0 && !gpio_irq_enabled
) {
1532 enable_irq(gpio_irq
);
1533 gpio_irq_enabled
= 1;
1539 if (data_len
== -1) {
1542 printk(KERN_ERR
"PMU: bad reply len %d\n", bite
);
1543 } else if (data_index
< 32) {
1544 reply_ptr
[data_index
++] = bite
;
1546 if (data_index
< data_len
) {
1551 if (pmu_state
== reading_intr
) {
1553 int_data_state
[int_data_last
] = int_data_ready
;
1554 interrupt_data_len
[int_data_last
] = data_len
;
1558 * For PMU sleep and freq change requests, we lock the
1559 * PMU until it's explicitly unlocked. This avoids any
1560 * spurrious event polling getting in
1562 current_req
= req
->next
;
1563 req
->reply_len
+= data_index
;
1564 if (req
->data
[0] == PMU_SLEEP
|| req
->data
[0] == PMU_CPU_SPEED
)
1573 printk(KERN_ERR
"via_pmu_interrupt: unknown state %d?\n",
1580 via_pmu_interrupt(int irq
, void *arg
)
1582 unsigned long flags
;
1586 struct adb_request
*req
= NULL
;
1589 /* This is a bit brutal, we can probably do better */
1590 spin_lock_irqsave(&pmu_lock
, flags
);
1594 /* On 68k Macs, VIA interrupts are dispatched individually.
1595 * Unless we are polling, the relevant IRQ flag has already
1599 if (IS_ENABLED(CONFIG_PPC_PMAC
) || !irq
) {
1600 intr
= in_8(&via1
[IFR
]) & (SR_INT
| CB1_INT
);
1601 out_8(&via1
[IFR
], intr
);
1603 #ifndef CONFIG_PPC_PMAC
1605 case IRQ_MAC_ADB_CL
:
1608 case IRQ_MAC_ADB_SR
:
1616 if (++nloop
> 1000) {
1617 printk(KERN_DEBUG
"PMU: stuck in intr loop, "
1618 "intr=%x, ier=%x pmu_state=%d\n",
1619 intr
, in_8(&via1
[IER
]), pmu_state
);
1622 if (intr
& CB1_INT
) {
1623 adb_int_pending
= 1;
1624 pmu_irq_stats
[11]++;
1626 if (intr
& SR_INT
) {
1627 req
= pmu_sr_intr();
1631 #ifndef CONFIG_PPC_PMAC
1637 if (pmu_state
== idle
) {
1638 if (adb_int_pending
) {
1639 if (int_data_state
[0] == int_data_empty
)
1641 else if (int_data_state
[1] == int_data_empty
)
1646 int_data_state
[int_data_last
] = int_data_fill
;
1647 /* Sounds safer to make sure ACK is high before writing.
1648 * This helped kill a problem with ADB and some iBooks
1651 send_byte(PMU_INT_ACK
);
1652 adb_int_pending
= 0;
1653 } else if (current_req
)
1657 /* Mark the oldest buffer for flushing */
1658 if (int_data_state
[!int_data_last
] == int_data_ready
) {
1659 int_data_state
[!int_data_last
] = int_data_flush
;
1660 int_data
= !int_data_last
;
1661 } else if (int_data_state
[int_data_last
] == int_data_ready
) {
1662 int_data_state
[int_data_last
] = int_data_flush
;
1663 int_data
= int_data_last
;
1666 spin_unlock_irqrestore(&pmu_lock
, flags
);
1668 /* Deal with completed PMU requests outside of the lock */
1674 /* Deal with interrupt datas outside of the lock */
1675 if (int_data
>= 0) {
1676 pmu_handle_data(interrupt_data
[int_data
], interrupt_data_len
[int_data
]);
1677 spin_lock_irqsave(&pmu_lock
, flags
);
1679 int_data_state
[int_data
] = int_data_empty
;
1684 return IRQ_RETVAL(handled
);
1690 unsigned long flags
;
1692 spin_lock_irqsave(&pmu_lock
, flags
);
1693 if (pmu_state
== locked
)
1695 adb_int_pending
= 1;
1696 spin_unlock_irqrestore(&pmu_lock
, flags
);
1700 static __maybe_unused irqreturn_t
1701 gpio1_interrupt(int irq
, void *arg
)
1703 unsigned long flags
;
1705 if ((in_8(gpio_reg
+ 0x9) & 0x02) == 0) {
1706 spin_lock_irqsave(&pmu_lock
, flags
);
1707 if (gpio_irq_enabled
> 0) {
1708 disable_irq_nosync(gpio_irq
);
1709 gpio_irq_enabled
= 0;
1711 pmu_irq_stats
[12]++;
1712 adb_int_pending
= 1;
1713 spin_unlock_irqrestore(&pmu_lock
, flags
);
1714 via_pmu_interrupt(0, NULL
);
1721 pmu_enable_irled(int on
)
1723 struct adb_request req
;
1725 if (pmu_state
== uninitialized
)
1727 if (pmu_kind
== PMU_KEYLARGO_BASED
)
1730 pmu_request(&req
, NULL
, 2, PMU_POWER_CTRL
, PMU_POW_IRLED
|
1731 (on
? PMU_POW_ON
: PMU_POW_OFF
));
1732 pmu_wait_complete(&req
);
1735 /* Offset between Unix time (1970-based) and Mac time (1904-based) */
1736 #define RTC_OFFSET 2082844800
1738 time64_t
pmu_get_time(void)
1740 struct adb_request req
;
1743 if (pmu_request(&req
, NULL
, 1, PMU_READ_RTC
) < 0)
1745 pmu_wait_complete(&req
);
1746 if (req
.reply_len
!= 4)
1747 pr_err("%s: got %d byte reply\n", __func__
, req
.reply_len
);
1748 now
= (req
.reply
[0] << 24) + (req
.reply
[1] << 16) +
1749 (req
.reply
[2] << 8) + req
.reply
[3];
1750 return (time64_t
)now
- RTC_OFFSET
;
1753 int pmu_set_rtc_time(struct rtc_time
*tm
)
1756 struct adb_request req
;
1758 now
= lower_32_bits(rtc_tm_to_time64(tm
) + RTC_OFFSET
);
1759 if (pmu_request(&req
, NULL
, 5, PMU_SET_RTC
,
1760 now
>> 24, now
>> 16, now
>> 8, now
) < 0)
1762 pmu_wait_complete(&req
);
1763 if (req
.reply_len
!= 0)
1764 pr_err("%s: got %d byte reply\n", __func__
, req
.reply_len
);
1771 struct adb_request req
;
1773 if (pmu_state
== uninitialized
)
1776 local_irq_disable();
1778 drop_interrupts
= 1;
1780 if (pmu_kind
!= PMU_KEYLARGO_BASED
) {
1781 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, PMU_INT_ADB
|
1783 while(!req
.complete
)
1787 pmu_request(&req
, NULL
, 1, PMU_RESET
);
1788 pmu_wait_complete(&req
);
1796 struct adb_request req
;
1798 if (pmu_state
== uninitialized
)
1801 local_irq_disable();
1803 drop_interrupts
= 1;
1805 if (pmu_kind
!= PMU_KEYLARGO_BASED
) {
1806 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, PMU_INT_ADB
|
1808 pmu_wait_complete(&req
);
1810 /* Disable server mode on shutdown or we'll just
1813 pmu_set_server_mode(0);
1816 pmu_request(&req
, NULL
, 5, PMU_SHUTDOWN
,
1817 'M', 'A', 'T', 'T');
1818 pmu_wait_complete(&req
);
1826 return pmu_state
!= uninitialized
;
1829 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
1831 * Put the powerbook to sleep.
1834 static u32 save_via
[8];
1835 static int __fake_sleep
;
1838 save_via_state(void)
1840 save_via
[0] = in_8(&via1
[ANH
]);
1841 save_via
[1] = in_8(&via1
[DIRA
]);
1842 save_via
[2] = in_8(&via1
[B
]);
1843 save_via
[3] = in_8(&via1
[DIRB
]);
1844 save_via
[4] = in_8(&via1
[PCR
]);
1845 save_via
[5] = in_8(&via1
[ACR
]);
1846 save_via
[6] = in_8(&via1
[T1CL
]);
1847 save_via
[7] = in_8(&via1
[T1CH
]);
1850 restore_via_state(void)
1852 out_8(&via1
[ANH
], save_via
[0]);
1853 out_8(&via1
[DIRA
], save_via
[1]);
1854 out_8(&via1
[B
], save_via
[2]);
1855 out_8(&via1
[DIRB
], save_via
[3]);
1856 out_8(&via1
[PCR
], save_via
[4]);
1857 out_8(&via1
[ACR
], save_via
[5]);
1858 out_8(&via1
[T1CL
], save_via
[6]);
1859 out_8(&via1
[T1CH
], save_via
[7]);
1860 out_8(&via1
[IER
], IER_CLR
| 0x7f); /* disable all intrs */
1861 out_8(&via1
[IFR
], 0x7f); /* clear IFR */
1862 out_8(&via1
[IER
], IER_SET
| SR_INT
| CB1_INT
);
1865 #define GRACKLE_PM (1<<7)
1866 #define GRACKLE_DOZE (1<<5)
1867 #define GRACKLE_NAP (1<<4)
1868 #define GRACKLE_SLEEP (1<<3)
1870 static int powerbook_sleep_grackle(void)
1872 unsigned long save_l2cr
;
1873 unsigned short pmcr1
;
1874 struct adb_request req
;
1875 struct pci_dev
*grackle
;
1877 grackle
= pci_get_domain_bus_and_slot(0, 0, 0);
1881 /* Turn off various things. Darwin does some retry tests here... */
1882 pmu_request(&req
, NULL
, 2, PMU_POWER_CTRL0
, PMU_POW0_OFF
|PMU_POW0_HARD_DRIVE
);
1883 pmu_wait_complete(&req
);
1884 pmu_request(&req
, NULL
, 2, PMU_POWER_CTRL
,
1885 PMU_POW_OFF
|PMU_POW_BACKLIGHT
|PMU_POW_IRLED
|PMU_POW_MEDIABAY
);
1886 pmu_wait_complete(&req
);
1888 /* For 750, save backside cache setting and disable it */
1889 save_l2cr
= _get_L2CR(); /* (returns -1 if not available) */
1891 if (!__fake_sleep
) {
1892 /* Ask the PMU to put us to sleep */
1893 pmu_request(&req
, NULL
, 5, PMU_SLEEP
, 'M', 'A', 'T', 'T');
1894 pmu_wait_complete(&req
);
1897 /* The VIA is supposed not to be restored correctly*/
1899 /* We shut down some HW */
1900 pmac_call_feature(PMAC_FTR_SLEEP_STATE
,NULL
,0,1);
1902 pci_read_config_word(grackle
, 0x70, &pmcr1
);
1903 /* Apparently, MacOS uses NAP mode for Grackle ??? */
1904 pmcr1
&= ~(GRACKLE_DOZE
|GRACKLE_SLEEP
);
1905 pmcr1
|= GRACKLE_PM
|GRACKLE_NAP
;
1906 pci_write_config_word(grackle
, 0x70, pmcr1
);
1908 /* Call low-level ASM sleep handler */
1912 low_sleep_handler();
1914 /* We're awake again, stop grackle PM */
1915 pci_read_config_word(grackle
, 0x70, &pmcr1
);
1916 pmcr1
&= ~(GRACKLE_PM
|GRACKLE_DOZE
|GRACKLE_SLEEP
|GRACKLE_NAP
);
1917 pci_write_config_word(grackle
, 0x70, pmcr1
);
1919 pci_dev_put(grackle
);
1921 /* Make sure the PMU is idle */
1922 pmac_call_feature(PMAC_FTR_SLEEP_STATE
,NULL
,0,0);
1923 restore_via_state();
1925 /* Restore L2 cache */
1926 if (save_l2cr
!= 0xffffffff && (save_l2cr
& L2CR_L2E
) != 0)
1927 _set_L2CR(save_l2cr
);
1929 /* Restore userland MMU context */
1930 switch_mmu_context(NULL
, current
->active_mm
, NULL
);
1932 /* Power things up */
1934 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, pmu_intr_mask
);
1935 pmu_wait_complete(&req
);
1936 pmu_request(&req
, NULL
, 2, PMU_POWER_CTRL0
,
1937 PMU_POW0_ON
|PMU_POW0_HARD_DRIVE
);
1938 pmu_wait_complete(&req
);
1939 pmu_request(&req
, NULL
, 2, PMU_POWER_CTRL
,
1940 PMU_POW_ON
|PMU_POW_BACKLIGHT
|PMU_POW_CHARGER
|PMU_POW_IRLED
|PMU_POW_MEDIABAY
);
1941 pmu_wait_complete(&req
);
1947 powerbook_sleep_Core99(void)
1949 unsigned long save_l2cr
;
1950 unsigned long save_l3cr
;
1951 struct adb_request req
;
1953 if (pmac_call_feature(PMAC_FTR_SLEEP_STATE
,NULL
,0,-1) < 0) {
1954 printk(KERN_ERR
"Sleep mode not supported on this machine\n");
1958 if (num_online_cpus() > 1 || cpu_is_offline(0))
1961 /* Stop environment and ADB interrupts */
1962 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, 0);
1963 pmu_wait_complete(&req
);
1965 /* Tell PMU what events will wake us up */
1966 pmu_request(&req
, NULL
, 4, PMU_POWER_EVENTS
, PMU_PWR_CLR_WAKEUP_EVENTS
,
1968 pmu_wait_complete(&req
);
1969 pmu_request(&req
, NULL
, 4, PMU_POWER_EVENTS
, PMU_PWR_SET_WAKEUP_EVENTS
,
1970 0, PMU_PWR_WAKEUP_KEY
|
1971 (option_lid_wakeup
? PMU_PWR_WAKEUP_LID_OPEN
: 0));
1972 pmu_wait_complete(&req
);
1974 /* Save the state of the L2 and L3 caches */
1975 save_l3cr
= _get_L3CR(); /* (returns -1 if not available) */
1976 save_l2cr
= _get_L2CR(); /* (returns -1 if not available) */
1978 if (!__fake_sleep
) {
1979 /* Ask the PMU to put us to sleep */
1980 pmu_request(&req
, NULL
, 5, PMU_SLEEP
, 'M', 'A', 'T', 'T');
1981 pmu_wait_complete(&req
);
1984 /* The VIA is supposed not to be restored correctly*/
1987 /* Shut down various ASICs. There's a chance that we can no longer
1988 * talk to the PMU after this, so I moved it to _after_ sending the
1989 * sleep command to it. Still need to be checked.
1991 pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, 1);
1993 /* Call low-level ASM sleep handler */
1997 low_sleep_handler();
1999 /* Restore Apple core ASICs state */
2000 pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, 0);
2003 restore_via_state();
2005 /* tweak LPJ before cpufreq is there */
2006 loops_per_jiffy
*= 2;
2009 pmac_call_early_video_resume();
2011 /* Restore L2 cache */
2012 if (save_l2cr
!= 0xffffffff && (save_l2cr
& L2CR_L2E
) != 0)
2013 _set_L2CR(save_l2cr
);
2014 /* Restore L3 cache */
2015 if (save_l3cr
!= 0xffffffff && (save_l3cr
& L3CR_L3E
) != 0)
2016 _set_L3CR(save_l3cr
);
2018 /* Restore userland MMU context */
2019 switch_mmu_context(NULL
, current
->active_mm
, NULL
);
2021 /* Tell PMU we are ready */
2023 pmu_request(&req
, NULL
, 2, PMU_SYSTEM_READY
, 2);
2024 pmu_wait_complete(&req
);
2025 pmu_request(&req
, NULL
, 2, PMU_SET_INTR_MASK
, pmu_intr_mask
);
2026 pmu_wait_complete(&req
);
2028 /* Restore LPJ, cpufreq will adjust the cpu frequency */
2029 loops_per_jiffy
/= 2;
2034 #define PB3400_MEM_CTRL 0xf8000000
2035 #define PB3400_MEM_CTRL_SLEEP 0x70
2037 static void __iomem
*pb3400_mem_ctrl
;
2039 static void powerbook_sleep_init_3400(void)
2041 /* map in the memory controller registers */
2042 pb3400_mem_ctrl
= ioremap(PB3400_MEM_CTRL
, 0x100);
2043 if (pb3400_mem_ctrl
== NULL
)
2044 printk(KERN_WARNING
"ioremap failed: sleep won't be possible");
2047 static int powerbook_sleep_3400(void)
2052 struct adb_request sleep_req
;
2053 unsigned int __iomem
*mem_ctrl_sleep
;
2055 if (pb3400_mem_ctrl
== NULL
)
2057 mem_ctrl_sleep
= pb3400_mem_ctrl
+ PB3400_MEM_CTRL_SLEEP
;
2059 /* Set the memory controller to keep the memory refreshed
2060 while we're asleep */
2061 for (i
= 0x403f; i
>= 0x4000; --i
) {
2062 out_be32(mem_ctrl_sleep
, i
);
2064 x
= (in_be32(mem_ctrl_sleep
) >> 16) & 0x3ff;
2070 /* Ask the PMU to put us to sleep */
2071 pmu_request(&sleep_req
, NULL
, 5, PMU_SLEEP
, 'M', 'A', 'T', 'T');
2072 pmu_wait_complete(&sleep_req
);
2075 pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, 1);
2079 /* Put the CPU into sleep mode */
2080 hid0
= mfspr(SPRN_HID0
);
2081 hid0
= (hid0
& ~(HID0_NAP
| HID0_DOZE
)) | HID0_SLEEP
;
2082 mtspr(SPRN_HID0
, hid0
);
2084 msr
= mfmsr() | MSR_POW
;
2090 local_irq_disable();
2092 /* OK, we're awake again, start restoring things */
2093 out_be32(mem_ctrl_sleep
, 0x3f);
2094 pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, 0);
2099 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
2102 * Support for /dev/pmu device
2104 #define RB_SIZE 0x10
2105 struct pmu_private
{
2106 struct list_head list
;
2111 unsigned char data
[16];
2113 wait_queue_head_t wait
;
2115 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2116 int backlight_locker
;
2120 static LIST_HEAD(all_pmu_pvt
);
2121 static DEFINE_SPINLOCK(all_pvt_lock
);
2124 pmu_pass_intr(unsigned char *data
, int len
)
2126 struct pmu_private
*pp
;
2127 struct list_head
*list
;
2129 unsigned long flags
;
2131 if (len
> sizeof(pp
->rb_buf
[0].data
))
2132 len
= sizeof(pp
->rb_buf
[0].data
);
2133 spin_lock_irqsave(&all_pvt_lock
, flags
);
2134 for (list
= &all_pmu_pvt
; (list
= list
->next
) != &all_pmu_pvt
; ) {
2135 pp
= list_entry(list
, struct pmu_private
, list
);
2136 spin_lock(&pp
->lock
);
2140 if (i
!= pp
->rb_get
) {
2141 struct rb_entry
*rp
= &pp
->rb_buf
[pp
->rb_put
];
2143 memcpy(rp
->data
, data
, len
);
2145 wake_up_interruptible(&pp
->wait
);
2147 spin_unlock(&pp
->lock
);
2149 spin_unlock_irqrestore(&all_pvt_lock
, flags
);
2153 pmu_open(struct inode
*inode
, struct file
*file
)
2155 struct pmu_private
*pp
;
2156 unsigned long flags
;
2158 pp
= kmalloc(sizeof(struct pmu_private
), GFP_KERNEL
);
2161 pp
->rb_get
= pp
->rb_put
= 0;
2162 spin_lock_init(&pp
->lock
);
2163 init_waitqueue_head(&pp
->wait
);
2164 mutex_lock(&pmu_info_proc_mutex
);
2165 spin_lock_irqsave(&all_pvt_lock
, flags
);
2166 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2167 pp
->backlight_locker
= 0;
2169 list_add(&pp
->list
, &all_pmu_pvt
);
2170 spin_unlock_irqrestore(&all_pvt_lock
, flags
);
2171 file
->private_data
= pp
;
2172 mutex_unlock(&pmu_info_proc_mutex
);
2177 pmu_read(struct file
*file
, char __user
*buf
,
2178 size_t count
, loff_t
*ppos
)
2180 struct pmu_private
*pp
= file
->private_data
;
2181 DECLARE_WAITQUEUE(wait
, current
);
2182 unsigned long flags
;
2185 if (count
< 1 || !pp
)
2188 spin_lock_irqsave(&pp
->lock
, flags
);
2189 add_wait_queue(&pp
->wait
, &wait
);
2190 set_current_state(TASK_INTERRUPTIBLE
);
2194 if (pp
->rb_get
!= pp
->rb_put
) {
2196 struct rb_entry
*rp
= &pp
->rb_buf
[i
];
2198 spin_unlock_irqrestore(&pp
->lock
, flags
);
2201 if (ret
> 0 && copy_to_user(buf
, rp
->data
, ret
))
2205 spin_lock_irqsave(&pp
->lock
, flags
);
2210 if (file
->f_flags
& O_NONBLOCK
)
2213 if (signal_pending(current
))
2215 spin_unlock_irqrestore(&pp
->lock
, flags
);
2217 spin_lock_irqsave(&pp
->lock
, flags
);
2219 __set_current_state(TASK_RUNNING
);
2220 remove_wait_queue(&pp
->wait
, &wait
);
2221 spin_unlock_irqrestore(&pp
->lock
, flags
);
2227 pmu_write(struct file
*file
, const char __user
*buf
,
2228 size_t count
, loff_t
*ppos
)
2234 pmu_fpoll(struct file
*filp
, poll_table
*wait
)
2236 struct pmu_private
*pp
= filp
->private_data
;
2238 unsigned long flags
;
2242 poll_wait(filp
, &pp
->wait
, wait
);
2243 spin_lock_irqsave(&pp
->lock
, flags
);
2244 if (pp
->rb_get
!= pp
->rb_put
)
2246 spin_unlock_irqrestore(&pp
->lock
, flags
);
2251 pmu_release(struct inode
*inode
, struct file
*file
)
2253 struct pmu_private
*pp
= file
->private_data
;
2254 unsigned long flags
;
2257 file
->private_data
= NULL
;
2258 spin_lock_irqsave(&all_pvt_lock
, flags
);
2259 list_del(&pp
->list
);
2260 spin_unlock_irqrestore(&all_pvt_lock
, flags
);
2262 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
2263 if (pp
->backlight_locker
)
2264 pmac_backlight_enable();
2272 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
2273 static void pmac_suspend_disable_irqs(void)
2275 /* Call platform functions marked "on sleep" */
2276 pmac_pfunc_i2c_suspend();
2277 pmac_pfunc_base_suspend();
2280 static int powerbook_sleep(suspend_state_t state
)
2284 /* Wait for completion of async requests */
2285 while (!batt_req
.complete
)
2288 /* Giveup the lazy FPU & vec so we don't have to back them
2289 * up from the low level code
2293 #ifdef CONFIG_ALTIVEC
2294 if (cpu_has_feature(CPU_FTR_ALTIVEC
))
2295 enable_kernel_altivec();
2296 #endif /* CONFIG_ALTIVEC */
2299 case PMU_OHARE_BASED
:
2300 error
= powerbook_sleep_3400();
2302 case PMU_HEATHROW_BASED
:
2303 case PMU_PADDINGTON_BASED
:
2304 error
= powerbook_sleep_grackle();
2306 case PMU_KEYLARGO_BASED
:
2307 error
= powerbook_sleep_Core99();
2321 static void pmac_suspend_enable_irqs(void)
2323 /* Force a poll of ADB interrupts */
2324 adb_int_pending
= 1;
2325 via_pmu_interrupt(0, NULL
);
2329 /* Call platform functions marked "on wake" */
2330 pmac_pfunc_base_resume();
2331 pmac_pfunc_i2c_resume();
2334 static int pmu_sleep_valid(suspend_state_t state
)
2336 return state
== PM_SUSPEND_MEM
2337 && (pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, -1) >= 0);
2340 static const struct platform_suspend_ops pmu_pm_ops
= {
2341 .enter
= powerbook_sleep
,
2342 .valid
= pmu_sleep_valid
,
2345 static int register_pmu_pm_ops(void)
2347 if (pmu_kind
== PMU_OHARE_BASED
)
2348 powerbook_sleep_init_3400();
2349 ppc_md
.suspend_disable_irqs
= pmac_suspend_disable_irqs
;
2350 ppc_md
.suspend_enable_irqs
= pmac_suspend_enable_irqs
;
2351 suspend_set_ops(&pmu_pm_ops
);
2356 device_initcall(register_pmu_pm_ops
);
2359 static int pmu_ioctl(struct file
*filp
,
2360 u_int cmd
, u_long arg
)
2362 __u32 __user
*argp
= (__u32 __user
*)arg
;
2363 int error
= -EINVAL
;
2366 #ifdef CONFIG_PPC_PMAC
2368 if (!capable(CAP_SYS_ADMIN
))
2370 return pm_suspend(PM_SUSPEND_MEM
);
2371 case PMU_IOC_CAN_SLEEP
:
2372 if (pmac_call_feature(PMAC_FTR_SLEEP_STATE
, NULL
, 0, -1) < 0)
2373 return put_user(0, argp
);
2375 return put_user(1, argp
);
2378 #ifdef CONFIG_PMAC_BACKLIGHT_LEGACY
2379 /* Compatibility ioctl's for backlight */
2380 case PMU_IOC_GET_BACKLIGHT
:
2384 brightness
= pmac_backlight_get_legacy_brightness();
2388 return put_user(brightness
, argp
);
2391 case PMU_IOC_SET_BACKLIGHT
:
2395 error
= get_user(brightness
, argp
);
2399 return pmac_backlight_set_legacy_brightness(brightness
);
2401 #ifdef CONFIG_INPUT_ADBHID
2402 case PMU_IOC_GRAB_BACKLIGHT
: {
2403 struct pmu_private
*pp
= filp
->private_data
;
2405 if (pp
->backlight_locker
)
2408 pp
->backlight_locker
= 1;
2409 pmac_backlight_disable();
2413 #endif /* CONFIG_INPUT_ADBHID */
2414 #endif /* CONFIG_PMAC_BACKLIGHT_LEGACY */
2416 case PMU_IOC_GET_MODEL
:
2417 return put_user(pmu_kind
, argp
);
2418 case PMU_IOC_HAS_ADB
:
2419 return put_user(pmu_has_adb
, argp
);
2424 static long pmu_unlocked_ioctl(struct file
*filp
,
2425 u_int cmd
, u_long arg
)
2429 mutex_lock(&pmu_info_proc_mutex
);
2430 ret
= pmu_ioctl(filp
, cmd
, arg
);
2431 mutex_unlock(&pmu_info_proc_mutex
);
2436 #ifdef CONFIG_COMPAT
2437 #define PMU_IOC_GET_BACKLIGHT32 _IOR('B', 1, compat_size_t)
2438 #define PMU_IOC_SET_BACKLIGHT32 _IOW('B', 2, compat_size_t)
2439 #define PMU_IOC_GET_MODEL32 _IOR('B', 3, compat_size_t)
2440 #define PMU_IOC_HAS_ADB32 _IOR('B', 4, compat_size_t)
2441 #define PMU_IOC_CAN_SLEEP32 _IOR('B', 5, compat_size_t)
2442 #define PMU_IOC_GRAB_BACKLIGHT32 _IOR('B', 6, compat_size_t)
2444 static long compat_pmu_ioctl (struct file
*filp
, u_int cmd
, u_long arg
)
2449 case PMU_IOC_GET_BACKLIGHT32
:
2450 cmd
= PMU_IOC_GET_BACKLIGHT
;
2452 case PMU_IOC_SET_BACKLIGHT32
:
2453 cmd
= PMU_IOC_SET_BACKLIGHT
;
2455 case PMU_IOC_GET_MODEL32
:
2456 cmd
= PMU_IOC_GET_MODEL
;
2458 case PMU_IOC_HAS_ADB32
:
2459 cmd
= PMU_IOC_HAS_ADB
;
2461 case PMU_IOC_CAN_SLEEP32
:
2462 cmd
= PMU_IOC_CAN_SLEEP
;
2464 case PMU_IOC_GRAB_BACKLIGHT32
:
2465 cmd
= PMU_IOC_GRAB_BACKLIGHT
;
2468 return -ENOIOCTLCMD
;
2470 return pmu_unlocked_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
2474 static const struct file_operations pmu_device_fops
= {
2478 .unlocked_ioctl
= pmu_unlocked_ioctl
,
2479 #ifdef CONFIG_COMPAT
2480 .compat_ioctl
= compat_pmu_ioctl
,
2483 .release
= pmu_release
,
2484 .llseek
= noop_llseek
,
2487 static struct miscdevice pmu_device
= {
2488 PMU_MINOR
, "pmu", &pmu_device_fops
2491 static int pmu_device_init(void)
2493 if (pmu_state
== uninitialized
)
2495 if (misc_register(&pmu_device
) < 0)
2496 printk(KERN_ERR
"via-pmu: cannot register misc device.\n");
2499 device_initcall(pmu_device_init
);
2504 polled_handshake(void)
2506 via2
[B
] &= ~TREQ
; eieio();
2507 while ((via2
[B
] & TACK
) != 0)
2509 via2
[B
] |= TREQ
; eieio();
2510 while ((via2
[B
] & TACK
) == 0)
2515 polled_send_byte(int x
)
2517 via1
[ACR
] |= SR_OUT
| SR_EXT
; eieio();
2518 via1
[SR
] = x
; eieio();
2523 polled_recv_byte(void)
2527 via1
[ACR
] = (via1
[ACR
] & ~SR_OUT
) | SR_EXT
; eieio();
2528 x
= via1
[SR
]; eieio();
2530 x
= via1
[SR
]; eieio();
2535 pmu_polled_request(struct adb_request
*req
)
2537 unsigned long flags
;
2542 l
= pmu_data_len
[c
][0];
2543 if (l
>= 0 && req
->nbytes
!= l
+ 1)
2546 local_irq_save(flags
);
2547 while (pmu_state
!= idle
)
2550 while ((via2
[B
] & TACK
) == 0)
2552 polled_send_byte(c
);
2554 l
= req
->nbytes
- 1;
2555 polled_send_byte(l
);
2557 for (i
= 1; i
<= l
; ++i
)
2558 polled_send_byte(req
->data
[i
]);
2560 l
= pmu_data_len
[c
][1];
2562 l
= polled_recv_byte();
2563 for (i
= 0; i
< l
; ++i
)
2564 req
->reply
[i
+ req
->reply_len
] = polled_recv_byte();
2569 local_irq_restore(flags
);
2573 /* N.B. This doesn't work on the 3400 */
2574 void pmu_blink(int n
)
2576 struct adb_request req
;
2578 memset(&req
, 0, sizeof(req
));
2580 for (; n
> 0; --n
) {
2587 req
.reply
[0] = ADB_RET_OK
;
2589 req
.reply_expected
= 0;
2590 pmu_polled_request(&req
);
2598 req
.reply
[0] = ADB_RET_OK
;
2600 req
.reply_expected
= 0;
2601 pmu_polled_request(&req
);
2606 #endif /* DEBUG_SLEEP */
2608 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
2609 int pmu_sys_suspended
;
2611 static int pmu_syscore_suspend(void)
2613 /* Suspend PMU event interrupts */
2615 pmu_sys_suspended
= 1;
2617 #ifdef CONFIG_PMAC_BACKLIGHT
2618 /* Tell backlight code not to muck around with the chip anymore */
2619 pmu_backlight_set_sleep(1);
2625 static void pmu_syscore_resume(void)
2627 struct adb_request req
;
2629 if (!pmu_sys_suspended
)
2632 /* Tell PMU we are ready */
2633 pmu_request(&req
, NULL
, 2, PMU_SYSTEM_READY
, 2);
2634 pmu_wait_complete(&req
);
2636 #ifdef CONFIG_PMAC_BACKLIGHT
2637 /* Tell backlight code it can use the chip again */
2638 pmu_backlight_set_sleep(0);
2640 /* Resume PMU event interrupts */
2642 pmu_sys_suspended
= 0;
2645 static struct syscore_ops pmu_syscore_ops
= {
2646 .suspend
= pmu_syscore_suspend
,
2647 .resume
= pmu_syscore_resume
,
2650 static int pmu_syscore_register(void)
2652 register_syscore_ops(&pmu_syscore_ops
);
2656 subsys_initcall(pmu_syscore_register
);
2657 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
2659 EXPORT_SYMBOL(pmu_request
);
2660 EXPORT_SYMBOL(pmu_queue_request
);
2661 EXPORT_SYMBOL(pmu_poll
);
2662 EXPORT_SYMBOL(pmu_poll_adb
);
2663 EXPORT_SYMBOL(pmu_wait_complete
);
2664 EXPORT_SYMBOL(pmu_suspend
);
2665 EXPORT_SYMBOL(pmu_resume
);
2666 EXPORT_SYMBOL(pmu_unlock
);
2667 #if defined(CONFIG_PPC32)
2668 EXPORT_SYMBOL(pmu_enable_irled
);
2669 EXPORT_SYMBOL(pmu_battery_count
);
2670 EXPORT_SYMBOL(pmu_batteries
);
2671 EXPORT_SYMBOL(pmu_power_flags
);
2672 #endif /* CONFIG_SUSPEND && CONFIG_PPC32 */