cdev设备驱动的使用

struct xlnx_vzu3_device;


struct vzu3_class_ops{
int (*read_value)(struct device *);
int (*set_value)(struct device *, int *);
int (*read_offset)(struct device *);
int (*set_offset)(struct device *, int *);
};




struct vzu3Device{
struct device dev;
struct module   *owner;
struct class *cls;
unsigned int regNo;

unsigned int id;


unsigned char name[16];
struct cdev char_dev;
struct vzu3_class_ops *ops;
struct xlnx_vzu3_device *xlnx_dev;
unsigned int majorNumber;
unsigned int bram1_addr;
unsigned int bram2_addr;
unsigned int bram3_addr;
unsigned int fpga_regs;

unsigned int timeout;


spinlock_t lock;/* Mutex */
struct tasklet_struct finish_tasklet;/* Tasklet structures */


struct timer_list timer;/* Timer for timeouts */
};




struct xlnx_vzu3_device{
struct vzu3Device *vzu3;
int value;
int offset;
};






struct xlnx_vzu3_device xlnx_vzu3_dev;
static dev_t vzu3_devt;
struct class *vzu3_class;




/********************************************************************/


void __init vzu3_dev_init(void)
{
int err;


err = alloc_chrdev_region(&vzu3_devt, 0, 16, "xlnx_vzu3");
if (err < 0)
pr_err("failed to allocate char dev region\n");
}


static int xlnx_vzu3_read_value(struct device *dev)
{
return 0;
}


static int xlnx_vzu3_set_value(struct device *dev,int *value)
{
return 0;
}


static int xlnx_vzu3_read_offset(struct device *dev)
{
return 0;
}


static int xlnx_vzu3_set_offset(struct device *dev,int *value)
{
return 0;
}


static const struct vzu3_class_ops xlnx_vzu3_ops={
.read_value=xlnx_vzu3_read_value,
.set_value=xlnx_vzu3_set_value,
.read_offset=xlnx_vzu3_read_offset,
.set_offset=xlnx_vzu3_set_offset
};




static void devm_vzu3_device_release(struct device *dev, void *res)
{
struct vzu3_device *vzu3 = *(struct vzu3_device **)res;


//rtc_device_unregister(rtc);
}


struct vzu3Device *vzu3_device_register(const char *name, struct device *dev,
const struct vzu3_class_ops *ops,
struct module *owner)
{
struct vzu3Device *vzu3;

vzu3=kzalloc(sizeof(struct vzu3Device), GFP_KERNEL);

vzu3->ops = ops;
vzu3->owner = owner;


vzu3->dev.parent = dev;
vzu3->dev.class = vzu3_class;


vzu3->id=1;
vzu3->timeout=2;
dev_set_name(&vzu3->dev, "vzu3__%d", 1);
vzu3->dev.devt=MKDEV(MAJOR(vzu3_devt),1);


cdev_init(&vzu3->char_dev, &vzu3Fops);
vzu3->char_dev.owner = THIS_MODULE;//vzu3->owner;
vzu3->char_dev.kobj.parent = &vzu3->dev.kobj;


device_register(&vzu3->dev);
cdev_add(&vzu3->char_dev, vzu3->dev.devt, 1);
}






struct vzu3Device *devm_vzu3_device_register(struct device *dev,
const char *name,
const struct vzu3_class_ops *ops,
struct module *owner)
{
struct vzu3Device **ptr, *vzu3;


ptr = devres_alloc(devm_vzu3_device_release, sizeof(*ptr), GFP_KERNEL);
if (!ptr)
return ERR_PTR(-ENOMEM);


vzu3 = vzu3_device_register(name, dev, ops, owner);
if (!IS_ERR(vzu3)) {
*ptr = vzu3;
devres_add(dev, ptr);
} else {
devres_free(ptr);
}


return vzu3;
}






static int vzu3_probe(struct platform_device *pdev)
{
int ret = 0;
struct resource *res;
int             err;
int regNo=0;


vzu3_class=class_create(THIS_MODULE,"vzu3");
vzu3_dev_init();
printk(KERN_ERR "vzu3_dev_init , vzu3_devt =%x\n",vzu3_devt);


xlnx_vzu3_dev.vzu3=devm_vzu3_device_register(&pdev->dev,pdev->name,&xlnx_vzu3_ops,THIS_MODULE);


platform_set_drvdata(pdev,&xlnx_vzu3_dev);
//rtc_dev_prepare
//err = device_register(&rtc->dev);
//rtc_dev_add_device(rtc);
return 0;

}




static int vzu3Open(struct inode *inode, struct file *filp)
{
//struct xlnx_vzu3_device*xlnx_vzu3=dev_get_drvdata;
struct vzu3Device*vzu3=container_of(inode->i_cdev,struct vzu3Device, char_dev);
printk(KERN_ERR "vzu3->id=%d,vzu3->timeout=%d\n",vzu3->id,vzu3->timeout);
}