Example #1
0
        static bool ConfigurePinger(UsbController port)
        {
            UsbController.PortState portState = port.Status;

            if (portState != UsbController.PortState.Stopped)
            {
                Debug.Print("The controller has already been initialized and is in state " + portState.ToString() + ".");
                // return false;
            }

            // Create the device descriptor
            Configuration.DeviceDescriptor device = new Configuration.DeviceDescriptor(0x15A2, 0x0026, 0x0100);
            device.iManufacturer = 1;       // String 1 is the manufacturer name
            device.iProduct = 2;       // String 2 is the product name
            device.bcdUSB = 0x0110;  // USB version 1.10

            // Create the simple configuration descriptor
            Configuration.Endpoint endpoint1 = new Configuration.Endpoint(1, Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Write);
            Configuration.Endpoint endpoint2 = new Configuration.Endpoint(2, Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Read);
            endpoint1.wMaxPacketSize = 64;
            endpoint2.wMaxPacketSize = 64;      // Pinger endpoints use the maximum allowable buffer
            Configuration.Endpoint[] endpoints = new Configuration.Endpoint[2] { endpoint1, endpoint2 };
            // Assign the endpoints to the interface and set up the interface fields
            Configuration.UsbInterface UsbInterface0 = new Configuration.UsbInterface(0, endpoints);
            UsbInterface0.bInterfaceClass = 0xFF;    // Vendor class
            UsbInterface0.bInterfaceSubClass = 1;
            UsbInterface0.bInterfaceProtocol = 1;
            // Finish by assigning the interfaces to the configuration descriptor
            Configuration.UsbInterface[] UsbInterfaces = new Configuration.UsbInterface[1] { UsbInterface0 };
            Configuration.ConfigurationDescriptor config = new Configuration.ConfigurationDescriptor(280, UsbInterfaces);

            // Create the standard strings needed for the iMXS board Pinger
            Configuration.StringDescriptor manufacturerName = new Configuration.StringDescriptor(1, "Freescale");
            Configuration.StringDescriptor productName = new Configuration.StringDescriptor(2, "Micro Framework MXS Reference ");
            Configuration.StringDescriptor displayName = new Configuration.StringDescriptor(4, "iMXS");
            Configuration.StringDescriptor friendlyName = new Configuration.StringDescriptor(5, "a7e70ea2");

            // Create the Sideshow OS String descriptor as if it were a standard string descriptor
            Configuration.StringDescriptor OS_StringDescriptor = new Configuration.StringDescriptor(0xEE, "MSFT100\xA5");

            // Create the Sideshow OS Extended Compatible ID Descriptor as a Generic
            byte[] compatibleIdPayload = new byte[]
            {
                40, 0, 0, 0,    // Size of the payload
                00, 1,          // Version 1.00
                04, 0,          // OS Compatible ID request
                1,              // Interface count
                0,0,0,0,0,0,0,  // padding (7 zeros)

                0,              // Interface number
                1,              // reserved
                (byte)'S', (byte)'I', (byte)'D', (byte)'E', (byte)'S', (byte)'H', (byte)'W', 0,     // Compatible ID
                (byte)'E', (byte)'N', (byte)'H', (byte)'V', (byte)'1',         0,         0, 0,     // Sub-compatible ID
                0,0,0,0,0,0     // padding (6 zeros)
            };
            // Assign the payload to the generic and fill in the generic descriptor fields
            const byte RequestType = Configuration.GenericDescriptor.REQUEST_IN | Configuration.GenericDescriptor.REQUEST_Vendor;
            const byte RequestCommand = 0xA5;
            const byte XCompatibleOsRequest = 4;
            Configuration.GenericDescriptor XCompatibleOsDescriptor = new Configuration.GenericDescriptor(RequestType, 0, compatibleIdPayload);
            XCompatibleOsDescriptor.bRequest = RequestCommand;
            XCompatibleOsDescriptor.wIndex = XCompatibleOsRequest;

            // Now assemble all of these descriptors into the final configuration
            Configuration simpleConfig = new Configuration();
            simpleConfig.descriptors = new Configuration.Descriptor[]
            {
                device,
                config,
                manufacturerName,
                productName,
                displayName,
                friendlyName,
                OS_StringDescriptor,
                XCompatibleOsDescriptor,
            };

            try
            {
                // Set the configuration to the USB Controller
                port.Configuration = simpleConfig;

                if (port.ConfigurationError != UsbController.ConfigError.ConfigOK)
                {
                    Debug.Print("Simple configuration reported an error " + port.ConfigurationError.ToString());
                    return false;
                }

                // Kick the USB Controller into action
                if (!port.Start())
                {
                    Debug.Print("Simple USB could not be started.");
                    return false;
                }
            }
            catch (ArgumentException)
            {
                Debug.Print("Couldn't configure Simple USB due to error " + port.ConfigurationError.ToString());
                return false;
            }

            const int MaxTenths = 20;       // Wait up to two seconds for controller to finish handshake
            int tenths;
            for (tenths = 0; tenths < MaxTenths; tenths++)
            {
                if (port.Status == UsbController.PortState.Running)     // If host has finished with handshake
                    break;
                System.Threading.Thread.Sleep(100);
            }
            if (tenths < MaxTenths)
                return true;

            Debug.Print("After " + MaxTenths.ToString() + " tenths of a second, Simple USB still had status of " + port.Status.ToString());
            return false;
        }
Example #2
0
        static bool ConfigureMouseAndPinger(UsbController port)
        {
            UsbController.PortState portState = port.Status;

            if (portState != UsbController.PortState.Stopped)
            {
                Debug.Print("The controller has already been initialized and is in state " + portState.ToString() + ".");
                // return false;
            }

            // Create the device descriptor
            Configuration.DeviceDescriptor device = new Configuration.DeviceDescriptor(0x15A2, 0x0026, 0x0100);
            device.iManufacturer = 1;       // String 1 is the manufacturer name
            device.iProduct = 2;       // String 2 is the product name
            device.bcdUSB = 0x0110;  // USB version 1.10

            // Create the compound configuration descriptor
            Configuration.Endpoint endpoint1 = new Configuration.Endpoint(1, Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Write);
            Configuration.Endpoint endpoint2 = new Configuration.Endpoint(2, Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Read);
            Configuration.Endpoint endpoint3 = new Configuration.Endpoint(3, Configuration.Endpoint.ATTRIB_Interrupt | Configuration.Endpoint.ATTRIB_Write);
            endpoint1.wMaxPacketSize = 64;
            endpoint2.wMaxPacketSize = 64;      // Pinger endpoints use the maximum allowable buffer
            endpoint3.wMaxPacketSize = 8;       // Mouse data requires only eight bytes
            endpoint3.bInterval = 10;      // Host should request data from mouse every 10 mS
            Configuration.Endpoint[] pingerEndpoints = new Configuration.Endpoint[2] { endpoint1, endpoint2 };
            Configuration.Endpoint[] mouseEndpoints = new Configuration.Endpoint[1] { endpoint3 };
            // Set up the Pinger interface
            Configuration.UsbInterface UsbInterface0 = new Configuration.UsbInterface(0, pingerEndpoints);
            UsbInterface0.bInterfaceClass = 0xFF;    // Vendor class
            UsbInterface0.bInterfaceSubClass = 1;
            UsbInterface0.bInterfaceProtocol = 1;
            // Set up the Mouse interface
            Configuration.UsbInterface UsbInterface1 = new Configuration.UsbInterface(1, mouseEndpoints);
            UsbInterface1.bInterfaceClass = 3;    // HID interface
            UsbInterface1.bInterfaceSubClass = 1;    // Boot device
            UsbInterface1.bInterfaceProtocol = 2;    // Standard mouse protocol
            // Assemble the HID class descriptor
            byte[] HidPayload = new byte[]
            {
                0x01, 0x01,     // bcdHID = HID version 1.01
                0x00,           // bCountryCode (unimportant)
                0x01,           // bNumDescriptors = number of descriptors available for this device
                0x22,           // bDescriptorType = Report descriptor
                0x32, 0x00      // Total size of Report descriptor (50)
            };
            UsbInterface1.classDescriptors = new Configuration.ClassDescriptor[1];
            UsbInterface1.classDescriptors[0] = new Configuration.ClassDescriptor(0x21, HidPayload);
            Configuration.UsbInterface[] UsbInterfaces = new Configuration.UsbInterface[2] { UsbInterface0, UsbInterface1 };
            Configuration.ConfigurationDescriptor config = new Configuration.ConfigurationDescriptor(280, UsbInterfaces);

            // Create the report descriptor as a Generic
            // This data was created using 
            byte[] BootMouseReportPayload = new byte[]
            {
                0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
                0x09, 0x02,                    // USAGE (Mouse)
                0xa1, 0x01,                    // COLLECTION (Application)
                0x09, 0x01,                    //   USAGE (Pointer)
                0xa1, 0x00,                    //   COLLECTION (Physical)
                0x05, 0x09,                    //     USAGE_PAGE (Button)
                0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
                0x29, 0x03,                    //     USAGE_MAXIMUM (Button 3)
                0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
                0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
                0x95, 0x03,                    //     REPORT_COUNT (3)
                0x75, 0x01,                    //     REPORT_SIZE (1)
                0x81, 0x02,                    //     INPUT (Data,Var,Abs)
                0x95, 0x01,                    //     REPORT_COUNT (1)
                0x75, 0x05,                    //     REPORT_SIZE (5)
                0x81, 0x01,                    //     INPUT (Cnst,Ary,Abs)
                0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
                0x09, 0x30,                    //     USAGE (X)
                0x09, 0x31,                    //     USAGE (Y)
                0x15, 0x81,                    //     LOGICAL_MINIMUM (-127)
                0x25, 0x7f,                    //     LOGICAL_MAXIMUM (127)
                0x75, 0x08,                    //     REPORT_SIZE (8)
                0x95, 0x02,                    //     REPORT_COUNT (2)
                0x81, 0x06,                    //     INPUT (Data,Var,Rel)
                0xc0,                          //     END_COLLECTION
                0xc0                           // END_COLLECTION
            };
            const byte DescriptorRequest = 0x81;
            const byte ReportDescriptor = 0x22;
            const byte GetDescriptor = 0x06;
            const ushort Report_wValue = (ushort)ReportDescriptor << 8;
            Configuration.GenericDescriptor mouseReportDescriptor = new Configuration.GenericDescriptor(DescriptorRequest, Report_wValue, BootMouseReportPayload);
            mouseReportDescriptor.bRequest = GetDescriptor;
            mouseReportDescriptor.wIndex = 1;        // The interface number

            // Create the standard strings needed for the iMXS board Pinger
            Configuration.StringDescriptor manufacturerName = new Configuration.StringDescriptor(1, "Freescale");
            Configuration.StringDescriptor productName = new Configuration.StringDescriptor(2, "Micro Framework MXS Reference ");
            Configuration.StringDescriptor displayName = new Configuration.StringDescriptor(4, "iMXS");
            Configuration.StringDescriptor friendlyName = new Configuration.StringDescriptor(5, "a7e70ea2");

            // Create the Sideshow OS String descriptor as if it were a standard string descriptor
            Configuration.StringDescriptor OS_StringDescriptor = new Configuration.StringDescriptor(0xEE, "MSFT100\xA5");

            // Create the Sideshow OS Extended Compatible ID Descriptor as a Generic
            byte[] compatibleIdPayload = new byte[]
            {
                40, 0, 0, 0,    // Size of the payload
                00, 1,          // Version 1.00
                04, 0,          // OS Compatible ID request
                1,              // Interface count
                0,0,0,0,0,0,0,  // padding (7 zeros)

                0,              // Interface number
                1,              // reserved
                (byte)'S', (byte)'I', (byte)'D', (byte)'E', (byte)'S', (byte)'H', (byte)'W', 0,     // Compatible ID
                (byte)'E', (byte)'N', (byte)'H', (byte)'V', (byte)'1',         0,         0, 0,     // Sub-compatible ID
                0,0,0,0,0,0     // padding (6 zeros)
            };
            // Create the report descriptor as a Generic
            const byte RequestType = Configuration.GenericDescriptor.REQUEST_IN | Configuration.GenericDescriptor.REQUEST_Vendor;
            const byte RequestCommand = 0xA5;
            const byte XCompatibleOsRequest = 4;
            Configuration.GenericDescriptor XCompatibleOsDescriptor = new Configuration.GenericDescriptor(RequestType, 0, compatibleIdPayload);
            XCompatibleOsDescriptor.bRequest = RequestCommand;
            XCompatibleOsDescriptor.wIndex = XCompatibleOsRequest;

            // Now assemble all of these descriptors into the final configuration
            Configuration compoundConfig = new Configuration();
            compoundConfig.descriptors = new Configuration.Descriptor[]
            {
                device,
                config,
                manufacturerName,
                productName,
                displayName,
                friendlyName,
                OS_StringDescriptor,
                XCompatibleOsDescriptor,
                mouseReportDescriptor
            };

            try
            {
                // Set the configuration to the USB Controller
                port.Configuration = compoundConfig;

                if (port.ConfigurationError != UsbController.ConfigError.ConfigOK)
                {
                    Debug.Print("Compound configuration reported an error " + port.ConfigurationError.ToString());
                    return false;
                }

                // Kick the USB Controller into action
                if (!port.Start())
                {
                    Debug.Print("Compound USB could not be started.");
                    return false;
                }
            }
            catch (ArgumentException)
            {
                Debug.Print("Couldn't configure Compound USB due to error " + port.ConfigurationError.ToString());
                return false;
            }

            const int MaxTenths = 20;       // Wait up to two seconds for controller to finish handshake
            int tenths;
            for (tenths = 0; tenths < MaxTenths; tenths++)
            {
                if (port.Status == UsbController.PortState.Running)     // If host has finished with handshake
                    break;
                System.Threading.Thread.Sleep(100);
            }
            if (tenths < MaxTenths)
                return true;

            Debug.Print("After " + MaxTenths.ToString() + " tenths of a second, Compound USB still had status of " + port.Status.ToString());
            return false;
        }
Example #3
0
        /// <summary>
        /// Configures the USB port.
        /// </summary>
        /// <param name="port"></param>
        /// <param name="fAddMouse"></param>
        private static void ConfigureUsbPort(UsbController port, bool fAddMouse)
        {
            try
            {
                bool fMouseConfigExists = false;
                Configuration configuration = port.Configuration;
                Configuration.DeviceDescriptor device;
                Configuration.ConfigurationDescriptor cfgDesc = null;
                int cfgDescIndex = 0;
                int mouseInterfaceIndex = 0;

                if (configuration == null)
                {
                    configuration = new Configuration();

                    // Create the device descriptor.
                    device = new Configuration.DeviceDescriptor(0xBADA, 0x0026,
                        0x0100);
                    device.bcdUSB = 0x110;
                    device.bDeviceClass = 0;
                    device.bDeviceSubClass = 0;
                    device.bDeviceProtocol = 0;
                    device.bMaxPacketSize0 = 8;
                    device.iManufacturer = 1; // String #1 is the manufacturer name.
                    device.iProduct = 2;      // String #2 is the product name.
                    device.iSerialNumber = 0;
                }
                else
                {
                    for (int i = 0; i < configuration.descriptors.Length; i++)
                    {
                        if (configuration.descriptors[i] is Configuration.ConfigurationDescriptor)
                        {
                            Configuration.ConfigurationDescriptor cfg =
                                (Configuration.ConfigurationDescriptor)configuration.descriptors[i];

                            // We make the assumption here that the second 
                            // interface is always a mouse.
                            for (int j = 0; j < cfg.interfaces.Length; j++)
                            {
                                if (cfg.interfaces[j].bInterfaceClass == 3 &&
                                    cfg.interfaces[j].bInterfaceProtocol == 2)
                                {
                                    fMouseConfigExists = true;
                                    mouseInterfaceIndex = j;
                                }
                            }
                            cfgDesc =
                                (Configuration.ConfigurationDescriptor)configuration.descriptors[i];
                            break;
                        }
                        cfgDescIndex++;
                    }

                    device = configuration.descriptors[0] as
                        Configuration.DeviceDescriptor;
                }

                if (fAddMouse && !fMouseConfigExists)
                {
                    Configuration.Endpoint endpoint = new Configuration.Endpoint(
                        3, Configuration.Endpoint.ATTRIB_Interrupt |
                        Configuration.Endpoint.ATTRIB_Write);
                    endpoint.wMaxPacketSize = 8; // Mouse data requires only eight bytes.
                    endpoint.bInterval = 10;     // Host should request data from mouse every 10 mS.

                    Configuration.Endpoint[] mouseEndpoints =
                        new Configuration.Endpoint[1] { endpoint };

                    // Set up the mouse interface.
                    Configuration.UsbInterface usbInterface =
                        new Configuration.UsbInterface(1, mouseEndpoints);
                    usbInterface.bInterfaceClass = 3;    // HID interface.
                    usbInterface.bInterfaceSubClass = 1; // Boot device.
                    usbInterface.bInterfaceProtocol = 2; // Standard mouse protocol.
                    usbInterface.iInterface = 1;    // Interface index.

                    // Assemble the HID class descriptor.
                    byte[] HidPayload = new byte[]
                    {
                        0x01, 0x01,     // bcdHID = HID version 1.01.
                        0x00,           // bCountryCode (unimportant).
                        0x01,           // bNumDescriptors = number of descriptors available for this device.
                        0x22,           // bDescriptorType = Report descriptor.
                        0x32, 0x00      // Total size of Report descriptor (50).
                    };

                    usbInterface.classDescriptors =
                        new Configuration.ClassDescriptor[1] { 
                            new Configuration.ClassDescriptor(0x21, HidPayload) };

                    if (cfgDesc == null)
                    {
                        Configuration.UsbInterface[] UsbInterfaces =
                            new Configuration.UsbInterface[1] { usbInterface };
                        cfgDesc = new Configuration.ConfigurationDescriptor(
                            280, UsbInterfaces);
                        mouseInterfaceIndex = 0;
                    }
                    else
                    {
                        Configuration.UsbInterface[] UsbInterfaces =
                            new Configuration.UsbInterface[cfgDesc.interfaces.Length + 1];

                        Array.Copy(cfgDesc.interfaces, UsbInterfaces,
                            cfgDesc.interfaces.Length);

                        UsbInterfaces[UsbInterfaces.Length - 1] = usbInterface;

                        mouseInterfaceIndex = UsbInterfaces.Length - 1;

                        cfgDesc.interfaces = UsbInterfaces;
                    }

                    // Create the report descriptor as a Generic.  This data was 
                    // created using...
                    byte[] BootMouseReportPayload = null;

                    BootMouseReportPayload = new byte[]
                    {
                        0x05, 0x01,  // USAGE_PAGE (Generic Desktop)
                        0x09, 0x02,  // USAGE (Mouse)
                        0xa1, 0x01,  // COLLECTION (Application)
                        0x09, 0x01,  //   USAGE (Pointer)
                        0xa1, 0x00,  //   COLLECTION (Physical)
                        0x05, 0x09,  //     USAGE_PAGE (Button)
                        0x19, 0x01,  //     USAGE_MINIMUM (Button 1)
                        0x29, 0x03,  //     USAGE_MAXIMUM (Button 3)
                        0x15, 0x00,  //     LOGICAL_MINIMUM (0)
                        0x25, 0x01,  //     LOGICAL_MAXIMUM (1)
                        0x95, 0x03,  //     REPORT_COUNT (3)
                        0x75, 0x01,  //     REPORT_SIZE (1)
                        0x81, 0x02,  //     INPUT (Data,Var,Abs)
                        0x95, 0x01,  //     REPORT_COUNT (1)
                        0x75, 0x05,  //     REPORT_SIZE (5)
                        0x81, 0x01,  //     INPUT (Cnst,Ary,Abs)
                        0x05, 0x01,  //     USAGE_PAGE (Generic Desktop)
                        0x09, 0x30,  //     USAGE (X)
                        0x09, 0x31,  //     USAGE (Y)
                        0x15, 0x81,  //     LOGICAL_MINIMUM (-127)
                        0x25, 0x7f,  //     LOGICAL_MAXIMUM (127)
                        0x75, 0x08,  //     REPORT_SIZE (8)
                        0x95, 0x02,  //     REPORT_COUNT (2)
                        0x81, 0x06,  //     INPUT (Data,Var,Rel)
                        0xc0,        //   END_COLLECTION
                        0xc0         // END_COLLECTION
                    };

                    const byte DescriptorRequest = 0x81;
                    const byte ReportDescriptor = 0x22;
                    const byte GetDescriptor = 0x06;
                    const ushort Report_wValue = (ushort)ReportDescriptor << 8;
                    Configuration.GenericDescriptor mouseReportDescriptor =
                        new Configuration.GenericDescriptor(DescriptorRequest,
                            Report_wValue, BootMouseReportPayload);
                    mouseReportDescriptor.bRequest = GetDescriptor;
                    mouseReportDescriptor.wIndex =
                        (ushort)(mouseInterfaceIndex);  // The interface number.

                    Configuration.StringDescriptor manufacturerName;
                    Configuration.StringDescriptor productName;
                    Configuration.StringDescriptor displayName;
                    Configuration.StringDescriptor friendlyName;

                    // Create the standard strings for the USB device
                    manufacturerName = new Configuration.StringDescriptor(
                        1, "Sample Manufacturer");
                    productName = new Configuration.StringDescriptor(
                        2, "Micro Framework Mouse Sample");
                    displayName = new Configuration.StringDescriptor(
                        4, "Micro Framework Mouse");
                    friendlyName = new Configuration.StringDescriptor(
                        5, "NetMF_Mouse");

                    if (configuration.descriptors == null)
                    {
                        configuration.descriptors =
                            new Configuration.Descriptor[]
                        {
                            device,
                            cfgDesc,
                            manufacturerName,
                            productName,
                            displayName,
                            friendlyName,
                            mouseReportDescriptor
                        };
                    }
                    else
                    {
                        int descLength = configuration.descriptors.Length;

                        Configuration.Descriptor[] descriptors =
                            new Configuration.Descriptor[descLength + 1];

                        Array.Copy(configuration.descriptors, descriptors,
                            descLength);

                        descriptors[cfgDescIndex] = cfgDesc;
                        descriptors[descLength] = mouseReportDescriptor;

                        configuration.descriptors = descriptors;
                    }
                }
                else if (!fAddMouse && fMouseConfigExists)
                {
                    Configuration.UsbInterface[] UsbInterfaces =
                        new Configuration.UsbInterface[cfgDesc.interfaces.Length - 1];

                    Array.Copy(cfgDesc.interfaces, UsbInterfaces,
                        cfgDesc.interfaces.Length - 1);

                    // Make sure we are removing the correct interface.
                    if (mouseInterfaceIndex != (cfgDesc.interfaces.Length - 1))
                    {
                        cfgDesc.interfaces[mouseInterfaceIndex] =
                            cfgDesc.interfaces[cfgDesc.interfaces.Length - 1];
                    }

                    cfgDesc.interfaces = UsbInterfaces;

                    configuration.descriptors[cfgDescIndex] = cfgDesc;
                }

                port.Stop();

                // Give the PC some time to unload the driver.
                Thread.Sleep(500);

                port.Configuration = configuration;

                if (port.ConfigurationError !=
                    UsbController.ConfigError.ConfigOK)
                {
                    Debug.Print("Compound configuration reported an error " +
                        port.ConfigurationError.ToString());
                }

                // Kick the USB controller into action.
                if (!port.Start())
                {
                    Debug.Print("Compound USB could not be started.");
                }
            }
            catch (ArgumentException)
            {
                try
                {
                    // Try to recover from a bad USB configuration.
                    port.Configuration = null;
                    port.Start();
                }
                catch
                {
                }

                Debug.Print("Couldn't configure Compound USB due to error " +
                    port.ConfigurationError.ToString());
            }
        }
Example #4
0
        private static bool ConfigureUSBController(UsbController usbController)
        {
            bool bRet = false;

            // Create the device descriptor

            Configuration.DeviceDescriptor device = new Configuration.DeviceDescriptor(0xDEAD, 0x0110, 0x0200);
            device.bcdUSB = 0x110;
            device.bDeviceClass = 0xFF;     // Vendor defined class
            device.bDeviceSubClass = 0xFF;     // Vendor defined subclass
            device.bDeviceProtocol = 0;
            device.bMaxPacketSize0 = 8;        // Maximum packet size of EP0
            device.iManufacturer = 1;        // String #1 is manufacturer name (see string descriptors below)
            device.iProduct = 2;        // String #2 is product name
            device.iSerialNumber = 3;        // String #3 is the serial number

            // Create the endpoints
            Configuration.Endpoint writeEP = new Configuration.Endpoint(WRITE_EP, Configuration.Endpoint.ATTRIB_Write | Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Synchronous);//Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Write);
            writeEP.wMaxPacketSize = 64;
            writeEP.bInterval = 0;

            Configuration.Endpoint readEP = new Configuration.Endpoint(READ_EP, Configuration.Endpoint.ATTRIB_Read | Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Synchronous);// Configuration.Endpoint.ATTRIB_Bulk | Configuration.Endpoint.ATTRIB_Read);
            readEP.wMaxPacketSize = 64;
            readEP.bInterval = 0;

            Configuration.Endpoint[] usbEndpoints = new Configuration.Endpoint[] { writeEP, readEP };

            // Set up the USB interface
            Configuration.UsbInterface usbInterface = new Configuration.UsbInterface(0, usbEndpoints);
            usbInterface.bInterfaceClass = 0xFF; // Vendor defined class
            usbInterface.bInterfaceSubClass = 0xFF; // Vendor defined subclass
            usbInterface.bInterfaceProtocol = 0;

            // Create array of USB interfaces
            Configuration.UsbInterface[] usbInterfaces = new Configuration.UsbInterface[] { usbInterface };

            // Create configuration descriptor
            Configuration.ConfigurationDescriptor config = new Configuration.ConfigurationDescriptor(200, usbInterfaces);

            // Create the string descriptors
            Configuration.StringDescriptor manufacturerName = new Configuration.StringDescriptor(1, "YourName");
            Configuration.StringDescriptor productName = new Configuration.StringDescriptor(2, "YourProductName");
            Configuration.StringDescriptor serialNumber = new Configuration.StringDescriptor(3, "0000-0" + USB.SerialNumber.Substring(0, 3) + "-" + USB.SerialNumber.Substring(3, 4) + "-" + USB.SerialNumber.Substring(7, 4));
            Configuration.StringDescriptor displayName = new Configuration.StringDescriptor(4, "YourDisplayName");
            Configuration.StringDescriptor friendlyName = new Configuration.StringDescriptor(5, "YourFriendlyName");

            // Create the final configuration
            Configuration configuration = new Configuration();

            configuration.descriptors = new Configuration.Descriptor[] {
                                                                        device,
                                                                        config,
                                                                        manufacturerName,
                                                                        productName,
                                                                        serialNumber,
                                                                        displayName,
                                                                        friendlyName
                                                                        };
            try
            {
                // Set the configuration
                usbController.Configuration = configuration;

                if (UsbController.ConfigError.ConfigOK != usbController.ConfigurationError)
                {
                    throw new ArgumentException();
                }

                // If all ok, start the USB controller.
                bRet = usbController.Start();
            }
            catch (ArgumentException)
            {
                Debug.Print("Can't configure USB controller, error " + usbController.ConfigurationError.ToString());
            }

            return bRet;
        }
Example #5
0
        /// <summary>
        /// Configure specified USB Controller for MIDI Output.
        /// </summary>
        /// <param name="usbController">Controller to configure. Should be first controller apparently to the device.</param>
        private static void ConfigureUsbController(UsbController usbController)
        {
            // setup our USB Controller's configuration
            Configuration configuration = new Configuration();

            // device descriptor
            Configuration.DeviceDescriptor deviceDescriptor = new Configuration.DeviceDescriptor(0x22B1, 0xFFFF, 0x0100); // VID, PID, version -- if you change the PID (0xFFFF) be sure to change the VID.
            deviceDescriptor.bcdUSB = 0x0200;           //complies with USB 2.0
            deviceDescriptor.bDeviceClass = 0x00;       //Defined at Interface Level //01 if audio http://msdn.microsoft.com/en-us/windows/hardware/gg487327
            deviceDescriptor.bDeviceSubClass = 0x00;    //Unused
            deviceDescriptor.bDeviceProtocol = 0x00;    //Unused
            deviceDescriptor.bMaxPacketSize0 = 32;    //Max Packet size of 3
            deviceDescriptor.iManufacturer = 0x01;      // manufacture name is first descriptor
            deviceDescriptor.iProduct = 0x02;           // product name is second descriptor
            deviceDescriptor.iSerialNumber = 0x03;      // serial number is third
            deviceDescriptor.idProduct = 0x0000;
            deviceDescriptor.idVendor = 0x0000;

            configuration.descriptors = new Configuration.Descriptor[]
            {
                new Configuration.StringDescriptor(1, "Burgundy Team"),
                new Configuration.StringDescriptor(2, "PNOscan II"),
                new Configuration.StringDescriptor(3, "00000001"),

            };

            byte[] classDecriptorPayload = new byte[]
            {

            };

            // write endpoint
            Configuration.Endpoint writeEndpoint = new Configuration.Endpoint(0x01, 0x02);
            writeEndpoint.bmAttributes = 0x02;  //Bulk not shared
            writeEndpoint.wMaxPacketSize = 32;   // packet size: 32 bytes
            writeEndpoint.bInterval = 0;            //Ignored for Bulk Set to zero

            Configuration.UsbInterface usbInterface = new Configuration.UsbInterface(0, new Configuration.Endpoint[] { writeEndpoint });
            usbInterface.bInterfaceClass = 0x01;        //AUDIO
            usbInterface.bInterfaceSubClass = 0x03;     //MIDISTREAMING
            usbInterface.bInterfaceProtocol = 0x00;     //Not Used

            // configuration descriptor
            Configuration.ConfigurationDescriptor configurationDescriptor = new Configuration.ConfigurationDescriptor(MAXPOWER_MILLIAMPS, new Configuration.UsbInterface[] { usbInterface });
            configurationDescriptor.bmAttributes = Configuration.ConfigurationDescriptor.ATTRIB_Base | Configuration.ConfigurationDescriptor.ATTRIB_SelfPowered;

            usbController.Configuration = configuration;

            if (usbController.ConfigurationError != UsbController.ConfigError.ConfigOK)
            {
                Debug.Print("Failed USB Configuration\n");
                Debug.Print(usbController.ConfigurationError.ToString());
                return;
            }
        }