RK3576开发板PWM驱动教程（上）触觉智能开发板演示基础原理/设备树/红外收发捕获解析

&pwm1_6ch_5 {
    status = "okay";
};

/ {
    /* 背光设备 */
    backlight: backlight {
        compatible = "pwm-backlight";
        pwms = <&pwm1_6ch_5 0 25000 0>;  /* PWM, channel, period(ns), polarity */
        /* 亮度等级表 */
        brightness-levels = <
              0  20  20  21  21  22  22  23
             23  24  24  25  25  26  26  27
             /* ... 更多等级 ... */
            248 249 250 251 252 253 254 255
        >;
        default-brightness-level = <200>;
        /* 电源控制 */
        enable-gpios = <&gpio4 RK_PA1 GPIO_ACTIVE_HIGH>;
    };
    /* 风扇 PWM 控制 */
    fan: pwm-fan {
        compatible = "pwm-fan";
        pwms = <&pwm2 0 40000 0>;  /* 25KHz PWM 频率 */
        /* 温度与转速曲线 */
        cooling-levels = <0 100 150 200 255>;
        
#cooling
-cells = <2>;
    };
};

&pinctrl {
    pwm1 {
        pwm1m0_pins: pwm1m0-pins {
            rockchip,pins =
                <1 RK_PB6 2 &pcfg_pull_none>;
        };
    };
    pwm2 {
        pwm2m0_pins: pwm2m0-pins {
            rockchip,pins =
                <1 RK_PB7 2 &pcfg_pull_none>;
        };
    };
};

#include
 <linux/pwm.h>
struct pwm_capture {
    unsigned int period;      /* 捕获到的周期 (ns) */
    unsigned int duty_cycle;  /* 捕获到的占空比 (ns) */
};
/* 捕获外部 PWM 信号 */
int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result, unsigned long timeout);

#include <linux/pwm.h>
#include <linux/module.h>
#include <linux/platform_device.h>
struct my_pwm_capture_dev {
    struct pwm_device *pwm;
    struct device *dev;
};
static int my_capture_probe(struct platform_device *pdev)
{
    struct my_pwm_capture_dev *priv;
    int ret;
    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;
    priv->dev = &pdev->dev;
    /* 获取 PWM 设备（与 PWM 输出共用节点） */
    priv->pwm = devm_pwm_get(&pdev->dev, NULL);
    if (IS_ERR(priv->pwm)) {
        ret = PTR_ERR(priv->pwm);
        if (ret != -EPROBE_DEFER)
            dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret);
        return ret;
    }
    platform_set_drvdata(pdev, priv);
    dev_info(&pdev->dev, "PWM capture device initialized\n");
    return 0;
}
/* 读取捕获结果 */
static int my_capture_read(struct my_pwm_capture_dev *priv,
                           unsigned int *period_ns,
                           unsigned int *duty_ns)
{
    struct pwm_capture result;
    int ret;
    /* 捕获外部信号，超时 100ms */
    ret = pwm_capture(priv->pwm, &result, 100);
    if (ret) {
        dev_err(priv->dev, "Failed to capture PWM: %d\n", ret);
        return ret;
    }
    *period_ns = result.period;
    *duty_ns = result.duty_cycle;
    dev_info(priv->dev, "Captured: period=%uns, duty=%uns\n",
             result.period, result.duty_cycle);
    return 0;
}
/* 计算频率和占空比百分比 */
static void my_capture_calc_freq_duty(unsigned int period_ns, unsigned int duty_ns,
                                      unsigned int *freq_hz, unsigned int *duty_pct)
{
    if (period_ns == 0)
        return;
    *freq_hz = 1000000000 / period_ns;
    *duty_pct = (duty_ns * 100) / period_ns;
}
static int my_capture_remove(struct platform_device *pdev)
{
    return 0;
}
static const struct of_device_id my_capture_of_match[] = {
    { .compatible = "mycompany,my-pwm-capture", },
    { }
};
static struct platform_driver my_capture_driver = {
    .probe = my_capture_probe,
    .remove = my_capture_remove,
    .driver = {
        .name = "my-pwm-capture",
        .of_match_table = my_capture_of_match,
    },
};
module_platform_driver(my_capture_driver);
MODULE_LICENSE("GPL");

/ {
    /* GPIO 红外接收头 */
    ir_receiver: ir-receiver {
        compatible = "gpio-ir-receiver";
        gpios = <&gpio0 RK_PA5 GPIO_ACTIVE_LOW>;
        linux,rc-map-name = "rc-rc6-mce";  /* 使用预定义的按键映射 */
        linux,autosuspend-period = <125>;  /* 自动挂起延迟 (ms) */
    };
};

CONFIG_RC_CORE=y
CONFIG_GPIO_IR_RECEIVER=m          # 或 y
CONFIG_RC_DECODERS=y               # 包含 NEC、RC5、RC6 等解码器
CONFIG_RC_MAP=y

# 按键映射表格式：scancode keycode
# scancode: 遥控器发送的原始 NEC 码
# keycode: 映射到的 Linux 按键
0x12ff01 KEY_POWER
0x12ff02 KEY_VOLUMEUP
0x12ff03 KEY_VOLUMEDOWN
0x12ff04 KEY_UP
0x12ff05 KEY_DOWN
0x12ff06 KEY_LEFT
0x12ff07 KEY_RIGHT
0x12ff08 KEY_ENTER

ir-keytable -c                    # 清除现有映射
ir-keytable -p NEC -p RC-6        # 启用解码协议
ir-keytable -w /etc/rc_keymaps/my_remote.map  # 加载映射

# 查看红外设备
ir-keytable
# 输出示例：
# Found /sys/class/rc/rc0/ with:
#   Name: gpio_ir_recv
#   Driver: gpio-ir-recv
#   Default keymap: rc-rc6-mce
#   Input device: /dev/input/event2
#   Enabled protocols: nec
# 实时监控按键事件
ir-keytable -t
# 输出示例：
# 1234.567890: event type EV_MSC, evscancode = 0x12ff01
# 1234.567891: event type EV_KEY, KEY_POWER(116) pressed
# 1234.567891: event type EV_KEY, KEY_POWER(116) released
# 查看原始事件
cat /dev/input/event2 | hexdump
# 使用 evtest 测试
evtest /dev/input/event2

&pwm2 {
    status = "okay";
    pinctrl-0 = <&pwm2m0_pins>;
    rockchip,pwm-ir-transmit;   /* 使能 IR 发射功能 */
};

CONFIG_RC_CORE=y               # 必须启用（IR 发射依赖 rc-core）
CONFIG_PWM_ROCKCHIP=y          # 或 m

txbuf[0]: NEC 引导码低电平时间 (μs)，通常 9000
txbuf[1]: NEC 引导码高电平时间 (μs)，通常 4500
txbuf[2]: 重复码高电平时间 (μs)，通常 2250
txbuf[3]: 逻辑 "0" 和 "1" 低电平时间 (μs)，通常 560
txbuf[4]: 逻辑 "0" 高电平时间 (μs)，通常 560
txbuf[5]: 逻辑 "1" 高电平时间 (μs)，通常 1690
txbuf[6]: 32位 NEC 数据

bit[31:24]  bit[23:16]    bit[15:8]       bit[7:0]
命令反码    命令码        地址反码        地址码

#include <linux/pwm.h>
#include <linux/rc-core.h>
#include <linux/module.h>
struct my_pwm_ir_dev {
    struct rc_dev *rcdev;
    struct platform_device *pdev;
};
/* NEC 协议红外发射 */
static int my_pwm_ir_tx(struct rc_dev *dev, unsigned int *txbuf, unsigned int count)
{
    struct my_pwm_ir_dev *priv = dev->priv;
    struct pwm_device *pwm;
    int ret;
    if (count < 2)
        return -EINVAL;
    pwm = dev->priv;
    if (!pwm)
        return -ENODEV;
    /* 通过 PWM IR 硬件发射 */
    /* 注意：实际发射由 pwm-rockchip 驱动的
     * rockchip_pwm_ir_transmit 处理 */
    ret = pwm_ir_transmit(pwm, txbuf, count);
    if (ret < 0)
        dev_err(&dev->dev, "IR transmit failed: %d\n", ret);
    return ret;
}
static int my_pwm_ir_probe(struct platform_device *pdev)
{
    struct my_pwm_ir_dev *priv;
    struct rc_dev *rcdev;
    int ret;
    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;
    /* 注册 rc_dev */
    rcdev = devm_rc_allocate_device(&pdev->dev, RC_DRIVER_IR_RAW_TX);
    if (!rcdev)
        return -ENOMEM;
    rcdev->driver_name = "my-pwm-ir";
    rcdev->device_name = "PWM IR Transmitter";
    rcdev->tx_ir = my_pwm_ir_tx;
    rcdev->priv = priv;
    rcdev->allowed_protocols = RC_BIT_NEC | RC_BIT_NECX | RC_BIT_NEC32;
    ret = devm_rc_register_device(&pdev->dev, rcdev);
    if (ret) {
        dev_err(&pdev->dev, "Failed to register rc device: %d\n", ret);
        return ret;
    }
    priv->rcdev = rcdev;
    priv->pdev = pdev;
    dev_info(&pdev->dev, "PWM IR transmitter registered\n");
    return 0;
}
static const struct of_device_id my_pwm_ir_of_match[] = {
    { .compatible = "mycompany,my-pwm-ir", },
    { }
};
static struct platform_driver my_pwm_ir_driver = {
    .probe = my_pwm_ir_probe,
    .driver = {
        .name = "my-pwm-ir",
        .of_match_table = my_pwm_ir_of_match,
    },
};
module_platform_driver(my_pwm_ir_driver);
MODULE_LICENSE("GPL");

# 使用 ir-ctl 发送 NEC 码
# 格式：ir-ctl --transmit=<device> --send="protocol:scancode"
# 发送 NEC POWER 键（地址 0x01，命令 0x10）
ir-ctl -d /dev/lirc0 --send=nec:0x12ff01
# 查看 IR 设备
ir-ctl -i
# 输出示例：
# lirc0: PWM IR Transmitter
#   driver: my-pwm-ir
#   Features: send
#   Allowed protocols: NEC NECX NEC32
# 发送重复码（长按效果）
ir-ctl -d /dev/lirc0 --send=nec:0x12ff01 --send=nec:0x12ff01 --send=nec:0x12ff01
# 使用 evtest 验证（发射 + 接收回路测试）
ir-ctl -d /dev/lirc0 --send=nec:0x12ff01
ir-keytable -t  # 在另一终端中观察