一、需求：
四路风扇分别通过PA6PG9PG11PG12四个脚输出pwm信号，控制风扇风速。但是芯片这4个脚没用硬件PWM功能，所以必须使用io口模拟pwm时序。 主要通过高精度定时器hrtimer去模拟pwm时序
二、功能实现
1、dts文件注册pwm设备
gpio-pwms {
compatible = "gpio-pwms";
pinctrl-names = "default";
pwm1 {
label = "pwm1";
gpios = <&pio 0 6 GPIO_ACTIVE_HIGH>; //GPIO6 ---> PA6
};
pwm2 {
label = "pwm2";
gpios = <&pio 6 9 GPIO_ACTIVE_HIGH>; //GPIO201 ---->PG9
};
pwm3{
label = "pwm3";
gpios = <&pio 6 11 GPIO_ACTIVE_HIGH>; //GPIO203 ----->PG11
};
pwm4{
label = "pwm4";
gpios = <&pio 6 12 GPIO_ACTIVE_HIGH>; //GPIO204 ----->PG12
};
};
2、驱动编写
(1）解析dts文件中的数据
static struct gpio_pwms_platform_data * gpio_pwms_get_devtree_pdata(struct device *dev)
{
struct device_node *node, *pp;
struct gpio_pwms_platform_data *pdata;
struct pwm_chip *pwm;
int error;
int npwms;
int i = 0;
node = dev->of_node;
if (!node)
return NULL;
npwms = of_get_child_count(node); //获取dts文件中pwm结点的个数
if (npwms == 0)
return NULL;
pdata = devm_kzalloc(dev, sizeof(*pdata) + npwms * (sizeof *pwm),GFP_KERNEL);
if (!pdata) {
error = -ENOMEM;
goto err_out;
}
pdata->pwms = (struct pwm_chip *)(pdata + 1);
pdata->npwms = npwms;
for_each_child_of_node(node, pp)
{
enum of_gpio_flags flags;
if (!of_find_property(pp, "gpios", NULL))
{
pdata->npwms--;
printk( "Found pwm without gpios
");
continue;
}
pwm = &pdata->pwms[i++];
pwm->gpio = of_get_gpio_flags(pp, 0, &flags); //获取每个pwm的gpio
printk("pwm->gpio=%d,flags=%d",pwm->gpio,flags);
if (pwm->gpio < 0)
{
error = pwm->gpio;
if (error != -ENOENT)
{
if (error != -EPROBE_DEFER)
dev_err(dev,
"Failed to get gpio flags, error: %d
",
error);
return ERR_PTR(error);
}
}
else
{
pwm->active_low = flags ;
}
pwm->desc = of_get_property(pp, "label", NULL); //获取label的字串
}
if (pdata->npwms == 0) {
error = -EINVAL;
goto err_out;
}
return pdata;
err_out:
return ERR_PTR(error);
}
（2）gpio_demo_probe函数主要用于创建pwm设备和class，分别给四个pwm设备分配主设备和次设备号,并且设置io口的输入输出。
static int gpio_demo_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; int error; int i,ret=0; unsigned int gpio; struct pwm_chip *gpwm = NULL; pdata = pdev->dev.platform_data; if (!pdata) { pdata = gpio_pwms_get_devtree_pdata(dev); //获取dts中定义设备树的数据 if (IS_ERR(pdata)) return PTR_ERR(pdata); if (!pdata) { printk( "missing platform data "); return -EINVAL; } } gloabl_pwms_dev = devm_kzalloc(dev, pdata->npwms * sizeof(struct pwm_chip), GFP_KERNEL); if (!gloabl_pwms_dev) { printk("no memory for gloabl_pwms_dev data "); return -ENOMEM; } memcpy(gloabl_pwms_dev, pdata->pwms, pdata->npwms * sizeof(struct pwm_chip)); for(i=0;i<pdata->npwms;i++) {
//申请主设备和此设备号,分配了cdev结构，注册了驱动的操作方法集 gpwm = &gloabl_pwms_dev[i]; gpwm->devno = MKDEV(pmajor, i); register_chrdev_region(gpwm->devno , 1, gpwm->desc); gpwm->cdev = cdev_alloc(); gpwm->cdev->owner = THIS_MODULE; cdev_init(gpwm->cdev,&pwm_fops); cdev_add(gpwm->cdev,gpwm->devno,1); } pwm_class = class_create(THIS_MODULE,PWM_CLASS_NAME); //创建class gpio-pwm if(IS_ERR(pwm_class)){ printk("debug:error class_create "); ret = PTR_ERR(pwm_class); goto err_class_error; } for (i = 0; i < pdata->npwms; i++) { gpwm = &gloabl_pwms_dev[i]; gpio = gpwm->gpio; gpwm->dev = device_create(pwm_class,NULL,gpwm->devno,NULL,"pwm%d",i+1); //创建pwm设备 if(IS_ERR(gpwm->dev)){ printk("debug:error device_create "); ret = PTR_ERR(gpwm); goto err_class_error; } else { printk("pwm_device_create "); } if(!gpio_is_valid(gpio)) printk("debug:invalid gpio,gpio=0x%x ", gpio); error = gpio_direction_output(gpio, !((gpwm->active_low == OF_GPIO_ACTIVE_LOW) ? 0 : 1)); //设置io口为输出即默认电平 if (error) { printk( "unable to set direction on gpio %u, err=%d ", gpio, error); return error; } //设置默认pwm周期和高电平时间 gpwm->period = 40000; gpwm->duty = 20000; //申请device error = devm_gpio_request(dev, gpio,gpwm->desc); if (error) { printk( "unable to request gpio %u, err=%d ", gpio, error); goto err_device_create; } else { printk("successed to request gpio "); gpwm->status = PWM_DISABLE; } } return 0; err_device_create: device_destroy(pwm_class,gpwm->devno); err_class_error: class_destroy(pwm_class); return ret; }
注册了字符设备后，/dev/目录下会生成pwm1pwm2pwm3pwm4四个字符设备。可以在应用层去对设备进行读写操作，会调用到驱动下的这几个函数。
const struct file_operations pwm_fops = {
.open = pwm_drv_open,
.write = pwm_drv_write,
.read = pwm_drv_read,
.unlocked_ioctl = pwm_drv_ioctl,
.release = pwm_drv_close,
};
（3）pwm_drv_ioctl函数会对应用层发过来的指令进行响应.
//command
#define PWM_PERIOD_SET _IOW('A', 1, unsigned long) #define PWM_DUTY_SET _IOW('A', 2, unsigned long) #define PWM_START _IOW('A', 3, unsigned long)
long pwm_drv_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
int ret = 0,minornum=0;
struct inode * ginode = NULL;
struct pwm_chip * pwm_dev = NULL;
ginode = file_inode(filep);
minornum= iminor(ginode);
pwm_dev = &gloabl_pwms_dev[minornum];
printk("pwm_drv_ioctl.minornum=%d...gpio=%d.period=%ld..duty=%ld..
",minornum,pwm_dev->gpio,pwm_dev->period,pwm_dev->duty);
switch(minornum)
{
case 0:
pwm1_dev = &gloabl_pwms_dev[minornum];
break;
case 1:
pwm2_dev = &gloabl_pwms_dev[minornum];
break;
case 2:
pwm3_dev = &gloabl_pwms_dev[minornum];
break;
case 3:
pwm4_dev = &gloabl_pwms_dev[minornum];
break;
default:
break;
}
switch(cmd)
{
case PWM_PERIOD_SET :
if(0 == minornum)
{
pwm1_dev->period = arg;
}
else if(1 == minornum)
{
pwm2_dev->period = arg;
}
else if(2 == minornum)
{
pwm3_dev->period = arg;
}
else if(3 == minornum)
{
pwm4_dev->period = arg;
}
break;
case PWM_DUTY_SET :
if(0 == minornum)
{
pwm1_dev->duty = arg;
}
else if(1 == minornum)
{
pwm2_dev->duty = arg;
}
else if(2 == minornum)
{
pwm3_dev->duty = arg;
}
else if(3 == minornum)
{
pwm4_dev->duty = arg;
}
break;
case PWM_START :
if(0 == minornum)
{
if(pwm1_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm1_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm1_gpio aready work
");
}
}
else if(1 == minornum)
{
if(pwm2_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm2_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm2_gpio aready work
");
}
}
else if(2 == minornum)
{
if(pwm3_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm3_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm3_gpio aready work
");
}
}
else if(3 == minornum)
{
if(pwm4_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm4_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm4_gpio aready work
");
}
}
break;
default :
ret = -1;
break;
}
return 0;
}
(4)hrtimer精准定时器模拟pwm信号
- 初始化定时器，是指hrtimer1_handler为回调函数，hrtimer_start激活回调函数。
hrtimer_init(&pwm1_dev->mytimer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
pwm1_dev->mytimer.function = hrtimer1_handler;
pwm1_dev->kt = ktime_set(0, pwm1_dev->period-pwm1_dev->duty);
hrtimer_start(&pwm1_dev->mytimer,pwm1_dev->kt,HRTIMER_MODE_REL);
- 初始化完之后会调用hrtimer1_handler函数，在回调函数会判断io口的电平高低，然后使用ktime_set设置到期时间，如果io为低电平，如果duty不为0，则拉高，ktime_set设置高电平的时间为duty,hrtimer_forward_now函数会等待duty纳秒，然后再执行回调函数hrtimer1_handler，再进行判断，如此循环。使用hrtimer_cancel函数去取消hrtimer.
我们需要四个定时器去模拟pwm,故要写四个回调函数模拟。
注意：根据实际测量，这里gpio_get_value获取到gpio的值，1为低电平，0为高电平。
static enum hrtimer_restart hrtimer1_handler(struct hrtimer *timer)
{
if (gpio_get_value(pwm1_dev->gpio) == 1) {
// There is no need to pull down when the duty cycle is 100%
if (pwm1_dev->duty != 0) {
gpio_set_value(pwm1_dev->gpio, 0);
pwm1_dev->kt = ktime_set(0, pwm1_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm1_dev->mytimer, pwm1_dev->kt);
} else {
// There is no need to pull up when the duty cycle is 0
if (pwm1_dev->duty != pwm1_dev->period) {
gpio_set_value(pwm1_dev->gpio, 1);
pwm1_dev->kt = ktime_set(0, pwm1_dev->period-pwm1_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm1_dev->mytimer, pwm1_dev->kt);
}
return HRTIMER_RESTART;
}
（5）设备注册
static struct of_device_id gpio_demo_of_match[] = {
{.compatible = "gpio-pwms"},
{},
}
MODULE_DEVICE_TABLE(of, gpio_demo_of_match);
static struct platform_driver gpio_demo_driver = {
.probe = gpio_demo_probe,
.driver = {
.name = "gpio-pwms",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(gpio_demo_of_match),
}
};
static int __init gpio_demo_init(void)
{
return platform_driver_register(&gpio_demo_driver);
}
static void __exit gpio_demo_exit(void)
{
int i;
struct pwm_chip *gpwm = NULL;
for(i=0;i<pdata->npwms;i++ )
{
gpwm = &gloabl_pwms_dev[i];
gpio_set_value(gpwm->gpio, 1);
gpio_free(gpwm->gpio);
device_destroy(pwm_class,gpwm->devno);
cdev_del(gpwm->cdev);
unregister_chrdev_region(gpwm->devno,1);
hrtimer_cancel(&gpwm->mytimer);
kfree(gpwm);
}
class_destroy(pwm_class);
return platform_driver_unregister(&gpio_demo_driver);
}
late_initcall(gpio_demo_init);
module_exit(gpio_demo_exit);
// add by SouthLj 2019-0924 end
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SouthLj");
（6）注册成功
注册完pwm设备和gpio_pwms class就可以看到如下目录：
可以看到设备的主、次设备号：
/dev目录下也可以看到四个设备，应用层就会通过ioctl对pwm设备写数据到驱动。
三、调用控制
luci界面中设置风扇的数据后，会将数据更新到/etc/config/cgminer配置文件中，然后重新启动cgminer(即执行/etc/init.d/cgminer脚本)，脚本中会将风扇风速最大最小值、风速默认值、风速自动控制、预启动时间以及预启动时间内风扇的风速，通过传参传给cgminer.
AVA9_OPTIONS=" --fan-limit $_fan_min-$_fan_max $VOLT_OFFSET"
PARAMS=" --lowmem $AVA9_OPTIONS $POOL1 $POOL2 $POOL3 --api-allow $_aa --api-listen $_mo --fan-ctrl $_fan_ctrl $PRE_BOOT --pwm-default $_pwm_default"
NTP_POOL="-p 0.openwrt.pool.ntp.org -p 1.openwrt.pool.ntp.org -p 3.openwrt.pool.ntp.org -p 4.openwrt.pool.ntp.org"
ASIA="-p 1.cn.pool.ntp.org -p 3.asia.pool.ntp.org -p 2.asia.pool.ntp.org"
# _ntp_enable: openwrt, asia, globle
if [ "$_ntp_enable" == "asia" ]; then
NTP_POOL="${ASIA}"
fi
if [ ! -f /tmp/cgminer-ntpd-done -a "$_ntp_enable" != "disable" ]; then
while [ "$NTPD_RET" != "0" ]; do
ntpd -d -n -q -N ${NTP_POOL}
NTPD_RET=$?
done
touch /tmp/cgminer-ntpd-done
fi
# Make sure udevd run before cgminer start
UDEVDCNT=`pidof udevd | wc -w`
if [ "$UDEVDCNT" == "0" ]; then
mkdir -p /run
udevd --daemon
fi
sleep 2
start-stop-daemon -S -x $APP -p $PID_FILE -m -b -- $PARAMS
pwm占空比设到20%，pwm波形不稳定,导致风扇有顿挫感。nano给的软件默认最小占空比为30%.
cgminer.c中通过参数判断会执行相应的函数：
char *set_avalon9_fan_auto_control(char *arg)
{
int ret=1,autocontrol=0;
ret = sscanf(arg, "%d", &autocontrol);
printf("autocontrol=%d
",autocontrol);
if (ret < 1)
return "No value passed to avalon9-fan-auto-control";
opt_avalon9_fan_auto_control = autocontrol;
return NULL;
}
//风扇预启动设置逻辑是，如果风扇自动控制开关为enable,控制板上电开机后，则会根据
预启动速度跑，跑的时间是预启动时间，时间过后，风扇风速会按照默认风速转。预启动
设置只在上电第一次有效。
char *set_avalon9_fan_pre_boot_setup(char *arg)
{
int ret=1,prebootime =1,prebootfan =100;
ret = sscanf(arg, "%d-%d", &prebootfan,&prebootime);
printf("prebootime=%d,prebootfan=%d
",prebootime,prebootfan);
if (prebootfan < 0 || prebootfan> 100 || prebootime < 0 || prebootime > 10)
return "Invalid value passed to boot_setup";
if (ret < 1)
return "No value passed to avalon9-fan-pre-boot-setup";
prebootflag = 1;
opt_avalon9_fan_pre_boottim = prebootime;
opt_avalon9_fan_pre_bootfan = prebootfan;
return NULL;
}
void open_pwm_device(float pwmval)
{
int fd;
fd = open("/dev/pwm1",O_RDWR );
if(fd < 0)
{
printf("failed to open pwm1 failed!
");
}
ioctl(fd,PWM_PERIOD_SET,40000); // 10 000 00ns = 1ms 10 00ns = 1us
ioctl(fd,PWM_DUTY_SET,(int)(40000*((float)pwmval/100)));
ioctl(fd,PWM_START,1);
close(fd);
fd = open("/dev/pwm2",O_RDWR);
if(fd < 0)
{
printf("failed to open pwm2!
");
}
ioctl(fd,PWM_PERIOD_SET,40000); // 10 000 000ns = 10ms
ioctl(fd,PWM_DUTY_SET,(int)(40000*((float)pwmval/100)));
ioctl(fd,PWM_START,1);
close(fd);
fd = open("/dev/pwm3",O_RDWR);
if(fd < 0)
{
printf("failed to open pwm3 failed!
");
}
ioctl(fd,PWM_PERIOD_SET,40000); // 10 000 000ns = 10ms
ioctl(fd,PWM_DUTY_SET,(int)(40000*((float)pwmval/100)));
ioctl(fd,PWM_START,1);
close(fd);
fd = open("/dev/pwm4",O_RDWR);
if(fd < 0)
{
printf("failed to open pwm4!
");
}
ioctl(fd,PWM_PERIOD_SET,40000); // 10 000 000ns = 10ms
ioctl(fd,PWM_DUTY_SET,(int)(40000*((float)pwmval/100)));
ioctl(fd,PWM_START,1);
close(fd);
}
char *set_avalon9_fan_pwm_default(char *arg)
{
int pwmval;
int ret=1;
// int delaytime = 90000000;
ret = sscanf(arg, "%d", &pwmval);
printf("
...........set_avalon9_fan_default_pwm....pwmval=%d..opt_avalon9_fan_auto_control=%d...
",pwmval,opt_avalon9_fan_auto_control);
if (ret < 1)
return "No value passed to avalon9-fan-default-pwm";
if(pwmval<opt_avalon9_fan_min)
{
pwmval =opt_avalon9_fan_min;
}
else if(pwmval>opt_avalon9_fan_max)
{
pwmval =opt_avalon9_fan_max;
}
if(opt_avalon9_fan_auto_control == 1)
{
if(opt_avalon9_fan_pre_bootfan<opt_avalon9_fan_min)
{
opt_avalon9_fan_pre_bootfan =opt_avalon9_fan_min;
}
else if(opt_avalon9_fan_pre_bootfan>opt_avalon9_fan_max)
{
opt_avalon9_fan_pre_bootfan =opt_avalon9_fan_max;
}
if(prebootflag==1)
{
prebootflag==0;
open_pwm_device(opt_avalon9_fan_pre_bootfan);
cgsleep_ms(opt_avalon9_fan_pre_boottim*60000);
}
open_pwm_device(pwmval);
}
else
{
open_pwm_device(pwmval);
}
return NULL;
}
通过cat /sys/class/kernel/gpio命令查看四个pwm口的电平高低。
四、源码：
dts文件：
gpio-pwms {
compatible = "gpio-pwms";
pinctrl-names = "default";
pwm1 {
label = "pwm1";
gpios = <&pio 0 6 GPIO_ACTIVE_HIGH>;
};
pwm2 {
label = "pwm2";
gpios = <&pio 6 9 GPIO_ACTIVE_HIGH>;
};
pwm3{
label = "pwm3";
gpios = <&pio 6 11 GPIO_ACTIVE_HIGH>;
};
pwm4{
label = "pwm4";
gpios = <&pio 6 12 GPIO_ACTIVE_HIGH>;
};
};
pwm_gpio.h:
/**
* pwm_gpio.h create by yuan
*/
#ifndef __PWM_GPIO_H__
#define __PWM_GPIO_H__
#include <linux/ioctl.h>
#define PWM_PERIOD_SET _IOW('A', 1, unsigned long)
#define PWM_DUTY_SET _IOW('A', 2, unsigned long)
#define PWM_START _IOW('A', 3, unsigned long)
#endif /* pwm-gpio.h */
pwm_gpio.c:
/**
* pwm_gpio.c create by yuanqiangfei
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/of_platform.h>
#include <linux/of_gpio.h>
#include <linux/of_device.h>
#include <linux/pwm-gpio.h>
#define PWM_CLASS_NAME "gpio-pwms" //产生sys/class/gpio-pwms
#define PWM_DEVICE_NUM 0 //产生/dev/pwm-0
typedef enum {
PWM_DISABLE = 0,
PWM_ENABLE,
}PWM_STATUS_t;
//pwm的设备对象
struct pwm_chip{
dev_t devno;
struct cdev *cdev;
struct device *dev;
unsigned long period;
unsigned long duty;
struct hrtimer mytimer;
ktime_t kt;
PWM_STATUS_t status;
char *desc;
int gpio;
int active_low;
};
struct gpio_pwms_platform_data {
struct pwm_chip *pwms;
int npwms;
};
static int pmajor = 247;
struct pwm_chip *pwm1_dev = NULL;
struct pwm_chip *pwm2_dev = NULL;
struct pwm_chip *pwm3_dev = NULL;
struct pwm_chip *pwm4_dev = NULL;
static struct class *pwm_class = NULL;
static struct pwm_chip *gloabl_pwms_dev = NULL;
static struct gpio_pwms_platform_data *pdata = NULL;
static void pwm_gpio_start(int minor);
static enum hrtimer_restart hrtimer1_handler(struct hrtimer *timer);
static enum hrtimer_restart hrtimer2_handler(struct hrtimer *timer);
static enum hrtimer_restart hrtimer3_handler(struct hrtimer *timer);
static enum hrtimer_restart hrtimer4_handler(struct hrtimer *timer);
int pwm_drv_open (struct inode * inode, struct file *filp)
{
return 0;
}
ssize_t pwm_drv_read (struct file *filp, char __user *userbuf, size_t count, loff_t *fpos)
{
return 0;
}
ssize_t pwm_drv_write (struct file *filp, const char __user *userbuf, size_t count, loff_t *fpos)
{
return 0;
}
long pwm_drv_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
int ret = 0,minornum=0;
struct inode * ginode = NULL;
struct pwm_chip * pwm_dev = NULL;
ginode = file_inode(filep);
minornum= iminor(ginode);
pwm_dev = &gloabl_pwms_dev[minornum];
printk("pwm_drv_ioctl.minornum=%d...gpio=%d.period=%ld..duty=%ld..
",minornum,pwm_dev->gpio,pwm_dev->period,pwm_dev->duty);
switch(minornum)
{
case 0:
pwm1_dev = &gloabl_pwms_dev[minornum];
break;
case 1:
pwm2_dev = &gloabl_pwms_dev[minornum];
break;
case 2:
pwm3_dev = &gloabl_pwms_dev[minornum];
break;
case 3:
pwm4_dev = &gloabl_pwms_dev[minornum];
break;
default:
break;
}
switch(cmd)
{
case PWM_PERIOD_SET :
if(0 == minornum)
{
pwm1_dev->period = arg;
}
else if(1 == minornum)
{
pwm2_dev->period = arg;
}
else if(2 == minornum)
{
pwm3_dev->period = arg;
}
else if(3 == minornum)
{
pwm4_dev->period = arg;
}
break;
case PWM_DUTY_SET :
if(0 == minornum)
{
pwm1_dev->duty = arg;
}
else if(1 == minornum)
{
pwm2_dev->duty = arg;
}
else if(2 == minornum)
{
pwm3_dev->duty = arg;
}
else if(3 == minornum)
{
pwm4_dev->duty = arg;
}
break;
case PWM_START :
if(0 == minornum)
{
if(pwm1_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm1_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm1_gpio aready work
");
}
}
else if(1 == minornum)
{
if(pwm2_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm2_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm2_gpio aready work
");
}
}
else if(2 == minornum)
{
if(pwm3_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm3_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm3_gpio aready work
");
}
}
else if(3 == minornum)
{
if(pwm4_dev->status == PWM_DISABLE){
// start timer
pwm_gpio_start(minornum);
pwm4_dev->status = PWM_ENABLE;
}else{
printk("debug:pwm4_gpio aready work
");
}
}
break;
default :
ret = -1;
break;
}
return 0;
}
int pwm_drv_close (struct inode *inode, struct file *filp)
{
printk("pwm_drv_close...
");
return 0;
}
static void pwm_gpio_start(int minor)
{
printk("pwm_gpio_start...minor=%d..
",minor);
switch(minor)
{
case 0:
hrtimer_init(&pwm1_dev->mytimer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
pwm1_dev->mytimer.function = hrtimer1_handler;
pwm1_dev->kt = ktime_set(0, pwm1_dev->period-pwm1_dev->duty);
hrtimer_start(&pwm1_dev->mytimer,pwm1_dev->kt,HRTIMER_MODE_REL);
break;
case 1:
hrtimer_init(&pwm2_dev->mytimer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
pwm2_dev->mytimer.function = hrtimer2_handler;
pwm2_dev->kt = ktime_set(0, pwm2_dev->period-pwm2_dev->duty);
hrtimer_start(&pwm2_dev->mytimer,pwm2_dev->kt,HRTIMER_MODE_REL);
break;
case 2:
hrtimer_init(&pwm3_dev->mytimer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
pwm3_dev->mytimer.function = hrtimer3_handler;
pwm3_dev->kt = ktime_set(0,pwm3_dev->period -pwm3_dev->duty);
hrtimer_start(&pwm3_dev->mytimer,pwm3_dev->kt,HRTIMER_MODE_REL);
break;
case 3:
hrtimer_init(&pwm4_dev->mytimer,CLOCK_MONOTONIC,HRTIMER_MODE_REL);
pwm4_dev->mytimer.function = hrtimer4_handler;
pwm4_dev->kt = ktime_set(0, pwm4_dev->period-pwm4_dev->duty);
hrtimer_start(&pwm4_dev->mytimer,pwm4_dev->kt,HRTIMER_MODE_REL);
break;
default:
break;
}
}
static enum hrtimer_restart hrtimer1_handler(struct hrtimer *timer)
{
if (gpio_get_value(pwm1_dev->gpio) == 1) {
// There is no need to pull down when the duty cycle is 100%
if (pwm1_dev->duty != 0) {
gpio_set_value(pwm1_dev->gpio, 0);
pwm1_dev->kt = ktime_set(0, pwm1_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm1_dev->mytimer, pwm1_dev->kt);
} else {
// There is no need to pull up when the duty cycle is 0
if (pwm1_dev->duty != pwm1_dev->period) {
gpio_set_value(pwm1_dev->gpio, 1);
pwm1_dev->kt = ktime_set(0, pwm1_dev->period-pwm1_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm1_dev->mytimer, pwm1_dev->kt);
}
return HRTIMER_RESTART;
}
static enum hrtimer_restart hrtimer2_handler(struct hrtimer *timer)
{
if (gpio_get_value(pwm2_dev->gpio) == 1) {
// There is no need to pull down when the duty cycle is 100%
if (pwm2_dev->duty != 0) {
gpio_set_value(pwm2_dev->gpio, 0);
pwm2_dev->kt = ktime_set(0, pwm2_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm2_dev->mytimer, pwm2_dev->kt);
} else {
// There is no need to pull up when the duty cycle is 0
if (pwm2_dev->duty != pwm2_dev->period) {
gpio_set_value(pwm2_dev->gpio, 1);
pwm2_dev->kt = ktime_set(0, pwm2_dev->period-pwm2_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm2_dev->mytimer, pwm2_dev->kt);
}
return HRTIMER_RESTART;
}
static enum hrtimer_restart hrtimer3_handler(struct hrtimer *timer)
{
if (gpio_get_value(pwm3_dev->gpio) == 1) {
// There is no need to pull down when the duty cycle is 100%
if (pwm3_dev->duty != 0) {
gpio_set_value(pwm3_dev->gpio, 0);
pwm3_dev->kt = ktime_set(0, pwm3_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm3_dev->mytimer, pwm3_dev->kt);
} else {
// There is no need to pull up when the duty cycle is 0
if (pwm3_dev->duty != pwm3_dev->period) {
gpio_set_value(pwm3_dev->gpio, 1);
pwm3_dev->kt = ktime_set(0, pwm3_dev->period-pwm3_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm3_dev->mytimer, pwm3_dev->kt);
}
return HRTIMER_RESTART;
}
static enum hrtimer_restart hrtimer4_handler(struct hrtimer *timer)
{
if (gpio_get_value(pwm4_dev->gpio) == 1) {
// There is no need to pull down when the duty cycle is 100%
if (pwm4_dev->duty != 0) {
gpio_set_value(pwm4_dev->gpio, 0);
pwm4_dev->kt = ktime_set(0, pwm4_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm4_dev->mytimer, pwm4_dev->kt);
} else {
// There is no need to pull up when the duty cycle is 0
if (pwm4_dev->duty != pwm4_dev->period) {
gpio_set_value(pwm4_dev->gpio, 1);
pwm4_dev->kt = ktime_set(0, pwm4_dev->period-pwm4_dev->duty);
}
// timer overflow
hrtimer_forward_now(&pwm4_dev->mytimer, pwm4_dev->kt);
}
return HRTIMER_RESTART;
}
const struct file_operations pwm_fops = {
.open = pwm_drv_open,
.write = pwm_drv_write,
.read = pwm_drv_read,
.unlocked_ioctl = pwm_drv_ioctl,
.release = pwm_drv_close,
};
static struct gpio_pwms_platform_data * gpio_pwms_get_devtree_pdata(struct device *dev)
{
struct device_node *node, *pp;
struct gpio_pwms_platform_data *pdata;
struct pwm_chip *pwm;
int error;
int npwms;
int i = 0;
node = dev->of_node;
if (!node)
return NULL;
npwms = of_get_child_count(node);
if (npwms == 0)
return NULL;
pdata = devm_kzalloc(dev, sizeof(*pdata) + npwms * (sizeof *pwm),GFP_KERNEL);
if (!pdata) {
error = -ENOMEM;
goto err_out;
}
pdata->pwms = (struct pwm_chip *)(pdata + 1);
pdata->npwms = npwms;
for_each_child_of_node(node, pp)
{
enum of_gpio_flags flags;
if (!of_find_property(pp, "gpios", NULL))
{
pdata->npwms--;
printk( "Found pwm without gpios
");
continue;
}
pwm = &pdata->pwms[i++];
pwm->gpio = of_get_gpio_flags(pp, 0, &flags);
printk("pwm->gpio=%d,flags=%d",pwm->gpio,flags);
if (pwm->gpio < 0)
{
error = pwm->gpio;
if (error != -ENOENT)
{
if (error != -EPROBE_DEFER)
dev_err(dev,
"Failed to get gpio flags, error: %d
",
error);
return ERR_PTR(error);
}
}
else
{
pwm->active_low = flags ;
}
pwm->desc = of_get_property(pp, "label", NULL);
}
if (pdata->npwms == 0) {
error = -EINVAL;
goto err_out;
}
return pdata;
err_out:
return ERR_PTR(error);
}
static int gpio_demo_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
int error;
int i,ret=0;
unsigned int gpio;
struct pwm_chip *gpwm = NULL;
pdata = pdev->dev.platform_data;
if (!pdata) {
pdata = gpio_pwms_get_devtree_pdata(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
if (!pdata) {
printk( "missing platform data
");
return -EINVAL;
}
}
gloabl_pwms_dev = devm_kzalloc(dev, pdata->npwms * sizeof(struct pwm_chip),
GFP_KERNEL);
if (!gloabl_pwms_dev) {
printk("no memory for gloabl_pwms_dev data
");
return -ENOMEM;
}
memcpy(gloabl_pwms_dev, pdata->pwms, pdata->npwms * sizeof(struct pwm_chip));
for(i=0;i<pdata->npwms;i++)
{
gpwm = &gloabl_pwms_dev[i];
gpwm->devno = MKDEV(pmajor, i);
register_chrdev_region(gpwm->devno , 1, gpwm->desc);
gpwm->cdev = cdev_alloc();
gpwm->cdev->owner = THIS_MODULE;
cdev_init(gpwm->cdev,&pwm_fops);
cdev_add(gpwm->cdev,gpwm->devno,1);
}
pwm_class = class_create(THIS_MODULE,PWM_CLASS_NAME);
if(IS_ERR(pwm_class)){
printk("debug:error class_create
");
ret = PTR_ERR(pwm_class);
goto err_class_error;
}
for (i = 0; i < pdata->npwms; i++)
{
gpwm = &gloabl_pwms_dev[i];
gpio = gpwm->gpio;
gpwm->dev = device_create(pwm_class,NULL,gpwm->devno,NULL,"pwm%d",i+1);
if(IS_ERR(gpwm->dev)){
printk("debug:error device_create
");
ret = PTR_ERR(gpwm);
goto err_class_error;
}
else
{
printk("pwm_device_create
");
}
if(!gpio_is_valid(gpio))
printk("debug:invalid gpio,gpio=0x%x
", gpio);
error = gpio_direction_output(gpio, !((gpwm->active_low == OF_GPIO_ACTIVE_LOW) ? 0 : 1));
if (error) {
printk(
"unable to set direction on gpio %u, err=%d
",
gpio, error);
return error;
}
gpwm->period = 40000;
gpwm->duty = 20000;
error = devm_gpio_request(dev, gpio,gpwm->desc);
if (error) {
printk( "unable to request gpio %u, err=%d
",
gpio, error);
goto err_device_create;
}
else
{
printk("successed to request gpio
");
gpwm->status = PWM_DISABLE;
}
}
return 0;
err_device_create:
device_destroy(pwm_class,gpwm->devno);
err_class_error:
class_destroy(pwm_class);
return ret;
}
static struct of_device_id gpio_demo_of_match[] = {
{.compatible = "gpio-pwms"},
{},
}
MODULE_DEVICE_TABLE(of, gpio_demo_of_match);
static struct platform_driver gpio_demo_driver = {
.probe = gpio_demo_probe,
.driver = {
.name = "gpio-pwms",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(gpio_demo_of_match),
}
};
static int __init gpio_demo_init(void)
{
return platform_driver_register(&gpio_demo_driver);
}
static void __exit gpio_demo_exit(void)
{
int i;
struct pwm_chip *gpwm = NULL;
for(i=0;i<pdata->npwms;i++ )
{
gpwm = &gloabl_pwms_dev[i];
gpio_set_value(gpwm->gpio, 1);
gpio_free(gpwm->gpio);
device_destroy(pwm_class,gpwm->devno);
cdev_del(gpwm->cdev);
unregister_chrdev_region(gpwm->devno,1);
hrtimer_cancel(&gpwm->mytimer);
kfree(gpwm);
}
class_destroy(pwm_class);
return platform_driver_unregister(&gpio_demo_driver);
}
late_initcall(gpio_demo_init);
module_exit(gpio_demo_exit);
// add by SouthLj 2019-0924 end
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SouthLj");
/* end pwm_gpio.c */