MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/kernelhwsrv/kernel/eka/include/d32usbdescriptors.h
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifndef D32USBDESCRIPTORS_H

    17 #define D32USBDESCRIPTORS_H

    18 

    19 #include <e32base.h>

    20 

    21 

    22 /*****************************************************************************/

    23 /*                                                                           */

    24 /* USB descriptors parser framework                                          */

    25 /*                                                                           */

    26 /*****************************************************************************/

    27 

    28 class TUsbGenericDescriptor;

    29 

    30 /**

    31 The Symbian USB Descriptor Parsing Framework class.

    32 

    33 This class is to aid users of USBDI by providing the facilities to parse the

    34 raw descriptor data into wrapper classes that allow access to the fields in 

    35 the descriptor bodies, and pointers to map the serial data blob into the tree 

    36 structure that descriptors logically have.

    37 

    38 @publishedPartner Intended to be available to 3rd parties later

    39 @prototype

    40 */

    41 NONSHARABLE_CLASS(UsbDescriptorParser)

    42 	{

    43 public:

    44 	typedef TUsbGenericDescriptor* (*TUsbDescriptorParserL)(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

    45 

    46 public:

    47 	// Main parse function.

    48 	IMPORT_C static TInt Parse(const TDesC8& aUsbDes, TUsbGenericDescriptor*& aDesc);

    49 

    50 	// Custom parsing framework.

    51 	IMPORT_C static void RegisterCustomParserL(TUsbDescriptorParserL aParserFunc);

    52 	IMPORT_C static void UnregisterCustomParser(TUsbDescriptorParserL aParserFunc);

    53 

    54 private:

    55 	static TUsbGenericDescriptor* FindParserAndParseAndCheckL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

    56 	static TUsbGenericDescriptor* FindParserAndParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

    57 	static void ParseDescriptorTreeL(TPtrC8& aUsbDes, TUsbGenericDescriptor& aPreviousDesc);

    58 	static void BuildTreeL(TUsbGenericDescriptor& aNewDesc, TUsbGenericDescriptor& aPreviousDesc);

    59 	static TUsbGenericDescriptor& FindSuitableParentL(TUsbGenericDescriptor& aNewDesc, TUsbGenericDescriptor& aTopParent);

    60 	static TUsbGenericDescriptor* UnknownUsbDescriptorParserL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

    61 	};

    62 

    63 

    64 /*****************************************************************************/

    65 /*                                                                           */

    66 /* USB standard descriptors                                                  */

    67 /*                                                                           */

    68 /*****************************************************************************/

    69 

    70 

    71 /**

    72 Base class for USB descriptors.

    73 All USB descriptors contain type and length, and may have peers and children.

    74 

    75 @publishedPartner Intended to be available to 3rd parties later

    76 @prototype

    77 */

    78 class TUsbGenericDescriptor

    79 	{

    80 public:

    81 	IMPORT_C TUsbGenericDescriptor();

    82 	

    83 	IMPORT_C void DestroyTree();

    84 

    85 	IMPORT_C TUint8 TUint8At(TInt aOffset) const;

    86 	IMPORT_C TUint16 TUint16At(TInt aOffset) const;

    87 	IMPORT_C TUint32 TUint32At(TInt aOffset) const;

    88 

    89 	IMPORT_C TUsbGenericDescriptor& operator=(const TUsbGenericDescriptor& aDescriptor);

    90 

    91 	/**

    92 	Helper function to allow TUsbGenericDescriptor types to be placed on the cleanup stack.

    93 	*/

    94 	inline operator TCleanupItem() { return TCleanupItem(Cleanup,this); }

    95 

    96 public:

    97 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

    98 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

    99 	virtual TBool IsChild(TUsbGenericDescriptor& aPotentialChild);

   100 

   101 private:

   102 	IMPORT_C static void Cleanup(TAny* aPtr);

   103 	static void WalkAndDelete(TUsbGenericDescriptor* aDesc);

   104 

   105 public:		// USB standard fields

   106 	/**

   107 	The offset in a standard USB descriptor to the bLength field.

   108 	*/

   109 	static const TInt KbLengthOffset = 0;

   110 

   111 	/**

   112 	The offset in a standard USB descriptor to the bDescriptorType field.

   113 	*/

   114 	static const TInt KbDescriptorTypeOffset = 1;

   115 

   116 	/**

   117 	Standard Length field.

   118 	*/

   119 	TUint8	ibLength;

   120 	

   121 	/**

   122 	Standard Type field.

   123 	*/

   124 	TUint8	ibDescriptorType;

   125 	

   126 public:

   127 	/**

   128 	The flag to indicate whether the USB descriptor has been recognised

   129 	and parsed.

   130 	*/

   131 	enum TUsbGenericDescriptorFlags

   132 		{

   133 		EUnrecognised = 0x00,

   134 		ERecognised = 0x01,

   135 		};

   136 	

   137 public:		// Symbian generated fields

   138 	/**

   139 	Flag to show if the descriptor has been recognised and parsed, or if its data can only be represented as a

   140 	binary blob.  This field should particularly be checked if writing code which may run on older versions of

   141 	the operating system, where a (now) known descriptor may not have been parsed, or before parsing a new

   142 	descriptor from a blob, where later versions of the operating system may have already extracted the fields.

   143 	*/

   144 	TUint8	iRecognisedAndParsed;

   145 

   146 	/**

   147 	A pointer to the next peer of this descriptor, or NULL.

   148 	As an example, an endpoint descriptor will contain pointers to any other endpoint descriptors on the same

   149 	interface.

   150 	*/

   151 	TUsbGenericDescriptor* iNextPeer;

   152 

   153 	/**

   154 	A pointer to the first child of this descriptor, or NULL.

   155 	As an example, an interface descriptor will contain a pointer to the first endpoint descriptor on the

   156 	interface. The iNextPeer member can then be used to examine other endpoints on the interface.

   157 	*/

   158 	TUsbGenericDescriptor* iFirstChild;

   159 	

   160 	/**

   161 	A pointer to the parent to this descriptor, or NULL.

   162 	As an example an endpoint descriptor from a configuration bundle will have the interface that it

   163 	is a member of as it's parent.

   164 	*/

   165 	TUsbGenericDescriptor* iParent;

   166 

   167 	/**

   168 	The binary blob that contains this descriptor

   169 	*/

   170 	TPtrC8			iBlob;

   171 	};

   172 

   173 enum TUsbDescriptorType

   174 	{

   175 	EDevice						= 1,

   176 	EConfiguration				= 2,

   177 	EString						= 3,

   178 	EInterface					= 4,

   179 	EEndpoint					= 5,

   180 	EDeviceQualifier			= 6,

   181 	EOtherSpeedConfiguration	= 7,

   182 	EInterfacePower				= 8,

   183 	EOTG						= 9,

   184 	EDebug						= 10,

   185 	EInterfaceAssociation		= 11,

   186 	};

   187 

   188 /**

   189 Device descriptor.

   190 

   191 See section 9.6.1 of the USB 2.0 specification.

   192 

   193 @publishedPartner Intended to be available to 3rd parties later

   194 @prototype

   195 */

   196 NONSHARABLE_CLASS(TUsbDeviceDescriptor) : public TUsbGenericDescriptor

   197 	{

   198 public:

   199 	IMPORT_C TUsbDeviceDescriptor();

   200 	IMPORT_C static TUsbDeviceDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   201 

   202 public:

   203 	static const TInt KSizeInOctets = 18;

   204 	enum TFieldOffsets

   205 		{

   206 		EbcdUSB				= 2,

   207 		EbDeviceClass		= 4,

   208 		EbDeviceSubClass	= 5,

   209 		EbDeviceProtocol	= 6,

   210 		EbMaxPacketSize0	= 7,

   211 		EidVendor			= 8,

   212 		EidProduct			= 10,

   213 		EbcdDevice			= 12,

   214 		EiManufacturer		= 14,

   215 		EiProduct			= 15,

   216 		EiSerialNumber		= 16,

   217 		EbNumConfigurations	= 17

   218 		};

   219 

   220 public:

   221 	IMPORT_C TUint16 USBBcd() const;

   222 	IMPORT_C TUint8 DeviceClass() const;

   223 	IMPORT_C TUint8 DeviceSubClass() const;

   224 	IMPORT_C TUint8 DeviceProtocol() const;

   225 	IMPORT_C TUint8 MaxPacketSize0() const;

   226 	IMPORT_C TUint16 VendorId() const;

   227 	IMPORT_C TUint16 ProductId() const;

   228 	IMPORT_C TUint16 DeviceBcd() const;

   229 	IMPORT_C TUint8 ManufacturerIndex() const;

   230 	IMPORT_C TUint8 ProductIndex() const;

   231 	IMPORT_C TUint8 SerialNumberIndex() const;

   232 	IMPORT_C TUint8 NumConfigurations() const;

   233 

   234 public:

   235 	static TUsbDeviceDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   236 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   237 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   238 	};

   239 

   240 

   241 /**

   242 Device Qualifier descriptor.

   243 

   244 See section 9.6.2 of the USB 2.0 specification.

   245 

   246 @publishedPartner Intended to be available to 3rd parties later

   247 @prototype

   248 */

   249 NONSHARABLE_CLASS(TUsbDeviceQualifierDescriptor) : public TUsbGenericDescriptor

   250 	{

   251 public:

   252 	IMPORT_C TUsbDeviceQualifierDescriptor();

   253 	IMPORT_C static TUsbDeviceQualifierDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   254 	

   255 public:

   256 	static const TInt KSizeInOctets = 10;

   257 	enum TFieldOffsets

   258 		{

   259 		EbcdUSB				= 2,

   260 		EbDeviceClass		= 4,

   261 		EbDeviceSubClass	= 5,

   262 		EbDeviceProtocol	= 6,

   263 		EbMaxPacketSize0	= 7,

   264 		EbNumConfigurations	= 8,

   265 		EbReserved			= 9

   266 		};

   267 

   268 public:

   269 	IMPORT_C TUint16 USBBcd() const;

   270 	IMPORT_C TUint8 DeviceClass() const;

   271 	IMPORT_C TUint8 DeviceSubClass() const;

   272 	IMPORT_C TUint8 DeviceProtocol() const;

   273 	IMPORT_C TUint8 MaxPacketSize0() const;

   274 	IMPORT_C TUint8 NumConfigurations() const;

   275 	IMPORT_C TUint8 Reserved() const;

   276 	

   277 public:

   278 	static TUsbDeviceQualifierDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   279 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   280 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   281 	};

   282 

   283 

   284 /**

   285 Configuration descriptor.

   286 

   287 See section 9.6.3 of the USB 2.0 specification.

   288 

   289 @publishedPartner Intended to be available to 3rd parties later

   290 @prototype

   291 */

   292 NONSHARABLE_CLASS(TUsbConfigurationDescriptor) : public TUsbGenericDescriptor

   293 	{

   294 public:

   295 	IMPORT_C TUsbConfigurationDescriptor();

   296 	IMPORT_C static TUsbConfigurationDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   297 

   298 public:

   299 	static const TInt KSizeInOctets = 9;

   300 	enum TFieldOffsets

   301 		{

   302 		EwTotalLength			= 2,

   303 		EbNumInterfaces			= 4,

   304 		EbConfigurationValue	= 5,

   305 		EiConfiguration			= 6,

   306 		EbmAttributes			= 7,

   307 		EbMaxPower				= 8

   308 		};

   309 

   310 public:

   311 	IMPORT_C TUint16 TotalLength() const;

   312 	IMPORT_C TUint8 NumInterfaces() const;

   313 	IMPORT_C TUint8 ConfigurationValue() const;

   314 	IMPORT_C TUint8 ConfigurationIndex() const;

   315 	IMPORT_C TUint8 Attributes() const;

   316 	IMPORT_C TUint8 MaxPower() const;

   317 

   318 public:

   319 	static TUsbConfigurationDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   320 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   321 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   322 	};

   323 

   324 

   325 /**

   326 Other Speed descriptor.

   327 

   328 See section 9.6.4 of the USB 2.0 specification.

   329 

   330 @publishedPartner Intended to be available to 3rd parties later

   331 @prototype

   332 */

   333 NONSHARABLE_CLASS(TUsbOtherSpeedDescriptor) : public TUsbGenericDescriptor

   334 	{

   335 public:

   336 	IMPORT_C TUsbOtherSpeedDescriptor();

   337 	IMPORT_C static TUsbOtherSpeedDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   338 

   339 public:

   340 	static const TInt KSizeInOctets = 9;

   341 	enum TFieldOffsets

   342 		{

   343 		EwTotalLength 			= 2,

   344 		EbNumInterfaces			= 4,

   345 		EbConfigurationValue	= 5,

   346 		EiConfiguration			= 6,

   347 		EbmAttributes			= 7,

   348 		EbMaxPower				= 8

   349 		};

   350 

   351 public:

   352 	IMPORT_C TUint16 TotalLength() const;

   353 	IMPORT_C TUint8 NumInterfaces() const;

   354 	IMPORT_C TUint8 ConfigurationValue() const;

   355 	IMPORT_C TUint8 ConfigurationIndex() const;

   356 	IMPORT_C TUint8 Attributes() const;

   357 	IMPORT_C TUint8 MaxPower() const;

   358 	

   359 public:

   360 	static TUsbOtherSpeedDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   361 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   362 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   363 	};

   364 

   365 

   366 /**

   367 Interface Association Descriptor

   368 

   369 See the USB IAD ECN.

   370 

   371 @publishedPartner Intended to be available to 3rd parties later

   372 @prototype

   373 */

   374 NONSHARABLE_CLASS(TUsbInterfaceAssociationDescriptor) : public TUsbGenericDescriptor

   375 	{

   376 public:

   377 	IMPORT_C TUsbInterfaceAssociationDescriptor();

   378 	IMPORT_C static TUsbInterfaceAssociationDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   379 

   380 public:

   381 	static const TInt KSizeInOctets = 8;

   382 	enum TFieldOffsets

   383 		{

   384 		EbFirstInterface	= 2,

   385 		EbInterfaceCount	= 3,

   386 		EbFunctionClass		= 4,

   387 		EbFunctionSubClass	= 5,

   388 		EbFunctionProtocol	= 6,

   389 		EiFunction			= 7

   390 		};

   391 	

   392 public:

   393 	IMPORT_C TUint8 FirstInterface() const;

   394 	IMPORT_C TUint8 InterfaceCount() const;

   395 	IMPORT_C TUint8 FunctionClass() const;

   396 	IMPORT_C TUint8 FunctionSubClass() const;

   397 	IMPORT_C TUint8 FunctionProtocol() const;

   398 	IMPORT_C TUint8 FunctionIndex() const;

   399 	

   400 public:

   401 	static TUsbInterfaceAssociationDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   402 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   403 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   404 	virtual TBool IsChild(TUsbGenericDescriptor& aPotentialChild);

   405 	};

   406 

   407 /**

   408 Interface descriptor.

   409 

   410 See section 9.6.5 of the USB 2.0 specification.

   411 

   412 @publishedPartner Intended to be available to 3rd parties later

   413 @prototype

   414 */

   415 NONSHARABLE_CLASS(TUsbInterfaceDescriptor) : public TUsbGenericDescriptor

   416 	{

   417 public:

   418 	IMPORT_C TUsbInterfaceDescriptor();

   419 	IMPORT_C static TUsbInterfaceDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   420 

   421 public:

   422 	static const TInt KSizeInOctets = 9;

   423 	enum TFieldOffsets

   424 		{

   425 		EbInterfaceNumber	= 2,

   426 		EbAlternateSetting	= 3,

   427 		EbNumEndpoints		= 4,

   428 		EbInterfaceClass	= 5,

   429 		EbInterfaceSubClass	= 6,

   430 		EbInterfaceProtocol	= 7,

   431 		EiInterface			= 8

   432 		};

   433 	

   434 public:

   435 	IMPORT_C TUint8 InterfaceNumber() const;

   436 	IMPORT_C TUint8 AlternateSetting() const;

   437 	IMPORT_C TUint8 NumEndpoints() const;

   438 	IMPORT_C TUint8 InterfaceClass() const;

   439 	IMPORT_C TUint8 InterfaceSubClass() const;

   440 	IMPORT_C TUint8 InterfaceProtocol() const;

   441 	IMPORT_C TUint8 Interface() const;

   442 	

   443 public:

   444 	static TUsbInterfaceDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   445 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   446 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   447 	};

   448 

   449 /**

   450 Endpoint descriptor.

   451 

   452 See section 9.6.6 of the USB 2.0 specification.

   453 Note these exclude support support for:

   454 'Standard AC Interrupt Endpoint Descriptor'

   455 'Standard AS Isochronous Synch Endpoint Descriptor'

   456 'Standard AS Isochronous Audio Data Endpoint Descriptor'

   457 as defined in USB Audio Device Class Spec v1.0 which are all 9 bytes in size.

   458 To support these custom descriptors may be registered with the

   459 parser.

   460 

   461 @publishedPartner Intended to be available to 3rd parties later

   462 @prototype

   463 */

   464 NONSHARABLE_CLASS(TUsbEndpointDescriptor) : public TUsbGenericDescriptor

   465 	{

   466 public:

   467 	IMPORT_C TUsbEndpointDescriptor();

   468 	IMPORT_C static TUsbEndpointDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   469 

   470 public:

   471 	static const TInt KSizeInOctets = 7;

   472 	enum TFieldOffsets

   473 		{

   474 		EbEndpointAddress	= 2,

   475 		EbmAttributes		= 3,

   476 		EwMaxPacketSize		= 4,

   477 		EbInterval			= 6

   478 		};

   479 

   480 public:

   481 	IMPORT_C TUint8 EndpointAddress() const;

   482 	IMPORT_C TUint8 Attributes() const;

   483 	IMPORT_C TUint16 MaxPacketSize() const;

   484 	IMPORT_C TUint8 Interval() const;

   485 	

   486 public:

   487 	static TUsbEndpointDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   488 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   489 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   490 	};

   491 

   492 /**

   493 String descriptor

   494 

   495 See section 9.6.7 of the USB 2.0 specification.

   496 

   497 @publishedPartner Intended to be available to 3rd parties later

   498 @prototype

   499 */

   500 NONSHARABLE_CLASS(TUsbStringDescriptor) : public TUsbGenericDescriptor

   501 	{

   502 public:

   503 	IMPORT_C TUsbStringDescriptor();

   504 	IMPORT_C static TUsbStringDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   505 

   506 public:

   507 	IMPORT_C TInt GetLangId(TInt aIndex) const;

   508 	IMPORT_C void StringData(TDes16& aString) const;

   509 

   510 public:

   511 	static TUsbStringDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   512 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   513 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   514 	};

   515 

   516 /**

   517 OTG descriptor.

   518 

   519 See section 6.4 of the USB 2.0 On-The-Go Supplement Revision 1.3

   520 

   521 @publishedPartner Intended to be available to 3rd parties later

   522 @prototype

   523 */

   524 NONSHARABLE_CLASS(TUsbOTGDescriptor) : public TUsbGenericDescriptor

   525 	{

   526 public:

   527 	IMPORT_C TUsbOTGDescriptor();

   528 	IMPORT_C static TUsbOTGDescriptor* Cast(TUsbGenericDescriptor* aOriginal);

   529 

   530 public:

   531 	static const TInt KSizeInOctets = 3;

   532 	enum TFieldOffsets

   533 		{

   534 		EbmAttributes		= 2

   535 		};

   536 

   537 public:

   538 	IMPORT_C TUint8 Attributes() const;

   539     IMPORT_C TBool HNPSupported() const;

   540     IMPORT_C TBool SRPSupported() const;

   541 public:

   542 	static TUsbOTGDescriptor* ParseL(TPtrC8& aUsbDes, TUsbGenericDescriptor* aPreviousDesc);

   543 	virtual TBool IsParent(TUsbGenericDescriptor& aPotentialParent);

   544 	virtual TBool IsPeer(TUsbGenericDescriptor& aPotentialPeer);

   545 	};

   546 

   547 

   548 #endif	// D32USBDESCRIPTORS_H
Symaptic