/* * Remove the top element, or object. */ int fr_heap_extract(fr_heap_t *hp, void *data) { int child, parent; int max; if (!hp || (hp->num_elements == 0)) return 0; max = hp->num_elements - 1; /* * Extract element. Default is the first one. */ if (!data) { parent = 0; } else { /* extract from the middle */ if (!hp->offset) return 0; parent = *((int *)(((uint8_t *)data) + hp->offset)); /* * Out of bounds. */ if (parent < 0 || parent >= hp->num_elements) return 0; } RESET_OFFSET(hp, parent); child = HEAP_LEFT(parent); while (child <= max) { /* * Maybe take the right child. */ if ((child != max) && (hp->cmp(hp->p[child + 1], hp->p[child]) < 0)) { child = child + 1; } hp->p[parent] = hp->p[child]; SET_OFFSET(hp, parent); parent = child; child = HEAP_LEFT(child); } hp->num_elements--; /* * We didn't end up at the last element in the heap. * This element has to be re-inserted. */ if (parent != max) { /* * Fill hole with last entry and bubble up, * reusing the insert code */ hp->p[parent] = hp->p[max]; return fr_heap_bubble(hp, parent); } return 1; }
static int aw_reset_assert(device_t dev, intptr_t id, bool reset) { struct aw_reset_softc *sc; uint32_t reg_value; sc = device_get_softc(dev); mtx_lock(&sc->mtx); reg_value = RESET_READ(sc, RESET_OFFSET(id)); if (reset) reg_value &= ~(1 << RESET_SHIFT(id)); else reg_value |= (1 << RESET_SHIFT(id)); RESET_WRITE(sc, RESET_OFFSET(id), reg_value); mtx_unlock(&sc->mtx); return (0); }
static int aw_reset_is_asserted(device_t dev, intptr_t id, bool *reset) { struct aw_reset_softc *sc; uint32_t reg_value; sc = device_get_softc(dev); mtx_lock(&sc->mtx); reg_value = RESET_READ(sc, RESET_OFFSET(id)); mtx_unlock(&sc->mtx); *reset = (reg_value & (1 << RESET_SHIFT(id))) != 0 ? false : true; return (0); }
/* * remove top element from heap, or obj if obj != NULL */ void heap_extract(struct dn_heap *h, void *obj) { int child, father, max = h->elements - 1; if (max < 0) { printf("--- %s: empty heap 0x%p\n", __FUNCTION__, h); return; } if (obj == NULL) father = 0; /* default: move up smallest child */ else { /* extract specific element, index is at offset */ if (h->ofs <= 0) panic("%s: extract from middle not set on %p\n", __FUNCTION__, h); father = *((int *)((char *)obj + h->ofs)); if (father < 0 || father >= h->elements) { panic("%s: father %d out of bound 0..%d\n", __FUNCTION__, father, h->elements); } } /* * below, father is the index of the empty element, which * we replace at each step with the smallest child until we * reach the bottom level. */ // XXX why removing RESET_OFFSET increases runtime by 10% ? RESET_OFFSET(h, father); while ( (child = HEAP_LEFT(father)) <= max ) { if (child != max && DN_KEY_LT(h->p[child+1].key, h->p[child].key) ) child++; /* take right child, otherwise left */ h->p[father] = h->p[child]; SET_OFFSET(h, father); father = child; } h->elements--; if (father != max) { /* * Fill hole with last entry and bubble up, * reusing the insert code */ h->p[father] = h->p[max]; heap_insert(h, father, NULL); } }
u8 phy_addr; u8 offset; } PHY_cfg; typedef struct { u8 link:1,speed:2,duplex:3,changed:1; u8 length; u32 rx_err; u32 link_time; } PHY; void print(char *str); static XGpio gpio; static PHY_cfg phyCfg[3]={ {MDC_OFFSET(0),MDIO_OFFSET(0),LINK_OFFSET(0),SPEED_OFFSET(0),DUPLEX_OFFSET(0),RESET_OFFSET(0),PHY0_PADDR}, {MDC_OFFSET(1),MDIO_OFFSET(1),LINK_OFFSET(1),SPEED_OFFSET(1),DUPLEX_OFFSET(1),RESET_OFFSET(1),PHY1_PADDR}, {MDC_OFFSET(2),MDIO_OFFSET(2),LINK_OFFSET(2),SPEED_OFFSET(2),DUPLEX_OFFSET(2),RESET_OFFSET(2),PHY2_PADDR}, }; static PHY phy[3]; static u8 decipher_key[8] = DECIPHER_KEY; void delay(u32 d) { while(d--); } void IO_SetDirection(u8 bit, u8 dir) { u32 mask;