platform总线globalfifo驱动

功能是使用内存的4k单元，实现读，写，偏移，清除。

 /*********************************************************************************
  *      Copyright:  (C) 2014 zhouguangfeng<zhouguangfeng91@gmail.com>
  + plat_globalfifo.c
 /*********************************************************************************
  *      Copyright:  (C) 2014 zhouguangfeng<zhouguangfeng91@gmail.com>
  *                  All rights reserved.
  *
  *       Filename:  plat_globalfifo.c
  *    Description:  This file is a commom platform driver
  *
  *        Version:  1.0.0(08/19/2014)
  *         Author:  zhouguangfeng <zhouguangfeng91@gmail.com>
  *      ChangeLog:  1, Release initial version on "08/19/2014 02:31:17 PM"
  *
  ********************************************************************************/
 #include <linux/fs.h>//struct file_operations
 #include <linux/types.h>//special type definition,like dev_t off_t defined by typedef
 #include <linux/init.h> // init and exit
 #include <linux/module.h>//support module load and unload
 #include <linux/errno.h>
 #include <linux/mm.h> //memory mannage ,include kmalloc.kfree and so on
 #include <linux/sched.h>
 #include <linux/cdev.h> //char device structure definition
 #include <asm/io.h>     //io operation function ,like ioremap,iowrite
 #include <asm/system.h>
 #include <asm/ioctl.h>   //for ioctl command
 #include <asm/uaccess.h>
 #include <linux/platform_device.h> //platform support
 #include <linux/kernel.h>
 #include <linux/device.h> //class_create() and device_create()
 
 #define GLOBALFIFO_SIZE       0x1000  /* 4K */
 #define NAME                  "globalfifo"
 #define KELNEL_OLD             0   /* decsion ioctl() */
 
 #ifndef GLOBALFIFO_MAJOR
 #define GLOBALFIFO_MAJOR       0
 #endif
 
 //#define GLOBALFIFO_CLEAR      0x17
 //#define MEM_CLEAR           __IO (GLOBALFIFO_CLEAR, 0x20)
 #define MEM_CLEAR              0x20
 
 static int globalfifo_major = GLOBALFIFO_MAJOR;
 static int globalfifo_minor = ;
 
 /*  ============================ Platform Device part =============================== */
 
 struct globalfifo_dev
 {
     struct cdev cdev;
     unsigned int current_len;
     unsigned char mem[GLOBALFIFO_SIZE];
     struct class   *class;
 
     //struct semaphrore sem;
    // wait_queue_t r_wait;
     //wait_queue_t r_wait;
 } globalfifo_dev;
 
 static void plat_release(struct device * dev)
 {
     return;
 }
 
 static struct platform_device globalfifo_device = {
         .name = "globalfifo",
         .id   = ,
         .dev  = {
             .release = plat_release,
         },
 };
 
 /*  ===================== globalfifo driver part ===========================*/
 
 int globalfifo_open(struct inode *inode, struct file *filp)
 {
     struct globalfifo_dev *dev;
 
     dev = container_of(inode->i_cdev, struct globalfifo_dev, cdev);
     filp->private_data = dev;
 
     return ;
 }
 
 int globalfifo_release(struct inode *inode, struct file *filp)
 {
     return ;
 }
 
 #if KELNEL_OLD
 static ssize_t globalfifo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
 {
     struct globalfifo_dev *dev = filp->private_data;
     switch(cmd)
     {
          case  MEM_CLEAR:
             memset(dev->mem, , GLOBALFIFO_SIZE);
             printk(KERN_INFO "globalfifo is set to zero\n");
             break;
 
          default:
             return -EINVAL;
     }
 
     return ;
 }
 #endif
 
 static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t size, loff_t *opps)
 {
     unsigned long p = *opps;
     unsigned int count = size;
     int ret = ;
 
     struct globalfifo_dev *dev = filp->private_data;
 
     if(p >= GLOBALFIFO_SIZE)
     {
          return count ? -ENXIO : ;
     }
     if(count > GLOBALFIFO_SIZE - p)
     {
          count = GLOBALFIFO_SIZE - p;
     }
 
     if(copy_to_user(buf, (void *)((dev->mem)+p), count))
     {
          ret = -EFAULT;
     }
     else
     {
         *opps += count;
          ret = count;
          printk(KERN_INFO"read %u bytes(s) from %lu\n", count, p);
     }
 
     return ret;
 }
 
 static ssize_t globalfifo_write(struct file *filp, const char __user *buf, size_t size, loff_t *opps)
 {
     unsigned long  p = *opps;
     unsigned int count = size;
     int ret;
 
     struct globalfifo_dev *dev = filp->private_data;
 
     if(p >= GLOBALFIFO_SIZE)
     {
         return count ? -ENXIO : ;
     }
 
     if(count > GLOBALFIFO_SIZE - p)
     {
         count = GLOBALFIFO_SIZE - p;
     }
 
     if(copy_from_user(((dev->mem)+p), buf, count))
     {
         ret = -EFAULT;
     }
     else
     {
        *opps =+ count;
         ret = count;
         printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
     }
     return ret;
 }
 
 #if 1
 static loff_t globalfifo_llseek(struct file *filp, loff_t offset, int orig)
 {
     loff_t ret = ;
 
     switch(orig)
     {
         case :
             if(offset < )
             {
                 ret = -EINVAL;
                 break;
             }
 
             if((unsigned int )offset > GLOBALFIFO_SIZE)
             {
                 ret = -EINVAL;
                 break;
             }
             filp->f_pos = (unsigned int)offset;
             ret = filp->f_pos;
             break;
 
         case :
             if((filp->f_pos + offset) > GLOBALFIFO_SIZE)
             { ret = -EINVAL;
                break;
             }
 
             if((filp->f_pos + offset) < )
             {
                ret = -EINVAL;
                break;
             }
             filp->f_pos += offset;
             ret = filp->f_pos;
             break;
 
         default:
             ret = -EINVAL;
                break;
     }
 
     return ret;
 }
 #endif
 
 static const struct file_operations globalfifo_fops ={
     .owner = THIS_MODULE,
     .read = globalfifo_read,
     .write = globalfifo_write,
     .open = globalfifo_open,
     .release = globalfifo_release,
     .llseek = globalfifo_llseek,
 
 #if KELNEL_OLD
     .unlocked_ioctl = globalfifo_ioctl,
 #endif
 };
 
 static int  globalfifo_probe(struct platform_device *dev)
 {
     int ret;
     dev_t devno;
 
     /* Alloc for device major */
     if(globalfifo_major)
     {
         devno = MKDEV(globalfifo_major, globalfifo_minor);
         ret = register_chrdev_region(devno, , NAME);
     }
     else
     {
         ret = alloc_chrdev_region(&devno, , , NAME);
         globalfifo_major= MAJOR(devno);
     }
 
     /*  Alloc for device major failure */
     if (ret < )
     {
         printk("%s driver can't get major %d\n", NAME, globalfifo_major);
         return ret;
     }
 
 /* Initialize globalfifo structure and register cdev*/
     memset(&globalfifo_dev, , sizeof(struct globalfifo_dev));
     cdev_init (&(globalfifo_dev.cdev), &globalfifo_fops);
     globalfifo_dev.cdev.owner  = THIS_MODULE;
 
     ret = cdev_add (&(globalfifo_dev.cdev), devno , );
     if (ret)
     {
          printk (KERN_NOTICE "error %d add %s device", ret, NAME);
          goto fail_cdev_add;
     }
 
     globalfifo_dev.class = class_create(THIS_MODULE, NAME);
     if(IS_ERR(globalfifo_dev.class))
     {
         printk("%s driver create class failure\n", NAME);
         goto fail_class;
     }
 
     device_create(globalfifo_dev.class, NULL, devno, NULL, NAME);
 
     return ;
 fail_class:
     cdev_del(&(globalfifo_dev.cdev));
 
 fail_cdev_add:
     unregister_chrdev_region(devno, );
     printk("failure to insmod!\n");
     return ret;
 }
 
 static int  globalfifo_remove(struct platform_device *pdev)
 {
     dev_t devno = MKDEV(globalfifo_major, globalfifo_minor);
 
     cdev_del(&globalfifo_dev.cdev);
     device_destroy(globalfifo_dev.class, devno);
     class_destroy(globalfifo_dev.class);
 
     unregister_chrdev_region(devno, );
     printk("s3c %s driver removed\n", NAME);
 
     return ;
 }
 
 static struct platform_driver globalfifo_driver = {
     .probe  = globalfifo_probe,
     .remove = globalfifo_remove,
     .driver = {
         .name = "globalfifo",
         .owner = THIS_MODULE,
     },
 };
 
 static int __init globalfifo_init(void)
 {
     int       ret = ;
 
     ret = platform_device_register(&globalfifo_device);
     if(ret)
     {
         printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__, __LINE__ ,ret);
         goto fail_reg_plat_dev;
     }
     printk("Register S3C %s Platform Device successfully.\n", NAME);
 
     ret = platform_driver_register(&globalfifo_driver);
     if(ret)
     {
         printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__, __LINE__, ret);
         goto fail_reg_plat_drv;
     }
     printk("Register S3C %s Platform Driver successfully.\n", NAME);
 
     return ;
 
 fail_reg_plat_drv:
     platform_device_unregister(&globalfifo_device);
 fail_reg_plat_dev:
     return ret;
 }
 
 static void  __exit globalfifo_exit(void)
 {
     printk("%s():%s remove %d platform drvier\n", __FUNCTION__, NAME, __LINE__);
     platform_driver_unregister(&globalfifo_driver);
 
     printk("%s():%s remove %d platform device\n", __FUNCTION__, NAME, __LINE__);
     platform_device_unregister(&globalfifo_device);
 }
 
 module_init(globalfifo_init);
 module_exit(globalfifo_exit);
 MODULE_ALIAS("platform: globalfifo");
 MODULE_LICENSE("GPL");

Makefile：

 #ARCH=x86
 ARCH=arm920t
 #PROJ=fl2440
 PWD=$(shell pwd)
 
 ifneq ("${ARCH}", "x86")
 CROSS_COMPILE ?= /opt/buildroot-2011.11/${ARCH}/usr/bin/arm-linux-
 KERNEL_DIR =  ../../kernel/linux-3.8/
 else
 KERNEL_DIR = /lib/modules/$(shell uname -r)/build
 endif
 
 obj-m += plat_globalfifo.o
 
 all:
     make -C $(KERNEL_DIR) SUBDIRS=$(PWD) modules
     @make clear
 
 clear:
     @rm -f *.o *.cmd *.mod.c
     @rm -rf  *~ core .depend  .tmp_versions Module.symvers modules.order -f
     @rm -f .*ko.*  *ko.*  .*.o.cmd 
 
 clean:
     rm -f *.ko *.o
     rm -f cscope.* tags

测试程序：

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <string.h>
 
 #define MEM_CLEAR              0x20
 #define MAX                    0x1000
 
 int main (int argc, char **argv)
 {
     int fd;
     char buf[MAX] = "hello world";
     char buf2[MAX];
 
     fd = open("/dev/globalfifo", O_RDWR, );
     write(fd, buf, sizeof(buf));
     lseek(fd, , SEEK_SET);
     read(fd, buf2, sizeof(buf2));
     printf("buf=%s, buf2=%s\n", buf, buf2);
 
     close(fd);
     return ;
 } /* ----- End of main() ----- */