/*
|
* drivers/pwm/pwm-sunxi-dev.c
|
*
|
* Allwinnertech pulse-width-modulation controller driver
|
*
|
* Copyright (C) 2019 AllWinner
|
*
|
*
|
* This file is licensed under the terms of the GNU General Public
|
* License version 2. This program is licensed "as is" without any
|
* warranty of any kind, whether express or implied.
|
*/
|
#include <linux/module.h>
|
#include <linux/init.h>
|
#include <linux/kernel.h>
|
#include <linux/fs.h>
|
#include <linux/cdev.h>
|
#include <linux/uaccess.h>
|
#include <linux/slab.h>
|
#include <linux/clk.h>
|
#include <linux/gpio.h>
|
#include <linux/device.h>
|
#include <linux/pinctrl/consumer.h>
|
#include <asm/io.h>
|
#include <linux/pwm.h>
|
|
#define PWM_ERR(fmt, arg...) pr_err("%s()%d - "fmt, __func__, __LINE__, ##arg)
|
|
#define PWM_IOCTL_BASE 'P'
|
#define GROUP_PWM_CONFIG _IOW(PWM_IOCTL_BASE, 4, struct pwm_config_group)
|
#define GROUP_PWM_DISABLE _IOW(PWM_IOCTL_BASE, 5, struct pwm_config_group)
|
|
struct pwm_config_group {
|
int group_channel;
|
int group_run_count;
|
int pwm_polarity;
|
int pwm_period;
|
};
|
|
struct sunxi_pwm_dev {
|
struct device *dev;
|
struct cdev cdev;
|
dev_t chrdev;
|
};
|
|
static struct sunxi_pwm_dev *sunxi_pwm_dev;
|
static struct class *sunxi_pwm_class;
|
|
static int sunxi_pwm_open(struct inode *inode, struct file *filp)
|
{
|
filp->private_data = sunxi_pwm_dev;
|
return 0;
|
}
|
|
static int sunxi_pwm_release(struct inode *inode, struct file *filp)
|
{
|
return 0;
|
}
|
|
static long sunxi_pwm_unlocked_ioctl(struct file *filp, unsigned int cmd,
|
unsigned long arg)
|
{
|
unsigned int size;
|
struct pwm_config_group *code_group;
|
unsigned int ret, i, group;
|
unsigned char name[30];
|
|
static struct pwm_device *pwm[8] = {NULL};
|
switch (cmd) {
|
case GROUP_PWM_CONFIG:
|
size = _IOC_SIZE(cmd);
|
|
code_group = (struct pwm_config_group *)kzalloc(size, GFP_KERNEL);
|
if (IS_ERR_OR_NULL(code_group)) {
|
PWM_ERR("not enough memory\n");
|
return -ENOMEM;
|
}
|
|
if (copy_from_user(code_group, (void __user *)arg, size)) {
|
PWM_ERR("copy buffer err\n");
|
return -ENOMEM;
|
}
|
|
group = code_group->group_channel;
|
|
if (group < 1) {
|
return -EINVAL;
|
}
|
|
for (i = 4*(group-1); i < 4*group; i++) {
|
sprintf(name, "sunxi_pwm%d", i);
|
if (pwm[i] == NULL) {
|
pwm[i] = pwm_request(i, name);
|
|
if (IS_ERR_OR_NULL(pwm[i])) {
|
PWM_ERR("pwm err\n");
|
return -ENODEV;
|
}
|
}
|
|
pwm[i]->chip_data = code_group;
|
|
// pwm_disable(pwm[i]); /* first disabled then enable */
|
|
ret = pwm_config(pwm[i], 0, 1); /* the argument can’t be same as the first */
|
if (ret < 0) {
|
PWM_ERR("pwm ioctl err0\n");
|
return -EINVAL;
|
}
|
ret = pwm_config(pwm[i], 0x2ee, 0x7cf);
|
if (ret < 0) {
|
PWM_ERR("pwm ioctl err\n");
|
return -EINVAL;
|
}
|
|
pwm_enable(pwm[i]);
|
/*pwm_free(pwm);*/
|
}
|
|
kfree(code_group);
|
break;
|
case GROUP_PWM_DISABLE:
|
size = _IOC_SIZE(cmd);
|
|
code_group = (struct pwm_config_group *)kzalloc(size, GFP_KERNEL);
|
if (IS_ERR_OR_NULL(code_group)) {
|
PWM_ERR("not enough memory\n");
|
return -ENOMEM;
|
}
|
|
if (copy_from_user(code_group, (void __user *)arg, size)) {
|
PWM_ERR("copy buffer err\n");
|
return -ENOMEM;
|
}
|
|
group = code_group->group_channel;
|
|
if (group < 1) {
|
PWM_ERR("group para err\n");
|
return -EINVAL;
|
}
|
|
for (i = 4*(group-1); i < 4*group; i++) {
|
pwm[i]->chip_data = code_group;
|
|
if (pwm[i]) {
|
pwm_disable(pwm[i]);
|
pwm_free(pwm[i]);
|
pwm[i] = NULL;
|
}
|
}
|
|
|
kfree(code_group);
|
break;
|
default:
|
PWM_ERR("a err cmd");
|
return -ENOTTY;
|
}
|
return 0;
|
}
|
|
#ifdef CONFIG_COMPAT
|
static long sunxi_pwm_compat_ioctl(struct file *filp, unsigned int cmd,
|
unsigned long arg)
|
{
|
unsigned long translated_arg = (unsigned long)compat_ptr(arg);
|
|
return sunxi_pwm_unlocked_ioctl(filp, cmd, translated_arg);
|
}
|
#endif
|
|
static const struct file_operations sunxi_pwm_fops = {
|
.owner = THIS_MODULE,
|
.unlocked_ioctl = sunxi_pwm_unlocked_ioctl,
|
#ifdef CONFIG_COMPAT
|
.compat_ioctl = sunxi_pwm_compat_ioctl,
|
#endif
|
.open = sunxi_pwm_open,
|
.release = sunxi_pwm_release,
|
};
|
|
static int __init sunxi_pwm_init(void)
|
{
|
int err = 0;
|
struct device *dev;
|
|
sunxi_pwm_dev = kzalloc(sizeof(struct sunxi_pwm_dev), GFP_KERNEL);
|
if (sunxi_pwm_dev == NULL) {
|
PWM_ERR("kzalloc failed!\n");
|
return -ENOMEM;
|
}
|
|
err = alloc_chrdev_region(&sunxi_pwm_dev->chrdev, 0, 1, "sunxi-pwm-dev");
|
|
if (err) {
|
PWM_ERR("alloc_chrdev_region failed!\n");
|
goto alloc_chrdev_err;
|
}
|
|
cdev_init(&(sunxi_pwm_dev->cdev), &sunxi_pwm_fops);
|
sunxi_pwm_dev->cdev.owner = THIS_MODULE;
|
err = cdev_add(&(sunxi_pwm_dev->cdev), sunxi_pwm_dev->chrdev, 1);
|
if (err) {
|
PWM_ERR("cdev_add failed!\n");
|
goto cdev_add_err;
|
}
|
|
sunxi_pwm_class = class_create(THIS_MODULE, "sunxi_pwm_char_class");
|
if (IS_ERR(sunxi_pwm_class)) {
|
err = PTR_ERR(sunxi_pwm_class);
|
PWM_ERR("class_create failed!\n");
|
goto class_err;
|
}
|
|
dev = device_create(sunxi_pwm_class, NULL, sunxi_pwm_dev->chrdev, NULL,
|
"sunxi_pwm%d", 0);
|
if (IS_ERR(dev)) {
|
err = PTR_ERR(dev);
|
PWM_ERR("device_create failed!\n");
|
goto device_err;
|
}
|
|
return 0;
|
|
device_err:
|
device_destroy(sunxi_pwm_class, sunxi_pwm_dev->chrdev);
|
class_err:
|
cdev_del(&(sunxi_pwm_dev->cdev));
|
cdev_add_err:
|
unregister_chrdev_region(sunxi_pwm_dev->chrdev, 1);
|
alloc_chrdev_err:
|
kfree(sunxi_pwm_dev);
|
|
return err;
|
}
|
|
static void __exit sunxi_pwm_exit(void)
|
{
|
cdev_del(&(sunxi_pwm_dev->cdev));
|
unregister_chrdev_region(sunxi_pwm_dev->chrdev, 1);
|
device_destroy(sunxi_pwm_class, sunxi_pwm_dev->chrdev);
|
class_destroy(sunxi_pwm_class);
|
kfree(sunxi_pwm_dev);
|
}
|
|
module_init(sunxi_pwm_init);
|
module_exit(sunxi_pwm_exit);
|
MODULE_AUTHOR("Li huaxing");
|
MODULE_LICENSE("GPL");
|
MODULE_DESCRIPTION("SUNXI_PWM char");
|
