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

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

嵌入式Linux

开发平台：

Unix_Linux

usb_ctl.c：源码内容
  1.  /*
  2.  * Copyright (C) Compaq Computer Corporation, 1998, 1999
  3.  *  Copyright (C) Extenex Corporation, 2001
  4.  *
  5.  *  usb_ctl.c
  6.  *
  7.  *  SA1100 USB controller core driver.
  8.  *
  9.  *  This file provides interrupt routing and overall coordination
  10.  *  of the three endpoints in usb_ep0, usb_receive (1),  and usb_send (2).
  11.  *
  12.  *  Please see linux/Documentation/arm/SA1100/SA1100_USB for details.
  13.  *
  14.  */
  15. #include <linux/config.h>
  16. #include <linux/module.h>
  17. #include <linux/init.h>
  18. #include <linux/proc_fs.h>
  19. #include <linux/tqueue.h>
  20. #include <linux/delay.h>
  21. #include <linux/sched.h>
  22. #include <linux/slab.h>
  23. #include <asm/io.h>
  24. #include <asm/dma.h>
  25. #include <asm/irq.h>
  26. #include <asm/mach-types.h>
  28. #include "sa1100_usb.h"
  29. #include "usb_ctl.h"
  31. //////////////////////////////////////////////////////////////////////////////
  32. // Prototypes
  33. //////////////////////////////////////////////////////////////////////////////
  35. int usbctl_next_state_on_event( int event );
  36. static void udc_int_hndlr(int, void *, struct pt_regs *);
  37. static void initialize_descriptors( void );
  38. static void soft_connect_hook( int enable );
  39. static void udc_disable(void);
  40. static void udc_enable(void);
  42. #if CONFIG_PROC_FS
  43. #define PROC_NODE_NAME "sausb"
  44. static int usbctl_read_proc(char *page, char **start, off_t off,
  45. int count, int *eof, void *data);
  46. #endif
  48. //////////////////////////////////////////////////////////////////////////////
  49. // Globals
  50. //////////////////////////////////////////////////////////////////////////////
  51. static const char pszMe[] = "usbctl: ";
  52. struct usb_info_t usbd_info;  /* global to ep0, usb_recv, usb_send */
  54. /* device descriptors */
  55. static desc_t desc;
  57. #define MAX_STRING_DESC 8
  58. static string_desc_t * string_desc_array[ MAX_STRING_DESC ];
  59. static string_desc_t sd_zero;  /* special sd_zero holds language codes */
  61. // called when configured
  62. static usb_notify_t configured_callback = NULL;
  64. enum { kStateZombie  = 0,  kStateZombieSuspend  = 1,
  65. kStateDefault = 2,  kStateDefaultSuspend = 3,
  66. kStateAddr    = 4,  kStateAddrSuspend    = 5,
  67. kStateConfig  = 6,  kStateConfigSuspend  = 7
  68. };
  70. static int device_state_machine[8][6] = {
  71. //                suspend               reset          resume     adddr config deconfig
  72. /* zombie */  {  kStateZombieSuspend,  kStateDefault, kError,    kError, kError, kError },
  73. /* zom sus */ {  kError, kStateDefault, kStateZombie, kError, kError, kError },
  74. /* default */ {  kStateDefaultSuspend, kError, kStateDefault, kStateAddr, kError, kError },
  75. /* def sus */ {  kError, kStateDefault, kStateDefault, kError, kError, kError },
  76. /* addr */    {  kStateAddrSuspend, kStateDefault, kError, kError, kStateConfig, kError },
  77. /* addr sus */{  kError, kStateDefault, kStateAddr, kError, kError, kError },
  78. /* config */  {  kStateConfigSuspend, kStateDefault, kError, kError, kError, kStateAddr },
  79. /* cfg sus */ {  kError, kStateDefault, kStateConfig, kError, kError, kError }
  80. };
  82. /* "device state" is the usb device framework state, as opposed to the
  83.    "state machine state" which is whatever the driver needs and is much
  84.    more fine grained
  85. */
  86. static int sm_state_to_device_state[8] =
  87. //  zombie           zom suspend          default            default sus
  88. { USB_STATE_POWERED, USB_STATE_SUSPENDED, USB_STATE_DEFAULT, USB_STATE_SUSPENDED,
  89. // addr              addr sus             config                config sus
  90.   USB_STATE_ADDRESS, USB_STATE_SUSPENDED, USB_STATE_CONFIGURED, USB_STATE_SUSPENDED
  91. };
  93. static char * state_names[8] =
  94. { "zombie", "zombie suspended", "default", "default suspended",
  95.   "address", "address suspended", "configured", "config suspended"
  96. };
  98. static char * event_names[6] =
  99. { "suspend", "reset", "resume",
  100.   "address assigned", "configure", "de-configure"
  101. };
  103. static char * device_state_names[] =
  104. { "not attached", "attached", "powered", "default",
  105.   "address", "configured", "suspended" };
  107. static int sm_state = kStateZombie;
  109. //////////////////////////////////////////////////////////////////////////////
  110. // Async
  111. //////////////////////////////////////////////////////////////////////////////
  112. static void core_kicker(void);
  114. static inline void enable_resume_mask_suspend( void );
  115. static inline void enable_suspend_mask_resume(void);
  117. static void
  118. udc_int_hndlr(int irq, void *dev_id, struct pt_regs *regs)
  119. {
  120.    __u32 status = Ser0UDCSR;
  122. /* ReSeT Interrupt Request - UDC has been reset */
  123. if ( status & UDCSR_RSTIR )
  124. {
  125. if ( usbctl_next_state_on_event( kEvReset ) != kError )
  126. {
  127. /* starting 20ms or so reset sequence now... */
  128. printk("%sResettingn", pszMe);
  129. ep0_reset();  // just set state to idle
  130. ep1_reset();  // flush dma, clear false stall
  131. ep2_reset();  // flush dma, clear false stall
  132. }
  133. // mask reset ints, they flood during sequence, enable
  134. // suspend and resume
  135. Ser0UDCCR |= UDCCR_REM;    // mask reset
  136. Ser0UDCCR &= ~(UDCCR_SUSIM | UDCCR_RESIM); // enable suspend and resume
  137. UDC_flip(  Ser0UDCSR, status ); // clear all pending sources
  138. return; // <-- no reason to continue if resetting
  139. }
  140. // else we have done something other than reset, so be sure reset enabled
  141. UDC_clear( Ser0UDCCR, UDCCR_REM );
  143. /* RESume Interrupt Request */
  144. if ( status & UDCSR_RESIR )
  145. {
  146. usbctl_next_state_on_event( kEvResume );
  147. core_kicker();
  148. enable_suspend_mask_resume();
  149. }
  151. /* SUSpend Interrupt Request */
  152. if ( status & UDCSR_SUSIR )
  153. {
  154. usbctl_next_state_on_event( kEvSuspend );
  155. enable_resume_mask_suspend();
  156. }
  158. UDC_flip(Ser0UDCSR, status); // clear all pending sources
  160. if (status & UDCSR_EIR)
  161.  ep0_int_hndlr();
  163. if (status & UDCSR_RIR)
  164. ep1_int_hndlr(status);
  166. if (status & UDCSR_TIR)
  167. ep2_int_hndlr(status);
  168. }
  170. static inline void enable_resume_mask_suspend( void )
  171. {
  172.  int i = 0;
  174.  while( 1 ) {
  175.   Ser0UDCCR |= UDCCR_SUSIM; // mask future suspend events
  176.   udelay( i );
  177.   if ( (Ser0UDCCR & UDCCR_SUSIM) || (Ser0UDCSR & UDCSR_RSTIR) )
  178.    break;
  179.   if ( ++i == 50 ) {
  180.    printk( "%senable_resume(): Could not set SUSIM %8.8Xn",
  181.    pszMe, Ser0UDCCR );
  182.    break;
  183.   }
  184.  }
  186.  i = 0;
  187.  while( 1 ) {
  188.   Ser0UDCCR &= ~UDCCR_RESIM;
  189.   udelay( i );
  190.   if ( ( Ser0UDCCR & UDCCR_RESIM ) == 0
  191.    ||
  192.    (Ser0UDCSR & UDCSR_RSTIR)
  193.  )
  194.    break;
  195.   if ( ++i == 50 ) {
  196.    printk( "%senable_resume(): Could not clear RESIM %8.8Xn",
  197.    pszMe, Ser0UDCCR );
  198.    break;
  199.   }
  200.  }
  201. }
  203. static inline void enable_suspend_mask_resume(void)
  204. {
  205.  int i = 0;
  206.  while( 1 ) {
  207.   Ser0UDCCR |= UDCCR_RESIM; // mask future resume events
  208.   udelay( i );
  209.   if ( Ser0UDCCR & UDCCR_RESIM || (Ser0UDCSR & UDCSR_RSTIR) )
  210.    break;
  211.   if ( ++i == 50 ) {
  212.    printk( "%senable_suspend(): Could not set RESIM %8.8Xn",
  213.    pszMe, Ser0UDCCR );
  214.    break;
  215.   }
  216.  }
  217.  i = 0;
  218.  while( 1 ) {
  219.   Ser0UDCCR &= ~UDCCR_SUSIM;
  220.   udelay( i );
  221.   if ( ( Ser0UDCCR & UDCCR_SUSIM ) == 0
  222.    ||
  223.    (Ser0UDCSR & UDCSR_RSTIR)
  224.  )
  225.    break;
  226.   if ( ++i == 50 ) {
  227.    printk( "%senable_suspend(): Could not clear SUSIM %8.8Xn",
  228.    pszMe, Ser0UDCCR );
  229.    break;
  230.   }
  231.  }
  232. }
  235. //////////////////////////////////////////////////////////////////////////////
  236. // Public Interface
  237. //////////////////////////////////////////////////////////////////////////////
  239. /* Open SA usb core on behalf of a client, but don't start running */
  241. int
  242. sa1100_usb_open( const char * client )
  243. {
  244.  if ( usbd_info.client_name != NULL )
  245.   return -EBUSY;
  247.  usbd_info.client_name = (char*) client;
  248.  memset(&usbd_info.stats, 0, sizeof(struct usb_stats_t));
  249.  memset(string_desc_array, 0, sizeof(string_desc_array));
  251.  /* hack to start in zombie suspended state */
  252.  sm_state = kStateZombieSuspend;
  253.  usbd_info.state = USB_STATE_SUSPENDED;
  255.  /* create descriptors for enumeration */
  256.  initialize_descriptors();
  258.  printk( "%sOpened for %sn", pszMe, client );
  259.  return 0;
  260. }
  262. /* Start running. Must have called usb_open (above) first */
  263. int
  264. sa1100_usb_start( void )
  265. {
  266.  if ( usbd_info.client_name == NULL ) {
  267.   printk( "%s%s - no client registeredn",
  268.   pszMe, __FUNCTION__ );
  269.   return -EPERM;
  270.  }
  272.  /* start UDC internal machinery running */
  273.  udc_enable();
  274.  udelay( 100 );
  276.  /* clear stall - receiver seems to start stalled? 19Jan01ww */
  277.  /* also clear other stuff just to be thurough 22Feb01ww */
  278.  UDC_clear(Ser0UDCCS1, UDCCS1_FST | UDCCS1_RPE | UDCCS1_RPC );
  279.  UDC_clear(Ser0UDCCS2, UDCCS2_FST | UDCCS2_TPE | UDCCS2_TPC );
  281.  /* mask everything */
  282.  Ser0UDCCR = 0xFC;
  284.  /* flush DMA and fire through some -EAGAINs */
  285.  ep1_init( usbd_info.dmach_rx );
  286.  ep2_init( usbd_info.dmach_tx );
  288.  /* give endpoint notification we are starting */
  289.  ep1_state_change_notify( USB_STATE_SUSPENDED );
  290.  ep2_state_change_notify( USB_STATE_SUSPENDED );
  292.  /* enable any platform specific hardware */
  293.  soft_connect_hook( 1 );
  295. /* clear all top-level sources */
  296.  Ser0UDCSR = UDCSR_RSTIR | UDCSR_RESIR | UDCSR_EIR   |
  297.          UDCSR_RIR   | UDCSR_TIR   | UDCSR_SUSIR ;
  299.  /* EXERIMENT - a short line in the spec says toggling this
  300.   ..bit diddles the internal state machine in the udc to
  301.   ..expect a suspend */
  302.  Ser0UDCCR  |= UDCCR_RESIM;
  303.  /* END EXPERIMENT 10Feb01ww */
  305.  /* enable any platform specific hardware */
  306.  soft_connect_hook( 1 );
  308.  /* enable interrupts. If you are unplugged you will
  309.     immediately get a suspend interrupt. If you are plugged
  310.     and have a soft connect-circuit, you will get a reset
  311.         If you are plugged without a soft-connect, I think you
  312.     also get suspend. In short, start with suspend masked
  313.     and everything else enabled */
  314.  UDC_write( Ser0UDCCR, UDCCR_SUSIM );
  316.  printk( "%sStarted for %sn", pszMe, usbd_info.client_name );
  317.  return 0;
  318. }
  320. /* Stop USB core from running */
  321. int
  322. sa1100_usb_stop( void )
  323. {
  324.  if ( usbd_info.client_name == NULL ) {
  325.   printk( "%s%s - no client registeredn",
  326.   pszMe, __FUNCTION__ );
  327.   return -EPERM;
  328.  }
  329.  /* mask everything */
  330.  Ser0UDCCR = 0xFC;
  331.  ep1_reset();
  332.  ep2_reset();
  333.  udc_disable();
  334.  printk( "%sStoppedn", pszMe );
  335.  return 0;
  336. }
  338. /* Tell SA core client is through using it */
  339. int
  340. sa1100_usb_close( void )
  341. {
  342.  if ( usbd_info.client_name == NULL ) {
  343.   printk( "%s%s - no client registeredn",
  344.   pszMe, __FUNCTION__ );
  345.   return -EPERM;
  346.  }
  347.  usbd_info.client_name = NULL;
  348.  printk( "%sClosedn", pszMe );
  349.  return 0;
  350. }
  352. /* set a proc to be called when device is configured */
  353. usb_notify_t sa1100_set_configured_callback( usb_notify_t func )
  354. {
  355.  usb_notify_t retval = configured_callback;
  356.  configured_callback = func;
  357.  return retval;
  358. }
  360. /*====================================================
  361.  * Descriptor Manipulation.
  362.  * Use these between open() and start() above to setup
  363.  * the descriptors for your device.
  364.  *
  365.  */
  367. /* get pointer to static default descriptor */
  368. desc_t *
  369. sa1100_usb_get_descriptor_ptr( void ) { return &desc; }
  371. /* optional: set a string descriptor */
  372. int
  373. sa1100_usb_set_string_descriptor( int i, string_desc_t * p )
  374. {
  375.  int retval;
  376.  if ( i < MAX_STRING_DESC ) {
  377.   string_desc_array[i] = p;
  378.   retval = 0;
  379.  } else {
  380.   retval = -EINVAL;
  381.  }
  382.  return retval;
  383. }
  385. /* optional: get a previously set string descriptor */
  386. string_desc_t *
  387. sa1100_usb_get_string_descriptor( int i )
  388. {
  389.  return ( i < MAX_STRING_DESC )
  390.     ? string_desc_array[i]
  391.     : NULL;
  392. }
  395. /* optional: kmalloc and unicode up a string descriptor */
  396. string_desc_t *
  397. sa1100_usb_kmalloc_string_descriptor( const char * p )
  398. {
  399.  string_desc_t * pResult = NULL;
  401.  if ( p ) {
  402.   int len = strlen( p );
  403.   int uni_len = len * sizeof( __u16 );
  404.   pResult = (string_desc_t*) kmalloc( uni_len + 2, GFP_KERNEL ); /* ugh! */
  405.   if ( pResult != NULL ) {
  406.    int i;
  407.    pResult->bLength = uni_len + 2;
  408.    pResult->bDescriptorType = USB_DESC_STRING;
  409.    for( i = 0; i < len ; i++ ) {
  410. pResult->bString[i] = make_word( (__u16) p[i] );
  411.    }
  412.   }
  413.  }
  414.  return pResult;
  415. }
  417. //////////////////////////////////////////////////////////////////////////////
  418. // Exports to rest of driver
  419. //////////////////////////////////////////////////////////////////////////////
  421. /* called by the int handler here and the two endpoint files when interesting
  422.    .."events" happen */
  424. int
  425. usbctl_next_state_on_event( int event )
  426. {
  427. int next_state = device_state_machine[ sm_state ][ event ];
  428. if ( next_state != kError )
  429. {
  430. int next_device_state = sm_state_to_device_state[ next_state ];
  431. printk( "%s%s --> [%s] --> %s. Device in %s state.n",
  432. pszMe, state_names[ sm_state ], event_names[ event ],
  433. state_names[ next_state ], device_state_names[ next_device_state ] );
  435. sm_state = next_state;
  436. if ( usbd_info.state != next_device_state )
  437. {
  438. if ( configured_callback != NULL
  439.  &&
  440.  next_device_state == USB_STATE_CONFIGURED
  441.  &&
  442.  usbd_info.state != USB_STATE_SUSPENDED
  443.    ) {
  444.   configured_callback();
  445. }
  446. usbd_info.state = next_device_state;
  447. ep1_state_change_notify( next_device_state );
  448. ep2_state_change_notify( next_device_state );
  449. }
  450. }
  451. #if 0
  452. else
  453. printk( "%s%s --> [%s] --> ??? is an error.n",
  454. pszMe, state_names[ sm_state ], event_names[ event ] );
  455. #endif
  456. return next_state;
  457. }
  459. //////////////////////////////////////////////////////////////////////////////
  460. // Private Helpers
  461. //////////////////////////////////////////////////////////////////////////////
  463. /* setup default descriptors */
  465. static void
  466. initialize_descriptors(void)
  467. {
  468. desc.dev.bLength               = sizeof( device_desc_t );
  469. desc.dev.bDescriptorType       = USB_DESC_DEVICE;
  470. desc.dev.bcdUSB                = 0x100; /* 1.0 */
  471. desc.dev.bDeviceClass          = 0xFF; /* vendor specific */
  472. desc.dev.bDeviceSubClass       = 0;
  473. desc.dev.bDeviceProtocol       = 0;
  474. desc.dev.bMaxPacketSize0       = 8; /* ep0 max fifo size */
  475. desc.dev.idVendor              = 0; /* vendor ID undefined */
  476. desc.dev.idProduct             = 0; /* product */
  477. desc.dev.bcdDevice             = 0; /* vendor assigned device release num */
  478. desc.dev.iManufacturer         = 0; /* index of manufacturer string */
  479. desc.dev.iProduct              = 0; /* index of product description string */
  480. desc.dev.iSerialNumber         = 0; /* index of string holding product s/n */
  481. desc.dev.bNumConfigurations    = 1;
  483. desc.b.cfg.bLength             = sizeof( config_desc_t );
  484. desc.b.cfg.bDescriptorType     = USB_DESC_CONFIG;
  485. desc.b.cfg.wTotalLength        = make_word_c( sizeof(struct cdb) );
  486. desc.b.cfg.bNumInterfaces      = 1;
  487. desc.b.cfg.bConfigurationValue = 1;
  488. desc.b.cfg.iConfiguration      = 0;
  489. desc.b.cfg.bmAttributes        = USB_CONFIG_BUSPOWERED;
  490. desc.b.cfg.MaxPower            = USB_POWER( 500 );
  492. desc.b.intf.bLength            = sizeof( intf_desc_t );
  493. desc.b.intf.bDescriptorType    = USB_DESC_INTERFACE;
  494. desc.b.intf.bInterfaceNumber   = 0; /* unique intf index*/
  495. desc.b.intf.bAlternateSetting  = 0;
  496. desc.b.intf.bNumEndpoints      = 2;
  497. desc.b.intf.bInterfaceClass    = 0xFF; /* vendor specific */
  498. desc.b.intf.bInterfaceSubClass = 0;
  499. desc.b.intf.bInterfaceProtocol = 0;
  500. desc.b.intf.iInterface         = 0;
  502. desc.b.ep1.bLength             = sizeof( ep_desc_t );
  503. desc.b.ep1.bDescriptorType     = USB_DESC_ENDPOINT;
  504. desc.b.ep1.bEndpointAddress    = USB_EP_ADDRESS( 1, USB_OUT );
  505. desc.b.ep1.bmAttributes        = USB_EP_BULK;
  506. desc.b.ep1.wMaxPacketSize      = make_word_c( 64 );
  507. desc.b.ep1.bInterval           = 0;
  509. desc.b.ep2.bLength             = sizeof( ep_desc_t );
  510. desc.b.ep2.bDescriptorType     = USB_DESC_ENDPOINT;
  511. desc.b.ep2.bEndpointAddress    = USB_EP_ADDRESS( 2, USB_IN );
  512. desc.b.ep2.bmAttributes        = USB_EP_BULK;
  513. desc.b.ep2.wMaxPacketSize      = make_word_c( 64 );
  514. desc.b.ep2.bInterval           = 0;
  516. /* set language */
  517. /* See: http://www.usb.org/developers/data/USB_LANGIDs.pdf */
  518. sd_zero.bDescriptorType = USB_DESC_STRING;
  519. sd_zero.bLength         = sizeof( string_desc_t );
  520. sd_zero.bString[0]      = make_word_c( 0x409 ); /* American English */
  521. sa1100_usb_set_string_descriptor( 0, &sd_zero );
  522. }
  524. /* soft_connect_hook()
  525.  * Some devices have platform-specific circuitry to make USB
  526.  * not seem to be plugged in, even when it is. This allows
  527.  * software to control when a device 'appears' on the USB bus
  528.  * (after Linux has booted and this driver has loaded, for
  529.  * example). If you have such a circuit, control it here.
  530.  */
  531. static void
  532. soft_connect_hook( int enable )
  533. {
  534. #ifdef CONFIG_SA1100_EXTENEX1
  535.  if (machine_is_extenex1() ) {
  536.   if ( enable ) {
  537.    PPDR |= PPC_USB_SOFT_CON;
  538.    PPSR |= PPC_USB_SOFT_CON;
  539.   } else {
  540.    PPSR &= ~PPC_USB_SOFT_CON;
  541.    PPDR &= ~PPC_USB_SOFT_CON;
  542.   }
  543.  }
  544. #endif
  545. }
  547. /* disable the UDC at the source */
  548. static void
  549. udc_disable(void)
  550. {
  551. soft_connect_hook( 0 );
  552. UDC_set( Ser0UDCCR, UDCCR_UDD );
  553. }
  556. /*  enable the udc at the source */
  557. static void
  558. udc_enable(void)
  559. {
  560. UDC_clear(Ser0UDCCR, UDCCR_UDD);
  561. }
  563. // HACK DEBUG  3Mar01ww
  564. // Well, maybe not, it really seems to help!  08Mar01ww
  565. static void
  566. core_kicker( void )
  567. {
  568.  __u32 car = Ser0UDCAR;
  569.  __u32 imp = Ser0UDCIMP;
  570.  __u32 omp = Ser0UDCOMP;
  572.  UDC_set( Ser0UDCCR, UDCCR_UDD );
  573.  udelay( 300 );
  574.  UDC_clear(Ser0UDCCR, UDCCR_UDD);
  576.  Ser0UDCAR = car;
  577.  Ser0UDCIMP = imp;
  578.  Ser0UDCOMP = omp;
  579. }
  581. //////////////////////////////////////////////////////////////////////////////
  582. // Proc Filesystem Support
  583. //////////////////////////////////////////////////////////////////////////////
  585. #if CONFIG_PROC_FS
  587. #define SAY( fmt, args... )  p += sprintf(p, fmt, ## args )
  588. #define SAYV(  num )         p += sprintf(p, num_fmt, "Value", num )
  589. #define SAYC( label, yn )    p += sprintf(p, yn_fmt, label, yn )
  590. #define SAYS( label, v )     p += sprintf(p, cnt_fmt, label, v )
  592. static int usbctl_read_proc(char *page, char **start, off_t off,
  593.     int count, int *eof, void *data)
  594. {
  595.  const char * num_fmt   = "%25.25s: %8.8lXn";
  596.  const char * cnt_fmt   = "%25.25s: %lun";
  597.  const char * yn_fmt    = "%25.25s: %sn";
  598.  const char * yes       = "YES";
  599.  const char * no        = "NO";
  600.  unsigned long v;
  601.  char * p = page;
  602.  int len;
  604.    SAY( "SA1100 USB Controller Coren" );
  605.  SAY( "USB state: %s (%s) %dn",
  606.   device_state_names[ sm_state_to_device_state[ sm_state ] ],
  607.   state_names[ sm_state ],
  608.   sm_state );
  610.  SAYS( "ep0 bytes read", usbd_info.stats.ep0_bytes_read );
  611.  SAYS( "ep0 bytes written", usbd_info.stats.ep0_bytes_written );
  612.  SAYS( "ep0 FIFO read failures", usbd_info.stats.ep0_fifo_write_failures );
  613.  SAYS( "ep0 FIFO write failures", usbd_info.stats.ep0_fifo_write_failures );
  615.  SAY( "n" );
  617.  v = Ser0UDCAR;
  618.  SAY( "%25.25s: 0x%8.8lX - %ldn", "Address Register", v, v );
  619.  v = Ser0UDCIMP;
  620.  SAY( "%25.25s: %ld (%8.8lX)n", "IN  max packet size", v+1, v );
  621.  v = Ser0UDCOMP;
  622.  SAY( "%25.25s: %ld (%8.8lX)n", "OUT max packet size", v+1, v );
  624.  v = Ser0UDCCR;
  625.  SAY( "nUDC Mask Registern" );
  626.  SAYV( v );
  627.  SAYC( "UDC Active",                ( v & UDCCR_UDA ) ? yes : no );
  628.  SAYC( "Suspend interrupts masked", ( v & UDCCR_SUSIM ) ? yes : no );
  629.  SAYC( "Resume interrupts masked",  ( v & UDCCR_RESIM ) ? yes : no );
  630.  SAYC( "Reset interrupts masked",   ( v & UDCCR_REM ) ? yes : no );
  632.  v = Ser0UDCSR;
  633.  SAY( "nUDC Interrupt Request Registern" );
  634.  SAYV( v );
  635.  SAYC( "Reset pending",      ( v & UDCSR_RSTIR ) ? yes : no );
  636.  SAYC( "Suspend pending",    ( v & UDCSR_SUSIR ) ? yes : no );
  637.  SAYC( "Resume pending",     ( v & UDCSR_RESIR ) ? yes : no );
  638.  SAYC( "ep0 pending",        ( v & UDCSR_EIR )   ? yes : no );
  639.  SAYC( "receiver pending",   ( v & UDCSR_RIR )   ? yes : no );
  640.  SAYC( "tramsitter pending", ( v & UDCSR_TIR )   ? yes : no );
  642. #ifdef CONFIG_SA1100_EXTENEX1
  643.  SAYC( "nSoft connect", (PPSR & PPC_USB_SOFT_CON) ? "Visible" : "Hidden" );
  644. #endif
  646. #if 0
  647.  v = Ser0UDCCS0;
  648.  SAY( "nUDC Endpoint Zero Status Registern" );
  649.  SAYV( v );
  650.  SAYC( "Out Packet Ready", ( v & UDCCS0_OPR ) ? yes : no );
  651.  SAYC( "In Packet Ready",  ( v & UDCCS0_IPR ) ? yes : no );
  652.  SAYC( "Sent Stall",       ( v & UDCCS0_SST ) ? yes : no );
  653.  SAYC( "Force Stall",      ( v & UDCCS0_FST ) ? yes : no );
  654.  SAYC( "Data End",         ( v & UDCCS0_DE )  ? yes : no );
  655.  SAYC( "Data Setup End",   ( v & UDCCS0_SE )  ? yes : no );
  656.  SAYC( "Serviced (SO)",    ( v & UDCCS0_SO )  ? yes : no );
  658.  v = Ser0UDCCS1;
  659.  SAY( "nUDC Receiver Status Registern" );
  660.  SAYV( v );
  661.  SAYC( "Receive Packet Complete", ( v & UDCCS1_RPC ) ? yes : no );
  662.  SAYC( "Sent Stall",              ( v & UDCCS1_SST ) ? yes : no );
  663.  SAYC( "Force Stall",             ( v & UDCCS1_FST ) ? yes : no );
  664.  SAYC( "Receive Packet Error",    ( v & UDCCS1_RPE ) ? yes : no );
  665.  SAYC( "Receive FIFO not empty",  ( v & UDCCS1_RNE ) ? yes : no );
  667.  v = Ser0UDCCS2;
  668.  SAY( "nUDC Transmitter Status Registern" );
  669.  SAYV( v );
  670.  SAYC( "FIFO has < 8 of 16 chars", ( v & UDCCS2_TFS ) ? yes : no );
  671.  SAYC( "Transmit Packet Complete", ( v & UDCCS2_TPC ) ? yes : no );
  672.  SAYC( "Transmit FIFO underrun",   ( v & UDCCS2_TUR ) ? yes : no );
  673.  SAYC( "Transmit Packet Error",    ( v & UDCCS2_TPE ) ? yes : no );
  674.  SAYC( "Sent Stall",               ( v & UDCCS2_SST ) ? yes : no );
  675.  SAYC( "Force Stall",              ( v & UDCCS2_FST ) ? yes : no );
  676. #endif
  678.  len = ( p - page ) - off;
  679.  if ( len < 0 )
  680.   len = 0;
  681.  *eof = ( len <=count ) ? 1 : 0;
  682.  *start = page + off;
  683.  return len;
  684. }
  686. #endif  /* CONFIG_PROC_FS */
  688. //////////////////////////////////////////////////////////////////////////////
  689. // Module Initialization and Shutdown
  690. //////////////////////////////////////////////////////////////////////////////
  691. /*
  692.  * usbctl_init()
  693.  * Module load time. Allocate dma and interrupt resources. Setup /proc fs
  694.  * entry. Leave UDC disabled.
  695.  */
  696. int __init usbctl_init( void )
  697. {
  698. int retval = 0;
  700. udc_disable();
  702. memset( &usbd_info, 0, sizeof( usbd_info ) );
  704. #if CONFIG_PROC_FS
  705. create_proc_read_entry ( PROC_NODE_NAME, 0, NULL, usbctl_read_proc, NULL);
  706. #endif
  708. /* setup rx dma */
  709. retval = sa1100_request_dma(&usbd_info.dmach_rx, "USB receive", DMA_Ser0UDCRd);
  710. if (retval) {
  711. printk("%sunable to register for rx dma rc=%dn", pszMe, retval );
  712. goto err_rx_dma;
  713. }
  715. /* setup tx dma */
  716. retval = sa1100_request_dma(&usbd_info.dmach_tx, "USB transmit", DMA_Ser0UDCWr);
  717. if (retval) {
  718. printk("%sunable to register for tx dma rc=%dn",pszMe,retval);
  719. goto err_tx_dma;
  720. }
  722. /* now allocate the IRQ. */
  723. retval = request_irq(IRQ_Ser0UDC, udc_int_hndlr, SA_INTERRUPT,
  724.   "SA USB core", NULL);
  725. if (retval) {
  726. printk("%sCouldn't request USB irq rc=%dn",pszMe, retval);
  727. goto err_irq;
  728. }
  730. printk( "SA1100 USB Controller Core Initializedn");
  731. return 0;
  733. err_irq:
  734. sa1100_free_dma(usbd_info.dmach_tx);
  735. usbd_info.dmach_tx = 0;
  736. err_tx_dma:
  737. sa1100_free_dma(usbd_info.dmach_rx);
  738. usbd_info.dmach_rx = 0;
  739. err_rx_dma:
  740. return retval;
  741. }
  742. /*
  743.  * usbctl_exit()
  744.  * Release DMA and interrupt resources
  745.  */
  746. void __exit usbctl_exit( void )
  747. {
  748.     printk("Unloading SA1100 USB Controllern");
  750. udc_disable();
  752. #if CONFIG_PROC_FS
  753.     remove_proc_entry ( PROC_NODE_NAME, NULL);
  754. #endif
  756.     sa1100_free_dma(usbd_info.dmach_rx);
  757.     sa1100_free_dma(usbd_info.dmach_tx);
  758.     free_irq(IRQ_Ser0UDC, NULL);
  759. }
  761. EXPORT_SYMBOL( sa1100_usb_open );
  762. EXPORT_SYMBOL( sa1100_usb_start );
  763. EXPORT_SYMBOL( sa1100_usb_stop );
  764. EXPORT_SYMBOL( sa1100_usb_close );
  767. EXPORT_SYMBOL( sa1100_usb_get_descriptor_ptr );
  768. EXPORT_SYMBOL( sa1100_usb_set_string_descriptor );
  769. EXPORT_SYMBOL( sa1100_usb_get_string_descriptor );
  770. EXPORT_SYMBOL( sa1100_usb_kmalloc_string_descriptor );
  773. module_init( usbctl_init );
  774. module_exit( usbctl_exit );