Chinaunix首页 | 论坛 | 博客

Ghazar的ChinaUnix博客

首页　| 　博文目录　| 　关于我

Ghazar

  • 博客访问： 183169
  • 博文数量： 80
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 83
  • 用 户 组： 普通用户
  • 注册时间： 2016-03-23 13:37
文章分类

全部博文（80）

文章存档

2016年（80）

我的朋友
最近访客
推荐博文
相关博文
Linux TTY设备驱动

分类： LINUX

2016-03-23 13:45:20

原文地址：Linux TTY设备驱动 作者：星闪夜空

 首先需要说明的是，这篇文章是我根据lanlovehua的博客http://blog.chinaunix.net/uid-21273878-id-1828727.html与《LDD3》中的TTY驱动程序这章整理而成的。

一、tty设备的数据流通图


tty设备有三层：tty核心、tty线路规程、tty驱动。我们写驱动只负责最底层的tty驱动，线路规程的设置也是在底层的tty驱动，tty核心是封装好的。

用户空间主要是通过设备文件同tty核心交互，而tty核心根据用户空间的操作再选择跟tty线路规程或者tty驱动交互，例：设置硬件的ioctl指令就直接交给tty驱动处理，read和write操作交给tty线路规程处理。

二、TTY驱动怎么没有read函数

主要是因为输入设备和输出设备不一样。由于这样的原因，tty驱动层和tty的线路规程层都有一个缓冲区（因为tty核心只能从tty线路规程层的缓冲区读取数据，所以tty线路规程层也需要一个缓冲区）。

三、驱动程序tiny_tty.c

点击(此处)折叠或打开

  1. /*
  2.  * Tiny TTY driver
  3.  *
  4.  * Copyright (C) 2002-2004 Greg Kroah-Hartman (greg@kroah.com)
  5.  *
  6.  *    This program is free software; you can redistribute it and/or modify
  7.  *    it under the terms of the GNU General Public License as published by
  8.  *    the Free Software Foundation, version 2 of the License.
  9.  *
  10.  * This driver shows how to create a minimal tty driver. It does not rely on
  11.  * any backing hardware, but creates a timer that emulates data being received
  12.  * from some kind of hardware.
  13.  */

  15. #include <linux/kernel.h>
  16. #include <linux/errno.h>
  17. #include <linux/init.h>
  18. #include <linux/module.h>
  19. #include <linux/slab.h>
  20. #include <linux/sched.h>
  21. #include <linux/wait.h>
  22. #include <linux/tty.h>
  23. #include <linux/tty_driver.h>
  24. #include <linux/tty_flip.h>
  25. #include <linux/serial.h>
  26. #include <asm/uaccess.h>


  29. #define DRIVER_VERSION "v2.0"
  30. #define DRIVER_AUTHOR "Greg Kroah-Hartman "
  31. #define DRIVER_DESC "Tiny TTY driver"

  33. /* Module information */
  34. MODULE_AUTHOR( DRIVER_AUTHOR );
  35. MODULE_DESCRIPTION( DRIVER_DESC );
  36. MODULE_LICENSE("GPL");

  38. #define TTY_FLIPBUF_SIZE 512

  40. #define DELAY_TIME        HZ * 2    /* 2 seconds per character */
  41. #define TINY_DATA_CHARACTER    't'

  43. #define TINY_TTY_MAJOR        240    /* experimental range */
  44. #define TINY_TTY_MINORS        4    /* only have 4 devices */

  46. struct tiny_serial {
  47.     struct tty_struct    *tty;        /* pointer to the tty for this device */
  48.     int            open_count;    /* number of times this port has been opened */
  49.     struct semaphore    sem;        /* locks this structure */
  50.     struct timer_list    *timer;

  52.     /* for tiocmget and tiocmset functions */
  53.     int            msr;        /* MSR shadow */
  54.     int            mcr;        /* MCR shadow */

  56.     /* for ioctl fun */
  57.     struct serial_struct    serial;
  58.     wait_queue_head_t    wait;
  59.     struct async_icount    icount;
  60. };

  62. static struct tiny_serial *tiny_table[TINY_TTY_MINORS];    /* initially all NULL */


  65. static void tiny_timer(unsigned long timer_data)
  66. {
  67.     struct tiny_serial *tiny = (struct tiny_serial *)timer_data;
  68.     struct tty_struct *tty;
  69.     int i;
  70.     char data[1] = {TINY_DATA_CHARACTER};
  71.     int data_size = 1;

  73.     if (!tiny)
  74.         return;

  76.     tty = tiny->tty;

  78.     /* send the data to the tty layer for users to read. This doesn't
  79.      * actually push the data through unless tty->low_latency is set */
  80.     for (i = 0; i < data_size; ++i) {
  81.         if (tty->count >= TTY_FLIPBUF_SIZE)
  82.             tty_flip_buffer_push(tty);
  83.         tty_insert_flip_char(tty, data[i], TTY_NORMAL);
  84.     }
  85.     tty_flip_buffer_push(tty);

  87.     /* resubmit the timer again */
  88.     tiny->timer->expires = jiffies + DELAY_TIME;
  89.     add_timer(tiny->timer);
  90. }

  92. static int tiny_open(struct tty_struct *tty, struct file *file)
  93. {
  94.     struct tiny_serial *tiny;
  95.     struct timer_list *timer;
  96.     int index;

  98.     /* initialize the pointer in case something fails */
  99.     tty->driver_data = NULL;

  101.     /* get the serial object associated with this tty pointer */
  102.     index = tty->index;
  103.     tiny = tiny_table[index];
  104.     if (tiny == NULL) {
  105.         /* first time accessing this device, let's create it */
  106.         tiny = kmalloc(sizeof(*tiny), GFP_KERNEL);
  107.         if (!tiny)
  108.             return -ENOMEM;

  110.         //init_MUTEX(&tiny->sem);
  111.                 sema_init(&tiny->sem, 1);
  112.         tiny->open_count = 0;
  113.         tiny->timer = NULL;

  115.         tiny_table[index] = tiny;
  116.     }

  118.     down(&tiny->sem);

  120.     /* save our structure within the tty structure */
  121.     tty->driver_data = tiny;
  122.     tiny->tty = tty;

  124.     ++tiny->open_count;
  125.     if (tiny->open_count == 1) {
  126.         /* this is the first time this port is opened */
  127.         /* do any hardware initialization needed here */

  129.         /* create our timer and submit it */
  130.         if (!tiny->timer) {
  131.             timer = kmalloc(sizeof(*timer), GFP_KERNEL);
  132.             if (!timer) {
  133.                 up(&tiny->sem);
  134.                 return -ENOMEM;
  135.             }
  136.             tiny->timer = timer;
  137.         }
  138.         tiny->timer->data = (unsigned long )tiny;
  139.         tiny->timer->function = tiny_timer;
  140.                 init_timer(tiny->timer);
  141.         tiny->timer->expires = jiffies + DELAY_TIME;
  142.         add_timer(tiny->timer);
  143.     }

  145.     up(&tiny->sem);
  146.     return 0;
  147. }

  149. static void do_close(struct tiny_serial *tiny)
  150. {

  152.     down(&tiny->sem);

  154.     if (!tiny->open_count) {
  155.         /* port was never opened */
  156.         goto exit;
  157.     }

  159.     --tiny->open_count;
  160.     if (tiny->open_count <= 0) {
  161.         /* The port is being closed by the last user. */
  162.         /* Do any hardware specific stuff here */

  164.         /* shut down our timer */
  165.         del_timer(tiny->timer);
  166.     }
  167. exit:
  168.     up(&tiny->sem);
  169. }

  171. static void tiny_close(struct tty_struct *tty, struct file *file)
  172. {
  173.     struct tiny_serial *tiny = tty->driver_data;

  175.     if (tiny)
  176.         do_close(tiny);
  177. }    

  179. static int tiny_write(struct tty_struct *tty,
  180.          const unsigned char *buffer, int count)
  181. {
  182.     struct tiny_serial *tiny = tty->driver_data;
  183.     int i;
  184.     int retval = -EINVAL;
  185.   
  186.         printk("Enter tiny_write\n");

  188.     if (!tiny)
  189.         return -ENODEV;

  191.     down(&tiny->sem);

  193.     if (!tiny->open_count)
  194.         /* port was not opened */
  195.         goto exit;

  197.     /* fake sending the data out a hardware port by
  198.      * writing it to the kernel debug log.
  199.      */
  200.     printk(KERN_DEBUG "%s - ", __FUNCTION__);
  201.     for (i = 0; i < count; ++i)
  202.         printk("%02x ", buffer[i]);
  203.     printk("\n");
  204.      
  205.         //up(&tiny->sem);
  206.         //return count;
  207.         
  208. exit:
  209.     up(&tiny->sem);
  210.     return retval;
  211. }

  213. static int tiny_write_room(struct tty_struct *tty)
  214. {
  215.     struct tiny_serial *tiny = tty->driver_data;
  216.     int room = -EINVAL;

  218.     if (!tiny)
  219.         return -ENODEV;

  221.     down(&tiny->sem);
  222.     
  223.     if (!tiny->open_count) {
  224.         /* port was not opened */
  225.         goto exit;
  226.     }

  228.     /* calculate how much room is left in the device */
  229.     room = 255;

  231. exit:
  232.     up(&tiny->sem);
  233.     return room;
  234. }

  236. #define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))

  238. static void tiny_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
  239. {
  240.     unsigned int cflag;

  242.     cflag = tty->termios->c_cflag;

  244.     /* check that they really want us to change something */
  245.     if (old_termios) {
  246.         if ((cflag == old_termios->c_cflag) &&
  247.          (RELEVANT_IFLAG(tty->termios->c_iflag) ==
  248.          RELEVANT_IFLAG(old_termios->c_iflag))) {
  249.             printk(KERN_DEBUG " - nothing to change...\n");
  250.             return;
  251.         }
  252.     }

  254.     /* get the byte size */
  255.     switch (cflag & CSIZE) {
  256.         case CS5:
  257.             printk(KERN_DEBUG " - data bits = 5\n");
  258.             break;
  259.         case CS6:
  260.             printk(KERN_DEBUG " - data bits = 6\n");
  261.             break;
  262.         case CS7:
  263.             printk(KERN_DEBUG " - data bits = 7\n");
  264.             break;
  265.         default:
  266.         case CS8:
  267.             printk(KERN_DEBUG " - data bits = 8\n");
  268.             break;
  269.     }
  270.     
  271.     /* determine the parity */
  272.     if (cflag & PARENB)
  273.         if (cflag & PARODD)
  274.             printk(KERN_DEBUG " - parity = odd\n");
  275.         else
  276.             printk(KERN_DEBUG " - parity = even\n");
  277.     else
  278.         printk(KERN_DEBUG " - parity = none\n");

  280.     /* figure out the stop bits requested */
  281.     if (cflag & CSTOPB)
  282.         printk(KERN_DEBUG " - stop bits = 2\n");
  283.     else
  284.         printk(KERN_DEBUG " - stop bits = 1\n");

  286.     /* figure out the hardware flow control settings */
  287.     if (cflag & CRTSCTS)
  288.         printk(KERN_DEBUG " - RTS/CTS is enabled\n");
  289.     else
  290.         printk(KERN_DEBUG " - RTS/CTS is disabled\n");
  291.     
  292.     /* determine software flow control */
  293.     /* if we are implementing XON/XOFF, set the start and
  294.      * stop character in the device */
  295.     if (I_IXOFF(tty) || I_IXON(tty)) {
  296.         unsigned char stop_char = STOP_CHAR(tty);
  297.         unsigned char start_char = START_CHAR(tty);

  299.         /* if we are implementing INBOUND XON/XOFF */
  300.         if (I_IXOFF(tty))
  301.             printk(KERN_DEBUG " - INBOUND XON/XOFF is enabled, "
  302.                 "XON = %2x, XOFF = %2x", start_char, stop_char);
  303.         else
  304.             printk(KERN_DEBUG" - INBOUND XON/XOFF is disabled");

  306.         /* if we are implementing OUTBOUND XON/XOFF */
  307.         if (I_IXON(tty))
  308.             printk(KERN_DEBUG" - OUTBOUND XON/XOFF is enabled, "
  309.                 "XON = %2x, XOFF = %2x", start_char, stop_char);
  310.         else
  311.             printk(KERN_DEBUG" - OUTBOUND XON/XOFF is disabled");
  312.     }

  314.     /* get the baud rate wanted */
  315.     printk(KERN_DEBUG " - baud rate = %d", tty_get_baud_rate(tty));
  316. }

  318. static struct tty_operations serial_ops = {
  319.     .open = tiny_open,
  320.     .close = tiny_close,
  321.     .write = tiny_write,
  322.     .write_room = tiny_write_room,
  323.     .set_termios = tiny_set_termios,
  324. };

  326. static struct tty_driver *tiny_tty_driver;

  328. static int __init tiny_init(void)
  329. {
  330.     int retval;

  332.     /* allocate the tty driver */
  333.     tiny_tty_driver = alloc_tty_driver(TINY_TTY_MINORS);
  334.     if (!tiny_tty_driver)
  335.         return -ENOMEM;

  337.     /* initialize the tty driver */
  338.     tiny_tty_driver->owner = THIS_MODULE;
  339.     tiny_tty_driver->driver_name = "tiny_tty";
  340.     tiny_tty_driver->name = "ttty";
  341.     tiny_tty_driver->major = TINY_TTY_MAJOR,
  342.     tiny_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
  343.     tiny_tty_driver->subtype = SERIAL_TYPE_NORMAL,
  344.     tiny_tty_driver->flags = TTY_DRIVER_REAL_RAW,
  345.     tiny_tty_driver->init_termios = tty_std_termios;
  346.     tiny_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  347.     tty_set_operations(tiny_tty_driver, &serial_ops);

  349.     /* register the tty driver */
  350.     retval = tty_register_driver(tiny_tty_driver);
  351.     if (retval) {
  352.         printk(KERN_ERR "failed to register tiny tty driver");
  353.         put_tty_driver(tiny_tty_driver);
  354.         return retval;
  355.     }

  357.     printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);

  359.     return retval;
  360. }

  362. static void __exit tiny_exit(void)
  363. {
  364.     struct tiny_serial *tiny;
  365.     int i;

  367.         for(i = 0; i < TINY_TTY_MINORS; ++i)
  368.             tty_unregister_device(tiny_tty_driver, i);
  369.     tty_unregister_driver(tiny_tty_driver);

  371.     /* shut down all of the timers and free the memory */
  372.     for (i = 0; i < TINY_TTY_MINORS; ++i) {
  373.         tiny = tiny_table[i];
  374.         if (tiny) {
  375.             /* close the port */
  376.             while (tiny->open_count)
  377.                 do_close(tiny);

  379.             /* shut down our timer and free the memory */
  380.             del_timer(tiny->timer);
  381.             kfree(tiny->timer);
  382.             kfree(tiny);
  383.             tiny_table[i] = NULL;
  384.         }
  385.     }
  386. }

  388. module_init(tiny_init);
  389. module_exit(tiny_exit);



四、测试程序

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <termios.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>

  9. #define max_buffer_size 100 /*recv buffer size*/


  12. int open_serial(int k)
  13. {
  14.     char pathname[20] = {0};
  15.     int ret;

  17.     sprintf(pathname, "/dev/ttty%d", k);
  18.     ret = open(pathname, O_RDWR|O_NOCTTY);
  19.     if(ret == -1)
  20.     {
  21.         perror("open error");
  22.         exit(-1);
  23.     }
  24.     else
  25.         printf("Open %s success\n", pathname);

  27.     return ret;
  28. }

  30. int main()
  31. {
  32.     int fd;
  33.     ssize_t n;
  34.     char recv[max_buffer_size] = {0};
  35.     struct termios opt;

  37.     fd = open_serial(0); /*open device 0*/

  39.     tcgetattr(fd, &opt);
  40.     cfmakeraw(&opt);
  41.     tcsetattr(fd, TCSANOW, &opt);


  44.     printf("ready for receiving data...\n");
  45.     n = read(fd, recv, sizeof(recv));
  46.     if(n == -1)
  47.     {
  48.         perror("read error");
  49.         exit(-1);
  50.     }
  51.     
  52.     printf("The data received is %s", recv);
  53.     if(close(fd) == -1)
  54.         perror("close error");
  55.     
  56.     return 0;
  57. }

五、测试结果

用户测试信息：


dmesg信息：


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

上一篇：linux tty驱动架构分析

下一篇：嵌入式Linux内核I2C子系统详解

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

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

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

16024965号-6