1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use crate::{BusDevice, BusResumeDevice};
use sys_util::{error, warn, EventFd};
/// ACPI PM resource for handling OS suspend/resume request
pub struct ACPIPMResource {
suspend_evt: EventFd,
pm1_status: u16,
pm1_enable: u16,
pm1_control: u16,
sleep_control: u8,
sleep_status: u8,
}
impl ACPIPMResource {
/// Constructs ACPI Power Management Resouce.
pub fn new(suspend_evt: EventFd) -> ACPIPMResource {
ACPIPMResource {
suspend_evt,
pm1_status: 0,
pm1_enable: 0,
pm1_control: 0,
sleep_control: 0,
sleep_status: 0,
}
}
}
/// the ACPI PM register's base and length.
pub const ACPIPM_RESOURCE_BASE: u64 = 0x600;
pub const ACPIPM_RESOURCE_LEN: u8 = 8;
pub const ACPIPM_RESOURCE_EVENTBLK_LEN: u8 = 4;
pub const ACPIPM_RESOURCE_CONTROLBLK_LEN: u8 = 2;
/// ACPI PM register value definations
const PM1_STATUS: u16 = 0;
const PM1_ENABLE: u16 = 2;
const PM1_CONTROL: u16 = 4;
const SLEEP_CONTROL: u16 = 6;
const SLEEP_STATUS: u16 = 7;
const BITMASK_PM1CNT_SLEEP_ENABLE: u16 = 0x2000;
const BITMASK_SLEEPCNT_SLEEP_ENABLE: u8 = 0x20;
const BITMASK_PM1CNT_WAKE_STATUS: u16 = 0x8000;
const BITMASK_SLEEPCNT_WAKE_STATUS: u8 = 0x80;
impl BusDevice for ACPIPMResource {
fn debug_label(&self) -> String {
"ACPIPMResource".to_owned()
}
fn read(&mut self, offset: u64, data: &mut [u8]) {
let val = match offset as u16 {
PM1_STATUS => self.pm1_status,
PM1_ENABLE => self.pm1_enable,
PM1_CONTROL => self.pm1_control,
SLEEP_CONTROL => self.sleep_control as u16,
SLEEP_STATUS => self.sleep_status as u16,
_ => {
warn!("ACPIPM: Bad read from offset {}", offset);
return;
}
};
let val_arr = val.to_ne_bytes();
for i in 0..std::mem::size_of::<u16>() {
if i < data.len() {
data[i] = val_arr[i];
}
}
}
fn write(&mut self, offset: u64, data: &[u8]) {
let max_bytes = std::mem::size_of::<u16>();
// only allow maximum max_bytes to write
if data.len() > max_bytes {
warn!("ACPIPM: bad write size: {}", data.len());
return;
}
let mut val_arr = u16::to_ne_bytes(0 as u16);
for i in 0..std::mem::size_of::<u16>() {
if i < data.len() {
val_arr[i] = data[i];
}
}
let val = u16::from_ne_bytes(val_arr);
match offset as u16 {
PM1_STATUS => self.pm1_status &= !val,
PM1_ENABLE => self.pm1_enable = val,
PM1_CONTROL => {
if (val & BITMASK_PM1CNT_SLEEP_ENABLE) == BITMASK_PM1CNT_SLEEP_ENABLE {
if let Err(e) = self.suspend_evt.write(1) {
error!("ACPIPM: failed to trigger suspend event: {}", e);
}
}
self.pm1_control = val & !BITMASK_PM1CNT_SLEEP_ENABLE;
}
SLEEP_CONTROL => {
let sleep_control = val as u8;
if (sleep_control & BITMASK_SLEEPCNT_SLEEP_ENABLE) == BITMASK_SLEEPCNT_SLEEP_ENABLE
{
if let Err(e) = self.suspend_evt.write(1) {
error!("ACPIPM: failed to trigger suspend event: {}", e);
}
}
self.sleep_control = sleep_control as u8 & !BITMASK_SLEEPCNT_SLEEP_ENABLE;
}
SLEEP_STATUS => self.sleep_status &= !val as u8,
_ => {
warn!("ACPIPM: Bad write to offset {}", offset);
}
};
}
}
impl BusResumeDevice for ACPIPMResource {
fn resume_imminent(&mut self) {
let val = self.pm1_status;
self.pm1_status = val | BITMASK_PM1CNT_WAKE_STATUS;
let val = self.sleep_status;
self.sleep_status = val | BITMASK_SLEEPCNT_WAKE_STATUS;
}
}
|