Chinaunix首页 | 论坛 | 博客

IT花园

首页　| 　博文目录　| 　关于我

dingzerong

  • 博客访问： 1262571
  • 博文数量： 548
  • 博客积分： 7597
  • 博客等级： 少将
  • 技术积分： 4224
  • 用 户 组： 普通用户
  • 注册时间： 2010-12-15 13:21
个人简介

嵌入式软件工程师&&太极拳

文章分类

全部博文（548）

文章存档

2014年（10）

2013年（76）

2012年（175）

2011年（287）

我的朋友
最近访客
推荐博文
相关博文
AT91SAM9G20驱动程序设计

分类： 嵌入式

2012-05-15 18:19:57


 

点击(此处)折叠或打开

  1. AT91SAM9G20驱动程序设计
  2. 开发环境：Vmware + ubuntu10.04
  3. 硬件平台：AT91SAM9G20
  4. Linux版本：linux2.6.27
  5. 一：led驱动
  6. 说明：因为设计的开发板上没有led灯，便通过PC0来演示，通过示波器来观察引脚端的电平变化。
  7. 1.驱动程序：my_led.c
  8. #include <linux/kernel.h>
  9. #include <linux/init.h>
  10. #include <linux/module.h>
  11. #include <linux/fs.h>
  12. #include <linux/cdev.h>
  13. #include <linux/types.h>
  14. #include <asm/gpio.h>

  16. #define MY_LED_MAJOR    250        //定义主设备号
  17. #define LED_ON         0
  18. #define LED_OFF         1
  19. struct global_dev{
  20.     struct cdev cdev;
  21. };    //定义设备结构体
  22. struct global_dev *global_devp;    //定义一个指向设备结构体的指针
  23. static int my_led_open(struct inode *inode, struct file *filp)
  24. {
  25.     filp->private_data = global_devp;
  26.     return 0;
  27. }
  28. static int my_led_release(struct inode *inode, struct file *file)
  29. {
  30.     return 0;
  31. }
  32. static int my_led_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data)
  33. {    
  34.     switch(cmd)
  35.     {
  36.         case LED_ON:
  37.             at91_set_gpio_value(AT91_PIN_PC0, 0);    //将PC0引脚置低
  38.             break;
  39.         case LED_OFF:
  40.             at91_set_gpio_value(AT91_PIN_PC0, 1);    //将PC1引脚置高
  41.             break;
  42.         default:
  43.             printk("no valid cmd input!\n");
  44.             break;
  45.     }
  46.     return 0;
  47. }
  48. struct file_operations my_led_ctl_ops ={
  49.     .owner = THIS_MODULE,
  50.     .open = my_led_open,
  51.     .release = my_led_release,
  52.     .ioctl = my_led_ioctl,
  53. };
  54. /*初始化设备结构体*/
  55. static void my_led_setup(struct global_dev *dev, int index)
  56. {
  57.     int err;
  58.     int devno = MKDEV(MY_LED_MAJOR, index);
  59.     cdev_init(&dev->cdev, &my_led_ctl_ops);
  60.     dev->cdev.owner = THIS_MODULE;
  61.     dev->cdev.ops = &my_led_ctl_ops;
  62.     err = cdev_add(&dev->cdev, devno, 1);
  63.     if(err)
  64.         printk("add my led setup failed!\n");
  65. }
  66. static int my_led_init(void)
  67. {
  68.     int ret;
  69.     dev_t devno = MKDEV(MY_LED_MAJOR, 0);    //创建设备号
  70.     printk("my first driver--led!\n");
  71.     at91_set_GPIO_periph(AT91_PIN_PC0, 1);
  72.     at91_set_gpio_output(AT91_PIN_PC0, 1);    //对PC0引脚的初始化
  73.     ret = register_chrdev_region(devno, 1, "my_led");    //申请设备号
  74.     if( ret < 0) {
  75.         printk("my_led init_module failed with %d\n", ret);
  76.         return ret;
  77.     }
  78.     else
  79.         printk("my_led init_module success!\n");
  80.     global_devp = kmalloc(sizeof(struct global_dev), GFP_KERNEL);    //申请设备内存
  81.     memset(global_devp, 0, sizeof(struct global_dev));
  82.     my_led_setup(global_devp, 0);
  83.     return ret;
  84. }
  85. static void my_led_cleanup(void)
  86. {
  87.     cdev_del(&global_devp->cdev);    //删除设备
  88.     kfree(global_devp);        //释放内存
  89.     unregister_chrdev_region(MKDEV(MY_LED_MAJOR, 0), 1);    //释放设备号
  90. }
  91. MODULE_LICENSE("MYGPL");
  92. MODULE_AUTHOR("FANY");
  93. module_init(my_led_init);    //注册设备
  94. module_exit(my_led_cleanup);    //卸载设备
  95. 2:如何将驱动驱动程序编译成模块
  96. ①在drivers目录下新建led目录，并在该目录下添加Kconfig，Makefile文件。
  97. Kconfig：
  98. Menu "My driver support"
  99. Config
  100. Trisate "led driver!"
  101. Help
  102. Led driver
  103. Endmenu:
  104. Makefile：
  105. Obj-$(CONFIG_MY_LED)    += my_led.o
  106. ②修改linux/drivers目录下的Kconfig，Makefile文件
  107. Kconfig:
  108. Source "drivers/led/Kconfig"
  109. Makefile:
  110. Obj-y     += my_led/
  111. ③修改体系结构目录arch/arm目录下的Kconfig文件，否则在配置菜单中将无法看到led的配置选项。（如果是在drivers目录下新建一文件夹，并在其中添加驱动程序，必须相应的体系结构目录下添加配置选项）。
  112. Kconfig:
  113. Source "driver/led/Kconfig"
  114. 3.测试程序：my_led_test.c
  115. #include <stdio.h>
  116. #include <string.h>
  117. #include <stdlib.h>
  118. #include <fcntl.h>
  119. #include <unistd.h>

  121. #define DEVICE_NAME "/dev/my_led"
  122. #define LED_ON    0
  123. #define LED_OFF     1

  125. int main(void)
  126. {
  127.     int fd;
  128.     int ret;
  129.     int i;
  130.     printf("my_led_driver test!\n");

  132.     fd = open(DEVICE_NAME, O_RDONLY);
  133.     if(fd == -1)
  134.         printf("open device %s error!\n", DEVICE_NAME);
  135.     for(i = 0; i < 50; i++)
  136.     {
  137.         ioctl(fd, LED_OFF);
  138.         sleep(1);
  139.         ioctl(fd, LED_ON);
  140.         sleep(1);
  141.     }
  142.     ret = close(fd);
  143.     printf("ret = %d\n", ret);
  144.     printf("close my_led_driver!\n");
  145.     return 0;
  146. }

  148. 将测试程序编译成目标平台的可执行文件，并下载到开发板
  149. GCC=/home/zzq/9G20/arm-2007q1/bin/arm-none-linux-gnueabi-gcc #交叉编译器的路径
  150. My_led_test:my_led_test.c
  151.     $(GCC) -o my_led_test my_led_test.c
  152. clean:
  153.     rm -f my_led_test
  154. 学习总结：熟悉驱动程序的架构，如何将驱动程序添加到内核即如何写测试程序。
  155. 二：按键驱动设计
  156. 1.硬件部分：PC4接按键。
  157. 2.驱动程序：
  158. #include <linux/module.h>
  159. #include <linux/cdev.h>
  160. #include <linux/init.h>
  161. #include <linux/fs.h>
  162. #include <linux/interrupt.h>
  163. #include <linux/irq.h>
  164. #include <linux/sched.h>
  165. #include <linux/pm.h>
  166. #include <linux/sysctl.h>
  167. #include <linux/proc_fs.h>
  168. #include <linux/delay.h>
  169. #include <linux/input.h>
  170. #include <linux/gpio_keys.h>

  172. #include <asm/gpio.h>
  173. #include <asm/uaccess.h>
  174. #include <asm/io.h>
  175. #include <asm/irq.h>
  176. #include <mach/gpio.h>

  178. #define BUTTON_MAJOR    245
  179. #define DEVICE_NAME     "/dev/button"

  181. static volatile int ev_press = 0;
  182. static struct cdev button_cdev;

  184. static void button_do_tasklet(unsigned long n);
  185. DECLARE_TASKLET(button_tasklet, button_do_tasklet, 0);//定义tasklet并与处理函数关联起来

  187. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);//静态的初始化一个等待队列

  189. struct button_irq_desc {
  190.     int irq;
  191.     int irq_type;
  192.     int pin;
  193.     int number;
  194.     char *name;
  195. };

  197. static struct button_irq_desc button_irq[1] = { {AT91_PIN_PB22, AT91_AIC_SRCTYPE_LOW, AT91_PIN_PB22, 0, "KEY0"} };

  199. static int key_values[1]={0};
  200. //中断处理底半部
  201. static void button_do_tasklet(unsigned long n)
  202. {
  203.     wake_up_interruptible(&button_waitq);    //唤醒队列
  204.     printk("button press!\n");    
  205. }
  206. //中断处理顶半部
  207. static irqreturn_t button_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  208. {
  209.     int up;
  210.      static int press_down;
  211.     up = gpio_get_value(button_irq[0].pin);
  212.     printk("irq\n");
  213.     /*按键消抖*/
  214.     if(up)    press_down = 1;    //当按键没有按下,置标志位为1.
  215.     if(!up && (press_down == 1)) {            
  216.         press_down = 0; //当按键按下,置标志位为0.    
  217.         ev_press = 1;
  218.         at91_set_gpio_value(button_irq[0].pin, 1);                        
  219.         key_values[button_irq[0].number] = !up;
  220. tasklet_schedule(&button_tasklet);    
  221.     }
  222.     return IRQ_RETVAL(IRQ_HANDLED);
  223. }
  224. static int button_open(struct inode *inode, struct file *filp)
  225. {
  226.     return 0;
  227. }
  228. static int button_release(struct inode *inode, struct file *filp)
  229. {
  230.     return 0;
  231. }
  232. static int button_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
  233. {
  234.     int ret;
  235.     if(!ev_press) {    //当按键没有按下时，读进程挂起，知道按键按下。    
  236.         wait_event_interruptible(button_waitq, ev_press);
  237.     }
  238.     ev_press = 0;
  239.     ret = copy_to_user(buff, (const void *)key_values, min(sizeof(key_values), count));
  240.     memset((void __user *)key_values, 0, sizeof(key_values));
  241.     return ret ? -EFAULT:min(sizeof(key_values), count);
  242. }

  244. static struct file_operations button_fops = {
  245.     .owner = THIS_MODULE,
  246.     .open = button_open,
  247.     .release = button_release,
  248.     .read = button_read,
  249. };

  251. static int irq_init(void)
  252. {
  253.     int err;
  254.     at91_set_gpio_input(button_irq[0].pin, 1);
  255.     at91_set_deglitch(button_irq[0].pin, 1);//将PC0设置为中断功能
  256.     set_irq_type(button_irq[0].irq, button_irq[0].irq_type);//设置中断类型
  257.     at91_set_gpio_value(button_irq[0].pin, 1);

  259.     err = request_irq( button_irq[0].irq, button_interrupt, IRQF_DISABLED, \
  260.             button_irq[0].name, (void *)&button_irq[0]);//申请中断
  261.     if ( err ) {
  262.         disable_irq(button_irq[0].irq);
  263.         free_irq(button_irq[0].irq, (void *)&button_irq[0]);
  264.         return -EBUSY;
  265.     }    

  267.     return 0;
  268. }

  270. static int __init button_init(void)
  271. {
  272.     int ret, err;
  273.     ret = register_chrdev_region(MKDEV(BUTTON_MAJOR, 0), 1, DEVICE_NAME);
  274.     if(ret < 0) {
  275.         printk("button init failed with %d\n", ret);
  276.         return ret;
  277.     }
  278.     cdev_init(&button_cdev, &button_fops);
  279.     button_cdev.owner = THIS_MODULE;
  280.     button_cdev.ops = &button_fops;
  281.     err = cdev_add(&button_cdev, MKDEV(BUTTON_MAJOR, 0), 1);
  282.     if( err<0 ) {
  283.         printk("key add failed\n");
  284.         return err;
  285.     }
  286.     irq_init();
  287.     printk("key driver add success!\n");
  288.     return 0;
  289. }
  290. static void __exit button_exit(void)
  291. {
  292.     cdev_del(&button_cdev);
  293.     unregister_chrdev_region(MKDEV(BUTTON_MAJOR, 0), 1);
  294.     disable_irq(button_irq[0].irq);
  295.     free_irq(button_irq[0].irq, (void *)&button_irq[0]);
  296.     printk("unregister key driver!\n");
  297. }
  298. module_init(button_init);
  299. module_exit(button_exit);
  300. MODULE_AUTHOR("fany");
  301. MODULE_DESCRIPTION("Atmel9g20 key Driver");
  302. MODULE_LICENSE("GPL");
  303. 3.测试程序：
  304. #include <stdio.h>
  305. #include <string.h>
  306. #include <stdlib.h>
  307. #include <fcntl.h>
  308. #include <unistd.h>
  309. #include <errno.h>

  311. #define DEVICE_NAME "/dev/button"

  313. int main(void)
  314. {
  315.     int fd,i;
  316.     int ret;
  317.     int key_value[1];
  318.     printf("key test!\n");
  319.     fd = open(DEVICE_NAME, O_RDWR);
  320.     if(fd < 0)
  321.         printf("open device %s error!\n", DEVICE_NAME);
  322.     else
  323.         printf("open device success!\n");
  324.     while(1) {
  325.         ret = read(fd, key_value, 1);
  326.         if( !ret ) {
  327.             printf("button not press!\n");
  328.         }
  329.         else
  330.             printf("button press!\n");    
  331.         printf("key_value %d\n", key_value);
  332.     }
  333.     close(fd);
  334.     printf("close key driver!\n");
  335.     return 0;
  336. }
  337. 4.学习总结：
  338. 在linux设备驱动程序中，中断处理程序通常分为两部分：上半部和下半部。上半部处理比较紧急的的硬件操作，比如简单的读取寄存器中的状态并清除中断标志后，进行登记中断的工作。剩下的工作就由下半部来实现。
  339. 对阻塞与非阻塞进程的理解，阻塞：在执行设备操作时，若不能获取设备资源则挂起，直到满足可操作的条件后再进行操作。非阻塞操作：在执行设备操作时，若不能获取设备资源则立即返回。
  340. 三：总线驱动
  341. AT91SAM9G20存储器映射图(截取部分)，片选4接外设，利用总线对外设进行访问。

  343. 但是在linux驱动，不能对物理地址进行操作，可通过内存访问的机制实现对物理地址的访问。将一段物理地址空间映射到虚拟地址空间中，然后对虚拟地址的操作即是对物理地址的操作。

  345. 3.1：总线驱动
  346. #include <linux/module.h>
  347. #include <linux/errno.h>
  348. #include <linux/types.h>
  349. #include <linux/device.h>
  350. #include <linux/fs.h>
  351. #include <linux/platform_device.h>
  352. #include <linux/init.h>
  353. #include <linux/cdev.h>

  355. #include <asm/io.h>
  356. #include <asm/uaccess.h>
  357. #include <mach/gpio.h>
  358. #include <mach/at91sam9_smc.h>
  359. #include <mach/at91sam9260_matrix.h>
  360. #include <mach/at91sam9260.h>
  361. #include <mach/at91_pmc.h>
  362. #include "atmel9g20_liu.h"

  364. struct gr_liu_info {
  365.     void __iomem    *virtbase;
  366.     void __iomem    *regbase;
  367.     struct resource *res;
  368.     u32    flags;
  369. };

  371. static struct gr_liu_info liu_info;
  372. static struct cdev atmel9g20_liu_cdev;

  374. unsigned short liu_read(unsigned addr)
  375. {    
  376.     addr &= ATMEL9G20_LIU_MASK;
  377.     addr = addr << 1;
  378.     addr += (unsigned long)liu_info.regbase;
  379.     printk("read the virtual addr is 0x%x\n", addr);
  380.     return readw(addr) & 0xff;    //读IO内存。
  381. }
  382. EXPORT_SYMBOL(liu_read);

  384. int liu_write(unsigned addr, unsigned val)
  385. {
  386.     addr &= ATMEL9G20_LIU_MASK;
  387.     addr = addr << 1;
  388.     addr += (unsigned long)liu_info.regbase;
  389.     printk("write the virtual addr is 0x%x\n", addr);
  390.     writew(val&0xff, addr);    //写IO内存
  391.     return 0;
  392. }
  393. EXPORT_SYMBOL(liu_write);

  395. static int atmel9g20_liu_open(struct inode *inode, struct file *filp)
  396. {    
  397.     return 0;
  398. }

  400. static int atmel9g20_liu_release(struct inode *inode, struct file *filp)
  401. {
  402.     return 0;
  403. }

  405. static int atmel9g20_liu_ioctl(struct inode *inode, struct file *filp, unsigned cmd, unsigned long arg)
  406. {
  407.     int ret;
  408.     liu_ctlf_t ctlf;
  409.     
  410.     switch (cmd) {
  411.         case LIU_IOCSET:
  412.             ret = copy_from_user(&ctlf, (liu_ctlf_t __user *)arg, sizeof(liu_ctlf_t));
  413.                 if (ret)
  414.                 return ret;
  415.                 printk("input addr is 0x%x,input val is 0x%x\n",ctlf.addr, ctlf.val);
  416.             liu_write(ctlf.addr, ctlf.val);
  417.             return ret;

  419.         case LIU_IOCGET:
  420.             ret = copy_from_user(&ctlf, (liu_ctlf_t __user *)arg, sizeof(liu_ctlf_t));
  421.             if (ret)
  422.                 return ret;
  423.             ctlf.val = liu_read(ctlf.addr);            
  424.             if (copy_to_user((void __user *)arg, &ctlf, sizeof(liu_ctlf_t)))
  425.                 return -EFAULT;
  426.             return ret;
  427.     }
  428.     return -ENOTTY;
  429. }

  431. static const struct file_operations atmel9g20_liu_fops = {
  432.     .owner    =     THIS_MODULE,
  433.     .open        =    atmel9g20_liu_open,
  434.     .ioctl        =    atmel9g20_liu_ioctl,
  435.     .release    =    atmel9g20_liu_release,
  436. };
  437. static int __devinit liu_probe(struct platform_device *pdev)
  438. {
  439.     int ret = 0;    
  440.     if (pdev->num_resources != 1) {
  441.         ret = -ENODEV;
  442.         goto err1;
  443.     }
  444. //IO内存的申请
  445.     liu_info.res = request_mem_region(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1, "9g20-liu");

  447.     if (!liu_info.res) {
  448.         printk("liu: can't get request mem region");
  449.         ret = -ENOMEM;
  450.         goto err1;
  451.     }
  452. //IO内存的映射
  453.     liu_info.regbase = ioremap(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1);
  454.     printk("request virtual addr liu_info.regbase=0x%x\n",(unsigned int)liu_info.regbase);
  455.     if (liu_info.regbase == NULL) {
  456.         printk("liu: can't get ioremap mem\n");
  457.         ret = -ENOMEM;
  458.         goto err2;
  459.     }
  460.     dev_set_drvdata(&pdev->dev, &liu_info);
  461.     printk("LIU probe done!\n");    
  462.     return 0;    
  463. err2:
  464.     release_mem_region(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1);
  465. err1:
  466.     return ret;
  467. }

  469. static int liu_remove(struct platform_device *pdev)
  470. {
  471.     struct gr_liu_info *fi;
  472.     fi = pdev->dev.driver_data;
  473.     iounmap(fi->regbase);//解除映射，
  474.     release_mem_region(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1);//释放内存
  475.     fi->flags = 0x0;
  476.     return 0;
  477. }

  479. static struct platform_driver liu_driver = {
  480.     .probe = liu_probe,
  481.     .remove = liu_remove,
  482.     .driver = {
  483.         .name = "9g20-liu",
  484.         .owner = THIS_MODULE,
  485.     },
  486. };
  487. //设置SMC寄存器
  488. static void cs4_init(void)
  489. {
  490.     at91_sys_write(AT91_MATRIX_EBICSA,at91_sys_read(AT91_MATRIX_EBICSA) | AT91_MATRIX_CS4A_SMC);
  491.     
  492.     /* Configure SMC CS4 */
  493.     at91_sys_write(AT91_SMC_SETUP(4),
  494.          AT91_SMC_NWESETUP_(2) | AT91_SMC_NCS_WRSETUP_(2) |
  495.          AT91_SMC_NRDSETUP_(2) | AT91_SMC_NCS_RDSETUP_(2));
  496.     at91_sys_write(AT91_SMC_PULSE(4),
  497.          AT91_SMC_NWEPULSE_(12) | AT91_SMC_NCS_WRPULSE_(10) |
  498.          AT91_SMC_NRDPULSE_(12) | AT91_SMC_NCS_RDPULSE_(10));
  499.     at91_sys_write(AT91_SMC_CYCLE(4),
  500.          AT91_SMC_NWECYCLE_(16) | AT91_SMC_NRDCYCLE_(16));
  501.     at91_sys_write(AT91_SMC_MODE(4),
  502.          AT91_SMC_READMODE | AT91_SMC_WRITEMODE | AT91_SMC_DBW_16 |
  503.          AT91_SMC_EXNWMODE_DISABLE | AT91_SMC_TDF_(3));

  505.     at91_sys_write(AT91_PMC_PCER, 1 << AT91SAM9260_ID_PIOC);

  507.     /* Enable CS4 */
  508.         at91_set_A_periph(AT91_PIN_PC8, 1);

  510.         printk("*************at91sam9g20ek_ebibus_cs4_init*******\n");    
  511. }

  513. static int __init atmel9g20_liu_init(void)
  514. {
  515.     int ret,err;
  516.     ret = register_chrdev_region(MKDEV(LIU_MAJOR, 0), 1, "/dev/liu");

  518.     if( ret < 0) {
  519.         printk("LIU init_module failed with %d\n", ret);
  520.         return ret;
  521.     }    

  523.     cdev_init(&atmel9g20_liu_cdev, &atmel9g20_liu_fops);
  524.     atmel9g20_liu_cdev.owner = THIS_MODULE;
  525.     atmel9g20_liu_cdev.ops = &atmel9g20_liu_fops;
  526.     err = cdev_add(&atmel9g20_liu_cdev, MKDEV(LIU_MAJOR, 0), 1);
  527.     
  528.     if( err<0 ) {
  529.         printk("liu add failed\n");
  530.         return err;
  531.     }
  532.     cs4_init();    
  533.     return platform_driver_register(&liu_driver);    //注册平台设备。
  534. }
  535. static void __exit atmel9g20_liu_cleanup(void)
  536. {
  537.     printk("atmel 9g20 liu exit\n");

  539.     cdev_del(&atmel9g20_liu_cdev);
  540.     unregister_chrdev_region(MKDEV(LIU_MAJOR, 0), 1);
  541.     platform_driver_unregister(&liu_driver);
  542. }

  544. module_init(atmel9g20_liu_init);
  545. module_exit(atmel9g20_liu_cleanup);
  546. MODULE_AUTHOR("fany");
  547. MODULE_DESCRIPTION("Atmel9g20 liu Driver");
  548. MODULE_LICENSE("GPL");
  549. 并在/arch/arm/mach-at91/board-sam9g20ek.c中初始化
  550. #define GR_LIU_BASE 0x50000000
  551. #define GR_LIU_SIZE 0x1000
  552. static struct resource gr_liu_resource[] = {
  553.     {        
  554.         .start        = GR_LIU_BASE,
  555.         .end        = GR_LIU_BASE + GR_LIU_SIZE - 1,
  556.         .flags        = IORESOURCE_MEM,
  557.     }
  558. };

  560. static struct platform_device grd_liu = {
  561.     .name    = "9g20-liu",
  562.     .id        = -1,
  563.     .dev        = {
  564.                 .platform_data    = NULL,
  565.             },
  566.     .resource    = gr_liu_resource,
  567.     .num_resources    = 1,
  568. };

  570. static void __init at91_add_device_liu(void) {    
  571.     platform_device_register(&grd_liu);
  572.      printk("*************at91_add_device_liu*******\n");
  573. }
  574. static void __init ek_board_init(void)
  575. {
  576. ........
  577. at91_add_device_liu();
  578. }
  579. 3.2:总线驱动测试程序：
  580. #include <sys/types.h>
  581. #include <sys/fcntl.h>
  582. #include <sys/ioctl.h>
  583. #include <stdio.h>
  584. #include <stdlib.h>
  585. #include <string.h>
  586. #include <math.h>

  588. #define DRIVER_LIU_FILE         "/dev/liu"
  589. #define LIU_IOCSET _IOW('i',30,liu_ctlf_t)
  590. #define LIU_IOCGET _IOWR('i',31,liu_ctlf_t)

  592. typedef struct liu_ctlf{
  593.     unsigned addr;
  594.     unsigned val;
  595. }liu_ctlf_t;
  596. //写IO内存
  597. unsigned int LiuWrite(unsigned addr, unsigned data)
  598. {
  599.     int liu_fd;
  600.     liu_ctlf_t ctlf;

  602.     liu_fd = open(DRIVER_LIU_FILE, O_RDWR, 0666);
  603.     if (liu_fd<0)
  604.     {
  605.       printf("open liu file error!\n");
  606.      return -1;
  607.     }
  608.     ctlf.addr = addr;
  609.     ctlf.val = data&0xffff;
  610.     ioctl(liu_fd, LIU_IOCSET, &ctlf);
  611.     close(liu_fd);
  612.     return (0);
  613. }
  614. //读IO内存
  615. unsigned int LiuRead(unsigned addr)
  616. {
  617.     int liu_fd;
  618.     liu_ctlf_t ctlf;

  620.     liu_fd = open(DRIVER_LIU_FILE, O_RDONLY, 0666);
  621.         if (liu_fd<0)
  622.         {
  623.              printf("open liu file error!\n");
  624.          return -1;
  625.         }
  626.     ctlf.addr=addr;
  627.     ctlf.val = 0;
  628.         ioctl(liu_fd,LIU_IOCGET, &ctlf);
  629.     close(liu_fd);
  630.         return ((ctlf.val)&0xffff);
  631. }

  633. int main(int argc, const char * * argv)
  634. {
  635.     unsigned int LiuAddr, value, readBack;
  636.     if (argc < 3) {
  637.         printf("writeFpgaReg addr value\n");
  638.         return -1;
  639.     }
  640.     sscanf(argv[1],"%x", &LiuAddr);
  641.     sscanf(argv[2],"%x", &value);
  642.     LiuWrite(LiuAddr, value);
  643.     readBack = LiuRead(LiuAddr);
  644.     printf("readback: 0x%0x=0x%x\n",LiuAddr, readBack);

  646.     return 0;
  647. }
  648. 输入命令的格式为：./test addr val
  649. 片选4的物理地址为0x50000000，申请一段从0x50000000开始的一段内存空间，其大小为0xffff，并将这段地址空间做映射，在上层对物理地址的操作既是对这一段虚拟地址空间的操作。
  650. 4：信号量
  651. 当多个执行单元，同时并行执行，在获取共享资源时，可能发生冲突，如何利用信号量来保护临界区代码，解决冲突。
  652. #include <linux/module.h>
  653. #include <linux/init.h>
  654. #include <linux/fs.h>
  655. #include <linux/types.h>
  656. #include <linux/errno.h>
  657. #include <linux/mm.h>
  658. #include <linux/slab.h>
  659. #include <linux/kernel.h>
  660. #include <linux/sched.h>
  661. #include <linux/cdev.h>

  663. #include <asm/io.h>
  664. #include <asm/system.h>
  665. #include <asm/uaccess.h>

  667. #define MEMDEV_MAJOR 200

  669. #define MEM_SIZE 100

  671. struct mem_dev {
  672.     struct cdev cdev;
  673.     unsigned char mem[MEM_SIZE];
  674.     struct semaphore sem;    //定义信号量
  675. };

  677. struct mem_dev *mem_devp;

  679. int memdev_open(struct inode *inode, struct file *filp) {
  680.     filp->private_data = mem_devp;
  681.     return 0;
  682. }

  684. int memdev_release(struct inode *inode, struct file *filp) {
  685.     return 0;
  686. }

  688. static ssize_t memdev_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
  689. {
  690.     unsigned long p = *ppos;
  691.     unsigned int count = size;
  692.     int ret = 0;
  693.     
  694.     struct mem_dev *dev = filp->private_data;

  696.     if(p > MEM_SIZE)
  697.         return count;
  698.     if(count > MEM_SIZE - p)
  699.         count = MEM_SIZE - p;
  700.     
  701.     if(down_interruptible(&dev->sem)){    //获取信号量
  702.         return -ERESTARTSYS;
  703.     }

  705.     if(copy_to_user(buf, (void *)(dev->mem + p), count)) {
  706.         return - EFAULT;
  707.     }
  708.     else {
  709.         *ppos += count;
  710.         ret = count;
  711.         printk("read %d bytes from %d\n", count, (unsigned int)p);
  712.     }
  713.     up(&dev->sem);    //释放信号量
  714.     return ret;
  715. }

  717. static ssize_t memdev_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
  718. {
  719.     unsigned long p = *ppos;
  720.     unsigned count = size;
  721.     int ret = 0;

  723.     struct mem_dev *dev = filp->private_data;

  725.     if(p > MEM_SIZE)
  726.         return count;
  727.     if(count > MEM_SIZE - p)
  728.         count = MEM_SIZE - p;

  730.     if(copy_from_user(dev->mem + p, buf, count))
  731.         return -EFAULT;
  732.     else {
  733.         *ppos += count;
  734.         ret = count;
  735.         printk("write %d bytes from %d\n", count, (unsigned int)p);
  736.     }
  737.     
  738.     return ret;
  739. }

  741. static loff_t memdev_llseek(struct file *filp, loff_t offset, int orig)
  742. {
  743.     switch(orig) {
  744.         case SEEK_SET:
  745.             if((offset < 0) || (offset > MEM_SIZE))
  746.                 return -EINVAL;
  747.             filp->f_pos = (unsigned int)offset;
  748.             break;
  749.         case SEEK_CUR:
  750.             if(((filp->f_pos + offset) > MEM_SIZE) || ((filp->f_pos + offset)< 0))
  751.                 return -EINVAL;
  752.             filp->f_pos = filp->f_pos + offset;
  753.             break;
  754.         default:
  755.             return -EINVAL;
  756.             break;
  757.     }
  758.     return filp->f_pos;
  759. }

  761. static const struct file_operations mem_fops = {
  762.     .owner = THIS_MODULE,
  763.     .open = memdev_open,
  764.     .release = memdev_release,
  765.     .read = memdev_read,
  766.     .write = memdev_write,
  767.     .llseek = memdev_llseek,
  768. };

  770. static void memdev_setup_cdev(struct mem_dev *dev, int index)
  771. {
  772.     int err;
  773.     dev_t devno = MKDEV(MEMDEV_MAJOR, index);
  774.     cdev_init(&dev->cdev, &mem_fops);
  775.     dev->cdev.owner = THIS_MODULE;
  776.     dev->cdev.ops = &mem_fops;
  777.     err = cdev_add(&dev->cdev, devno, 1);
  778.     if(err < 0) {
  779.         printk("add memdev failed!\n");
  780.     }
  781. }
  782. static int memdev_init(void)
  783. {
  784.     int ret;
  785.     dev_t devno = MKDEV(MEMDEV_MAJOR, 0);
  786.     ret = register_chrdev_region(devno, 1, "/dev/memdev");
  787.     if (ret < 0)
  788.     {
  789.         printk("register memdev failed\n");
  790.         return ret;
  791.     }

  793.     mem_devp = kmalloc(sizeof(struct mem_dev), GFP_KERNEL);
  794.     if(!mem_devp)
  795.     {
  796.         printk("kmalloc failed!\n");
  797.     }
  798.     memset(mem_devp, 0, sizeof(struct mem_dev));

  800.     memdev_setup_cdev(mem_devp, 0);

  802.     init_MUTEX(&mem_devp->sem);    //初始化信号量
  803.     
  804.     printk("memdev init!\n");
  805.     return 0;
  806. }

  808. static void memdev_exit(void)
  809. {
  810.     cdev_del(&mem_devp->cdev);
  811.     kfree(mem_devp);
  812.     unregister_chrdev_region(MKDEV(MEMDEV_MAJOR, 0), 1);
  813.     printk("memdev exit!\n");
  814. }

  816. MODULE_LICENSE("GPL");
  817. MODULE_DESCRIPTION("MEM DRIVERS");
  818. MODULE_AUTHOR("FANY");

  820. module_init(memdev_init);
  821. module_exit(memdev_exit);


 

阅读(1277) | 评论(0) | 转发(0) |
0

上一篇：copy_from_user() and copy_to_user()

下一篇：ARM9g20电源管理

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6