static void add_en_passant_captures(list_t * list, const board_t * board) {
int from, to;
int me;
int inc;
int pawn;
ASSERT(list!=NULL);
ASSERT(board!=NULL);
to = board->ep_square;
if (to != SquareNone) {
me = board->turn;
inc = PAWN_MOVE_INC(me);
pawn = PAWN_MAKE(me);
from = to - (inc-1);
if (board->square[from] == pawn) {
ASSERT(!SQUARE_IS_PROMOTE(to));
LIST_ADD(list,MOVE_MAKE_FLAGS(from,to,MoveEnPassant));
}
from = to - (inc+1);
if (board->square[from] == pawn) {
ASSERT(!SQUARE_IS_PROMOTE(to));
LIST_ADD(list,MOVE_MAKE_FLAGS(from,to,MoveEnPassant));
}
}
}
void kill(ipcw *w)
{
if (w >= (data+0) && w < (data + preallocated_bitems))
{
LIST_ADD((ipcwspace *)w, first, last, prev, next );
} else
{
LIST_ADD((ipcwspace *)w, first_a, last_a, prev, next);
}
}
void add_promote(list_t * list, int move) {
ASSERT(list!=NULL);
ASSERT(move_is_ok(move));
ASSERT((move&~07777)==0); // HACK
ASSERT(SQUARE_IS_PROMOTE(MOVE_TO(move)));
LIST_ADD(list,move|MovePromoteQueen);
LIST_ADD(list,move|MovePromoteKnight);
LIST_ADD(list,move|MovePromoteRook);
LIST_ADD(list,move|MovePromoteBishop);
}
static void
_fill_zone_config(E_Zone *zone,
E_Config_Dialog_Data *cfdata)
{
E_Radio_Group *rg;
Evas *evas = cfdata->evas;
int i;
/* Clear old entries first */
evas_object_del(cfdata->o_desklist);
cfdata->o_desklist = e_widget_list_add(evas, 1, 0);
e_scrollframe_child_set(e_widget_scrollframe_object_get(cfdata->o_deskscroll), cfdata->o_desklist);
e_widget_sub_object_add(cfdata->o_deskscroll, cfdata->o_desklist);
for (i = 0; i < zone->desk_y_count * zone->desk_x_count; i++)
{
E_Desk *desk = zone->desks[i];
if (!desk) continue;
struct _E_Config_vdesk *vd = get_vdesk(cfdata, desk->x, desk->y, zone->num);
if (!vd)
{
vd = malloc(sizeof(struct _E_Config_vdesk));
vd->x = desk->x;
vd->y = desk->y;
vd->zone_num = zone->num;
vd->layout = TILE_NONE;
cfdata->vdesks = eina_list_append(cfdata->vdesks, vd);
}
rg = e_widget_radio_group_new(&(vd->layout));
Evas_Object *radiolist = e_widget_list_add(evas, 0, 1);
LIST_ADD(radiolist, e_widget_label_add(evas, desk->name));
LIST_ADD(radiolist, RADIO("None", TILE_NONE, rg));
LIST_ADD(radiolist, RADIO("Bigmain", TILE_BIGMAIN, rg));
LIST_ADD(radiolist, RADIO("Grid", TILE_GRID, rg));
LIST_ADD(cfdata->o_desklist, radiolist);
}
/* Get the correct sizes of desklist and scrollframe */
int mw, mh;
e_widget_size_min_get(cfdata->o_desklist, &mw, &mh);
evas_object_resize(cfdata->o_desklist, mw, mh);
if (mh > 150)
mh = 150;
mw += 32;
mh += 32;
e_widget_size_min_set(cfdata->o_deskscroll, mw, mh);
}
/* Log a fork system call.
*
* This will log the return value, but only if it's not 0 (i.e., is in
* the parent). */
static void
handle_fork(struct filemon *fm, char op,
is_at_enum is_at __maybe_unused, struct pt_regs *regs)
{
#ifndef FILEMON_PERFORMANCE_NO_FORK_FM
struct pid *pid;
#endif
int scrv;
scrv = syscall_get_return_value(current, regs);
if (scrv == 0) /* The < 0 case was already handled. */
return;
filemon_log(fm, op, "%i", scrv);
#ifndef FILEMON_PERFORMANCE_NO_FORK_FM
/* List is already locked */
pid = find_get_pid(scrv);
if (pid >= 0) {
struct fm_pids *s;
s = kmalloc(sizeof(struct fm_pids), GFP_KERNEL);
if (s) {
s->pid = pid;
LIST_ADD(&s->list, &fm->shead->list);
}
}
#endif
}
int dfile_create(char const *name, char const *path, int const flags, int const system)
{
DFILE *df = dfile_malloc();
if(!df)
return (-1);
dfile_init(df);
LIST_ADD(l_dfile, df, sizeof(DFILE));
df->state = dfsVirgin;
strncpy(df->name, name, MAX_STRING-1);
strncpy(df->path, path, 79);
if(load_dfile(df, path, flags) != 0)
{
vmlog(8, "dfile_create: bad load on `%s', aborting.\n", path);
LIST_REMOVE(l_dfile, df);
FREE(df);
return (-1);
}
if(system)
df->flags |= DFS_SYSTEM;
return (0);
}
status_t PortCreateFile(fsd_t *fsd, vnode_id_t dir, const wchar_t *name,
void **cookie)
{
port_fsd_t *pfsd;
port_t *server;
pfsd = (port_fsd_t*) fsd;
assert(dir == VNODE_ROOT);
//wprintf(L"PortCreateFile(%s)\n", name);
server = malloc(sizeof(port_t));
if (server == NULL)
return errno;
memset(server, 0, sizeof(port_t));
server->is_server = true;
server->u.server.name = _wcsdup(name);
*cookie = server;
SpinAcquire(&pfsd->sem);
LIST_ADD(pfsd->server, server);
SpinRelease(&pfsd->sem);
return 0;
}
int Sched::addtoactive(Task &task)
{
Task *pos;
uint8_t task_priority;
task_priority = task.Task_GetSchedPriority();
DEBUG_PRINT("addtoactive:task_priority:%d\n",task_priority);
task.Task_SetState(TSTATE_TASK_READYTORUN);
if (LIST_EMPTY(task_active)) { // furtherm
LIST_ADD(task_active, task);
DEBUG_PRINT("LIST_EMPTY:LIST_ADD to task_active OK\n");
Sched_SetCurrentTask(task);
DEBUG_PRINT("It's the first task.\n");
return OK;
}else {
if (LIST_LAST_ENTRY(task_active).Task_GetSchedPriority() > task_priority) {
LIST_ADD_TAIL(task_active, task);
}else {
LIST_FOR_EACH_ENTRY(task_active, pos) {
if (pos->Task_GetSchedPriority() <= task_priority) {
LIST_ADD_BEFORE(task_active, task, (*pos));
}
}
if (!Sched_locked() && IS_LIST_FIRST_ENTRY(task_active, task)) {
return OK;
}
}
}
return NO;
}
static bool add_piece_moves(list_t * list, const board_t * board, int to, bool legal, bool stop) {
int me;
const sq_t * ptr;
int from, piece;
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(SQUARE_IS_OK(to));
ASSERT(legal==true||legal==false);
ASSERT(stop==true||stop==false);
me = board->turn;
for (ptr = &board->piece[me][1]; (from=*ptr) != SquareNone; ptr++) { // HACK: no king
piece = board->square[from];
if (PIECE_ATTACK(board,piece,from,to)) {
if (!legal || !is_pinned(board,from,me)) {
if (stop) return true;
LIST_ADD(list,MOVE_MAKE(from,to));
}
}
}
return false;
}
/**
* Create a session and its associated queues.
* @param nsid namespace id
* @param qcount queue count
* @param qsize queue size
* @return newly created session.
*/
static unvme_session_t* unvme_session_create(int nsid, int qcount, int qsize)
{
DEBUG_FN("%x: nsid=%d qc=%d qs=%d",
unvme_dev.vfiodev->pci, nsid, qcount, qsize);
if ((nsid == 0 && (unvme_dev.ses || qcount != 1)) ||
(nsid != 0 && !unvme_dev.ses)) FATAL("nsid %d", nsid);
// allocate a session with its queue array
unvme_session_t* ses = zalloc(sizeof(unvme_session_t) +
sizeof(unvme_queue_t) * qcount);
ses->queues = (unvme_queue_t*)(ses + 1);
ses->qcount = qcount;
ses->qsize = qsize;
ses->masksize = ((qsize + 63) / 64) * sizeof(u64);
if (pthread_spin_init(&ses->iomem.lock, PTHREAD_PROCESS_SHARED))
FATAL("pthread_spin_init");
LIST_ADD(unvme_dev.ses, ses);
if (!nsid) {
unvme_adminq_create(ses);
unvme_ns_init(ses, nsid);
DEBUG_FN("%x: adminq", unvme_dev.vfiodev->pci);
} else {
unvme_ns_init(ses, nsid);
int i;
for (i = 0; i < qcount; i++) unvme_ioq_create(ses, i);
DEBUG_FN("%x: q=%d-%d bs=%d nb=%lu", unvme_dev.vfiodev->pci,
ses->id, ses->queues[qcount-1].id,
ses->ns.blocksize, ses->ns.blockcount);
}
return ses;
}
void Node_add_sib(Node *sib1, Node *sib2)
{
assert_not(sib1, NULL);
assert_not(sib2, NULL);
LIST_ADD(Node, sib1, sib2, sibling);
sib2->parent = sib1->parent;
}
void Node_add_child(Node *parent, Node *child)
{
assert_not(parent, NULL);
assert_not(child, NULL);
LIST_ADD(Node, parent->child, child, sibling);
child->parent = parent;
}
static void *gp_worker_main(void *pvt)
{
struct gp_thread *t = (struct gp_thread *)pvt;
struct gp_query *q = NULL;
char dummy = 0;
int ret;
while (!t->pool->shutdown) {
/* ======> COND_MUTEX */
pthread_mutex_lock(&t->cond_mutex);
while (t->query == NULL) {
/* wait for next query */
pthread_cond_wait(&t->cond_wakeup, &t->cond_mutex);
if (t->pool->shutdown) {
pthread_exit(NULL);
}
}
/* grab the query off the shared pointer */
q = t->query;
t->query = NULL;
/* <====== COND_MUTEX */
pthread_mutex_unlock(&t->cond_mutex);
/* handle the client request */
gp_handle_query(t->pool, q);
/* now get lock on main queue, to play with the reply list */
/* ======> POOL LOCK */
pthread_mutex_lock(&t->pool->lock);
/* put back query so that dispatcher can send reply */
q->next = t->pool->reply_list;
t->pool->reply_list = q;
/* add us back to the free list but only if we are not
* shutting down */
if (!t->pool->shutdown) {
LIST_DEL(t->pool->busy_list, t);
LIST_ADD(t->pool->free_list, t);
}
/* <====== POOL LOCK */
pthread_mutex_unlock(&t->pool->lock);
/* and wake up dispatcher so it will handle it */
ret = write(t->pool->sig_pipe[1], &dummy, 1);
if (ret == -1) {
GPERROR("Failed to signal dispatcher!");
}
}
pthread_exit(NULL);
}
void add_pawn_move(list_t * list, int from, int to) {
int move;
ASSERT(list!=NULL);
ASSERT(SQUARE_IS_OK(from));
ASSERT(SQUARE_IS_OK(to));
move = MOVE_MAKE(from,to);
if (SQUARE_IS_PROMOTE(to)) {
LIST_ADD(list,move|MovePromoteQueen);
LIST_ADD(list,move|MovePromoteKnight);
LIST_ADD(list,move|MovePromoteRook);
LIST_ADD(list,move|MovePromoteBishop);
} else {
LIST_ADD(list,move);
}
}
static INLINE struct svga_winsys_surface *
svga_screen_cache_lookup(struct svga_screen *svgascreen,
const struct svga_host_surface_cache_key *key)
{
struct svga_host_surface_cache *cache = &svgascreen->cache;
struct svga_winsys_screen *sws = svgascreen->sws;
struct svga_host_surface_cache_entry *entry;
struct svga_winsys_surface *handle = NULL;
struct list_head *curr, *next;
unsigned bucket;
unsigned tries = 0;
assert(key->cachable);
bucket = svga_screen_cache_bucket(key);
pipe_mutex_lock(cache->mutex);
curr = cache->bucket[bucket].next;
next = curr->next;
while(curr != &cache->bucket[bucket]) {
++tries;
entry = LIST_ENTRY(struct svga_host_surface_cache_entry, curr, bucket_head);
assert(entry->handle);
if(memcmp(&entry->key, key, sizeof *key) == 0 &&
sws->fence_signalled( sws, entry->fence, 0 ) == 0) {
assert(sws->surface_is_flushed(sws, entry->handle));
handle = entry->handle; // Reference is transfered here.
entry->handle = NULL;
LIST_DEL(&entry->bucket_head);
LIST_DEL(&entry->head);
LIST_ADD(&entry->head, &cache->empty);
break;
}
curr = next;
next = curr->next;
}
pipe_mutex_unlock(cache->mutex);
if (SVGA_DEBUG & DEBUG_DMA)
debug_printf("%s: cache %s after %u tries (bucket %d)\n", __FUNCTION__,
handle ? "hit" : "miss", tries, bucket);
return handle;
}
static void add_castle_moves(list_t * list, const board_t * board) {
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(!board_is_check(board));
if (COLOUR_IS_WHITE(board->turn)) {
if ((board->flags & FlagsWhiteKingCastle) != 0
&& board->square[F1] == Empty
&& board->square[G1] == Empty
&& !is_attacked(board,F1,Black)) {
LIST_ADD(list,MOVE_MAKE_FLAGS(E1,G1,MoveCastle));
}
if ((board->flags & FlagsWhiteQueenCastle) != 0
&& board->square[D1] == Empty
&& board->square[C1] == Empty
&& board->square[B1] == Empty
&& !is_attacked(board,D1,Black)) {
LIST_ADD(list,MOVE_MAKE_FLAGS(E1,C1,MoveCastle));
}
} else { // black
if ((board->flags & FlagsBlackKingCastle) != 0
&& board->square[F8] == Empty
&& board->square[G8] == Empty
&& !is_attacked(board,F8,White)) {
LIST_ADD(list,MOVE_MAKE_FLAGS(E8,G8,MoveCastle));
}
if ((board->flags & FlagsBlackQueenCastle) != 0
&& board->square[D8] == Empty
&& board->square[C8] == Empty
&& board->square[B8] == Empty
&& !is_attacked(board,D8,White)) {
LIST_ADD(list,MOVE_MAKE_FLAGS(E8,C8,MoveCastle));
}
}
}
static void add_check(list_t * list, int move, board_t * board) {
undo_t undo[1];
ASSERT(list!=NULL);
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
move_do(board,move,undo);
if (IS_IN_CHECK(board,board->turn)) LIST_ADD(list,move);
move_undo(board,move,undo);
}
void RtlHandleRx(rtl8139_t *rtl)
{
uint32_t ring_offs, rx_size, rx_status;
rxpacket_t *packet;
ring_offs = rtl->cur_rx % RX_BUF_LEN;
rx_status = *(uint32_t*) (rtl->rx_ring + ring_offs);
rx_size = rx_status >> 16;
rx_status &= 0xffff;
if ((rx_status & (RxBadSymbol | RxRunt | RxTooLong | RxCRCErr | RxBadAlign)) ||
(rx_size < ETH_ZLEN) ||
(rx_size > ETH_FRAME_LEN + 4))
{
wprintf(L"rx error 0x%x\n", rx_status);
RtlReset(rtl); /* this clears all interrupts still pending */
RtlStartIo(rtl);
return;
}
packet = malloc(sizeof(rxpacket_t) - 1 + rx_size - 4);
if (packet == NULL)
return;
packet->length = rx_size - 4; /* no one cares about the FCS */
/* Received a good packet */
if (ring_offs + 4 + rx_size - 4 > RX_BUF_LEN)
{
int semi_count = RX_BUF_LEN - ring_offs - 4;
memcpy(packet->data, rtl->rx_ring + ring_offs + 4, semi_count);
memcpy(packet->data + semi_count, rtl->rx_ring, rx_size - 4 - semi_count);
//wprintf(L"rx packet %d+%d bytes", semi_count,rx_size - 4 - semi_count);
}
else
{
memcpy(packet->data, rtl->rx_ring + ring_offs + 4, packet->length);
//wprintf(L"rx packet %d bytes", rx_size-4);
}
/*wprintf(L" at %X type %02X%02X rxstatus %hX\n",
(unsigned long)(rtl->rx_ring + ring_offs+4),
packet->data[12], packet->data[13], rx_status);*/
packet->type = *(unsigned short*) (packet->data + 12);
LIST_ADD(rtl->packet, packet);
rtl->cur_rx = (rtl->cur_rx + rx_size + 4 + 3) & ~3;
out16(rtl->iobase + RxBufPtr, rtl->cur_rx - 16);
RtlStartIo(rtl);
}
/*
* Returns:
* 1 - If message is added to the retry queue.
* 0 - If message is not added to the retry queue
*/
static int
iio_msg_done(struct qnio_msg *msg)
{
struct iio_device *device = (struct iio_device*)msg->reserved;
struct channel *channel = device->channel;
int retry = 0;
int do_failover = 0;
int error;
ck_spinlock_lock(&device->slock);
device->active_msg_count --;
error = msg->hinfo.err;
if (error == QNIOERROR_HUP) {
nioDbg("QNIOERROR_HUP received on msgid=%ld %p",msg->hinfo.cookie, msg);
switch (device->state) {
case IIO_DEVICE_ACTIVE:
device->state = IIO_DEVICE_QUIESCE;
/* Continue */
case IIO_DEVICE_QUIESCE:
case IIO_DEVICE_FAILOVER:
device->retry_msg_count ++;
device->active_msg_count ++;
channel->cd->chdrv_msg_resend_cleanup(msg);
LIST_ADD(&device->retryq, &msg->lnode);
retry = 1;
break;
case IIO_DEVICE_FAILED:
break;
default:
nioDbg("Unknown device state");
break;
}
} else if (error) {
nioDbg("message failed with error %d", error);
}
if (device->state == IIO_DEVICE_QUIESCE &&
device->active_msg_count == device->retry_msg_count) {
device->state = IIO_DEVICE_FAILOVER;
do_failover = 1;
}
ck_spinlock_unlock(&device->slock);
if (do_failover) {
iio_device_failover(device);
}
return retry;
}
static void
pool_buffer_destroy(struct pb_buffer *buf)
{
struct pool_buffer *pool_buf = pool_buffer(buf);
struct pool_pb_manager *pool = pool_buf->mgr;
assert(!pipe_is_referenced(&pool_buf->base.reference));
pipe_mutex_lock(pool->mutex);
LIST_ADD(&pool_buf->head, &pool->free);
pool->numFree++;
pipe_mutex_unlock(pool->mutex);
}
inline Node *Node_create(Node *parent, enum NodeType type)
{
Node *node = node_test_calloc();
assert_mem(node);
node->type = type;
// now just add the new node on to the current's children
if(parent) {
node->parent = parent;
LIST_ADD(Node, parent->child, node, sibling);
}
return node;
}
int usb_os_find_busses(struct usb_bus **busses)
{
struct usb_bus *fbus = NULL;
DIR *dir;
struct dirent *entry;
dir = opendir(usb_path);
if (!dir)
USB_ERROR_STR(-errno, "couldn't opendir(%s): %s", usb_path,
strerror(errno));
while ((entry = readdir(dir)) != NULL)
{
struct usb_bus *bus;
/* Skip anything starting with a . */
if (entry->d_name[0] == '.')
continue;
if (!strchr("0123456789", entry->d_name[strlen(entry->d_name) - 1]))
{
if (usb_debug >= 2)
fprintf(stderr, "usb_os_find_busses: Skipping non bus directory %s\n",
entry->d_name);
continue;
}
bus = malloc(sizeof(*bus));
if (!bus)
USB_ERROR(-ENOMEM);
memset((void *)bus, 0, sizeof(*bus));
strncpy(bus->dirname, entry->d_name, sizeof(bus->dirname) - 1);
bus->dirname[sizeof(bus->dirname) - 1] = 0;
LIST_ADD(fbus, bus);
if (usb_debug >= 2)
fprintf(stderr, "usb_os_find_busses: Found %s\n", bus->dirname);
}
closedir(dir);
*busses = fbus;
return 0;
}
/**
* Put a descriptor entry back by moving it from the use to the free list.
* @param desc descriptor
*/
static void unvme_put_desc(unvme_desc_t* desc)
{
unvme_queue_t* ioq = desc->ioq;
if (ioq->descnext == desc) {
if (desc != desc->next) ioq->descnext = desc->next;
else ioq->descnext = NULL;
}
LIST_DEL(ioq->desclist, desc);
memset(desc, 0, sizeof(unvme_desc_t) + ioq->ses->masksize);
desc->ioq = ioq;
LIST_ADD(ioq->descfree, desc);
ioq->desccount--;
}
status_t PortLookupFile(fsd_t *fsd, vnode_id_t node, uint32_t open_flags,
void **cookie)
{
port_fsd_t *pfsd;
port_t *server, *client;
port_waiter_t *waiter;
pipe_t *ends[2];
pfsd = (port_fsd_t*) fsd;
if (node == VNODE_ROOT)
return EACCESS;
server = (port_t*) node;
assert(server->is_server);
client = malloc(sizeof(port_t));
if (client == NULL)
goto error0;
waiter = malloc(sizeof(port_waiter_t));
if (waiter == NULL)
goto error1;
if (!FsCreatePipeInternal(ends))
goto error2;
memset(client, 0, sizeof(*client));
memset(waiter, 0, sizeof(*waiter));
client->is_server = false;
waiter->end_client = client->u.client = ends[0];
waiter->end_server = ends[1];
SpinAcquire(&server->u.server.sem);
LIST_ADD(server->u.server.waiter, waiter);
SpinRelease(&server->u.server.sem);
*cookie = client;
PortWakeBlockedAcceptors(server);
return 0;
error2:
free(waiter);
error1:
free(client);
error0:
return errno;
}
jobject vector_Ptr_Layer_to_List(JNIEnv* env, std::vector<cv::Ptr<cv::dnn::Layer> >& vs)
{
static jclass juArrayList = ARRAYLIST(env);
static jmethodID m_create = CONSTRUCTOR(env, juArrayList);
jmethodID m_add = LIST_ADD(env, juArrayList);
static jclass jLayerClass = LAYER(env);
static jmethodID m_create_layer = LAYER_CONSTRUCTOR(env, jLayerClass);
jobject result = env->NewObject(juArrayList, m_create, vs.size());
for (std::vector< cv::Ptr<cv::dnn::Layer> >::iterator it = vs.begin(); it != vs.end(); ++it) {
jobject element = env->NewObject(jLayerClass, m_create_layer, (*it).get());
env->CallBooleanMethod(result, m_add, element);
env->DeleteLocalRef(element);
}
return result;
}
static bool add_pawn_moves(list_t * list, const board_t * board, int to, bool legal, bool stop) {
int me;
int inc;
int pawn;
int from;
int piece;
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(SQUARE_IS_OK(to));
ASSERT(legal==true||legal==false);
ASSERT(stop==true||stop==false);
ASSERT(board->square[to]==Empty);
me = board->turn;
inc = PAWN_MOVE_INC(me);
pawn = PAWN_MAKE(me);
from = to - inc;
piece = board->square[from];
if (piece == pawn) { // single push
if (!legal || !is_pinned(board,from,me)) {
if (stop) return true;
add_pawn_move(list,from,to);
}
} else if (piece == Empty && PAWN_RANK(to,me) == Rank4) { // double push
from = to - (2*inc);
if (board->square[from] == pawn) {
if (!legal || !is_pinned(board,from,me)) {
if (stop) return true;
ASSERT(!SQUARE_IS_PROMOTE(to));
LIST_ADD(list,MOVE_MAKE(from,to));
}
}
}
return false;
}
static void DevCallLoader(load_request_t *load)
{
event_t *evt_done;
evt_done = EvtCreate(false);
load->evt_done = evt_done;
SemDown(mux_load);
LIST_ADD(load, load);
SemUp(mux_load);
wprintf(L"DevCallLoader: submitting request\n");
SemUp(sem_load);
ThrWaitHandle(current(), &evt_done->hdr);
KeYield();
HndClose(&evt_done->hdr);
}
static int find_devices(libusb_device **dev_list, int dev_list_len,
struct usb_bus *bus, struct usb_device **ret)
{
struct usb_device *devices = NULL;
struct usb_device *dev;
int i;
for (i = 0; i < dev_list_len; i++) {
libusb_device *newlib_dev = dev_list[i];
uint8_t bus_num = libusb_get_bus_number(newlib_dev);
if (bus_num != bus->location)
continue;
dev = malloc(sizeof(*dev));
if (!dev)
goto err;
/* No need to reference the device now, just take the pointer. We
* increase the reference count later if we keep the device. */
dev->dev = newlib_dev;
dev->bus = bus;
dev->devnum = libusb_get_device_address(newlib_dev);
sprintf(dev->filename, "%03d", dev->devnum);
LIST_ADD(devices, dev);
}
*ret = devices;
return 0;
err:
dev = devices;
while (dev) {
struct usb_device *tdev = dev->next;
free(dev);
dev = tdev;
}
return -ENOMEM;
}
static int32_t
iio_msg_submit(struct iio_device *device, struct qnio_msg *msg, uint32_t flags)
{
int32_t err;
int retry;
struct channel *channel;
nioDbg("iio_msg_submit: msg=%p, usr_ctx=%p, opcode=%d",
msg, msg->user_ctx, (int)msg->hinfo.opcode);
ck_spinlock_lock(&device->slock);
if (device->state == IIO_DEVICE_FAILED) {
ck_spinlock_unlock(&device->slock);
msg->hinfo.err = QNIOERROR_NOCONN;
errno = ENXIO;
return -1;
}
device->active_msg_count ++;
if (device->state == IIO_DEVICE_FAILOVER ||
device->state == IIO_DEVICE_QUIESCE) {
device->retry_msg_count ++;
LIST_ADD(&device->retryq, &msg->lnode);
ck_spinlock_unlock(&device->slock);
return 0;
}
ck_spinlock_unlock(&device->slock);
if(flags & IIO_FLAG_ASYNC) {
msg->hinfo.flags |= QNIO_FLAG_REQ;
} else {
msg->hinfo.flags |= QNIO_FLAG_SYNC_REQ;
}
msg->reserved = device;
channel = device->channel;
err = channel->cd->chdrv_msg_send(channel, msg);
if(err != 0) {
retry = iio_msg_done(msg);
if (retry) {
err = 0;
}
}
return err;
}
int usb_os_find_busses(struct usb_bus **busses)
{
struct usb_bus *fbus = NULL;
int controller;
int fd;
char buf[20];
for (controller = 0; controller < MAX_CONTROLLERS; controller++) {
struct usb_bus *bus;
snprintf(buf, sizeof(buf) - 1, "/dev/usb%d", controller);
fd = open(buf, O_RDWR);
if (fd < 0) {
if (usb_debug >= 2)
if (errno != ENXIO && errno != ENOENT)
fprintf(stderr, "usb_os_find_busses: can't open %s: %s\n",
buf, strerror(errno));
continue;
}
close(fd);
bus = malloc(sizeof(*bus));
if (!bus)
USB_ERROR(-ENOMEM);
memset((void *)bus, 0, sizeof(*bus));
strncpy(bus->dirname, buf, sizeof(bus->dirname) - 1);
bus->dirname[sizeof(bus->dirname) - 1] = 0;
LIST_ADD(fbus, bus);
if (usb_debug >= 2)
fprintf(stderr, "usb_os_find_busses: Found %s\n", bus->dirname);
}
*busses = fbus;
return 0;
}
