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
53 /* Not in all libusb-1.0 versions, so we have to roll our own :-( */
54 static char * usb_strerror(int e
)
56 static char unknerr
[256];
62 return "Input/output error";
63 case LIBUSB_ERROR_INVALID_PARAM
:
64 return "Invalid parameter";
65 case LIBUSB_ERROR_ACCESS
:
66 return "Access denied (insufficient permissions)";
67 case LIBUSB_ERROR_NO_DEVICE
:
68 return "No such device (it may have been disconnected)";
69 case LIBUSB_ERROR_NOT_FOUND
:
70 return "Entity not found";
71 case LIBUSB_ERROR_BUSY
:
72 return "Resource busy";
73 case LIBUSB_ERROR_TIMEOUT
:
74 return "Operation timed out";
75 case LIBUSB_ERROR_OVERFLOW
:
77 case LIBUSB_ERROR_PIPE
:
79 case LIBUSB_ERROR_INTERRUPTED
:
80 return "System call interrupted (perhaps due to signal)";
81 case LIBUSB_ERROR_NO_MEM
:
82 return "Insufficient memory";
83 case LIBUSB_ERROR_NOT_SUPPORTED
:
84 return "Operation not supported or unimplemented on this platform";
85 case LIBUSB_ERROR_OTHER
:
88 snprintf(unknerr
, sizeof(unknerr
), "Unknown error code %d / 0x%02x", e
, e
);
92 static libusb_device_handle
*hmcfgusb_find() {
93 libusb_device_handle
*devh
= NULL
;
99 cnt
= libusb_get_device_list(NULL
, &list
);
101 fprintf(stderr
, "Can't get USB device list: %d\n", (int)cnt
);
105 for (i
= 0; i
< cnt
; i
++){
106 struct libusb_device_descriptor desc
;
108 err
= libusb_get_device_descriptor(list
[i
], &desc
);
112 if ((desc
.idVendor
== ID_VENDOR
) && (desc
.idProduct
== ID_PRODUCT
)) {
113 libusb_device
*dev
= list
[i
];
115 err
= libusb_open(dev
, &devh
);
117 fprintf(stderr
, "Can't open device: %s\n", usb_strerror(err
));
121 err
= libusb_detach_kernel_driver(devh
, INTERFACE
);
122 if ((err
!= 0) && (err
!= LIBUSB_ERROR_NOT_FOUND
)) {
123 fprintf(stderr
, "Can't detach kernel driver: %s\n", usb_strerror(err
));
127 err
= libusb_claim_interface(devh
, INTERFACE
);
129 fprintf(stderr
, "Can't claim interface: %s\n", usb_strerror(err
));
141 int hmcfgusb_send(struct hmcfgusb_dev
*usbdev
, unsigned char* send_data
, int len
, int done
)
147 err
= libusb_interrupt_transfer(usbdev
->usb_devh
, EP_OUT
, send_data
, len
, &cnt
, USB_TIMEOUT
);
149 fprintf(stderr
, "Can't send data: %s\n", usb_strerror(err
));
150 if (err
== LIBUSB_ERROR_NO_DEVICE
)
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
));
159 if (err
== LIBUSB_ERROR_NO_DEVICE
)
168 static struct libusb_transfer
*hmcfgusb_prepare_int(libusb_device_handle
*devh
, libusb_transfer_cb_fn cb
, void *data
)
170 unsigned char *data_buf
;
171 struct libusb_transfer
*transfer
;
174 data_buf
= malloc(ASYNC_SIZE
);
176 fprintf(stderr
, "Can't allocate memory for data-buffer!\n");
180 transfer
= libusb_alloc_transfer(0);
182 fprintf(stderr
, "Can't allocate memory for usb-transfer!\n");
187 libusb_fill_interrupt_transfer(transfer
, devh
, EP_IN
,
188 data_buf
, ASYNC_SIZE
, cb
, data
, USB_TIMEOUT
);
190 transfer
->flags
= LIBUSB_TRANSFER_SHORT_NOT_OK
| LIBUSB_TRANSFER_FREE_BUFFER
;
192 err
= libusb_submit_transfer(transfer
);
194 fprintf(stderr
, "Can't submit transfer: %s\n", usb_strerror(err
));
195 libusb_free_transfer(transfer
);
203 struct hmcfgusb_cb_data
{
204 struct hmcfgusb_dev
*dev
;
209 static void LIBUSB_CALL
hmcfgusb_interrupt(struct libusb_transfer
*transfer
)
212 struct hmcfgusb_cb_data
*cb_data
;
214 cb_data
= transfer
->user_data
;
216 if (transfer
->status
!= LIBUSB_TRANSFER_COMPLETED
) {
217 if (transfer
->status
!= LIBUSB_TRANSFER_TIMED_OUT
) {
218 fprintf(stderr
, "Interrupt transfer not completed: %d!\n", transfer
->status
);
221 if (cb_data
&& cb_data
->dev
&& cb_data
->dev
->transfer
) {
222 libusb_free_transfer(cb_data
->dev
->transfer
);
223 cb_data
->dev
->transfer
= NULL
;
228 if (cb_data
&& cb_data
->cb
) {
229 cb_data
->cb(transfer
->buffer
, transfer
->actual_length
, cb_data
->data
);
231 hexdump(transfer
->buffer
, transfer
->actual_length
, "RECV> ");
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
;
323 int hmcfgusb_add_pfd(struct hmcfgusb_dev
*dev
, int fd
, short events
)
326 dev
->pfd
= realloc(dev
->pfd
, dev
->n_pfd
* sizeof(struct pollfd
));
328 perror("Can't realloc poll-fds");
332 dev
->pfd
[dev
->n_pfd
-1].fd
= fd
;
333 dev
->pfd
[dev
->n_pfd
-1].events
= events
;
334 dev
->pfd
[dev
->n_pfd
-1].revents
= 0;
339 int hmcfgusb_poll(struct hmcfgusb_dev
*dev
, int timeout
)
350 memset(&tv
, 0, sizeof(tv
));
351 err
= libusb_get_next_timeout(NULL
, &tv
);
353 fprintf(stderr
, "libusb_get_next_timeout: %s\n", usb_strerror(err
));
356 } else if (err
== 0) {
357 /* No pending timeout or a sane platform */
360 if ((tv
.tv_sec
== 0) && (tv
.tv_usec
== 0)) {
366 for (i
= 0; i
< dev
->n_pfd
; i
++) {
367 dev
->pfd
[i
].revents
= 0;
370 n
= poll(dev
->pfd
, dev
->n_pfd
, tv
.tv_sec
* 1000);
377 for (fd_n
= 0; fd_n
< dev
->n_pfd
; fd_n
++) {
378 if (dev
->pfd
[fd_n
].revents
) {
379 if (fd_n
< dev
->n_usb_pfd
) {
383 return dev
->pfd
[fd_n
].fd
;
391 memset(&tv
, 0, sizeof(tv
));
392 err
= libusb_handle_events_timeout_completed(NULL
, &tv
, NULL
);
394 fprintf(stderr
, "libusb_handle_events_timeout_completed: %s\n", usb_strerror(err
));
406 void hmcfgusb_close(struct hmcfgusb_dev
*dev
)
411 libusb_cancel_transfer(dev
->transfer
);
414 err
= libusb_release_interface(dev
->usb_devh
, INTERFACE
);
416 fprintf(stderr
, "Can't release interface: %s\n", usb_strerror(err
));
419 libusb_close(dev
->usb_devh
);