学习笔记 --- LINUX 驱动调试之动态设置寄存器

最新推荐文章于 2023-11-10 12:07:13 发布

软件框架设计

最新推荐文章于 2023-11-10 12:07:13 发布

阅读量998

点赞数

分类专栏： LINUX学习笔记

LINUX学习笔记专栏收录该内容

44 篇文章 1 订阅

订阅专栏

转自：http://liu1227787871.blog.163.com/blog/static/2053631972012610101614610/

当我们调试驱动程序的时候，可能要调整寄存器的设置。按照我们之前的作法就是直接在程序里面修改，然后重新编译程序。但是这种方法比较麻烦，我们可以编写一个工具，可以直接对寄存器进行修改，我们传入的是寄存器的物理地址，可以编写读写命令对寄存器查看与设置。其具体程序如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
#include <linux/device.h>

#define KER_RW_R8       0
#define KER_RW_R16     1
#define KER_RW_R32     2

#define KER_RW_W8      3
#define KER_RW_W16     4
#define KER_RW_W32     5

static int major;
static struct class *class;
static struct class_device *ker_dev;

/*我们主要完成的就是这个ioctl函数：其中arg表示传递进来的参数，它是有两个成员的一维数组
 *第一个成员表示地址表示地址，第二个成员只在写的时候有意义，表示要写入的数据
*/
static int ker_rw_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
 volatile unsigned char  *p8;
 volatile unsigned short *p16;
 volatile unsigned int   *p32;
 unsigned int val;
 unsigned int addr;

 unsigned int buf[2];

        /* 用户空间的arg拷贝到内核空间的buf中 */
 copy_from_user(buf, (const void __user *)arg, 8);
 addr = buf[0];    //第一个是地址
 val  = buf[1];     //第二个是数据
 
         //映射：因为我们传递进来的是物理地址，可以读写的必须是虚拟地址
         //这里映射了4个字节，因为寄存器地址是4个字节
 p8  = (volatile unsigned char *)ioremap(addr, 4);
 p16 = p8;
 p32 = p8;

 switch (cmd)
 {
  case KER_RW_R8:
  {
   val = *p8;  //取地址p8处的数据
                        /* 把内核中的数据val拷贝到用户空间 */
   copy_to_user((void __user *)(arg+4), &val, 4);//拷贝4个字节到用户空间
   break;
  }

  case KER_RW_R16:
  {
   val = *p16;
   copy_to_user((void __user *)(arg+4), &val, 4);
   break;
  }

  case KER_RW_R32:
  {
   val = *p32;
   copy_to_user((void __user *)(arg+4), &val, 4);
   break;
  }

  case KER_RW_W8:
  {       
   *p8 = val;  //把val写到地址p8处
   break;
  }

  case KER_RW_W16:
  {
   *p16 = val;
   break;
  }

  case KER_RW_W32:
  {
   *p32 = val;
   break;
  }
 }

 iounmap(p8);
 return 0;
}

static struct file_operations ker_rw_ops = {
 .owner   = THIS_MODULE,
 .ioctl   = ker_rw_ioctl,
};

static int ker_rw_init(void)
{
 major = register_chrdev(0, "ker_rw", &ker_rw_ops);
 class = class_create(THIS_MODULE, "ker_rw");
 /* 为了让mdev根据这些信息来创建设备节点 */
 ker_dev = class_device_create(class, NULL, MKDEV(major, 0), NULL, "ker_rw"); /* /dev/ker_rw */
 
 return 0;
}

static void ker_rw_exit(void)
{
 class_device_unregister(ker_dev);
 class_destroy(class);
 unregister_chrdev(major, "ker_rw");
}

module_init(ker_rw_init);
module_exit(ker_rw_exit);

MODULE_LICENSE("GPL");

我们总结一下：在这个函数里面主要是一个ioctl函数，在这个函数里面，写的话就根据地址，将数据写进去，读的话就将从要读的地址读出数据。显然，我们可以再用户空间给出寄存器地址，和相应的数据，进行寄存器的读写，下面我们来看应用程序：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

#define KER_RW_R8      0
#define KER_RW_R16     1
#define KER_RW_R32     2

#define KER_RW_W8      3
#define KER_RW_W16     4
#define KER_RW_W32     5

void print_usage(char *file)
{
 printf("Usage:\n");
 printf("%s <r8 | r16 | r32> <phy addr> [num]\n", file);
 printf("%s <w8 | w16 | w32> <phy addr> <val>\n", file);
}

int main(int argc, char **argv)
{
 int fd;
 unsigned int buf[2];
 unsigned int i;
 unsigned int num;
 
 if ((argc != 3) && (argc != 4))
 {
  print_usage(argv[0]);
  return -1;
 }

 fd = open("/dev/ker_rw", O_RDWR);
 if (fd < 0)
 {
  printf("can't open /dev/ker_rw\n");
  return -2;
 }

 /* addr */
 buf[0] = strtoul(argv[2], NULL, 0);

 if (argc == 4)
 {
  buf[1] = strtoul(argv[3], NULL, 0);
  num    = buf[1];//写的时候为要写入的数值，读的时候为要读的字节数
 }
 else
 {
  num = 1;
 }

 if (strcmp(argv[1], "r8") == 0)
 {
  for ( i = 0; i < num; i++)
  {
   ioctl(fd, KER_RW_R8, buf);  /* val = buf[1] */
   printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned char)buf[1]);
   buf[0] += 1;
  }
 }
 else if (strcmp(argv[1], "r16") == 0)
 {
  for ( i = 0; i < num; i++)
  {
   ioctl(fd, KER_RW_R16, buf);  /* val = buf[1] */
   printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned short)buf[1]);
   buf[0] += 2;
  }
 }
 else if (strcmp(argv[1], "r32") == 0)
 {
  for ( i = 0; i < num; i++)
  {
   ioctl(fd, KER_RW_R32, buf);  /* val = buf[1] */
   printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned int)buf[1]);
   buf[0] += 4;
  }
 }
 else if (strcmp(argv[1], "w8") == 0)
 {
  ioctl(fd, KER_RW_W8, buf);  /* val = buf[1] */
 }
 else if (strcmp(argv[1], "w16") == 0)
 {
  ioctl(fd, KER_RW_W16, buf);  /* val = buf[1] */
 }
 else if (strcmp(argv[1], "w32") == 0)
 {
  ioctl(fd, KER_RW_W32, buf);  /* val = buf[1] */
 }
 else
 {
  printf(argv[0]);
  return -1;
 }

 return 0;
 
}

这样就可以动态调试寄存器设置了，不需要每次配置好了再重新烧写。