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

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

嵌入式Linux

开发平台：

Unix_Linux

usb_ep0.c：源码内容
  1. /*
  2.  * Copyright (C) Extenex Corporation 2001
  3.  * Much folklore gleaned from original code:
  4.  *    Copyright (C) Compaq Computer Corporation, 1998, 1999
  5.  *
  6.  *  usb_ep0.c - SA1100 USB controller driver.
  7.  *              Endpoint zero management
  8.  *
  9.  *  Please see:
  10.  *    linux/Documentation/arm/SA1100/SA1100_USB
  11.  *  for details. (Especially since Intel docs are full of
  12.  *  errors about ep0 operation.) ward.willats@extenex.com.
  13.  *
  14.  * Intel also has a "Universal Serial Bus Client Device
  15.  * Validation for the StrongARM SA-1100 Microprocessor"
  16.  * document, which has flow charts and assembler test driver,
  17.  * but be careful, since it is just for validation and not
  18.  * a "real world" solution.
  19.  *
  20.  * A summary of three types of data-returning setups:
  21.  *
  22.  * 1. Setup request <= 8 bytes. That is, requests that can
  23.  *    be fullfilled in one write to the FIFO. DE is set
  24.  *    with IPR in queue_and_start_write(). (I don't know
  25.  *    if there really are any of these!)
  26.  *
  27.  * 2. Setup requests > 8 bytes (requiring more than one
  28.  *    IN to get back to the host), and we have at least
  29.  *    as much or more data than the host requested. In
  30.  *    this case we pump out everything we've got, and
  31.  *    when the final interrupt comes in due to the UDC
  32.  *    clearing the last IPR, we just set DE.
  33.  *
  34.  * 3. Setup requests > 8 bytes, but we don't have enough
  35.  *    data to satisfy the request. In this case, we send
  36.  *    everything we've got, and when the final interrupt
  37.  *    comes in due to the UDC clearing the last IPR
  38.  *    we write nothing to the FIFO and set both IPR and DE
  39.  *    so the UDC sends an empty packet and forces the host
  40.  *    to perform short packet retirement instead of stalling
  41.  *    out.
  42.  *
  43.  */
  45. #include <linux/delay.h>
  46. #include "sa1100_usb.h"  /* public interface */
  47. #include "usb_ctl.h"     /* private stuff */
  50. // 1 == lots of trace noise,  0 = only "important' stuff
  51. #define VERBOSITY 0
  53. enum { true = 1, false = 0 };
  54. typedef int bool;
  55. #ifndef MIN
  56. #define MIN( a, b ) ((a)<(b)?(a):(b))
  57. #endif
  59. #if 1 && !defined( ASSERT )
  60. #  define ASSERT(expr) 
  61.           if(!(expr)) { 
  62.           printk( "Assertion failed! %s,%s,%s,line=%dn",
  63.           #expr,__FILE__,__FUNCTION__,__LINE__); 
  64.           }
  65. #else
  66. #  define ASSERT(expr)
  67. #endif
  69. #if VERBOSITY
  70. #define PRINTKD(fmt, args...) printk( fmt , ## args)
  71. #else
  72. #define PRINTKD(fmt, args...)
  73. #endif
  75. /*================================================
  76.  * USB Protocol Stuff
  77.  */
  79. /* Request Codes   */
  80. enum { GET_STATUS=0,         CLEAR_FEATURE=1,     SET_FEATURE=3,
  81.    SET_ADDRESS=5,        GET_DESCRIPTOR=6,   SET_DESCRIPTOR=7,
  82.    GET_CONFIGURATION=8,  SET_CONFIGURATION=9, GET_INTERFACE=10,
  83.    SET_INTERFACE=11 };
  86. /* USB Device Requests */
  87. typedef struct
  88. {
  89.     __u8 bmRequestType;
  90.     __u8 bRequest;
  91.     __u16 wValue;
  92.     __u16 wIndex;
  93.     __u16 wLength;
  94. } usb_dev_request_t  __attribute__ ((packed));
  96. /***************************************************************************
  97. Prototypes
  98. ***************************************************************************/
  99. /* "setup handlers" -- the main functions dispatched to by the
  100.    .. isr. These represent the major "modes" of endpoint 0 operaton */
  101. static void sh_setup_begin(void); /* setup begin (idle) */
  102. static void sh_write( void );       /* writing data */
  103. static void sh_write_with_empty_packet( void ); /* empty packet at end of xfer*/
  104. /* called before both sh_write routines above */
  105. static void common_write_preamble( void );
  107. /* other subroutines */
  108. static __u32  queue_and_start_write( void * p, int req, int act );
  109. static void write_fifo( void );
  110. static int read_fifo( usb_dev_request_t * p );
  111. static void get_descriptor( usb_dev_request_t * pReq );
  113. /* some voodo helpers  01Mar01ww */
  114. static void set_cs_bits( __u32 set_bits );
  115. static void set_de( void );
  116. static void set_ipr( void );
  117. static void set_ipr_and_de( void );
  118. static bool clear_opr( void );
  120. /***************************************************************************
  121. Inline Helpers
  122. ***************************************************************************/
  124. /* Data extraction from usb_request_t fields */
  125. enum { kTargetDevice=0, kTargetInterface=1, kTargetEndpoint=2 };
  126. static inline int request_target( __u8 b ) { return (int) ( b & 0x0F); }
  128. static inline int windex_to_ep_num( __u16 w ) { return (int) ( w & 0x000F); }
  129. inline int type_code_from_request( __u8 by ) { return (( by >> 4 ) & 3); }
  131. /* following is hook for self-powered flag in GET_STATUS. Some devices
  132.    .. might like to override and return real info */
  133. static inline bool self_powered_hook( void ) { return true; }
  135. /* print string descriptor */
  136. static inline void psdesc( string_desc_t * p )
  137. {
  138.  int i;
  139.  int nchars = ( p->bLength - 2 ) / sizeof( __u16 );
  140.  printk( "'" );
  141.  for( i = 0 ; i < nchars ; i++ ) {
  142.   printk( "%c", (char) p->bString[i] );
  143.  }
  144.  printk( "'n" );
  145. }
  148. #if VERBOSITY
  149. /* "pcs" == "print control status" */
  150. static inline void pcs( void )
  151. {
  152.  __u32 foo = Ser0UDCCS0;
  153.  printk( "%8.8X: %s %s %s %sn",
  154.  foo,
  155.  foo & UDCCS0_SE ? "SE" : "",
  156.  foo & UDCCS0_OPR ? "OPR" : "",
  157.  foo & UDCCS0_IPR ? "IPR" : "",
  158.  foo & UDCCS0_SST ? "SST" : ""
  159.  );
  160. }
  161. static inline void preq( usb_dev_request_t * pReq )
  162. {
  163.  static char * tnames[] = { "dev", "intf", "ep", "oth" };
  164.  static char * rnames[] = { "std", "class", "vendor", "???" };
  165.  char * psz;
  166.  switch( pReq->bRequest ) {
  167.  case GET_STATUS: psz = "get stat"; break;
  168.  case CLEAR_FEATURE: psz = "clr feat"; break;
  169.  case SET_FEATURE: psz = "set feat"; break;
  170.  case SET_ADDRESS: psz = "set addr"; break;
  171.  case GET_DESCRIPTOR: psz = "get desc"; break;
  172.  case SET_DESCRIPTOR: psz = "set desc"; break;
  173.  case GET_CONFIGURATION: psz = "get cfg"; break;
  174.  case SET_CONFIGURATION: psz = "set cfg"; break;
  175.  case GET_INTERFACE: psz = "get intf"; break;
  176.  case SET_INTERFACE: psz = "set intf"; break;
  177.  default: psz = "unknown"; break;
  178.  }
  179.  printk( "- [%s: %s req to %s. dir=%s]n", psz,
  180.  rnames[ (pReq->bmRequestType >> 5) & 3 ],
  181.  tnames[ pReq->bmRequestType & 3 ],
  182.  ( pReq->bmRequestType & 0x80 ) ? "in" : "out" );
  183. }
  185. #else
  186. static inline void pcs( void ){}
  187. static inline void preq( void ){}
  188. #endif
  190. /***************************************************************************
  191. Globals
  192. ***************************************************************************/
  193. static const char pszMe[] = "usbep0: ";
  195. /* pointer to current setup handler */
  196. static void (*current_handler)(void) = sh_setup_begin;
  198. /* global write struct to keep write
  199.    ..state around across interrupts */
  200. static struct {
  201. unsigned char *p;
  202. int bytes_left;
  203. } wr;
  205. /***************************************************************************
  206. Public Interface
  207. ***************************************************************************/
  209. /* reset received from HUB (or controller just went nuts and reset by itself!)
  210.   so udc core has been reset, track this state here  */
  211. void
  212. ep0_reset(void)
  213. {
  214.  /* reset state machine */
  215.  current_handler = sh_setup_begin;
  216.  wr.p = NULL;
  217.  wr.bytes_left = 0;
  218.  usbd_info.address=0;
  219. }
  221. /* handle interrupt for endpoint zero */
  222. void
  223. ep0_int_hndlr( void )
  224. {
  225.  PRINTKD( "/\(%d)n", Ser0UDCAR );
  226.  pcs();
  228.  /* if not in setup begin, we are returning data.
  229. execute a common preamble to both write handlers
  230.  */
  231.  if ( current_handler != sh_setup_begin )
  232.   common_write_preamble();
  234.  (*current_handler)();
  236.  PRINTKD( "---n" );
  237.  pcs();
  238.  PRINTKD( "\/n" );
  239. }
  241. /***************************************************************************
  242. Setup Handlers
  243. ***************************************************************************/
  244. /*
  245.  * sh_setup_begin()
  246.  * This setup handler is the "idle" state of endpoint zero. It looks for OPR
  247.  * (OUT packet ready) to see if a setup request has been been received from the
  248.  * host. Requests without a return data phase are immediately handled. Otherwise,
  249.  * in the case of GET_XXXX the handler may be set to one of the sh_write_xxxx
  250.  * data pumpers if more than 8 bytes need to get back to the host.
  251.  *
  252.  */
  253. static void
  254. sh_setup_begin( void )
  255. {
  256.  unsigned char status_buf[2];  /* returned in GET_STATUS */
  257.  usb_dev_request_t req;
  258.  int request_type;
  259.  int n;
  260.  __u32 cs_bits;
  261.  __u32 address;
  262.  __u32 cs_reg_in = Ser0UDCCS0;
  264.  if (cs_reg_in & UDCCS0_SST) {
  265.   PRINTKD( "%ssetup begin: sent stall. Continuingn", pszMe );
  266.   set_cs_bits( UDCCS0_SST );
  267. }
  269.  if ( cs_reg_in & UDCCS0_SE ) {
  270.   PRINTKD( "%ssetup begin: Early term of setup. Continuingn", pszMe );
  271.   set_cs_bits( UDCCS0_SSE );    /* clear setup end */
  272.  }
  274.  /* Be sure out packet ready, otherwise something is wrong */
  275.  if ( (cs_reg_in & UDCCS0_OPR) == 0 ) {
  276.   /* we can get here early...if so, we'll int again in a moment  */
  277.   PRINTKD( "%ssetup begin: no OUT packet available. Exitingn", pszMe );
  278.   goto sh_sb_end;
  279.  }
  281.  /* read the setup request */
  282.  n = read_fifo( &req );
  283.  if ( n != sizeof( req ) ) {
  284.   printk( "%ssetup begin: fifo READ ERROR wanted %d bytes got %d. "
  285.   " Stalling out...n",
  286.   pszMe, sizeof( req ), n );
  287.   /* force stall, serviced out */
  288.   set_cs_bits( UDCCS0_FST | UDCCS0_SO  );
  289.   goto sh_sb_end;
  290.  }
  292.  /* Is it a standard request? (not vendor or class request) */
  293.  request_type = type_code_from_request( req.bmRequestType );
  294.  if ( request_type != 0 ) {
  295.   printk( "%ssetup begin: unsupported bmRequestType: %d ignoredn",
  296.   pszMe, request_type );
  297.   set_cs_bits( UDCCS0_DE | UDCCS0_SO );
  298.   goto sh_sb_end;
  299.  }
  301. #if VERBOSITY
  302.  {
  303.  unsigned char * pdb = (unsigned char *) &req;
  304.  PRINTKD( "%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X ",
  305.  pdb[0], pdb[1], pdb[2], pdb[3], pdb[4], pdb[5], pdb[6], pdb[7]
  306.   );
  307.  preq( &req );
  308.  }
  309. #endif
  311.  /* Handle it */
  312.  switch( req.bRequest ) {
  314.   /* This first bunch have no data phase */
  316.  case SET_ADDRESS:
  317.   address = (__u32) (req.wValue & 0x7F);
  318.   /* when SO and DE sent, UDC will enter status phase and ack,
  319.  ..propagating new address to udc core. Next control transfer
  320.  ..will be on the new address. You can't see the change in a
  321.  ..read back of CAR until then. (about 250us later, on my box).
  322.  ..The original Intel driver sets S0 and DE and code to check
  323.  ..that address has propagated here. I tried this, but it
  324.  ..would only work sometimes! The rest of the time it would
  325.  ..never propagate and we'd spin forever. So now I just set
  326.  ..it and pray...
  327.   */
  328.   Ser0UDCAR = address;
  329.   usbd_info.address = address;
  330.   usbctl_next_state_on_event( kEvAddress );
  331.   set_cs_bits( UDCCS0_SO | UDCCS0_DE );  /* no data phase */
  332.   printk( "%sI have been assigned address: %dn", pszMe, address );
  333.   break;
  336.  case SET_CONFIGURATION:
  337.   if ( req.wValue == 1 ) {
  338.    /* configured */
  339.    if (usbctl_next_state_on_event( kEvConfig ) != kError){
  340. /* (re)set the out and in max packet sizes */
  341. desc_t * pDesc = sa1100_usb_get_descriptor_ptr();
  342. __u32 out = __le16_to_cpu( pDesc->b.ep1.wMaxPacketSize );
  343. __u32 in  = __le16_to_cpu( pDesc->b.ep2.wMaxPacketSize );
  344. Ser0UDCOMP = ( out - 1 );
  345. Ser0UDCIMP = ( in - 1 );
  346. printk( "%sConfigured (OMP=%8.8X IMP=%8.8X)n", pszMe, out, in );
  347.    }
  348.   } else if ( req.wValue == 0 ) {
  349.    /* de-configured */
  350.    if (usbctl_next_state_on_event( kEvDeConfig ) != kError )
  351. printk( "%sDe-Configuredn", pszMe );
  352.   } else {
  353.    printk( "%ssetup phase: Unknown "
  354.    ""set configuration" data %dn",
  355.    pszMe, req.wValue );
  356.   }
  357.   set_cs_bits( UDCCS0_SO | UDCCS0_DE );  /* no data phase */
  358.   break;
  360.  case CLEAR_FEATURE:
  361.   /* could check data length, direction...26Jan01ww */
  362.   if ( req.wValue == 0 ) { /* clearing ENDPOINT_HALT/STALL */
  363.    int ep = windex_to_ep_num( req.wIndex );
  364.    if ( ep == 1 ) {
  365. printk( "%sclear feature "endpoint halt" "
  366. " on receivern", pszMe );
  367. ep1_reset();
  368.    }
  369.    else if ( ep == 2 ) {
  370. printk( "%sclear feature "endpoint halt" "
  371. "on xmittern", pszMe );
  372. ep2_reset();
  373.    } else {
  374. printk( "%sclear feature "endpoint halt" "
  375. "on unsupported ep # %dn",
  376. pszMe, ep );
  377.    }
  378.   } else {
  379.    printk( "%sUnsupported feature selector (%d) "
  380.    "in clear feature. Ignored.n" ,
  381.    pszMe, req.wValue );
  382.   }
  383.   set_cs_bits( UDCCS0_SO | UDCCS0_DE );  /* no data phase */
  384.   break;
  386.  case SET_FEATURE:
  387.   if ( req.wValue == 0 ) { /* setting ENDPOINT_HALT/STALL */
  388.    int ep = windex_to_ep_num( req.wValue );
  389.    if ( ep == 1 ) {
  390. printk( "%set feature "endpoint halt" "
  391. "on receivern", pszMe );
  392. ep1_stall();
  393.    }
  394.    else if ( ep == 2 ) {
  395. printk( "%sset feature "endpoint halt" "
  396. " on xmittern", pszMe );
  397. ep2_stall();
  398.    } else {
  399. printk( "%sset feature "endpoint halt" "
  400. "on unsupported ep # %dn",
  401. pszMe, ep );
  402.    }
  403.   }
  404.   else {
  405.    printk( "%sUnsupported feature selector "
  406.    "(%d) in set featuren",
  407.    pszMe, req.wValue );
  408.   }
  409.   set_cs_bits( UDCCS0_SO | UDCCS0_DE );  /* no data phase */
  410.   break;
  413.   /* The rest have a data phase that writes back to the host */
  414.  case GET_STATUS:
  415.   /* return status bit flags */
  416.   status_buf[0] = status_buf[1] = 0;
  417.   n = request_target(req.bmRequestType);
  418.   switch( n ) {
  419.   case kTargetDevice:
  420.    if ( self_powered_hook() )
  421. status_buf[0] |= 1;
  422.    break;
  423.   case kTargetInterface:
  424.    break;
  425.   case kTargetEndpoint:
  426.    /* return stalled bit */
  427.    n = windex_to_ep_num( req.wIndex );
  428.    if ( n == 1 )
  429. status_buf[0] |= (Ser0UDCCS1 & UDCCS1_FST) >> 4;
  430.    else if ( n == 2 )
  431. status_buf[0] |= (Ser0UDCCS2 & UDCCS2_FST) >> 5;
  432.    else {
  433. printk( "%sUnknown endpoint (%d) "
  434. "in GET_STATUSn", pszMe, n );
  435.    }
  436.    break;
  437.   default:
  438.    printk( "%sUnknown target (%d) in GET_STATUSn",
  439.    pszMe, n );
  440.    /* fall thru */
  441.    break;
  442.   }
  443.   cs_bits  = queue_and_start_write( status_buf,
  444. req.wLength,
  445. sizeof( status_buf ) );
  446.   set_cs_bits( cs_bits );
  447.   break;
  448.  case GET_DESCRIPTOR:
  449.   get_descriptor( &req );
  450.   break;
  452.  case GET_CONFIGURATION:
  453.   status_buf[0] = (usbd_info.state ==  USB_STATE_CONFIGURED)
  454.    ? 1
  455.    : 0;
  456.   cs_bits = queue_and_start_write( status_buf, req.wLength, 1 );
  457.   set_cs_bits( cs_bits );
  458.   break;
  459.  case GET_INTERFACE:
  460.   printk( "%sfixme: get interface not supportedn", pszMe );
  461.   cs_bits = queue_and_start_write( NULL, req.wLength, 0 );
  462.   set_cs_bits( cs_bits );
  463.   break;
  464.  case SET_INTERFACE:
  465.   printk( "%sfixme: set interface not supportedn", pszMe );
  466.   set_cs_bits( UDCCS0_DE | UDCCS0_SO );
  467.   break;
  468.  default :
  469.   printk("%sunknown request 0x%xn", pszMe, req.bRequest);
  470.   break;
  471.  } /* switch( bRequest ) */
  473. sh_sb_end:
  474.  return;
  476. }
  477. /*
  478.  * common_wrtie_preamble()
  479.  * Called before execution of sh_write() or sh_write_with_empty_packet()
  480.  * Handles common abort conditions.
  481.  *
  482.  */
  483. static void common_write_preamble( void )
  484. {
  485.  /* If "setup end" has been set, the usb controller has
  486. ..terminated a setup transaction before we set DE. This
  487. ..happens during enumeration with some hosts. For example,
  488. ..the host will ask for our device descriptor and specify
  489. ..a return of 64 bytes. When we hand back the first 8, the
  490. ..host will know our max packet size and turn around and
  491. ..issue a new setup immediately. This causes the UDC to auto-ack
  492. ..the new setup and set SE. We must then "unload" (process)
  493. ..the new setup, which is what will happen after this preamble
  494. ..is finished executing.
  495.  */
  496.  __u32 cs_reg_in = Ser0UDCCS0;
  498.  if ( cs_reg_in & UDCCS0_SE ) {
  499.   PRINTKD( "%swrite_preamble(): Early termination of setupn", pszMe );
  500.   Ser0UDCCS0 =  UDCCS0_SSE;    /* clear setup end */
  501.   current_handler = sh_setup_begin;
  502.  }
  504.  if ( cs_reg_in & UDCCS0_SST ) {
  505.   PRINTKD( "%swrite_preamble(): UDC sent stalln", pszMe );
  506.   Ser0UDCCS0 = UDCCS0_SST;    /* clear setup end */
  507.   current_handler = sh_setup_begin;
  508.  }
  510.  if ( cs_reg_in & UDCCS0_OPR ) {
  511.   PRINTKD( "%swrite_preamble(): see OPR. Stopping write to "
  512.    "handle new SETUPn", pszMe );
  513.   /* very rarely, you can get OPR and leftover IPR. Try to clear */
  514.   UDC_clear( Ser0UDCCS0, UDCCS0_IPR );
  515.   current_handler = sh_setup_begin;
  516.  }
  517. }
  519. /*
  520.  * sh_write()
  521.  * This is the setup handler when we are in the data return phase of
  522.  * a setup request and have as much (or more) data than the host
  523.  * requested. If we enter this routine and bytes left is zero, the
  524.  * last data packet has gone (int is because IPR was just cleared)
  525.  * so we just set DE and reset. Otheriwse, we write another packet
  526.  * and set IPR.
  527.  */
  528. static void sh_write()
  529. {
  530.  PRINTKD( "Wn" );
  532.  if ( Ser0UDCCS0 & UDCCS0_IPR ) {
  533.   PRINTKD( "%ssh_write(): IPR set, exitingn", pszMe );
  534.   return;
  535.  }
  537.  /* If bytes left is zero, we are coming in on the
  538. ..interrupt after the last packet went out. And
  539. ..we know we don't have to empty packet this transfer
  540. ..so just set DE and we are done */
  542.  if ( 0 == wr.bytes_left ) {
  543.   /* that's it, so data end  */
  544.   set_de();
  545.   wr.p = NULL;   /* be anal */
  546.   current_handler = sh_setup_begin;
  547.  } else {
  548.   /* Otherwise, more data to go */
  549.   write_fifo();
  550.   set_ipr();
  551.  }
  552. }
  553. /*
  554.  * sh_write_with_empty_packet()
  555.  * This is the setup handler when we don't have enough data to
  556.  * satisfy the host's request. After we send everything we've got
  557.  * we must send an empty packet (by setting IPR and DE) so the
  558.  * host can perform "short packet retirement" and not stall.
  559.  *
  560.  */
  561. static void sh_write_with_empty_packet( void )
  562. {
  563.  __u32 cs_reg_out = 0;
  564.  PRINTKD( "WEn" );
  566.  if ( Ser0UDCCS0 & UDCCS0_IPR ) {
  567.   PRINTKD( "%ssh_write(): IPR set, exitingn", pszMe );
  568.   return;
  569.  }
  571.  /* If bytes left is zero, we are coming in on the
  572. ..interrupt after the last packet went out.
  573. ..we must do short packet suff, so set DE and IPR
  574.  */
  576.  if ( 0 == wr.bytes_left ) {
  577.   set_ipr_and_de();
  578.   wr.p = NULL;
  579.   current_handler = sh_setup_begin;
  580.   PRINTKD( "%ssh_write empty() Sent empty packet n", pszMe );
  581.  }  else {
  582.   write_fifo(); /* send data */
  583.   set_ipr(); /* flag a packet is ready */
  584.  }
  585.  Ser0UDCCS0 = cs_reg_out;
  586. }
  588. /***************************************************************************
  589. Other Private Subroutines
  590. ***************************************************************************/
  591. /*
  592.  * queue_and_start_write()
  593.  * p == data to send
  594.  * req == bytes host requested
  595.  * act == bytes we actually have
  596.  * Returns: bits to be flipped in ep0 control/status register
  597.  *
  598.  * Called from sh_setup_begin() to begin a data return phase. Sets up the
  599.  * global "wr"-ite structure and load the outbound FIFO with data.
  600.  * If can't send all the data, set appropriate handler for next interrupt.
  601.  *
  602.  */
  603. static __u32  queue_and_start_write( void * in, int req, int act )
  604. {
  605.  __u32 cs_reg_bits = UDCCS0_IPR;
  606.  unsigned char * p = (unsigned char*) in;
  608.  PRINTKD( "Qr=%d a=%dn",req,act );
  610. /* thou shalt not enter data phase until the serviced OUT is clear */
  611.  if ( ! clear_opr() ) {
  612.   printk( "%sSO did not clear OPRn", pszMe );
  613.   return ( UDCCS0_DE | UDCCS0_SO ) ;
  614.  }
  615.  wr.p = p;
  616.  wr.bytes_left = MIN( act, req );
  618.  write_fifo();
  620.  if ( 0 == wr.bytes_left ) {
  621.   cs_reg_bits |= UDCCS0_DE; /* out in 1 so data end */
  622.   wr.p = NULL;   /* be anal */
  623.  }
  624.  else if ( act < req )   /* we are going to short-change host */
  625.   current_handler = sh_write_with_empty_packet; /* so need nul to not stall */
  626.  else /* we have as much or more than requested */
  627.   current_handler = sh_write;
  629.  return cs_reg_bits; /* note: IPR was set uncondtionally at start of routine */
  630. }
  631. /*
  632.  * write_fifo()
  633.  * Stick bytes in the 8 bytes endpoint zero FIFO.
  634.  * This version uses a variety of tricks to make sure the bytes
  635.  * are written correctly. 1. The count register is checked to
  636.  * see if the byte went in, and the write is attempted again
  637.  * if not. 2. An overall counter is used to break out so we
  638.  * don't hang in those (rare) cases where the UDC reverses
  639.  * direction of the FIFO underneath us without notification
  640.  * (in response to host aborting a setup transaction early).
  641.  *
  642.  */
  643. static void write_fifo( void )
  644. {
  645. int bytes_this_time = MIN( wr.bytes_left, 8 );
  646. int bytes_written = 0;
  647. int i=0;
  649. PRINTKD( "WF=%d: ", bytes_this_time );
  651. while( bytes_this_time-- ) {
  652.  PRINTKD( "%2.2X ", *wr.p );
  653.  i = 0;
  654.  do {
  655.   Ser0UDCD0 = *wr.p;
  656.   udelay( 20 );  /* voodo 28Feb01ww */
  657.   i++;
  658.  } while( Ser0UDCWC == bytes_written && i < 10 );
  659.  if ( i == 50 ) {
  660.   printk( "%swrite_fifo: write failuren", pszMe );
  661.   usbd_info.stats.ep0_fifo_write_failures++;
  662.  }
  664.  wr.p++;
  665.  bytes_written++;
  666. }
  667. wr.bytes_left -= bytes_written;
  669. /* following propagation voodo so maybe caller writing IPR in
  670.    ..a moment might actually get it to stick 28Feb01ww */
  671. udelay( 300 );
  673. usbd_info.stats.ep0_bytes_written += bytes_written;
  674. PRINTKD( "L=%d WCR=%8.8Xn", wr.bytes_left, Ser0UDCWC );
  675. }
  676. /*
  677.  * read_fifo()
  678.  * Read 1-8 bytes out of FIFO and put in request.
  679.  * Called to do the initial read of setup requests
  680.  * from the host. Return number of bytes read.
  681.  *
  682.  * Like write fifo above, this driver uses multiple
  683.  * reads checked agains the count register with an
  684.  * overall timeout.
  685.  *
  686.  */
  687. static int
  688. read_fifo( usb_dev_request_t * request )
  689. {
  690. int bytes_read = 0;
  691. int fifo_count;
  692. int i;
  694. unsigned char * pOut = (unsigned char*) request;
  696. fifo_count = ( Ser0UDCWC & 0xFF );
  698. ASSERT( fifo_count <= 8 );
  699. PRINTKD( "RF=%d ", fifo_count );
  701. while( fifo_count-- ) {
  702.  i = 0;
  703.  do {
  704.   *pOut = (unsigned char) Ser0UDCD0;
  705.   udelay( 10 );
  706.  } while( ( Ser0UDCWC & 0xFF ) != fifo_count && i < 10 );
  707.  if ( i == 10 ) {
  708.   printk( "%sread_fifo(): read failuren", pszMe );
  709.   usbd_info.stats.ep0_fifo_read_failures++;
  710.  }
  711.  pOut++;
  712.  bytes_read++;
  713. }
  715. PRINTKD( "fc=%dn", bytes_read );
  716. usbd_info.stats.ep0_bytes_read++;
  717. return bytes_read;
  718. }
  720. /*
  721.  * get_descriptor()
  722.  * Called from sh_setup_begin to handle data return
  723.  * for a GET_DESCRIPTOR setup request.
  724.  */
  725. static void get_descriptor( usb_dev_request_t * pReq )
  726. {
  727.  __u32 cs_bits = 0;
  728.  string_desc_t * pString;
  729.  ep_desc_t * pEndpoint;
  731.  desc_t * pDesc = sa1100_usb_get_descriptor_ptr();
  732.  int type = pReq->wValue >> 8;
  733.  int idx  = pReq->wValue & 0xFF;
  735.  switch( type ) {
  736.  case USB_DESC_DEVICE:
  737.   cs_bits =
  738.    queue_and_start_write( &pDesc->dev,
  739.   pReq->wLength,
  740.   pDesc->dev.bLength );
  741.   break;
  743.   // return config descriptor buffer, cfg, intf, 2 ep
  744.  case USB_DESC_CONFIG:
  745.   cs_bits =
  746.    queue_and_start_write( &pDesc->b,
  747.   pReq->wLength,
  748.   sizeof( struct cdb ) );
  749.   break;
  751.   // not quite right, since doesn't do language code checking
  752.  case USB_DESC_STRING:
  753.   pString = sa1100_usb_get_string_descriptor( idx );
  754.   if ( pString ) {
  755.    if ( idx != 0 ) {  // if not language index
  756. printk( "%sReturn string %d: ", pszMe, idx );
  757. psdesc( pString );
  758.    }
  759.    cs_bits =
  760. queue_and_start_write( pString,
  761.    pReq->wLength,
  762.    pString->bLength );
  763.   }
  764.   else {
  765.    printk("%sunkown string index %d Stall.n", pszMe, idx );
  766.    cs_bits = ( UDCCS0_DE | UDCCS0_SO | UDCCS0_FST );
  767.   }
  768.   break;
  770.  case USB_DESC_INTERFACE:
  771.   if ( idx == pDesc->b.intf.bInterfaceNumber ) {
  772.    cs_bits =
  773. queue_and_start_write( &pDesc->b.intf,
  774.    pReq->wLength,
  775.    pDesc->b.intf.bLength );
  776.   }
  777.   break;
  779.  case USB_DESC_ENDPOINT: /* correct? 21Feb01ww */
  780.   if ( idx == 1 )
  781.    pEndpoint = &pDesc->b.ep1;
  782.   else if ( idx == 2 )
  783.    pEndpoint = &pDesc->b.ep2;
  784.   else
  785.    pEndpoint = NULL;
  786.   if ( pEndpoint ) {
  787.    cs_bits =
  788. queue_and_start_write( pEndpoint,
  789.    pReq->wLength,
  790.    pEndpoint->bLength );
  791.   } else {
  792.    printk("%sunkown endpoint index %d Stall.n", pszMe, idx );
  793.    cs_bits = ( UDCCS0_DE | UDCCS0_SO | UDCCS0_FST );
  794.   }
  795.   break;
  798.  default :
  799.   printk("%sunknown descriptor type %d. Stall.n", pszMe, type );
  800.   cs_bits = ( UDCCS0_DE | UDCCS0_SO | UDCCS0_FST );
  801.   break;
  803.  }
  804.  set_cs_bits( cs_bits );
  805. }
  808. /* some voodo I am adding, since the vanilla macros just aren't doing it  1Mar01ww */
  810. #define ABORT_BITS ( UDCCS0_SST | UDCCS0_SE )
  811. #define OK_TO_WRITE (!( Ser0UDCCS0 & ABORT_BITS ))
  812. #define BOTH_BITS (UDCCS0_IPR | UDCCS0_DE)
  814. static void set_cs_bits( __u32 bits )
  815. {
  816.  if ( bits & ( UDCCS0_SO | UDCCS0_SSE | UDCCS0_FST ) )
  817.   Ser0UDCCS0 = bits;
  818.  else if ( (bits & BOTH_BITS) == BOTH_BITS )
  819.   set_ipr_and_de();
  820.  else if ( bits & UDCCS0_IPR )
  821.   set_ipr();
  822.  else if ( bits & UDCCS0_DE )
  823.   set_de();
  824. }
  826. static void set_de( void )
  827. {
  828.  int i = 1;
  829.  while( 1 ) {
  830.   if ( OK_TO_WRITE ) {
  831. Ser0UDCCS0 |= UDCCS0_DE;
  832.   } else {
  833.    PRINTKD( "%sQuitting set DE because SST or SE setn", pszMe );
  834.    break;
  835.   }
  836.   if ( Ser0UDCCS0 & UDCCS0_DE )
  837.    break;
  838.   udelay( i );
  839.   if ( ++i == 50  ) {
  840.    printk( "%sDangnabbbit! Cannot set DE! (DE=%8.8X CCS0=%8.8X)n",
  841.    pszMe, UDCCS0_DE, Ser0UDCCS0 );
  842.    break;
  843.   }
  844.  }
  845. }
  847. static void set_ipr( void )
  848. {
  849.  int i = 1;
  850.  while( 1 ) {
  851.   if ( OK_TO_WRITE ) {
  852. Ser0UDCCS0 |= UDCCS0_IPR;
  853.   } else {
  854.    PRINTKD( "%sQuitting set IPR because SST or SE setn", pszMe );
  855.    break;
  856.   }
  857.   if ( Ser0UDCCS0 & UDCCS0_IPR )
  858.    break;
  859.   udelay( i );
  860.   if ( ++i == 50  ) {
  861.    printk( "%sDangnabbbit! Cannot set IPR! (IPR=%8.8X CCS0=%8.8X)n",
  862.    pszMe, UDCCS0_IPR, Ser0UDCCS0 );
  863.    break;
  864.   }
  865.  }
  866. }
  870. static void set_ipr_and_de( void )
  871. {
  872.  int i = 1;
  873.  while( 1 ) {
  874.   if ( OK_TO_WRITE ) {
  875.    Ser0UDCCS0 |= BOTH_BITS;
  876.   } else {
  877.    PRINTKD( "%sQuitting set IPR/DE because SST or SE setn", pszMe );
  878.    break;
  879.   }
  880.   if ( (Ser0UDCCS0 & BOTH_BITS) == BOTH_BITS)
  881.    break;
  882.   udelay( i );
  883.   if ( ++i == 50  ) {
  884.    printk( "%sDangnabbbit! Cannot set DE/IPR! (DE=%8.8X IPR=%8.8X CCS0=%8.8X)n",
  885.    pszMe, UDCCS0_DE, UDCCS0_IPR, Ser0UDCCS0 );
  886.    break;
  887.   }
  888.  }
  889. }
  891. static bool clear_opr( void )
  892. {
  893.  int i = 10000;
  894.  bool is_clear;
  895.  do {
  896.   Ser0UDCCS0 = UDCCS0_SO;
  897.   is_clear  = ! ( Ser0UDCCS0 & UDCCS0_OPR );
  898.   if ( i-- <= 0 ) {
  899.    printk( "%sclear_opr(): failedn", pszMe );
  900.    break;
  901.   }
  902.  } while( ! is_clear );
  903.  return is_clear;
  904. }
  910. /* end usb_ep0.c */