libusb10_desc.c revision 203815 
1/* $FreeBSD: head/lib/libusb/libusb10_desc.c 203815 2010-02-13 09:45:50Z wkoszek $ */
2/*-
3 * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/queue.h>
28
29#include <stdio.h>
30#include <stdlib.h>
31
32#include "libusb20.h"
33#include "libusb20_desc.h"
34#include "libusb20_int.h"
35#include "libusb.h"
36#include "libusb10.h"
37
38#define	N_ALIGN(n) (-((-(n)) & (-8UL)))
39
40/* USB descriptors */
41
42int
43libusb_get_device_descriptor(libusb_device *dev,
44    struct libusb_device_descriptor *desc)
45{
46	struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
47	struct libusb20_device *pdev;
48
49	if ((dev == NULL) || (desc == NULL))
50		return (LIBUSB_ERROR_INVALID_PARAM);
51
52	pdev = dev->os_priv;
53	pdesc = libusb20_dev_get_device_desc(pdev);
54
55	desc->bLength = pdesc->bLength;
56	desc->bDescriptorType = pdesc->bDescriptorType;
57	desc->bcdUSB = pdesc->bcdUSB;
58	desc->bDeviceClass = pdesc->bDeviceClass;
59	desc->bDeviceSubClass = pdesc->bDeviceSubClass;
60	desc->bDeviceProtocol = pdesc->bDeviceProtocol;
61	desc->bMaxPacketSize0 = pdesc->bMaxPacketSize0;
62	desc->idVendor = pdesc->idVendor;
63	desc->idProduct = pdesc->idProduct;
64	desc->bcdDevice = pdesc->bcdDevice;
65	desc->iManufacturer = pdesc->iManufacturer;
66	desc->iProduct = pdesc->iProduct;
67	desc->iSerialNumber = pdesc->iSerialNumber;
68	desc->bNumConfigurations = pdesc->bNumConfigurations;
69
70	return (0);
71}
72
73int
74libusb_get_active_config_descriptor(libusb_device *dev,
75    struct libusb_config_descriptor **config)
76{
77	struct libusb20_device *pdev;
78	uint8_t config_index;
79
80	pdev = dev->os_priv;
81	config_index = libusb20_dev_get_config_index(pdev);
82
83	return (libusb_get_config_descriptor(dev, config_index, config));
84}
85
86int
87libusb_get_config_descriptor(libusb_device *dev, uint8_t config_index,
88    struct libusb_config_descriptor **config)
89{
90	struct libusb20_device *pdev;
91	struct libusb20_config *pconf;
92	struct libusb20_interface *pinf;
93	struct libusb20_endpoint *pend;
94	struct libusb_config_descriptor *pconfd;
95	struct libusb_interface_descriptor *ifd;
96	struct libusb_endpoint_descriptor *endd;
97	uint8_t *pextra;
98	uint16_t nextra;
99	uint8_t nif;
100	uint8_t nep;
101	uint8_t nalt;
102	uint8_t i;
103	uint8_t j;
104	uint8_t k;
105
106	if (dev == NULL || config == NULL)
107		return (LIBUSB_ERROR_INVALID_PARAM);
108
109	*config = NULL;
110
111	pdev = dev->os_priv;
112	pconf = libusb20_dev_alloc_config(pdev, config_index);
113
114	if (pconf == NULL)
115		return (LIBUSB_ERROR_NOT_FOUND);
116
117	nalt = nif = pconf->num_interface;
118	nep = 0;
119	nextra = N_ALIGN(pconf->extra.len);
120
121	for (i = 0; i < nif; i++) {
122
123		pinf = pconf->interface + i;
124		nextra += N_ALIGN(pinf->extra.len);
125		nep += pinf->num_endpoints;
126		k = pinf->num_endpoints;
127		pend = pinf->endpoints;
128		while (k--) {
129			nextra += N_ALIGN(pend->extra.len);
130			pend++;
131		}
132
133		j = pinf->num_altsetting;
134		nalt += pinf->num_altsetting;
135		pinf = pinf->altsetting;
136		while (j--) {
137			nextra += N_ALIGN(pinf->extra.len);
138			nep += pinf->num_endpoints;
139			k = pinf->num_endpoints;
140			pend = pinf->endpoints;
141			while (k--) {
142				nextra += N_ALIGN(pend->extra.len);
143				pend++;
144			}
145			pinf++;
146		}
147	}
148
149	nextra = nextra +
150	    (1 * sizeof(libusb_config_descriptor)) +
151	    (nif * sizeof(libusb_interface)) +
152	    (nalt * sizeof(libusb_interface_descriptor)) +
153	    (nep * sizeof(libusb_endpoint_descriptor));
154
155	nextra = N_ALIGN(nextra);
156
157	pconfd = malloc(nextra);
158
159	if (pconfd == NULL) {
160		free(pconf);
161		return (LIBUSB_ERROR_NO_MEM);
162	}
163	/* make sure memory is initialised */
164	memset(pconfd, 0, nextra);
165
166	pconfd->interface = (libusb_interface *) (pconfd + 1);
167
168	ifd = (libusb_interface_descriptor *) (pconfd->interface + nif);
169	endd = (libusb_endpoint_descriptor *) (ifd + nalt);
170	pextra = (uint8_t *)(endd + nep);
171
172	/* fill in config descriptor */
173
174	pconfd->bLength = pconf->desc.bLength;
175	pconfd->bDescriptorType = pconf->desc.bDescriptorType;
176	pconfd->wTotalLength = pconf->desc.wTotalLength;
177	pconfd->bNumInterfaces = pconf->desc.bNumInterfaces;
178	pconfd->bConfigurationValue = pconf->desc.bConfigurationValue;
179	pconfd->iConfiguration = pconf->desc.iConfiguration;
180	pconfd->bmAttributes = pconf->desc.bmAttributes;
181	pconfd->MaxPower = pconf->desc.bMaxPower;
182
183	if (pconf->extra.len != 0) {
184		pconfd->extra_length = pconf->extra.len;
185		pconfd->extra = pextra;
186		memcpy(pextra, pconf->extra.ptr, pconfd->extra_length);
187		pextra += N_ALIGN(pconfd->extra_length);
188	}
189	/* setup all interface and endpoint pointers */
190
191	for (i = 0; i < nif; i++) {
192
193		pconfd->interface[i].altsetting = ifd;
194		ifd->endpoint = endd;
195		endd += pconf->interface[i].num_endpoints;
196		ifd++;
197
198		for (j = 0; j < pconf->interface[i].num_altsetting; j++) {
199			ifd->endpoint = endd;
200			endd += pconf->interface[i].altsetting[j].num_endpoints;
201			ifd++;
202		}
203	}
204
205	/* fill in all interface and endpoint data */
206
207	for (i = 0; i < nif; i++) {
208		pinf = &pconf->interface[i];
209		pconfd->interface[i].num_altsetting = pinf->num_altsetting + 1;
210		for (j = 0; j < pconfd->interface[i].num_altsetting; j++) {
211			if (j != 0)
212				pinf = &pconf->interface[i].altsetting[j - 1];
213			ifd = &pconfd->interface[i].altsetting[j];
214			ifd->bLength = pinf->desc.bLength;
215			ifd->bDescriptorType = pinf->desc.bDescriptorType;
216			ifd->bInterfaceNumber = pinf->desc.bInterfaceNumber;
217			ifd->bAlternateSetting = pinf->desc.bAlternateSetting;
218			ifd->bNumEndpoints = pinf->desc.bNumEndpoints;
219			ifd->bInterfaceClass = pinf->desc.bInterfaceClass;
220			ifd->bInterfaceSubClass = pinf->desc.bInterfaceSubClass;
221			ifd->bInterfaceProtocol = pinf->desc.bInterfaceProtocol;
222			ifd->iInterface = pinf->desc.iInterface;
223			if (pinf->extra.len != 0) {
224				ifd->extra_length = pinf->extra.len;
225				ifd->extra = pextra;
226				memcpy(pextra, pinf->extra.ptr, pinf->extra.len);
227				pextra += N_ALIGN(pinf->extra.len);
228			}
229			for (k = 0; k < pinf->num_endpoints; k++) {
230				pend = &pinf->endpoints[k];
231				endd = &ifd->endpoint[k];
232				endd->bLength = pend->desc.bLength;
233				endd->bDescriptorType = pend->desc.bDescriptorType;
234				endd->bEndpointAddress = pend->desc.bEndpointAddress;
235				endd->bmAttributes = pend->desc.bmAttributes;
236				endd->wMaxPacketSize = pend->desc.wMaxPacketSize;
237				endd->bInterval = pend->desc.bInterval;
238				endd->bRefresh = pend->desc.bRefresh;
239				endd->bSynchAddress = pend->desc.bSynchAddress;
240				if (pend->extra.len != 0) {
241					endd->extra_length = pend->extra.len;
242					endd->extra = pextra;
243					memcpy(pextra, pend->extra.ptr, pend->extra.len);
244					pextra += N_ALIGN(pend->extra.len);
245				}
246			}
247		}
248	}
249
250	free(pconf);
251
252	*config = pconfd;
253
254	return (0);			/* success */
255}
256
257int
258libusb_get_config_descriptor_by_value(libusb_device *dev,
259    uint8_t bConfigurationValue, struct libusb_config_descriptor **config)
260{
261	struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
262	struct libusb20_device *pdev;
263	int i;
264	int err;
265
266	if (dev == NULL || config == NULL)
267		return (LIBUSB_ERROR_INVALID_PARAM);
268
269	pdev = dev->os_priv;
270	pdesc = libusb20_dev_get_device_desc(pdev);
271
272	for (i = 0; i < pdesc->bNumConfigurations; i++) {
273		err = libusb_get_config_descriptor(dev, i, config);
274		if (err)
275			return (err);
276
277		if ((*config)->bConfigurationValue == bConfigurationValue)
278			return (0);	/* success */
279
280		libusb_free_config_descriptor(*config);
281	}
282
283	*config = NULL;
284
285	return (LIBUSB_ERROR_NOT_FOUND);
286}
287
288void
289libusb_free_config_descriptor(struct libusb_config_descriptor *config)
290{
291	free(config);
292}
293
294int
295libusb_get_string_descriptor_ascii(libusb_device_handle *pdev,
296    uint8_t desc_index, unsigned char *data, int length)
297{
298	if (pdev == NULL || data == NULL || length < 1)
299		return (LIBUSB20_ERROR_INVALID_PARAM);
300
301	/* put some default data into the destination buffer */
302	data[0] = 0;
303
304	if (libusb20_dev_req_string_simple_sync(pdev, desc_index,
305	    data, length) == 0)
306		return (strlen(data));
307
308	return (LIBUSB_ERROR_OTHER);
309}
310
311int
312libusb_get_descriptor(libusb_device_handle * devh, uint8_t desc_type,
313    uint8_t desc_index, uint8_t *data, int length)
314{
315	return (libusb_control_transfer(devh, LIBUSB_ENDPOINT_IN,
316	    LIBUSB_REQUEST_GET_DESCRIPTOR, (desc_type << 8) | desc_index, 0, data,
317	    length, 1000));
318}
319