1/*-
2 * SPDX-License-Identifier: Beerware
3 *
4 * ----------------------------------------------------------------------------
5 * "THE BEER-WARE LICENSE" (Revision 42) (by Poul-Henning Kamp):
6 * <joerg@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return.        Joerg Wunsch
9 * ----------------------------------------------------------------------------
10 *
11 * $FreeBSD$
12 */
13
14/*
15 * Simple demo program to illustrate the handling of FreeBSD's
16 * libusb20.
17 */
18
19/*
20 * Examples:
21 * Just list all VID:PID pairs
22 * ./control
23 *
24 * Standard device request GET_STATUS, report two bytes of status
25 * (bit 0 in the first byte returned is the "self powered" bit)
26 * ./control -v 0x3eb -p 0x2103 in std dev get_status 0 0 2
27 *
28 * Request input reports through the interrupt pipe from a mouse
29 * device (move the mouse around after issuing the command):
30 * ./control -v 0x093a -p 0x2516 -i 0x81
31 *
32 */
33
34
35#include <limits.h>
36#include <stdbool.h>
37#include <stdio.h>
38#include <stdint.h>
39#include <stdlib.h>
40#include <sysexits.h>
41#include <unistd.h>
42#include <string.h>
43
44#include <libusb20.h>
45#include <libusb20_desc.h>
46
47#include <sys/queue.h>
48
49#include "util.h"
50
51/*
52 * If you want to see the details of the internal datastructures
53 * in the debugger, unifdef the following.
54 */
55#ifdef DEBUG
56#  include "/usr/src/lib/libusb/libusb20_int.h"
57#endif
58
59#define BUFLEN 64
60
61#define TIMEOUT 5000 		/* 5 s */
62
63int intr_ep;		/* endpoints */
64struct LIBUSB20_CONTROL_SETUP_DECODED setup;
65
66uint8_t out_buf[BUFLEN];
67uint16_t out_len;
68
69bool do_request;
70
71static void
72doit(struct libusb20_device *dev)
73{
74  int rv;
75
76  if (do_request)
77    printf("doit(): bmRequestType 0x%02x, bRequest 0x%02x, wValue 0x%04x, wIndex 0x%04x, wLength 0x%04x\n",
78	   setup.bmRequestType,
79	   setup.bRequest,
80	   setup.wValue,
81	   setup.wIndex,
82	   setup.wLength);
83
84  /*
85   * Open the device, allocating memory for two possible (bulk or
86   * interrupt) transfers.
87   *
88   * If only control transfers are intended (via
89   * libusb20_dev_request_sync()), transfer_max can be given as 0.
90   */
91  if ((rv = libusb20_dev_open(dev, 1)) != 0)
92    {
93      fprintf(stderr, "libusb20_dev_open: %s\n", libusb20_strerror(rv));
94      return;
95    }
96
97  /*
98   * If the device has more than one configuration, select the desired
99   * one here.
100   */
101  if ((rv = libusb20_dev_set_config_index(dev, 0)) != 0)
102    {
103      fprintf(stderr, "libusb20_dev_set_config_index: %s\n", libusb20_strerror(rv));
104      return;
105    }
106
107  uint8_t *data = 0;
108  uint16_t actlen;
109
110  if ((setup.bmRequestType & 0x80) != 0)
111    {
112      /* this is an IN request, allocate a buffer */
113      data = malloc(setup.wLength);
114      if (data == 0)
115	{
116	  fprintf(stderr,
117		  "Out of memory allocating %u bytes of reply buffer\n",
118		  setup.wLength);
119	  return;
120	}
121    }
122  else
123    data = out_buf;
124
125  if (do_request)
126    {
127      if ((rv = libusb20_dev_request_sync(dev, &setup, data,
128					  &actlen,
129					  TIMEOUT,
130					  0 /* flags */)) != 0)
131	{
132	  fprintf(stderr,
133		  "libusb20_dev_request_sync: %s\n", libusb20_strerror(rv));
134	}
135      printf("sent %d bytes\n", actlen);
136      if ((setup.bmRequestType & 0x80) != 0)
137	{
138	  print_formatted(data, (uint32_t)setup.wLength);
139	  free(data);
140	}
141    }
142
143  if (intr_ep != 0)
144    {
145      /*
146       * One transfer has been requested in libusb20_dev_open() above;
147       * obtain the corresponding transfer struct pointer.
148       */
149      struct libusb20_transfer *xfr_intr = libusb20_tr_get_pointer(dev, 0);
150
151      if (xfr_intr == NULL)
152	{
153	  fprintf(stderr, "libusb20_tr_get_pointer: %s\n", libusb20_strerror(rv));
154	  return;
155	}
156
157      /*
158       * Open the interrupt transfer.
159       */
160      if ((rv = libusb20_tr_open(xfr_intr, 0, 1, intr_ep)) != 0)
161	{
162	  fprintf(stderr, "libusb20_tr_open: %s\n", libusb20_strerror(rv));
163	  return;
164	}
165
166      uint8_t in_buf[BUFLEN];
167      uint32_t rlen;
168
169      if ((rv = libusb20_tr_bulk_intr_sync(xfr_intr, in_buf, BUFLEN, &rlen, TIMEOUT))
170	  != 0)
171	{
172	  fprintf(stderr, "libusb20_tr_bulk_intr_sync: %s\n", libusb20_strerror(rv));
173	}
174      printf("received %d bytes\n", rlen);
175      if (rlen > 0)
176	print_formatted(in_buf, rlen);
177
178      libusb20_tr_close(xfr_intr);
179    }
180
181  libusb20_dev_close(dev);
182}
183
184static void
185usage(void)
186{
187  fprintf(stderr,
188	  "Usage ./usb [-i <INTR_EP>] -v <VID> -p <PID> [dir type rcpt req wValue wIndex wLength [<outdata> ...]]\n");
189  exit(EX_USAGE);
190}
191
192static const char *reqnames[] =
193{
194  "get_status",
195  "clear_feature",
196  "res1",
197  "set_feature",
198  "res2",
199  "set_address",
200  "get_descriptor",
201  "set_descriptor",
202  "get_configuration",
203  "set_configuration",
204  "get_interface",
205  "set_interface",
206  "synch_frame",
207};
208
209static int
210get_req(const char *reqname)
211{
212  size_t i;
213  size_t l = strlen(reqname);
214
215  for (i = 0;
216       i < sizeof reqnames / sizeof reqnames[0];
217       i++)
218    if (strncasecmp(reqname, reqnames[i], l) == 0)
219      return i;
220
221  return strtoul(reqname, 0, 0);
222}
223
224
225static int
226parse_req(int argc, char **argv)
227{
228  int idx;
229  uint8_t rt = 0;
230
231  for (idx = 0; argc != 0 && idx <= 6; argc--, idx++)
232    switch (idx)
233      {
234      case 0:
235	/* dir[ection]: i[n] | o[ut] */
236	if (*argv[idx] == 'i')
237	  rt |= 0x80;
238	else if (*argv[idx] == 'o')
239	  /* nop */;
240	else
241	  {
242	    fprintf(stderr, "request direction must be \"in\" or \"out\" (got %s)\n",
243		    argv[idx]);
244	    return -1;
245	  }
246	break;
247
248      case 1:
249	/* type: s[tandard] | c[lass] | v[endor] */
250	if (*argv[idx] == 's')
251	  /* nop */;
252	else if (*argv[idx] == 'c')
253	  rt |= 0x20;
254	else if (*argv[idx] == 'v')
255	  rt |= 0x40;
256	else
257	  {
258	    fprintf(stderr,
259		    "request type must be one of \"standard\", \"class\", or \"vendor\" (got %s)\n",
260		    argv[idx]);
261	    return -1;
262	  }
263	break;
264
265      case 2:
266	/* rcpt: d[evice], i[nterface], e[ndpoint], o[ther] */
267	if (*argv[idx] == 'd')
268	  /* nop */;
269	else if (*argv[idx] == 'i')
270	  rt |= 1;
271	else if (*argv[idx] == 'e')
272	  rt |= 2;
273	else if (*argv[idx] == 'o')
274	  rt |= 3;
275	else
276	  {
277	    fprintf(stderr,
278		    "recipient must be one of \"device\", \"interface\", \"endpoint\", or \"other\" (got %s)\n",
279		    argv[idx]);
280	    return -1;
281	  }
282	setup.bmRequestType = rt;
283	break;
284
285      case 3:
286	setup.bRequest = get_req(argv[idx]);
287	break;
288
289      case 4:
290	setup.wValue = strtoul(argv[idx], 0, 0);
291	break;
292
293      case 5:
294	setup.wIndex = strtoul(argv[idx], 0, 0);
295	break;
296
297      case 6:
298	setup.wLength = strtoul(argv[idx], 0, 0);
299	break;
300      }
301
302  return argc;
303}
304
305
306int
307main(int argc, char **argv)
308{
309  unsigned int vid = UINT_MAX, pid = UINT_MAX; /* impossible VID:PID */
310  int c;
311
312  /*
313   * Initialize setup struct.  This step is required, and initializes
314   * internal fields in the struct.
315   *
316   * All the "public" fields are named exactly the way as the USB
317   * standard describes them, namely:
318   *
319   *	setup.bmRequestType: bitmask, bit 7 is direction
320   *	                              bits 6/5 is request type
321   *	                                       (standard, class, vendor)
322   *	                              bits 4..0 is recipient
323   *	                                       (device, interface, endpoint,
324   *	                                        other)
325   *	setup.bRequest:      the request itself (see get_req() for standard
326   *	                                         requests, or specific value)
327   *	setup.wValue:        a 16-bit value
328   *	setup.wIndex:        another 16-bit value
329   *	setup.wLength:       length of associated data transfer, direction
330   *	                     depends on bit 7 of bmRequestType
331   */
332  LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
333
334  while ((c = getopt(argc, argv, "i:p:v:")) != -1)
335    switch (c)
336      {
337      case 'i':
338	intr_ep = strtol(optarg, NULL, 0);
339	break;
340
341      case 'p':
342	pid = strtol(optarg, NULL, 0);
343	break;
344
345      case 'v':
346	vid = strtol(optarg, NULL, 0);
347	break;
348
349      default:
350	usage();
351	break;
352      }
353  argc -= optind;
354  argv += optind;
355
356  if (vid != UINT_MAX || pid != UINT_MAX)
357    {
358      if (intr_ep != 0 && (intr_ep & 0x80) == 0)
359	{
360	  fprintf(stderr, "Interrupt endpoint must be of type IN\n");
361	  usage();
362	}
363
364      if (argc > 0)
365	{
366	  do_request = true;
367
368	  int rv = parse_req(argc, argv);
369	  if (rv < 0)
370	    return EX_USAGE;
371	  argc = rv;
372
373	  if (argc > 0)
374	    {
375	      for (out_len = 0; argc > 0 && out_len < BUFLEN; out_len++, argc--)
376		{
377		  unsigned n = strtoul(argv[out_len], 0, 0);
378		  if (n > 255)
379		    fprintf(stderr,
380			    "Warning: data #%d 0x%0x > 0xff, truncating\n",
381			    out_len, n);
382		  out_buf[out_len] = (uint8_t)n;
383		}
384	      out_len++;
385	      if (argc > 0)
386		fprintf(stderr,
387			"Data count exceeds maximum of %d, ignoring %d elements\n",
388			BUFLEN, optind);
389	    }
390	}
391    }
392
393  struct libusb20_backend *be;
394  struct libusb20_device *dev;
395
396  if ((be = libusb20_be_alloc_default()) == NULL)
397    {
398      perror("libusb20_be_alloc()");
399      return 1;
400    }
401
402  dev = NULL;
403  while ((dev = libusb20_be_device_foreach(be, dev)) != NULL)
404    {
405      struct LIBUSB20_DEVICE_DESC_DECODED *ddp =
406      libusb20_dev_get_device_desc(dev);
407
408      printf("Found device %s (VID:PID = 0x%04x:0x%04x)\n",
409	     libusb20_dev_get_desc(dev),
410	     ddp->idVendor, ddp->idProduct);
411
412      if (ddp->idVendor == vid && ddp->idProduct == pid)
413	doit(dev);
414    }
415
416  libusb20_be_free(be);
417  return 0;
418}
419