driver: add oob support for rockchip pwm.

[ruiqurm]

This patchset introduces out-of-band (OOB) support for Rockchip PWM controllers, enabling real-time PWM control through the EVL framework. The changes include:

• Implementation of the pwm_cdev interface structure to expose PWM channels to userspace through /dev/pwm.

• Generic support for OOB PWM control, providing an abstraction for real-time, low-latency updates to PWM state.

• Rockchip-specific OOB PWM driver that integrates with the EVL kernel to provide deterministic PWM updates via the OOB path.

Tested on Rock5b+/5c(rk3588) platform.

Example test:

#include<evl/thread.h>
#include<sys/ioctl.h>
#include<evl/clock.h>
#include<stdbool.h>
#include<linux/pwm.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define MIN_THROTTLE 125000 // 125us
#define MAX_THROTTLE 250000 // 250us
#define ONE_SECOND_IN_NS 1000000000
#define FREQUENCY 500
const long PERIOD = ONE_SECOND_IN_NS / FREQUENCY;
struct timespec period_in_timespec = {
        .tv_sec = 0,
    .tv_nsec = PERIOD
};

void timespec_add_inplace(struct timespec *a, const struct timespec *b) {
    a->tv_sec += b->tv_sec;
    a->tv_nsec += b->tv_nsec;

    if (a->tv_nsec >= 1000000000L) {
        a->tv_sec += 1;
        a->tv_nsec -= 1000000000L;
    }
}

void init_esc(int fd){
        struct pwm_state_request req;
        struct timespec now;
        int ret;
        req.enabled = true;
        req.oneshot_count = 1;
        req.duty_cycle = MIN_THROTTLE;
        req.polarity = PWM_UAPI_POLARITY_NORMAL;
        req.period = MIN_THROTTLE;
        ret = evl_read_clock(EVL_CLOCK_MONOTONIC,&now);
        if (ret < 0){
                perror("%d read clock failed\n",ret);
                exit(-1);
        }
        for (int i =0;i<FREQUENCY*2;i++){
                ret = oob_ioctl(fd,PWM_SET_STATE_IOCTL,&req);
                if (ret < 0){
                perror("Failed to change pwm state");
                        exit(-1);
                }
                timespec_add_inplace(&now,&period_in_timespec);
                evl_sleep_until(EVL_CLOCK_MONOTONIC,&now);
        }
}
void test(int fd){
        struct pwm_state_request req;
        struct timespec now;
        int ret;
        int step = 50;
        req.enabled = true;
        req.oneshot_count = 1;
        req.duty_cycle = 125000;
        req.polarity = PWM_UAPI_POLARITY_NORMAL;
        req.period = 125000;
        ret = evl_read_clock(EVL_CLOCK_MONOTONIC,&now);
        if (ret < 0){
                perror("%d read clock failed\n",ret);
                exit(-1);
        }
        for (int i =0;i<FREQUENCY*2;i++){
                ret = oob_ioctl(fd,PWM_SET_STATE_IOCTL,&req);
                if (ret < 0){
                perror("Failed to change pwm state.period=%d",req.period);
                        exit(-1);
                }
                req.duty_cycle += step;
                req.period += step;
                timespec_add_inplace(&now,&period_in_timespec);
                evl_sleep_until(EVL_CLOCK_MONOTONIC,&now);
        }
}
int set_throttle(int fd,double throttle_in_precent){
        struct pwm_state_request req;
        int ret;
        long throttle_period;
        if (throttle_in_precent < 0 || throttle_in_precent > 1){
                return -1;
        }
        throttle_period =  throttle_in_precent * (MAX_THROTTLE - MIN_THROTTLE) + MIN_THROTTLE;
        req.enabled = true;
        req.oneshot_count = 1;
        req.duty_cycle = throttle_period;
        req.polarity = PWM_UAPI_POLARITY_NORMAL;
        req.period = throttle_period;
        ret = ioctl(fd,PWM_SET_STATE_IOCTL,&req);
        return ret;
}

void disable_pwm(int fd){
        int ret;
        struct pwm_state_request req;
        req.enabled = false;
        req.polarity= PWM_UAPI_POLARITY_NORMAL;
        ret = oob_ioctl(fd,PWM_SET_STATE_IOCTL,&req);
        if (ret < 0){
        perror("Failed to disable pwm");
                exit(-1);
        }
        close(fd);
}

int main(){
        int fd;
        struct pwm_state_request req;

        fd = open("/dev/pwm1",O_WRONLY | 010000000000);
        if (fd < 0) {
            perror("Failed to open /dev/pwm0\n");
            return 1;
        }

        evl_attach_self("test_pwm");

        init_esc(fd);
        test(fd);
        disable_pwm(fd);
        return 0;
}

[ruiqurm]

There could be some concurrency problems, where user use two threads to call the oob_apply and apply at same time.

[ruiqurm]

Here the difference between rockchip_pwm_oob_irq_v1 and the oridinary is that the oob function call the oob apply. Maybe we can have some tricks to bridge the gap.

[ruiqurm]

We could add an operation for compat pointer