Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1548 connectés 

  FORUM HardWare.fr
  Linux et OS Alternatifs
  Hardware

  driver tiny serial de LDD

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

driver tiny serial de LDD

n°1059913
sebchr
Posté le 12-07-2008 à 19:59:11  profilanswer
 

Bonjour,
 
j'essaie d'utiliser le driver tiny_serial donné par Linux device driver.
Il compile et se charge mais quand je fais cat > /dev/mydriver  
j'obtiens l'erreur : Erreur d'écriture.: Erreur d'entrée/sortie
 
Est ce que quelqu'un saurait trouver l'erreur dans le driver :
 

Code :
  1. /*
  2. * Tiny Serial 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 serial 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/slab.h>
  19. #include <linux/tty.h>
  20. #include <linux/tty_flip.h>
  21. #include <linux/serial.h>
  22. #include <linux/serial_core.h>
  23. #include <linux/module.h>
  26. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
  27. #define DRIVER_DESC "Tiny serial driver"
  29. /* Module information */
  30. MODULE_AUTHOR( DRIVER_AUTHOR );
  31. MODULE_DESCRIPTION( DRIVER_DESC );
  32. MODULE_LICENSE("GPL" );
  34. #define DELAY_TIME  HZ * 2 /* 2 seconds per character */
  35. #define TINY_DATA_CHARACTER 't'
  37. #define TINY_SERIAL_MAJOR 240 /* experimental range */
  38. #define TINY_SERIAL_MINORS 1 /* only have one minor */
  39. #define UART_NR   1 /* only use one port */
  41. #define TINY_SERIAL_NAME "ttytiny"
  43. #define MY_NAME   TINY_SERIAL_NAME
  45. static struct timer_list *timer;
  47. static void tiny_stop_tx(struct uart_port *port)
  48. {
  49. }
  51. static void tiny_stop_rx(struct uart_port *port)
  52. {
  53. }
  55. static void tiny_enable_ms(struct uart_port *port)
  56. {
  57. }
  59. static void tiny_tx_chars(struct uart_port *port)
  60. {
  61.   struct circ_buf *xmit = &port->info->xmit;
  62.   int count;
  64.   printk(KERN_INFO "tx_char\n" );
  65.   if (port->x_char) {
  66.     pr_debug("wrote %2x", port->x_char);
  67.     port->icount.tx++;
  68.     port->x_char = 0;
  69.     return;
  70.   }
  71.   if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
  72.     tiny_stop_tx(port);
  73.     return;
  74.   }
  76.   count = port->fifosize >> 1;
  77.   do {
  78.     pr_debug("wrote %2x", xmit->buf[xmit->tail]);
  79.     xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
  80.     port->icount.tx++;
  81.     if (uart_circ_empty(xmit))
  82.       break;
  83.   } while (--count > 0);
  85.   if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
  86.     uart_write_wakeup(port);
  88.   if (uart_circ_empty(xmit))
  89.     tiny_stop_tx(port);
  90. }
  92. static void tiny_start_tx(struct uart_port *port)
  93. {
  94. }
  96. static void tiny_timer(unsigned long data)
  97. {
  98.   struct uart_port *port;
  99.   struct tty_struct *tty;
  102.   port = (struct uart_port *)data;
  103.   if (!port)
  104.     return;
  105.   if (!port->info)
  106.     return;
  107.   tty = port->info->tty;
  108.   if (!tty)
  109.     return;
  111.   /* add one character to the tty port */
  112.   /* this doesn't actually push the data through unless tty->low_latency is set */
  113.   tty_insert_flip_char(tty, TINY_DATA_CHARACTER, 0);
  115.   tty_flip_buffer_push(tty);
  117.   /* resubmit the timer again */
  118.   timer->expires = jiffies + DELAY_TIME;
  119.   add_timer(timer);
  121.   /* see if we have any data to transmit */
  122.   tiny_tx_chars(port);
  123. }
  125. static unsigned int tiny_tx_empty(struct uart_port *port)
  126. {
  127.   return 0;
  128. }
  130. static unsigned int tiny_get_mctrl(struct uart_port *port)
  131. {
  132.   return 0;
  133. }
  135. static void tiny_set_mctrl(struct uart_port *port, unsigned int mctrl)
  136. {
  137. }
  139. static void tiny_break_ctl(struct uart_port *port, int break_state)
  140. {
  141. }
  143. static void tiny_set_termios(struct uart_port *port,
  144.                              struct ktermios *new, struct ktermios *old)
  145. {
  146.   int baud, quot, cflag = new->c_cflag;
  147.   /* get the byte size */
  148.   switch (cflag & CSIZE) {
  149.     case CS5:
  150.       printk(KERN_DEBUG " - data bits = 5\n" );
  151.       break;
  152.     case CS6:
  153.       printk(KERN_DEBUG " - data bits = 6\n" );
  154.       break;
  155.     case CS7:
  156.       printk(KERN_DEBUG " - data bits = 7\n" );
  157.       break;
  158.     default: // CS8
  159.       printk(KERN_DEBUG " - data bits = 8\n" );
  160.       break;
  161.   }
  163.   /* determine the parity */
  164.   if (cflag & PARENB)
  165.     if (cflag & PARODD)
  166.       pr_debug(" - parity = odd\n" );
  167.     else
  168.       pr_debug(" - parity = even\n" );
  169.   else
  170.     pr_debug(" - parity = none\n" );
  172.   /* figure out the stop bits requested */
  173.   if (cflag & CSTOPB)
  174.     pr_debug(" - stop bits = 2\n" );
  175.   else
  176.     pr_debug(" - stop bits = 1\n" );
  178.   /* figure out the flow control settings */
  179.   if (cflag & CRTSCTS)
  180.     pr_debug(" - RTS/CTS is enabled\n" );
  181.   else
  182.     pr_debug(" - RTS/CTS is disabled\n" );
  184.   /* Set baud rate */
  185.   //baud = uart_get_baud_rate(port, new, old, 0, port->uartclk/16);
  186.   //quot = uart_get_divisor(port, baud);
  188.   //UART_PUT_DIV_LO(port, (quot & 0xff));
  189.   //UART_PUT_DIV_HI(port, ((quot & 0xf00) >> 8));
  190. }
  192. static int tiny_startup(struct uart_port *port)
  193. {
  194.   /* this is the first time this port is opened */
  195.   /* do any hardware initialization needed here */
  197.   /* create our timer and submit it */
  198.   if (!timer) {
  199.     timer = kmalloc(sizeof(*timer), GFP_KERNEL);
  200.     if (!timer)
  201.       return -ENOMEM;
  202.   }
  203.   timer->data = (unsigned long)port;
  204.   timer->expires = jiffies + DELAY_TIME;
  205.   timer->function = tiny_timer;
  206.   add_timer(timer);
  207.   return 0;
  208. }
  210. static void tiny_shutdown(struct uart_port *port)
  211. {
  212.   /* The port is being closed by the last user. */
  213.   /* Do any hardware specific stuff here */
  215.   /* shut down our timer */
  216.   del_timer(timer);
  217. }
  219. static const char *tiny_type(struct uart_port *port)
  220. {
  221.   return "tinytty";
  222. }
  224. static void tiny_release_port(struct uart_port *port)
  225. {
  227. }
  229. static int tiny_request_port(struct uart_port *port)
  230. {
  231.   return 0;
  232. }
  234. static void tiny_config_port(struct uart_port *port, int flags)
  235. {
  236. }
  238. static int tiny_verify_port(struct uart_port *port, struct serial_struct *ser)
  239. {
  240.   return 0;
  241. }
  243. static struct uart_ops tiny_ops = {
  244.   .tx_empty = tiny_tx_empty,
  245.   .set_mctrl = tiny_set_mctrl,
  246.   .get_mctrl = tiny_get_mctrl,
  247.   .stop_tx = tiny_stop_tx,
  248.   .start_tx = tiny_start_tx,
  249.   .stop_rx = tiny_stop_rx,
  250.   .enable_ms = tiny_enable_ms,
  251.   .break_ctl = tiny_break_ctl,
  252.   .startup = tiny_startup,
  253.   .shutdown = tiny_shutdown,
  254.   .set_termios = tiny_set_termios,
  255.   .type  = tiny_type,
  256.   .release_port = tiny_release_port,
  257.   .request_port = tiny_request_port,
  258.   .config_port = tiny_config_port,
  259.   .verify_port = tiny_verify_port,
  260. };
  262. static struct uart_port tiny_port = {
  263.   .ops  = &tiny_ops,
  264. };
  266. static struct uart_driver tiny_reg = {
  267.   .owner  = THIS_MODULE,
  268.   .driver_name = TINY_SERIAL_NAME,
  269.   .dev_name = TINY_SERIAL_NAME,
  270.   .major  = TINY_SERIAL_MAJOR,
  271.   .minor  = TINY_SERIAL_MINORS,
  272.   .nr  = UART_NR,
  273. };
  275. static int __init tiny_init(void)
  276. {
  277.   int result;
  279.   printk(KERN_INFO "Tiny serial driver loaded\n" );
  281.   result = uart_register_driver(&tiny_reg);
  282.   if (result)
  283.     return result;
  285.   result = uart_add_one_port(&tiny_reg, &tiny_port);
  286.   if (result)
  287.     uart_unregister_driver(&tiny_reg);
  289.   return result;
  290. }
  292. module_init(tiny_init);

mood
Publicité
Posté le 12-07-2008 à 19:59:11  profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Linux et OS Alternatifs
  Hardware

  driver tiny serial de LDD

 

Sujets relatifs
Driver linuxplus de son sur mon pc meme avec nouveau driver
Intégrer un driver à une distrib linux.[Nvidia] Kernel 2.6.25 et driver Nvidia 169.12-173.08
Nouveau, un pilote libre pour les cartes graphiques NVIDIAProblème de compilation pour un driver carte wifi "config.h manquant"
Driver ATI Rage 128MO AMC VER 2.0 sortir tv videoDriver ATI Rage 128MO AMC VER 2.0
Debian Etch 2.6.18 & Marvell Yukon driver skydriver ATI
Plus de sujets relatifs à : driver tiny serial de LDD

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.086 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR