1 /* HM-CFG-USB libusb-driver
3 * Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to
7 * deal in the Software without restriction, including without limitation the
8 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 * sell copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
32 #include <libusb-1.0/libusb.h>
37 #define USB_TIMEOUT 10000
39 #define ID_VENDOR 0x1b1f
40 #define ID_PRODUCT 0xc00f
43 #define ASYNC_SIZE 0x0040
44 #define ASYNC_INTERVAL 32
54 /* Not in all libusb-1.0 versions, so we have to roll our own :-( */
55 static char * usb_strerror(int e
)
57 static char unknerr
[256];
63 return "Input/output error";
64 case LIBUSB_ERROR_INVALID_PARAM
:
65 return "Invalid parameter";
66 case LIBUSB_ERROR_ACCESS
:
67 return "Access denied (insufficient permissions)";
68 case LIBUSB_ERROR_NO_DEVICE
:
69 return "No such device (it may have been disconnected)";
70 case LIBUSB_ERROR_NOT_FOUND
:
71 return "Entity not found";
72 case LIBUSB_ERROR_BUSY
:
73 return "Resource busy";
74 case LIBUSB_ERROR_TIMEOUT
:
75 return "Operation timed out";
76 case LIBUSB_ERROR_OVERFLOW
:
78 case LIBUSB_ERROR_PIPE
:
80 case LIBUSB_ERROR_INTERRUPTED
:
81 return "System call interrupted (perhaps due to signal)";
82 case LIBUSB_ERROR_NO_MEM
:
83 return "Insufficient memory";
84 case LIBUSB_ERROR_NOT_SUPPORTED
:
85 return "Operation not supported or unimplemented on this platform";
86 case LIBUSB_ERROR_OTHER
:
89 snprintf(unknerr
, sizeof(unknerr
), "Unknown error code %d / 0x%02x", e
, e
);
93 static libusb_device_handle
*hmcfgusb_find() {
94 libusb_device_handle
*devh
= NULL
;
100 cnt
= libusb_get_device_list(NULL
, &list
);
102 fprintf(stderr
, "Can't get USB device list: %d\n", (int)cnt
);
106 for (i
= 0; i
< cnt
; i
++){
107 struct libusb_device_descriptor desc
;
109 err
= libusb_get_device_descriptor(list
[i
], &desc
);
113 if ((desc
.idVendor
== ID_VENDOR
) && (desc
.idProduct
== ID_PRODUCT
)) {
114 libusb_device
*dev
= list
[i
];
116 err
= libusb_open(dev
, &devh
);
118 fprintf(stderr
, "Can't open device: %s\n", usb_strerror(err
));
122 err
= libusb_detach_kernel_driver(devh
, INTERFACE
);
123 if ((err
!= 0) && (err
!= LIBUSB_ERROR_NOT_FOUND
)) {
124 fprintf(stderr
, "Can't detach kernel driver: %s\n", usb_strerror(err
));
128 err
= libusb_claim_interface(devh
, INTERFACE
);
130 fprintf(stderr
, "Can't claim interface: %s\n", usb_strerror(err
));
142 int hmcfgusb_send(struct hmcfgusb_dev
*usbdev
, unsigned char* send_data
, int len
, int done
)
148 hexdump(send_data
, len
, "USB < ");
149 err
= libusb_interrupt_transfer(usbdev
->usb_devh
, EP_OUT
, send_data
, len
, &cnt
, USB_TIMEOUT
);
151 fprintf(stderr
, "Can't send data: %s\n", usb_strerror(err
));
156 err
= libusb_interrupt_transfer(usbdev
->usb_devh
, EP_OUT
, send_data
, 0, &cnt
, USB_TIMEOUT
);
158 fprintf(stderr
, "Can't send data: %s\n", usb_strerror(err
));
166 static struct libusb_transfer
*hmcfgusb_prepare_int(libusb_device_handle
*devh
, libusb_transfer_cb_fn cb
, void *data
)
168 unsigned char *data_buf
;
169 struct libusb_transfer
*transfer
;
172 data_buf
= malloc(ASYNC_SIZE
);
174 fprintf(stderr
, "Can't allocate memory for data-buffer!\n");
178 transfer
= libusb_alloc_transfer(0);
180 fprintf(stderr
, "Can't allocate memory for usb-transfer!\n");
185 libusb_fill_interrupt_transfer(transfer
, devh
, EP_IN
,
186 data_buf
, ASYNC_SIZE
, cb
, data
, USB_TIMEOUT
);
188 transfer
->flags
= LIBUSB_TRANSFER_SHORT_NOT_OK
| LIBUSB_TRANSFER_FREE_BUFFER
;
190 err
= libusb_submit_transfer(transfer
);
192 fprintf(stderr
, "Can't submit transfer: %s\n", usb_strerror(err
));
193 libusb_free_transfer(transfer
);
201 struct hmcfgusb_cb_data
{
202 struct hmcfgusb_dev
*dev
;
207 static void LIBUSB_CALL
hmcfgusb_interrupt(struct libusb_transfer
*transfer
)
210 struct hmcfgusb_cb_data
*cb_data
;
212 cb_data
= transfer
->user_data
;
214 if (transfer
->status
!= LIBUSB_TRANSFER_COMPLETED
) {
215 if (transfer
->status
!= LIBUSB_TRANSFER_TIMED_OUT
) {
216 fprintf(stderr
, "Interrupt transfer not completed: %d!\n", transfer
->status
);
219 if (cb_data
&& cb_data
->dev
&& cb_data
->dev
->transfer
) {
220 libusb_free_transfer(cb_data
->dev
->transfer
);
221 cb_data
->dev
->transfer
= NULL
;
226 if (cb_data
&& cb_data
->cb
) {
228 hexdump(transfer
->buffer
, transfer
->actual_length
, "USB > ");
229 cb_data
->cb(transfer
->buffer
, transfer
->actual_length
, cb_data
->data
);
231 hexdump(transfer
->buffer
, transfer
->actual_length
, "> ");
235 err
= libusb_submit_transfer(transfer
);
237 fprintf(stderr
, "Can't re-submit transfer: %s\n", usb_strerror(err
));
238 free(transfer
->buffer
);
239 libusb_free_transfer(transfer
);
243 struct hmcfgusb_dev
*hmcfgusb_init(hmcfgusb_cb_fn cb
, void *data
)
245 libusb_device_handle
*devh
= NULL
;
246 const struct libusb_pollfd
**usb_pfd
= NULL
;
247 struct hmcfgusb_dev
*dev
= NULL
;
248 struct hmcfgusb_cb_data
*cb_data
= NULL
;
252 err
= libusb_init(NULL
);
254 fprintf(stderr
, "Can't initialize libusb: %s\n", usb_strerror(err
));
258 devh
= hmcfgusb_find();
260 fprintf(stderr
, "Can't find/open hmcfgusb!\n");
264 dev
= malloc(sizeof(struct hmcfgusb_dev
));
266 perror("Can't allocate memory for hmcfgusb_dev");
270 memset(dev
, 0, sizeof(struct hmcfgusb_dev
));
271 dev
->usb_devh
= devh
;
273 cb_data
= malloc(sizeof(struct hmcfgusb_cb_data
));
275 perror("Can't allocate memory for hmcfgusb_cb_data");
279 memset(cb_data
, 0, sizeof(struct hmcfgusb_cb_data
));
283 cb_data
->data
= data
;
285 dev
->transfer
= hmcfgusb_prepare_int(devh
, hmcfgusb_interrupt
, cb_data
);
286 if (!dev
->transfer
) {
287 fprintf(stderr
, "Can't prepare async device io!\n");
291 usb_pfd
= libusb_get_pollfds(NULL
);
293 fprintf(stderr
, "Can't get FDset from libusb!\n");
299 for(i
= 0; usb_pfd
[i
]; i
++)
302 dev
->pfd
= malloc(dev
->n_usb_pfd
* sizeof(struct pollfd
));
304 perror("Can't allocate memory for poll-fds");
308 memset(dev
->pfd
, 0, dev
->n_usb_pfd
* sizeof(struct pollfd
));
310 for (i
= 0; i
< dev
->n_usb_pfd
; i
++) {
311 dev
->pfd
[i
].fd
= usb_pfd
[i
]->fd
;
312 dev
->pfd
[i
].events
= usb_pfd
[i
]->events
;
313 dev
->pfd
[i
].revents
= 0;
318 dev
->n_pfd
= dev
->n_usb_pfd
;
325 int hmcfgusb_add_pfd(struct hmcfgusb_dev
*dev
, int fd
, short events
)
328 dev
->pfd
= realloc(dev
->pfd
, dev
->n_pfd
* sizeof(struct pollfd
));
330 perror("Can't realloc poll-fds");
334 dev
->pfd
[dev
->n_pfd
-1].fd
= fd
;
335 dev
->pfd
[dev
->n_pfd
-1].events
= events
;
336 dev
->pfd
[dev
->n_pfd
-1].revents
= 0;
341 int hmcfgusb_poll(struct hmcfgusb_dev
*dev
, int timeout
)
352 memset(&tv
, 0, sizeof(tv
));
353 err
= libusb_get_next_timeout(NULL
, &tv
);
355 fprintf(stderr
, "libusb_get_next_timeout: %s\n", usb_strerror(err
));
358 } else if (err
== 0) {
359 /* No pending timeout or a sane platform */
362 if ((tv
.tv_sec
== 0) && (tv
.tv_usec
== 0)) {
368 for (i
= 0; i
< dev
->n_pfd
; i
++) {
369 dev
->pfd
[i
].revents
= 0;
372 n
= poll(dev
->pfd
, dev
->n_pfd
, tv
.tv_sec
* 1000);
380 for (fd_n
= 0; fd_n
< dev
->n_pfd
; fd_n
++) {
381 if (dev
->pfd
[fd_n
].revents
) {
382 if (fd_n
< dev
->n_usb_pfd
) {
387 return dev
->pfd
[fd_n
].fd
;
395 memset(&tv
, 0, sizeof(tv
));
396 err
= libusb_handle_events_timeout_completed(NULL
, &tv
, NULL
);
398 fprintf(stderr
, "libusb_handle_events_timeout_completed: %s\n", usb_strerror(err
));
406 fprintf(stderr
, "closing device-connection due to error %d\n", quit
);
413 void hmcfgusb_close(struct hmcfgusb_dev
*dev
)
418 libusb_cancel_transfer(dev
->transfer
);
421 err
= libusb_release_interface(dev
->usb_devh
, INTERFACE
);
423 fprintf(stderr
, "Can't release interface: %s\n", usb_strerror(err
));
426 libusb_close(dev
->usb_devh
);
433 void hmcfgusb_set_debug(int d
)