embedded/libs4c/usb/more/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
  15   // ****************************
  16   int usb_stdreq_get_status( usb_device_t *udev)
  17   {
  18     unsigned char c, buf[2] = { 0, 0};
  19     unsigned char epid = (unsigned char) udev->request.wIndex;
  20     usb_ep_t *ep0 = &(udev->ep0);
  21
  22     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetStatus\n"));
  23     switch( udev->request.bmRequestType & USB_RECIPIENT) {
  24       case USB_RECIPIENT_DEVICE:
  25         if ( udev->flags & USB_FLAG_REMOTE_WAKE) //.remote_wake_up == 1)
  26           buf[0] = USB_GETSTATUS_REMOTE_WAKEUP_ENABLED | USB_GETSTATUS_SELF_POWERED;
  27         else
  28           buf[0] = USB_GETSTATUS_SELF_POWERED;
  29         break;
  30       case USB_RECIPIENT_INTERFACE:
  31         break;
  32       case USB_RECIPIENT_ENDPOINT:
  33        #if 0
  34         if ( epid & USB_ENDPOINT_DIRECTION_MASK)
  35           c = pdiSelectEp(pdiEp2Idx(epid)); // endpoint in
  36         else
  37           c = pdiSelectEp(pdiEp2Idx(epid));     // endpoint Out
  38           #ifdef PDIUSBD12
  39           buf[0] = (( c & PDI_SELEP_STALL) == PDI_SELEP_STALL);
  40           #else
  41           buf[0] = 0;
  42           #endif
  43        #endif
  44        #warning usb_stdreq_get_status is DUMMY
  45         break;
  46       default:
  47         return USB_COMPLETE_FAIL;
  48     }
  49     usb_udev_write_endpoint( ep0, buf, 2);
  50     return USB_COMPLETE_OK;
  51   }
  52
  53   int usb_stdreq_clear_feature( usb_device_t *udev)
  54   {
  55     usb_ep_t *ep = NULL;
  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(!epid) {
  70           ep = &udev->ep0;
  71         } else {
  72           unsigned char i;
  73           for(i = 0; i < udev->cntep; i++) {
  74             if(udev->ep[i].epnum == epid) {
  75               ep = &udev->ep[i];
  76             }
  77           }
  78           if(!ep)
  79             break;
  80         }
  81         if ( dreq->wValue == USB_FEATURE_ENDPOINT_STALL) {
  82           usb_udev_unstall(ep);
  83           usb_udev_ack_setup( udev);
  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_ep_t *ep = NULL;
  94     USB_DEVICE_REQUEST *dreq = &(udev->request);
  95     unsigned char epid = (unsigned char) dreq->wIndex;
  96
  97     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetFeature\n"));
  98     switch( dreq->bmRequestType & USB_RECIPIENT) {
  99       case USB_RECIPIENT_DEVICE:
 100         if ( dreq->wValue == USB_FEATURE_REMOTE_WAKEUP) {
 101           udev->flags |= USB_FLAG_REMOTE_WAKE; //.remote_wake_up = 1;
 102           usb_udev_ack_setup( udev);
 103           return USB_COMPLETE_OK;
 104         }
 105         break;
 106       case USB_RECIPIENT_ENDPOINT:
 107         if(!epid) {
 108           ep = &udev->ep0;
 109         } else {
 110           unsigned char i;
 111           for(i = 0; i < udev->cntep; i++) {
 112             if(udev->ep[i].epnum == epid) {
 113               ep = &udev->ep[i];
 114             }
 115           }
 116           if(!ep)
 117             break;
 118         }
 119         if ( dreq->wValue == USB_FEATURE_ENDPOINT_STALL) {
 120           usb_udev_stall(ep);
 121           usb_udev_ack_setup( udev);
 122           return USB_COMPLETE_OK;
 123         }
 124         break;
 125     }
 126     return USB_COMPLETE_FAIL;
 127   }
 128
 129   int usb_stdreq_set_address( usb_device_t *udev)
 130   {
 131     int adr;
 132     USB_DEVICE_REQUEST *dreq = &(udev->request);
 133     adr=dreq->wValue & DEVICE_ADDRESS_MASK;
 134     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetAddr-%d\n",adr));
 135     usb_udev_ack_setup( udev);
 136     usb_udev_set_addr( udev, adr);
 137     return USB_COMPLETE_OK;
 138   }
 139
 140   int usb_stdreq_get_configuration( usb_device_t *udev)
 141   {
 142     unsigned char buf = udev->configuration; //usb_flags.configured;
 143     usb_ep_t *ep0 = &(udev->ep0);
 144     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetConfig\n"));
 145     usb_udev_write_endpoint( ep0, &buf, 1);
 146     return USB_COMPLETE_OK;
 147   }
 148
 149   int usb_stdreq_set_configuration( usb_device_t *udev)
 150   {
 151     USB_DEVICE_REQUEST *dreq = &(udev->request);
 152     unsigned char iCfg = dreq->wValue & 0xff;
 153     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetConfig\n"));
 154     while (1) {       // put device in unconfigured state or set configuration 1 ( no else)
 155       const USB_DEVICE_CONFIGURATION_ENTRY *pcd = udev->devdes_table->pConfigurations;
 156       if(iCfg) {
 157         unsigned char i = udev->devdes_table->bNumConfigurations;
 158         for(; i && (pcd->pConfigDescription->bConfigurationValue != iCfg); i--, pcd++);
 159         if(!i)
 160           break;
 161       }
 162
 163       udev->flags &= ~USB_FLAG_CONFIGURED;
 164
 165       usb_udev_ack_setup( udev);
 166
 167       usb_udev_set_configuration( udev, iCfg);
 168
 169       udev->configuration = iCfg;  //usb_flags.configured = iCfg;
 170
 171       if(iCfg)
 172         udev->flags |= USB_FLAG_CONFIGURED;
 173
 174       return USB_COMPLETE_OK;
 175     }
 176     return USB_COMPLETE_FAIL;
 177   }
 178
 179   int usb_stdreq_get_interface( usb_device_t *udev)
 180   {
 181     unsigned char buf = 0; /// udev->interface
 182     usb_ep_t *ep0 = &(udev->ep0);
 183     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetIface\n"));
 184     usb_udev_write_endpoint( ep0, &buf, 1);
 185     return USB_COMPLETE_OK;
 186   }
 187
 188   int usb_stdreq_set_interface( usb_device_t *udev)
 189   {
 190     USB_DEVICE_REQUEST *dreq = &(udev->request);
 191
 192     usb_debug_print( DEBUG_LEVEL_HIGH, ("SetIface\n"));
 193     if (( dreq->wValue == 0) && ( dreq->wIndex == 0)) {
 194       usb_udev_ack_setup( udev);
 195       return USB_COMPLETE_OK;
 196     } else {
 197       return USB_COMPLETE_FAIL;
 198     }
 199   }
 200
 201   int usb_stdreq_get_descriptor( usb_device_t *udev)
 202   {
 203     unsigned char confidx;
 204     unsigned char *pDesc;
 205     unsigned short Len = 0;
 206     USB_DEVICE_REQUEST *dreq = &(udev->request);
 207     const USB_DEVICE_CONFIGURATION_ENTRY *pconfent;
 208     int i;
 209
 210     i = (dreq->wValue >> 8) & 0xff; /* MSB part of wValue */
 211     usb_debug_print( DEBUG_LEVEL_HIGH, ("GetDesc\n"));
 212     usb_debug_print( DEBUG_LEVEL_VERBOSE, ( " - %s desc.\n", /*(unsigned int)*/ usb_debug_get_std_descriptor(i)));
 213
 214     switch (i) {
 215       case USB_DESCRIPTOR_TYPE_DEVICE:
 216         pDesc = (unsigned char *)udev->devdes_table->pDeviceDescription;
 217         Len = sizeof( USB_DEVICE_DESCRIPTOR);
 218         break;
 219       case USB_DESCRIPTOR_TYPE_CONFIGURATION:
 220         /* FIXME confidx = udev->configuration; */
 221         confidx = 0;
 222         pconfent = &udev->devdes_table->pConfigurations[confidx];
 223         pDesc = (unsigned char *)pconfent->pConfigDescription;
 224         Len = pconfent->iConfigTotalLength;
 225         break;
 226       case USB_DESCRIPTOR_TYPE_INTERFACE:
 227         /* FIXME multiple interfaces */
 228         pDesc = (unsigned char *)udev->devdes_table->pInterfaceDescriptors[0];
 229         Len = sizeof( USB_INTERFACE_DESCRIPTOR);
 230         break;
 231       case USB_DESCRIPTOR_TYPE_STRING:
 232         i = dreq->wValue & 0xff; /* LSB part of wValue */
 233         /*printf("Get descriptor indx=0x%02x\n", i);*/
 234         if ( i < udev->devdes_table->iNumStrings) {
 235           pDesc = (unsigned char *) udev->devdes_table->pStrings[i];
 236           Len = *pDesc;
 237           /*usb_debug_print(0,("indx=0x%02x ptr=%p len=%d : '%c'\n", i, pDesc, Len, pDesc[2]));*/
 238         } else {
 239           return USB_COMPLETE_FAIL;
 240         }
 241         break;
 242       default:
 243         return USB_COMPLETE_FAIL;
 244     }
 245     if ( dreq->wLength < Len) Len = dreq->wLength;
 246     usb_send_control_data( udev, pDesc, Len);
 247     return USB_COMPLETE_OK;
 248   }
 249
 250
 251 /*
 252   void usb_init_stdreq_fnc( usb_device_t *udev)
 253   {
 254     // memset( udev->stdreq, 0, sizeof(udev->stdreq));
 255
 256     udev->stdreq[USB_REQUEST_GET_STATUS] = usb_stdreq_get_status;
 257     udev->stdreq[USB_REQUEST_CLEAR_FEATURE] = usb_stdreq_clear_feature;
 258     udev->stdreq[USB_REQUEST_SET_FEATURE] = usb_stdreq_set_feature;
 259     udev->stdreq[USB_REQUEST_SET_ADDRESS] = usb_stdreq_set_address;
 260     udev->stdreq[USB_REQUEST_GET_DESCRIPTOR] = usb_stdreq_get_descriptor;
 261     udev->stdreq[USB_REQUEST_GET_CONFIGURATION] = usb_stdreq_get_configuration;
 262     udev->stdreq[USB_REQUEST_SET_CONFIGURATION] = usb_stdreq_set_configuration;
 263     udev->stdreq[USB_REQUEST_GET_INTERFACE] = usb_stdreq_get_interface;
 264     udev->stdreq[USB_REQUEST_SET_INTERFACE] = usb_stdreq_set_interface;
 265   }
 266 */