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

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

嵌入式Linux

开发平台：

Unix_Linux

usb-char.c：源码内容
  1. /*
  2.  * (C) Copyright 2000-2001 MIZI Research, Inc.
  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 S3C2410 USB function
  21.  * driver.
  22.  */
  24. #include <linux/module.h>
  25. #include <linux/config.h>
  26. #include <linux/miscdevice.h>
  27. #include <linux/slab.h>
  28. #include <linux/init.h>
  29. #include <linux/cache.h>
  30. #include <linux/poll.h>
  31. #include <linux/circ_buf.h>
  32. #include <linux/timer.h>
  34. #include <asm/io.h>
  35. #include <asm/semaphore.h>
  36. #include <asm/proc/page.h>
  37. #include <asm/mach-types.h>
  39. #include "usb-char.h"
  40. #include "s3c2410_usb.h"
  42. #ifdef CONFIG_MIZI
  43. #include <asm/irq.h>
  44. #ifdef CONFIG_PM
  45. #include <linux/pm.h>
  46. static struct pm_dev *usb_char_pm_dev;
  47. #endif
  48. #endif
  51. //////////////////////////////////////////////////////////////////////////////
  52. // Driver  Options
  53. //////////////////////////////////////////////////////////////////////////////
  55. #ifdef CONFIG_MIZI
  56. #define VERSION "0.5"
  57. #define LINUETTE_VENDOR_ID 0x49f
  58. #define LINUETTE_PRODUCT_ID 0x505A
  59. #define LINUETTE_REV_NUM 1
  60.  
  61. #define USB_CHAR_MANUFACTURE "MIZI Research Inc."
  62. #define USB_CHAR_FOR_WHAT "linu@usb"
  63. #define USB_CHAR_BUILD_DATE "20020115"
  64. #define USB_CHAR_INTERFACE "Bulk Transfer"
  65. #else
  66. #define VERSION "0.4"
  67. #endif
  70. //#define VERBOSITY 1
  72. #if VERBOSITY
  73. # define PRINTK(a...) printk(__FILE__":"__FUNCTION__"(): " ##a)
  74. #else
  75. # define PRINTK(a...) (void)(0)
  76. #endif
  78. //////////////////////////////////////////////////////////////////////////////
  79. // Globals - Macros - Enums - Structures
  80. //////////////////////////////////////////////////////////////////////////////
  81. #ifndef MIN
  82. #define MIN( a, b ) ((a)<(b)?(a):(b))
  83. #endif
  85. typedef int bool; enum { false = 0, true = 1 };
  87. static const char pszMe[] = "usbchr: ";
  89. static wait_queue_head_t wq_read;
  90. static wait_queue_head_t wq_write;
  91. static wait_queue_head_t wq_poll;
  93. /* Serialze multiple writers onto the transmit hardware
  94. .. since we sleep the writer during transmit to stay in
  95. .. sync. (Multiple writers don't make much sense, but..) */
  96. static DECLARE_MUTEX( xmit_sem );
  98. // size of usb DATA0/1 packets. 64 is standard maximum
  99. // for bulk transport, though most hosts seem to be able
  100. // to handle larger.
  101. #define TX_PACKET_SIZE 64
  102. #define RX_PACKET_SIZE 64
  103. #define RBUF_SIZE  (4*PAGE_SIZE)
  105. static struct wcirc_buf {
  106.   char *buf;
  107.   int in;
  108.   int out;
  109. } rx_ring = { NULL, 0, 0 };
  111. static struct {
  112.  unsigned long  cnt_rx_complete;
  113.  unsigned long  cnt_rx_errors;
  114.  unsigned long  bytes_rx;
  115.  unsigned long  cnt_tx_timeouts;
  116.  unsigned long  cnt_tx_errors;
  117.  unsigned long  bytes_tx;
  118. } charstats;
  121. static char * tx_buf = NULL;
  122. static char * packet_buffer = NULL;
  123. static int sending = 0;
  124. static int usb_ref_count = 0;
  125. static int last_tx_result = 0;
  126. static int last_rx_result = 0;
  127. static int last_tx_size = 0;
  128. static struct timer_list tx_timer;
  130. //////////////////////////////////////////////////////////////////////////////
  131. // Prototypes
  132. //////////////////////////////////////////////////////////////////////////////
  133. #ifndef CONFIG_MIZI
  134. static char *  what_the_f( int e );
  135. #endif
  136. static void  free_txrx_buffers( void );
  137. static void     twiddle_descriptors( void );
  138. static void     free_string_descriptors( void ) ;
  139. static int      usbc_open( struct inode *pInode, struct file *pFile );
  140. static void     rx_done_callback_packet_buffer( int flag, int size );
  142. static void     tx_timeout( unsigned long );
  143. static void     tx_done_callback( int flag, int size );
  145. static ssize_t  usbc_read( struct file *, char *, size_t, loff_t * );
  146. static ssize_t  usbc_write( struct file *, const char *, size_t, loff_t * );
  147. static unsigned int usbc_poll( struct file *pFile, poll_table * pWait );
  148. static int usbc_ioctl( struct inode *pInode, struct file *pFile,
  149.                        unsigned int nCmd, unsigned long argument );
  150. static int      usbc_close( struct inode *pInode, struct file *pFile );
  152. #ifdef CONFIG_S3C2410_EXTENEX1
  153. static void     extenex_configured_notify_proc( void );
  154. #endif
  155. #ifdef CONFIG_MIZI
  156. static int usbc_activate(void);
  157. static void usbc_deactivate(void);
  158. #endif
  159. //////////////////////////////////////////////////////////////////////////////
  160. // Private Helpers
  161. //////////////////////////////////////////////////////////////////////////////
  162. #if defined(CONFIG_PM) && defined(CONFIG_MIZI)
  163. extern void usbctl_suspend(void);
  164. extern void usbctl_resume(void);
  165. static int
  166. usbchar_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
  167. {
  168. PRINTK("pm_callback: %dn", req);
  170. switch (req) {
  171. case PM_RESUME:    
  172. usbctl_resume();
  173. usbc_activate();
  174. PRINTK("usb-char wakeup...");
  175. break;
  176. case PM_SUSPEND:   
  177. usbc_deactivate();
  178. usbctl_suspend();
  179. PRINTK("usb-char sleep...");
  180. break;
  181. }
  182. PRINTK("donen");
  183.  
  184. return 0;
  185. }
  186. #endif
  188. #ifndef CONFIG_MIZI
  189. static char * what_the_f( int e )
  190. {
  191.  char * p;
  192.  switch( e ) {
  193.  case 0:
  194.   p = "noErr";
  195.   break;
  196.  case -ENODEV:
  197.   p = "ENODEV - usb not in config state";
  198.   break;
  199.  case -EBUSY:
  200.   p = "EBUSY - another request on the hardware";
  201.   break;
  202.  case -EAGAIN:
  203.   p = "EAGAIN";
  204.   break;
  205.  case -EINTR:
  206.   p = "EINTR - interruptedn";
  207.   break;
  208.  case -EPIPE:
  209.   p = "EPIPE - zero length xfern";
  210.   break;
  211.  default:
  212.   p = "????";
  213.   break;
  214.  }
  215.  return p;
  216. }
  217. #endif
  219. static void free_txrx_buffers( void )
  220. {
  221. PRINTK("n");
  222.  if ( rx_ring.buf != NULL ) {
  223.   kfree( rx_ring.buf );
  224.   rx_ring.buf = NULL;
  225.  }
  226.  if ( packet_buffer != NULL ) {
  227.   kfree( packet_buffer );
  228.   packet_buffer = NULL;
  229.  }
  230.  if ( tx_buf != NULL ) {
  231.   kfree( tx_buf );
  232.   tx_buf = NULL;
  233.  }
  234. }
  236. /* twiddle_descriptors()
  237.  * It is between open() and start(). Setup descriptors.
  238.  */
  239. static void twiddle_descriptors( void )
  240. {
  241.  desc_t * pDesc = s3c2410_usb_get_descriptor_ptr();
  242.  string_desc_t * pString;
  244. PRINTK("n");
  246.  pDesc->b.ep1.wMaxPacketSize = make_word_c( RX_PACKET_SIZE );
  247.  pDesc->b.ep1.bmAttributes   = USB_EP_BULK;
  248.  pDesc->b.ep2.wMaxPacketSize = make_word_c( TX_PACKET_SIZE );
  249.  pDesc->b.ep2.bmAttributes   = USB_EP_BULK;
  251. #ifdef CONFIG_MIZI
  252. pDesc->dev.idVendor = LINUETTE_VENDOR_ID;
  253. pDesc->dev.idProduct = LINUETTE_PRODUCT_ID;
  254. pDesc->dev.bcdDevice = LINUETTE_REV_NUM;
  255. pDesc->b.cfg.bmAttributes = USB_CONFIG_SELFPOWERED;
  256. pDesc->b.cfg.MaxPower = 0;
  258. if (s3c2410_usb_get_string_descriptor(4)) return;
  260. pString = s3c2410_usb_kmalloc_string_descriptor( USB_CHAR_MANUFACTURE);
  261. if ( pString ) {
  262. s3c2410_usb_set_string_descriptor( 1, pString );
  263. pDesc->dev.iManufacturer = 1;
  264. }
  266. pString = s3c2410_usb_kmalloc_string_descriptor( USB_CHAR_FOR_WHAT );
  267. if ( pString ) {
  268. s3c2410_usb_set_string_descriptor( 2, pString );
  269. pDesc->dev.iProduct = 2;
  270. }
  272. pString = s3c2410_usb_kmalloc_string_descriptor( USB_CHAR_BUILD_DATE );
  273. if ( pString ) {
  274. s3c2410_usb_set_string_descriptor( 3, pString );
  275. pDesc->dev.iSerialNumber = 3;
  276. }
  278. pString = s3c2410_usb_kmalloc_string_descriptor( USB_CHAR_INTERFACE );
  279. if ( pString ) {
  280. s3c2410_usb_set_string_descriptor( 4, pString );
  281. pDesc->b.intf.iInterface = 4;
  282. }
  283. #endif
  284. }
  286. static void free_string_descriptors( void )
  287. {
  288. PRINTK("n");
  289.  if ( machine_is_extenex1() ) {
  290.   string_desc_t * pString;
  291.   int i;
  292.   for( i = 1 ; i <= 4 ; i++ ) {
  293.    pString = s3c2410_usb_get_string_descriptor( i );
  294.    if ( pString )
  295. kfree( pString );
  296.   }
  297.  }
  298. #ifdef CONFIG_MIZI
  299. {
  300. string_desc_t * pString;
  301. int i;
  302. for( i = 1 ; i <= 4 ; i++ ) {
  303. pString = s3c2410_usb_get_string_descriptor( i );
  304. if ( pString )
  305. kfree( pString );
  306. s3c2410_usb_set_string_descriptor( i , NULL);
  307. }
  308. }
  309. #endif
  310. }
  312. //////////////////////////////////////////////////////////////////////////////
  313. // ASYNCHRONOUS
  314. //////////////////////////////////////////////////////////////////////////////
  315. static  void kick_start_rx( void )
  316. {
  317. PRINTK("n");
  318. #if defined(CONFIG_MIZI)
  319.    {
  320. #else
  321.     // PRINTK("i'm not  MIZI - %dn", usb_ref_count);
  322.  if ( usb_ref_count ) {
  323. #endif
  324.   int total_space  = CIRC_SPACE( rx_ring.in, rx_ring.out, RBUF_SIZE );
  325. //       PRINTK("total_space = %d, %dn", total_space, RX_PACKET_SIZE);
  326.   if ( total_space >= RX_PACKET_SIZE ) {
  327.    s3c2410_usb_recv( packet_buffer,
  328. RX_PACKET_SIZE,
  329. rx_done_callback_packet_buffer
  330.       );
  331.   }
  332.  }
  333. }
  334. /*
  335.  * rx_done_callback_packet_buffer()
  336.  * We have completed a DMA xfer into the temp packet buffer.
  337.  * Move to ring.
  338.  *
  339.  * flag values:
  340.  * on init,  -EAGAIN
  341.  * on reset, -EINTR
  342.  * on RPE, -EIO
  343.  * on short packet -EPIPE
  344.  */
  345. static void
  346. rx_done_callback_packet_buffer( int flag, int size )
  347. {
  348.  charstats.cnt_rx_complete++;
  350. PRINTK("n");
  351.  if ( flag == 0 || flag == -EPIPE ) {
  352.   size_t n;
  354.   charstats.bytes_rx += size;
  356.   n = CIRC_SPACE_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE );
  357.   n = MIN( n, size );
  358.   size -= n;
  360.   memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer, n );
  361.   rx_ring.in = (rx_ring.in + n) & (RBUF_SIZE-1);
  362.   memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer + n, size );
  363.   rx_ring.in = (rx_ring.in + size) & (RBUF_SIZE-1);
  365.   wake_up_interruptible( &wq_read );
  366.   wake_up_interruptible( &wq_poll );
  368.   last_rx_result = 0;
  370.   kick_start_rx();
  372.  } else if ( flag != -EAGAIN ) {
  373.   charstats.cnt_rx_errors++;
  374.   last_rx_result = flag;
  375.   wake_up_interruptible( &wq_read );
  376.   wake_up_interruptible( &wq_poll );
  377.  }
  378.  else  /* init, start a read */
  379.   kick_start_rx();
  380. }
  383. static void tx_timeout( unsigned long unused )
  384. {
  385. PRINTK( "%stx timeoutn", pszMe );
  386. s3c2410_usb_send_reset();
  387. charstats.cnt_tx_timeouts++;
  388. }
  391. // on init, -EAGAIN
  392. // on reset, -EINTR
  393. // on TPE, -EIO
  394. static void tx_done_callback( int flags, int size )
  395. {
  396. PRINTK("n");
  397.  if ( flags == 0 )
  398.   charstats.bytes_tx += size;
  399.  else
  400.   charstats.cnt_tx_errors++;
  401.  last_tx_size = size;
  402.  last_tx_result = flags;
  403.  sending = 0;
  404.  wake_up_interruptible( &wq_write );
  405.  wake_up_interruptible( &wq_poll );
  406. }
  409. //////////////////////////////////////////////////////////////////////////////
  410. // Workers
  411. //////////////////////////////////////////////////////////////////////////////
  413. #ifdef CONFIG_MIZI
  414. static void usbc_alloc_mem(void)
  415. {
  416. PRINTK("n");
  417. tx_buf = (char*) kmalloc( TX_PACKET_SIZE, GFP_KERNEL | GFP_DMA );
  418. if ( tx_buf == NULL ) {
  419. PRINTK( "%sARGHH! COULD NOT ALLOCATE TX BUFFERn", pszMe );
  420. }
  422. rx_ring.buf = (char*) kmalloc( RBUF_SIZE, GFP_KERNEL );
  423. if ( rx_ring.buf == NULL ) {
  424. PRINTK( "%sARGHH! COULD NOT ALLOCATE RX BUFFERn", pszMe );
  425. }
  427. packet_buffer = (char*) kmalloc( RX_PACKET_SIZE, GFP_KERNEL | GFP_DMA );
  428. if ( packet_buffer == NULL ) {
  429. PRINTK( "%sARGHH! COULD NOT ALLOCATE RX PACKET BUFFERn",pszMe);
  430. }
  431. //usbc_ioctl(0, 0, USBC_IOC_FLUSH_ALL, 0);
  432. }
  433. #endif
  435. static int usbc_open( struct inode *pInode, struct file *pFile )
  436. {
  437.  MOD_INC_USE_COUNT;
  438.  kick_start_rx();
  439.  return 0;
  440. }
  442. /*
  443.  * Read endpoint. Note that you can issue a read to an
  444.  * unconfigured endpoint. Eventually, the host may come along
  445.  * and configure underneath this module and data will appear.
  446.  */
  447. static ssize_t usbc_read( struct file *pFile, char *pUserBuffer,
  448.                         size_t stCount, loff_t *pPos )
  449. {
  450.  ssize_t retval;
  451.  int flags;
  452.  DECLARE_WAITQUEUE( wait, current );
  454. // PRINTK( "count=%d", stCount);
  456.  local_irq_save( flags );
  457.  if ( last_rx_result == 0 ) {
  458.   local_irq_restore( flags );
  459.  } else {  /* an error happended and receiver is paused */
  460.   local_irq_restore( flags );
  461.   last_rx_result = 0;
  462.   kick_start_rx();
  463.  }
  465.  add_wait_queue( &wq_read, &wait );
  466.  while( 1 ) {
  467.   ssize_t bytes_avail;
  468.   ssize_t bytes_to_end;
  470.   set_current_state( TASK_INTERRUPTIBLE );
  472.   /* snap ring buf state */
  473.   local_irq_save( flags );
  474.   bytes_avail  = CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE );
  475.   bytes_to_end = CIRC_CNT_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE );
  476.   local_irq_restore( flags );
  478.   if ( bytes_avail != 0 ) {
  479.    ssize_t bytes_to_move = MIN( stCount, bytes_avail );
  480.    retval = 0; // will be bytes transfered
  481.    if ( bytes_to_move != 0 ) {
  482. size_t n = MIN( bytes_to_end, bytes_to_move );
  483. if ( copy_to_user( pUserBuffer,
  484.    &rx_ring.buf[ rx_ring.out ],
  485.    n ) ) {
  486.  retval = -EFAULT;
  487.  break;
  488. }
  489. bytes_to_move -= n;
  490.   retval += n;
  491. // might go 1 char off end, so wrap
  492. rx_ring.out = ( rx_ring.out + n ) & (RBUF_SIZE-1);
  493. if ( copy_to_user( pUserBuffer + n,
  494.    &rx_ring.buf[ rx_ring.out ],
  495.    bytes_to_move )
  496.  ) {
  497.  retval = -EFAULT;
  498.  break;
  499. }
  500. rx_ring.out += bytes_to_move; // cannot wrap
  501. retval += bytes_to_move;
  502. kick_start_rx();
  503.    }
  504.    break;
  505.   }
  506.   else if ( last_rx_result ) {
  507.    retval = last_rx_result;
  508.    break;
  509.   }
  510.   else if ( pFile->f_flags & O_NONBLOCK ) {  // no data, can't sleep
  511.    retval = -EAGAIN;
  512.    break;
  513.   }
  514.   else if ( signal_pending( current ) ) {   // no data, can sleep, but signal
  515.    retval = -ERESTARTSYS;
  516.    break;
  517.   }
  518.   schedule();     // no data, can sleep
  519.  }
  520.  set_current_state( TASK_RUNNING );
  521.  remove_wait_queue( &wq_read, &wait );
  523. #ifndef CONFIG_MIZI
  524.  if ( retval < 0 )
  525.   printk( "%sread error %d - %sn", pszMe, retval, what_the_f( retval ) );
  526. #endif
  527.  return retval;
  528. }
  530. /*
  531.  * Write endpoint. This routine attempts to break the passed in buffer
  532.  * into usb DATA0/1 packet size chunks and send them to the host.
  533.  * (The lower-level driver tries to do this too, but easier for us
  534.  * to manage things here.)
  535.  *
  536.  * We are at the mercy of the host here, in that it must send an IN
  537.  * token to us to pull this data back, so hopefully some higher level
  538.  * protocol is expecting traffic to flow in that direction so the host
  539.  * is actually polling us. To guard against hangs, a 5 second timeout
  540.  * is used.
  541.  *
  542.  * This routine takes some care to only report bytes sent that have
  543.  * actually made it across the wire. Thus we try to stay in lockstep
  544.  * with the completion routine and only have one packet on the xmit
  545.  * hardware at a time. Multiple simultaneous writers will get
  546.  * "undefined" results.
  547.  *
  548.   */
  549. static ssize_t  usbc_write( struct file *pFile, const char * pUserBuffer,
  550.  size_t stCount, loff_t *pPos )
  551. {
  552.  ssize_t retval = 0;
  553.  ssize_t stSent = 0;
  555.  DECLARE_WAITQUEUE( wait, current );
  557.  PRINTK( KERN_DEBUG "%swrite() %d bytesn", pszMe, stCount );
  559.  down( &xmit_sem );  // only one thread onto the hardware at a time
  561.  while( stCount != 0 && retval == 0 ) {
  562.   int nThisTime  = MIN( TX_PACKET_SIZE, stCount );
  563.   copy_from_user( tx_buf, pUserBuffer, nThisTime );
  564.   sending = nThisTime;
  565.     retval = s3c2410_usb_send( tx_buf, nThisTime, tx_done_callback );
  566.   if ( retval < 0 ) {
  567. #ifndef CONFIG_MIZI
  568.    char * p = what_the_f( retval );
  569.    printk( "%sCould not queue xmission. rc=%d - %sn",
  570.    pszMe, retval, p );
  571. #endif
  572.    sending = 0;
  573.    break;
  574.   }
  575.   /* now have something on the diving board */
  576.   add_wait_queue( &wq_write, &wait );
  577.   tx_timer.expires = jiffies + ( HZ * 5 );
  578.   add_timer( &tx_timer );
  579.   while( 1 ) {
  580.    set_current_state( TASK_INTERRUPTIBLE );
  581.    if ( sending == 0 ) {  /* it jumped into the pool */
  582. del_timer( &tx_timer );
  583. retval = last_tx_result;
  584. if ( retval == 0 ) {
  585.  stSent  += last_tx_size;
  586.  pUserBuffer += last_tx_size;
  587.  stCount     -= last_tx_size;
  588. }
  589. #ifndef CONFIG_MIZI
  590. else
  591.  printk( "%sxmission error rc=%d - %sn",
  592.  pszMe, retval, what_the_f(retval) );
  593. #endif
  594. break;
  595.    }
  596.    else if ( signal_pending( current ) ) {
  597. del_timer( &tx_timer );
  598. PRINTK( "%ssignaln", pszMe  );
  599. retval = -ERESTARTSYS;
  600. break;
  601.    }
  602.    schedule();
  603.   }
  604.   set_current_state( TASK_RUNNING );
  605.   remove_wait_queue( &wq_write, &wait );
  606.  }
  608.  up( &xmit_sem );
  610.  if ( 0 == retval )
  611.   retval = stSent;
  612.  return retval;
  613. }
  615. static unsigned int usbc_poll( struct file *pFile, poll_table * pWait )
  616. {
  617.  unsigned int retval = 0;
  619.  PRINTK( KERN_DEBUG "%poll()n", pszMe );
  621.  poll_wait( pFile, &wq_poll, pWait );
  623.  if ( CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE ) )
  624.   retval |= POLLIN | POLLRDNORM;
  625.  if ( s3c2410_usb_xmitter_avail() )
  626.   retval |= POLLOUT | POLLWRNORM;
  627.  return retval;
  628. }
  630. static int usbc_ioctl( struct inode *pInode, struct file *pFile,
  631.                        unsigned int nCmd, unsigned long argument )
  632. {
  633.  int retval = 0;
  635.  switch( nCmd ) {
  637.  case USBC_IOC_FLUSH_RECEIVER:
  638.   s3c2410_usb_recv_reset();
  639.   rx_ring.in = rx_ring.out = 0;
  640.   break;
  642.  case USBC_IOC_FLUSH_TRANSMITTER:
  643.   s3c2410_usb_send_reset();
  644.   break;
  646.  case USBC_IOC_FLUSH_ALL:
  647.   s3c2410_usb_recv_reset();
  648.   rx_ring.in = rx_ring.out = 0;
  649.   s3c2410_usb_send_reset();
  650.   break;
  652.  default:
  653.   retval = -ENOIOCTLCMD;
  654.   break;
  656.  }
  657.  return retval;
  658. }
  661. #ifdef CONFIG_MIZI
  662. static int
  663. usbc_activate(void)
  664. {
  665. int retval = 0;
  667. PRINTK("n");
  668. /* start usb core */
  669. retval = s3c2410_usb_open( "usb-char" );
  671. twiddle_descriptors();
  673. retval = s3c2410_usb_start();
  674. if ( retval ) {
  675. PRINTK( "%sAGHH! Could not USB coren", pszMe );
  676. free_txrx_buffers();
  677. return retval;
  678. }
  680. usb_ref_count++;   /* must do _before_ kick_start() */
  681. kick_start_rx();
  682. return 0;
  683. }
  685. static void
  686. usbc_deactivate(void)
  687. {
  688. PRINTK("n");
  689. down( &xmit_sem );
  690. s3c2410_usb_stop();
  691. del_timer( &tx_timer );
  692. s3c2410_usb_close();
  693. up( &xmit_sem );
  694. }
  695. #endif
  697. static int usbc_close( struct inode *pInode, struct file * pFile )
  698. {
  699. PRINTK( KERN_DEBUG "%sclose()n", pszMe );
  700. #ifdef CONFIG_MIZI
  701. --usb_ref_count;
  703. #else
  704. if ( --usb_ref_count == 0 ) {
  705.  down( &xmit_sem );
  706.  s3c2410_usb_stop();
  707.  free_txrx_buffers();
  708.  free_string_descriptors();
  709.  del_timer( &tx_timer );
  710.  s3c2410_usb_close();
  711.  up( &xmit_sem );
  712. }
  713. #endif
  714.     MOD_DEC_USE_COUNT;
  715.     return 0;
  716. }
  718. //////////////////////////////////////////////////////////////////////////////
  719. // Initialization
  720. //////////////////////////////////////////////////////////////////////////////
  722. static struct file_operations usbc_fops = {
  723. owner:      THIS_MODULE,
  724. open: usbc_open,
  725. read: usbc_read,
  726. write: usbc_write,
  727. poll: usbc_poll,
  728. ioctl: usbc_ioctl,
  729. release: usbc_close,
  730. };
  732. static struct miscdevice usbc_misc_device = {
  733.     USBC_MINOR, "usb_char", &usbc_fops
  734. };
  736. /*
  737.  * usbc_init()
  738.  */
  740. int __init usbc_init( void )
  741. {
  742.  int rc;
  744. #if !defined( CONFIG_ARCH_S3C2410 )
  745.  return -ENODEV;
  746. #endif
  748.  if ( (rc = misc_register( &usbc_misc_device )) != 0 ) {
  749.   printk( KERN_WARNING "%sCould not register device 10, "
  750.   "%d. (%d)n", pszMe, USBC_MINOR, rc );
  751.   return -EBUSY;
  752.  }
  754.  // initialize wait queues
  755.  init_waitqueue_head( &wq_read );
  756.  init_waitqueue_head( &wq_write );
  757.  init_waitqueue_head( &wq_poll );
  759.  // initialize tx timeout timer
  760.  init_timer( &tx_timer );
  761.  tx_timer.function = tx_timeout;
  763. #ifdef CONFIG_MIZI
  764. memset( &charstats, 0, sizeof( charstats ) );
  765. sending = 0;
  766. last_tx_result = 0;
  767. last_tx_size = 0;
  768. #endif
  769. printk( KERN_INFO "USB Function Character Driver Interface"
  770. " - %s, (C) 2001, Extenex Corp.n", VERSION);
  771.  
  772. #ifdef CONFIG_MIZI
  773. #ifdef CONFIG_PM
  774. usb_char_pm_dev = pm_register(PM_SYS_DEV, PM_SYS_MISC,
  775.       usbchar_pm_callback);
  776. #endif
  777. usbc_alloc_mem();
  778. usbc_activate();
  779. #endif
  780.  return rc;
  781. }
  783. void __exit usbc_exit( void )
  784. {
  785. #ifdef CONFIG_MIZI
  786. usbc_deactivate();
  787. free_txrx_buffers();
  788. free_string_descriptors();
  789. #ifdef CONFIG_PM
  790. if (usb_char_pm_dev)
  791. pm_unregister(usb_char_pm_dev);
  792. #endif 
  793. #endif
  794. misc_deregister( &usbc_misc_device );
  795. }
  797. EXPORT_NO_SYMBOLS;
  799. module_init(usbc_init);
  800. module_exit(usbc_exit);
  804. // end: usb-char.c