// include/linux/pm.h
struct dev_pm_ops {
    int (*suspend)(struct device *dev);
    int (*resume)(struct device *dev);
    int (*suspend_late)(struct device *dev);
    int (*resume_early)(struct device *dev);
    int (*freeze)(struct device *dev);        // hibernation。    int (*thaw)(struct device *dev);           // hibernation。    int (*poweroff)(struct device *dev);       // hibernation。    int (*restore)(struct device *dev);        // hibernation。    // Runtime PM回调
    int (*runtime_suspend)(struct device *dev);
    int (*runtime_resume)(struct device *dev);
    int (*runtime_idle)(struct device *dev);
};

// my_sensor_drv.c - 带PM回调的Platform驱动
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/clk.h>
#include <linux/regulator/consumer.h>
#include <linux/io.h>

struct my_sensor_data {
    void __iomem *base;
    struct clk *clk;
    struct regulator *vdd;
    u32 saved_ctrl;    // 休眠前保存控制寄存器
    u32 saved_cfg;     // 休眠前保存配置寄存器
};

static int my_sensor_suspend(struct device *dev)
{
    struct my_sensor_data *data = dev_get_drvdata(dev);

    // 保存寄存器，唤醒后恢。    data->saved_ctrl = readl(data->base + CTRL_REG);
    data->saved_cfg  = readl(data->base + CFG_REG);

    // 关闭时钟
    clk_disable_unprepare(data->clk);

    // 关闭电源（如果设备有独立供电。    if (data->vdd)
        regulator_disable(data->vdd);

    dev_info(dev, "suspended\n");
    return 0;
}

static int my_sensor_resume(struct device *dev)
{
    struct my_sensor_data *data = dev_get_drvdata(dev);
    int ret;

    // 恢复电源
    if (data->vdd) {
        ret = regulator_enable(data->vdd);
        if (ret) {
            dev_err(dev, "failed to enable vdd: %d\n", ret);
            return ret;
        }
    }

    // 恢复时钟
    ret = clk_prepare_enable(data->clk);
    if (ret) {
        dev_err(dev, "failed to enable clk: %d\n", ret);
        return ret;
    }

    // 恢复寄存。    writel(data->saved_ctrl, data->base + CTRL_REG);
    writel(data->saved_cfg,  data->base + CFG_REG);

    dev_info(dev, "resumed\n");
    return 0;
}

// 用SET_SYSTEM_SLEEP_PM_OPS宏简化定。static const struct dev_pm_ops my_sensor_pm_ops = {
    SET_SYSTEM_SLEEP_PM_OPS(my_sensor_suspend, my_sensor_resume)
};

static int my_sensor_probe(struct platform_device *pdev)
{
    struct my_sensor_data *data;
    struct resource *res;

    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    data->base = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(data->base))
        return PTR_ERR(data->base);

    data->clk = devm_clk_get(&pdev->dev, NULL);
    if (IS_ERR(data->clk))
        return PTR_ERR(data->clk);

    data->vdd = devm_regulator_get_optional(&pdev->dev, "vdd");
    if (IS_ERR(data->vdd)) {
        if (PTR_ERR(data->vdd) != -ENODEV)
            return PTR_ERR(data->vdd);
        data->vdd = NULL;  // 没有独立供电，不影响
    }

    platform_set_drvdata(pdev, data);

    return clk_prepare_enable(data->clk);
}

static void my_sensor_remove(struct platform_device *pdev)
{
    struct my_sensor_data *data = platform_get_drvdata(pdev);

    clk_disable_unprepare(data->clk);
}

static const struct of_device_id my_sensor_of_match[] = {
    { .compatible = "myvendor,my-sensor" },
    { }
};
MODULE_DEVICE_TABLE(of, my_sensor_of_match);

static struct platform_driver my_sensor_driver = {
    .probe  = my_sensor_probe,
    .remove = my_sensor_remove,
    .driver = {
        .name           = "my-sensor",
        .of_match_table = my_sensor_of_match,
        .pm             = &my_sensor_pm_ops,  // 挂载PM操作
    },
};
module_platform_driver(my_sensor_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Sensor driver with suspend/resume support");

// 设置autosuspend延迟。00ms
pm_runtime_set_autosuspend_delay(dev, 200);

// 启用autosuspend
pm_runtime_use_autosuspend(dev);

// 用autosuspend版本的put
pm_runtime_put_sync_autosuspend(dev);  // 200ms内没有get才真正suspend

// my_i2c_sensor.c - 带Runtime PM的I2C传感器驱动#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/pm_runtime.h>
#include <linux/delay.h>

struct my_i2c_sensor {
    struct i2c_client *client;
    struct mutex lock;
};

// 读传感器数据前先唤醒设备
static int my_i2c_sensor_read(struct my_i2c_sensor *sensor, u8 reg, u8 *val)
{
    struct device *dev = &sensor->client->dev;
    int ret;

    // 唤醒设备，usage_count++
    ret = pm_runtime_get_sync(dev);
    if (ret < 0) {
        pm_runtime_put_noidle(dev);  // get失败也要减计数        return ret;
    }

    mutex_lock(&sensor->lock);
    ret = i2c_smbus_read_byte_data(sensor->client, reg);
    mutex_unlock(&sensor->lock);

    if (ret >= 0)
        *val = (u8)ret;

    // 用完放回，usage_count--。00ms后自动suspend
    pm_runtime_put_sync_autosuspend(dev);

    return ret < 0 ? ret : 0;
}

static int my_i2c_sensor_runtime_suspend(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);

    // 进入低功耗模式，传感器停止采。    i2c_smbus_write_byte_data(client, 0x10, 0x00);

    dev_dbg(dev, "runtime suspended\n");
    return 0;
}

static int my_i2c_sensor_runtime_resume(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);

    // 退出低功耗模式，恢复采样
    i2c_smbus_write_byte_data(client, 0x10, 0x01);
    // 等待传感器稳。    msleep(10);

    dev_dbg(dev, "runtime resumed\n");
    return 0;
}

static int my_i2c_sensor_runtime_idle(struct device *dev)
{
    // idle回调可选，返回0表示让PM核心继续走suspend流程
    // 返回调表示阻止suspend
    return 0;
}

static const struct dev_pm_ops my_i2c_sensor_pm_ops = {
    SET_RUNTIME_PM_OPS(my_i2c_sensor_runtime_suspend,
                       my_i2c_sensor_runtime_resume,
                       my_i2c_sensor_runtime_idle)
    // 系统休眠时也要处。    SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
                            pm_runtime_force_resume)
};

static int my_i2c_sensor_probe(struct i2c_client *client)
{
    struct device *dev = &client->dev;
    struct my_i2c_sensor *sensor;
    int ret;

    if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
        return -EIO;

    sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
    if (!sensor)
        return -ENOMEM;

    sensor->client = client;
    mutex_init(&sensor->lock);
    i2c_set_clientdata(client, sensor);

    // 初始化Runtime PM
    pm_runtime_set_active(dev);
    pm_runtime_set_autosuspend_delay(dev, 200);  // 200ms延迟挂起
    pm_runtime_use_autosuspend(dev);
    pm_runtime_enable(dev);

    // probe期间设备是active的，probe结束后可以put让它idle
    pm_runtime_put_sync_autosuspend(dev);

    return 0;
}

static void my_i2c_sensor_remove(struct i2c_client *client)
{
    struct device *dev = &client->dev;

    // remove时确保设备active，禁用Runtime PM
    pm_runtime_get_sync(dev);
    pm_runtime_disable(dev);
    pm_runtime_set_suspended(dev);
}

static const struct of_device_id my_i2c_sensor_of_match[] = {
    { .compatible = "myvendor,i2c-sensor" },
    { }
};
MODULE_DEVICE_TABLE(of, my_i2c_sensor_of_match);

static struct i2c_driver my_i2c_sensor_driver = {
    .probe = my_i2c_sensor_probe,
    .remove = my_i2c_sensor_remove,
    .driver = {
        .name           = "my-i2c-sensor",
        .of_match_table = my_i2c_sensor_of_match,
        .pm             = &my_i2c_sensor_pm_ops,
    },
};
module_i2c_driver(my_i2c_sensor_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("I2C sensor driver with Runtime PM");

// include/linux/pm_domain.h
struct generic_pm_domain {
    const char *name;                    // 电源域名。    int (*power_off)(struct generic_pm_domain *pd);
    int (*power_on)(struct generic_pm_domain *pd);
    unsigned int device_count;           // 域下设备。    unsigned int suspended_count;        // 已挂起设备数
    // ...锁、链表等内部字段
};

// 设备树中声明电源。power-domains {
    pd_video: power-domain@0 {
        compatible = "myvendor,power-domain";
        reg = <0 0x10>;          // PMU寄存器偏。        #power-domain-cells = <0>;
    };

    pd_gpu: power-domain@1 {
        compatible = "myvendor,power-domain";
        reg = <1 0x20>;
        #power-domain-cells = <0>;
    };
};

// 设备引用电源。&vpu {
    power-domains = <&pd_video>;
};

&display {
    power-domains = <&pd_video>;  // 和VPU共享同一个域
};

&gpu {
    power-domains = <&pd_gpu>;
};

# 挂起到内存S3)——最常用
echo mem > /sys/power/state

# 挂起到磁盘（S4)
echo disk > /sys/power/state

# 待机(S1)——部分平台支。echo freeze > /sys/power/state

# 查看当前支持的状态cat /sys/power/state
# 输出示例: freeze mem disk

# 查看可用测试级别
cat /sys/power/pm_test

# 输出: [none] core processors platform devices freezer

# 设置测试级别
echo devices > /sys/power/pm_test

# 触发休眠——只会走suspend/resume流程，不会真正断。echo mem > /sys/power/state

# 清除之前的闹。echo 0 > /sys/class/rtc/rtc0/wakealarm

# 设置5秒后唤醒
echo +5 > /sys/class/rtc/rtc0/wakealarm

# 触发休眠。秒后自动唤醒
echo mem > /sys/power/state

# 查看当前PM状态cat /sys/power/state

# 查看上次休眠成功/失败
cat /sys/power/suspend_stats/success
cat /sys/power/suspend_stats/fail

# 查看哪个设备导致休眠失败
cat /sys/power/suspend_stats/last_failed_dev

# 查看休眠耗时
cat /sys/power/suspend_stats/last_hardware

# Runtime PM状态cat /sys/devices/platform/soc/xxx/power/runtime_status
# 输出: active / suspended / unsupported

# 开启pm_trace
echo 1 > /sys/power/pm_trace

# 触发休眠
echo mem > /sys/power/state

# 如果卡死，重启后查看
# pm_trace把设备哈希写入RTC寄存器，重启后能读出。dmesg | grep "hash matches"

PM: hash matches drivers/clk/clk.c:245

CONFIG_PM_DEBUG=y           # PM调试总开销CONFIG_PM_SLEEP_DEBUG=y     # 休眠调试信息
CONFIG_PM_TRACE=y           # pm_trace支持
CONFIG_PM_TRACE_RTC=y       # pm_trace写RTC寄存```

开启`CONFIG_PM_SLEEP_DEBUG`后，`/sys/power/`下会多出`suspend_stats`的详细信息和每个设备的PM耗时统计数
### ftrace跟踪PM事件

```bash
# 使能PM相关tracepoint
echo 1 > /sys/kernel/debug/tracing/events/power/cpu_frequency/enable
echo 1 > /sys/kernel/debug/tracing/events/power/cpu_idle/enable
echo 1 > /sys/kernel/debug/tracing/events/power/pm_qos/enable

# 使能设备suspend/resume trace
echo 1 > /sys/kernel/debug/tracing/events/device/dev_suspend/enable
echo 1 > /sys/kernel/debug/tracing/events/device/dev_resume/enable

# 抓取trace
echo > /sys/kernel/debug/tracing/trace
echo mem > /sys/power/state
cat /sys/kernel/debug/tracing/trace

&gpio_keys {
    wakeup-source;   // 声明该设备可以唤醒系。};

// 错误：直接读寄存器，设备可能已suspended
val = readl(data->base + DATA_REG);

// 正确：先唤醒再读
pm_runtime_get_sync(dev);
val = readl(data->base + DATA_REG);
pm_runtime_put_sync_autosuspend(dev);

static irqreturn_t my_isr(int irq, void *dev_id)
{
    struct device *dev = dev_id;

    // 中断上下文不能用pm_runtime_get_sync（会睡眠。    // 用pm_runtime_get_if_in_use检查设备状态    if (!pm_runtime_get_if_in_use(dev))
        return IRQ_NONE;  // 设备已suspended，忽略中。
    // 处理中断...
    pm_runtime_put_sync_autosuspend(dev);
    return IRQ_HANDLED;
}