/*********************************************************************************
 *      Copyright:  (C) 2021 LingYun IoT System Studio
 *                  All rights reserved.
 *
 *       Filename:  pwm.c
 *    Description:  This file is used to control PWM buzzer/Led
 *
 * Pin connection:
 *               PWM Module              IGKBoard
 *                  VCC       <----->      5V
 *                  Led       <----->      #Pin28(PWM8)
 *                  GND       <----->      GND
 *
 *
 *
 ********************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <signal.h>
#include <getopt.h>
#include <libgen.h>

#define PWM_SYS_PATH      "/sys/class/pwm/pwmchip0"

#define ENABLE            1
#define DISABLE           0


typedef struct pwm_s 
{
	char				pwm_path[64]; /* PWM path, such as /sys/class/pwm/pwmchip0 */
	char				chn_path[64]; /* channel path, such as /sys/class/pwm/pwmchip0/pwm0 */
	int                 pwm_num;      /* pwm number */
	int                 chn_num;      /* channel number */
} pwm_t; 


int init_pwm(pwm_t *pwm, int pwm_num, int chn_num);
int conf_pwm(pwm_t *pwm, int freq, int duty);
int turn_pwm(pwm_t *pwm, int status);
int term_pwm(pwm_t *pwm);

static inline void msleep(unsigned long ms);

static inline void banner(const char *progname)
{
    printf("%s program Version v1.0.0\n", progname);
    printf("Copyright (C) 2023 LingYun IoT System Studio.\n");
}

static void program_usage(const char *progname)
{

    printf("Usage: %s [OPTION]...\n", progname);
    printf(" This is pwm control program. \n");

    printf(" -p[pwm     ]  Specify PWM chip, such as 1 for pwmchip1\n");
    printf(" -c[channel ]  Specify PWM channel, such as 0\n");
    printf(" -f[freq    ]  Specify PWM frequency, default 2500(Hz)\n");
    printf(" -d[duty    ]  Specify PWM duty, default 50(50%%)\n");
    printf(" -s[status  ]  Specify PWM status: 1->on(default), 0->off\n");
    printf(" -h[help    ]  Display this help information\n");
    printf(" -v[version ]  Display the program version\n");
    printf("\n");

	printf("Example buzzer : %s -p 1 -c 0 -f 10000 -d 50 -s 1\n", progname);
	printf("Example Led    : %s -p 1 -c 1 -f 100 -d 50 -s 1\n", progname);
	printf("Example disable: %s -p 1 -c 0 -s 0\n", progname);

    printf("\n");
    banner(progname);
    return;
}

int main(int argc, char **argv)
{
    int             rv;
    char           *progname=NULL;
    int             chn_num = -1;
    int             pwm_num = -1;
    int             freq = 2500;
    int             duty = 50;
    int             status = ENABLE;
	pwm_t           pwm;

    struct option long_options[] = {
        {"pwm", required_argument, NULL, 'p'},
        {"channel", required_argument, NULL, 'c'},
        {"freq", required_argument, NULL, 'f'},
        {"duty", required_argument, NULL, 'd'},
        {"status", required_argument, NULL, 's'},
        {"version", no_argument, NULL, 'v'},
        {"help", no_argument, NULL, 'h'},
        {NULL, 0, NULL, 0}
    };

    progname = basename(argv[0]);

    /* Parser the command line parameters */
    while ((rv = getopt_long(argc, argv, "p:c:f:d:s:vh", long_options, NULL)) != -1)
    {
        switch (rv)
        {
            case 'p': /*  Set pwm chip, such as 1 for pwmchip1 */
                pwm_num = atoi(optarg);
                break;

            case 'c': /*  Set pwm channel, such as 0,1 */
                chn_num = atoi(optarg);
                break;

            case 'f': /*  Set pwm frequency */
                freq = atoi(optarg);
                break;

            case 'd': /*  Set pwm duty cycle */
                duty = atoi(optarg);
                break;

            case 's': /*  Set pwm status, 0 for disable and 1 for enable */
                status = atoi(optarg);
                break;

            case 'v':  /* Get software version */
                banner(progname);
                return EXIT_SUCCESS;

            case 'h':  /* Get help information */
                program_usage(progname);
                return 0;

            default:
                break;
        }
    }

	if( pwm_num<0 || chn_num<0 )
	{
		program_usage(progname);
		return 0;
	}

	init_pwm(&pwm, pwm_num, chn_num);


	if( status )
	{
		if( (rv=conf_pwm(&pwm, freq, duty)) < 0 )
		{
			printf("Configure PWM failure, rv=%d\n", rv);
			return 1;
		}

		turn_pwm(&pwm, ENABLE);
	}
	else
	{
		term_pwm(&pwm);
	}

    return 0;
}

int init_pwm(pwm_t *pwm, int pwm_num, int chn_num)
{
	if( !pwm || pwm_num<0 || chn_num<0 )
	{
		printf("Invalid input arguments\n");
		return -1;
	}

	snprintf(pwm->pwm_path, sizeof(pwm->pwm_path), "/sys/class/pwm/pwmchip%d", pwm_num);
	snprintf(pwm->chn_path, sizeof(pwm->chn_path), "/sys/class/pwm/pwmchip%d/pwm%d", pwm_num, chn_num);
	pwm->pwm_num = pwm_num;
	pwm->chn_num = chn_num;

	return 0;
}

/* check PWM $channel export or not */
int check_pwm(pwm_t *pwm)
{
	/* check /sys/class/pwm/pwmchipX/pwmY exist or not */
	return access(pwm->chn_path, F_OK) ? 0 : 1;
}

/* export($export=1)/unexport($export=0) PWM $channel */
int export_pwm(pwm_t *pwm, int export)
{
	int           fd;
	char          buf[32];
	char          path[256];

	if( export && check_pwm(pwm) )
		return 0; /* export already when export  */
	else if( !export && !check_pwm(pwm) )
		return 0; /* unexport already when unexport  */

	/* export PWM channel by echo Y > /sys/class/pwm/pwmchipX/export */
	snprintf(path, sizeof(path), "%s/%s", pwm->pwm_path, export?"export":"unexport");
	if( (fd=open(path, O_WRONLY)) < 0 )
	{
		printf("open '%s' failed: %s\n", path, strerror(errno));
		return -3;
	}

	snprintf(buf, sizeof(buf), "%d", pwm->chn_num);
	write(fd, buf, strlen(buf));

	msleep(100);

	if( export && check_pwm(pwm) )
		return 0; /* export already when export  */
	else if( !export && !check_pwm(pwm) )
		return 0; /* unexport already when unexport  */

	return -4;
}

/* set PWM $channel */
int set_pwm(pwm_t *pwm, int freq, int duty) 
{
	int           fd;
	char          buf[32];
	char          path[256];
	int           period;
	int           duty_cycle;

	if( !check_pwm(pwm) )
		return -2;

	/* open PWM period file and write period in ns */
	snprintf(path, sizeof(path), "%s/period", pwm->chn_path);
	if( (fd=open(path, O_WRONLY)) < 0 )
	{
		printf("open '%s' failed: %s\n", path, strerror(errno));
		return -3;
	}
	period = 1000000000/freq;
	snprintf(buf, sizeof(buf), "%d", period);
	write(fd, buf, strlen(buf));

	/* open PWM duty_cycle file and write duty */
	snprintf(path, sizeof(path), "%s/duty_cycle", pwm->chn_path);
	if( (fd=open(path, O_WRONLY)) < 0 )
	{
		printf("open '%s' failed: %s\n", path, strerror(errno));
		return -3;
	}
	duty_cycle = (period*duty) / 100;
	snprintf(buf, sizeof(buf), "%d", duty_cycle);
	write(fd, buf, strlen(buf));

	return 0;
}

int conf_pwm(pwm_t *pwm, int freq, int duty)
{
	int           rv;
	char          buf[32];
	char          path[256];

	if( (rv=export_pwm(pwm, 1)) )
	{
		printf("export PWM channel[%d] failed, rv=%d\n", pwm->chn_num, rv);
		return rv; 
	}

	if( (rv=set_pwm(pwm, freq, duty)) )
	{
		printf("config PWM channel[%d] failed, rv=%d\n", pwm->chn_num, rv);
		return rv;
	}

	printf("config pwm%d channel%d with freq[%d] duty[%d] okay\n", pwm->pwm_num, pwm->chn_num, freq, duty);

	return 0;
}

int turn_pwm(pwm_t *pwm, int status)
{
	int           fd;
	char          buf[32];
	char          path[256];

	if( !check_pwm(pwm) )
		return -1;

	/* open PWM enable file and enable(1)/disable(0) it */
	snprintf(path, sizeof(path), "%s/enable", pwm->chn_path);
	if( (fd=open(path, O_WRONLY)) < 0 )
	{
		printf("open '%s' failed: %s\n", path, strerror(errno));
		return -3;
	}
	snprintf(buf, sizeof(buf), "%d", status?1:0);
	write(fd, buf, strlen(buf));

	printf("pwm[%d] channel[%d]%s\n", pwm->pwm_num, pwm->chn_num, status?"enable":"disable");

	return 0;
}

int term_pwm(pwm_t *pwm)
{
	if( !check_pwm(pwm) )
		return 0;

	turn_pwm(pwm, DISABLE);
	export_pwm(pwm, 0);

	return 0;
}

static inline void msleep(unsigned long ms)
{
    struct timespec cSleep;
    unsigned long ulTmp;

    cSleep.tv_sec = ms / 1000;
    if (cSleep.tv_sec == 0)
    {
        ulTmp = ms * 10000;
        cSleep.tv_nsec = ulTmp * 100;
    }
    else
    {
        cSleep.tv_nsec = 0;
    }

    nanosleep(&cSleep, 0);

    return ;
}