在智龙2上GPIO6 GPIO92产生PWM波

sundm75

方案一：利用 LED_PWM

(1) PWM0 PWM1 分析

原始功能没有复用

                              

LS1X_PWM0_BASE  0x1fe5c000 此处是物理地址0xbfefc0000 为核心虚地址空间的程序空间地址

使用的平台文件 pwm.c  中

这就需要在内核配置时，添加以下选项：

添加了HAVE_PWM后，就有了平台设备pwm_device的定义 ls1x_pwm_list

(2)内核中选择Loongson 1Cboard的CPU

则在pwm.c中定义了外部的ls1x_pwm_list，分析驱动pwm.c

这个变量在平台文件中定义，分析ls1c300a_openloongson_v2.0_platform.c

下面看leds_pwm

在drivers/leds/ 下的makefile, leds_pwm的编译依赖于 CONFIG_LEDS_PWM.

CONFIG_LEDS_PWM 在内核配置中的出现依赖于  HAVE_PWM配置项

其中， struct pwm_device 在文件

linux-3.0.82-openloongson\linux-3.0.82-openloongson\arch\mips\include\asm\mach-loongson\ls1x\ls1x_pwm.h

#ifndef __ASM_ARCH_LS1X_PWM_H

#define __ASM_ARCH_LS1X_PWM_H

struct pwm_device {

         unsignedint id;

         unsignedint gpio;

         boolused;

};

#endif /* __ASM_ARCH_LS1X_PWM_H */

（3）Linux内核配置选中pwm驱动

Machine selection --->

  Systemtype(Loongson family of machines) --->  

  MacineType(Loongson 1C board)  --->

[ ] loongson 1c v2

Enable PWM

在LED类中配置PWM

Device Drivers --->

LED Support --->  

   <*>PWM driven LED Support

在平台文件ls1c300a_openloongson_v2.0_platform.c 中添加：

#ifdef CONFIG_LEDS_PWM

static struct led_pwm ls1x_pwm_leds[] = {

         {

                   .name                   = "ls1x_pwm_led1",

                   .pwm_id              = 0,

                   .max_brightness  = 255,

                   .pwm_period_ns = 7812500,

         },

         {

                   .name                   = "ls1x_pwm_led2",

                   .pwm_id              = 1,

                   .max_brightness  = 255,

                   .pwm_period_ns = 7812500,

         },

};

static struct led_pwm_platform_data ls1x_pwm_data ={

         .num_leds  = ARRAY_SIZE(ls1x_pwm_leds),

         .leds           = ls1x_pwm_leds,

};

static struct platform_device ls1x_leds_pwm = {

         .name         = "leds_pwm",

         .id              =-1,

         .dev   = {

                   .platform_data= &ls1x_pwm_data,

         },

};

#endif //#ifdef CONFIG_LEDS_PWM

上一个平台文件中，函数static struct platform_device *ls1b_platform_devices[]__initdata  中添加：

#ifdef CONFIG_LEDS_PWM

         &ls1x_leds_pwm,

#endif

平台文件增加成功：leds_pwm

将PWM0 占比调到最大(高电平占100%)

echo 255 > brightness

将PWM0 占比调到最小(低电平占100%)

echo 0 > brightness

sundm75

编译成功后，编写测试代码：
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#define CMD_PWM_GET     _IO('c',0x01)
#define CMD_PWM_START   _IO('c',0x02)
#define CMD_PWM_STOP    _IO('c',0x03)
//sel为选择PWM通道(0或者1);value为占空比(0-100);  freq为频率().
int pwmset(unsigned int sel, unsigned int value, unsigned int freq) {
         int fd;
    //data[0]的值代表的是高电平脉冲所占的时钟数，data[1]的值代表的是低电平脉冲所占的时钟数
         unsigned int data[2] = {0x7ffffff,0x7ffffff};

         if(value>100)
                   value = 100;
         data[0] = freq / 100 * value;
         data[1] = freq / 100 * (100-value);

         printf("cys: ready to open!\n");
         fd = open("/dev/ls1f-pwm",O_RDWR);
         sleep(2);
         if (fd != -1)
         {
           printf("open ok!\n");
       //共有四路pwm(pwm0...pwm3)，四路pwm可同时工作，也可选择使用其中任何一路

                   if (sel <0 || sel > 3)
                     return -1;
                   switch(sel) {
                     case 0:
                            //在驱动中没有用到ioctl的第三个参数，故直接赋予0就可以啦
                       ioctl(fd, CMD_PWM_START , 0);
                       write(fd, data, sizeof(data) );
                       break;
                     case 1:
            ioctl(fd, CMD_PWM_START , 1);
                       write(fd, data, sizeof(data) );
            break;
                     case 2:
            ioctl(fd, CMD_PWM_START , 2);
                       write(fd, data, sizeof(data) );
            break;
                     case 3:
            ioctl(fd, CMD_PWM_START , 3);
                       write(fd, data, sizeof(data) );
            break;
                     default:
                       break;
                   }
         }
         else
         {
                  printf("Device open failure\n");
         }
         sleep(10);
         close(fd);
         return 0;
}
调用函数 pwmset(0,50,10000) 意思是在PWM0引脚产生占空比 50%, 周期10000时钟周期的波形。

sundm75

方案二：自己编写驱动文件
首先在平台文件中添加资源：
平台文件\arch\mips\loongson\ls1x\ls1c\ls1c300a_openloongson_v2.0_platform.c添加：

#ifdef CONFIG_LS1C_PWM_DRIVER
static struct resource ls1c_pwm0_resource[] = {
         [0]={
                   .start  = LS1X_PWM0_BASE,
                   .end   = (LS1X_PWM0_BASE + 0x0f),
                   .flags = IORESOURCE_MEM,
         },
         [1]={
                   .start  = LS1X_PWM1_BASE,
                   .end   = (LS1X_PWM1_BASE + 0x0f),
                   .flags = IORESOURCE_MEM,
         },
         [2]={
                   .start  = LS1X_PWM2_BASE,
                   .end   = (LS1X_PWM2_BASE + 0x0f),
                   .flags = IORESOURCE_MEM,
         },
         [3]={
                   .start  = LS1X_PWM3_BASE,
                   .end   = (LS1X_PWM3_BASE + 0x0f),
                   .flags = IORESOURCE_MEM,
         },
};

static struct platform_device ls1c_pwm_device = {
         .name         = "ls1c-pwm",
         .id     = -1,
         .num_resources   = ARRAY_SIZE(ls1c_pwm0_resource),
         .resource    = ls1c_pwm0_resource,
};
#endif //#ifdef CONFIG_LS1C_PWM_DRIVER

上一个文件中，函数 static struct platform_device *ls1b_platform_devices[] __initdata  中添加：
#ifdef CONFIG_LS1C_PWM_DRIVER
         &ls1c_pwm_device,
#endif

在 \drivers\char\Kconfig中添加：
config LS1C_PWM_DRIVER
         bool "ls1c pwm driver"
         default        n
         help
          pwm.

在 char 下的Makefile文件中添加语句：
obj-$(CONFIG_LS1C_PWM_DRIVER)        += ls1c-pwm.o

平台设备增加成功：ls1c-pwm
编写驱动文件 ls1c_pwm.c（根据1B中的资料修改）， 放到内核代码driver/char下，
修改Makefile文件，添加语句：obj-$(CONFIG_LS1C_PWM_DRIVER)       += ls1c-pwm.o
以下 设备驱动ls1c_pwm.c 代码：
/*ls1c_pwm.c*/
#include <linux/miscdevice.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/ioctl.h>
#include <linux/platform_device.h>
#include <linux/timer.h>

#define CMD_PWM_GET     _IO('c',0x01)
#define CMD_PWM_START   _IO('c',0x02)
#define CMD_PWM_STOP    _IO('c',0x03)

#define REG_PWM_CNTR  0x00 // 0xBFE5C010
#define REG_PWM_HRC    0x04 // 0xBFE5C014
#define REG_PWM_LRC     0x08 // 0xBFE5C018
#define REG_PWM_CTRL  0x0c  // 0xBFE5C01C
#define REG_GPIO_CFG0  0xbfd010c0//GPIO GPIO[31:0] 配置寄存器 1 表示配置为GPIO， 0 表示无效
#define REG_GPIO_CFG2  0xbfd010c8//GPIO[95:64] 配置寄存器 1 表示配置为GPIO， 0 表示无效
#define SB2F_GPIO_MUX_CTRL1 0xbfd00424//功能复用寄存器

static unsigned char __iomem *pwm_base = NULL;
struct resource *res;
static int ls1f_pwm_probe(struct platform_device *pdev);
struct platform_device *pwm_dev;
struct resource *res1 = NULL;

static int ls1f_pwm_getResourse(struct platform_device *pdev, unsigned int index);

static struct platform_driver ls1f_pwm_driver = {
         .probe = ls1f_pwm_probe,
         .driver = {
                            .name = "ls1c-pwm",
         },
};

static int ls1f_pwm_open(struct inode *inode, struct file *file)
{
    //配置PWM0 PWM1 原始功能没有复用
         //long val = readl(SB2F_GPIO_MUX_CTRL1);
         //val &= 0xfffffffc;
         //writel(val, SB2F_GPIO_MUX_CTRL1);

         long val = readl(REG_GPIO_CFG0);   
         //配置GPIO6引脚为普通功能，而非GPIO功能
         val &= 0xffffffbf;
         writel(val, REG_GPIO_CFG0);

         val = readl(REG_GPIO_CFG0);
         //配置GPIO92引脚为普通功能，而非GPIO功能
         val &= 0xefffffff;
         writel(val, REG_GPIO_CFG2);

        
         return 0;
}

static int ls1f_pwm_close(struct inode *inode, struct file *file)
{
         writel(0x0, pwm_base + REG_PWM_CTRL);
         return 0;
}

static ssize_t ls1f_pwm_read(struct file *file, char __user *buf, size_t count, loff_t *ptr)
{
         unsigned int pwm_val;
         pwm_val = readl(pwm_base);

         if (copy_to_user(buf, &pwm_val, sizeof(unsigned int)))
                   return -EFAULT;
         return 4;
}

static ssize_t ls1f_pwm_write(struct file *file, const char __user *buf, size_t count, loff_t *ptr)
{
         unsigned int hrc_val, lrc_val;
         unsigned int data[2] = {0x0};

         if (copy_from_user(data, buf, sizeof(data)))
         {
                   printk("Write error!\n");
                   return -EIO;
         }

         hrc_val = data[1] - 1;
         lrc_val = data[0] + data[1] -1;

         //设置占空比
         writel(hrc_val, pwm_base + REG_PWM_HRC);
         writel(lrc_val, pwm_base + REG_PWM_LRC);
         printk("hrc:%i ; lrc:%i\n",hrc_val,lrc_val);
         return 0;
}

static int pwm_start_stop(unsigned int cmd, unsigned long arg)
{
         printk("into: %s\n", __FUNCTION__);
         printk("arg: %ld\n", arg);

         if (arg > 3)
                   return -1;
         //从platform中获取指定PWM的寄存器基址 pwm_base
         //通过改变arg，实现在pwm0、pwm1、pwm2、pwm3之间切换
         ls1f_pwm_getResourse(pwm_dev, arg);
         switch (cmd) {
         //启动PWM
         case CMD_PWM_START:
                   printk("CMD_PWM_START\n");
                   writel(0x0, pwm_base + REG_PWM_CNTR);
                   writel(0x01, pwm_base + REG_PWM_CTRL);
                   break;
         //停止PWM
         case CMD_PWM_STOP:
                   printk("CMD_PWM_STOP\n");
                   writel(0x0, pwm_base + REG_PWM_CTRL);
                   break;
         default:
                   break;
         }
         return 0;
}

static long ls1f_pwm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
         printk("into %s\n", __FUNCTION__);
         printk("cmd: %d\n", cmd);
         printk("arg: %ld\n", arg);

         if (arg > 3)
                   return -1;

         switch (cmd) {
         case CMD_PWM_GET:
                   ls1f_pwm_getResourse(pwm_dev, arg);
                   break;
         case CMD_PWM_START:
         case CMD_PWM_STOP:
                   return pwm_start_stop(cmd, arg);
         default:
                   break;
         }
         return 0;
}


static const struct file_operations ls1f_pwm_ops = {
                   .owner = THIS_MODULE,
                   .open = ls1f_pwm_open,
                   .release = ls1f_pwm_close,
                   .read = ls1f_pwm_read,
                   .write = ls1f_pwm_write,
                   .unlocked_ioctl = ls1f_pwm_ioctl,
};

static struct miscdevice ls1f_pwm_miscdev = {
                   MISC_DYNAMIC_MINOR,
                   "ls1f-pwm",
                   &ls1f_pwm_ops,
};

static int ls1f_pwm_getResourse(struct platform_device *pdev, unsigned int index)
{
         res = platform_get_resource(pdev, IORESOURCE_MEM, index);

         if (res == NULL)
         {
           printk("Fail to get ls1f_pwm_resource!\n");
           return -ENOENT;
         }
         printk("Resource start=0x%x, end = 0x%x\n", res->start, res->end);
         if (res1 != NULL)
         {
                   release_mem_region(res->start, 0x0f);
         }
         res1 = request_mem_region(res->start, 0x0f, "ls1f-pwm");
         if (res1 == NULL)
         {
           printk("Fail to request ls1f_pwm region!\n");
           return -ENOENT;
         }
         pwm_base = ioremap(res->start, res->end - res->start + 1);
         if (pwm_base == NULL)
         {
           printk("Fail to ioremap ls1f_pwm resource!\n");
           return -EINVAL;
         }
         return 0;
}

static int __devinit ls1f_pwm_probe(struct platform_device *pdev)
{
         pwm_dev = pdev;
         return ls1f_pwm_getResourse(pdev, 1);
}

static int __init ls1f_pwm_init(void) {
         if (misc_register(&ls1f_pwm_miscdev))
         {
           printk(KERN_WARNING "pwm: Couldn't register device 10, %d.\n", 255);
           return -EBUSY;
         }
         return platform_driver_register(&ls1f_pwm_driver);
}

static void __exit ls1f_pwm_exit(void)
{
         misc_deregister(&ls1f_pwm_miscdev);
         release_mem_region(res->start, 0x20);
         platform_driver_unregister(&ls1f_pwm_driver);      
}

module_init(ls1f_pwm_init);
module_exit(ls1f_pwm_exit);
MODULE_AUTHOR("sundm");
MODULE_DESCRIPTION("loongson 1C PWM driver");
MODULE_LICENSE("GPL");

sundm75

上传代码

简单平安

赞！

ratking

感谢分享！