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

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

嵌入式Linux

开发平台：

Unix_Linux

usb_ctl.c：源码内容
  1. /*
  2.  *  This program is derived from Extenex Corporation's SA-1100 usb
  3.  *  controller core driver by MIZI.
  4.  * 
  5.  *  usb_ctl.c
  6.  *
  7.  *  S3C2410 USB controller core driver.
  8.  *
  9.  *  This file provides interrupt routing and overall coordination
  10.  *  of the five endpoints.
  11.  *  
  12.  *  Seungbum Lim <shawn@mizi.com>
  13.  */
  15. /*
  16.  * ep0 - register
  17.  * ep2~4 - dual port async. RAM (interrupt or DMA)
  18.  *
  19.  * config:
  20.  *  ep0.
  21.  *  ep2 : input - DMA_CH0 ?
  22.  *  ep1 : output - DMA_CH3 ?
  23.  */
  25. #include <linux/config.h>
  26. #include <linux/module.h>
  27. #include <linux/init.h>
  28. #include <linux/proc_fs.h>
  29. #include <linux/tqueue.h>
  30. #include <linux/delay.h>
  31. #include <linux/slab.h>
  32. #include <linux/pci.h>
  33. #include <asm/io.h>
  34. #include <asm/dma.h>
  35. #include <asm/irq.h>
  36. #include <asm/mach-types.h>
  38. #include "s3c2410_usb.h"
  39. #include "usb_ctl.h"
  41. //////////////////////////////////////////////////////////////////////////////
  42. // Prototypes
  43. //////////////////////////////////////////////////////////////////////////////
  44. int usbctl_next_state_on_event( int event );
  45. static void udc_int_hndlr(int, void *, struct pt_regs *);
  46. static void initialize_descriptors( void );
  47. void ChangeUPllValue(int mdiv, int pdiv, int sdiv);
  48. void reset_usbd(void);
  49. void reconfig_usbd(void);
  50. //#define USB_DEBUG 1
  52. #ifdef USB_DEBUG
  53. #define LOG(arg...) printk(__FILE__":"__FUNCTION__"(): " ##arg)
  54. #else
  55. #define LOG(arg...) (void)(0)
  56. #endif
  58. #if CONFIG_PROC_FS
  59. #define PROC_NODE_NAME "usb"
  60. static int usbctl_read_proc(char *page, char **start, off_t off,
  61. int count, int *eof, void *data);
  62. #endif
  64. //////////////////////////////////////////////////////////////////////////////
  65. // Globals
  66. //////////////////////////////////////////////////////////////////////////////
  67. static const char pszMe[] = "usbctl: ";
  68. struct usb_info_t usbd_info;  /* global to ep0, usb_recv, usb_send */
  69. //static int cnt=0;
  72. /* device descriptors */
  73. static desc_t desc;
  75. #define MAX_STRING_DESC 8
  76. static string_desc_t * string_desc_array[ MAX_STRING_DESC ];
  77. static string_desc_t sd_zero;  /* special sd_zero holds language codes */
  79. // called when configured
  80. static usb_notify_t configured_callback = NULL;
  82. enum { kStateZombie  = 0,  kStateZombieSuspend  = 1,
  83. kStateDefault = 2,  kStateDefaultSuspend = 3,
  84. kStateAddr    = 4,  kStateAddrSuspend    = 5,
  85. kStateConfig  = 6,  kStateConfigSuspend  = 7
  86. };
  88. static int device_state_machine[8][6] = {
  89. //                suspend               reset          resume     adddr config deconfig
  90. /* zombie */  {  kStateZombieSuspend,  kStateDefault, kError,    kError, kError, kError },
  91. /* zom sus */ {  kError, kStateDefault, kStateZombie, kError, kError, kError },
  92. /* default */ {  kStateDefaultSuspend, kError, kStateDefault, kStateAddr, kError, kError },
  93. /* def sus */ {  kError, kStateDefault, kStateDefault, kError, kError, kError },
  94. /* addr */    {  kStateAddrSuspend, kStateDefault, kError, kError, kStateConfig, kError },
  95. /* addr sus */{  kError, kStateDefault, kStateAddr, kError, kError, kError },
  96. /* config */  {  kStateConfigSuspend, kStateDefault, kError, kError, kError, kStateAddr },
  97. /* cfg sus */ {  kError, kStateDefault, kStateConfig, kError, kError, kError }
  98. };
  100. /* "device state" is the usb device framework state, as opposed to the
  101.    "state machine state" which is whatever the driver needs and is much
  102.    more fine grained
  103. */
  104. static int sm_state_to_device_state[8] =
  105. //  zombie           zom suspend          default            default sus
  106. { USB_STATE_POWERED, USB_STATE_SUSPENDED, USB_STATE_DEFAULT, USB_STATE_SUSPENDED,
  107. // addr              addr sus             config                config sus
  108.   USB_STATE_ADDRESS, USB_STATE_SUSPENDED, USB_STATE_CONFIGURED, USB_STATE_SUSPENDED
  109. };
  111. static char * state_names[8] =
  112. { "zombie", "zombie suspended", "default", "default suspended",
  113.   "address", "address suspended", "configured", "config suspended"
  114. };
  116. static char * event_names[6] =
  117. { "suspend", "reset", "resume",
  118.   "address assigned", "configure", "de-configure"
  119. };
  121. static char * device_state_names[] =
  122. { "not attached", "attached", "powered", "default",
  123.   "address", "configured", "suspended" };
  125. static int sm_state = kStateZombie;
  127. //////////////////////////////////////////////////////////////////////////////
  128. // Reset Fucntions
  129. //////////////////////////////////////////////////////////////////////////////
  131. void reset_usbd(void)
  132. {
  133.     int i;
  135.     UD_PWR = UD_PWR_DEFAULT | UD_PWR_RESET; /* UD_PWR default value, MCU_RESET */
  136.     UD_PWR;
  137.     UD_PWR = UD_PWR_DEFAULT;
  139. LOG("UD_PWR = 0x%08xn", UD_PWR);
  141.     for(i = 0; i< 0x100; i++) ;
  142. }
  145. void reconfig_usbd(void)
  146. {
  148. LOG("n");
  150.     /* sec like, shawn */
  151.     ep0_state = EP0_STATE_IDLE;
  152.     set_configuration = 1;
  153.     set_interface = 1;
  154.     device_status = 0;
  155.     ep0_status = 0;
  156.     ep_bulk_in_status = 0;
  157.     ep_bulk_out_status = 0;
  158.     
  159.         UD_PWR = UD_PWR_DEFAULT;
  160.         /* EP0 */
  161. UD_INDEX = UD_INDEX_EP0;       
  162. UD_MAXP = UD_MAXP_8; // 8 byte
  163. UD_INDEX = UD_INDEX_EP0;
  164. UD_ICSR1 = EP0_CSR_SOPKTRDY | EP0_CSR_SSE;
  165.         /* EP2 */
  166. UD_INDEX = UD_INDEX_EP2;           
  167. UD_MAXP = UD_MAXP_64; // 64 byte
  168. UD_INDEX = UD_INDEX_EP2;
  169. UD_ICSR1 = UD_ICSR1_FFLUSH | UD_ICSR1_CLRDT; // fifo flush, data toggle
  170. UD_INDEX = UD_INDEX_EP2;
  171. UD_ICSR2 = UD_ICSR2_MODEIN | UD_ICSR2_DMAIEN; // input mode, IN_PKT_RDY dis 
  172. #ifdef USE_USBD_DMA
  173. UD_ICSR2 &= ~UD_ICSR2_DMAIEN;
  174. #endif
  176. /* EP1 */
  177. UD_INDEX = UD_INDEX_EP1;            
  178. UD_MAXP = UD_MAXP_64; // 64 byte
  179. UD_INDEX = UD_INDEX_EP1;
  180. UD_ICSR1 = UD_ICSR1_FFLUSH | UD_ICSR1_CLRDT; // fifo flush, data toggle
  181. UD_INDEX = UD_INDEX_EP1;
  182. UD_ICSR2 = 0x0; // output mode
  183. UD_INDEX = UD_INDEX_EP1;
  184. UD_OCSR1 = UD_OCSR1_FFLUSH | UD_OCSR1_CLRDT; // fifo flush
  185. UD_INDEX = UD_INDEX_EP1;
  186. UD_OCSR2 = UD_OCSR2_DMAIEN; // OUT_PKT_RDY interrupt disable
  187. #ifdef USE_USBD_DMA
  188. UD_OCSR2 &= ~UD_OCSR2_DMAIEN; // OUT_PKT_RDY interrupt disable
  189. #endif
  191. UD_INTE = UD_INTE_EP0 | UD_INTE_EP2 | UD_INTE_EP1;
  192. UD_USBINTE = UD_USBINTE_RESET | UD_USBINTE_SUSPND;
  194.         initialize_descriptors();
  195.    bINTCTL(oINTMSK) &= ~(INT_USBD);
  196. }
  197.     
  199. static void
  200. udc_int_hndlr(int irq, void *dev_id, struct pt_regs *regs)
  201. {
  202.    __u8 saveIdx = UD_INDEX;
  203.      __u8 usb_status = UD_USBINT;
  204.    __u8 usbd_status = UD_INT;
  205. static int sb_debug_cnt = 1;
  207. LOG("usb_status = 0x%02x, usbd_status = 0x%02xn",
  208. usb_status, usbd_status);
  210. if ( usb_status & UD_USBINT_RESET ) {
  212.     LOG("n[%d]RESET interruptn",sb_debug_cnt++);
  213.     if( usbctl_next_state_on_event(kEvReset) != kError ) {
  214. LOG("%s Resettingn",pszMe);
  216. ep0_reset();
  217. ep1_reset();/* output */
  218. ep2_reset();/* input */
  220.     }
  222.    // reset_usbd();
  223.     reconfig_usbd();
  224.     UD_USBINT = UD_USBINT_RESET; //RESET_INT should be cleared after reconfig_usbd().- by samsung src
  225.     ep0_state = EP0_STATE_IDLE;
  227. }
  230. /* RESume Interrupt Request */
  231. if ( usb_status & UD_USBINT_RESUM ) {
  232.   LOG("[%d]RESUME interruptn", sb_debug_cnt++);
  233. UD_USBINT = UD_USBINT_RESUM;/* clear */
  234. usbctl_next_state_on_event( kEvResume );
  236. }
  239. /* SUSpend Interrupt Request */
  240. if ( usb_status & UD_USBINT_SUSPND ) { 
  241. LOG("[%d]SUSPEND interruptn", sb_debug_cnt++);
  242. UD_USBINT = UD_USBINT_SUSPND; /* clear */
  243. usbctl_next_state_on_event( kEvSuspend );
  245. }
  247. if ( usbd_status & UD_INT_EP0 ) {
  248. LOG("n[%d]EP0 interruptn",sb_debug_cnt++);
  249. UD_INT = UD_INT_EP0; /* clear */
  250. ep0_int_hndlr();
  252. }
  254.          /* output */
  255. if ( usbd_status & UD_INT_EP1 ) { 
  256. LOG("[%d]EP1 interruptn", sb_debug_cnt++);
  257. UD_INT = UD_INT_EP1;/* clear */
  258. ep1_int_hndlr(usbd_status);
  260. }
  261.         /* input */
  262. if ( usbd_status & UD_INT_EP2 ) {
  263. LOG("[%d]EP2 interruptn", sb_debug_cnt++); 
  264. UD_INT = UD_INT_EP2; /* clear */
  265. ep2_int_hndlr(usbd_status);
  267. }
  269. if(usbd_status & UD_INT_EP3) UD_INT = UD_INT_EP3;
  270. if(usbd_status & UD_INT_EP4) UD_INT = UD_INT_EP4;
  272.    Clear_pending(INT_USBD);
  273. UD_INDEX= saveIdx;
  275. }
  279. //////////////////////////////////////////////////////////////////////////////
  280. // Public Interface
  281. //////////////////////////////////////////////////////////////////////////////
  283. /* Open S3C2410 usb core on behalf of a client, but don't start running */
  285. int
  286. s3c2410_usb_open( const char * client )
  287. {
  289. LOG("n");
  291.  if ( usbd_info.client_name != NULL )
  292.   return -EBUSY;
  294.  usbd_info.client_name = (char*) client;
  295.  memset(&usbd_info.stats, 0, sizeof(struct usb_stats_t));
  296.  memset(string_desc_array, 0, sizeof(string_desc_array));
  298.  /* hack to start in zombie suspended state */
  299. #if 0
  300.  sm_state = kStateZombieSuspend;
  301.  usbd_info.state = USB_STATE_SUSPENDED;
  302. #endif
  304.  /* create descriptors for enumeration */
  305.  initialize_descriptors();
  307.  printk( "%sOpened for %sn", pszMe, client );
  308.  return 0;
  309. }
  311. /* Start running. Must have called usb_open (above) first */
  312. int
  313. s3c2410_usb_start( void )
  314. {
  315. unsigned long tmp;
  317. LOG("n");
  319.  if ( usbd_info.client_name == NULL ) {
  320.   printk( "%s%s - no client registeredn",
  321.   pszMe, __FUNCTION__ );
  322.   return -EPERM;
  323.  }
  325.  /* start UDC internal machinery running */
  326.  udelay( 100 );
  328.  /* clear stall - receiver seems to start stalled? */
  329. UD_INDEX = UD_INDEX_EP2; // EP2 input 
  330. tmp = UD_ICSR1; 
  331. tmp &= ~(UD_ICSR1_SENTSTL | UD_ICSR1_FFLUSH | UD_ICSR1_UNDRUN);
  332.         tmp &= ~(UD_ICSR1_PKTRDY | UD_ICSR1_SENDSTL);
  333. UD_ICSR1 = tmp;
  335. UD_INDEX = UD_INDEX_EP1; // EP1 output
  336. tmp = UD_OCSR1;
  337. tmp &= ~(UD_OCSR1_SENTSTL | UD_OCSR1_FFLUSH | UD_OCSR1_OVRRUN);
  338. tmp &= ~(UD_OCSR1_PKTRDY | UD_OCSR1_SENDSTL);
  339. UD_OCSR1 = tmp;
  342. /* flush DMA and fire through some -EAGAINs */
  343. ep2_init( usbd_info.dmach_tx );
  344. ep1_init( usbd_info.dmach_rx );
  347. /* clear all top-level sources */
  348. UD_INT = UD_INT_EP0 | UD_INT_EP1 | UD_INT_EP2;
  349. UD_USBINT = UD_USBINT_RESET | UD_USBINT_RESUM | UD_USBINT_SUSPND;
  351. printk( "%sStarted for %sn", pszMe, usbd_info.client_name );
  352. return 0;
  353. }
  355. /* Stop USB core from running */
  356. int
  357. s3c2410_usb_stop( void )
  358. {
  359. LOG("name=%sn", usbd_info.client_name ? usbd_info.client_name : "NULL");
  360.  if ( usbd_info.client_name == NULL ) {
  361.   printk( "%s%s - no client registeredn",
  362.   pszMe, __FUNCTION__ );
  363.   return -EPERM;
  364.  }
  365. #if 0
  366.  /* It may be default value of S3C2410 USBD and makes only RESET be enalble*/
  367.  UD_INTM = 0x13f;
  368. #endif
  369.  ep1_reset(); 
  370.  ep2_reset();
  371.  printk( "%sStopped n", pszMe );
  372.  return 0;
  373. }
  375. /* Tell S3C2410 core client is through using it */
  376. int
  377. s3c2410_usb_close( void )
  378. {
  379.  if ( usbd_info.client_name == NULL ) {
  380.   printk( "%s%s - no client registeredn",
  381.   pszMe, __FUNCTION__ );
  382.   return -EPERM;
  383.  }
  384.  usbd_info.client_name = NULL;
  385.  return 0;
  386. }
  388. /* set a proc to be called when device is configured */
  389. usb_notify_t s3c2410_set_configured_callback( usb_notify_t func )
  390. {
  391.  usb_notify_t retval = configured_callback;
  393. LOG("n");
  395.  configured_callback = func;
  396.  return retval;
  397. }
  399. /*====================================================
  400.  * Descriptor Manipulation.
  401.  * Use these between open() and start() above to setup
  402.  * the descriptors for your device.
  403.  *
  404.  */
  406. /* get pointer to static default descriptor */
  407. desc_t *
  408. s3c2410_usb_get_descriptor_ptr( void ) { return &desc; }
  410. /* optional: set a string descriptor */
  411. int
  412. s3c2410_usb_set_string_descriptor( int i, string_desc_t * p )
  413. {
  414.  int retval;
  416.  LOG("n");
  418.  if ( i < MAX_STRING_DESC ) {
  419.   string_desc_array[i] = p;
  420.   retval = 0;
  421.  } else {
  422.   retval = -EINVAL;
  423.  }
  424.  return retval;
  425. }
  427. /* optional: get a previously set string descriptor */
  428. string_desc_t *
  429. s3c2410_usb_get_string_descriptor( int i )
  430. {
  431. LOG("n");
  433.  return ( i < MAX_STRING_DESC )
  434.     ? string_desc_array[i]
  435.     : NULL;
  436. }
  439. /* optional: kmalloc and unicode up a string descriptor */
  440. string_desc_t *
  441. s3c2410_usb_kmalloc_string_descriptor( const char * p )
  442. {
  443.  string_desc_t * pResult = NULL;
  445.  LOG("n");
  447.  if ( p ) {
  448.   int len = strlen( p );
  449.   int uni_len = len * sizeof( __u16 );
  450.   pResult = (string_desc_t*) kmalloc( uni_len + 2, GFP_KERNEL ); /* ugh! */
  451.   if ( pResult != NULL ) {
  452.    int i;
  453.    pResult->bLength = uni_len + 2;
  454.    pResult->bDescriptorType = USB_DESC_STRING;
  455.    for( i = 0; i < len ; i++ ) {
  456. pResult->bString[i] = make_word( (__u16) p[i] );
  457.    }
  458.   }
  459.  }
  460.  return pResult;
  461. }
  463. //////////////////////////////////////////////////////////////////////////////
  464. // Exports to rest of driver
  465. //////////////////////////////////////////////////////////////////////////////
  467. /* called by the int handler here and the two endpoint files when interesting
  468.    .."events" happen */
  470. int
  471. usbctl_next_state_on_event( int event )
  472. {
  473. int next_state = device_state_machine[ sm_state ][ event ];
  475. LOG("n");
  477. if ( next_state != kError )
  478. {
  479. int next_device_state = sm_state_to_device_state[ next_state ];
  480. printk( "%s%s --> [%s] --> %s. Device in %s state.n",
  481. pszMe, state_names[ sm_state ], event_names[ event ],
  482. state_names[ next_state ], device_state_names[ next_device_state ] );
  484. sm_state = next_state;
  485. if ( usbd_info.state != next_device_state )
  486. {
  487. if ( configured_callback != NULL
  488.  &&
  489.  next_device_state == USB_STATE_CONFIGURED
  490.  &&
  491.  usbd_info.state != USB_STATE_SUSPENDED
  492.    ) {
  493.   configured_callback();
  494. }
  495. usbd_info.state = next_device_state;
  496. }
  497. }
  498. #if 0
  499. else
  500. printk( "%s%s --> [%s] --> ??? is an error.n",
  501. pszMe, state_names[ sm_state ], event_names[ event ] );
  502. #endif
  503. return next_state;
  504. }
  506. //////////////////////////////////////////////////////////////////////////////
  507. // Private Helpers
  508. //////////////////////////////////////////////////////////////////////////////
  510. //* setup default descriptors */
  512. static void
  513. initialize_descriptors(void)
  514. {
  515. LOG("n");
  517. desc.dev.bLength               = sizeof( device_desc_t );
  518. desc.dev.bDescriptorType       = USB_DESC_DEVICE;
  519. desc.dev.bcdUSB                = 0x100; /* 1.1 */
  520. desc.dev.bDeviceClass          = 0xFF; /* vendor specific */
  521. desc.dev.bDeviceSubClass       = 0x0;
  522. desc.dev.bDeviceProtocol       = 0x0;
  523. desc.dev.bMaxPacketSize0       = 0x8; /* ep0 max fifo size in s3c2410*/
  524. desc.dev.idVendor              = 0x49f; /* vendor ID undefined */
  525. desc.dev.idProduct             = 0x505a; /* product */
  526. desc.dev.bcdDevice             = 0x01 ; /* vendor assigned device release num */
  527. desc.dev.iManufacturer         = 0; /* index of manufacturer string */
  528. desc.dev.iProduct              = 0; /* index of product description string */
  529. desc.dev.iSerialNumber         = 0; /* index of string holding product s/n */
  530. desc.dev.bNumConfigurations    = 0x1;
  532. desc.b.cfg.bLength             = sizeof( config_desc_t );
  533. desc.b.cfg.bDescriptorType     = USB_DESC_CONFIG;
  534. desc.b.cfg.wTotalLength        = make_word_c( sizeof(struct cdb) );
  535. desc.b.cfg.bNumInterfaces      = 1;
  536. desc.b.cfg.bConfigurationValue = 1;
  537. desc.b.cfg.iConfiguration      = 0;
  538. desc.b.cfg.bmAttributes        = USB_CONFIG_BUSPOWERED;
  539. desc.b.cfg.MaxPower            = USB_POWER( 500 );
  541. desc.b.intf.bLength            = sizeof( intf_desc_t );
  542. desc.b.intf.bDescriptorType    = USB_DESC_INTERFACE;
  543. desc.b.intf.bInterfaceNumber   = 0x0; /* unique intf index*/
  544. desc.b.intf.bAlternateSetting  = 0x0;
  545. desc.b.intf.bNumEndpoints      = 2; /* endpoint number excluding ep0 */
  546. desc.b.intf.bInterfaceClass    = 0xFF; /* vendor specific */
  547. desc.b.intf.bInterfaceSubClass = 0x0;
  548. desc.b.intf.bInterfaceProtocol = 0x0;
  549. desc.b.intf.iInterface         = 0x0;
  551. desc.b.ep1.bLength             = sizeof( ep_desc_t );
  552.         desc.b.ep1.bDescriptorType     = USB_DESC_ENDPOINT;
  553.         desc.b.ep1.bEndpointAddress    = USB_EP_ADDRESS( 1, USB_OUT );
  554.         desc.b.ep1.bmAttributes        = USB_EP_BULK;
  555.         desc.b.ep1.wMaxPacketSize      = make_word_c( 64 );
  556.         desc.b.ep1.bInterval        = 0x0;
  558. desc.b.ep2.bLength             = sizeof( ep_desc_t );
  559. desc.b.ep2.bDescriptorType     = USB_DESC_ENDPOINT;
  560. desc.b.ep2.bEndpointAddress    = USB_EP_ADDRESS( 2, USB_IN );
  561. desc.b.ep2.bmAttributes        = USB_EP_BULK;
  562. desc.b.ep2.wMaxPacketSize      = make_word_c( 64 );
  563. desc.b.ep2.bInterval           = 0x0;
  565. /* set language */
  566. /* See: http://www.usb.org/developers/data/USB_LANGIDs.pdf */
  567. sd_zero.bDescriptorType = USB_DESC_STRING;
  568. sd_zero.bLength         = sizeof( string_desc_t );
  569. sd_zero.bString[0]      = make_word_c( 0x409 ); /* American English */
  570. s3c2410_usb_set_string_descriptor( 0, &sd_zero );
  571. }
  575. //////////////////////////////////////////////////////////////////////////////
  576. // Proc Filesystem Support
  577. //////////////////////////////////////////////////////////////////////////////
  579. #if CONFIG_PROC_FS
  580. #define SAY( fmt, args... )  p += sprintf(p, fmt, ## args )
  581. #define SAYV(  num )         p += sprintf(p, num_fmt, "Value", num )
  582. #define SAYC( label, yn )    p += sprintf(p, yn_fmt, label, yn )
  583. #define SAYS( label, v )     p += sprintf(p, cnt_fmt, label, v )
  585. static int usbctl_read_proc(char *page, char **start, off_t off,
  586.     int count, int *eof, void *data)
  587. {
  588. const char * num_fmt   = "%25.25s: %8.8lXn";
  589. const char * cnt_fmt   = "%25.25s: %lun";
  590. const char * yn_fmt    = "%25.25s: %sn";
  591. const char * yes       = "YES";
  592. const char * no        = "NO";
  593. const char * mask      = "MASK";
  594. const char * enable    = "ENABLE";
  595. unsigned long v;
  596. unsigned long backup;
  597. char * p = page;
  598. int len;
  600. SAY( "S3C2410 USB Controller Coren" );
  601. SAY( "USB state: %s (%s) %dn",
  602. device_state_names[ sm_state_to_device_state[ sm_state ] ],
  603. state_names[ sm_state ],
  604. sm_state );
  606. SAYS( "ep0 bytes read", usbd_info.stats.ep0_bytes_read );
  607. SAYS( "ep0 bytes written", usbd_info.stats.ep0_bytes_written );
  608. SAYS( "ep0 FIFO read failures", usbd_info.stats.ep0_fifo_write_failures );
  609. SAYS( "ep0 FIFO write failures", usbd_info.stats.ep0_fifo_write_failures );
  610.  
  611. v = UD_FIFO0;
  612. SAY( "%25.25s: 0x%8.8lX - %ldn", "EP_FIFO0", v, v );
  614.  
  615. SAY( "n" );
  617. v = UD_FUNC;
  618. SAY( "%25.25s: 0x%8.8lX - %ldn", "Address Register", v, v );
  620. backup = UD_INDEX;
  622. UD_INDEX = UD_INDEX_EP0;
  623. v = UD_MAXP;
  624. SAY( "%25.25s: %ld (%8.8lX)n", "EP0 size(EP0)", v, v );
  625.  
  626. UD_INDEX = UD_INDEX_EP2;
  627. v = UD_MAXP;
  628. SAY( "%25.25s: %ld (%8.8lX)n", "IN  max packet size(EP2)", v, v );
  629. UD_INDEX = UD_INDEX_EP1;
  630. v = UD_MAXP;
  631. SAY( "%25.25s: %ld (%8.8lX)n", "OUT max packet size(EP1)", v, v );
  633. UD_INDEX = backup;
  636. v = UD_PWR;
  637. SAY( "nUDC POWER Management Registern" );
  638. SAYV( v );
  639. SAYC( "ISO Update(R)",    ( v & UD_PWR_ISOUP )     ? yes : no );
  640. SAYC( "USB Reset(R)",   ( v & UD_PWR_RESET ) ? yes : no );
  641. SAYC( "MCU Resume(RW)",  ( v & UD_PWR_RESUME  ) ? yes : no );
  642. SAYC( "Suspend Mode(R)",( v & UD_PWR_SUSPND ) ? yes : no );
  643. SAYC( "Suspend Mode enable bit(RW)",  ( v & UD_PWR_ENSUSPND ) ? yes : no );
  644.  
  645.  
  646. v = UD_INT;
  647. SAY( "nUDC Interrupt Registern" );
  648. SAYV( v );
  649. SAYC( "EP4 pending",        ( v & UD_INT_EP4 )     ? yes : no );
  650. SAYC( "EP3 pending",        ( v & UD_INT_EP3 )     ? yes : no );
  651. SAYC( "EP2 pending",        ( v & UD_INT_EP2 )     ? yes : no );
  652. SAYC( "EP1 pending",        ( v & UD_INT_EP1 )     ? yes : no );
  653. SAYC( "EP0 pending",        ( v & UD_INT_EP0 )     ? yes : no );
  655. v = UD_USBINT;
  656. SAY( "nUSB Interrupt Registern" );
  657. SAYV( v );
  658. SAYC( "Reset",        ( v & UD_USBINT_RESET )     ? yes : no );
  659. SAYC( "Resume",        ( v & UD_USBINT_RESUM )     ? yes : no );
  660. SAYC( "Suspend",        ( v & UD_USBINT_SUSPND )     ? yes : no );
  662. v = UD_INTE;
  663. SAY( "nUDC Interrupt Enable Registern" );
  664. SAYV( v );
  665. SAYC( "EP4",                !( v & UD_INTE_EP4 )    ? mask : enable );
  666. SAYC( "EP3",                !( v & UD_INTE_EP3 )    ? mask : enable );
  667. SAYC( "EP2",                !( v & UD_INTE_EP2 )    ? mask : enable );
  668. SAYC( "EP1",                !( v & UD_INTE_EP1 )    ? mask : enable );
  669. SAYC( "EP0",                !( v & UD_INTE_EP0 )    ? mask : enable );
  671. v = UD_USBINTE;
  672. SAY( "nUSB Interrupt Enable Registern" );
  673. SAYV( v );
  674. SAYC( "Reset",              !( v & UD_USBINTE_RESET )    ? mask : enable );
  675. SAYC( "Suspend",            !( v & UD_USBINTE_SUSPND )  ? mask : enable );
  677. len = ( p - page ) - off;
  678. if ( len < 0 )
  679.      len = 0;
  680. *eof = ( len <=count ) ? 1 : 0;
  681. *start = page + off;
  682. return len;
  683. }
  684. #endif  /* CONFIG_PROC_FS */
  686. #if defined(CONFIG_PM) && defined(CONFIG_MIZI)
  687. void usbctl_suspend(void)
  688. {
  689. /* TODO: FIXME: */
  690. }
  692. void usbctl_resume(void)
  693. {
  694. /* TODO: FIXME: */
  695. }
  696. #endif
  699. //////////////////////////////////////////////////////////////////////////////
  700. // Module Initialization and Shutdown
  701. //////////////////////////////////////////////////////////////////////////////
  702. /*
  703.  * usbctl_init()
  704.  * Module load time. Allocate dma and interrupt resources. Setup /proc fs
  705.  * entry. Leave UDC disabled.
  706.  */
  707. int __init usbctl_init( void )
  708. {
  709. int retval = 0;
  711. #if CONFIG_MAX_ROOT_PORTS > 1
  712. printk("check your kernel config.n");
  713. return -ENODEV;
  714. #endif
  716. memset( &usbd_info, 0, sizeof( usbd_info ) );
  718. usbd_info.dmach_tx = DMA_CH3; // ep1
  719. usbd_info.dmach_rx = DMA_CH0; // ep2
  721. #if CONFIG_PROC_FS
  722. create_proc_read_entry ( PROC_NODE_NAME, 0, NULL, usbctl_read_proc, NULL);
  723. #endif
  725. #ifdef USE_USBD_DMA
  726. lsdkjflsdkjsdlkjflksdjf
  727. /* setup dma */
  728. #if 1
  729. retval = s3c2410_request_dma("USB", DMA_CH0, 
  730.  ep1_dma_callback, NULL);
  731. if (retval) {
  732. printk("%sunable to register for dma rc=%dn", pszMe, retval);
  733. goto err_dma;
  734. }
  736. retval = s3c2410_request_dma("USB", DMA_CH2, 
  737.  NULL, ep2_dma_callback);
  738. if (retval) {
  739. printk("%sunable to register for dma rc=%dn", pszMe, retval);
  740. goto err_dma;
  741. }
  742. #else
  743. retval = s3c2410_request_dma("USB", DMA_CH0, 
  744.  ep1_dma_callback, ep2_dma_callback);
  745. if (retval) {
  746. printk("%sunable to register for dma rc=%dn", pszMe, retval);
  747. goto err_dma;
  748. }
  749. #endif
  750. #endif // USE_USBD_DMA
  752. /* now allocate the IRQ. */
  753. retval = request_irq(IRQ_USBD, udc_int_hndlr, SA_INTERRUPT,
  754.   "S3C2410 USB core", NULL);
  755. if (retval) {
  756. printk("%sCouldn't request USB irq rc=%dn",pszMe, retval);
  757. goto err_irq;
  758. }
  760. /* MISC. register */
  761. MISCCR &= ~MISCCR_USBPAD;
  762. /* UPLLCON */
  763. UPLLCON = FInsrt(0x78, fPLL_MDIV) | FInsrt(0x02, fPLL_PDIV) 
  764. | FInsrt(0x03, fPLL_SDIV);
  765. /* CLKCON */
  766. CLKCON |= CLKCON_USBD;
  767.      Clear_pending(INT_USBD);
  769. printk( "S3C2410 USB Controller Core Initializedn");
  770. return 0;
  772. err_irq:
  774. #ifdef USE_USBD_DMA
  775. s3c2410_free_dma(DMA_CH0);
  776. s3c2410_free_dma(DMA_CH3);
  777. #endif 
  779. err_dma:
  780. usbd_info.dmach_tx = 0;
  781. usbd_info.dmach_rx = 0;
  782. return retval;
  783. }
  784. /*
  785.  * usbctl_exit()
  786.  * Release DMA and interrupt resources
  787.  */
  788. void __exit usbctl_exit( void )
  789. {
  790.     printk("Unloading S3C2410 USB Controllern");
  792. CLKCON &= ~CLKCON_USBD;
  794. #ifdef CONFIG_PROC_FS
  795.     remove_proc_entry ( PROC_NODE_NAME, NULL);
  796. #endif
  798. #ifdef USE_USBD_DMA
  799.     s3c2410_free_dma(usbd_info.dmach_rx);
  800.     s3c2410_free_dma(usbd_info.dmach_tx);
  801. #endif
  802.     free_irq(IRQ_USBD, NULL);
  803. }
  805. EXPORT_SYMBOL( s3c2410_usb_open );
  806. EXPORT_SYMBOL( s3c2410_usb_start );
  807. EXPORT_SYMBOL( s3c2410_usb_stop );
  808. EXPORT_SYMBOL( s3c2410_usb_close );
  811. EXPORT_SYMBOL( s3c2410_usb_get_descriptor_ptr );
  812. EXPORT_SYMBOL( s3c2410_usb_set_string_descriptor );
  813. EXPORT_SYMBOL( s3c2410_usb_get_string_descriptor );
  814. EXPORT_SYMBOL( s3c2410_usb_kmalloc_string_descriptor );
  816. #if defined(CONFIG_PM) && defined(CONFIG_MIZI)
  817. EXPORT_SYMBOL( usbctl_resume );
  818. EXPORT_SYMBOL( usbctl_suspend );
  819. #endif
  821. module_init( usbctl_init );
  822. module_exit( usbctl_exit );