xtalk: checkpatch clean (almost)
Signed-off-by: Oron Peled <oron.peled@xorcom.com> Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin: Xorcom xtalk (r10638) git-svn-id: http://svn.astersk.org/svn/dahdi/tools/trunk@10713 17933a7a-c749-41c5-a318-cba88f637d49
This commit is contained in:
parent
b440b2da8c
commit
8b7c731fb6
|
@ -30,7 +30,7 @@
|
|||
#include <debug.h>
|
||||
|
||||
int verbose = LOG_INFO;
|
||||
int debug_mask = 0;
|
||||
int debug_mask;
|
||||
|
||||
void log_function(int level, int mask, const char *msg, ...)
|
||||
{
|
||||
|
@ -44,7 +44,8 @@ void log_function(int level, int mask, const char *msg, ...)
|
|||
va_end(ap);
|
||||
}
|
||||
|
||||
void dump_packet(int loglevel, int mask, const char *msg, const char *buf, int len)
|
||||
void dump_packet(int loglevel, int mask, const char *msg,
|
||||
const char *buf, int len)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
|
@ -35,15 +35,18 @@ extern int debug_mask;
|
|||
/*
|
||||
* Logging
|
||||
*/
|
||||
void log_function(int level, int mask, const char *msg, ...) __attribute__(( format(printf, 3, 4) ));
|
||||
void log_function(int level, int mask, const char *msg, ...)
|
||||
__attribute__((format(printf, 3, 4)));
|
||||
|
||||
#define ERR(fmt, arg...) log_function(LOG_ERR, 0, "%s:%d: ERROR(%s): " fmt, __FILE__, __LINE__, __FUNCTION__, ## arg)
|
||||
#define ERR(fmt, arg...) log_function(LOG_ERR, 0, "%s:%d: ERROR(%s): " fmt, \
|
||||
__FILE__, __LINE__, __func__, ## arg)
|
||||
#define WARN(fmt, arg...) log_function(LOG_WARNING, 0, "WARNING: " fmt, ## arg)
|
||||
#define INFO(fmt, arg...) log_function(LOG_INFO, 0, "INFO: " fmt, ## arg)
|
||||
#define DBG(fmt, arg...) log_function(LOG_DEBUG, DBG_MASK, \
|
||||
"%s:%d: DBG(%s): " fmt, __FILE__, __LINE__, __FUNCTION__, ## arg)
|
||||
"%s:%d: DBG(%s): " fmt, __FILE__, __LINE__, __func__, ## arg)
|
||||
|
||||
void dump_packet(int loglevel, int mask, const char *msg, const char *buf, int len);
|
||||
void dump_packet(int loglevel, int mask, const char *msg,
|
||||
const char *buf, int len);
|
||||
void print_backtrace(FILE *fp);
|
||||
|
||||
#endif /* DEBUG_H */
|
||||
|
|
|
@ -7,7 +7,8 @@ struct xlist_node *xlist_new(void *data)
|
|||
{
|
||||
struct xlist_node *list;
|
||||
|
||||
if((list = malloc(sizeof(*list))) == NULL)
|
||||
list = malloc(sizeof(*list));
|
||||
if (!list)
|
||||
return NULL;
|
||||
list->next = list;
|
||||
list->prev = list;
|
||||
|
|
|
@ -29,8 +29,6 @@
|
|||
#include <xtalk.h>
|
||||
#include <debug.h>
|
||||
|
||||
static const char rcsid[] = "$Id$";
|
||||
|
||||
#define DBG_MASK 0x02
|
||||
|
||||
#define TIMEOUT 6000
|
||||
|
@ -103,7 +101,8 @@ void free_command(struct xtalk_command *cmd)
|
|||
free(cmd);
|
||||
}
|
||||
|
||||
static const struct xtalk_command_desc *get_command_desc(const struct xtalk_protocol *xproto, uint8_t op)
|
||||
static const struct xtalk_command_desc *get_command_desc(
|
||||
const struct xtalk_protocol *xproto, uint8_t op)
|
||||
{
|
||||
const struct xtalk_command_desc *desc;
|
||||
|
||||
|
@ -120,7 +119,8 @@ static const struct xtalk_command_desc *get_command_desc(const struct xtalk_prot
|
|||
return desc;
|
||||
}
|
||||
|
||||
static const char *ack_status_msg(const struct xtalk_protocol *xproto, uint8_t status)
|
||||
static const char *ack_status_msg(const struct xtalk_protocol *xproto,
|
||||
uint8_t status)
|
||||
{
|
||||
const char *ack_status;
|
||||
|
||||
|
@ -131,7 +131,8 @@ static const char *ack_status_msg(const struct xtalk_protocol *xproto, uint8_t s
|
|||
return ack_status;
|
||||
}
|
||||
|
||||
int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protocol *xproto)
|
||||
int xtalk_set_protocol(struct xtalk_device *xtalk_dev,
|
||||
const struct xtalk_protocol *xproto)
|
||||
{
|
||||
const char *protoname = (xproto) ? xproto->name : "GLOBAL";
|
||||
int i;
|
||||
|
@ -144,7 +145,8 @@ int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protoc
|
|||
desc = get_command_desc(xproto, i);
|
||||
if (desc) {
|
||||
if (!IS_PRIVATE_OP(i)) {
|
||||
ERR("Bad op=0x%X (should be in the range [0x%X-0x%X]\n",
|
||||
ERR("Bad op=0x%X "
|
||||
"(should be in the range [0x%X-0x%X]\n",
|
||||
i, PRIVATE_OP_FIRST, PRIVATE_OP_LAST);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
@ -154,7 +156,8 @@ int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protoc
|
|||
if (!IS_PRIVATE_OP(i)) {
|
||||
const char *name;
|
||||
|
||||
xtalk_dev->xproto.commands[i] = xtalk_base.commands[i];
|
||||
xtalk_dev->xproto.commands[i] =
|
||||
xtalk_base.commands[i];
|
||||
name = xtalk_dev->xproto.commands[i].name;
|
||||
if (name)
|
||||
DBG("global: op=0x%X (%s)\n", i, name);
|
||||
|
@ -167,7 +170,8 @@ int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protoc
|
|||
stat_msg = (xproto) ? xproto->ack_statuses[i] : NULL;
|
||||
if (stat_msg) {
|
||||
if (!IS_PRIVATE_OP(i)) {
|
||||
ERR("Bad status=0x%X (should be in the range [0x%X-0x%X]\n",
|
||||
ERR("Bad status=0x%X "
|
||||
"(should be in the range [0x%X-0x%X]\n",
|
||||
i, PRIVATE_OP_FIRST, PRIVATE_OP_LAST);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
@ -177,10 +181,12 @@ int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protoc
|
|||
if (!IS_PRIVATE_OP(i)) {
|
||||
const char *stat_msg;
|
||||
|
||||
xtalk_dev->xproto.ack_statuses[i] = xtalk_base.ack_statuses[i];
|
||||
xtalk_dev->xproto.ack_statuses[i] =
|
||||
xtalk_base.ack_statuses[i];
|
||||
stat_msg = xtalk_dev->xproto.ack_statuses[i];
|
||||
if (stat_msg)
|
||||
DBG("global: status=0x%X (%s)\n", i, stat_msg);
|
||||
DBG("global: status=0x%X (%s)\n",
|
||||
i, stat_msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -206,7 +212,8 @@ struct xtalk_command *new_command(
|
|||
}
|
||||
DBG("OP=0x%X [%s] (extra_data %d)\n", op, desc->name, extra_data);
|
||||
len = desc->len + extra_data;
|
||||
if((cmd = malloc(len)) == NULL) {
|
||||
cmd = malloc(len);
|
||||
if (!cmd) {
|
||||
ERR("Out of memory\n");
|
||||
return NULL;
|
||||
}
|
||||
|
@ -234,12 +241,12 @@ void xtalk_dump_command(struct xtalk_command *cmd)
|
|||
}
|
||||
INFO("DUMP: OP=0x%X len=%d seq=%d\n",
|
||||
cmd->header.op, cmd->header.len, cmd->header.seq);
|
||||
for(i = 0; i < len - sizeof(struct xtalk_header); i++) {
|
||||
for (i = 0; i < len - sizeof(struct xtalk_header); i++)
|
||||
INFO(" %2d. 0x%X\n", i, cmd->alt.raw_data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static int send_command(struct xtalk_device *xtalk_dev, struct xtalk_command *cmd, int timeout)
|
||||
static int send_command(struct xtalk_device *xtalk_dev,
|
||||
struct xtalk_command *cmd, int timeout)
|
||||
{
|
||||
int ret;
|
||||
int len;
|
||||
|
@ -248,41 +255,28 @@ static int send_command(struct xtalk_device *xtalk_dev, struct xtalk_command *cm
|
|||
len = cmd->header.len;
|
||||
cmd->header.seq = xtalk_dev->tx_sequenceno;
|
||||
|
||||
//printf("%s: len=%d\n", __FUNCTION__, len);
|
||||
#if 0
|
||||
extern FILE *fp;
|
||||
char *buf;
|
||||
|
||||
buf = (char *)cmd;
|
||||
if(fp) {
|
||||
int i;
|
||||
|
||||
fprintf(fp, "%05d:", cmd->header.seq);
|
||||
for(i = 0; i < len; i++)
|
||||
fprintf(fp, " %02X", (uint8_t)buf[i]);
|
||||
fprintf(fp, "\n");
|
||||
}
|
||||
#endif
|
||||
ret = xtalk_dev->ops.send_func(priv, (char *)cmd, len, timeout);
|
||||
if(ret < 0) {
|
||||
if (ret < 0)
|
||||
DBG("send_func failed ret=%d\n", ret);
|
||||
}
|
||||
xtalk_dev->tx_sequenceno++;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct xtalk_command *recv_command(struct xtalk_device *xtalk_dev, int timeout)
|
||||
static struct xtalk_command *recv_command(struct xtalk_device *xtalk_dev,
|
||||
int timeout)
|
||||
{
|
||||
struct xtalk_command *reply;
|
||||
void *priv = xtalk_dev->transport_priv;
|
||||
size_t psize = xtalk_dev->packet_size;
|
||||
int ret;
|
||||
|
||||
if((reply = malloc(xtalk_dev->packet_size)) == NULL) {
|
||||
reply = malloc(psize);
|
||||
if (!reply) {
|
||||
ERR("Out of memory\n");
|
||||
goto err;
|
||||
}
|
||||
reply->header.len = 0;
|
||||
ret = xtalk_dev->ops.recv_func(priv, (char *)reply, xtalk_dev->packet_size, timeout);
|
||||
ret = xtalk_dev->ops.recv_func(priv, (char *)reply, psize, timeout);
|
||||
if (ret < 0) {
|
||||
ERR("Receive from usb failed.\n");
|
||||
goto err;
|
||||
|
@ -290,16 +284,17 @@ static struct xtalk_command *recv_command(struct xtalk_device *xtalk_dev, int ti
|
|||
goto err; /* No reply */
|
||||
}
|
||||
if (ret != reply->header.len) {
|
||||
ERR("Wrong length received: got %d bytes, but length field says %d bytes%s\n",
|
||||
ERR("Wrong length received: got %d bytes, "
|
||||
"but length field says %d bytes%s\n",
|
||||
ret, reply->header.len,
|
||||
(ret == 1) ? ". Old USB firmware?" : "");
|
||||
goto err;
|
||||
}
|
||||
//dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, (char *)reply, ret);
|
||||
/* dump_packet(LOG_DEBUG, DBG_MASK, __func__, (char *)reply, ret); */
|
||||
return reply;
|
||||
err:
|
||||
if (reply) {
|
||||
memset(reply, 0, xtalk_dev->packet_size);
|
||||
memset(reply, 0, psize);
|
||||
free_command(reply);
|
||||
}
|
||||
return NULL;
|
||||
|
@ -323,12 +318,12 @@ int process_command(
|
|||
|
||||
xproto = &xtalk_dev->xproto;
|
||||
protoname = (xproto) ? xproto->name : "GLOBAL";
|
||||
/* So the caller knows if a reply was received */
|
||||
if (reply_ref)
|
||||
*reply_ref = NULL; /* So the caller knows if a reply was received */
|
||||
*reply_ref = NULL;
|
||||
reply_op = cmd->header.op | XTALK_REPLY_MASK;
|
||||
cmd_desc = get_command_desc(xproto, cmd->header.op);
|
||||
expected = get_command_desc(xproto, reply_op);
|
||||
//printf("%s: len=%d\n", __FUNCTION__, cmd->header.len);
|
||||
ret = send_command(xtalk_dev, cmd, TIMEOUT);
|
||||
if (!reply_ref) {
|
||||
DBG("No reply requested\n");
|
||||
|
@ -346,14 +341,16 @@ int process_command(
|
|||
}
|
||||
*reply_ref = reply;
|
||||
if ((reply->header.op & 0x80) != 0x80) {
|
||||
ERR("Unexpected reply op=0x%02X, should have MSB set.\n", reply->header.op);
|
||||
ERR("Unexpected reply op=0x%02X, should have MSB set.\n",
|
||||
reply->header.op);
|
||||
ret = -EPROTO;
|
||||
goto out;
|
||||
}
|
||||
DBG("REPLY OP: 0x%X\n", reply->header.op);
|
||||
reply_desc = get_command_desc(xproto, reply->header.op);
|
||||
if (!reply_desc) {
|
||||
ERR("Unknown reply (proto=%s) op=0x%02X\n", protoname, reply->header.op);
|
||||
ERR("Unknown reply (proto=%s) op=0x%02X\n",
|
||||
protoname, reply->header.op);
|
||||
ret = -EPROTO;
|
||||
goto out;
|
||||
}
|
||||
|
@ -363,7 +360,9 @@ int process_command(
|
|||
|
||||
if (expected) {
|
||||
ERR("Expected OP=0x%02X: Got ACK(%d): %s\n",
|
||||
reply_op, status, ack_status_msg(xproto, status));
|
||||
reply_op,
|
||||
status,
|
||||
ack_status_msg(xproto, status));
|
||||
ret = -EPROTO;
|
||||
goto out;
|
||||
} else if (status != STAT_OK) {
|
||||
|
@ -372,12 +371,6 @@ int process_command(
|
|||
cmd->header.op,
|
||||
cmd_desc->name,
|
||||
status, ack_status_msg(xproto, status));
|
||||
#if 0
|
||||
extern FILE *fp;
|
||||
if(fp) {
|
||||
fprintf(fp, "Got ACK(%d)\n", status);
|
||||
}
|
||||
#endif
|
||||
ret = -EPROTO;
|
||||
goto out;
|
||||
}
|
||||
|
@ -423,17 +416,20 @@ int xtalk_proto_query(struct xtalk_device *xtalk_dev)
|
|||
DBG("\n");
|
||||
assert(xtalk_dev != NULL);
|
||||
proto_version = xtalk_dev->xproto.proto_version;
|
||||
if((cmd = new_command(xtalk_dev, XTALK_PROTO_GET, 0)) == NULL) {
|
||||
cmd = new_command(xtalk_dev, XTALK_PROTO_GET, 0);
|
||||
if (!cmd) {
|
||||
ERR("new_command failed\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
CMD_FIELD(cmd, XTALK, PROTO_GET, proto_version) = proto_version; /* Protocol Version */
|
||||
/* Protocol Version */
|
||||
CMD_FIELD(cmd, XTALK, PROTO_GET, proto_version) = proto_version;
|
||||
ret = process_command(xtalk_dev, cmd, &reply);
|
||||
if (ret < 0) {
|
||||
ERR("process_command failed: %d\n", ret);
|
||||
goto out;
|
||||
}
|
||||
xtalk_dev->xtalk_proto_version = CMD_FIELD(reply, XTALK, PROTO_GET_REPLY, proto_version);
|
||||
xtalk_dev->xtalk_proto_version =
|
||||
CMD_FIELD(reply, XTALK, PROTO_GET_REPLY, proto_version);
|
||||
if (xtalk_dev->xtalk_proto_version != proto_version) {
|
||||
DBG("Got %s protocol version: 0x%02x (expected 0x%02x)\n",
|
||||
xtalk_dev->xproto.name,
|
||||
|
@ -453,19 +449,22 @@ out:
|
|||
* Wrappers
|
||||
*/
|
||||
|
||||
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops, size_t packet_size, void *priv)
|
||||
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops,
|
||||
size_t packet_size, void *priv)
|
||||
{
|
||||
struct xtalk_device *xtalk_dev;
|
||||
int ret;
|
||||
|
||||
DBG("\n");
|
||||
assert(ops != NULL);
|
||||
if((xtalk_dev = malloc(sizeof(*xtalk_dev))) == NULL) {
|
||||
xtalk_dev = malloc(sizeof(*xtalk_dev));
|
||||
if (!xtalk_dev) {
|
||||
ERR("Allocating XTALK device memory failed\n");
|
||||
return NULL;
|
||||
}
|
||||
memset(xtalk_dev, 0, sizeof(*xtalk_dev));
|
||||
memcpy((void *)&xtalk_dev->ops, (const void *)ops, sizeof(xtalk_dev->ops));
|
||||
memcpy((void *)&xtalk_dev->ops, (const void *)ops,
|
||||
sizeof(xtalk_dev->ops));
|
||||
xtalk_dev->transport_priv = priv;
|
||||
xtalk_dev->packet_size = packet_size;
|
||||
xtalk_dev->tx_sequenceno = 1;
|
||||
|
|
|
@ -95,7 +95,9 @@ struct xtalk_command {
|
|||
*/
|
||||
#define XTALK_STRUCT(p, o) p ## _struct_ ## o
|
||||
#define XTALK_PDATA(o) xtalk_privdata_ ## o
|
||||
#define CMD_FIELD(cmd, p, o, field) (((union XTALK_PDATA(p) *)&((cmd)->alt))->XTALK_STRUCT(p, o).field)
|
||||
#define XTALK_CMD_PTR(cmd, p) ((union XTALK_PDATA(p)*)&((cmd)->alt))
|
||||
#define CMD_FIELD(cmd, p, o, field) \
|
||||
(XTALK_CMD_PTR(cmd, p)->XTALK_STRUCT(p, o).field)
|
||||
#define CMD_DEF(p, o, ...) struct XTALK_STRUCT(p, o) { \
|
||||
__VA_ARGS__ \
|
||||
} PACKED XTALK_STRUCT(p, o)
|
||||
|
@ -103,8 +105,10 @@ struct xtalk_command {
|
|||
|
||||
/* Wrappers for transport (xusb) functions */
|
||||
struct xtalk_ops {
|
||||
int (*send_func)(void *transport_priv, void *data, size_t len, int timeout);
|
||||
int (*recv_func)(void *transport_priv, void *data, size_t maxlen, int timeout);
|
||||
int (*send_func)(void *transport_priv, void *data, size_t len,
|
||||
int timeout);
|
||||
int (*recv_func)(void *transport_priv, void *data, size_t maxlen,
|
||||
int timeout);
|
||||
int (*close_func)(void *transport_priv);
|
||||
};
|
||||
|
||||
|
@ -116,9 +120,11 @@ struct xtalk_ops {
|
|||
struct xtalk_device;
|
||||
|
||||
/* high-level */
|
||||
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops, size_t packet_size, void *transport_priv);
|
||||
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops,
|
||||
size_t packet_size, void *transport_priv);
|
||||
void xtalk_delete(struct xtalk_device *dev);
|
||||
int xtalk_set_protocol(struct xtalk_device *xtalk_dev, const struct xtalk_protocol *xproto);
|
||||
int xtalk_set_protocol(struct xtalk_device *xtalk_dev,
|
||||
const struct xtalk_protocol *xproto);
|
||||
int xtalk_proto_query(struct xtalk_device *dev);
|
||||
void xtalk_dump_command(struct xtalk_command *cmd);
|
||||
|
||||
|
@ -139,9 +145,9 @@ void free_command(struct xtalk_command *cmd);
|
|||
* cb - A callback function (type xtalk_cmd_callback_t)
|
||||
*/
|
||||
#define CMD_RECV(p, o, cb) \
|
||||
[p ## _ ## o | XTALK_REPLY_MASK] { \
|
||||
.op = p ## _ ## o | XTALK_REPLY_MASK, \
|
||||
.name = #o "_reply", \
|
||||
[p ## _ ## o | XTALK_REPLY_MASK] = { \
|
||||
.op = (p ## _ ## o) | XTALK_REPLY_MASK, \
|
||||
.name = (#o "_reply"), \
|
||||
.callback = (cb), \
|
||||
.len = \
|
||||
sizeof(struct xtalk_header) + \
|
||||
|
@ -149,9 +155,9 @@ void free_command(struct xtalk_command *cmd);
|
|||
}
|
||||
|
||||
#define CMD_SEND(p, o) \
|
||||
[p ## _ ## o] { \
|
||||
.op = p ## _ ## o, \
|
||||
.name = #o, \
|
||||
[p ## _ ## o] = { \
|
||||
.op = (p ## _ ## o), \
|
||||
.name = (#o), \
|
||||
.callback = NULL, \
|
||||
.len = \
|
||||
sizeof(struct xtalk_header) + \
|
||||
|
|
|
@ -18,7 +18,8 @@
|
|||
#define XTALK_PROTO_GET_REPLY (XTALK_PROTO_GET | XTALK_REPLY_MASK)
|
||||
#define XTALK_FWVERS_GET 0x11
|
||||
#define XTALK_FWVERS_GET_REPLY (XTALK_FWVERS_GET | XTALK_REPLY_MASK)
|
||||
#define XTALK_CAPS_GET 0x0E /* Get EEPROM table contents Product/Vendor Id ... */
|
||||
/* Get EEPROM table contents Product/Vendor Id ... */
|
||||
#define XTALK_CAPS_GET 0x0E
|
||||
#define XTALK_CAPS_GET_REPLY (XTALK_CAPS_GET | XTALK_REPLY_MASK)
|
||||
|
||||
/*------------- XTALK: statuses in ACK ---------------------------------------*/
|
||||
|
|
185
xpp/xtalk/xusb.c
185
xpp/xtalk/xusb.c
|
@ -35,8 +35,6 @@
|
|||
#include <sys/ipc.h>
|
||||
#include <sys/sem.h>
|
||||
|
||||
static const char rcsid[] = "$Id$";
|
||||
|
||||
#define DBG_MASK 0x01
|
||||
#define TIMEOUT 500
|
||||
#define MAX_RETRIES 10
|
||||
|
@ -67,7 +65,8 @@ void xusb_init_spec(struct xusb_spec *spec, char *name,
|
|||
uint16_t vendor_id, uint16_t product_id,
|
||||
int nifaces, int iface, int nep, int ep_out, int ep_in)
|
||||
{
|
||||
DBG("Initialize %s: interfaces=%d using interface num=%d endpoints=%d (OUT=0x%02X, IN=0x%02X)\n",
|
||||
DBG("Initialize %s: interfaces=%d using interface num=%d endpoints=%d "
|
||||
"(OUT=0x%02X, IN=0x%02X)\n",
|
||||
name, nifaces, iface, nep, ep_out, ep_in);
|
||||
memset(spec, 0, sizeof(*spec));
|
||||
spec->name = name;
|
||||
|
@ -87,7 +86,7 @@ void xusb_init_spec(struct xusb_spec *spec, char *name,
|
|||
* USB handling
|
||||
*/
|
||||
|
||||
static int get_usb_string(struct xusb *xusb, uint8_t item, char *buf, unsigned int len)
|
||||
static int get_usb_string(struct xusb *xusb, uint8_t item, char *buf)
|
||||
{
|
||||
char tmp[BUFSIZ];
|
||||
int ret;
|
||||
|
@ -98,10 +97,13 @@ static int get_usb_string(struct xusb *xusb, uint8_t item, char *buf, unsigned i
|
|||
ret = usb_get_string_simple(xusb->handle, item, tmp, BUFSIZ);
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
return snprintf(buf, len, "%s", tmp);
|
||||
return snprintf(buf, BUFSIZ, "%s", tmp);
|
||||
}
|
||||
|
||||
static const struct usb_interface_descriptor *get_interface(const struct usb_device *dev, int my_interface_num, int num_interfaces)
|
||||
static const struct usb_interface_descriptor *get_interface(
|
||||
const struct usb_device *dev,
|
||||
int my_interface_num,
|
||||
int num_interfaces)
|
||||
{
|
||||
const struct usb_interface *interface;
|
||||
const struct usb_interface_descriptor *iface_desc;
|
||||
|
@ -127,16 +129,16 @@ static const struct usb_interface_descriptor *get_interface(const struct usb_dev
|
|||
return iface_desc;
|
||||
}
|
||||
|
||||
static int match_interface(const struct usb_device *dev, const struct xusb_spec *spec)
|
||||
static int match_interface(const struct usb_device *dev,
|
||||
const struct xusb_spec *spec)
|
||||
{
|
||||
const struct usb_device_descriptor *dev_desc;
|
||||
const struct usb_interface_descriptor *iface_desc;
|
||||
|
||||
//debug_mask = 0xFF;
|
||||
//verbose = 1;
|
||||
dev_desc = &dev->descriptor;
|
||||
assert(dev_desc);
|
||||
DBG("Checking: %04X:%04X interfaces=%d interface num=%d endpoints=%d: \"%s\"\n",
|
||||
DBG("Checking: %04X:%04X interfaces=%d interface num=%d endpoints=%d: "
|
||||
"\"%s\"\n",
|
||||
spec->my_vendor_id,
|
||||
spec->my_product_id,
|
||||
spec->num_interfaces,
|
||||
|
@ -151,12 +153,16 @@ static int match_interface(const struct usb_device *dev, const struct xusb_spec
|
|||
DBG("Wrong product id 0x%X\n", dev_desc->idProduct);
|
||||
return 0;
|
||||
}
|
||||
if((iface_desc = get_interface(dev, spec->my_interface_num, spec->num_interfaces)) == NULL) {
|
||||
ERR("Could not get interface descriptor of device: %s\n", usb_strerror());
|
||||
iface_desc = get_interface(dev, spec->my_interface_num,
|
||||
spec->num_interfaces);
|
||||
if (!iface_desc) {
|
||||
ERR("Could not get interface descriptor of device: %s\n",
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if (iface_desc->bInterfaceClass != 0xFF) {
|
||||
DBG("Wrong interface class 0x%X\n", iface_desc->bInterfaceClass);
|
||||
DBG("Wrong interface class 0x%X\n",
|
||||
iface_desc->bInterfaceClass);
|
||||
return 0;
|
||||
}
|
||||
if (iface_desc->bInterfaceNumber != spec->my_interface_num) {
|
||||
|
@ -165,12 +171,16 @@ static int match_interface(const struct usb_device *dev, const struct xusb_spec
|
|||
return 0;
|
||||
}
|
||||
if (iface_desc->bNumEndpoints != spec->num_endpoints) {
|
||||
DBG("Wrong number of endpoints %d\n", iface_desc->bNumEndpoints);
|
||||
DBG("Wrong number of endpoints %d\n",
|
||||
iface_desc->bNumEndpoints);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
#define GET_USB_STRING(xusb, from, item) \
|
||||
get_usb_string((xusb), (from)->item, xusb->item)
|
||||
|
||||
static int xusb_fill_strings(struct xusb *xusb)
|
||||
{
|
||||
const struct usb_device_descriptor *dev_desc;
|
||||
|
@ -179,23 +189,28 @@ static int xusb_fill_strings(struct xusb *xusb)
|
|||
|
||||
dev_desc = &xusb->dev->descriptor;
|
||||
assert(dev_desc);
|
||||
if(get_usb_string(xusb, dev_desc->iManufacturer, xusb->iManufacturer, BUFSIZ) < 0) {
|
||||
ERR("Failed reading iManufacturer string: %s\n", usb_strerror());
|
||||
if (GET_USB_STRING(xusb, dev_desc, iManufacturer) < 0) {
|
||||
ERR("Failed reading iManufacturer string: %s\n",
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if(get_usb_string(xusb, dev_desc->iProduct, xusb->iProduct, BUFSIZ) < 0) {
|
||||
ERR("Failed reading iProduct string: %s\n", usb_strerror());
|
||||
if (GET_USB_STRING(xusb, dev_desc, iProduct) < 0) {
|
||||
ERR("Failed reading iProduct string: %s\n",
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if(get_usb_string(xusb, dev_desc->iSerialNumber, xusb->iSerialNumber, BUFSIZ) < 0) {
|
||||
ERR("Failed reading iSerialNumber string: %s\n", usb_strerror());
|
||||
if (GET_USB_STRING(xusb, dev_desc, iSerialNumber) < 0) {
|
||||
ERR("Failed reading iSerialNumber string: %s\n",
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if((iface_desc = get_interface(xusb->dev, xusb->interface_num, 0)) == NULL) {
|
||||
ERR("Could not get interface descriptor of device: %s\n", usb_strerror());
|
||||
iface_desc = get_interface(xusb->dev, xusb->interface_num, 0);
|
||||
if (!iface_desc) {
|
||||
ERR("Could not get interface descriptor of device: %s\n",
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if(get_usb_string(xusb, iface_desc->iInterface, xusb->iInterface, BUFSIZ) < 0) {
|
||||
if (GET_USB_STRING(xusb, iface_desc, iInterface) < 0) {
|
||||
ERR("Failed reading iInterface string: %s\n", usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
|
@ -207,7 +222,8 @@ static int xusb_open(struct xusb *xusb)
|
|||
assert(xusb);
|
||||
if (xusb->is_open)
|
||||
return 1;
|
||||
if((xusb->handle = usb_open(xusb->dev)) == NULL) {
|
||||
xusb->handle = usb_open(xusb->dev);
|
||||
if (!xusb->handle) {
|
||||
ERR("Failed to open usb device '%s': %s\n",
|
||||
xusb->devpath_tail, usb_strerror());
|
||||
return 0;
|
||||
|
@ -225,13 +241,16 @@ int xusb_claim_interface(struct xusb *xusb)
|
|||
xusb_open(xusb); /* If it's not open yet... */
|
||||
if (usb_claim_interface(xusb->handle, xusb->interface_num) != 0) {
|
||||
ERR("usb_claim_interface %d in '%s': %s\n",
|
||||
xusb->interface_num, xusb->devpath_tail, usb_strerror());
|
||||
xusb->interface_num,
|
||||
xusb->devpath_tail,
|
||||
usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
xusb->is_claimed = 1;
|
||||
xusb_fill_strings(xusb);
|
||||
dev_desc = &xusb->dev->descriptor;
|
||||
DBG("ID=%04X:%04X Manufacturer=[%s] Product=[%s] SerialNumber=[%s] Interface=[%s]\n",
|
||||
DBG("ID=%04X:%04X Manufacturer=[%s] Product=[%s] "
|
||||
"SerialNumber=[%s] Interface=[%s]\n",
|
||||
dev_desc->idVendor,
|
||||
dev_desc->idProduct,
|
||||
xusb->iManufacturer,
|
||||
|
@ -246,7 +265,8 @@ int xusb_claim_interface(struct xusb *xusb)
|
|||
ERR("Clearing input endpoint: %s\n", usb_strerror());
|
||||
return 0;
|
||||
}
|
||||
if((ret = xusb_flushread(xusb)) < 0) {
|
||||
ret = xusb_flushread(xusb);
|
||||
if (ret < 0) {
|
||||
ERR("xusb_flushread failed: %d\n", ret);
|
||||
return 0;
|
||||
}
|
||||
|
@ -292,7 +312,8 @@ void xusb_destroy(struct xusb *xusb)
|
|||
}
|
||||
}
|
||||
|
||||
static struct xusb *xusb_new(struct usb_device *dev, const struct xusb_spec *spec)
|
||||
static struct xusb *xusb_new(struct usb_device *dev,
|
||||
const struct xusb_spec *spec)
|
||||
{
|
||||
struct usb_device_descriptor *dev_desc;
|
||||
struct usb_config_descriptor *config_desc;
|
||||
|
@ -306,11 +327,13 @@ static struct xusb *xusb_new(struct usb_device *dev, const struct xusb_spec *spe
|
|||
/*
|
||||
* Get information from the usb_device
|
||||
*/
|
||||
if((dev_desc = &dev->descriptor) == NULL) {
|
||||
dev_desc = &dev->descriptor;
|
||||
if (!dev_desc) {
|
||||
ERR("usb device without a device descriptor\n");
|
||||
goto fail;
|
||||
}
|
||||
if((config_desc = dev->config) == NULL) {
|
||||
config_desc = dev->config;
|
||||
if (!config_desc) {
|
||||
ERR("usb device without a configuration descriptor\n");
|
||||
goto fail;
|
||||
}
|
||||
|
@ -320,19 +343,22 @@ static struct xusb *xusb_new(struct usb_device *dev, const struct xusb_spec *spe
|
|||
/* Calculate max packet size */
|
||||
max_packet_size = PACKET_SIZE;
|
||||
for (i = 0; i < iface_desc->bNumEndpoints; i++, endpoint++) {
|
||||
DBG("Validating endpoint @ %d (interface %d)\n", i, spec->my_interface_num);
|
||||
if(endpoint->bEndpointAddress == spec->my_ep_out || endpoint->bEndpointAddress == spec->my_ep_in) {
|
||||
DBG("Validating endpoint @ %d (interface %d)\n",
|
||||
i, spec->my_interface_num);
|
||||
if (endpoint->bEndpointAddress == spec->my_ep_out ||
|
||||
endpoint->bEndpointAddress == spec->my_ep_in) {
|
||||
if (endpoint->wMaxPacketSize > PACKET_SIZE) {
|
||||
ERR("Endpoint #%d wMaxPacketSize too large (%d)\n", i, endpoint->wMaxPacketSize);
|
||||
ERR("EP #%d wMaxPacketSize too large (%d)\n",
|
||||
i, endpoint->wMaxPacketSize);
|
||||
goto fail;
|
||||
}
|
||||
if(endpoint->wMaxPacketSize < max_packet_size) {
|
||||
if (endpoint->wMaxPacketSize < max_packet_size)
|
||||
max_packet_size = endpoint->wMaxPacketSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Fill xusb */
|
||||
if((xusb = malloc(sizeof(*xusb))) == NULL) {
|
||||
xusb = malloc(sizeof(*xusb));
|
||||
if (!xusb) {
|
||||
ERR("Out of memory");
|
||||
goto fail;
|
||||
}
|
||||
|
@ -396,7 +422,8 @@ struct xusb *xusb_find_iface(const char *devpath,
|
|||
|
||||
sscanf(dev->filename, "%d", &device_num);
|
||||
DBG("Check device %d\n", device_num);
|
||||
snprintf(tmppath, sizeof(tmppath), "%03d/%03d", bus_num, device_num);
|
||||
snprintf(tmppath, sizeof(tmppath), "%03d/%03d",
|
||||
bus_num, device_num);
|
||||
if (strncmp(tmppath, devpath, strlen(tmppath)) != 0)
|
||||
continue;
|
||||
dev_desc = &dev->descriptor;
|
||||
|
@ -405,7 +432,8 @@ struct xusb *xusb_find_iface(const char *devpath,
|
|||
assert(config_desc);
|
||||
interface = config_desc->interface;
|
||||
assert(interface);
|
||||
DBG("Matched device %s: %X:%X\n", tmppath, dev_desc->idVendor, dev_desc->idProduct);
|
||||
DBG("Matched device %s: %X:%X\n", tmppath,
|
||||
dev_desc->idVendor, dev_desc->idProduct);
|
||||
assert(dummy_spec);
|
||||
xusb_init_spec(dummy_spec, "<none>",
|
||||
dev_desc->idVendor, dev_desc->idProduct,
|
||||
|
@ -413,9 +441,9 @@ struct xusb *xusb_find_iface(const char *devpath,
|
|||
iface_num,
|
||||
interface->altsetting->bNumEndpoints,
|
||||
ep_out, ep_in);
|
||||
if((xusb = xusb_new(dev, dummy_spec)) == NULL) {
|
||||
xusb = xusb_new(dev, dummy_spec);
|
||||
if (!xusb)
|
||||
ERR("xusb allocation failed\n");
|
||||
}
|
||||
return xusb;
|
||||
}
|
||||
}
|
||||
|
@ -428,16 +456,17 @@ static const char *path_tail(const char *path)
|
|||
|
||||
assert(path != NULL);
|
||||
/* Find last '/' */
|
||||
if((p = memrchr(path, '/', strlen(path))) == NULL) {
|
||||
p = memrchr(path, '/', strlen(path));
|
||||
if (!p) {
|
||||
ERR("Missing a '/' in %s\n", path);
|
||||
return NULL;
|
||||
}
|
||||
/* Search for a '/' before that */
|
||||
if((p = memrchr(path, '/', p - path)) == NULL) {
|
||||
p = memrchr(path, '/', p - path);
|
||||
if (!p)
|
||||
p = path; /* No more '/' */
|
||||
} else {
|
||||
else
|
||||
p++; /* skip '/' */
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
|
@ -450,24 +479,28 @@ int xusb_filter_bypath(const struct xusb *xusb, void *data)
|
|||
assert(path != NULL);
|
||||
p = path_tail(path);
|
||||
if (strcmp(xusb->devpath_tail, p) != 0) {
|
||||
DBG("device path missmatch: '%s' != '%s'\n", xusb->devpath_tail, p);
|
||||
DBG("device path missmatch: '%s' != '%s'\n",
|
||||
xusb->devpath_tail, p);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs, const char *path)
|
||||
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs,
|
||||
const char *path)
|
||||
{
|
||||
struct xlist_node *xlist;
|
||||
struct xlist_node *head;
|
||||
struct xusb *xusb;
|
||||
|
||||
xlist = xusb_find_byproduct(specs, numspecs, xusb_filter_bypath, (void *)path);
|
||||
xlist = xusb_find_byproduct(specs, numspecs,
|
||||
xusb_filter_bypath, (void *)path);
|
||||
head = xlist_shift(xlist);
|
||||
if (!head)
|
||||
return NULL;
|
||||
if (!xlist_empty(xlist)) {
|
||||
ERR("Too many matches (extra %zd) to '%s'\n", xlist_length(xlist), path);
|
||||
ERR("Too many matches (extra %zd) to '%s'\n",
|
||||
xlist_length(xlist), path);
|
||||
return NULL;
|
||||
}
|
||||
xusb = head->data;
|
||||
|
@ -475,14 +508,16 @@ struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs, const
|
|||
return xusb;
|
||||
}
|
||||
|
||||
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs, int numspecs, xusb_filter_t filterfunc, void *data)
|
||||
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs,
|
||||
int numspecs, xusb_filter_t filterfunc, void *data)
|
||||
{
|
||||
struct xlist_node *xlist;
|
||||
struct usb_bus *bus;
|
||||
struct usb_device *dev;
|
||||
|
||||
DBG("specs(%d)\n", numspecs);
|
||||
if((xlist = xlist_new(NULL)) == NULL) {
|
||||
xlist = xlist_new(NULL);
|
||||
if (!xlist) {
|
||||
ERR("Failed allocation new xlist");
|
||||
goto fail_xlist;
|
||||
}
|
||||
|
@ -506,7 +541,8 @@ struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs, int numspe
|
|||
|
||||
if (!match_interface(dev, sp))
|
||||
continue;
|
||||
if((xusb = xusb_new(dev, sp)) == NULL) {
|
||||
xusb = xusb_new(dev, sp);
|
||||
if (!xusb) {
|
||||
ERR("xusb allocation failed\n");
|
||||
goto fail_malloc;
|
||||
}
|
||||
|
@ -528,7 +564,8 @@ fail_xlist:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs, xusb_filter_t filterfunc, void *data)
|
||||
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs,
|
||||
xusb_filter_t filterfunc, void *data)
|
||||
{
|
||||
struct xlist_node *xusb_list;
|
||||
struct xlist_node *curr;
|
||||
|
@ -646,14 +683,16 @@ int xusb_close(struct xusb *xusb)
|
|||
assert(xusb->spec->name);
|
||||
DBG("Closing interface \"%s\"\n", xusb->spec->name);
|
||||
if (xusb->is_claimed) {
|
||||
if(usb_release_interface(xusb->handle, xusb->spec->my_interface_num) != 0) {
|
||||
ERR("Releasing interface: usb: %s\n", usb_strerror());
|
||||
}
|
||||
if (usb_release_interface(xusb->handle,
|
||||
xusb->spec->my_interface_num) != 0)
|
||||
ERR("Releasing interface: usb: %s\n",
|
||||
usb_strerror());
|
||||
xusb->is_claimed = 0;
|
||||
}
|
||||
if (xusb->is_open) {
|
||||
if (usb_close(xusb->handle) != 0) {
|
||||
ERR("Closing device: usb: %s\n", usb_strerror());
|
||||
ERR("Closing device: usb: %s\n",
|
||||
usb_strerror());
|
||||
}
|
||||
xusb->is_open = 0;
|
||||
}
|
||||
|
@ -669,9 +708,10 @@ int xusb_send(struct xusb *xusb, char *buf, int len, int timeout)
|
|||
int ret;
|
||||
int retries = 0;
|
||||
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, buf, len);
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __func__, buf, len);
|
||||
if (EP_OUT(xusb) & USB_ENDPOINT_IN) {
|
||||
ERR("%s called with an input endpoint 0x%x\n", __FUNCTION__, EP_OUT(xusb));
|
||||
ERR("%s called with an input endpoint 0x%x\n",
|
||||
__func__, EP_OUT(xusb));
|
||||
return -EINVAL;
|
||||
}
|
||||
retry_write:
|
||||
|
@ -684,10 +724,12 @@ retry_write:
|
|||
if (ret != -ENODEV) {
|
||||
ERR("bulk_write to endpoint 0x%x failed: (%d) %s\n",
|
||||
EP_OUT(xusb), ret, usb_strerror());
|
||||
dump_packet(LOG_ERR, DBG_MASK, "xusb_send[ERR]", buf, len);
|
||||
//exit(2);
|
||||
dump_packet(LOG_ERR, DBG_MASK, "xusb_send[ERR]",
|
||||
buf, len);
|
||||
/*exit(2);*/
|
||||
} else {
|
||||
DBG("bulk_write to endpoint 0x%x got ENODEV\n", EP_OUT(xusb));
|
||||
DBG("bulk_write to endpoint 0x%x got ENODEV\n",
|
||||
EP_OUT(xusb));
|
||||
xusb_close(xusb);
|
||||
}
|
||||
return ret;
|
||||
|
@ -707,9 +749,8 @@ retry_write:
|
|||
#endif
|
||||
ERR("bulk_write to endpoint 0x%x short write[%d]: (%d)\n",
|
||||
EP_OUT(xusb), retries, ret);
|
||||
if (retries++ > MAX_RETRIES) {
|
||||
if (retries++ > MAX_RETRIES)
|
||||
return -EFAULT;
|
||||
}
|
||||
usleep(100);
|
||||
goto retry_write;
|
||||
}
|
||||
|
@ -728,7 +769,8 @@ int xusb_recv(struct xusb *xusb, char *buf, size_t len, int timeout)
|
|||
int retries = 0;
|
||||
|
||||
if (EP_IN(xusb) & USB_ENDPOINT_OUT) {
|
||||
ERR("%s called with an output endpoint 0x%x\n", __FUNCTION__, EP_IN(xusb));
|
||||
ERR("%s called with an output endpoint 0x%x\n",
|
||||
__func__, EP_IN(xusb));
|
||||
return -EINVAL;
|
||||
}
|
||||
retry_read:
|
||||
|
@ -754,13 +796,12 @@ retry_read:
|
|||
#endif
|
||||
ERR("bulk_read to endpoint 0x%x short read[%d]: (%d)\n",
|
||||
EP_IN(xusb), retries, ret);
|
||||
if (retries++ > MAX_RETRIES) {
|
||||
if (retries++ > MAX_RETRIES)
|
||||
return -EFAULT;
|
||||
}
|
||||
usleep(100);
|
||||
goto retry_read;
|
||||
}
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, buf, ret);
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __func__, buf, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -777,7 +818,7 @@ int xusb_flushread(struct xusb *xusb)
|
|||
return ret;
|
||||
} else if (ret > 0) {
|
||||
DBG("Got %d bytes:\n", ret);
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, tmpbuf, ret);
|
||||
dump_packet(LOG_DEBUG, DBG_MASK, __func__, tmpbuf, ret);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@ -817,9 +858,8 @@ static void xusb_lock_usb()
|
|||
sembuf.sem_num = 0;
|
||||
sembuf.sem_op = -1;
|
||||
sembuf.sem_flg = SEM_UNDO;
|
||||
if (semop(semid, &sembuf, 1) < 0) {
|
||||
if (semop(semid, &sembuf, 1) < 0)
|
||||
ERR("%s: semop() failed: %s\n", __func__, strerror(errno));
|
||||
}
|
||||
DBG("%d: LOCKED\n", getpid());
|
||||
}
|
||||
|
||||
|
@ -831,13 +871,12 @@ static void xusb_unlock_usb()
|
|||
sembuf.sem_num = 0;
|
||||
sembuf.sem_op = 1;
|
||||
sembuf.sem_flg = SEM_UNDO;
|
||||
if (semop(semid, &sembuf, 1) < 0) {
|
||||
if (semop(semid, &sembuf, 1) < 0)
|
||||
ERR("%s: semop() failed: %s\n", __func__, strerror(errno));
|
||||
}
|
||||
DBG("%d: UNLOCKED\n", getpid());
|
||||
}
|
||||
|
||||
static int initizalized = 0;
|
||||
static int initizalized;
|
||||
|
||||
static void xusb_init()
|
||||
{
|
||||
|
|
|
@ -64,10 +64,14 @@ struct xusb;
|
|||
* Prototypes
|
||||
*/
|
||||
typedef int (*xusb_filter_t)(const struct xusb *xusb, void *data);
|
||||
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs, int numspecs, xusb_filter_t filterfunc, void *data);
|
||||
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs, const char *path);
|
||||
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs, xusb_filter_t filterfunc, void *data);
|
||||
struct xusb *xusb_find_iface(const char *devpath, int iface_num, int ep_out, int ep_in, struct xusb_spec *dummy);
|
||||
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs,
|
||||
int numspecs, xusb_filter_t filterfunc, void *data);
|
||||
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs,
|
||||
const char *path);
|
||||
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs,
|
||||
xusb_filter_t filterfunc, void *data);
|
||||
struct xusb *xusb_find_iface(const char *devpath, int iface_num,
|
||||
int ep_out, int ep_in, struct xusb_spec *dummy);
|
||||
|
||||
/*
|
||||
* A convenience filter
|
||||
|
|
Loading…
Reference in New Issue