embedded/app/usbcan/usb_srq.c

   1 /*****************************************************/
   2 /***   Module : USB module                         ***/
   3 /***   Author : Roman Bartosinski (C) 28.04.2002   ***/
   4 /***   Modify : 08.08.2002, 16.04.2003             ***/
   5 /*****************************************************/
   6
   7 #include <string.h>
   8 #include <cpu_def.h>
   9 #include <system_def.h>
  10 #include <usb/usb.h>
  11 #include <usb/usb_spec.h>
  12 #include <usb/usbdebug.h>
  13 #include <usb/usb_srq.h>
  14 #include <usb/usb_defs.h>
  15 #include <usb/lpcusb.h>
  16
  17 //extern ul_dcnv_state_t ep1_dcnv_state;
  18
  19   // ****************************
  20   int usb_stdreq_get_status( usb_device_t *udev)
  21   {
  22     unsigned char c,buf[2] = { 0, 0};
  23     unsigned char epid = (unsigned char) udev->request.wIndex;
  24     usb_ep_t *ep0 = &(udev->ep0);
  25
  26     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetStatus\n"));
  27     switch( udev->request.bmRequestType & USB_RECIPIENT) {
  28       case USB_RECIPIENT_DEVICE:
  29         if ( udev->flags & USB_FLAG_REMOTE_WAKE) //.remote_wake_up == 1)
  30           buf[0] = USB_GETSTATUS_REMOTE_WAKEUP_ENABLED | USB_GETSTATUS_SELF_POWERED;
  31         else
  32           buf[0] = USB_GETSTATUS_SELF_POWERED;
  33         break;
  34       case USB_RECIPIENT_INTERFACE:
  35         break;
  36       case USB_RECIPIENT_ENDPOINT:
  37 /*        if ( epid & USB_ENDPOINT_DIRECTION_MASK)
  38           c = pdiSelectEp(pdiEp2Idx(epid)); // endpoint in
  39         else
  40           c = pdiSelectEp(pdiEp2Idx(epid));     // endpoint Out
  41           #ifdef PDIUSBD12
  42           buf[0] = (( c & PDI_SELEP_STALL) == PDI_SELEP_STALL);
  43           #else
  44           buf[0] = 0;
  45           #endif*/
  46         break;
  47       default:
  48         return USB_COMPLETE_FAIL;
  49     }
  50     usb_udev_write_endpoint( ep0, buf, 2);
  51     return USB_COMPLETE_OK;
  52   }
  53
  54   int usb_stdreq_clear_feature( usb_device_t *udev)
  55   {
  56     USB_DEVICE_REQUEST *dreq = &(udev->request);
  57     unsigned char epid = (unsigned char) dreq->wIndex;
  58
  59     usb_debug_print( DEBUG_LEVEL_HIGH, ("ClearFeature\n"));
  60     switch( dreq->bmRequestType & USB_RECIPIENT) {
  61       case USB_RECIPIENT_DEVICE:
  62         if ( dreq->wValue == USB_FEATURE_REMOTE_WAKEUP) {
  63           udev->flags &= ~USB_FLAG_REMOTE_WAKE; //.remote_wake_up = 0;
  64           usb_udev_ack_setup( udev);
  65           return USB_COMPLETE_OK;
  66         }
  67         break;
  68       case USB_RECIPIENT_ENDPOINT:
  69         if ( dreq->wValue == USB_FEATURE_ENDPOINT_STALL) {
  70           lpc_usb_clrstallEP(epid);
  71           usb_udev_ack_setup( udev);
  72           //initialize state of ulan convertor
  73           switch (epid&(USB_ENDPOINT_DIRECTION_MASK|0x03)) {
  74             case 0x01:                          //rx USB -> tx ulan
  75 //            ul_freemsg(ep1_dcnv_state.tx_fd);
  76 //              ep1_dcnv_state.tx_2send=-1;
  77               break;
  78             case 0x81:                          //tx USB -> rx ulan
  79 //            ul_freemsg(ep1_dcnv_state.rx_fd);
  80 //              ep1_dcnv_state.rx_2rec=-1;
  81 //              ep1_dcnv_state.rx_wait4host=0;
  82               break;
  83           }
  84           return USB_COMPLETE_OK;
  85         }
  86         break;
  87     }
  88     return USB_COMPLETE_FAIL;
  89   }
  90
  91   int usb_stdreq_set_feature( usb_device_t *udev)
  92   {
  93     USB_DEVICE_REQUEST *dreq = &(udev->request);
  94     unsigned char epid = (unsigned char) dreq->wIndex;
  95
  96     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetFeature\n"));
  97     switch( dreq->bmRequestType & USB_RECIPIENT) {
  98       case USB_RECIPIENT_DEVICE:
  99         if ( dreq->wValue == USB_FEATURE_REMOTE_WAKEUP) {
 100           udev->flags |= USB_FLAG_REMOTE_WAKE; //.remote_wake_up = 1;
 101           lpc_usb_setstallEP (epid);
 102           usb_udev_ack_setup( udev);
 103           return USB_COMPLETE_OK;
 104         }
 105         break;
 106       case USB_RECIPIENT_ENDPOINT:
 107         if ( dreq->wValue == USB_FEATURE_ENDPOINT_STALL) {
 108           usb_udev_ack_setup( udev);
 109           return USB_COMPLETE_OK;
 110         }
 111         break;
 112     }
 113     return USB_COMPLETE_FAIL;
 114   }
 115
 116   int usb_stdreq_set_address( usb_device_t *udev)
 117   {
 118     int adr;
 119     USB_DEVICE_REQUEST *dreq = &(udev->request);
 120     adr=dreq->wValue & DEVICE_ADDRESS_MASK;
 121     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetAddr-%d\n",adr));
 122     usb_udev_ack_setup( udev);
 123     lpc_usb_set_addr(adr);
 124     return USB_COMPLETE_OK;
 125   }
 126
 127   int usb_stdreq_get_configuration( usb_device_t *udev)
 128   {
 129     unsigned char buf = udev->configuration; //usb_flags.configured;
 130     usb_ep_t *ep0 = &(udev->ep0);
 131     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetConfig\n"));
 132     usb_udev_write_endpoint( ep0, &buf, 1);
 133     return USB_COMPLETE_OK;
 134   }
 135
 136   int usb_stdreq_set_configuration( usb_device_t *udev)
 137   {
 138     USB_DEVICE_REQUEST *dreq = &(udev->request);
 139     unsigned char iCfg = dreq->wValue & 0xff;
 140     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetConfig\n"));
 141     if ( iCfg < 2) {       // put device in unconfigured state or set configuration 1 ( no else)
 142       usb_udev_ack_setup( udev);
 143       lpc_usb_config_device(iCfg);
 144       if ( iCfg) {
 145         udev->flags |= USB_FLAG_CONFIGURED;
 146         lpc_usb_configEP(0x01,USB_MAX_PACKET0);
 147         lpc_usb_configEP(0x81,USB_MAX_PACKET0);
 148       } else {
 149         udev->flags &= ~USB_FLAG_CONFIGURED;
 150       }
 151       udev->configuration = iCfg;  //usb_flags.configured = iCfg;
 152       return USB_COMPLETE_OK;
 153     } else
 154       return USB_COMPLETE_FAIL;
 155   }
 156
 157   int usb_stdreq_get_interface( usb_device_t *udev)
 158   {
 159     unsigned char buf = 0; /// udev->interface
 160     usb_ep_t *ep0 = &(udev->ep0);
 161     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetIface\n"));
 162     usb_udev_write_endpoint( ep0, &buf, 1);
 163     return USB_COMPLETE_OK;
 164   }
 165
 166   int usb_stdreq_set_interface( usb_device_t *udev)
 167   {
 168     USB_DEVICE_REQUEST *dreq = &(udev->request);
 169
 170     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetIface\n"));
 171     if (( dreq->wValue == 0) && ( dreq->wIndex == 0)) {
 172       usb_udev_ack_setup( udev);
 173       return USB_COMPLETE_OK;
 174     } else {
 175       return USB_COMPLETE_FAIL;
 176     }
 177   }
 178
 179   int usb_stdreq_get_descriptor( usb_device_t *udev)
 180   {
 181     unsigned char *pDesc;
 182     unsigned short Len = 0;
 183     USB_DEVICE_REQUEST *dreq = &(udev->request);
 184     int i;
 185
 186     i = (dreq->wValue >> 8) & 0xff; /* MSB part of wValue */
 187     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetDesc\n"));
 188     usb_debug_print( DEBUG_LEVEL_VERBOSE, ( " - %s desc.\n", /*(unsigned int)*/ usb_debug_get_std_descriptor(i)));
 189
 190     switch (i) {
 191       case USB_DESCRIPTOR_TYPE_DEVICE:
 192         pDesc = (unsigned char *)&DeviceDescription;
 193         Len = sizeof( USB_DEVICE_DESCRIPTOR);
 194         break;
 195       case USB_DESCRIPTOR_TYPE_CONFIGURATION:
 196         pDesc = (unsigned char *)&ConfigDescription;
 197         Len = CONFIG_DESCRIPTOR_LENGTH;
 198         break;
 199       case USB_DESCRIPTOR_TYPE_INTERFACE:
 200         pDesc = (unsigned char *)&ConfigDescription.interface;
 201         Len = sizeof( USB_INTERFACE_DESCRIPTOR);
 202         break;
 203       case USB_DESCRIPTOR_TYPE_STRING:
 204         i = dreq->wValue & 0xff; /* LSB part of wValue */
 205         /*printf("Get descriptor indx=0x%02x\n", i);*/
 206         if ( i < CNT_STRINGS) {
 207           pDesc = (unsigned char *) StringDescriptors[ i];
 208           Len = *pDesc;
 209           /*usb_debug_print(0,("indx=0x%02x ptr=%p len=%d : '%c'\n", i, pDesc, Len, pDesc[2]));*/
 210         } else {
 211           return USB_COMPLETE_FAIL;
 212         }
 213         break;
 214       default:
 215         return USB_COMPLETE_FAIL;
 216     }
 217     if ( dreq->wLength < Len) Len = dreq->wLength;
 218     usb_send_control_data( udev, pDesc, Len);
 219     return USB_COMPLETE_OK;
 220   }
 221
 222
 223 /*
 224   void usb_init_stdreq_fnc( usb_device_t *udev)
 225   {
 226     // memset( udev->stdreq, 0, sizeof(udev->stdreq));
 227
 228     udev->stdreq[USB_REQUEST_GET_STATUS] = usb_stdreq_get_status;
 229     udev->stdreq[USB_REQUEST_CLEAR_FEATURE] = usb_stdreq_clear_feature;
 230     udev->stdreq[USB_REQUEST_SET_FEATURE] = usb_stdreq_set_feature;
 231     udev->stdreq[USB_REQUEST_SET_ADDRESS] = usb_stdreq_set_address;
 232     udev->stdreq[USB_REQUEST_GET_DESCRIPTOR] = usb_stdreq_get_descriptor;
 233     udev->stdreq[USB_REQUEST_GET_CONFIGURATION] = usb_stdreq_get_configuration;
 234     udev->stdreq[USB_REQUEST_SET_CONFIGURATION] = usb_stdreq_set_configuration;
 235     udev->stdreq[USB_REQUEST_GET_INTERFACE] = usb_stdreq_get_interface;
 236     udev->stdreq[USB_REQUEST_SET_INTERFACE] = usb_stdreq_set_interface;
 237   }
 238 */