开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
usb-char.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：19k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

usb-char.c：源码内容
  1. /*
  2.  * (C) Copyright 2000-2001 Extenex Corporation
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  *
  18.  *  usb-char.c
  19.  *
  20.  *  Miscellaneous character device interface for SA1100 USB function
  21.  * driver.
  22.  *
  23.  *  Background:
  24.  *  The SA1100 function driver ported from the Compaq Itsy project
  25.  *  has an interface, usb-eth.c, to feed network packets over the
  26.  *  usb wire and into the Linux TCP/IP stack.
  27.  *
  28.  *  This file replaces that one with a simple character device
  29.  *  interface that allows unstructured "byte pipe" style reads and
  30.  *  writes over the USB bulk endpoints by userspace programs.
  31.  *
  32.  *  A new define, CONFIG_SA1100_USB_NETLINK, has been created that,
  33.  *  when set, (the default) causes the ethernet interface to be used.
  34.  *  When not set, this more pedestrian character interface is linked
  35.  *  in instead.
  36.  *
  37.  *  Please see linux/Documentation/arm/SA1100/SA1100_USB for details.
  38.  *
  39.  *  ward.willats@extenex.com
  40.  *
  41.  *  To do:
  42.  *  - Can't dma into ring buffer directly with pci_map/unmap usb_recv
  43.  *    uses and get bytes out at the same time DMA is going on. Investigate:
  44.  *    a) changing usb_recv to use alloc_consistent() at client request; or
  45.  *    b) non-ring-buffer based data structures. In the meantime, I am using
  46.  *    a bounce buffer. Simple, but wasteful.
  47.  */
  49. #include <linux/module.h>
  50. #include <linux/config.h>
  51. #include <linux/miscdevice.h>
  52. #include <linux/slab.h>
  53. #include <linux/init.h>
  54. #include <linux/cache.h>
  55. #include <linux/poll.h>
  56. #include <linux/circ_buf.h>
  57. #include <linux/timer.h>
  59. #include <asm/io.h>
  60. #include <asm/semaphore.h>
  61. #include <asm/proc/page.h>
  62. #include <asm/mach-types.h>
  64. #include "usb-char.h"
  65. #include "pxa_usb.h"
  69. //////////////////////////////////////////////////////////////////////////////
  70. // Driver  Options
  71. //////////////////////////////////////////////////////////////////////////////
  73. #define VERSION  "0.4"
  76. #define VERBOSITY 1
  78. #if VERBOSITY
  79. # define PRINTK(x, a...) printk (x, ## a)
  80. #else
  81. # define PRINTK(x, a...) /**/
  82. #endif
  84. //////////////////////////////////////////////////////////////////////////////
  85. // Globals - Macros - Enums - Structures
  86. //////////////////////////////////////////////////////////////////////////////
  87. #ifndef MIN
  88. #define MIN( a, b ) ((a)<(b)?(a):(b))
  89. #endif
  91. typedef int bool; enum { false = 0, true = 1 };
  93. static const char pszMe[] = "usbchr: ";
  95. static wait_queue_head_t wq_read;
  96. static wait_queue_head_t wq_write;
  97. static wait_queue_head_t wq_poll;
  99. /* Serialze multiple writers onto the transmit hardware
  100. .. since we sleep the writer during transmit to stay in
  101. .. sync. (Multiple writers don't make much sense, but..) */
  102. static DECLARE_MUTEX( xmit_sem );
  104. // size of usb DATA0/1 packets. 64 is standard maximum
  105. // for bulk transport, though most hosts seem to be able
  106. // to handle larger.
  107. #define TX_PACKET_SIZE 64
  108. #define RX_PACKET_SIZE 64
  109. #define RBUF_SIZE  (4*PAGE_SIZE)
  111. static struct wcirc_buf {
  112.   char *buf;
  113.   int in;
  114.   int out;
  115. } rx_ring = { NULL, 0, 0 };
  117. static struct {
  118.  unsigned long  cnt_rx_complete;
  119.  unsigned long  cnt_rx_errors;
  120.  unsigned long  bytes_rx;
  121.  unsigned long  cnt_tx_timeouts;
  122.  unsigned long  cnt_tx_errors;
  123.  unsigned long  bytes_tx;
  124. } charstats;
  127. static char * tx_buf = NULL;
  128. static char * packet_buffer = NULL;
  129. static int sending = 0;
  130. static int usb_ref_count = 0;
  131. static int last_tx_result = 0;
  132. static int last_rx_result = 0;
  133. static int last_tx_size = 0;
  134. static struct timer_list tx_timer;
  136. //////////////////////////////////////////////////////////////////////////////
  137. // Prototypes
  138. //////////////////////////////////////////////////////////////////////////////
  139. static char *  what_the_f( int e );
  140. static void  free_txrx_buffers( void );
  141. static void     twiddle_descriptors( void );
  142. static void     free_string_descriptors( void ) ;
  143. static int      usbc_open( struct inode *pInode, struct file *pFile );
  144. static void     rx_done_callback_packet_buffer( int flag, int size );
  146. static void     tx_timeout( unsigned long );
  147. static void     tx_done_callback( int flag, int size );
  149. static ssize_t  usbc_read( struct file *, char *, size_t, loff_t * );
  150. static ssize_t  usbc_write( struct file *, const char *, size_t, loff_t * );
  151. static unsigned int usbc_poll( struct file *pFile, poll_table * pWait );
  152. static int usbc_ioctl( struct inode *pInode, struct file *pFile,
  153.                        unsigned int nCmd, unsigned long argument );
  154. static int      usbc_close( struct inode *pInode, struct file *pFile );
  156. #ifdef CONFIG_SA1100_EXTENEX1
  157. static void     extenex_configured_notify_proc( void );
  158. #endif
  159. //////////////////////////////////////////////////////////////////////////////
  160. // Private Helpers
  161. //////////////////////////////////////////////////////////////////////////////
  163. static char * what_the_f( int e )
  164. {
  165.  char * p;
  166.  switch( e ) {
  167.  case 0:
  168.   p = "noErr";
  169.   break;
  170.  case -ENODEV:
  171.   p = "ENODEV - usb not in config state";
  172.   break;
  173.  case -EBUSY:
  174.   p = "EBUSY - another request on the hardware";
  175.   break;
  176.  case -EAGAIN:
  177.   p = "EAGAIN";
  178.   break;
  179.  case -EINTR:
  180.   p = "EINTR - interruptedn";
  181.   break;
  182.  case -EPIPE:
  183.   p = "EPIPE - zero length xfern";
  184.   break;
  185.  default:
  186.   p = "????";
  187.   break;
  188.  }
  189.  return p;
  190. }
  192. static void free_txrx_buffers( void )
  193. {
  194.  if ( rx_ring.buf != NULL ) {
  195.   kfree( rx_ring.buf );
  196.   rx_ring.buf = NULL;
  197.  }
  198.  if ( packet_buffer != NULL ) {
  199.   kfree( packet_buffer );
  200.   packet_buffer = NULL;
  201.  }
  202.  if ( tx_buf != NULL ) {
  203.   kfree( tx_buf );
  204.   tx_buf = NULL;
  205.  }
  206. }
  208. /* twiddle_descriptors()
  209.  * It is between open() and start(). Setup descriptors.
  210.  */
  211. static void twiddle_descriptors( void )
  212. {
  213.  desc_t * pDesc = pxa_usb_get_descriptor_ptr();
  214.  string_desc_t * pString;
  216.  pDesc->b.ep1.wMaxPacketSize = make_word_c( RX_PACKET_SIZE );
  217.  pDesc->b.ep1.bmAttributes   = USB_EP_BULK;
  218.  pDesc->b.ep2.wMaxPacketSize = make_word_c( TX_PACKET_SIZE );
  219.  pDesc->b.ep2.bmAttributes   = USB_EP_BULK;
  221.          if ( machine_is_extenex1() ) {
  222. #ifdef CONFIG_SA1100_EXTENEX1
  223.   pDesc->dev.idVendor = make_word_c( 0xC9F );
  224.   pDesc->dev.idProduct = 1;
  225.   pDesc->dev.bcdDevice = make_word_c( 0x0001 );
  226.   pDesc->b.cfg.bmAttributes = USB_CONFIG_SELFPOWERED;
  227.   pDesc->b.cfg.MaxPower = 0;
  229.   pString = pxa_usb_kmalloc_string_descriptor( "Extenex" );
  230.   if ( pString ) {
  231.    pxa_usb_set_string_descriptor( 1, pString );
  232.    pDesc->dev.iManufacturer = 1;
  233.   }
  235.   pString = pxa_usb_kmalloc_string_descriptor( "Handheld Theater" );
  236.   if ( pString ) {
  237.    pxa_usb_set_string_descriptor( 2, pString );
  238.    pDesc->dev.iProduct = 2;
  239.   }
  241.   pString = pxa_usb_kmalloc_string_descriptor( "00000000" );
  242.   if ( pString ) {
  243.    pxa_usb_set_string_descriptor( 3, pString );
  244.    pDesc->dev.iSerialNumber = 3;
  245.   }
  247.   pString = pxa_usb_kmalloc_string_descriptor( "HHT Bulk Transfer" );
  248.   if ( pString ) {
  249.    pxa_usb_set_string_descriptor( 4, pString );
  250.    pDesc->b.intf.iInterface = 4;
  251.   }
  252.   pxa_set_configured_callback( extenex_configured_notify_proc );
  253. #endif
  254.  }
  255. }
  257. static void free_string_descriptors( void )
  258. {
  259.  if ( machine_is_extenex1() ) {
  260.   string_desc_t * pString;
  261.   int i;
  262.   for( i = 1 ; i <= 4 ; i++ ) {
  263.    pString = pxa_usb_get_string_descriptor( i );
  264.    if ( pString )
  265. kfree( pString );
  266.   }
  267.  }
  268. }
  270. //////////////////////////////////////////////////////////////////////////////
  271. // ASYNCHRONOUS
  272. //////////////////////////////////////////////////////////////////////////////
  273. static  void kick_start_rx( void )
  274. {
  275.  if ( usb_ref_count ) {
  276.   int total_space  = CIRC_SPACE( rx_ring.in, rx_ring.out, RBUF_SIZE );
  277.   if ( total_space >= RX_PACKET_SIZE ) {
  278.    pxa_usb_recv( packet_buffer,
  279. RX_PACKET_SIZE,
  280. rx_done_callback_packet_buffer
  281.       );
  282.   }
  283.  }
  284. }
  285. /*
  286.  * rx_done_callback_packet_buffer()
  287.  * We have completed a DMA xfer into the temp packet buffer.
  288.  * Move to ring.
  289.  *
  290.  * flag values:
  291.  * on init,  -EAGAIN
  292.  * on reset, -EINTR
  293.  * on RPE, -EIO
  294.  * on short packet -EPIPE
  295.  */
  296. static void
  297. rx_done_callback_packet_buffer( int flag, int size )
  298. {
  299.  charstats.cnt_rx_complete++;
  301.  if ( flag == 0 || flag == -EPIPE ) {
  302.   size_t n;
  304.   charstats.bytes_rx += size;
  306.   n = CIRC_SPACE_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE );
  307.   n = MIN( n, size );
  308.   size -= n;
  310.   memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer, n );
  311.   rx_ring.in = (rx_ring.in + n) & (RBUF_SIZE-1);
  312.   memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer + n, size );
  313.   rx_ring.in = (rx_ring.in + size) & (RBUF_SIZE-1);
  315.   wake_up_interruptible( &wq_read );
  316.   wake_up_interruptible( &wq_poll );
  318.   last_rx_result = 0;
  320.   kick_start_rx();
  322.  } else if ( flag != -EAGAIN ) {
  323.   charstats.cnt_rx_errors++;
  324.   last_rx_result = flag;
  325.   wake_up_interruptible( &wq_read );
  326.   wake_up_interruptible( &wq_poll );
  327.  }
  328.  else  /* init, start a read */
  329.   kick_start_rx();
  330. }
  333. static void tx_timeout( unsigned long unused )
  334. {
  335. printk( "%stx timeoutn", pszMe );
  336. pxa_usb_send_reset();
  337. charstats.cnt_tx_timeouts++;
  338. }
  341. // on init, -EAGAIN
  342. // on reset, -EINTR
  343. // on TPE, -EIO
  344. static void tx_done_callback( int flags, int size )
  345. {
  346.  if ( flags == 0 )
  347.   charstats.bytes_tx += size;
  348.  else
  349.   charstats.cnt_tx_errors++;
  350.  last_tx_size = size;
  351.  last_tx_result = flags;
  352.  sending = 0;
  353.  wake_up_interruptible( &wq_write );
  354.  wake_up_interruptible( &wq_poll );
  355. }
  358. //////////////////////////////////////////////////////////////////////////////
  359. // Workers
  360. //////////////////////////////////////////////////////////////////////////////
  362. static int usbc_open( struct inode *pInode, struct file *pFile )
  363. {
  364.  int retval = 0;
  366.  PRINTK( KERN_DEBUG "%sopen()n", pszMe );
  368.  /* start usb core */
  369.  retval = pxa_usb_open( "usb-char" );
  370.  if ( retval ) return retval;
  372.  /* allocate memory */
  373.  if ( usb_ref_count == 0 ) {
  374.   tx_buf = (char*) kmalloc( TX_PACKET_SIZE, GFP_KERNEL | GFP_DMA );
  375.   if ( tx_buf == NULL ) {
  376.    printk( "%sARGHH! COULD NOT ALLOCATE TX BUFFERn", pszMe );
  377.    goto malloc_fail;
  378.   }
  379.   rx_ring.buf =
  380. (char*) kmalloc( RBUF_SIZE, GFP_KERNEL );
  382.   if ( rx_ring.buf == NULL ) {
  383.    printk( "%sARGHH! COULD NOT ALLOCATE RX BUFFERn", pszMe );
  384.    goto malloc_fail;
  385.   }
  387.   packet_buffer =
  388. (char*) kmalloc( RX_PACKET_SIZE, GFP_KERNEL | GFP_DMA  );
  390.   if ( packet_buffer == NULL ) {
  391.    printk( "%sARGHH! COULD NOT ALLOCATE RX PACKET BUFFERn", pszMe );
  392.    goto malloc_fail;
  393.   }
  394.   rx_ring.in = rx_ring.out = 0;
  395.   memset( &charstats, 0, sizeof( charstats ) );
  396.   sending = 0;
  397.   last_tx_result = 0;
  398.   last_tx_size = 0;
  399.  }
  401.  /* modify default descriptors */
  402.  twiddle_descriptors();
  404.  retval = pxa_usb_start();
  405.  if ( retval ) {
  406.   printk( "%sAGHH! Could not USB coren", pszMe );
  407.   free_txrx_buffers();
  408.   return retval;
  409.  }
  410.  usb_ref_count++;   /* must do _before_ kick_start() */
  411.  MOD_INC_USE_COUNT;
  412.  kick_start_rx();
  413.  return 0;
  415.  malloc_fail:
  416.  free_txrx_buffers();
  417.  return -ENOMEM;
  418. }
  420. /*
  421.  * Read endpoint. Note that you can issue a read to an
  422.  * unconfigured endpoint. Eventually, the host may come along
  423.  * and configure underneath this module and data will appear.
  424.  */
  425. static ssize_t usbc_read( struct file *pFile, char *pUserBuffer,
  426.                         size_t stCount, loff_t *pPos )
  427. {
  428.  ssize_t retval;
  429.  int flags;
  430.  DECLARE_WAITQUEUE( wait, current );
  432.  PRINTK( KERN_DEBUG "%sread()n", pszMe );
  434.  local_irq_save( flags );
  435.  if ( last_rx_result == 0 ) {
  436.   local_irq_restore( flags );
  437.  } else {  /* an error happended and receiver is paused */
  438.   local_irq_restore( flags );
  439.   last_rx_result = 0;
  440.   kick_start_rx();
  441.  }
  443.  add_wait_queue( &wq_read, &wait );
  444.  while( 1 ) {
  445.   ssize_t bytes_avail;
  446.   ssize_t bytes_to_end;
  448.   set_current_state( TASK_INTERRUPTIBLE );
  450.   /* snap ring buf state */
  451.   local_irq_save( flags );
  452.   bytes_avail  = CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE );
  453.   bytes_to_end = CIRC_CNT_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE );
  454.   local_irq_restore( flags );
  456.   if ( bytes_avail != 0 ) {
  457.    ssize_t bytes_to_move = MIN( stCount, bytes_avail );
  458.    retval = 0; // will be bytes transfered
  459.    if ( bytes_to_move != 0 ) {
  460. size_t n = MIN( bytes_to_end, bytes_to_move );
  461. if ( copy_to_user( pUserBuffer,
  462.    &rx_ring.buf[ rx_ring.out ],
  463.    n ) ) {
  464.  retval = -EFAULT;
  465.  break;
  466. }
  467. bytes_to_move -= n;
  468.   retval += n;
  469. // might go 1 char off end, so wrap
  470. rx_ring.out = ( rx_ring.out + n ) & (RBUF_SIZE-1);
  471. if ( copy_to_user( pUserBuffer + n,
  472.    &rx_ring.buf[ rx_ring.out ],
  473.    bytes_to_move )
  474.  ) {
  475.  retval = -EFAULT;
  476.  break;
  477. }
  478. rx_ring.out += bytes_to_move; // cannot wrap
  479. retval += bytes_to_move;
  480. kick_start_rx();
  481.    }
  482.    break;
  483.   }
  484.   else if ( last_rx_result ) {
  485.    retval = last_rx_result;
  486.    break;
  487.   }
  488.   else if ( pFile->f_flags & O_NONBLOCK ) {  // no data, can't sleep
  489.    retval = -EAGAIN;
  490.    break;
  491.   }
  492.   else if ( signal_pending( current ) ) {   // no data, can sleep, but signal
  493.    retval = -ERESTARTSYS;
  494.    break;
  495.   }
  496.   schedule();     // no data, can sleep
  497.  }
  498.  set_current_state( TASK_RUNNING );
  499.  remove_wait_queue( &wq_read, &wait );
  501.  if ( retval < 0 )
  502.   printk( "%sread error %d - %sn", pszMe, retval, what_the_f( retval ) );
  503.  return retval;
  504. }
  506. /*
  507.  * Write endpoint. This routine attempts to break the passed in buffer
  508.  * into usb DATA0/1 packet size chunks and send them to the host.
  509.  * (The lower-level driver tries to do this too, but easier for us
  510.  * to manage things here.)
  511.  *
  512.  * We are at the mercy of the host here, in that it must send an IN
  513.  * token to us to pull this data back, so hopefully some higher level
  514.  * protocol is expecting traffic to flow in that direction so the host
  515.  * is actually polling us. To guard against hangs, a 5 second timeout
  516.  * is used.
  517.  *
  518.  * This routine takes some care to only report bytes sent that have
  519.  * actually made it across the wire. Thus we try to stay in lockstep
  520.  * with the completion routine and only have one packet on the xmit
  521.  * hardware at a time. Multiple simultaneous writers will get
  522.  * "undefined" results.
  523.  *
  524.   */
  525. static ssize_t  usbc_write( struct file *pFile, const char * pUserBuffer,
  526.  size_t stCount, loff_t *pPos )
  527. {
  528.  ssize_t retval = 0;
  529.  ssize_t stSent = 0;
  531.  DECLARE_WAITQUEUE( wait, current );
  533.  PRINTK( KERN_DEBUG "%swrite() %d bytesn", pszMe, stCount );
  535.  down( &xmit_sem );  // only one thread onto the hardware at a time
  537.  while( stCount != 0 && retval == 0 ) {
  538.   int nThisTime  = MIN( TX_PACKET_SIZE, stCount );
  539.   copy_from_user( tx_buf, pUserBuffer, nThisTime );
  540.   sending = nThisTime;
  541.     retval = pxa_usb_send( tx_buf, nThisTime, tx_done_callback );
  542.   if ( retval < 0 ) {
  543.    char * p = what_the_f( retval );
  544.    printk( "%sCould not queue xmission. rc=%d - %sn",
  545.    pszMe, retval, p );
  546.    sending = 0;
  547.    break;
  548.   }
  549.   /* now have something on the diving board */
  550.   add_wait_queue( &wq_write, &wait );
  551.   tx_timer.expires = jiffies + ( HZ * 5 );
  552.   add_timer( &tx_timer );
  553.   while( 1 ) {
  554.    set_current_state( TASK_INTERRUPTIBLE );
  555.    if ( sending == 0 ) {  /* it jumped into the pool */
  556. del_timer( &tx_timer );
  557. retval = last_tx_result;
  558. if ( retval == 0 ) {
  559.  stSent  += last_tx_size;
  560.  pUserBuffer += last_tx_size;
  561.  stCount     -= last_tx_size;
  562. }
  563. else
  564.  printk( "%sxmission error rc=%d - %sn",
  565.  pszMe, retval, what_the_f(retval) );
  566. break;
  567.    }
  568.    else if ( signal_pending( current ) ) {
  569. del_timer( &tx_timer );
  570. printk( "%ssignaln", pszMe  );
  571. retval = -ERESTARTSYS;
  572. break;
  573.    }
  574.    schedule();
  575.   }
  576.   set_current_state( TASK_RUNNING );
  577.   remove_wait_queue( &wq_write, &wait );
  578.  }
  580.  up( &xmit_sem );
  582.  if ( 0 == retval )
  583.   retval = stSent;
  584.  return retval;
  585. }
  587. static unsigned int usbc_poll( struct file *pFile, poll_table * pWait )
  588. {
  589.  unsigned int retval = 0;
  591.  PRINTK( KERN_DEBUG "%poll()n", pszMe );
  593.  poll_wait( pFile, &wq_poll, pWait );
  595.  if ( CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE ) )
  596.   retval |= POLLIN | POLLRDNORM;
  597.  if ( pxa_usb_xmitter_avail() )
  598.   retval |= POLLOUT | POLLWRNORM;
  599.  return retval;
  600. }
  602. static int usbc_ioctl( struct inode *pInode, struct file *pFile,
  603.                        unsigned int nCmd, unsigned long argument )
  604. {
  605.  int retval = 0;
  607.  switch( nCmd ) {
  609.  case USBC_IOC_FLUSH_RECEIVER:
  610.   pxa_usb_recv_reset();
  611.   rx_ring.in = rx_ring.out = 0;
  612.   break;
  614.  case USBC_IOC_FLUSH_TRANSMITTER:
  615.   pxa_usb_send_reset();
  616.   break;
  618.  case USBC_IOC_FLUSH_ALL:
  619.   pxa_usb_recv_reset();
  620.   rx_ring.in = rx_ring.out = 0;
  621.   pxa_usb_send_reset();
  622.   break;
  624.  default:
  625.   retval = -ENOIOCTLCMD;
  626.   break;
  628.  }
  629.  return retval;
  630. }
  633. static int usbc_close( struct inode *pInode, struct file * pFile )
  634. {
  635. PRINTK( KERN_DEBUG "%sclose()n", pszMe );
  636. if ( --usb_ref_count == 0 ) {
  637.  down( &xmit_sem );
  638.  pxa_usb_stop();
  639.  free_txrx_buffers();
  640.  free_string_descriptors();
  641.  del_timer( &tx_timer );
  642.  pxa_usb_close();
  643.  up( &xmit_sem );
  644. }
  645.     MOD_DEC_USE_COUNT;
  646.     return 0;
  647. }
  649. #ifdef CONFIG_SA1100_EXTENEX1
  650. #include "../../../drivers/char/ex_gpio.h"
  651. void extenex_configured_notify_proc( void )
  652. {
  653.  if ( exgpio_play_string( "440,1:698,1" ) == -EAGAIN )
  654.   printk( "%sWanted to BEEP but ex_gpio not openn", pszMe );
  655. }
  656. #endif
  657. //////////////////////////////////////////////////////////////////////////////
  658. // Initialization
  659. //////////////////////////////////////////////////////////////////////////////
  661. static struct file_operations usbc_fops = {
  662. owner:      THIS_MODULE,
  663. open: usbc_open,
  664. read: usbc_read,
  665. write: usbc_write,
  666. poll: usbc_poll,
  667. ioctl: usbc_ioctl,
  668. release: usbc_close,
  669. };
  671. static struct miscdevice usbc_misc_device = {
  672.     USBC_MINOR, "usb_char", &usbc_fops
  673. };
  675. /*
  676.  * usbc_init()
  677.  */
  679. int __init usbc_init( void )
  680. {
  681.  int rc;
  683.  if ( (rc = misc_register( &usbc_misc_device )) != 0 ) {
  684.   printk( KERN_WARNING "%sCould not register device 10, "
  685.   "%d. (%d)n", pszMe, USBC_MINOR, rc );
  686.   return -EBUSY;
  687.  }
  689.  // initialize wait queues
  690.  init_waitqueue_head( &wq_read );
  691.  init_waitqueue_head( &wq_write );
  692.  init_waitqueue_head( &wq_poll );
  694.  // initialize tx timeout timer
  695.  init_timer( &tx_timer );
  696.  tx_timer.function = tx_timeout;
  698.   printk( KERN_INFO "USB Function Character Driver Interface"
  699.   " - %s, (C) 2001, Extenex Corp.n", VERSION
  700.    );
  702.  return rc;
  703. }
  705. void __exit usbc_exit( void )
  706. {
  707. }
  709. EXPORT_NO_SYMBOLS;
  711. module_init(usbc_init);
  712. module_exit(usbc_exit);
  716. // end: usb-char.c