static int __init complete_init(void)
{
int ret;
ret = alloc_chrdev_region(&complete_dev, 0, 1, "complete");
if (ret < 0) {
printk(KERN_WARNING "complete: can't alloc chrdev\n");
return ret;
}
complete_cdev = cdev_alloc();
if (!complete_cdev) {
ret = -ENOMEM;
goto fail;
}
complete_cdev->ops = &complete_fops;
ret = cdev_add(complete_cdev, complete_dev, 1);
if (ret < 0) {
printk(KERN_NOTICE "complete: Error adding cdev\n");
goto fail_cdev;
}
return 0;
fail_cdev:
kfree(complete_cdev);
fail:
unregister_chrdev_region(complete_dev, 1);
return ret;
}
/*
*----------------------------------------------------------------------------
* Function : aic3262_driver_init
*
* Purpose : Register a char driver for dynamic aic3262-tiload programming
*----------------------------------------------------------------------------
*/
int aic3262_driver_init(struct snd_soc_codec *codec)
{
int result;
dev_t dev = MKDEV(aic3262_major, 0);
printk("TiLoad DRIVER : %s\n", __FUNCTION__);
aic3262_codec = codec;
printk("allocating dynamic major number\n");
result = alloc_chrdev_region(&dev, 0, 1, DEVICE_NAME);
if (result < 0) {
printk("cannot allocate major number %d\n", aic3262_major);
return result;
}
tiload_class = class_create(THIS_MODULE, DEVICE_NAME);
aic3262_major = MAJOR(dev);
printk("allocated Major Number: %d\n", aic3262_major);
aic3262_cdev = cdev_alloc();
cdev_init(aic3262_cdev, &aic3262_fops);
aic3262_cdev->owner = THIS_MODULE;
aic3262_cdev->ops = &aic3262_fops;
if (cdev_add(aic3262_cdev, dev, 1) < 0) {
dprintk("aic3262_driver: cdev_add failed \n");
unregister_chrdev_region(dev, 1);
aic3262_cdev = NULL;
return 1;
}
printk("Registered aic3262 TiLoad driver, Major number: %d \n",
aic3262_major);
//class_device_create(tiload_class, NULL, dev, NULL, DEVICE_NAME, 0);
return 0;
}
static int uio_major_init(void)
{
static const char name[] = "uio";
struct cdev *cdev = NULL;
dev_t uio_dev = 0;
int result;
result = alloc_chrdev_region(&uio_dev, 0, UIO_MAX_DEVICES, name);
if (result)
goto out;
result = -ENOMEM;
cdev = cdev_alloc();
if (!cdev)
goto out_unregister;
cdev->owner = THIS_MODULE;
cdev->ops = &uio_fops;
kobject_set_name(&cdev->kobj, "%s", name);
result = cdev_add(cdev, uio_dev, UIO_MAX_DEVICES);
if (result)
goto out_put;
uio_major = MAJOR(uio_dev);
uio_cdev = cdev;
return 0;
out_put:
kobject_put(&cdev->kobj);
out_unregister:
unregister_chrdev_region(uio_dev, UIO_MAX_DEVICES);
out:
return result;
}
static int at91_adc_cdev_setup(void){
int status;
/* alloc a new device number (major: dynamic, minor: 0) */
status = alloc_chrdev_region(&at91_adc_devno,0,1,at91_adc_device.name);
if(status){
goto err;
}
/* create a new char device */
at91_adc_cdev = cdev_alloc();
if(at91_adc_cdev == NULL){ status=-ENOMEM; goto err; }
at91_adc_cdev->owner = THIS_MODULE;
at91_adc_cdev->ops = &at91_adc_fops;
status = cdev_add(at91_adc_cdev,at91_adc_devno,1);
if(status){
goto err;
}
/* register the class */
at91_adc_class = class_create(THIS_MODULE, DRV_CLASS);
if(IS_ERR(at91_adc_class)){ status=-EFAULT; goto err; }
device_create(at91_adc_class, NULL, at91_adc_devno, NULL, at91_adc_device.name);
printk(KERN_INFO "Major: %u; minor: %u\n", \
MAJOR(at91_adc_devno), MINOR(at91_adc_devno) \
);
return 0;
err:
at91_adc_cdev_teardown();
return status;
}
int __init lcd_module_init(void)
{
int ret = 0, err;
__inf("lcd_module_init\n");
alloc_chrdev_region(&devid, 0, 1, "lcd");
my_cdev = cdev_alloc();
cdev_init(my_cdev, &lcd_fops);
my_cdev->owner = THIS_MODULE;
err = cdev_add(my_cdev, devid, 1);
if (err)
{
__wrn("cdev_add fail.\n");
return -1;
}
lcd_class = class_create(THIS_MODULE, "lcd");
if (IS_ERR(lcd_class))
{
__wrn("class_create fail\n");
return -1;
}
device_create(lcd_class, NULL, devid, NULL, "lcd");
lcd_init();
return ret;
}
static int cs598_create_char_dev(void)
{
int result = 0;
/* Dynamically allocate a major number for the device */
result = alloc_chrdev_region(&cs598_dev,
cs598_dev_minor,
cs598_nr_devs,
"my_char_dev");
cs598_dev_major = result;
if (result < 0) {
printk(KERN_INFO "cs598: Char dev cannot get major\n");
return result;
}
/* Allocate a character device structure */
cs598_cdev = cdev_alloc();
/* Assign the function pointers */
cs598_cdev->ops = &cs598_dev_fops;
cs598_cdev->owner = THIS_MODULE;
/* Add this character device */
result = cdev_add(cs598_cdev, cs598_dev, 1);
if (result) {
printk(KERN_INFO "cs598: Error adding device\n");
return result;
}
return result;
}
static int __init pa_dev_init(void)
{
// int status = 0;
int err = 0;
printk("[pa_drv] start!!!\n");
if((platform_device_register(&sw_device_pa))<0)
return err;
if ((err = platform_driver_register(&sw_pa_driver)) < 0)
return err;
alloc_chrdev_region(&dev_num, 0, 1, "pa_chrdev");
pa_dev = cdev_alloc();
cdev_init(pa_dev, &pa_dev_fops);
pa_dev->owner = THIS_MODULE;
err = cdev_add(pa_dev, dev_num, 1);
if (err){
printk(KERN_NOTICE"Error %d adding pa_dev!\n", err);
return -1;
}
pa_dev_class = class_create(THIS_MODULE, "pa_cls");
device_create(pa_dev_class, NULL,
dev_num, NULL, "pa_dev");
printk("[pa_drv] init end!!!\n");
return 0;
}
/*
* devapc_init: module init function.
*/
static int __init devapc_init(void)
{
int ret;
/*You do not need to open the clock for Rainier*/
//enable_clock(MT_CG_INFRA_DEVICE_APC,"DEVAPC");
pr_warn("[DEVAPC] module init. \n");
ret = platform_device_register(&devapc_device);
if (ret) {
pr_warn("[DEVAPC] Unable to do device register(%d)\n", ret);
return ret;
}
ret = platform_driver_register(&devapc_driver);
if (ret) {
pr_warn("[DEVAPC] Unable to register driver (%d)\n", ret);
platform_device_unregister(&devapc_device);
return ret;
}
g_devapc_ctrl = cdev_alloc();
if (!g_devapc_ctrl) {
pr_warn("[DEVAPC] Failed to add devapc device! (%d)\n", ret);
platform_driver_unregister(&devapc_driver);
platform_device_unregister(&devapc_device);
return ret;
}
g_devapc_ctrl->owner = THIS_MODULE;
return 0;
}
int capture_module_init(void)
{
int ret = 0, err;
pr_info("[DISP]capture_module_init\n");
alloc_chrdev_region(&devid, 0, 1, "capture");
my_cdev = cdev_alloc();
my_cdev->owner = THIS_MODULE;
err = cdev_add(my_cdev, devid, 1);
if (err) {
__wrn("cdev_add fail\n");
return -1;
}
capture_class = class_create(THIS_MODULE, "capture");
if (IS_ERR(capture_class)) {
__wrn("class_create fail\n");
return -1;
}
device_create(capture_class, NULL, devid, NULL, "capture");
ret = platform_device_register(&capture_device);
if (ret == 0) {
ret = platform_driver_register(&capture_driver);
}
pr_info("[DISP]==capture finish==\n");
return ret;
}
static int createDevice(void)
{
/*Alocciert platz für device*/
if(alloc_chrdev_region(&my_dev,0, DEV_COUNT, DEV_NAME) < 0)
{
printk (KERN_ERR "Alloc device fehler\n");
return -EIO;
}
printk (KERN_INFO "MAJOR NUMBER: %d/n", MAJOR(my_dev));
my_cdev = cdev_alloc();
if(my_cdev == NULL){
printk (KERN_ERR "cdev alloc FAIL!/n");
}
my_cdev->owner = THIS_MODULE;
my_cdev->ops = &my_fops;
printk (KERN_INFO "cdev alloc SUCCESSFUL\n");
if(cdev_add(my_cdev, my_dev, DEV_COUNT)){
printk (KERN_ERR "add device FAILD\n");
my_cdev = NULL;
return -EIO;
}
return 0;
}
static int fa_init(void)
{
int ret = 0;
ret = alloc_chrdev_region(&ndev, 0, 1, "fa_dev");
if(ret < 0) {
printk(KERN_INFO "register dev failed!\n");
return ret;
}
pcdev = cdev_alloc();
cdev_init(pcdev, &ops);
pcdev->owner = THIS_MODULE;
cdev_add(pcdev, ndev, 1);
fa_cls = class_create(THIS_MODULE, "fa_dev");
if(IS_ERR(fa_cls))
return PTR_ERR(fa_cls);
fadev = device_create(fa_cls, NULL, ndev, NULL, "fa_dev");
if(IS_ERR(fadev))
return PTR_ERR(fadev);
//在sys文件系统中创建一个名为flag的文件
ret = device_create_file(fadev, &flag_attr);
return ret;
}
static int __init driver_entry_init(void)
{
printk(KERN_WARNING "Gilc: The moudle has been loaded!\n");
ret = alloc_chrdev_region(&dev_num,0,1,DEVICE_NAME);
if (ret < 0){
printk(KERN_WARNING "Gilc: Failed to allocate a major number\n");
return ret;
}
major_number = MAJOR(dev_num);
printk(KERN_WARNING "Gilc: major number is %d", major_number);
printk(KERN_WARNING "\tuse \"mknod /dev/%s c %d 0\" for device file", DEVICE_NAME,major_number);
my_cdev = cdev_alloc();
my_cdev->ops = &fops;
my_cdev->owner = THIS_MODULE;
ret = cdev_add(my_cdev,dev_num,1);
if (ret < 0){
printk(KERN_WARNING "Gilc: unable to add cdev to kernel\n");
return ret;
}
sema_init(&virtual_device.sem , 1);
return 0;
}
static int __init my_init(void)
{
if (alloc_chrdev_region(&first, 0, count, MYDEV_NAME) < 0) {
printk(KERN_ERR ME
"failed to allocate character device region\n");
return -1;
}
if (!(my_cdev = cdev_alloc())) {
printk(KERN_ERR ME "cdev_alloc() failed\n");
unregister_chrdev_region(first, count);
return -1;
}
cdev_init(my_cdev, &mycdrv_fops);
if (cdev_add(my_cdev, first, count) < 0) {
printk(KERN_ERR ME "cdev_add() failed\n");
cdev_del(my_cdev);
unregister_chrdev_region(first, count);
return -1;
}
my_sysfs_class = class_create(THIS_MODULE, "my_class");
device_create(my_sysfs_class, NULL, first, NULL, "%s", "mycdrv");
printk(KERN_INFO ME "simple ioctl chrdrv created, major %d\n",
MAJOR(first));
printk(KERN_INFO ME "sizeof(uint32_t) is %d\n", sizeof(uint32_t));
return 0;
}
static int mtk_ext_disp_mgr_probe(struct platform_device *pdev)
{
int ret = 0;
struct class_device *class_dev = NULL;
printk("[EXTD]%s\n", __func__);
/* Allocate device number for hdmi driver */
ret = alloc_chrdev_region(&hdmi_devno, 0, 1, HDMI_DEVNAME);
if (ret)
{
printk("[EXTD]alloc_chrdev_region fail\n");
return -1;
}
/* For character driver register to system, device number binded to file operations */
hdmi_cdev = cdev_alloc();
hdmi_cdev->owner = THIS_MODULE;
hdmi_cdev->ops = &external_display_fops;
ret = cdev_add(hdmi_cdev, hdmi_devno, 1);
/* For device number binded to device name(hdmitx), one class is corresponeded to one node */
hdmi_class = class_create(THIS_MODULE, HDMI_DEVNAME);
/* mknod /dev/hdmitx */
class_dev = (struct class_device *)device_create(hdmi_class, NULL, hdmi_devno, NULL, HDMI_DEVNAME);
printk("[EXTD][%s] out\n", __func__);
return 0;
}
//------------------------------------------------------------------------------
static inline int SYSRAM_RegCharDrv(void)
{
LOG_MSG("E");
if(alloc_chrdev_region(&Sysram.DevNo, 0, 1,SYSRAM_DEV_NAME) )
{
LOG_ERR("allocate device no failed");
return -EAGAIN;
}
//allocate driver
Sysram.pCharDrv = cdev_alloc();
if(Sysram.pCharDrv == NULL)
{
unregister_chrdev_region(Sysram.DevNo, 1);
LOG_ERR("allocate mem for kobject failed");
return -ENOMEM;
}
//Attatch file operation.
cdev_init(Sysram.pCharDrv, &SysramFileOper);
Sysram.pCharDrv->owner = THIS_MODULE;
//Add to system
if(cdev_add(Sysram.pCharDrv, Sysram.DevNo, 1))
{
LOG_ERR("Attatch file operation failed");
unregister_chrdev_region(Sysram.DevNo, 1);
return -EAGAIN;
}
LOG_MSG("X");
return 0;
}
int init__ (void)
{
buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (buffer==NULL)
{
printk (KERN_INFO "Create buffer error\n");
return -ENOMEM;
}
register_chrdev (866, "myeth", &chardev_fops);
first_node = MKDEV(866, 50);
register_chrdev_region (first_node, 1, "myeth");
my_cdev = cdev_alloc();
cdev_init(my_cdev, &chardev_fops);
cdev_add (my_cdev,first_node, 1);
printk (KERN_INFO "loaded: %s\n", NIITM_NAME);
//eth *****
myeth_dev = alloc_netdev(sizeof(struct myeth_dev), NDEV_NAME,
NET_NAME_UNKNOWN, &mynet_init);
if(register_netdev(myeth_dev)) {
printk(KERN_ERR "netdev register failed\n");
return -ENODEV;
}
printk(KERN_INFO "netdev registered success\n");
return 0;
}
static int hdmi_probe(struct platform_device *pdev)
{
int ret = 0;
struct class_device *class_dev = NULL;
printk("[hdmi]%s\n", __func__);
/* Allocate device number for hdmi driver */
ret = alloc_chrdev_region(&hdmi_devno, 0, 1, HDMI_DEVNAME);
if(ret)
{
printk("[hdmi]alloc_chrdev_region fail\n");
return -1;
}
/* For character driver register to system, device number binded to file operations */
hdmi_cdev = cdev_alloc();
hdmi_cdev->owner = THIS_MODULE;
hdmi_cdev->ops = &hdmi_fops;
ret = cdev_add(hdmi_cdev, hdmi_devno, 1);
/* For device number binded to device name(hdmitx), one class is corresponeded to one node */
hdmi_class = class_create(THIS_MODULE, HDMI_DEVNAME);
/* mknod /dev/hdmitx */
class_dev = (struct class_device *)device_create(hdmi_class, NULL, hdmi_devno, NULL, HDMI_DEVNAME);
printk("[hdmi][%s] current=0x%08x\n", __func__, (unsigned int)current);
init_waitqueue_head(&hdmi_update_wq);
hdmi_update_task = kthread_create(hdmi_update_kthread, NULL, "hdmi_update_kthread");
wake_up_process(hdmi_update_task);
return 0;
}
static int driver_entry(void){
// register our device with the system; a 2 step process
//step 1: use dynamic allocation to assign our device
// a major number-- alloc_chrdev_region(dev_t*,uint fminor,uint count,char* name)
ret = alloc_chrdev_region(&dev_num,0,1,DEVICE_NAME);
if(ret<0) {
// at times kernel functions return negatives,there is an error
printk(KERN_ALERT "sunilcode: failed to allocate a amajor number");
return ret;
}
major_number = MAJOR(dev_num); //extracts the major number and store in our variable (MACRO)
printk(KERN_INFO "sunilcode: major number is %d",major_number);
printk(KERN_INFO "\tuse \"mknod /dev/%s c %d 0\" for device file",DEVICE_NAME,major_number);
//step (2)
mcdev = cdev_alloc(); // create our cdev structure, initialized our cdev
mcdev->ops = &fops; // struct file_operation
mcdev->owner = THIS_MODULE;
//now that we create cdev,we have to add it to the kernel
//int cdev_add(struct cdev* dev,dev_t num,unsigned intcount)
ret = cdev_add(mcdev,dev_num,1);
if(ret<0) {
//always check errors
printk(KERN_ALERT "sunilcode: unable to add cdev to kernel");
return ret;
}
// initialize our semaphore
sema_init(&virtual_device.sem,1); //initial value of one
return 0;
}
static int __init my_init (void)
{
first = MKDEV (my_major, my_minor);
if (register_chrdev_region (first, count, MYDEV_NAME) < 0) {
printk (KERN_ERR "failed to register character device region\n");
return -1;
}
if (!(my_cdev = cdev_alloc ())) {
printk (KERN_ERR "cdev_alloc() failed\n");
unregister_chrdev_region (first, count);
return -1;
}
cdev_init (my_cdev, &mycdrv_fops);
kbuf = kmalloc (KBUF_SIZE, GFP_KERNEL);
if (cdev_add (my_cdev, first, count) < 0) {
printk (KERN_ERR "cdev_add() failed\n");
cdev_del (my_cdev);
unregister_chrdev_region (first, count);
kfree (kbuf);
return -1;
}
printk (KERN_INFO "\nSucceeded in registering character device %s\n",
MYDEV_NAME);
return 0;
}
static int __init template_init(void)
{
printk( "\t registering %s\n", TEMPLATE);
if (alloc_chrdev_region(&template_dev_number, 0, 1, TEMPLATE)<0)
return -EIO;
driver_object = cdev_alloc();
if (driver_object==NULL)
goto free_device_number;
driver_object->owner = THIS_MODULE;
driver_object->ops = &fops;
if(cdev_add(driver_object, template_dev_number, 1))
goto free_cdev;
template_class = class_create(THIS_MODULE, TEMPLATE);
if(IS_ERR(template_class))
goto free_cdev;
template_dev=device_create(template_class, NULL, template_dev_number, NULL, "%s", TEMPLATE);
if(IS_ERR(template_dev)){
pr_err("hello: device create failed\n");
goto free_class;
}
printk( "\t registering %s complete\n", TEMPLATE);
return 0;
free_class:
class_destroy(template_class);
free_cdev:
kobject_put(&driver_object->kobj);
free_device_number:
unregister_chrdev_region(template_dev_number, 1);
return -EIO;
}
int __init g2d_module_init(void)
{
int ret, err;
alloc_chrdev_region(&devid, 0, 1, "g2d_chrdev");
g2d_cdev = cdev_alloc();
cdev_init(g2d_cdev, &g2d_fops);
g2d_cdev->owner = THIS_MODULE;
err = cdev_add(g2d_cdev, devid, 1);
if (err)
{
ERR("I was assigned major number %d.\n", MAJOR(devid));
return -1;
}
g2d_class = class_create(THIS_MODULE, "g2d_class");
if (IS_ERR(g2d_class))
{
ERR("create class error\n");
return -1;
}
device_create(g2d_class, NULL, devid, NULL, "g2d");
ret = platform_device_register(&g2d_device);
if (ret == 0)
{
ret = platform_driver_register(&g2d_driver);
}
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&g2d_early_suspend_handler);
#endif
INFO("Module initialized.major:%d\n", MAJOR(devid));
return ret;
}
static int __init my_init (void)
{
if (alloc_chrdev_region (&first, 0, count, MYDEV_NAME) < 0) {
printk (KERN_ERR "failed to allocate character device region\n");
return -1;
}
if (!(my_cdev = cdev_alloc ())) {
printk (KERN_ERR "cdev_alloc() failed\n");
unregister_chrdev_region (first, count);
return -1;
}
cdev_init (my_cdev, &mycdrv_fops);
kbuf = kmalloc (KBUF_SIZE, GFP_KERNEL);
if (cdev_add (my_cdev, first, count) < 0) {
printk (KERN_ERR "cdev_add() failed\n");
cdev_del (my_cdev);
unregister_chrdev_region (first, count);
kfree (kbuf);
return -1;
}
foo_class = class_create (THIS_MODULE, "my_class");
device_create (foo_class, NULL, first, "%s", "mycdrv");
printk (KERN_INFO "\nSucceeded in registering character device %s\n",
MYDEV_NAME);
printk (KERN_INFO "Major number = %d, Minor number = %d\n", MAJOR (first),
MINOR (first));
return 0;
}
static int __init bootkey_init(void)
{
printk(KERN_ALERT "BOOT_KEY interrupt driver loaded\n");
//Make device number
devno = MKDEV(BOOTKEYK_MAJOR, BOOTKEY_MINOR);
//Request GPIO
int err = 0;
err = gpio_request(BOOTKEY_GPIO, "BOOT_KEY");
if(err < 0)
{
printk(KERN_ALERT "ERROR requesting GPIO: %d\n", err);
goto err_exit;
}
//Set GPIO direction (in or out)
err = gpio_direction_input(BOOTKEY_GPIO);
if(err < 0)
{
printk(KERN_ALERT "ERROR changing GPIO direction: %d\n", err);
goto err_freegpio;
}
//Register device
err = register_chrdev_region(devno, 1, "BOOT_KEY");
if(err < 0)
{
printk(KERN_ALERT "ERROR register cdev: %d\n", err);
goto err_freegpio;
}
//Cdev init
cdevStruct = cdev_alloc();
cdev_init(cdevStruct, &bootkey_fops);
//Add Cdev
err = cdev_add(cdevStruct, devno, 1);
if(err < 0)
{
printk(KERN_ALERT "ERROR adding cdev: %d\n", err);
goto err_unregister_chardev;
}
//Succes
printk(KERN_ALERT "BOOT_KEY interrupt driver loaded successfully\n");
return 0;
//Goto erros
err_unregister_chardev:
unregister_chrdev_region(devno, 1);
err_freegpio:
gpio_free(BOOTKEY_GPIO);
err_exit:
return err;
}
static int init_func(void)
{
dev_t first_node = MKDEV(major,minor);
printk(KERN_INFO "init module ! ! ! \n");
if(register_chrdev_region(first_node,1,"kbuf")<0)
{
unregister_chrdev_region(first_node, 1);
printk(KERN_INFO "ERROR register_chrdev_region ! ! ! \n");
return -EINTR;
}
my_cdev = cdev_alloc();
cdev_init(my_cdev,&chardev_fops);
if(cdev_add(my_cdev,first_node,1)<0)
{
unregister_chrdev_region(first_node, 1);
printk(KERN_INFO "ERROR cdev_add ! ! ! \n");
return -EINTR;
}
init_mynet();
return 0;
}
static int __init disp_module_init(void)
{
int ret, err;
__inf("disp_module_init\n");
alloc_chrdev_region(&devid, 0, 1, "disp");
my_cdev = cdev_alloc();
cdev_init(my_cdev, &disp_fops);
my_cdev->owner = THIS_MODULE;
err = cdev_add(my_cdev, devid, 1);
if (err) {
__wrn("cdev_add fail\n");
return -1;
}
disp_class = class_create(THIS_MODULE, "disp");
if (IS_ERR(disp_class)) {
__wrn("class_create fail\n");
return -1;
}
device_create(disp_class, NULL, devid, NULL, "disp");
ret = platform_device_register(&disp_device);
if (ret == 0)
ret = platform_driver_register(&disp_driver);
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&backlight_early_suspend_handler);
#endif
return ret;
}
/**__init函数**/
static int __init dev_init(void)
{
int result;
result = alloc_chrdev_region(&led_num,0,1,"ledtest");//动态申请设备号
if(result<0){
printk(KERN_WARNING "led:can't get major");
return result;//返回错误值
}
/*字符设备的注册*/
my_led=cdev_alloc();//分配空间给my_cdev
cdev_init(my_led,&myled_fops);//初始化已分配到的结构
my_led->ops=&myled_fops;//指定file operations
my_led->owner=THIS_MODULE;//指定模块拥有者
if(cdev_add(my_led,led_num,1))//将cdev添加入内核
printk(KERN_NOTICE"Someting wrong when adding cdev\n");
else
printk("Success adding cdev\n");
led_init();//初始化led，包括内存映射，io初始化
/*用于在/dev创建设备节点*/
led_class = class_create(THIS_MODULE,"ledtest");//创建设备类
device_create(led_class,NULL,led_num,NULL,"ledtest");//创建设备节点
return 0;
}
int __init hdmi_module_init(void)
{
int ret = 0, err;
__inf("hdmi_module_init\n");
alloc_chrdev_region(&devid, 0, 1, "hdmi");
my_cdev = cdev_alloc();
cdev_init(my_cdev, &hdmi_fops);
my_cdev->owner = THIS_MODULE;
err = cdev_add(my_cdev, devid, 1);
if (err)
{
__wrn("cdev_add fail.\n");
return -1;
}
hdmi_class = class_create(THIS_MODULE, "hdmi");
if (IS_ERR(hdmi_class))
{
__wrn("class_create fail\n");
return -1;
}
ret |= hdmi_i2c_add_driver();
ret = platform_device_register(&hdmi_device);
if (ret == 0)
{
ret = platform_driver_register(&hdmi_driver);
}
return ret;
}
//----------------------------------------------------------------------------
static int ResMgr_RegCharDev(void)
{
MINT32 Ret = 0;
//
LOG_MSG("\r\n");
//
ResMgr.DevNo = 0;
Ret = alloc_chrdev_region(&(ResMgr.DevNo), RES_MGR_DEV_NO_MINOR, RES_MGR_DEV_NUM, RES_MGR_DEV_NAME);
if(Ret < 0)
{
LOG_ERR("alloc_chrdev_region fail:Ret(%ld)\r\n", Ret);
return Ret;
}
//Allocate memory for driver
ResMgr.pCharDrv = cdev_alloc();
if(ResMgr.pCharDrv == NULL)
{
unregister_chrdev_region(ResMgr.DevNo, RES_MGR_DEV_NUM);
LOG_ERR("Allocate mem for kobject failed\r\n");
return -ENOMEM;
}
//Attatch file operation.
cdev_init(ResMgr.pCharDrv, &ResMgr_FileOper);
ResMgr.pCharDrv->owner = THIS_MODULE;
//Add to system
if(cdev_add(ResMgr.pCharDrv, ResMgr.DevNo, RES_MGR_DEV_MINOR_NUM))
{
LOG_ERR("Attatch file operation failed\r\n");
unregister_chrdev_region(ResMgr.DevNo, RES_MGR_DEV_NUM);
return -EAGAIN;
}
//
LOG_MSG("OK\r\n");
return Ret;
}
static int mtkfb_vsync_probe(struct platform_device *pdev)
{
struct class_device;
struct class_device *class_dev = NULL;
printk("\n=== MTKFB_VSYNC probe ===\n");
if (alloc_chrdev_region(&mtkfb_vsync_devno, 0, 1, MTKFB_VSYNC_DEVNAME))
{
VSYNC_ERR("can't get device major number...\n");
return -EFAULT;
}
printk("get device major number (%d)\n", mtkfb_vsync_devno);
mtkfb_vsync_cdev = cdev_alloc();
mtkfb_vsync_cdev->owner = THIS_MODULE;
mtkfb_vsync_cdev->ops = &mtkfb_vsync_fops;
cdev_add(mtkfb_vsync_cdev, mtkfb_vsync_devno, 1);
mtkfb_vsync_class = class_create(THIS_MODULE, MTKFB_VSYNC_DEVNAME);
class_dev = (struct class_device *)device_create(mtkfb_vsync_class, NULL, mtkfb_vsync_devno, NULL, MTKFB_VSYNC_DEVNAME);
VSYNC_INF("probe is done\n");
return 0;
}
/* Call after load of module.
*/
static int __init init_function(void) {
int err;
/*** Register device number ***/
err = alloc_chrdev_region(&mDevice, 0, 1, "SympleDriver");
if(err) goto fail_reg;
printk(KERN_INFO "SympleDriver registered %u, %u\n", MAJOR(mDevice), MINOR(mDevice));
/*** Register char device ***/
mCdev = cdev_alloc();
mCdev->owner = THIS_MODULE;
mCdev->ops = &mFops;
err = cdev_add(mCdev, mDevice,1);
if(err) goto fail_cdev_add;
/*** Create device ***/
mClass = class_create(THIS_MODULE, "SampleClass");
device_create(mClass, NULL, mDevice, NULL, "SympleDriver");
return 0;
// Failes to register device
fail_cdev_add:
printk(KERN_ALERT "Couldn't add the character device\n");
unregister_chrdev_region(mDevice, 1);
fail_reg:
printk(KERN_ALERT "Couldn't register or allocate the device number\n");
return err;
} // init_function
