设备驱动(十五)

开启设备的时钟

1. struct clk *my_clk;     //定义时钟结构体
2. my_clk = clk_get(NULL, "watchdog");     //获取设备的时钟信息
3. clk_enable(my_clk);      //打开时钟
4. clk_disable(my_clk);     //关闭时钟

所有有关时钟的设备，只有打开时钟后设置设备的寄存器才有效。

看门狗驱动

原理图

PCLK = 66MHZ

WTCON

[15:8]     0x80

[5]          0x1

[4:3]       0x2

WTCNT

0x8000

1. 模块许可
2. 加载函数
   1. 注册字符设备
   2. 映射
   3. 获取时钟
3. 卸载函数
4. 操作集合
   1. FEED_DOG
5. 打开时钟
6. 设置计数器WTCNT
7. 使能看门狗WTCON
8. release关闭时钟

PWM脉冲调制

GPD0_1 

TCNTB1 0x1e

TCMPB1 0xf

TCFG0[7:0]  0xff

TCFG1[7:4] 0x4

最后设置
TCON[11:8] 0x2

1. 模块许可
2. 加载函数
   1. 申请设备号
   2. 注册字符设备
   3. 映射寄存器
3. open函数
   1. 设置预分频、设置再分频
   2. 设置tcnt、tcmp
   3. 设置gpd0_1为TOUT_1输出
   4. 使能tcon，手动更新tcnt,tcmp
4. 卸载函数
   1. 关闭tcon
5. 操作集合
   1. BEEP_ON
      1. 设置自动重装tcon、tcmp
   2. BEEP_OFF
      1. 关闭tcon
   3. SET_CNTB1
      1. 安装参数更新tcon、tcmp

PWM产考代码

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <asm/io.h>

//#include <plat/regs-timer.h>

//#include <mach/regs-gpio.h>

#include "fs210_pwm.h"

MODULE_LICENSE("Dual BSD/GPL");

MODULE_AUTHOR("farsight");

#define GPD0CON  0xE02000A0

struct pwm_timer

{

     unsigned int tcfg0;

     unsigned int tcfg1;

     unsigned int tcon;

     unsigned int tcntb0;

     unsigned int tcmpb0;

     unsigned int tcnto0;

     unsigned int tcntb1;

     unsigned int tcmpb1;

} *pwm_timer;

static int pwm_major = 250;

static int pwm_minor = 0;

static struct cdev pwm_cdev;

void *gpd0con;

static void beep_init(void)

{

     writel((readl(gpd0con) & (~0xf<<4)) | (0x2<<4), gpd0con);

     writel(readl(&pwm_timer->tcfg0) | 0xff, &pwm_timer->tcfg0);

     writel((readl(&pwm_timer->tcfg1) & ~(0xf<<4)) | (0x4<<4), &pwm_timer->tcfg1);

     writel(30, &pwm_timer->tcntb1);

     writel(15, &pwm_timer->tcmpb1);

     writel((readl(&pwm_timer->tcon) & ~(0xf<<8)) | (0x2<<8), &pwm_timer->tcon);

}

static void beep_on(void)

{

     writel((readl(&pwm_timer->tcon) & ~(0xf<<8)) | (0x9<<8), &pwm_timer->tcon);

}

static void beep_off(void)

{

     writel((readl(&pwm_timer->tcon) & ~(0xf<<8)), &pwm_timer->tcon);

}

static void set_cnt(unsigned long count)

{

     writel(count, &pwm_timer->tcntb1);

     writel(count/2, &pwm_timer->tcmpb1);

}

static int fs210_pwm_open(struct inode *inode, struct file *file)

{

     printk("pwm: device open\n");

     beep_init();

     return 0;

}

static int fs210_pwm_close(struct inode *inode, struct file *file)

{

     printk("pwm: device close\n");

     beep_off();

     return 0;

}

static long fs210_pwm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

     //printk("pwm: device ioctl\n");

     switch(cmd)

     {

     case BEEP_ON:

          printk("pwm: BEEP ON\n");

          beep_on();

          break;

     case BEEP_OFF:

          printk("pwm: BEEP OFF\n");

          beep_off();

          break;

     case SET_CNT:

          printk("pwm: SET CNT\n");

          set_cnt(arg);

          break;

     default:

          printk("pwm: available command\n");

          return -EINVAL;

     }

     return 0;

}

static struct file_operations fs210_pwm_ops = {

     .owner           = THIS_MODULE,

     .open           = fs210_pwm_open,

     .release      = fs210_pwm_close,

     .unlocked_ioctl          = fs210_pwm_ioctl

};

static int pwm_setup_cdev(struct cdev *cdev,

          struct file_operations *fops)

{

     int result;

     dev_t devno = MKDEV(pwm_major, pwm_minor);

     cdev_init(cdev, fops);

     cdev->owner = THIS_MODULE;

     result = cdev_add(cdev, devno, 1);

     if (result)

     {

          printk("pwm: fail to add cdev\n");

          return result;

     }

     return 0;

}

static int __init fs210_pwm_init(void)

{

     int result;

     dev_t devno = MKDEV(pwm_major, pwm_minor);

     result = register_chrdev_region(devno, 1, "fs210_pwm");

     if (result)

     {

          printk("pwm: unable to get major %d\n", pwm_major);

          return result;

     }

     result = pwm_setup_cdev(&pwm_cdev, &fs210_pwm_ops);

     if (result)

          return result;

     gpd0con = ioremap(GPD0CON, 4);

     pwm_timer = ioremap(0xE2500000, sizeof(struct pwm_timer));

     printk("pwm: driver installed with major %d!\n", pwm_major);

     return 0;

}

static void __exit fs210_pwm_exit(void)

{

     dev_t devno = MKDEV(pwm_major, pwm_minor);

     cdev_del(&pwm_cdev);

     unregister_chrdev_region(devno, 1);

     iounmap(gpd0con);

     iounmap(pwm_timer);

     printk("pwm: driver uninstalled!\n");

}

module_init(fs210_pwm_init);

module_exit(fs210_pwm_exit);

看门狗参考代码

#include <linux/module.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/ioctl.h>

#include <asm/uaccess.h>

#include <asm/io.h>

//#include <linux/delay.h>

#include <plat/regs-watchdog.h>

//#include <plat/map-base.h>

#include <linux/clk.h>

#define WATCHDOG_MAGIC 'k' 

#define FEED_DOG _IO(WATCHDOG_MAGIC,1)

#define WATCHDOG_MAJOR 250

#define DEVICE_NAME "s5pv210_watchdog"

MODULE_LICENSE("GPL");

MODULE_AUTHOR("farsight");

MODULE_DESCRIPTION("s5pv210 Watchdog");

#define S5PV210_PA_WTCON 0xE2700000

#define S5PV210_PA_WTCNT 0xE2700008

void *s5pv210_wtcon;

void *s5pv210_wtcnt;

struct clk     *clk;

static int watchdog_major = WATCHDOG_MAJOR;

static struct cdev watchdog_cdev;

static int watchdog_open(struct inode *inode ,struct file *file)    

{

     clk_enable(clk);

     writel(0x8000, s5pv210_wtcnt);//设置计数寄存器，如果里面内容递减为0时，reset。

     writel(S3C2410_WTCON_ENABLE|S3C2410_WTCON_DIV64|S3C2410_WTCON_RSTEN |

               S3C2410_WTCON_PRESCALE(0x80), s5pv210_wtcon);//设置控制寄存器的属性，具体参看datasheet，主要是得到t_watchdog时钟周期。

     printk(KERN_NOTICE"open the watchdog now!\n");

    

     return 0;

}

static int watchdog_release(struct inode *inode,struct file *file)

{

     clk_disable(clk);

    

     return 0;

}

//喂狗

static long watchdog_ioctl(struct file *file,unsigned int cmd,unsigned long arg)

{    

     switch( cmd )

     {

     case FEED_DOG:

          writel(0x8000, s5pv210_wtcnt);

          break;

     }

    

     return 0;    

}

//将设备注册到系统之中

static void watchdog_setup_dev(struct cdev *dev,int minor,struct file_operations *fops)

{

     int err;

     dev_t devno = MKDEV(watchdog_major,minor);

    

     cdev_init(dev, fops);

     dev->owner = THIS_MODULE;

     err = cdev_add(dev, devno, 1);

     if (err)

     printk(KERN_INFO"Error %d adding watchdog %d\n",err,minor);

}

static struct file_operations watchdog_ops = {

     .owner = THIS_MODULE,

     .open = watchdog_open,

     .release = watchdog_release,

     .unlocked_ioctl = watchdog_ioctl,

};

//注册设备驱动程序，主要完成主设备号的注册

static int __init s5pv210_watchdog_init(void)

{

     int result;

    

     dev_t dev = MKDEV(watchdog_major,0);

    

     result = register_chrdev_region(dev,1,DEVICE_NAME);

    

     if (result < 0)

     {

          printk(KERN_WARNING"watchdog:unable to get major %d\n",watchdog_major);         

            return result;

     }

     printk(KERN_NOTICE"[DEBUG] watchdog device major is %d\n",watchdog_major);

    

     watchdog_setup_dev(&watchdog_cdev, 0, &watchdog_ops);

     s5pv210_wtcon = ioremap(S5PV210_PA_WTCON, 4);

     s5pv210_wtcnt = ioremap(S5PV210_PA_WTCNT, 4);

     clk = clk_get(NULL, "watchdog");

     if (IS_ERR(clk)) {

          printk("failed to get watchdog clock\n");

          result = PTR_ERR(clk);

          return result;

     }

    

     return 0;

}

//驱动模块卸载

static void s5pv210_watchdog_exit(void)

{

     iounmap(s5pv210_wtcon);

     iounmap(s5pv210_wtcnt);

     cdev_del(&watchdog_cdev);

     unregister_chrdev_region(MKDEV(watchdog_major,0),1);

}

module_init(s5pv210_watchdog_init);

module_exit(s5pv210_watchdog_exit);