1 #include <linux/module.h>
2 #include <linux/fs.h>
3 #include <linux/cdev.h>
4 #include <linux/platform_device.h>
5 #include <linux/of_device.h>
6 #include <linux/of_platform.h>
7
8 static dev_t linuxmag_number;
9 static struct cdev *driver_object;
0 static struct class *linmag_class;
1 static struct platform_device_id pdi;
2
3 static struct file_operations fops;
4 static DECLARE_COMPLETION( dev_obj_is_free );
5
6 static int linuxmag_probe_device( struct platform_device *pdev )
7 {
8     struct device *dev = &pdev->dev;
9     struct device_node *nodeptr = dev->of_node;
0     const void *prop_value;
1     int size, i;
2     u16 value;
3     const __be16 *beptr;
4
5     pr_info("linuxmag_probe_device( %p, %p )\n", pdev, nodeptr);
6     pr_info("pd->id: %d\n", pdev->id );
7     pr_info("pd->name: %s\n", pdev->name );
8     nodeptr = of_find_node_by_path("gpio");
9
0     prop_value = of_get_property( nodeptr, "string-property", &size );
1     printk("linuxmag_probe_device(): prop_value=%p, size: %d\n",
2         prop_value, size);
3     if (prop_value)
4         printk("prop_value: %s\n", (char *)prop_value);
5
6     prop_value = of_get_property( nodeptr, "bytes", &size );
7     printk("linuxmag_probe_device(): prop_value=%p, size: %d\n",
8         prop_value, size);
9     printk("byte array: [ ");
0     for ( i=0; i<size; i++ ) {
1         printk("%x ", *(char *)(prop_value+i));
2     }
3     printk(" ]\n");
4
5     beptr = of_get_property( nodeptr, "u16", &size );
6     printk("linuxmag_probe_device(): prop_value=%p, size: %d\n",
7         prop_value, size);
8     if (prop_value) {
9         value = be16_to_cpup( beptr );
0         printk("value: %x\n", value);
1     }
2     return 0;
3 }
4
5 static int linuxmag_remove_device( struct platform_device *pdev )
6 {
7     return 0;
8 }
9
0 static void linuxmag_release( struct device *dev )
1 {
2     complete( &dev_obj_is_free );
3 }
4
5 struct platform_device linuxmag = {
6     .name  = "linmag", /* driver identification */
7     .id    = 0,
8     .dev = {
9         .release = linuxmag_release,
0     }
1 };
2
3 static struct of_device_id linmag_match[] = {
4     { .compatible = "linmag" },
5     {}
6 };
7
8 static struct platform_driver mydriver = {
9     .probe = linuxmag_probe_device,
0     .remove = linuxmag_remove_device,
1     .driver = {
2         .name = "linmag_driver",
3         .of_match_table = linmag_match,
4     }
5 };
6 MODULE_DEVICE_TABLE( of, linmag_match );
7
8 static int __init mod_init(void)
9 {
0     pr_info("mod_init()\n");
1     strcpy( pdi.name, "linmag" );
2     mydriver.id_table = &pdi;
3     if (platform_driver_register(&mydriver)!=0) {
4         pr_err("driver_register failed\n");
5         return -EIO;
6     }
7     if (alloc_chrdev_region(&linuxmag_number,0,1,"linmag")<0)
8         return -EIO;
9     driver_object = cdev_alloc();
0     if (driver_object==NULL)
1         goto free_device_number;
2     driver_object->owner = THIS_MODULE;
3     driver_object->ops = &fops;
4     if (cdev_add(driver_object,linuxmag_number,1))
5         goto free_cdev;
6     linmag_class = class_create( THIS_MODULE, "linuxmag" );
7     if (IS_ERR(linmag_class)) {
8         printk("linuxmag: no udev support.\n");
9         goto free_cdev;
0     }
1     linuxmag.dev.devt = linuxmag_number;
2     platform_device_register( &linuxmag );
3     return 0;
4
5 free_cdev:
6     kobject_put( &driver_object->kobj );
7 free_device_number:
8     unregister_chrdev_region( linuxmag_number, 3 );
9     return -EIO;
0 }
1
2 static void __exit mod_exit(void)
3 {
4     pr_info("mod_exit()\n");
5     device_release_driver( &linuxmag.dev );
6     platform_device_unregister( &linuxmag );
7     class_destroy( linmag_class );
8     cdev_del( driver_object );
9     unregister_chrdev_region( linuxmag_number, 1 );
0     platform_driver_unregister(&mydriver);
1     wait_for_completion( &dev_obj_is_free );
2 }
3
4 module_init( mod_init );
5 module_exit( mod_exit );
6 MODULE_LICENSE("GPL");