驱动程序显示加载成功，但是运行测试应用程序后，向设备发数据就出现键盘鼠标无响应，串口端没有打印信息，也不能输入。求助！！！，只能

[小北丶]

这是我的驱动程序

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/interrupt.h>

#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/errno.h>
/* Standard module information, edit as appropriate */
MODULE_LICENSE("GPL");
MODULE_AUTHOR
    ("Xilinx Inc.");
MODULE_DESCRIPTION
    ("mygpio - loadable module template generated by petalinux-create -t modules");

#define DRIVER_NAME "mygpio"

/* Simple example of how to receive command line parameters to your module.
   Delete if you don't need them */
unsigned myint = 0xdeadbeef;
char *mystr = "default";

module_param(myint, int, S_IRUGO);
module_param(mystr, charp, S_IRUGO);

struct mygpio_local {
	unsigned long mem_start;
	unsigned long mem_end;
	void __iomem *base_addr;
        struct device *dev;
	struct cdev cdev;
};
static struct mygpio_local *lp;
struct class *mygpio_class;
static int mygpio_major;
/*文件打开函数*/
static int mygpio_open(struct inode *inode, struct file *filp){
	printk("mygpio open success\n");
	return 0;
}
/*文件释放函数*/
static int mygpio_release(struct inode *inode, struct file *filp){
	printk("mygpio release success\n");
	return 0;
}
/*文件写函数*/
static ssize_t mygpio_write(struct file *f, const char __user * buf, size_t len, loff_t * off)
{

	int ret;
	printk("mygpio start to write.\n");
	ret=copy_from_user(lp->base_addr,buf,len);
	if(ret!=0){
		printk("copy from user failure\n");
		return -EFAULT;
	}
	return len;
}
static long mygpio_ioctl(struct file *filp, unsigned int reg_num, unsigned long arg)
{
	printk("reg num is %d,arg is %d\n",reg_num,arg);
        iowrite32(arg,lp->base_addr+reg_num*4);
	return 0;
}
static ssize_t mygpio_read(struct file *f, char __user * buf, size_t len, loff_t * off)
{
	int ret;
	printk("mygpio start to read\n");
	ret=copy_to_user(buf,lp->base_addr,len);
	if(ret!=0){
	    printk("copy to user failure\n");
		return -EFAULT;
	}
        return len;
}
/*文件操作结构体*/
static const struct file_operations mygpio_fops={
	.owner	= THIS_MODULE,
	.open	= mygpio_open,//打开设备函数
	.write  = mygpio_write,
	.read   = mygpio_read,
        .unlocked_ioctl=mygpio_ioctl,
	.release= mygpio_release,//释放设备函数
};
static void mygpio_cdev_setup_cdev(struct mygpio_local *devp, int minor){
	int err;
	dev_t devno = MKDEV(mygpio_major, minor);/*构造设备号*/
	cdev_init(&devp->cdev, &mygpio_fops);/*初始化cdev设备*/
	devp->cdev.owner = THIS_MODULE;/*使驱动程序属于该模块*/
	devp->cdev.ops = &mygpio_fops;/*cdev连接file_operations指针*/
	err = cdev_add(&devp->cdev, devno, 1);/*将cdev注册到系统中*/
	if (err)
		printk(KERN_NOTICE "mygpio: error in cdev_add()\n");
}
static int mygpio_probe(struct platform_device *pdev)
{
	struct resource *r_mem; /* IO mem resources */
	struct device *dev = &pdev->dev;
	dev_t devno;
	int rc = 0;
	int ret;
	dev_info(dev, "Device Tree Probing\n");
	/* Get iospace for the device */
	r_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r_mem) {
		dev_err(dev, "invalid address\n");
		return -ENODEV;
	}
	lp = (struct mygpio_local *) kmalloc(sizeof(struct mygpio_local), GFP_KERNEL);
	if (!lp) {
		dev_err(dev, "Cound not allocate mygpio device\n");
		return -ENOMEM;
	}
	dev_set_drvdata(dev, lp);
	lp->mem_start = r_mem->start;
	lp->mem_end = r_mem->end;

	if (!request_mem_region(lp->mem_start,
				lp->mem_end - lp->mem_start + 1,
				DRIVER_NAME)) {
		dev_err(dev, "Couldn't lock memory region at %p\n",
			(void *)lp->mem_start);
		rc = -EBUSY;
		goto error1;
	}

	lp->base_addr = ioremap(lp->mem_start, lp->mem_end - lp->mem_start + 1);
	if (!lp->base_addr) {
		dev_err(dev, "mygpio: Could not allocate iomem\n");
		rc = -EIO;
		goto error2;
	}

	
	dev_info(dev,"mygpio at 0x%08x mapped to 0x%08x",
		(unsigned int __force)lp->mem_start,
		(unsigned int __force)lp->base_addr);
	ret=alloc_chrdev_region(&devno,0,1,"mygpio");//分配设备号
	if(ret<0){
		printk("mygpio: allocate devno failed\n");
		return ret;
	}
	mygpio_major=MAJOR(devno);
	//用于创建/dev目录下的设备节点
	mygpio_class=class_create(THIS_MODULE,"mygpio_class");
	if(IS_ERR(mygpio_class)){
		printk("mygpio_class: create class error\n");
		return -1;
	}
	lp->dev=device_create(mygpio_class,NULL,devno,NULL,"mygpio");
	mygpio_cdev_setup_cdev(lp,0);
	return 0;
error2:
	release_mem_region(lp->mem_start, lp->mem_end - lp->mem_start + 1);
error1:
	kfree(lp);
	dev_set_drvdata(dev, NULL);
	return rc;
}

static int mygpio_remove(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	release_mem_region(lp->mem_start, lp->mem_end - lp->mem_start + 1);
	kfree(lp);
	dev_set_drvdata(dev, NULL);
	return 0;
}

#ifdef CONFIG_OF
static struct of_device_id mygpio_of_match[] = {
	{ .compatible = "xlnx,ww-gpio-1.00.a", },
	{ /* end of list */ },
};
MODULE_DEVICE_TABLE(of, mygpio_of_match);
#else
# define mygpio_of_match
#endif


static struct platform_driver mygpio_driver = {
	.driver = {
		.name = DRIVER_NAME,
		.owner = THIS_MODULE,
		.of_match_table	= mygpio_of_match,
	},
	.probe		= mygpio_probe,
	.remove		= mygpio_remove,
};

static int __init mygpio_init(void)
{
	printk("<1>Hello module mygpio.\n");
	printk("<1>Module parameters were (0x%08x) and \"%s\"\n", myint,
	       mystr);

	return platform_driver_register(&mygpio_driver);
}


static void __exit mygpio_exit(void)
{
	platform_driver_unregister(&mygpio_driver);
	printk(KERN_ALERT "Goodbye module mygpio.\n");
}

module_init(mygpio_init);
module_exit(mygpio_exit);

这是我的测试应用程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <signal.h>
int fd1,fd2;
void dma_data_read(void)
{
	char  buffer[4096];	
	int i;
	printf("start to read !\n");
	read(fd1,&buffer,sizeof(buffer));//从内核空间读出dma传送的数据并保存在buffer中
	//打印出保存的数据，验证传输的数据是否正确是否正确
	for(i=0;i<4096;i++)
        {
	     printf("buffer[%d]=%d,\n",i,buffer[i]);
        }
	
}
int main(int argc, char **argv)
{
    printf("Test start!\n"); 
    int gpiodata;
    int Oflags;
    int ret;
    signal(SIGIO,dma_data_read);
    fd1=open("/dev/s2mmdma",O_RDWR);//打开s2mmdma设备
    if(fd1<0){
        printf("can not open device s2mmdma!\n");
        return 0;
    }
    fd2=open("/dev/mygpio",O_RDWR);//打开mygpio设备
    if(fd2<0){
    	printf("can't open device mygpio!\n");
    }
	//建立异步通知机制，当dma通道传输完成时，会通过异步通知机制告诉应用程序去读数据
    ret=fcntl(fd1,F_SETOWN,getpid());
    if(ret<0){
      printf("can't fcntl_1!\n");
    }
    Oflags=fcntl(fd1,F_GETFL);
    printf("Oflags is : %d\n",Oflags);
    if(Oflags<0){
       printf("can't fcntl_2\n");
    }
    ret=fcntl(fd1,F_SETFL,Oflags | FASYNC);
    if(ret<0){
       printf("can't fcntl_3\n");
    }
	//
    printf("input gpio data:\n");
    scanf("%d",&gpiodata);
    ioctl(fd1,1,4096); //第二个参数怎定为1，第三个参数是dma传输的长度 以字节为单位 当把传输的字节长度写入dma相应的寄存器后，dma传输就绪(详见pg021)
    //write(fd2,&gpiodata,sizeof(gpiodata));
    ioctl(fd2,0,gpiodata);//控制gpio的输出，开始产生数据
    sleep(1);
    close(fd1);
    close(fd2);
    return 0;
}

希望得到各位的指点。

[sunchuquin]

因为加载之后还要启动啊

[小北丶]

在打开测试应用程序之前，串口已经打印出驱动加载成功的信息，测试程序打开后，在向gpio发数据之前都是正常，没有出现异常，但是在向gpio发1或0后，就出现linux死机状态，键盘和鼠标无效，串口也不能进行操作。

[小北丶]

引用 2 楼 Dennis_Sck 的回复:

因为加载之后还要启动啊

你没看测试文件当中已经启动了我的设备。